netbyte.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:14k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "hxcom.h"
  36. #include "hlxclib/ctype.h"
  37. #include "safestring.h"
  38. #include "netbyte.h"
  39. #include "hxtypes.h"
  40. #include "ihxpckts.h"
  41. #include "hxbuffer.h"
  42. #ifdef _MACINTOSH
  43. #include "hxstrutl.h" // for isascii definition
  44. #endif
  45. #include "hxheap.h"
  46. #ifdef _DEBUG
  47. #undef HX_THIS_FILE
  48. static const char HX_THIS_FILE[] = __FILE__;
  49. #endif
  50. #ifndef INADDR_NONE
  51. #define INADDR_NONE -1
  52. #endif
  53. #if defined(HELIX_CONFIG_NOSTATICS)
  54. # include "globals/hxglobals.h"
  55. #endif
  56. #if defined(HELIX_CONFIG_NOSTATICS)
  57. # define STATIC_CHAR_ARRAY(name, length) 
  58.     static const char _##name = ''; 
  59.     char*& str = (char*&)HXGlobalCharArray::Get(&_##name, length, "" );
  60. #else    
  61. # define STATIC_CHAR_ARRAY(name, length) static char name[length];
  62. #endif /* HELIX_CONFIG_NOSTATICS */
  63. #ifndef NET_ENDIAN
  64. NetWord WToNet(HostWord wHost) {
  65. /* Hopefully, a portable implementation
  66. ** (although it's unnecessary labor on a
  67. ** non-swapped machine) 
  68. */
  69. NetWord wNet;
  70. unsigned char *uc = (unsigned char *)&wNet;
  71. *uc++ = (unsigned char) ((wHost & 0xFF00) >> 8);
  72. *uc++ = (unsigned char) (wHost & 0x00FF);
  73. return wNet;
  74. HostWord WToHost(NetWord wNet) {
  75. HostWord wHost;
  76. unsigned char *uc = (unsigned char *)&wNet;
  77. wHost = (*uc++) << 8;
  78. wHost += (*uc++);
  79. return wHost;
  80. }
  81. NetDWord DwToNet(HostDWord dwHost) {
  82. NetDWord dwNet;
  83. unsigned char *uc = (unsigned char *)&dwNet;
  84. *uc++ = (unsigned char) ((dwHost & 0xFF000000L) >> 24);
  85. *uc++ = (unsigned char) ((dwHost & 0x00FF0000L) >> 16);
  86. *uc++ = (unsigned char) ((dwHost & 0x0000FF00L) >> 8);
  87. *uc++ = (unsigned char) (dwHost & 0x000000FFL);
  88. return dwNet;
  89. HostDWord DwToHost(NetDWord dwNet) {
  90. HostDWord dwHost;
  91. unsigned char *uc = (unsigned char *)&dwNet;
  92. dwHost = ((unsigned long)(*uc++)) << 24;
  93. dwHost += ((unsigned long)(*uc++)) << 16;
  94. dwHost += ((unsigned long)(*uc++)) << 8;
  95. dwHost += (unsigned long)(*uc++);
  96. return dwHost;
  97. }
  98. #endif
  99. int 
  100. TestBigEndian(void)
  101. {
  102.     unsigned long test = 0x000000FF;
  103.     char *temp = (char *)&test;
  104.     /* on big endian machines, the first byte should be 0x00, on little endian 0xFF.*/
  105.     return (temp[0] == 0);
  106. }
  107. /*  Converts 2 byte ints from big endian to little endian or vice versa */
  108. void 
  109. SwapWordBytes(HostWord *data, int numInts)
  110. {
  111.     INT32     i;
  112.     INT16  temp;
  113.     char    *temp1, *temp2;
  114.     /* temp2 points to our temporary int that will hold the swapped bytes */
  115.     temp2 = (char *) &temp;
  116.     for(i = 0; i < numInts; i++)
  117.     {
  118. temp1 = (char *) &data[i];
  119.         temp2[0] = temp1[1];
  120. temp2[1] = temp1[0];
  121. data[i] = temp;
  122.     }
  123. }
  124. /*  Converts 4 byte ints from big endian to little endian or vice versa */
  125. void 
  126. SwapDWordBytes(HostDWord *data, int numInts)
  127. {
  128.     INT32     i,temp;
  129.     char    *temp1, *temp2;
  130.     /* temp2 points to our temporary int that will hold the swapped bytes */
  131.     temp2 = (char *) &temp;
  132.     for(i = 0; i < numInts; i++)
  133.     {
  134. temp1 = (char *) &data[i];
  135.         temp2[0] = temp1[3];
  136.         temp2[1] = temp1[2];
  137.         temp2[2] = temp1[1];
  138. temp2[3] = temp1[0];
  139. data[i] = temp;
  140.     }
  141. }
  142. /*
  143.  * IP domain addresses will NOT be recignized as valid addresses
  144.  * even if they are specified as "99.99.234" or "99.234"
  145.  */
  146. int
  147. IsNumericAddr(const char* addrStr, UINT32 size)
  148. {
  149.     // check the params
  150.     if (NULL == addrStr || 0 == size)
  151.     {
  152. return 0;
  153.     }
  154.     
  155.     const char* ptr = (addrStr && size) ? addrStr+size-1 : 0;
  156.     int len = (int)size;
  157.     int numericAddr = 0;
  158.     int dotCount = 0;
  159.     if (isdigit(*ptr))
  160.         numericAddr = 1;
  161.     while (--len)
  162.     {
  163.         if (*ptr == '.')
  164.             dotCount++;
  165.         else if (isalpha(*ptr))
  166.             numericAddr = 0;
  167.         --ptr;
  168.     }
  169.     return (dotCount == 3) ? numericAddr : 0;
  170. }
  171. void
  172. NetLongToAscii(UINT32 addr, IHXBuffer* pAddrBuf)
  173. {
  174.     char str[16]; /* Flawfinder: ignore */  // max addr string length + NULL -- "255.255.255.255"
  175.     char* ptr = (char *)str;
  176.     char* prevStrEnd = 0;
  177.     SafeSprintf(ptr, sizeof(str), "%lu", ((addr&0xff000000) >> 24));
  178.     ptr = (char *)memchr(str, 0, 16);
  179.     prevStrEnd = ptr;
  180.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%lu", ((addr&0x00ff0000) >> 16));
  181.     ptr = (char *)memchr(prevStrEnd, 0, 16);
  182.     prevStrEnd = ptr;
  183.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%lu", ((addr&0x0000ff00) >> 8));
  184.     ptr = (char *)memchr(prevStrEnd, 0, 16);
  185.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%lu", (addr&0x000000ff));
  186.     pAddrBuf->Set((BYTE *)str, strlen(str)+1);
  187. }
  188. // takes the addr in HOST-byte order!!!
  189. // its too late in the cycle to make this fundamental a change
  190. // so we r keeping it the same
  191. char*
  192. HXInetNtoa(UINT32 addr)
  193. {
  194.     STATIC_CHAR_ARRAY(str, 16); /* Flawfinder: ignore */ // max addr string length + NULL -- "255.255.255.255"
  195.     char* ptr = (char *)str;
  196.     char* prevStrEnd = 0;
  197.     SafeSprintf(ptr, sizeof(str), "%lu", ((addr&0xff000000) >> 24));
  198.     ptr = (char *)memchr(str, 0, 16);
  199.     prevStrEnd = ptr;
  200.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%lu", ((addr&0x00ff0000) >> 16));
  201.     ptr = (char *)memchr(prevStrEnd, 0, 16);
  202.     prevStrEnd = ptr;
  203.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%lu", ((addr&0x0000ff00) >> 8));
  204.     ptr = (char *)memchr(prevStrEnd, 0, 16);
  205.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%lu", (addr&0x000000ff));
  206.     return str;
  207. }
  208. /*
  209. * ++Copyright++ 1983, 1990, 1993
  210. * -
  211. * Copyright (c) 1983, 1990, 1993
  212. *    The Regents of the University of California.  All rights reserved.
  213. * Redistribution and use in source and binary forms, with or without
  214. * modification, are permitted provided that the following conditions
  215. * are met:
  216. * 1. Redistributions of source code must retain the above copyright
  217. *    notice, this list of conditions and the following disclaimer.
  218. * 2. Redistributions in binary form must reproduce the above copyright
  219. *    notice, this list of conditions and the following disclaimer in the
  220. *    documentation and/or other materials provided with the distribution.
  221. * 3. All advertising materials mentioning features or use of this software
  222. *    must display the following acknowledgement:
  223. * This product includes software developed by the University of
  224. * California, Berkeley and its contributors.
  225. * 4. Neither the name of the University nor the names of its contributors
  226. *    may be used to endorse or promote products derived from this software
  227. *    without specific prior written permission.
  228. * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  229. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  230. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  231. * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  232. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  233. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  234. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  235. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  236. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  237. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  238. * SUCH DAMAGE.
  239. * -
  240. * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  241. * Permission to use, copy, modify, and distribute this software for any
  242. * purpose with or without fee is hereby granted, provided that the above
  243. * copyright notice and this permission notice appear in all copies, and that
  244. * the name of Digital Equipment Corporation not be used in advertising or
  245. * publicity pertaining to distribution of the document or software without
  246. * specific, written prior permission.
  247. * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  248. * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  249. * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  250. * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  251. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  252. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  253. * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  254. * SOFTWARE.
  255. * -
  256. * --Copyright--
  257. */
  258. /*
  259. * Ascii internet address interpretation routine.
  260. * The value returned is in network order.
  261. * Check whether "cp" is a valid ascii representation
  262. * of an Internet address and convert to a binary address.
  263. * Returns 1 if the address is valid, 0 if not.
  264. * This replaces inet_addr, the return value from which
  265. * cannot distinguish between failure and a local broadcast address.
  266. */
  267. UINT32
  268. HXinet_addr(const char* cp)
  269. {
  270.     UINT32 val = 0;
  271.     int base = 0, n = 0;
  272.     char c;
  273.     UINT parts[4];
  274.     UINT *pp = parts;
  275.     c = *cp;
  276.     for (;;) 
  277.     {
  278. /*
  279. * Collect number up to ``.''.
  280. * Values are specified as for C:
  281. * 0x=hex, 0=octal, isdigit=decimal.
  282. */
  283. if (!isdigit(c))
  284.     return (INADDR_NONE);
  285. val = 0; base = 10;
  286. if (c == '0') 
  287. {
  288.     c = *++cp;
  289.     if (c == 'x' || c == 'X')
  290.     {
  291. base = 16, c = *++cp;
  292.     }
  293.     else
  294.     {
  295. base = 8;
  296.     }
  297. }
  298. for (;;) 
  299. {
  300.     if (isascii(c) && isdigit(c)) 
  301.     {
  302. val = (val * base) + (c - '0');
  303. c = *++cp;
  304.     } 
  305.     else if (base == 16 && isascii(c) && isxdigit(c)) 
  306.     {
  307. val = (val << 4) | (c + 10 - (islower(c) ? 'a' : 'A'));
  308. c = *++cp;
  309.     } 
  310.     else
  311.     {
  312. break;
  313.     }
  314. }
  315. if (c == '.') 
  316. {
  317.     /*
  318.     * Internet format:
  319.     * a.b.c.d
  320.     * a.b.c (with c treated as 16 bits)
  321.     * a.b (with b treated as 24 bits)
  322.     */
  323.     if (pp >= parts + 3)
  324.     {
  325. return (INADDR_NONE);
  326.     }
  327.     *pp++ = val;
  328.     c = *++cp;
  329. else
  330. {
  331.     break;
  332. }
  333.     }
  334.     /*
  335.     * Check for trailing characters.
  336.     */
  337.     if (c != '' && (!isascii(c) || !isspace(c)))
  338.     {
  339. return (INADDR_NONE);
  340.     }
  341.     /*
  342.     * Concoct the address according to
  343.     * the number of parts specified.
  344.     */
  345.     n = pp - parts + 1;
  346.     switch (n) 
  347.     {
  348. case 0:
  349.     return (INADDR_NONE); /* initial nondigit */
  350. case 1: /* a -- 32 bits */
  351.     break;
  352. case 2: /* a.b -- 8.24 bits */
  353.     if (val > 0xffffff)
  354. return (INADDR_NONE);
  355.     val |= parts[0] << 24;
  356.     break;
  357. case 3: /* a.b.c -- 8.8.16 bits */
  358.     if (val > 0xffff)
  359. return (INADDR_NONE);
  360.     val |= (parts[0] << 24) | (parts[1] << 16);
  361.     break;
  362. case 4: /* a.b.c.d -- 8.8.8.8 bits */
  363.     if (val > 0xff)
  364. return (INADDR_NONE);
  365.     val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
  366.     break;
  367.     }
  368.     return DwToNet(val);
  369. }
  370. // to store actual netbyte order of bytes in a string
  371. // on a little endian machine basically swap the bytes
  372. char*
  373. NetLongAddrToDecimalStr(ULONG32 ulAddr)
  374. {
  375.     STATIC_CHAR_ARRAY(str, 11);/* Flawfinder: ignore */ // max decimal digits (4 Gig) for a 4-byte number
  376.     unsigned long test = 0x000000FF;
  377.     char *temp = (char *)&test;
  378.     if (temp[0] != 0x0) // big-endian
  379.     {
  380. ULONG32 addr = 0;
  381. char* temp1 = (char *)&addr;
  382. temp = (char *)&ulAddr;
  383. temp1[0] = temp[3];
  384. temp1[1] = temp[2];
  385. temp1[2] = temp[1];
  386. temp1[3] = temp[0];
  387. SafeSprintf(str, sizeof(str), "%lu", (unsigned long)addr);
  388.     }
  389.     else
  390.     {
  391. SafeSprintf(str, sizeof(str), "%lu", (unsigned long)ulAddr);
  392.     }
  393.     return str;
  394. }
  395. char*
  396. NetLongToAsciiStr(UINT32 addr)
  397. {
  398.     STATIC_CHAR_ARRAY(str, 16);/* Flawfinder: ignore */ // max addr string length + NULL -- "255.255.255.255"
  399.     UCHAR* tmp = (UCHAR *)&addr;
  400.     char* ptr = (char *)str;
  401.     char* prevStrEnd = 0;
  402.     SafeSprintf(ptr, sizeof(str), "%u", tmp[0]);
  403.     ptr = (char *)memchr(str, 0, 16);
  404.     prevStrEnd = ptr;
  405.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%u", tmp[1]);
  406.     ptr = (char *)memchr(str, 0, 16);
  407.     prevStrEnd = ptr;
  408.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%u", tmp[2]);
  409.     ptr = (char *)memchr(str, 0, 16);
  410.     prevStrEnd = ptr;
  411.     SafeSprintf(ptr, sizeof(str)-(ptr-str), ".%u", tmp[3]);
  412.     return str;
  413. }