internet_address.h

Go to the documentation of this file.

#ifndef INTERNET_ADDRESS_CLASS
#define INTERNET_ADDRESS_CLASS

// Name   : internet_address
// Author : Chris Koeritz
// Copyright (c) 1995-$now By Author.  This program is free software; you can
// redistribute it and/or modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation:
//     http://www.gnu.org/licenses/gpl.html
// or under the terms of the GNU Library license:
//     http://www.gnu.org/licenses/lgpl.html
// at your preference.  Those licenses describe your legal rights to this
// software, and no other rights or warranties apply.
// Please send updates for this code to: fred@gruntose.com -- Thanks, fred.

#include "base_address.h"

#include <configuration/configurator.h>

namespace sockets {

// forward.
class machine_uid;


class internet_address : public base_address
{
public:
  enum internet_address_constraints {
    ADDRESS_SIZE = 4,
    MAXIMUM_HOSTNAME_LENGTH = 128
  };

  typedef basis::abyte address_array[ADDRESS_SIZE];
  address_array ip_address;
  int port;

  char hostname[MAXIMUM_HOSTNAME_LENGTH];
    // can be resolved to an ip_address if a domain name server
    // is available.

  internet_address();
  internet_address(const basis::byte_array &ip_address, const basis::astring &host,
          int port);

  DEFINE_CLASS_NAME("internet_address");

  machine_uid convert() const;
    // returns the address in the uniquifying format.

  void fill(const basis::byte_array &ip_address, const basis::astring &host, int port);

  bool same_host(const base_address &to_compare) const;
  bool same_port(const base_address &to_compare) const;
  bool shareable(const base_address &to_compare) const;

  bool operator == (const internet_address &to_compare) const {
    return same_host(to_compare) && same_port(to_compare);
  }

  basis::astring text_form() const;

  basis::astring tokenize() const;
  bool detokenize(const basis::astring &info);

  basis::astring normalize_host() const;
    // returns a normal form for the hostname or address.  this will come from
    // the hostname member first, if it's set.  next it will come from the
    // string form of the IP address.

  static const basis::byte_array &nil_address();
    // returns the address that is all zeros, otherwise known as INADDR_ANY.

  bool is_nil_address() const;
    // returns true if this object's address_array is all zeros.

  static bool is_nil_address(const address_array &ip_address);
    // returns true if the array "ip_address" is all zero.

  static bool appropriate_for_ip(const basis::astring &to_check);
    // tests whether the string is possibly an ip address; it must have no
    // characters in it besides dots and numbers.

  static bool valid_address(const basis::astring &to_check);
    // returns true if the address "to_check" seems well-formed for IP.  note
    // that this will accept 0.0.0.0 as valid.

  static bool is_valid_internet_address(const basis::astring &to_check,
          basis::byte_array &ip_form, bool &all_zeros);
    // this function checks the string "to_check" to see if it is a valid
    // internet address (e.g., 143.203.39.222).  if it is a valid address,
    // then the address "ip_form" is filled in with four bytes that are each
    // in the range (0..255).  if the "ip_form" is 0.0.0.0, then all_zeros
    // is set to true.

  static bool ip_appropriate_number(const basis::astring &to_check, int indy,
          basis::astring &accum);

  static bool has_ip_address(const basis::astring &to_check, basis::astring &ip_found);

  static basis::astring ip_address_text_form(const basis::byte_array &ip_address);
    // returns a string containing the textual form of the "ip_address".  the
    // "ip_address" is expected to have the proper length (four bytes).  if it
    // does not, then an empty string is returned.

  static const basis::byte_array &localhost();
    // provides the array that indicates localhost, rather than a NIC.
    // this is commonly known to be 127.0.0.1.

  bool is_localhost() const;
    // returns true if the address in question is the same as the localhost,
    // either through the name matching "local" or "localhost", or through
    // the address matching 127.0.0.1.  note that the word "local" here is
    // an "enhancement" and would not normally be considered the same as
    // localhost.  beware a networked computer that's actually named "local".
    // also note that an address where the name disagrees with the address is
    // basically broken, but we are not checking that here; either condition
    // of the hostname or the address matching causes this to return true.

  base_address *create_copy() const;

  void pack(basis::byte_array &packed_form) const;
  bool unpack(basis::byte_array &packed_form);

  virtual int packed_size() const;
};

} //namespace.

#endif