swiipaddress.cpp

openvxi3.4是一个voicexml对话脚本语言的解释器源码.可用VC６.０编译．

{
  char *localHost = "localhost";
  sethostname(localHost); // assuming it is localhost first
  aPort = port;
}


SWIipAddress::SWIipAddress ( const char * hostName, int port)
  : ipAddressSet(false)
{
  setport(port);
  setHostName(hostName);
}


int SWIipAddress::setHostName ( const char * theAddress)
{
  //
  // Look for semicolon which means the port address is appended
  //
  int colonPos = -1;

  const char * cstrAddress = theAddress;

  while (*cstrAddress)
  {
    if (*cstrAddress == ':')
    {
      colonPos = cstrAddress - theAddress;
      break;
    }
    cstrAddress++;
  }

  //
  // Found the port address so get it
  //
  if (colonPos != -1)
  {
    aPort = atoi(theAddress + (colonPos + 1));

    if (aPort)
    {
      strncpy(rawHostName, theAddress, colonPos - 1);
      rawHostName[colonPos] = '\0';
    }
    else
    {
      return -1;
    }

  }
  else // No ':' in input string;
  {
    strcpy(rawHostName,theAddress);
  }

  ipAddressSet = false;
  return 0;
}


void SWIipAddress::setport( int iPort )
{
    ipAddressSet = false;
    aPort = iPort;
}


