address.cpp

Go to the documentation of this file.

#ifndef ADDRESS_IMPLEMENTATION_FILE
#define ADDRESS_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : network_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; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "address.h"
#include "imp_sockets.h"
#include "machine_uid.h"

#include <basis/byte_array.h>
#include <basis/function.h>
#include <basis/istring.h>
#include <basis/mutex.h>
#include <data_struct/configurator.h>
#include <data_struct/static_memory_gremlin.h>
#include <data_struct/string_table.h>
#include <textual/parser_bits.h>
#include <textual/tokenizer.h>

#include <stdio.h>
#include <string.h>

using namespace basis;

//#define DEBUG_ADDRESS
  // uncomment if you want a debugging version of address.


#undef LOG
#define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger(), to_print)


network_address::network_address()
: _type(UNINITIALIZED_ADDRESS),
  _addr(NIL)
{}

network_address::network_address(const network_address &to_copy)
: packable(),
  _type(to_copy._type),
  _addr(to_copy._addr? to_copy._addr->create_copy() : NIL)
{}

network_address::network_address(const internet_address &address)
: _type(INTERNET_ADDRESS),
  _addr(address.create_copy())
{}

#ifndef EMBEDDED_BUILD

network_address::network_address(const serial_port_address &address)
: _type(SERIAL_PORT_ADDRESS),
  _addr(address.create_copy())
{}

network_address::network_address(const ipc_address &address)
: _type(IPC_ADDRESS),
  _addr(address.create_copy())
{}

#endif

network_address::~network_address()
{
  _type = UNINITIALIZED_ADDRESS;
  WHACK(_addr);
}

network_address &network_address::operator =(const network_address &to_copy)
{
  if (this == &to_copy) return *this;
  WHACK(_addr);
  _type = to_copy._type;
  if (to_copy._addr)
    _addr = to_copy._addr->create_copy();
  return *this;
}

bool network_address::valid() const
{ return (_type > ADDRESS_SENTINEL_BEGIN) && (_type < ADDRESS_SENTINEL_END); }

internet_address *network_address::internet()
{ return dynamic_cast<internet_address *>(_addr); }

#ifndef EMBEDDED_BUILD
serial_port_address *network_address::serial()
{ return dynamic_cast<serial_port_address *>(_addr); }

ipc_address *network_address::ipc()
{ return dynamic_cast<ipc_address *>(_addr); }
#endif

const internet_address *network_address::internet() const
{ return dynamic_cast<const internet_address *>(_addr); }

#ifndef EMBEDDED_BUILD
const serial_port_address *network_address::serial() const
{ return dynamic_cast<const serial_port_address *>(_addr); }

const ipc_address *network_address::ipc() const
{ return dynamic_cast<const ipc_address *>(_addr); }
#endif

bool network_address::comparable(address_type a, address_type b) const
{
  return (a == b);
/*    || ( (a == MODEM_ADDRESS) && (b == SERIAL_PORT_ADDRESS) )
      || ( (b == MODEM_ADDRESS) && (a == SERIAL_PORT_ADDRESS) ); */
}

int network_address::packed_size() const
{
  if (!_addr) return 0;  // bogus.
  return _addr->packed_size();
}

bool network_address::same_host(const network_address &to_compare) const
{
  FUNCDEF("same_host");
  if (!comparable(address_type(_type), address_type(to_compare._type)))
    return false;
  if (!_addr) return true;  // uninitialized.
  return _addr->same_host(*to_compare._addr);
}

bool network_address::same_port(const network_address &to_compare) const
{
  FUNCDEF("same_port");
  if (!comparable(address_type(_type), address_type(to_compare._type)))
    return false;
  if (!_addr) return true;  // uninitialized.
  return _addr->same_port(*to_compare._addr);
}

