开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
SWIipAddress.cpp
资源名称：openvxi-3.4.zip　[点击查看]
上传用户：xqtpzdz
上传日期：2022-05-21
资源大小：1764k
文件大小：15k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

SWIipAddress.cpp：源码内容
  2. /****************License************************************************
  3.  * Vocalocity OpenVXI
  4.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *  
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  19.  * registered trademarks of Vocalocity, Inc. 
  20.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  21.  * by Vocalocity.
  22.  ***********************************************************************/
  24. #include <string.h>
  25. #include "SWIipAddress.hpp"
  27. #ifdef _WIN32
  28. #include <winsock2.h>
  29. #else
  30. #include <netinet/in.h>
  31. #include <netdb.h>
  32. #include <arpa/inet.h>
  33. #include <stdlib.h>
  34. #include <errno.h>
  35. #include <unistd.h>
  36. #endif
  38. #if defined(WIN32) || defined(_decunix_)
  39. /* These OSes are thread safe by using thread local storage for the hostent */
  40. static int my_gethostbyaddr_r (const char * addr, socklen_t len,
  41.        int type,
  42.        struct hostent * result_buf,
  43.        char * buf, size_t buflen,
  44.        struct hostent ** result,
  45.        int * h_errnop) {
  46.   *result = gethostbyaddr(addr, len, type);
  47.   return (result ? 0 : -1);
  48. }
  50. static int my_gethostbyname_r (const char * name,
  51.        struct hostent * result_buf,
  52.        char * buf, size_t buflen,
  53.        struct hostent ** result,
  54.        int * h_errnop) {
  55.   *result = gethostbyname(name);
  56.   return (result ? 0 : -1);
  57. }
  58. #elif defined(_solaris_)
  59. static int my_gethostbyaddr_r (const char * addr, socklen_t len,
  60.        int type,
  61.        struct hostent * result_buf,
  62.        char * buf, size_t buflen,
  63.        struct hostent ** result,
  64.        int * h_errnop) {
  65.   *result = gethostbyaddr_r(addr, len, type, result_buf, buf, buflen,
  66.     h_errnop);
  67.   return (result ? 0 : -1);
  68. }
  70. static int my_gethostbyname_r (const char * name,
  71.        struct hostent * result_buf,
  72.        char * buf, size_t buflen,
  73.        struct hostent ** result,
  74.        int * h_errnop) {
  75.   *result = gethostbyname_r(name, result_buf, buf, buflen, h_errnop);
  76.   return (result ? 0 : -1);
  77. }
  78. #else
  79. /* Linux, maybe others */
  80. #define my_gethostbyaddr_r gethostbyaddr_r
  81. #define my_gethostbyname_r gethostbyname_r
  82. #endif
  84. #ifdef _WIN32
  85. // Class used for static initialization of mutex or WSA layer.
  86. class SWIipAddressInit
  87. {
  88.  public:
  89.   SWIipAddressInit();
  90.   ~SWIipAddressInit();
  91. };
  93. SWIipAddressInit::SWIipAddressInit()
  94. {
  95.   WSADATA wsaData;
  96.   WSAStartup(MAKEWORD(2, 2), &wsaData);
  97. }
  99. SWIipAddressInit::~SWIipAddressInit()
  100. {
  101.   WSACleanup();
  102. }
  104. static SWIipAddressInit G_netInit;
  106. #endif
  108. #define SOCK_ERROR(classname, msg) 
  109. do { 
  110.   if (_logger) 
  111.   { 
  112.     if (errno) 
  113.       _logger->Error(500, L"%s%S%s%S%s%S%s%d", L"class", classname, L"msg", msg, 
  114.   L"errnoStr", strerror(errno), L"errno", errno); 
  115.     else 
  116.       _logger->Error(500, L"%s%S%s%S", L"class", classname, L"msg", msg); 
  117.   } 
  118. } while(0)
  121. SWIipAddress::SWIipAddress(const SWIipAddress &sina)
  122. {
  123.   _logger         = sina._logger;
  124.   sin_family      = sina.sin_family;
  125.   sin_addr.s_addr = sina.sin_addr.s_addr;
  126.   sin_port   = sina.sin_port;
  127. }
  129. SWIipAddress::SWIipAddress(SWIutilLogger *logger)
  130. {
  131.   _logger =       logger;
  132.   sin_family   = AF_INET;
  133.   sin_addr.s_addr = htonl(INADDR_ANY);
  134.   sin_port   = 0;
  135. }
  137. SWIipAddress::SWIipAddress(unsigned long addr,
  138.    int port_no,
  139.                            SWIutilLogger *logger)
  140. {
  141. // addr and port_no are in host byte order
  142.   _logger         = logger;
  143.   sin_family      = AF_INET;
  144.   sin_addr.s_addr = htonl(addr);
  145.   sin_port   = htons(port_no);
  146. }
  148. SWIipAddress::SWIipAddress(unsigned long addr,
  149.    const char* sn,
  150.                            const char* pn,
  151.                            SWIutilLogger *logger)
  152. {
  153.   // addr is in host byte order
  154.   _logger         = logger;
  155.   sin_family      = AF_INET;
  156.   sin_addr.s_addr = htonl (addr);
  157.   setport(sn, pn);
  158. }
  160. SWIipAddress::SWIipAddress(const char* host_name,
  161.                            int port_no,
  162.                            SWIutilLogger *logger)
  163. {
  164. // port_no is in host byte order
  165.   _logger = logger;
  166.   sethostname(host_name);
  167.   sin_port = htons(port_no);
  168. }
  170. SWIipAddress::SWIipAddress(const char* hn,
  171.    const char* sn,
  172.                            const char* pn,
  173.                            SWIutilLogger *logger)
  174. {
  175.   _logger = logger;
  176.   sethostname(hn);
  177.   setport(sn, pn);
  178. }
  180. void SWIipAddress::setport(int port_no)
  181. {
  182.   sin_port = htons(port_no);
  183. }
  185. int SWIipAddress::setport(const char* sn, const char* pn)
  186. {
  187.   servent* sp = getservbyname(sn, pn);
  188.   if (sp == 0)
  189.   {
  190.     SOCK_ERROR("SWIipAddress", "invalid service name");
  191.     return -1;
  192.   }
  193.   sin_port = sp->s_port;
  194.   return 0;
  195. }
  197. int SWIipAddress::getport() const
  198. {
  199.   return ntohs (sin_port);
  200. }
  202. int SWIipAddress::sethostname(const char* host_name)
  203. {
  204.   if ( (sin_addr.s_addr = inet_addr(host_name)) == (in_addr_t) -1) {
  205.     int hostErrno;
  206.     struct hostent hostResult;
  207.     char hostBuffer[4096];
  208.     hostent* hp;
  209.     if ((my_gethostbyname_r(host_name, &hostResult, hostBuffer,
  210.     2048, &hp, &hostErrno) != 0) ||
  211. (hp == 0))
  212.     {
  213.       return -1;
  214.     }
  215.     memcpy(&sin_addr, hp->h_addr, hp->h_length);
  216.     sin_family = hp->h_addrtype;
  217.   }
  218.   else
  219.     sin_family = AF_INET;
  220.   return 0;
  221. }
  223. int SWIipAddress::gethostname(char *hostname, size_t hostnameLen) const
  224. {
  225.   hostname[0] = '';
  227.   if (sin_addr.s_addr == htonl(INADDR_ANY)) {
  228.     if (::gethostname(hostname, hostnameLen) == -1) {
  229.       SOCK_ERROR("SWIipAddress", "gethostname");
  230.       hostname[0] = '';
  231.       return -1;
  232.     }
  233.     return 0;
  234.   }
  236.   int hostErrno;
  237.   struct hostent hostResult;
  238.   char hostBuffer[4096];
  239.   hostent* hp;
  240.   if ((my_gethostbyaddr_r((const char*) &sin_addr, sizeof(sin_addr),
  241.   family(), &hostResult, hostBuffer, 2048, &hp,
  242.   &hostErrno) != 0) ||
  243.       (hp == 0))
  244.   {
  245.     SWIipAddress::herror("gethostbyaddr");
  246.     return -1;
  247.   }
  248.   if ((hp->h_name) && (strlen(hp->h_name) < hostnameLen)) {
  249.     strcpy (hostname, hp->h_name);
  250.     return 0;
  251.   }
  252.   return -1;
  253. }
  256. unsigned int SWIipAddress::hashCode() const
  257. {
  258.   unsigned int h = (unsigned int) ntohl(sin_addr.s_addr);
  259.   h <<= 16;
  260.   h |= ntohs(sin_port) & 0xFF;
  261.   return h;
  262. }
  264. bool SWIipAddress::operator==(const SWIipAddress& rhs) const
  265. {
  266.   if (this == &rhs) return true;
  268.   return sin_addr.s_addr == rhs.sin_addr.s_addr &&
  269.     sin_port == rhs.sin_port;
  270. }
  272. SWIHashable *SWIipAddress::clone() const
  273. {
  274.   return new SWIipAddress(*this);
  275. }
  277. bool SWIipAddress::equals(const SWIHashable *rhs) const
  278. {
  279.   return operator==(*((const SWIipAddress *) rhs));
  280. }
  282. #ifdef _WIN32
  284. static char* errmsg[] = {
  285.   "No error",
  286.   "Host not found",
  287.   "Try again",
  288.   "No recovery",
  289.   "No address"
  290.   "Unknown error"
  291. };
  293. /* Winsock.h maps h_errno to WSAGetLastError() function call */
  294. void SWIipAddress::herror(const char* em) const
  295. {
  296.   int err;
  297.   switch(h_errno) { /* calls WSAGetLastError() */
  298.    case HOST_NOT_FOUND:
  299.      err = 1;
  300.      break;
  301.    case TRY_AGAIN:
  302.      err = 2;
  303.      break;
  304.    case NO_RECOVERY:
  305.      err = 3;
  306.      break;
  307.    case NO_ADDRESS:
  308.      err = 4;
  309.      break;
  310.    default:
  311.      err = 5;
  312.      break;
  313.   }
  315.   SOCK_ERROR(em, errmsg[err]);
  316. }
  318. #else // !_WIN32
  320. /* Use the native UNIX call */
  321. void SWIipAddress::herror(const char* em) const
  322. {
  323. #ifdef _decunix_
  324.   if (_logger)
  325.   {
  326.     if (errno)
  327.       Error(500, L"%s%S%s%d%s%S%s%d", L"class", em, L"h_errno", h_errno,
  328.             L"errnoStr", strerror(errno), L"errno", errno);
  329.     else
  330.       Error(500, L"%s%S%s%d", L"class", em, L"h_errno", h_errno);
  331.   }
  332. #else
  333.   SOCK_ERROR(em, hstrerror(h_errno));
  334. #endif
  335. }
  337. #endif // !_WIN32
  339. #if 0
  340. SWIipAddress::SWIipAddress (int port)
  341.    : ipAddressSet(false)
  342. {
  343.   char *localHost = "localhost";
  344.   sethostname(localHost); // assuming it is localhost first
  345.   aPort = port;
  346. }
  349. SWIipAddress::SWIipAddress ( const char * hostName, int port)
  350.   : ipAddressSet(false)
  351. {
  352.   setport(port);
  353.   setHostName(hostName);
  354. }
  357. int SWIipAddress::setHostName ( const char * theAddress)
  358. {
  359.   //
  360.   // Look for semicolon which means the port address is appended
  361.   //
  362.   int colonPos = -1;
  364.   const char * cstrAddress = theAddress;
  366.   while (*cstrAddress)
  367.   {
  368.     if (*cstrAddress == ':')
  369.     {
  370.       colonPos = cstrAddress - theAddress;
  371.       break;
  372.     }
  373.     cstrAddress++;
  374.   }
  376.   //
  377.   // Found the port address so get it
  378.   //
  379.   if (colonPos != -1)
  380.   {
  381.     aPort = atoi(theAddress + (colonPos + 1));
  383.     if (aPort)
  384.     {
  385.       strncpy(rawHostName, theAddress, colonPos - 1);
  386.       rawHostName[colonPos] = '';
  387.     }
  388.     else
  389.     {
  390.       return -1;
  391.     }
  393.   }
  394.   else // No ':' in input string;
  395.   {
  396.     strcpy(rawHostName,theAddress);
  397.   }
  399.   ipAddressSet = false;
  400.   return 0;
  401. }
  404. void SWIipAddress::setport( int iPort )
  405. {
  406.     ipAddressSet = false;
  407.     aPort = iPort;
  408. }
  411. char * SWIipAddress::getHostName( ) const
  412. {
  413.   char * hostName;
  414.   struct hostent * pxHostEnt = NULL;
  416.   initIpAddress();
  418.   if ((my_gethostbyaddr_r(
  419.   {
  421.   }
  422.   LOCK();
  424.   pxHostEnt = gethostbyaddr(ipAddress, IPV4_LENGTH, AF_INET);
  426.   if (pxHostEnt)
  427.   {
  428.     hostName = pxHostEnt->h_name;
  429.     UNLOCK();
  430.   }
  431.   else
  432.   {
  433.     UNLOCK();
  434.     hostName = getIpName();
  435.   }
  437.   return hostName;
  438. }
  441. char * SWIipAddress::getIpName () const
  442. {
  443.     char * ipName;
  444.     struct in_addr temp;
  446.     initIpAddress();
  448.     memcpy((void *)&temp.s_addr, ipAddress, IPV4_LENGTH);
  450.     LOCK();
  452.     // $$$ This returns a pointer to a static char[]
  453.     ipName = inet_ntoa(temp);
  455.     UNLOCK();
  457.     return ipName;
  458. }
  461. unsigned int SWIipAddress::getIp4Address () const
  462. {
  463.     unsigned lTmp;
  465.     initIpAddress();
  467.     memcpy((void *) &lTmp, ipAddress, IPV4_LENGTH);
  469.     return lTmp;
  470. }
  473. void SWIipAddress::getSockAddr (struct sockaddr & socka) const
  474. {
  475.     short tmp_s = htons (aPort);
  476.     char * tmp_p;
  478.     tmp_p = (char*) &tmp_s;
  479.     socka.sa_family = AF_INET;
  480.     socka.sa_data[0] = tmp_p[0];
  481.     socka.sa_data[1] = tmp_p[1];
  482.     initIpAddress();
  483.     memcpy((void *)&socka.sa_data[2], ipAddress, IPV4_LENGTH);
  485.     return ;
  486. }
  489. int SWIipAddress::getPort () const
  490. {
  491.     return aPort;
  492. }
  495. bool operator < ( const SWIipAddress & xAddress, const SWIipAddress & yAddress )
  496. {
  497.     xAddress.initIpAddress();
  498.     yAddress.initIpAddress();
  499.     for (int i = 0 ; i <= IPV4_LENGTH; i++ )
  500.     {
  501.         if ( xAddress.ipAddress[i] < yAddress.ipAddress[i])
  502.         {
  503.             return true;
  504.         }
  505.         if ( xAddress.ipAddress[i] > yAddress.ipAddress[i])
  506.         {
  507.             return false;
  508.         }
  509.     }
  510.     return xAddress.aPort < yAddress.aPort ;
  511. }
  514. bool operator == ( const SWIipAddress & xAddress, const SWIipAddress & yAddress )
  515. {
  516.     xAddress.initIpAddress();
  517.     yAddress.initIpAddress();
  518.     for (int i = 0 ; i < IPV4_LENGTH ; i++ )
  519.     {
  520.         if ( xAddress.ipAddress[i] != yAddress.ipAddress[i])
  521.         {
  522.             return false;
  523.         }
  524.     }
  525.     return xAddress.aPort == yAddress.aPort ;
  526. }
  529. bool operator != ( const SWIipAddress & xAddress, const SWIipAddress & yAddress )
  530. {
  531.     return !(xAddress == yAddress);
  532. }
  535. SWIipAddress & SWIipAddress::operator=( const SWIipAddress& x )
  536. {
  537.     this->aPort = x.aPort;
  538.     memcpy( this->ipAddress, x.ipAddress, sizeof(this->ipAddress) );
  539.     ipAddressSet = x.ipAddressSet;
  541.     memcpy(this->rawHostName, x.rawHostName, sizeof(this->rawHostName));
  542.     // xraf rawHostName = x.rawHostName;
  543.     //   strncpy( this->ipAddress, x.ipAddress, IPV4_LENGTH );
  544.     return ( *this );
  545. }
  548. unsigned int SWIipAddress::hashIpPort( )
  549. {
  550.     unsigned int ipAddressLocal = getIp4Address ();
  551.     int port = getPort ();
  552.     return (hashIpPort( ipAddressLocal, port )) ;
  553. }
  556. unsigned int SWIipAddress::hashIpPort( const char * theAddress, const char * port )
  557. {
  558.     SWIipAddress net;
  560.     net.setHostName ( theAddress );
  561.     net.setport ( atoi(port) );
  563.     return ( net.hashIpPort() );
  564. }
  567. unsigned int SWIipAddress::hashIpPort( const unsigned int ipAddress, const int port )
  568. {
  569.     unsigned int hashKey = 0x0;
  570.     hashKey = (ipAddress << 16) | (port & 0xFF);
  572.     return hashKey;
  573. }
  575. int SWIipAddress::initIpAddress() const
  576. {
  577.   int status = 0;
  579.   if (!ipAddressSet)
  580.   {
  581.     if (is_valid_ip_addr(rawHostName) )
  582.     {
  583.       ipAddressSet = true;
  584.     }
  585.     else
  586.     {
  587.       LOCK();
  588.       struct hostent * pxHostEnt = 0;
  589.       pxHostEnt = gethostbyname(rawHostName);
  591.       if (pxHostEnt)
  592.       {
  593.         memcpy((void *)&ipAddress,
  594.                (void *)pxHostEnt->h_addr,
  595.                pxHostEnt->h_length);
  596.         ipAddressSet = true;
  597.       }
  598.       else
  599.       {
  600.         status = -1;
  601.       }
  603.       UNLOCK();
  604.     }
  605.   }
  606.   return status;
  607. }
  610. /**
  611.   * Return TRUE if the address is a valid IP address (dot-decimal form)
  612.   * such as 128.128.128.128. Checks for invalid or ill formed addresses
  613.   * If the address is valid, copy it into ipAddress
  614.   */
  615. bool SWIipAddress::is_valid_ip_addr(const char * addr) const
  616. {
  618.     unsigned long maskcheck = ~255; // mask to check if 'tween 0 and 255
  619.     const char *advancer = addr;
  620.     unsigned long octet;
  621.     char *nextchar;
  623.     // always check for spaces and right number
  624.     // first and last fields must be 1-255, middle two 0-255
  626.     if ((*(advancer) == 0) || (*(advancer) == ' ') || (*(advancer) == 't'))
  627.     {
  628.         return false;
  629.     }
  630.     octet = strtoul(advancer, &nextchar, 10);
  631.     if((*nextchar != '.') || (octet & maskcheck) || (octet == 0))
  632.     {
  633.         return false;
  634.     }
  635.     ipAddress[0] = (char) octet;
  638.     advancer = nextchar+1;
  639.     if ((*(advancer) == 0) || (*(advancer) == ' ') || (*(advancer) == 't'))
  640.     {
  641.         return false;
  642.     }
  643.     octet = strtoul(advancer, &nextchar, 10);
  644.     if((*nextchar != '.') || (octet & maskcheck))
  645.     {
  646.         return false;
  647.     }
  648.     ipAddress[1] = (char) octet;
  651.     advancer = nextchar+1;
  652.     if ((*(advancer) == 0) || (*(advancer) == ' ') || (*(advancer) == 't'))
  653.     {
  654.         return false;
  655.     }
  656.     octet = strtoul(advancer, &nextchar, 10);
  657.     if((*nextchar != '.') || (octet & maskcheck))
  658.     {
  659.         return false;
  660.     }
  661.     ipAddress[2] = (char) octet;
  664.     advancer = nextchar+1;
  665.     if ((*(advancer) == 0) || (*(advancer) == ' ') || (*(advancer) == 't'))
  666.     {
  667.         return false;
  668.     }
  669.     octet = strtoul(advancer, &nextchar, 10);
  670.     if((*nextchar) || (octet & maskcheck) || (octet == 0))
  671.     {
  672.         return false;
  673.     }
  674.     ipAddress[3] = (char) octet;
  676.     return true;
  678. }
  679. #endif
  680. // End of File