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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rtsputil.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：19k
源码类别：

Symbian

开发平台：

Visual C++

rtsputil.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: rtsputil.cpp,v 1.6.32.3 2004/07/09 01:48:16 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hxtypes.h"
  51. #include "hxstring.h"
  52. #include "dbcs.h"
  53. #include "rtsputil.h"
  54. #include "safestring.h"
  56. #include "hxheap.h"
  57. #ifdef _DEBUG
  58. #undef HX_THIS_FILE
  59. static const char HX_THIS_FILE[] = __FILE__;
  60. #endif
  63. /*
  64.  * Table for encoding base64
  65.  */
  66. static const char Base64[] =
  67.    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  69. /*
  70.  * Table for encoding URL-safe base64
  71.  */
  72. static const char URLBase64[] =
  73.    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!*";
  75. #define XX 127
  76. /*
  77.  * Table for decoding base64
  78.  */
  79. static const char Index64[256] = { /* Flawfinder: ignore */
  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.     XX,62,XX,XX, XX,XX,XX,XX, XX,XX,63,62, XX,XX,XX,63,
  83.     52,53,54,55, 56,57,58,59, 60,61,XX,XX, XX,XX,XX,XX,
  84.     XX, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  85.     15,16,17,18, 19,20,21,22, 23,24,25,XX, XX,XX,XX,XX,
  86.     XX,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  87.     41,42,43,44, 45,46,47,48, 49,50,51,XX, XX,XX,XX,XX,
  88.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  89.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  90.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  91.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  92.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  93.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  94.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  95.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX
  96. };
  97. #define CHAR64(c)  (Index64[(unsigned char)(c)])
  99. static void 
  100. Output64Chunk(int c1, int c2, int c3, int pads, char* pBuf,
  101.     INT32 bufOffset)
  102. {
  103.     pBuf[bufOffset++] = Base64[c1>>2];
  104.     pBuf[bufOffset++] = Base64[((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)];
  105.     if (pads == 2) 
  106.     {
  107.         pBuf[bufOffset++] = '=';
  108.         pBuf[bufOffset++] = '=';
  109.     }
  110.     else if (pads) 
  111.     {
  112.         pBuf[bufOffset++] = Base64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  113.         pBuf[bufOffset++] = '=';
  114.     } 
  115.     else 
  116.     {
  117.         pBuf[bufOffset++] = Base64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  118.         pBuf[bufOffset++] = Base64[c3 & 0x3F];
  119.     }
  120. }
  122. static void 
  123. OutputURL64Chunk(int c1, int c2, int c3, int pads, char* pBuf,
  124.     INT32 bufOffset)
  125. {
  126.     pBuf[bufOffset++] = URLBase64[c1>>2];
  127.     pBuf[bufOffset++] = URLBase64[((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)];
  128.     if (pads == 2) 
  129.     {
  130.         pBuf[bufOffset++] = '=';
  131.         pBuf[bufOffset++] = '=';
  132.     }
  133.     else if (pads) 
  134.     {
  135.         pBuf[bufOffset++] = URLBase64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  136.         pBuf[bufOffset++] = '=';
  137.     } 
  138.     else 
  139.     {
  140.         pBuf[bufOffset++] = URLBase64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  141.         pBuf[bufOffset++] = URLBase64[c3 & 0x3F];
  142.     }
  143. }
  145. INT32 
  146. BinTo64(const BYTE* pInBuf, INT32 len, char* pOutBuf)
  147. {
  148.     int c1, c2, c3;
  149.     //INT32 ct = 0;
  150.     //INT32 written = 0;
  151.     INT32 inOffset = 0;
  152.     INT32 outOffset = 0;
  154.     while(inOffset < len)
  155.     {
  156. c1 = pInBuf[inOffset++];
  157. if(inOffset == len)
  158. {
  159.     Output64Chunk(c1, 0, 0, 2, pOutBuf, outOffset);
  160.     outOffset += 4;
  161. }
  162. else
  163. {
  164.     c2 = pInBuf[inOffset++];
  165.     if(inOffset == len)
  166.     {
  167. Output64Chunk(c1, c2, 0, 1, pOutBuf, outOffset);
  168. outOffset += 4;
  169.     }
  170.     else
  171.     {
  172. c3 = pInBuf[inOffset++];
  173. Output64Chunk(c1, c2, c3, 0, pOutBuf, outOffset);
  174. outOffset += 4;
  175.     }
  176. }
  177. #if XXXBAB
  178. ct += 4;
  179. if(ct > 44) // EOL after 45 chars
  180. {
  181.     pOutBuf[outOffset++] = 'n';
  182.     written += 46;
  183.     ct = 0;
  184. }
  185. #endif
  186.     }
  187. #if XXXBAB
  188.     if(ct)
  189.     {
  190. pOutBuf[outOffset++] = 'n';
  191. ct++;
  192.     }
  193. #endif
  194.     pOutBuf[outOffset++] = '';
  195.     return outOffset;
  196. }
  198. INT32 
  199. BinToURL64(const BYTE* pInBuf, INT32 len, char* pOutBuf)
  200. {
  201.     int c1, c2, c3;
  202.     INT32 inOffset = 0;
  203.     INT32 outOffset = 0;
  205.     while(inOffset < len)
  206.     {
  207. c1 = pInBuf[inOffset++];
  208. if(inOffset == len)
  209. {
  210.     OutputURL64Chunk(c1, 0, 0, 2, pOutBuf, outOffset);
  211.     outOffset += 4;
  212. }
  213. else
  214. {
  215.     c2 = pInBuf[inOffset++];
  216.     if(inOffset == len)
  217.     {
  218. OutputURL64Chunk(c1, c2, 0, 1, pOutBuf, outOffset);
  219. outOffset += 4;
  220.     }
  221.     else
  222.     {
  223. c3 = pInBuf[inOffset++];
  224. OutputURL64Chunk(c1, c2, c3, 0, pOutBuf, outOffset);
  225. outOffset += 4;
  226.     }
  227. }
  228.     }
  229.     pOutBuf[outOffset++] = '';
  230.     return outOffset;
  231. }
  233. INT32
  234. BinFrom64(const char* pInBuf, INT32 len, BYTE* pOutBuf)
  235. {
  236.     int c1, c2, c3, c4;
  237.     INT32 offset = 0;
  238.     INT32 outOffset = 0;
  240.     while(offset < len)
  241.     {
  242. c1 = pInBuf[offset++];
  243. if(c1 != '=' && CHAR64(c1) == XX)
  244. {
  245.     continue;
  246. }
  247. else if (offset == len)
  248. {
  249.     /* BAD data */
  250.     return -1;
  251. }
  252. do
  253. {
  254.     c2 = pInBuf[offset++];
  255. } 
  256. while(offset < len && c2 != '=' && CHAR64(c2) == XX);
  257. if (offset == len)
  258. {
  259.     /* BAD data */
  260.     return -1;
  261. }
  262.         do
  263. {
  264.     c3 = pInBuf[offset++];
  265. }
  266. while(offset < len && c3 != '=' && CHAR64(c3) == XX);
  267. if (offset == len)
  268. {
  269.     /* BAD data */
  270.     return -1;
  271. }
  272. do
  273. {
  274.     c4 = pInBuf[offset++];
  275. }
  276. while(offset < len && c4 != '=' && CHAR64(c4) == XX);
  277. if (offset == len && c4 != '=' && CHAR64(c4) == XX)
  278. {
  279.     /* BAD data */
  280.     return -1;
  281. }
  282. if(c1 == '=' || c2 == '=')
  283. {
  284.     continue;
  285. }
  286. c1 = CHAR64(c1);
  287. c2 = CHAR64(c2);
  288. pOutBuf[outOffset++]  = ((c1 << 2) | ((c2 & 0x30) >> 4));
  289. if(c3 == '=')
  290. {
  291.     continue;
  292. }
  293. else
  294. {
  295.     c3 = CHAR64(c3);
  296.     pOutBuf[outOffset++]  = (((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2));
  297.     if(c4 == '=')
  298.     {
  299. continue;
  300.     }
  301.     else
  302.     {
  303. c4 = CHAR64(c4);
  304. pOutBuf[outOffset++] = (((c3 & 0x03) << 6) | c4);
  305.     }
  306. }
  307.     }
  309.     return outOffset;
  310. }
  312. const char*
  313. EncodeCString(const char* pStr)
  314. {
  315.     CHXString tmp;
  317.     for(size_t i=0;i<strlen(pStr);++i)
  318.     {
  319.         switch(pStr[i])
  320.         {
  321.             case 'n':
  322.             {
  323.                 tmp += "\n";
  324.             }
  325.             break;
  327.             case 't':
  328.             {
  329.                 tmp += "\t";
  330.             }
  331.             break;
  333.             case 'r':
  334.             {
  335.                 tmp += "\r";
  336.             }
  337.             break;
  339.             case '"':
  340.             {
  341.                 tmp += "\"";
  342.             }
  343.             break;
  345.             case '\':
  346.             {
  347.                 tmp += "\\";
  348.             }
  349.             break;
  351.             default:
  352.             {
  353.                 tmp += pStr[i];
  354.             }
  355.         }
  356.     }
  357.     return tmp;
  358. }
  361. #ifdef XXXBAB
  363. void
  364. printbuf(unsigned char* pBuf, int len)
  365. {
  366.     for(int i=0; i<len; i++)
  367.     {
  368. printf("%02x ", pBuf[i]);
  369.     }
  370.     printf("n");
  371. }
  373. static unsigned char testBytes[] =
  374.     { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 
  375.       0x4f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  376.       0x00, 0x00, 0x00, 0x00, 0x75, 0x76, 0x77, 0x78,
  377.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  378.       0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xb3, 0x5f, 0x78,
  379.       0x4f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  380.       0x00, 0x00, 0x00, 0x00, 0x75, 0x76, 0x77, 0x78,
  381.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  382.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  383.       0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xb3, 0x5f, 0x78,
  384.       0x4f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  385.       0x00, 0x00, 0x00, 0x00, 0x75, 0x76, 0x77, 0x78,
  386.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  387.       0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xb3, 0x5f, 0x78,
  388.       0x4f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  389.       0x00, 0x00, 0x00, 0x00, 0x75, 0x76, 0x77, 0x78,
  390.       0x45, 0x44, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f,
  391.       0x77, 0x88, 0x00 };
  393. static unsigned char testBytes2[] =
  394.     { 0x7F, 0x63, 0x31, 0xBB, 0x90, 0x21, 0x32, 0x11,
  395.       0xC4 };
  396. void main()
  397. {
  398.     unsigned char encodeBuf[300]; /* Flawfinder: ignore */
  399.     unsigned char decodeBuf[300]; /* Flawfinder: ignore */
  401.     memset(encodeBuf, '', sizeof(encodeBuf));
  402.     memset(decodeBuf, '', sizeof(decodeBuf));
  404.     int rc = BinTo64(testBytes, sizeof(testBytes), encodeBuf);
  405.     printf("original size: %d, encoded size: %dn", sizeof(testBytes), rc);
  406.     printf("%sn", encodeBuf);
  407.     rc = BinFrom64(encodeBuf, rc, decodeBuf);
  408.     printf("decode size: %dn", rc);
  409.     printbuf(decodeBuf, rc);
  410. }
  412. #endif /* XXXBAB */
  415. const char escapeChars[] =
  416. {       
  417.     0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  418.     1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,0,1,0,0,
  419.     0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  420.     1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  421.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  422.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  423.     0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
  424.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  425.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  426.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  427.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  428.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  429.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  430. };
  432. /*
  433.  * Function: URLEscapeBuffer
  434.  */
  435. INT32 
  436. URLEscapeBuffer(const char* pInBuf, INT32 len, char* pOutBuf)
  437. {
  438.     const char* pInputPos = pInBuf;
  439.     char* pOutputPos = pOutBuf;
  440.     char pTemp[3]; /* Flawfinder: ignore */
  441.     
  442.     if (!pInBuf || !len || !pOutBuf)
  443.     {
  444. return -1;
  445.     }
  447.     // Iterate through the input buffer
  448.     while (pInputPos < pInBuf + len)
  449.     {
  450. BOOL bIsIllegal = FALSE;
  452. if (HXIsDBCSEnabled())
  453. {
  454.     // If an illegal URL character is found, translate it
  455.     bIsIllegal = 
  456.         HXIsEqual(pInputPos, 0x7f) ||
  457.      HXIsEqual(pInputPos, '%')  ||
  458.      HXIsEqual(pInputPos, '"')  ||
  459.      HXIsEqual(pInputPos, '+')  ||
  460.      HXIsEqual(pInputPos, '<')  ||
  461. HXIsEqual(pInputPos, '>')  ||
  462.      HXIsEqual(pInputPos, ',')  ||
  463.      HXIsEqual(pInputPos, '#')  ||
  464.      HXIsEqual(pInputPos, 0x01) ||
  465.      HXIsEqual(pInputPos, 0x02) ||
  466.      HXIsEqual(pInputPos, 0x03) ||
  467.      HXIsEqual(pInputPos, 0x04) ||
  468.      HXIsEqual(pInputPos, 0x05) ||
  469.      HXIsEqual(pInputPos, 0x06) ||
  470.      HXIsEqual(pInputPos, 0x07) ||
  471.      HXIsEqual(pInputPos, 0x08) ||
  472.      HXIsEqual(pInputPos, 0x09) ||
  473.      HXIsEqual(pInputPos, 0x0a) ||
  474.      HXIsEqual(pInputPos, 0x0b) ||
  475.      HXIsEqual(pInputPos, 0x0c) ||
  476.      HXIsEqual(pInputPos, 0x0d) ||
  477.      HXIsEqual(pInputPos, 0x0e) ||
  478.      HXIsEqual(pInputPos, 0x0f) ||
  479.      HXIsEqual(pInputPos, 0x10) ||
  480.      HXIsEqual(pInputPos, 0x11) ||
  481.      HXIsEqual(pInputPos, 0x12) ||
  482.      HXIsEqual(pInputPos, 0x13) ||
  483.      HXIsEqual(pInputPos, 0x14) ||
  484.      HXIsEqual(pInputPos, 0x15) ||
  485.      HXIsEqual(pInputPos, 0x16) ||
  486.      HXIsEqual(pInputPos, 0x17) ||
  487.      HXIsEqual(pInputPos, 0x18) ||
  488.      HXIsEqual(pInputPos, 0x19) ||
  489.      HXIsEqual(pInputPos, 0x1a) ||
  490.      HXIsEqual(pInputPos, 0x1b) ||
  491.      HXIsEqual(pInputPos, 0x1c) ||
  492.      HXIsEqual(pInputPos, 0x1d) ||
  493.      HXIsEqual(pInputPos, 0x1e) ||
  494.      HXIsEqual(pInputPos, 0x1f);
  495. }
  496. else
  497. {
  498.     // Use a lookup table for improved performance
  499.     bIsIllegal = (BOOL)escapeChars[(UCHAR)*pInputPos];
  500. }
  502. if (bIsIllegal)
  503. {
  504.     SafeSprintf(pTemp, sizeof(pTemp), "%02x", *pInputPos);
  506.     *pOutputPos++ = '%';
  507.     *pOutputPos++ = pTemp[0];
  508.     *pOutputPos++ = pTemp[1];
  509. }
  510. else if (HXIsEqual(pInputPos, ' '))
  511. {
  512.     *pOutputPos++ = '+';
  513. }
  514. else
  515. {
  516.     *pOutputPos++ = *pInputPos;
  518.     if (HXIsLeadByte(*pInputPos))
  519.     {
  520.      *pOutputPos++ = *(pInputPos + 1);
  521.     }
  522. }
  524. pInputPos = HXGetNextChar(pInputPos);
  525.     }
  527.     // Return the length of the escaped content
  528.     return (pOutputPos - pOutBuf);
  529. }
  531. const char escapeCharsNoReserved[] =
  532. { //8,9,A,B,C,D,E,F
  533.     0,1,1,1,1,1,1,1, // 0x00
  534.     1,1,1,1,1,1,1,1, // 0x08
  535.     1,1,1,1,1,1,1,1, // 0x10
  536.     1,1,1,1,1,1,1,1, // 0x18
  537.     1,0,1,1,0,1,0,0, // 0x20
  538.     0,0,0,0,0,0,0,0, // 0x28
  539.     0,0,0,0,0,0,0,0, // 0x30
  540.     0,0,0,0,1,0,1,0, // 0x38
  541.     0,0,0,0,0,0,0,0, // 0x40
  542.     0,0,0,0,0,0,0,0, // 0x48
  543.     0,0,0,0,0,0,0,0, // 0x50
  544.     0,0,0,1,1,1,1,0, // 0x58
  545.     1,0,0,0,0,0,0,0, // 0x60
  546.     0,0,0,0,0,0,0,0, // 0x68
  547.     0,0,0,0,0,0,0,0, // 0x70
  548.     0,0,0,1,1,1,1,1, // 0x78
  549.     1,1,1,1,1,1,1,1, // 0x80
  550.     1,1,1,1,1,1,1,1, // 0x88
  551.     1,1,1,1,1,1,1,1, // 0x90
  552.     1,1,1,1,1,1,1,1, // 0x98
  553.     1,1,1,1,1,1,1,1, // 0xA0
  554.     1,1,1,1,1,1,1,1, // 0xA8
  555.     1,1,1,1,1,1,1,1, // 0xB0
  556.     1,1,1,1,1,1,1,1, // 0xB8
  557.     1,1,1,1,1,1,1,1, // 0xC0
  558.     1,1,1,1,1,1,1,1, // 0xC8
  559.     1,1,1,1,1,1,1,1, // 0xD0
  560.     1,1,1,1,1,1,1,1, // 0xD8
  561.     1,1,1,1,1,1,1,1, // 0xE0
  562.     1,1,1,1,1,1,1,1, // 0xE8
  563.     1,1,1,1,1,1,1,1, // 0xF0
  564.     1,1,1,1,1,1,1,1  // 0xF8
  565. };
  568. const char escapeCharsReserved[] =
  569. { //8,9,A,B,C,D,E,F     
  570.     0,1,1,1,1,1,1,1, // 0x00
  571.     1,1,1,1,1,1,1,1, // 0x08
  572.     1,1,1,1,1,1,1,1, // 0x10
  573.     1,1,1,1,1,1,1,1, // 0x18
  574.     1,0,1,1,0,1,1,0, // 0x20
  575.     0,0,0,0,0,0,0,1, // 0x28
  576.     0,0,0,0,0,0,0,0, // 0x30
  577.     0,0,1,1,1,1,1,1, // 0x38
  578.     1,0,0,0,0,0,0,0, // 0x40
  579.     0,0,0,0,0,0,0,0, // 0x48
  580.     0,0,0,0,0,0,0,0, // 0x50
  581.     0,0,0,1,1,1,1,0, // 0x58
  582.     1,0,0,0,0,0,0,0, // 0x60
  583.     0,0,0,0,0,0,0,0, // 0x68
  584.     0,0,0,0,0,0,0,0, // 0x70
  585.     0,0,0,1,1,1,1,1, // 0x78
  586.     1,1,1,1,1,1,1,1, // 0x80
  587.     1,1,1,1,1,1,1,1, // 0x88
  588.     1,1,1,1,1,1,1,1, // 0x90
  589.     1,1,1,1,1,1,1,1, // 0x98
  590.     1,1,1,1,1,1,1,1, // 0xA0
  591.     1,1,1,1,1,1,1,1, // 0xA8
  592.     1,1,1,1,1,1,1,1, // 0xB0
  593.     1,1,1,1,1,1,1,1, // 0xB8
  594.     1,1,1,1,1,1,1,1, // 0xC0
  595.     1,1,1,1,1,1,1,1, // 0xC8
  596.     1,1,1,1,1,1,1,1, // 0xD0
  597.     1,1,1,1,1,1,1,1, // 0xD8
  598.     1,1,1,1,1,1,1,1, // 0xE0
  599.     1,1,1,1,1,1,1,1, // 0xE8
  600.     1,1,1,1,1,1,1,1, // 0xF0
  601.     1,1,1,1,1,1,1,1  // 0xF8
  602. };
  604. /*
  605.  * Function: URLEscapeBufferReserved  this function will escape all potentially unsafe charactors.
  606.  */
  607. INT32 
  608. URLEscapeBuffer2(const char* pInBuf, INT32 len, char* pOutBuf, BOOL bReserved)
  609. {
  610.     const char* pInputPos = pInBuf;
  611.     char* pOutputPos = pOutBuf;
  612.     char pTemp[3];
  613.     
  614.     if (!pInBuf || !len || !pOutBuf)
  615.     {
  616. return -1;
  617.     }
  619.     const char* lookupTable = NULL;
  620.     if (bReserved)
  621.     {
  622. lookupTable = (const char*)escapeCharsReserved;
  623.     }
  624.     else
  625.     {
  626. lookupTable = (const char*)escapeCharsNoReserved;
  627.     }
  628.     
  629.  
  631.     // Iterate through the input buffer
  632.     while (pInputPos < pInBuf + len)
  633.     {
  634. // Use a lookup table for improved performance
  635. BOOL bIsIllegal = (BOOL)lookupTable[(UCHAR)*pInputPos];
  637. if (bIsIllegal)
  638. {
  639.     SafeSprintf(pTemp, sizeof(pTemp), "%02x", *pInputPos);
  641.     *pOutputPos++ = '%';
  642.     *pOutputPos++ = pTemp[0];
  643.     *pOutputPos++ = pTemp[1];
  644. }
  645. else
  646. {
  647.     *pOutputPos++ = *pInputPos;
  648. }
  650. ++pInputPos;
  651.     }
  653.     // Return the length of the escaped content
  654.     return (pOutputPos - pOutBuf);
  655. }
  658. /*
  659.  * Function: URLUnescapeBuffer
  660.  */
  661. INT32 
  662. URLUnescapeBuffer(const char* pInBuf, INT32 len, char* pOutBuf)
  663. {
  664.     char* pOutputPos = pOutBuf;
  665.     char pTemp[3];
  667.     if (!pInBuf || !len || !pOutBuf)
  668.     {
  669. return -1;
  670.     }
  672.     // Iterate through the input buffer
  673.     for (INT32 i = 0; i < len; i++)
  674.     {
  675. // Ignore whitespace
  676. if ((UCHAR)pInBuf[i] < 21)
  677. {
  678.     continue;
  679. }
  680. // If an escaped character is found, translate it
  681. else if (pInBuf[i] == '%')
  682. {
  683.     if (len < i + 3)
  684.     {
  685. // Incomplete %xx representation
  686. return -1;
  687.     }
  688.     
  689.     // Ignore whitespace
  690.     while (pInBuf[i + 1] < 21) 
  691.     { 
  692. i++;
  693. if (len < i + 3)
  694. {
  695.     return -1;
  696. }
  697.     }
  698.     pTemp[0] = pInBuf[i + 1];
  700.     // Ignore whitespace
  701.     while (pInBuf[i + 2] < 21) 
  702.     { 
  703. i++;
  704. if (len < i + 3)
  705. {
  706.     return -1;
  707. }
  708.     }
  709.     pTemp[1] = pInBuf[i + 2];
  711.     pTemp[2] = '';
  712.     *pOutputPos++ = (char)strtol(pTemp, NULL, 16);
  714.     i += 2;
  715. }
  716. else if (pInBuf[i] == '+')
  717. {
  718.     *pOutputPos++ = ' ';
  719. }
  720. else
  721. {
  722.     *pOutputPos++ = pInBuf[i];
  723. }
  724.     }
  726.     // Return the length of the escaped content
  727.     return (pOutputPos - pOutBuf);
  728. }
  731. #ifdef XXXDPS
  733. static const char* pTestTable[] =
  734. {
  735.     "this is a test, this is only a test",
  736.     "abcdefghijklmnopqrstuvwxyz0123456789/NoneOfThisShouldGetEscaped...",
  737.     "rnt,#><+"%All Of The First 10 Chars Should Get Escaped",
  738.     "Insert a DBCS test string here."
  739. };
  741. void main()
  742. {
  743.     unsigned char encodeBuf[300]; /* Flawfinder: ignore */
  744.     unsigned char decodeBuf[300]; /* Flawfinder: ignore */
  746.     for (int i = 0; i < 4; i++)
  747.     {
  748. memset(encodeBuf, '', sizeof(encodeBuf));
  749. memset(decodeBuf, '', sizeof(decodeBuf));
  751. printf("Escaping >>>%s<<<n", pTestTable[i]);
  752. int rc = URLEscapeBuffer((char*)pTestTable[i], strlen(pTestTable[i]), (char*)encodeBuf);
  753. printf("original size: %d, encoded size: %dn", strlen(pTestTable[i]), rc);
  754. printf("%sn", encodeBuf);
  755. rc = URLUnescapeBuffer((char*)encodeBuf, rc, (char*)decodeBuf);
  756. printf("decode size: %dn", rc);
  757. printf("%sn", decodeBuf);
  758. printf("n");
  759.     }
  760. }
  762. #endif /* XXXDPS */