bool network_address::shareable(const network_address &to_compare) const
{
  if (! operator == (to_compare)) return false;
    // if the addresses are not basically identical, then they're not shareable.

  if (!_addr) return false;  // uninitialized.
  return _addr->shareable(*to_compare._addr);
}

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

istring network_address::text_for_type(address_type type) 
{
  istring to_return;
  switch (type) {
    case UNINITIALIZED_ADDRESS: return "Uninitialized";
    case IPC_ADDRESS: return "IPC";
    case INTERNET_ADDRESS: return "TCP/IP";
    case SERIAL_PORT_ADDRESS: return "Serial_Port";
    default:
      return isprintf("unknown address type %d", type);
  }
}

#define APPROX(t) (t.lower()).substring(0, 2)

network_address::address_type network_address::type_from_text
  (const istring &text)
{
  if (APPROX(text) == APPROX(text_for_type(IPC_ADDRESS)))
    return IPC_ADDRESS;
  if (APPROX(text) == APPROX(text_for_type(INTERNET_ADDRESS)))
    return INTERNET_ADDRESS;
  if (APPROX(text) == APPROX(text_for_type(SERIAL_PORT_ADDRESS)))
    return SERIAL_PORT_ADDRESS;
  return UNINITIALIZED_ADDRESS;
}

istring network_address::text_form(bool show_type) const
{
  istring to_return;
  if (show_type) {
    istring type_to_print(text_for_type(type()));
    if (_addr) type_to_print += " ";
      // only add a space if we expect to have some contents.
    to_return += type_to_print;
  }
  if (_addr) to_return += _addr->text_form();
  return to_return;
}

istring network_address::unified_hostname() const
{
  istring to_return;
  if (type() == network_address::INTERNET_ADDRESS) {
    to_return = internet()->normalize_host();
  } else if (type() == network_address::IPC_ADDRESS) {
    to_return = "local";
  } else {
    to_return = "n/a";
  }
  return to_return;
}

istring network_address::tokenize() const
{
  istring to_return("type");
  to_return += TOKEN_ASSIGN();
  to_return += text_for_type(type());
  // add a separator if there is any tokenized data.
  if (_addr) {
    to_return += TOKEN_SEPARATOR();
    to_return += ' ';
    to_return += _addr->tokenize();
  }
  return to_return;
}

// fills in an address of the "addr_type" from the token list.
#define FILL(addr_type) { \
  addr_type *low = new addr_type; \
  worked = low->detokenize(info); \
  if (worked) _addr = low; \
  else WHACK(low); \
  break; \
}

bool network_address::detokenize(const istring &info)
{
  FUNCDEF("detokenize");
  // clear out existing stuff first.
  _type = UNINITIALIZED_ADDRESS;
  WHACK(_addr);

  int first_sep = info.find(TOKEN_SEPARATOR());
  if (negative(first_sep))
    first_sep = info.length();

  int first_assign = info.find(TOKEN_ASSIGN());
  if (negative(first_assign)) return false;  // no separator means it's bogus.

  // the positions of the "type" string and it's value have now been computed.
  // let's hope it's there.
  istring type_tag = info.substring(0, first_assign - 1);
  type_tag.strip_spaces();
  if (type_tag.lower() != istring("type")) return false;
    // wrong tag found first.

  istring type_name = info.substring(first_assign + 1, first_sep - 1);
  type_name.strip_spaces();

  bool worked = false;

  _type = type_from_text(type_name);
  switch (_type) {
    case UNINITIALIZED_ADDRESS: worked = true; break; 
    case INTERNET_ADDRESS: FILL(internet_address);
#ifndef EMBEDDED_BUILD
    case SERIAL_PORT_ADDRESS: FILL(serial_port_address);
    case IPC_ADDRESS: FILL(ipc_address);
#endif
    default: {
      LOG(isprintf("unknown type %d.", _type));
      break;
    }
  }
  return worked;
}

//hmmm: consider moving the functions for storage out to a helper file.