char * SWIipAddress::getHostName( ) const
{
  char * hostName;
  struct hostent * pxHostEnt = NULL;

  initIpAddress();

  if ((my_gethostbyaddr_r(
  {

  }
  LOCK();

  pxHostEnt = gethostbyaddr(ipAddress, IPV4_LENGTH, AF_INET);

  if (pxHostEnt)
  {
    hostName = pxHostEnt->h_name;
    UNLOCK();
  }
  else
  {
    UNLOCK();
    hostName = getIpName();
  }

  return hostName;
}


char * SWIipAddress::getIpName () const
{
    char * ipName;
    struct in_addr temp;

    initIpAddress();

    memcpy((void *)&temp.s_addr, ipAddress, IPV4_LENGTH);

    LOCK();

    // $$$ This returns a pointer to a static char[]
    ipName = inet_ntoa(temp);

    UNLOCK();

    return ipName;
}


unsigned int SWIipAddress::getIp4Address () const
{
    unsigned lTmp;

    initIpAddress();

    memcpy((void *) &lTmp, ipAddress, IPV4_LENGTH);

    return lTmp;
}


void SWIipAddress::getSockAddr (struct sockaddr & socka) const
{
    short tmp_s = htons (aPort);
    char * tmp_p;

    tmp_p = (char*) &tmp_s;
    socka.sa_family = AF_INET;
    socka.sa_data[0] = tmp_p[0];
    socka.sa_data[1] = tmp_p[1];
    initIpAddress();
    memcpy((void *)&socka.sa_data[2], ipAddress, IPV4_LENGTH);

    return ;
}


int SWIipAddress::getPort () const
{
    return aPort;
}


bool operator < ( const SWIipAddress & xAddress, const SWIipAddress & yAddress )
{
    xAddress.initIpAddress();
    yAddress.initIpAddress();
    for (int i = 0 ; i <= IPV4_LENGTH; i++ )
    {
        if ( xAddress.ipAddress[i] < yAddress.ipAddress[i])
        {
            return true;
        }
        if ( xAddress.ipAddress[i] > yAddress.ipAddress[i])
        {
            return false;
        }
    }
    return xAddress.aPort < yAddress.aPort ;
}


bool operator == ( const SWIipAddress & xAddress, const SWIipAddress & yAddress )
{
    xAddress.initIpAddress();
    yAddress.initIpAddress();
    for (int i = 0 ; i < IPV4_LENGTH ; i++ )
    {
        if ( xAddress.ipAddress[i] != yAddress.ipAddress[i])
        {
            return false;
        }
    }
    return xAddress.aPort == yAddress.aPort ;
}


bool operator != ( const SWIipAddress & xAddress, const SWIipAddress & yAddress )
{
    return !(xAddress == yAddress);
}


SWIipAddress & SWIipAddress::operator=( const SWIipAddress& x )
{
    this->aPort = x.aPort;
    memcpy( this->ipAddress, x.ipAddress, sizeof(this->ipAddress) );
    ipAddressSet = x.ipAddressSet;

    memcpy(this->rawHostName, x.rawHostName, sizeof(this->rawHostName));
    // xraf rawHostName = x.rawHostName;
    //   strncpy( this->ipAddress, x.ipAddress, IPV4_LENGTH );
    return ( *this );
}


unsigned int SWIipAddress::hashIpPort( )
{
    unsigned int ipAddressLocal = getIp4Address ();
    int port = getPort ();
    return (hashIpPort( ipAddressLocal, port )) ;
}


unsigned int SWIipAddress::hashIpPort( const char * theAddress, const char * port )
{
    SWIipAddress net;

    net.setHostName ( theAddress );
    net.setport ( atoi(port) );

    return ( net.hashIpPort() );
}


unsigned int SWIipAddress::hashIpPort( const unsigned int ipAddress, const int port )
{
    unsigned int hashKey = 0x0;
    hashKey = (ipAddress << 16) | (port & 0xFF);

    return hashKey;
}

int SWIipAddress::initIpAddress() const
{
  int status = 0;

  if (!ipAddressSet)
  {
    if (is_valid_ip_addr(rawHostName) )
    {
      ipAddressSet = true;
    }
    else
    {
      LOCK();
      struct hostent * pxHostEnt = 0;
      pxHostEnt = gethostbyname(rawHostName);

      if (pxHostEnt)
      {
        memcpy((void *)&ipAddress,
               (void *)pxHostEnt->h_addr,
               pxHostEnt->h_length);
        ipAddressSet = true;
      }
      else
      {
        status = -1;
      }

      UNLOCK();
    }
  }
  return status;
}


/**
  * Return TRUE if the address is a valid IP address (dot-decimal form)
  * such as 128.128.128.128. Checks for invalid or ill formed addresses
  * If the address is valid, copy it into ipAddress
  */
bool SWIipAddress::is_valid_ip_addr(const char * addr) const
{

    unsigned long maskcheck = ~255; // mask to check if 'tween 0 and 255
    const char *advancer = addr;
    unsigned long octet;
    char *nextchar;

    // always check for spaces and right number
    // first and last fields must be 1-255, middle two 0-255

    if ((*(advancer) == 0) || (*(advancer) == ' ') || (*(advancer) == '\t'))
    {
        return false;
    }
    octet = strtoul(advancer, &nextchar, 10);
    if((*nextchar != '.') || (octet & maskcheck) || (octet == 0))
    {
        return false;
    }
    ipAddress[0] = (char) octet;


    advancer = nextchar+1;
    if ((*(advancer) == 0) || (*(advancer) == ' ') || (*(advancer) == '\t'))
    {
        return false;
    }
    octet = strtoul(advancer, &nextchar, 10);
    if((*nextchar != '.') || (octet & maskcheck))
    {
        return false;
    }
    ipAddress[1] = (char) octet;


    advancer = nextchar+1;
    if ((*(advancer) == 0) || (*(advancer) == ' ') || (*(advancer) == '\t'))
    {
        return false;
    }
    octet = strtoul(advancer, &nextchar, 10);
    if((*nextchar != '.') || (octet & maskcheck))
    {
        return false;
    }
    ipAddress[2] = (char) octet;


    advancer = nextchar+1;
    if ((*(advancer) == 0) || (*(advancer) == ' ') || (*(advancer) == '\t'))
    {
        return false;
    }
    octet = strtoul(advancer, &nextchar, 10);
    if((*nextchar) || (octet & maskcheck) || (octet == 0))
    {
        return false;
    }
    ipAddress[3] = (char) octet;

    return true;

}
#endif
// End of File