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