network_address network_address::load(configurator &config,
    const istring &section, const istring &name, const network_address &def)
{
  istring token_list;
  if (!config.get(section, name, token_list)) {
    // no entry stored means no address.  set the address to the default.
    config.put(section, name, def.tokenize());
    return def;
  }
  network_address to_return;
  // get the rest of the work done by detokenize.
  if (to_return.detokenize(token_list)) return to_return;
  // didn't work, dang it.  Note that we don't reject it here and store the
  // default.  that's because this indicates an error in formatting of the 
  // address, and we want the user to have a chance to correct that and try
  // again.
  return network_address();
}

bool network_address::store(configurator &config, const istring &section,
    const istring &name, const network_address &to_store)
{
  istring text = to_store.tokenize();
  return config.put(section, name, text);
}

void network_address::parse_pack(byte_array &packed_form) const
{ tokenize().pack(packed_form); }

bool network_address::parse_unpack(byte_array &packed_form)
{
  istring tokenized;
  if (!tokenized.unpack(packed_form)) return false;
  if (!detokenize(tokenized)) return false;
  return true;
}

machine_uid network_address::convert() const
{
  if (!_addr) return machine_uid();
  return _addr->convert(); 
}

void network_address::pack(byte_array &packed_form) const
{
  attach(packed_form, int(_type));
  if (_addr) _addr->pack(packed_form);
}

bool network_address::unpack(byte_array &packed_form)
{
  FUNCDEF("unpack");
  // trash current stuff.
  WHACK(_addr);
  _type = UNINITIALIZED_ADDRESS;
  int type;
  if (!detach(packed_form, type)) return false;
  _type = type;
  switch (_type) {
    case UNINITIALIZED_ADDRESS: return true;
    case INTERNET_ADDRESS: _addr = new internet_address(); break;
#ifndef EMBEDDED_BUILD
    case SERIAL_PORT_ADDRESS: _addr = new serial_port_address(); break;
    case IPC_ADDRESS: _addr = new ipc_address(); break;
#endif
    default: {
      LOG(isprintf("unknown type %d.", _type));
      return false;
    }
  }
  bool to_return = _addr->unpack(packed_form);
  if (!to_return) {
    _type = UNINITIALIZED_ADDRESS;
    WHACK(_addr);
  }
  return to_return;
}


// provides an easy way to cast to the proper type and provide a non-pointer
// to work with.
#define CAST_UP(type) \
  const type *temp = dynamic_cast<const type *>(&compare_in); \
  if (!temp) return false;  /* shouldn't happen but it means bad things. */ \
  const type &to_compare = *temp;


internet_address::internet_address() { fill(byte_array(), "", 0); }

internet_address::internet_address(const byte_array &ip,
    const istring &host, int port_in)
{ fill(ip, host, port_in); }

//hmmm: for ipv6, we will need a new object, called ipv6_address perhaps.
//      it will copy everything here but will have a longer address array.
//      we will need a new object for ipv6_machine_uid also.

machine_uid internet_address::convert() const
{ return internet_machine_uid(hostname, byte_array(ADDRESS_SIZE, ip_address)); }

bool internet_address::ip_appropriate_number(const istring &to_check, int indy,
    istring &accum)
{
  FUNCDEF("ip_appropriate_number");
  accum.reset();
  for (int i = indy; (i < indy + 3) && (i < to_check.length()); i++) {
    // make sure it looks like a good number.
    if (!parser_bits::is_numeric(to_check[i]) || (to_check[i] == '-') ) {
      // this one doesn't look good right here, but if we already got a digit,
      // we're okay.
      if (i == indy) return false;  // hadn't gotten any digits at all yet.
      else break;  // got one, so let's check our progress below.
    }
    accum += to_check[i];  // snag the current digit.
  }
  if (!accum.length()) return false;  // how would that happen?
  int convert = accum.convert(-1);
  return (convert >= 0) && (convert <= 255);
}

