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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rtsputil.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：18k
源码类别：

Symbian

开发平台：

C/C++

rtsputil.cpp：源码内容
  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 ***** */ 
  36. #include "hxtypes.h"
  37. #include "hxstring.h"
  38. #include "dbcs.h"
  39. #include "rtsputil.h"
  40. #include "safestring.h"
  42. #include "hxheap.h"
  43. #ifdef _DEBUG
  44. #undef HX_THIS_FILE
  45. static const char HX_THIS_FILE[] = __FILE__;
  46. #endif
  49. /*
  50.  * Table for encoding base64
  51.  */
  52. static const char Base64[] =
  53.    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  55. /*
  56.  * Table for encoding URL-safe base64
  57.  */
  58. static const char URLBase64[] =
  59.    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!*";
  61. #define XX 127
  62. /*
  63.  * Table for decoding base64
  64.  */
  65. static const char Index64[256] = { /* Flawfinder: ignore */
  66.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  67.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  68.     XX,62,XX,XX, XX,XX,XX,XX, XX,XX,63,62, XX,XX,XX,63,
  69.     52,53,54,55, 56,57,58,59, 60,61,XX,XX, XX,XX,XX,XX,
  70.     XX, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  71.     15,16,17,18, 19,20,21,22, 23,24,25,XX, XX,XX,XX,XX,
  72.     XX,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  73.     41,42,43,44, 45,46,47,48, 49,50,51,XX, XX,XX,XX,XX,
  74.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  75.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  76.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  77.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  78.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  79.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  80.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  81.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX
  82. };
  83. #define CHAR64(c)  (Index64[(unsigned char)(c)])
  85. static void 
  86. Output64Chunk(int c1, int c2, int c3, int pads, char* pBuf,
  87.     INT32 bufOffset)
  88. {
  89.     pBuf[bufOffset++] = Base64[c1>>2];
  90.     pBuf[bufOffset++] = Base64[((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)];
  91.     if (pads == 2) 
  92.     {
  93.         pBuf[bufOffset++] = '=';
  94.         pBuf[bufOffset++] = '=';
  95.     }
  96.     else if (pads) 
  97.     {
  98.         pBuf[bufOffset++] = Base64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  99.         pBuf[bufOffset++] = '=';
  100.     } 
  101.     else 
  102.     {
  103.         pBuf[bufOffset++] = Base64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  104.         pBuf[bufOffset++] = Base64[c3 & 0x3F];
  105.     }
  106. }
  108. static void 
  109. OutputURL64Chunk(int c1, int c2, int c3, int pads, char* pBuf,
  110.     INT32 bufOffset)
  111. {
  112.     pBuf[bufOffset++] = URLBase64[c1>>2];
  113.     pBuf[bufOffset++] = URLBase64[((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)];
  114.     if (pads == 2) 
  115.     {
  116.         pBuf[bufOffset++] = '=';
  117.         pBuf[bufOffset++] = '=';
  118.     }
  119.     else if (pads) 
  120.     {
  121.         pBuf[bufOffset++] = URLBase64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  122.         pBuf[bufOffset++] = '=';
  123.     } 
  124.     else 
  125.     {
  126.         pBuf[bufOffset++] = URLBase64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  127.         pBuf[bufOffset++] = URLBase64[c3 & 0x3F];
  128.     }
  129. }
  131. INT32 
  132. BinTo64(const BYTE* pInBuf, INT32 len, char* pOutBuf)
  133. {
  134.     int c1, c2, c3;
  135.     //INT32 ct = 0;
  136.     //INT32 written = 0;
  137.     INT32 inOffset = 0;
  138.     INT32 outOffset = 0;
  140.     while(inOffset < len)
  141.     {
  142. c1 = pInBuf[inOffset++];
  143. if(inOffset == len)
  144. {
  145.     Output64Chunk(c1, 0, 0, 2, pOutBuf, outOffset);
  146.     outOffset += 4;
  147. }
  148. else
  149. {
  150.     c2 = pInBuf[inOffset++];
  151.     if(inOffset == len)
  152.     {
  153. Output64Chunk(c1, c2, 0, 1, pOutBuf, outOffset);
  154. outOffset += 4;
  155.     }
  156.     else
  157.     {
  158. c3 = pInBuf[inOffset++];
  159. Output64Chunk(c1, c2, c3, 0, pOutBuf, outOffset);
  160. outOffset += 4;
  161.     }
  162. }
  163. #if XXXBAB
  164. ct += 4;
  165. if(ct > 44) // EOL after 45 chars
  166. {
  167.     pOutBuf[outOffset++] = 'n';
  168.     written += 46;
  169.     ct = 0;
  170. }
  171. #endif
  172.     }
  173. #if XXXBAB
  174.     if(ct)
  175.     {
  176. pOutBuf[outOffset++] = 'n';
  177. ct++;
  178.     }
  179. #endif
  180.     pOutBuf[outOffset++] = '';
  181.     return outOffset;
  182. }
  184. INT32 
  185. BinToURL64(const BYTE* pInBuf, INT32 len, char* pOutBuf)
  186. {
  187.     int c1, c2, c3;
  188.     INT32 inOffset = 0;
  189.     INT32 outOffset = 0;
  191.     while(inOffset < len)
  192.     {
  193. c1 = pInBuf[inOffset++];
  194. if(inOffset == len)
  195. {
  196.     OutputURL64Chunk(c1, 0, 0, 2, pOutBuf, outOffset);
  197.     outOffset += 4;
  198. }
  199. else
  200. {
  201.     c2 = pInBuf[inOffset++];
  202.     if(inOffset == len)
  203.     {
  204. OutputURL64Chunk(c1, c2, 0, 1, pOutBuf, outOffset);
  205. outOffset += 4;
  206.     }
  207.     else
  208.     {
  209. c3 = pInBuf[inOffset++];
  210. OutputURL64Chunk(c1, c2, c3, 0, pOutBuf, outOffset);
  211. outOffset += 4;
  212.     }
  213. }
  214.     }
  215.     pOutBuf[outOffset++] = '';
  216.     return outOffset;
  217. }
  219. INT32
  220. BinFrom64(const char* pInBuf, INT32 len, BYTE* pOutBuf)
  221. {
  222.     int c1, c2, c3, c4;
  223.     INT32 offset = 0;
  224.     INT32 outOffset = 0;
  226.     while(offset < len)
  227.     {
  228. c1 = pInBuf[offset++];
  229. if(c1 != '=' && CHAR64(c1) == XX)
  230. {
  231.     continue;
  232. }
  233. else if (offset == len)
  234. {
  235.     /* BAD data */
  236.     return -1;
  237. }
  238. do
  239. {
  240.     c2 = pInBuf[offset++];
  241. } 
  242. while(offset < len && c2 != '=' && CHAR64(c2) == XX);
  243. if (offset == len)
  244. {
  245.     /* BAD data */
  246.     return -1;
  247. }
  248.         do
  249. {
  250.     c3 = pInBuf[offset++];
  251. }
  252. while(offset < len && c3 != '=' && CHAR64(c3) == XX);
  253. if (offset == len)
  254. {
  255.     /* BAD data */
  256.     return -1;
  257. }
  258. do
  259. {
  260.     c4 = pInBuf[offset++];
  261. }
  262. while(offset < len && c4 != '=' && CHAR64(c4) == XX);
  263. if (offset == len && c4 != '=' && CHAR64(c4) == XX)
  264. {
  265.     /* BAD data */
  266.     return -1;
  267. }
  268. if(c1 == '=' || c2 == '=')
  269. {
  270.     continue;
  271. }
  272. c1 = CHAR64(c1);
  273. c2 = CHAR64(c2);
  274. pOutBuf[outOffset++]  = ((c1 << 2) | ((c2 & 0x30) >> 4));
  275. if(c3 == '=')
  276. {
  277.     continue;
  278. }
  279. else
  280. {
  281.     c3 = CHAR64(c3);
  282.     pOutBuf[outOffset++]  = (((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2));
  283.     if(c4 == '=')
  284.     {
  285. continue;
  286.     }
  287.     else
  288.     {
  289. c4 = CHAR64(c4);
  290. pOutBuf[outOffset++] = (((c3 & 0x03) << 6) | c4);
  291.     }
  292. }
  293.     }
  295.     return outOffset;
  296. }
  298. const char*
  299. EncodeCString(const char* pStr)
  300. {
  301.     CHXString tmp;
  303.     for(size_t i=0;i<strlen(pStr);++i)
  304.     {
  305.         switch(pStr[i])
  306.         {
  307.             case 'n':
  308.             {
  309.                 tmp += "\n";
  310.             }
  311.             break;
  313.             case 't':
  314.             {
  315.                 tmp += "\t";
  316.             }
  317.             break;
  319.             case 'r':
  320.             {
  321.                 tmp += "\r";
  322.             }
  323.             break;
  325.             case '"':
  326.             {
  327.                 tmp += "\"";
  328.             }
  329.             break;
  331.             case '\':
  332.             {
  333.                 tmp += "\\";
  334.             }
  335.             break;
  337.             default:
  338.             {
  339.                 tmp += pStr[i];
  340.             }
  341.         }
  342.     }
  343.     return tmp;
  344. }
  347. #ifdef XXXBAB
  349. void
  350. printbuf(unsigned char* pBuf, int len)
  351. {
  352.     for(int i=0; i<len; i++)
  353.     {
  354. printf("%02x ", pBuf[i]);
  355.     }
  356.     printf("n");
  357. }
  359. static unsigned char testBytes[] =
  360.     { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 
  361.       0x4f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  362.       0x00, 0x00, 0x00, 0x00, 0x75, 0x76, 0x77, 0x78,
  363.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  364.       0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xb3, 0x5f, 0x78,
  365.       0x4f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  366.       0x00, 0x00, 0x00, 0x00, 0x75, 0x76, 0x77, 0x78,
  367.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  368.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  369.       0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xb3, 0x5f, 0x78,
  370.       0x4f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  371.       0x00, 0x00, 0x00, 0x00, 0x75, 0x76, 0x77, 0x78,
  372.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  373.       0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xb3, 0x5f, 0x78,
  374.       0x4f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  375.       0x00, 0x00, 0x00, 0x00, 0x75, 0x76, 0x77, 0x78,
  376.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  377.       0x77, 0x88, 0x00 };
  379. static unsigned char testBytes2[] =
  380.     { 0x7F, 0x63, 0x31, 0xBB, 0x90, 0x21, 0x32, 0x11,
  381.       0xC4 };
  382. void main()
  383. {
  384.     unsigned char encodeBuf[300]; /* Flawfinder: ignore */
  385.     unsigned char decodeBuf[300]; /* Flawfinder: ignore */
  387.     memset(encodeBuf, '', sizeof(encodeBuf));
  388.     memset(decodeBuf, '', sizeof(decodeBuf));
  390.     int rc = BinTo64(testBytes, sizeof(testBytes), encodeBuf);
  391.     printf("original size: %d, encoded size: %dn", sizeof(testBytes), rc);
  392.     printf("%sn", encodeBuf);
  393.     rc = BinFrom64(encodeBuf, rc, decodeBuf);
  394.     printf("decode size: %dn", rc);
  395.     printbuf(decodeBuf, rc);
  396. }
  398. #endif /* XXXBAB */
  401. const char escapeChars[] =
  402. {       
  403.     0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  404.     1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,0,1,0,0,
  405.     0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  406.     1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  407.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  408.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  409.     0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
  410.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  411.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  412.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  413.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  414.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  415.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  416. };
  418. /*
  419.  * Function: URLEscapeBuffer
  420.  */
  421. INT32 
  422. URLEscapeBuffer(const char* pInBuf, INT32 len, char* pOutBuf)
  423. {
  424.     const char* pInputPos = pInBuf;
  425.     char* pOutputPos = pOutBuf;
  426.     char pTemp[3]; /* Flawfinder: ignore */
  427.     
  428.     if (!pInBuf || !len || !pOutBuf)
  429.     {
  430. return -1;
  431.     }
  433.     // Iterate through the input buffer
  434.     while (pInputPos < pInBuf + len)
  435.     {
  436. BOOL bIsIllegal = FALSE;
  438. if (HXIsDBCSEnabled())
  439. {
  440.     // If an illegal URL character is found, translate it
  441.     bIsIllegal = 
  442.         HXIsEqual(pInputPos, 0x7f) ||
  443.      HXIsEqual(pInputPos, '%')  ||
  444.      HXIsEqual(pInputPos, '"')  ||
  445.      HXIsEqual(pInputPos, '+')  ||
  446.      HXIsEqual(pInputPos, '<')  ||
  447. HXIsEqual(pInputPos, '>')  ||
  448.      HXIsEqual(pInputPos, ',')  ||
  449.      HXIsEqual(pInputPos, '#')  ||
  450.      HXIsEqual(pInputPos, 0x01) ||
  451.      HXIsEqual(pInputPos, 0x02) ||
  452.      HXIsEqual(pInputPos, 0x03) ||
  453.      HXIsEqual(pInputPos, 0x04) ||
  454.      HXIsEqual(pInputPos, 0x05) ||
  455.      HXIsEqual(pInputPos, 0x06) ||
  456.      HXIsEqual(pInputPos, 0x07) ||
  457.      HXIsEqual(pInputPos, 0x08) ||
  458.      HXIsEqual(pInputPos, 0x09) ||
  459.      HXIsEqual(pInputPos, 0x0a) ||
  460.      HXIsEqual(pInputPos, 0x0b) ||
  461.      HXIsEqual(pInputPos, 0x0c) ||
  462.      HXIsEqual(pInputPos, 0x0d) ||
  463.      HXIsEqual(pInputPos, 0x0e) ||
  464.      HXIsEqual(pInputPos, 0x0f) ||
  465.      HXIsEqual(pInputPos, 0x10) ||
  466.      HXIsEqual(pInputPos, 0x11) ||
  467.      HXIsEqual(pInputPos, 0x12) ||
  468.      HXIsEqual(pInputPos, 0x13) ||
  469.      HXIsEqual(pInputPos, 0x14) ||
  470.      HXIsEqual(pInputPos, 0x15) ||
  471.      HXIsEqual(pInputPos, 0x16) ||
  472.      HXIsEqual(pInputPos, 0x17) ||
  473.      HXIsEqual(pInputPos, 0x18) ||
  474.      HXIsEqual(pInputPos, 0x19) ||
  475.      HXIsEqual(pInputPos, 0x1a) ||
  476.      HXIsEqual(pInputPos, 0x1b) ||
  477.      HXIsEqual(pInputPos, 0x1c) ||
  478.      HXIsEqual(pInputPos, 0x1d) ||
  479.      HXIsEqual(pInputPos, 0x1e) ||
  480.      HXIsEqual(pInputPos, 0x1f);
  481. }
  482. else
  483. {
  484.     // Use a lookup table for improved performance
  485.     bIsIllegal = (BOOL)escapeChars[(UCHAR)*pInputPos];
  486. }
  488. if (bIsIllegal)
  489. {
  490.     SafeSprintf(pTemp, sizeof(pTemp), "%02x", *pInputPos);
  492.     *pOutputPos++ = '%';
  493.     *pOutputPos++ = pTemp[0];
  494.     *pOutputPos++ = pTemp[1];
  495. }
  496. else if (HXIsEqual(pInputPos, ' '))
  497. {
  498.     *pOutputPos++ = '+';
  499. }
  500. else
  501. {
  502.     *pOutputPos++ = *pInputPos;
  504.     if (HXIsLeadByte(*pInputPos))
  505.     {
  506.      *pOutputPos++ = *(pInputPos + 1);
  507.     }
  508. }
  510. pInputPos = HXGetNextChar(pInputPos);
  511.     }
  513.     // Return the length of the escaped content
  514.     return (pOutputPos - pOutBuf);
  515. }
  517. const char escapeCharsNoReserved[] =
  518. { //8,9,A,B,C,D,E,F
  519.     0,1,1,1,1,1,1,1, // 0x00
  520.     1,1,1,1,1,1,1,1, // 0x08
  521.     1,1,1,1,1,1,1,1, // 0x10
  522.     1,1,1,1,1,1,1,1, // 0x18
  523.     1,0,1,1,0,1,0,0, // 0x20
  524.     0,0,0,0,0,0,0,0, // 0x28
  525.     0,0,0,0,0,0,0,0, // 0x30
  526.     0,0,0,0,1,0,1,0, // 0x38
  527.     0,0,0,0,0,0,0,0, // 0x40
  528.     0,0,0,0,0,0,0,0, // 0x48
  529.     0,0,0,0,0,0,0,0, // 0x50
  530.     0,0,0,1,1,1,1,0, // 0x58
  531.     1,0,0,0,0,0,0,0, // 0x60
  532.     0,0,0,0,0,0,0,0, // 0x68
  533.     0,0,0,0,0,0,0,0, // 0x70
  534.     0,0,0,1,1,1,1,1, // 0x78
  535.     1,1,1,1,1,1,1,1, // 0x80
  536.     1,1,1,1,1,1,1,1, // 0x88
  537.     1,1,1,1,1,1,1,1, // 0x90
  538.     1,1,1,1,1,1,1,1, // 0x98
  539.     1,1,1,1,1,1,1,1, // 0xA0
  540.     1,1,1,1,1,1,1,1, // 0xA8
  541.     1,1,1,1,1,1,1,1, // 0xB0
  542.     1,1,1,1,1,1,1,1, // 0xB8
  543.     1,1,1,1,1,1,1,1, // 0xC0
  544.     1,1,1,1,1,1,1,1, // 0xC8
  545.     1,1,1,1,1,1,1,1, // 0xD0
  546.     1,1,1,1,1,1,1,1, // 0xD8
  547.     1,1,1,1,1,1,1,1, // 0xE0
  548.     1,1,1,1,1,1,1,1, // 0xE8
  549.     1,1,1,1,1,1,1,1, // 0xF0
  550.     1,1,1,1,1,1,1,1  // 0xF8
  551. };
  554. const char escapeCharsReserved[] =
  555. { //8,9,A,B,C,D,E,F     
  556.     0,1,1,1,1,1,1,1, // 0x00
  557.     1,1,1,1,1,1,1,1, // 0x08
  558.     1,1,1,1,1,1,1,1, // 0x10
  559.     1,1,1,1,1,1,1,1, // 0x18
  560.     1,0,1,1,0,1,1,0, // 0x20
  561.     0,0,0,0,0,0,0,1, // 0x28
  562.     0,0,0,0,0,0,0,0, // 0x30
  563.     0,0,1,1,1,1,1,1, // 0x38
  564.     1,0,0,0,0,0,0,0, // 0x40
  565.     0,0,0,0,0,0,0,0, // 0x48
  566.     0,0,0,0,0,0,0,0, // 0x50
  567.     0,0,0,1,1,1,1,0, // 0x58
  568.     1,0,0,0,0,0,0,0, // 0x60
  569.     0,0,0,0,0,0,0,0, // 0x68
  570.     0,0,0,0,0,0,0,0, // 0x70
  571.     0,0,0,1,1,1,1,1, // 0x78
  572.     1,1,1,1,1,1,1,1, // 0x80
  573.     1,1,1,1,1,1,1,1, // 0x88
  574.     1,1,1,1,1,1,1,1, // 0x90
  575.     1,1,1,1,1,1,1,1, // 0x98
  576.     1,1,1,1,1,1,1,1, // 0xA0
  577.     1,1,1,1,1,1,1,1, // 0xA8
  578.     1,1,1,1,1,1,1,1, // 0xB0
  579.     1,1,1,1,1,1,1,1, // 0xB8
  580.     1,1,1,1,1,1,1,1, // 0xC0
  581.     1,1,1,1,1,1,1,1, // 0xC8
  582.     1,1,1,1,1,1,1,1, // 0xD0
  583.     1,1,1,1,1,1,1,1, // 0xD8
  584.     1,1,1,1,1,1,1,1, // 0xE0
  585.     1,1,1,1,1,1,1,1, // 0xE8
  586.     1,1,1,1,1,1,1,1, // 0xF0
  587.     1,1,1,1,1,1,1,1  // 0xF8
  588. };
  590. /*
  591.  * Function: URLEscapeBufferReserved  this function will escape all potentially unsafe charactors.
  592.  */
  593. INT32 
  594. URLEscapeBuffer2(const char* pInBuf, INT32 len, char* pOutBuf, BOOL bReserved)
  595. {
  596.     const char* pInputPos = pInBuf;
  597.     char* pOutputPos = pOutBuf;
  598.     char pTemp[3];
  599.     
  600.     if (!pInBuf || !len || !pOutBuf)
  601.     {
  602. return -1;
  603.     }
  605.     const char* lookupTable = NULL;
  606.     if (bReserved)
  607.     {
  608. lookupTable = (const char*)escapeCharsReserved;
  609.     }
  610.     else
  611.     {
  612. lookupTable = (const char*)escapeCharsNoReserved;
  613.     }
  614.     
  615.  
  617.     // Iterate through the input buffer
  618.     while (pInputPos < pInBuf + len)
  619.     {
  620. // Use a lookup table for improved performance
  621. BOOL bIsIllegal = (BOOL)lookupTable[(UCHAR)*pInputPos];
  623. if (bIsIllegal)
  624. {
  625.     SafeSprintf(pTemp, sizeof(pTemp), "%02x", *pInputPos);
  627.     *pOutputPos++ = '%';
  628.     *pOutputPos++ = pTemp[0];
  629.     *pOutputPos++ = pTemp[1];
  630. }
  631. else
  632. {
  633.     *pOutputPos++ = *pInputPos;
  634. }
  636. ++pInputPos;
  637.     }
  639.     // Return the length of the escaped content
  640.     return (pOutputPos - pOutBuf);
  641. }
  644. /*
  645.  * Function: URLUnescapeBuffer
  646.  */
  647. INT32 
  648. URLUnescapeBuffer(const char* pInBuf, INT32 len, char* pOutBuf)
  649. {
  650.     char* pOutputPos = pOutBuf;
  651.     char pTemp[3];
  653.     if (!pInBuf || !len || !pOutBuf)
  654.     {
  655. return -1;
  656.     }
  658.     // Iterate through the input buffer
  659.     for (INT32 i = 0; i < len; i++)
  660.     {
  661. // Ignore whitespace
  662. if ((UCHAR)pInBuf[i] < 21)
  663. {
  664.     continue;
  665. }
  666. // If an escaped character is found, translate it
  667. else if (pInBuf[i] == '%')
  668. {
  669.     if (len < i + 3)
  670.     {
  671. // Incomplete %xx representation
  672. return -1;
  673.     }
  674.     
  675.     // Ignore whitespace
  676.     while (pInBuf[i + 1] < 21) 
  677.     { 
  678. i++;
  679. if (len < i + 3)
  680. {
  681.     return -1;
  682. }
  683.     }
  684.     pTemp[0] = pInBuf[i + 1];
  686.     // Ignore whitespace
  687.     while (pInBuf[i + 2] < 21) 
  688.     { 
  689. i++;
  690. if (len < i + 3)
  691. {
  692.     return -1;
  693. }
  694.     }
  695.     pTemp[1] = pInBuf[i + 2];
  697.     pTemp[2] = '';
  698.     *pOutputPos++ = (char)strtol(pTemp, NULL, 16);
  700.     i += 2;
  701. }
  702. else if (pInBuf[i] == '+')
  703. {
  704.     *pOutputPos++ = ' ';
  705. }
  706. else
  707. {
  708.     *pOutputPos++ = pInBuf[i];
  709. }
  710.     }
  712.     // Return the length of the escaped content
  713.     return (pOutputPos - pOutBuf);
  714. }
  717. #ifdef XXXDPS
  719. static const char* pTestTable[] =
  720. {
  721.     "this is a test, this is only a test",
  722.     "abcdefghijklmnopqrstuvwxyz0123456789/NoneOfThisShouldGetEscaped...",
  723.     "rnt,#><+"%All Of The First 10 Chars Should Get Escaped",
  724.     "Insert a DBCS test string here."
  725. };
  727. void main()
  728. {
  729.     unsigned char encodeBuf[300]; /* Flawfinder: ignore */
  730.     unsigned char decodeBuf[300]; /* Flawfinder: ignore */
  732.     for (int i = 0; i < 4; i++)
  733.     {
  734. memset(encodeBuf, '', sizeof(encodeBuf));
  735. memset(decodeBuf, '', sizeof(decodeBuf));
  737. printf("Escaping >>>%s<<<n", pTestTable[i]);
  738. int rc = URLEscapeBuffer((char*)pTestTable[i], strlen(pTestTable[i]), (char*)encodeBuf);
  739. printf("original size: %d, encoded size: %dn", strlen(pTestTable[i]), rc);
  740. printf("%sn", encodeBuf);
  741. rc = URLUnescapeBuffer((char*)encodeBuf, rc, (char*)decodeBuf);
  742. printf("decode size: %dn", rc);
  743. printf("%sn", decodeBuf);
  744. printf("n");
  745.     }
  746. }
  748. #endif /* XXXDPS */