// needs to see 1-3 numbers, period, 1-3 numbers, period etc...
// for a total of three periods and 4 number sets.
bool internet_address::has_ip_address(const istring &to_check,
    istring &ip_found)
{
  FUNCDEF("has_ip_address");
  int nums_seen = 0;
  ip_found.reset();
  for (int i = 0; i < to_check.length(); i++) {
    bool hosed = false;
    istring num_found;
//    if (!!ip_found) LOG(istring("current ip found=") + ip_found);
    if (!ip_appropriate_number(to_check, i, num_found)) {
//      LOG(isprintf("no ip approp %d", i));
      hosed = true;
    } else {
      // we're seeing the number we want here.
//      LOG(istring("num found = ") + num_found);
      nums_seen++;
      if (nums_seen >= 4) {
        ip_found += num_found;  // get our last part.
        return true;  // hey, that's a match.
      }
      // look for a period now.
      int period_indy = to_check.find('.', i);
      if (negative(period_indy) || (period_indy > i + 3) ) hosed = true;
      else {
        for (int x = i; x < period_indy; x++) {
          if (!parser_bits::is_numeric(to_check[x]) || (to_check[x] == '-')) {
//            LOG(isprintf("hosed by bad char at %d -> %c", x, to_check[x]));
            hosed = true;  // wrong character seen in between.
          }
        }
        if (!hosed) {
          ip_found += to_check.substring(i, period_indy);
          i = period_indy;  // skip to where our next number should be.
        }
      }
    }
    if (hosed) {
      nums_seen = 0;
      ip_found.reset();
    }
  }
  return false;
}

const byte localhosts_bytes[] = { 127, 0, 0, 1 };
SAFE_STATIC_CONST(byte_array, internet_address::localhost,
    (ADDRESS_SIZE, localhosts_bytes))

bool internet_address::is_localhost() const
{
  // check whether the host is "local" or "localhost".
  istring host = hostname;
  host.to_lower();
  if ( (host == "local") || (host == "localhost") )
    return true;

  // check whether the address is local even if the hostname wasn't.
  for (int i = 0; i < ADDRESS_SIZE; i++) {
    if (ip_address[i] != localhost().get(i))
      return false;
  }

  return true;  // the address matched.
}

istring internet_address::normalize_host() const
{
  // try the hostname first.
  istring remote = hostname;
  if (remote.t()) return remote;
  // there was no host we can use; try the IP address instead.
  byte_array ip_form(ADDRESS_SIZE, ip_address);
  remote = ip_address_text_form(ip_form);
  return remote;  // they get whatever we had as the address.
}

int internet_address::packed_size() const
{
  return sizeof(port) +
      + sizeof(int) + ADDRESS_SIZE
      + sizeof(int) + MAXIMUM_HOSTNAME_LENGTH;
}

void internet_address::pack(byte_array &packed_form) const
{
  attach(packed_form, port);
  packed_form += byte_array(ADDRESS_SIZE, ip_address);
  packed_form += byte_array(MAXIMUM_HOSTNAME_LENGTH, (byte *)hostname);
}

bool internet_address::unpack(byte_array &packed_form)
{
  // check for minimum expected length.
  if (packed_form.length() < int(sizeof(port)) + ADDRESS_SIZE
      + MAXIMUM_HOSTNAME_LENGTH)
    return false;
  if (!detach(packed_form, port)) return false;
  packed_form.stuff(ADDRESS_SIZE, ip_address);
  packed_form.zap(0, ADDRESS_SIZE - 1);
  packed_form.stuff(MAXIMUM_HOSTNAME_LENGTH, (byte *)hostname);
  packed_form.zap(0, MAXIMUM_HOSTNAME_LENGTH - 1);
  return true;
}

void internet_address::fill(const byte_array &ip, const istring &host,
    int port_in)
{
  port = port_in;
  int mini = minimum(int(ADDRESS_SIZE), ip.length());
  for (int i = 0; i < mini; i++) ip_address[i] = ip[i];
  for (int j = mini; j < ADDRESS_SIZE; j++) ip_address[j] = 0;
  hostname[0] = '\0';
  host.stuff(hostname, MAXIMUM_HOSTNAME_LENGTH - 1);
}

address_base *internet_address::create_copy() const
{
  return new internet_address(byte_array(ADDRESS_SIZE, ip_address),
      hostname, port);
}

istring internet_address::text_form() const
{
  istring to_print("[");
  if (istring(hostname).t()) {
    to_print += "host=";
    to_print += hostname;
    to_print += ", ";
  }
    to_print += "ip_addr=";
    for (int i = 0; i < ADDRESS_SIZE; i++) {
      to_print += isprintf("%d", int(ip_address[i]));
      if (i != ADDRESS_SIZE - 1) to_print += ".";
    }
    to_print += ", ";
  to_print += isprintf("port=%u]", port);
  return to_print;
}

bool internet_address::is_nil_address(const address_array &ip_address)
{
  for (int i = 0; i < ADDRESS_SIZE; i++) if (ip_address[i]) return false;
  return true;
}

const byte nil_address_bytes[] = { 0, 0, 0, 0 };
SAFE_STATIC_CONST(byte_array, internet_address::nil_address,
    (ADDRESS_SIZE, nil_address_bytes))

bool internet_address::is_nil_address() const
{ return is_nil_address(ip_address); }

bool internet_address::same_host(const address_base &compare_in) const
{
  CAST_UP(internet_address);

  // they can't be the same if one is a valid address and the other's not, but
  // they are the same if both addresses are empty.
  // even so, they're not the same if either's name was non-empty but they're
  // both nil.
  if ( (is_nil_address(ip_address) && is_nil_address(to_compare.ip_address))
      && !istring(hostname) && !istring(to_compare.hostname) )
    return true;
  if ( (is_nil_address(ip_address) && is_nil_address(to_compare.ip_address))
      && (istring(hostname).iequals(to_compare.hostname)) )
    return true;
  if (is_nil_address(ip_address)) return false;
  if (is_nil_address(to_compare.ip_address)) return false;

  // check that the bytes don't differ for the IP address.
  for (int i = 0; i < ADDRESS_SIZE; i++)
    if (ip_address[i] != to_compare.ip_address[i])
      return false;  // we have a loser.

  // they could still be different addresses if the hostnames differ...

  if (istring(hostname).t() && istring(to_compare.hostname).t()) {
    // name comparison.
    if (istring(hostname).lower() != istring(to_compare.hostname).lower())
      return false;
  }

  return true;
    // all bytes and host were identical, so it's the same address.
}

bool internet_address::same_port(const address_base &compare_in) const
{
  CAST_UP(internet_address);
  return port == to_compare.port;
}

bool internet_address::shareable(const address_base &) const
{ return true; }

bool internet_address::detokenize(const istring &info)
{
  FUNCDEF("detokenize");
  LOADER_ENTRY;
  // either IP address or host must be specified.

  FIND("address", addr);
#ifdef DEBUG_ADDRESS
  LOG(istring("info is ") + info + istring('.'));
  LOG(istring("addr is ") + addr);
#endif
  byte_array ip_found;
  if (addr.t()) {
    // this bit rips off successive bytes from the string until the internet
    // address is filled out.  ignores any erroneous strings.
    for (int i = 0; i < ADDRESS_SIZE; i++) {
#ifdef DEBUG_ADDRESS
      LOG(istring("ip curr: ") + addr);
#endif
      int current_byte = addr.convert(int(0));
      ip_found += byte(current_byte);
#ifdef DEBUG_ADDRESS
      LOG(isprintf("%d: %02x ", i, current_byte));
#endif
      int indy = addr.find('.');
      addr.zap(0, indy);  // no error checking, but whatever.
    }
  }

  FIND("host", host);
  GRAB("port", port_t);  // this one's definitely needed.
  int port = port_t.convert(0);
  fill(ip_found, host, port);
#ifdef DEBUG_ADDRESS
  LOG(istring("tcp/ip address found::: ") + text_form());
#endif
  LOADER_EXIT;
  return true;
}

istring internet_address::tokenize() const
{
  FUNCDEF("tokenize");
  STORER_ENTRY;
#ifdef DEBUG_ADDRESS
  LOG(istring(isprintf("host eval is %d for %s",
      istring(hostname).t(), hostname));
#endif
  if (istring(hostname).t()) ADD("host", hostname);
  bool print_ip = false;
  for (int i = 0; i < ADDRESS_SIZE; i++) if (ip_address[i]) print_ip = true;
  if (print_ip) {
    istring ip_addr;
    for (int i = 0; i < ADDRESS_SIZE; i++)
      ip_addr += isprintf("%d", int(ip_address[i])) + istring(".");
    ip_addr.zap(ip_addr.end(), ip_addr.end());  // remove last period. 
    ADD("address", ip_addr);
  }
  ADD("port", isprintf("%d", int(port)));
#ifdef DEBUG_ADDRESS
  LOG(istring("your toke's currently ") + fred.text_form());
#endif
  DUMP_EXIT;
}

// by Gary Hardley.
// fixes by CAK 6/26/2002.
bool internet_address::is_valid_internet_address(const istring &to_check,
    byte_array &ip_form, bool &all_zeros)
{
  istring tmpstr = to_check;  // temporary copy of the given address string.
  all_zeros = true;  // default to true until proven otherwise.
  ip_form.reset();  // empty the address.

  // get the first part of the address.
  char *p = strtok(tmpstr.s(), ".");

  int index = 0;
  while (p && (index < ADDRESS_SIZE)) {
    int nTemp = istring(p).convert(-1);

    // is this part of the string a valid number between 0 & 255?
    if ( (nTemp < 0) || (nTemp > 255) ) return false;  // no.

    // yes, assign the number to the next address byte.
    ip_form += (byte)nTemp;

    // get the next part of the string
    p = strtok(NIL, ".");
  }

  // if p is non-null, there was extra stuff at the end, so return false.
  if (p) return false;

  for (int i = 0; i < ip_form.length(); i++)
    if (ip_form[i]) { all_zeros = false; break; }

  return ip_form.length() == ADDRESS_SIZE;
}

bool internet_address::valid_address(const istring &to_check)
{
  byte_array addr;
  bool all_zeros;
  return is_valid_internet_address(to_check, addr, all_zeros);
}

istring internet_address::ip_address_text_form(const byte_array &ip_address)
{
  return isprintf("%d.%d.%d.%d", int(ip_address[0]),
      int(ip_address[1]), int(ip_address[2]), int(ip_address[3]));
}

#ifndef EMBEDDED_BUILD


serial_port_address::serial_port_address() { fill(1, 9600, 8, 'N', 1); }

serial_port_address::serial_port_address(int port_in, int baud_rate_in,
    byte data_bits_in, char parity_in, byte stop_bits_in)
{ fill(port_in, baud_rate_in, data_bits_in, parity_in, stop_bits_in); }

address_base *serial_port_address::create_copy() const
{
  return new serial_port_address(port, baud_rate, data_bits, parity, stop_bits);
}

machine_uid serial_port_address::convert() const { return machine_uid(); }

istring serial_port_address::GET_DSR() { return "get_dsr"; }

istring serial_port_address::GET_CTS() { return "get_cts"; }

istring serial_port_address::SET_DTR() { return "set_dtr"; }

istring serial_port_address::SET_RTS() { return "set_rts"; }

istring serial_port_address::USE_MARK_SPACE() { return "mark_space"; }

istring serial_port_address::text_form() const
{
  return isprintf("[port %d, baud %d, data %d, parity %c, stop %d]",
      port, baud_rate, int(data_bits), parity, int(stop_bits));
}

bool serial_port_address::same_host(const address_base &) const
{ return true; }

bool serial_port_address::same_port(const address_base &compare_in) const
{
  CAST_UP(serial_port_address);
  return port == to_compare.port;
}

bool serial_port_address::shareable(const address_base &compare_in) const
{
  CAST_UP(serial_port_address);
  if (baud_rate != to_compare.baud_rate) return false;
  if (data_bits != to_compare.data_bits) return false;
  if (parity != to_compare.parity) return false;
  if (stop_bits != to_compare.stop_bits) return false;
  return true;
}

int serial_port_address::packed_size() const
{
  return sizeof(port) + sizeof(baud_rate) + sizeof(data_bits)
      + sizeof(stop_bits)
      + 1;  // one byte for parity.
}

void serial_port_address::pack(byte_array &packed_form) const
{
  attach(packed_form, port);
  attach(packed_form, baud_rate);
  attach(packed_form, data_bits);
  attach(packed_form, stop_bits);
  packed_form += byte_array(1, (byte *)&parity);
}

bool serial_port_address::unpack(byte_array &packed_form)
{
  if (u_int(packed_form.length()) < sizeof(port) + sizeof(baud_rate)
      + sizeof(data_bits) + sizeof(stop_bits) + 1)
    return false;
  if (!detach(packed_form, port)) return false;
  if (!detach(packed_form, baud_rate)) return false;
  if (!detach(packed_form, data_bits)) return false;
  if (!detach(packed_form, stop_bits)) return false;
  parity = packed_form[0];
  packed_form.zap(0, 0);
  return true;
}

void serial_port_address::fill(int port_in, int baud_rate_in,
    byte data_bits_in, char parity_in, byte stop_bits_in)
{
  port = port_in;
  baud_rate = baud_rate_in;
  data_bits = data_bits_in;
  // make sure the parity looks right.
  parity = (istring(parity_in, 1).upper())[0];
  stop_bits = stop_bits_in;
}

bool serial_port_address::detokenize(const istring &info)
{
  LOADER_ENTRY;
  GRAB("port", port);  // necessary.
  GRAB("baud", baud);  // necessary.
  FIND("parity", parity);  // optional.
  FIND("data", data);  // optional.
  FIND("stop", stop);  // optional.
  fill(port.convert(0), baud.convert(0), byte(data.convert(8)),
      parity[0], byte(stop.convert(1)));
  LOADER_EXIT;
  return true;
}

istring serial_port_address::tokenize() const
{
  STORER_ENTRY;
  ADD("port", isprintf("%d", int(port)));
  ADD("baud", isprintf("%d", baud_rate));
  ADD("parity", istring(parity, 1));
  ADD("data", isprintf("%d", int(data_bits)));
  ADD("stop", isprintf("%d", int(stop_bits)));
  DUMP_EXIT;
}


ipc_address::ipc_address() { fill("", ""); }

ipc_address::ipc_address(const istring &service, const istring &topic)
{ fill(service, topic); }

machine_uid ipc_address::convert() const { return machine_uid(); }

void ipc_address::fill(const istring &service_in, const istring &topic_in)
{
  service_in.stuff(service, MAXIMUM_IPC_NAME_LENGTH - 1);
  topic_in.stuff(topic, MAXIMUM_IPC_NAME_LENGTH - 1);
}

int ipc_address::packed_size() const
{
  return 2 * (sizeof(int) + MAXIMUM_IPC_NAME_LENGTH);
}

void ipc_address::pack(byte_array &packed_form) const
{
  packed_form += byte_array(MAXIMUM_IPC_NAME_LENGTH, (byte *)service);
  packed_form += byte_array(MAXIMUM_IPC_NAME_LENGTH, (byte *)topic);
}

bool ipc_address::unpack(byte_array &packed_form)
{