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

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

Symbian

开发平台：

Visual C++

hxinfcod.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxinfcod.cpp,v 1.5.32.3 2004/07/09 01:48:15 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. /****************************************************************************
  51.  *
  52.  * This file contains implementation of classes that support
  53.  * the encoding of raw bytes of upgrade negotiation messages
  54.  * into a clear text representaion of the raw data.
  55.  *
  56.  */
  58. #include "hxinfcod.h"
  59. #include "hxassert.h"
  60. #include "hlxclib/string.h"
  61. //#include "hlxclib/stdio.h"
  62. #include "netbyte.h"
  63. #include "hxheap.h"
  65. #ifdef _DEBUG
  66. #undef HX_THIS_FILE
  67. static const char HX_THIS_FILE[] = __FILE__;
  68. #endif
  71. /////////////////////////////////////////////////////////////////////
  72. static UINT16  FourByteAlign(UINT16 number)
  73. {
  74. return( ((number+3)>>2)<<2 );
  75. }
  78. //*******************************************************************
  79. // CHXInfoEncoder
  80. //*******************************************************************
  82. // IUnknown interface listing
  83. BEGIN_INTERFACE_LIST(CHXInfoEncoder)
  84.     INTERFACE_LIST_ENTRY(IID_IHXObjOutStream, IHXObjOutStream)
  85. END_INTERFACE_LIST
  87. /////////////////////////////////////////////////////////////////////
  88. CHXInfoEncoder::CHXInfoEncoder()
  89. {
  90. m_FinalBuffer = NULL;
  91. m_bFinalBufferAllocFlag = FALSE;
  92. m_nFinalLen = 0;
  94. m_nOffset = 0;
  95. }
  97. /////////////////////////////////////////////////////////////////////
  98. // get ptr to encoded data - either the data buffer that's been Dump()'d
  99. // to, or a secondary buffer where data was further encoded (ie,
  100. // Hex'd or perplex'd).
  101. STDMETHODIMP_(const char*) CHXInfoEncoder::GetBuffer()
  102. {
  103. if (m_FinalBuffer)
  104. return((char*)m_FinalBuffer);
  106. return((char*)m_Buffer.GetPtr());
  107. }
  110. /////////////////////////////////////////////////////////////////////
  111. STDMETHODIMP_(UINT32) CHXInfoEncoder::GetLength()
  112. {
  113. if (m_FinalBuffer)
  114. return(m_nFinalLen);
  116. return(m_nOffset);
  117. }
  120. /////////////////////////////////////////////////////////////////////
  121. CHXInfoEncoder::~CHXInfoEncoder()
  122. {
  123. if ( (m_bFinalBufferAllocFlag==TRUE) && (m_FinalBuffer!=NULL) )
  124.     {
  125. delete [] m_FinalBuffer;
  126.     }
  127. }
  130. /////////////////////////////////////////////////////////////////////
  131. void CHXInfoEncoder::EncodeObj(IHXStreamableObj* pObj)
  132. {
  133. this->Initialize();
  134. this->WriteObj(pObj);
  135. }
  138. /////////////////////////////////////////////////////////////////////
  139. void CHXInfoEncoder::PerplexEncodeObj(IHXStreamableObj* pObj)
  140. {
  141. this->Initialize();
  142. this->WriteObj(pObj);
  143. this->Perplex();
  144. }
  146. /////////////////////////////////////////////////////////////////////
  147. BOOL CHXInfoEncoder::Perplex()
  148. {
  149. // no data to perplex?
  150. if (m_nOffset==0) return(FALSE);
  152. // if final buffer already exists, return error.....
  153. // That means we already did an encoding, and the user should
  154. // call Initialize() before the encoder is reused.
  155. if (m_FinalBuffer!=NULL) return(FALSE);
  157. // Make sure we're 4byte aligned. Needed by Perplex alg.
  158.     UINT32 nAlign =  (m_nOffset) % sizeof(ULONG32);
  160.     if (nAlign > 0)
  161.     {
  162. m_Buffer.EnsureValidOffset(m_nOffset+sizeof(ULONG32)-nAlign);
  163. for (; nAlign < sizeof(ULONG32); nAlign++)
  164. {
  165. m_Buffer.SetUCHAR(m_nOffset++,0);
  166. }
  167.     }
  169. // calc size of Perplexed buffer.
  170.     m_nFinalLen = m_nOffset * Perplex_PER_ULONG32 / sizeof(ULONG32);
  172. // alloc mem for final perplexed buffer
  173. // Add one to length 'cause low level perplex adds
  174. // a '' to the resulting string
  175. m_bFinalBufferAllocFlag = TRUE;
  176. m_FinalBuffer = new UCHAR[m_nFinalLen+1];
  177. HX_ASSERT(m_FinalBuffer!=NULL);
  179.     if( m_FinalBuffer==NULL)
  180.     {
  181. m_nFinalLen=0;
  182. return(FALSE);
  183.     }
  184. else
  185.     {
  186.         CHXInfoEncoder::DumpToPerplex((char*)m_FinalBuffer, m_nFinalLen+1, m_Buffer.GetPtr(), m_nOffset);
  187.     }
  189. return(TRUE);
  190. }
  193. /////////////////////////////////////////////////////////////////////
  194. void CHXInfoEncoder::HexEncodeObj(IHXStreamableObj* pObj)
  195. {
  196. this->Initialize();
  197. this->WriteObj(pObj);
  198. this->Hex();
  199. }
  201. /////////////////////////////////////////////////////////////////////
  202. BOOL CHXInfoEncoder::Hex()
  203. {
  204. // no data to perplex?
  205. if (m_nOffset==0) return(FALSE);
  207. // if final buffer already exists, return error.....
  208. // That means we already did an encoding, and the user should
  209. // call Initialize() before the encoder is reused.
  210. if (m_FinalBuffer!=NULL) return(FALSE);
  212. // calc size of hexed buffer.
  213.     m_nFinalLen = m_nOffset * 2;
  215. // alloc mem for final perplexed buffer
  216. m_bFinalBufferAllocFlag = TRUE;
  217. // Add one to length 'cause low level perplex adds
  218. // a '' to the resulting string
  219. m_FinalBuffer = new UCHAR[m_nFinalLen+1];
  220. HX_ASSERT(m_FinalBuffer!=NULL);
  222.     if( m_FinalBuffer==NULL)
  223.     {
  224. m_nFinalLen=0;
  225. return(FALSE);
  226.     }
  227. else
  228.     {
  229.         CHXInfoEncoder::DumpToHex((char*)m_FinalBuffer, m_Buffer.GetPtr(), m_nOffset);
  230.     }
  232. return(TRUE);
  233. }
  236. /////////////////////////////////////////////////////////////////////
  237. STDMETHODIMP CHXInfoEncoder::Initialize()
  238. {
  239. if (m_bFinalBufferAllocFlag==TRUE)
  240.     {
  241. if (m_FinalBuffer!=NULL)
  242. delete [] m_FinalBuffer;
  243.     }
  244. m_bFinalBufferAllocFlag = FALSE;
  245. m_FinalBuffer = NULL;
  246. m_nFinalLen    = 0;
  248. m_Buffer.Free();
  249. m_nOffset=0;
  251. return(HXR_OK);
  252. }
  254. /////////////////////////////////////////////////////////////////////
  255. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteObj(IHXStreamableObj* pObj) 
  256. {
  257. UINT32 nLen=this->GetOffset();
  259. if (pObj->WriteObjToBits(this)==HXR_OK)
  260. return this->GetOffset()-nLen;
  262. #if 0
  263. // reading object
  264. this->Seek(nLen);
  265. #endif
  266. return(0);
  267. }
  269. /////////////////////////////////////////////////////////////////////
  270. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUCHAR(UCHAR nValue)
  271. {
  272.     m_Buffer.SafeMemCopy(m_nOffset,&nValue, sizeof(nValue));
  273. m_nOffset += sizeof(nValue);
  274.     return sizeof(nValue);
  275. }
  279. /////////////////////////////////////////////////////////////////////
  280. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUINT16(UINT16 nValue)
  281. {
  282.     UINT16 temp16 = WToNet(nValue);
  284.     m_Buffer.SafeMemCopy(m_nOffset,&temp16, sizeof(temp16));
  286. m_nOffset += sizeof(temp16);
  287.     return sizeof(temp16);
  288. }
  290. /////////////////////////////////////////////////////////////////////
  291. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUINT32(UINT32 nValue)
  292. {
  293.     UINT32 temp32 = DwToNet(nValue);
  295. m_Buffer.SafeMemCopy(m_nOffset, &temp32, sizeof(temp32));
  297. m_nOffset += sizeof(temp32);
  298.     return sizeof(temp32);
  299. }
  301. /////////////////////////////////////////////////////////////////////
  302. // Dump at a specific position. Doesn't advance offset pointer
  303. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUINT16At(UINT32 nOffset, UINT16 nValue)
  304. {
  305.     UINT16 temp16 = WToNet(nValue);
  307. if (m_Buffer.IsValidOffset(nOffset+sizeof(temp16))==TRUE)
  308.     {
  309.      m_Buffer.MemCopy(nOffset,&temp16, sizeof(temp16));
  310.     }
  312.     return sizeof(temp16);
  313. }
  315. /////////////////////////////////////////////////////////////////////
  316. // Dump at a specific position. Doesn't advance offset pointer
  317. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUINT32At(UINT32 nOffset, UINT32 nValue)
  318. {
  319.     UINT32 temp32 = DwToNet(nValue);
  321. if (m_Buffer.IsValidOffset(nOffset+sizeof(temp32))==TRUE)
  322.     {
  323. m_Buffer.MemCopy(nOffset, &temp32, sizeof(temp32));
  324.     }
  326.     return sizeof(temp32);
  327. }
  330. /////////////////////////////////////////////////////////////////////
  331. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteString(const char* szValue)
  332. {
  333. if (szValue==NULL)
  334.     {
  335. szValue="";
  336.     }
  338.     UINT32 FieldLen = strlen(szValue);
  339.     HX_ASSERT(FieldLen < 0xFF);
  341. // ensure the buffer has enough room for us.
  342. if (m_Buffer.EnsureValidOffset(m_nOffset+FieldLen+1)==TRUE)
  343.     {
  344. m_Buffer.SetUCHAR(m_nOffset, (UCHAR)FieldLen );
  345.         m_Buffer.MemCopy(m_nOffset + 1, szValue, FieldLen);
  346.     }
  348.     FieldLen ++; //account for first SIZE byte
  350. m_nOffset += FieldLen;
  351.     return FieldLen;
  352. }
  355. /////////////////////////////////////////////////////////////////////
  356. // Similar to DumpString, except this one is handy when you need
  357. // to concat 2 or 3 strings and Dump them. Instead of allocating
  358. // a buffer, concating the strings and calling DumpString, use
  359. // this routine instead. It will take 2 or 3 strings as a parameters,
  360. // and dump them concatenated. The original strings are not modified.
  361. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteStringCat(const char* szValue1,const char* szValue2,const char* szValue3)
  362. {
  363. if (szValue1==NULL) { szValue1=""; }
  364. if (szValue2==NULL) { szValue2=""; }
  365. if (szValue3==NULL) { szValue3=""; }
  367.     UINT16 nLen1=strlen(szValue1);
  368.     UINT16 nLen2=strlen(szValue2);
  369.     UINT16 nLen3=strlen(szValue3);
  371.     UINT32 FieldLen = nLen1 + nLen2 + nLen3;
  373.     HX_ASSERT(FieldLen < 0xFF);
  375. // ensure the buffer has enough room for us.
  376. if (m_Buffer.EnsureValidOffset(m_nOffset+FieldLen+1)==TRUE)
  377.     {
  378. m_Buffer.SetUCHAR(m_nOffset, (UCHAR)FieldLen );
  379. m_nOffset++;
  381. if (nLen1)
  382.         {
  383.         m_Buffer.MemCopy(m_nOffset, szValue1, nLen1);
  384. m_nOffset+=nLen1;
  385.         }
  387. if (nLen2)
  388.         {
  389.         m_Buffer.MemCopy(m_nOffset, szValue2, nLen2);
  390. m_nOffset+=nLen2;
  391.         }
  393. if (nLen3)
  394.         {
  395.         m_Buffer.MemCopy(m_nOffset, szValue3, nLen3);
  396. m_nOffset+=nLen3;
  397.         }
  398.     }
  400.     FieldLen ++; //account for first SIZE byte
  401.     return FieldLen;
  402. }
  405. /////////////////////////////////////////////////////////////////////
  406. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteLargeString(const char* szValue)
  407. {
  408. if (szValue==NULL)
  409.     {
  410. szValue="";
  411.     }
  413. // get the length of the string
  414.     UINT32 FieldLen = strlen(szValue);
  415.     HX_ASSERT(FieldLen < 0xFFFF);
  417. // dump the size (this increments m_nOffset for us too)
  418. UINT32 nSize = WriteUINT16((UINT16)FieldLen);
  420.     m_Buffer.SafeMemCopy(m_nOffset, szValue, FieldLen);
  421. m_nOffset += FieldLen;
  423.     return (FieldLen+nSize);
  424. }
  427. /////////////////////////////////////////////////////////////////////
  428. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteBuffer(const char* szBuffer, UINT32 nSize)
  429. {
  430. HX_ASSERT(szBuffer!=NULL);
  432. if (szBuffer!=NULL)
  433.     {
  434.      m_Buffer.SafeMemCopy(m_nOffset, szBuffer, nSize);
  435.     }
  437. m_nOffset += nSize;
  438.     return (nSize);
  439. }
  441. #if 0
  442. /////////////////////////////////////////////////////////////////////
  443. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUTCTime(UTCTimeRep& TimeRep)
  444. {
  445. return(this->WriteUINT32( TimeRep.asUTCTimeT() ));
  447. //    return this->WriteString(( TimeRep.asUTCString() );
  448. }
  449. #endif
  452. //*******************************************************************
  453. // CHXInfoDecoder
  454. //*******************************************************************
  456. // IUnknown interface listing
  457. BEGIN_INTERFACE_LIST(CHXInfoDecoder)
  458.     INTERFACE_LIST_ENTRY(IID_IHXObjInStream, IHXObjInStream)
  459. END_INTERFACE_LIST
  461. /////////////////////////////////////////////////////////////////////
  464. BOOL  CHXInfoDecoder::DecodeObj(const UCHAR* buffer, UINT32 nSize, IHXStreamableObj* pObj)
  465. {
  466. HX_ASSERT(buffer!=NULL);
  467. if (buffer==NULL)
  468.     {
  469. return(FALSE);
  470.     }
  472. this->Initialize();
  474. // Casting away the const, so we must promise not to mess with the
  475. // contents...
  476. m_Buffer = (UCHAR *)buffer;
  477. m_nDecodedLen = nSize;
  479. // ReadObj returns 0 on failure
  480. return (this->ReadObj(pObj)>0);
  481. }
  483. /////////////////////////////////////////////////////////////////////
  484. BOOL  CHXInfoDecoder::PerplexDecodeObj(const char* szPerplex, IHXStreamableObj* pObj)
  485. {
  486. if (szPerplex)
  487.     {
  488. return this->PerplexDecodeObj(szPerplex,strlen(szPerplex),pObj);
  489.     }
  490. return(FALSE);
  491. }
  493. /////////////////////////////////////////////////////////////////////
  494. // We'll unperplex the data into our own buffer, then decode the obj.
  495. BOOL  CHXInfoDecoder::PerplexDecodeObj(const char* szPerplex, UINT32 nPlexLen, IHXStreamableObj* pObj)
  496. {
  497. UINT32 nBitLen  = nPlexLen * sizeof(ULONG32) / Perplex_PER_ULONG32;
  499. UCHAR* Buffer = new UCHAR[nBitLen + 4];
  500. HX_ASSERT(Buffer!=NULL);
  501. if (Buffer==NULL) return(FALSE);
  503.     UINT32 nBitLenActual = CHXInfoDecoder::SetFromPerplex(szPerplex, Buffer, nBitLen+4, nPlexLen);
  505. BOOL bRetVal = FALSE;
  506. if (nBitLenActual==nBitLen)
  507.     {
  508. bRetVal  = this->DecodeObj(Buffer, nBitLen, pObj);
  509.     }
  511. delete [] Buffer;
  513.     return bRetVal;
  514. }
  517. /////////////////////////////////////////////////////////////////////
  518. BOOL  CHXInfoDecoder::HexDecodeObj(const char* szHex, IHXStreamableObj* pObj)
  519. {
  520. if (szHex)
  521.     {
  522. return this->HexDecodeObj(szHex,strlen(szHex),pObj);
  523.     }
  524. return(FALSE);
  525. }
  527. /////////////////////////////////////////////////////////////////////
  528. BOOL  CHXInfoDecoder::HexDecodeObj(const char* szHex, UINT32 nHexLen, IHXStreamableObj* pObj)
  529. {
  530. UINT32 nBitLen  = nHexLen>>1; // unhexed length is 1/2 of hex'd length
  532. UCHAR* Buffer=new UCHAR[nBitLen];
  533. HX_ASSERT(Buffer!=NULL);
  534. if (Buffer==NULL) return(FALSE);
  536.     UINT32 nBitLenActual = CHXInfoDecoder::SetFromHex(szHex, Buffer, nHexLen);
  538. BOOL bRetVal = FALSE;
  539. if (nBitLenActual==nBitLen)
  540.     {
  541. bRetVal  = this->DecodeObj(Buffer,nBitLen,pObj);
  542.     }
  544. delete [] Buffer;
  546.     return bRetVal;
  547. }
  549. /////////////////////////////////////////////////////////////////////
  550. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadObj(IHXStreamableObj* pObj) 
  551. {
  552. UINT32 nLen=this->GetOffset();
  553. if (pObj->ReadObjFromBits(this)==HXR_OK)
  554. return this->GetOffset()-nLen;
  556. #if 0
  557. // reading object
  558. this->Seek(nLen);
  559. #endif
  560. return(0);
  561. }
  563. /////////////////////////////////////////////////////////////////////
  564. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadUCHAR(UCHAR& nValue)
  565. {
  566.     UCHAR temp;
  567.     memcpy(&temp, m_Buffer+m_nOffset, sizeof(temp)); /* Flawfinder: ignore */
  568.     nValue = temp;
  569. m_nOffset += sizeof(temp);
  570.     return sizeof(temp);
  571. }
  575. /////////////////////////////////////////////////////////////////////
  576. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadUINT16(UINT16& nValue)
  577. {
  578.     UINT16 temp16;
  579.     memcpy(&temp16, m_Buffer+m_nOffset, sizeof(temp16)); /* Flawfinder: ignore */
  580.     nValue = WToHost(temp16);
  582. m_nOffset += sizeof(temp16);
  583.     return sizeof(temp16);
  584. }
  586. /////////////////////////////////////////////////////////////////////
  587. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadUINT32(UINT32& nValue)
  588. {
  589.     UINT32 temp32;
  590.     memcpy(&temp32, m_Buffer+m_nOffset, sizeof(temp32)); /* Flawfinder: ignore */
  591.     nValue = DwToHost(temp32);
  593. m_nOffset += sizeof(temp32);
  594.     return sizeof(temp32);
  595. }
  598. /////////////////////////////////////////////////////////////////////
  599. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadString(CHXString& strValue)
  600. {
  601.     UINT32 FieldLen = *(m_Buffer+m_nOffset++);
  603.     char* pBuffer = strValue.GetBuffer((int)FieldLen);
  604.     memcpy(pBuffer, m_Buffer+m_nOffset, (int)FieldLen); /* Flawfinder: ignore */
  605.     pBuffer[FieldLen] = '';
  606.     strValue.ReleaseBuffer();
  608. m_nOffset += FieldLen;
  610.     return FieldLen+1;
  611. }
  614. /////////////////////////////////////////////////////////////////////
  615. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadAndAllocCString(char*& pszValue)
  616. {
  617.     UINT32 FieldLen = *(m_Buffer+m_nOffset++);
  619.     pszValue = new char[FieldLen+1];
  620.     memcpy(pszValue, m_Buffer+m_nOffset, (int)FieldLen); /* Flawfinder: ignore */
  621.     pszValue[FieldLen] = '';
  623. m_nOffset += FieldLen;
  625.     return FieldLen+1;
  626. }
  628. /////////////////////////////////////////////////////////////////////
  630. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadLargeString(CHXString& strValue)
  631. {
  632.     UINT16 FieldLen = 0;
  633.     UINT32 nSize = ReadUINT16(FieldLen);
  635.     char* pBuffer = strValue.GetBuffer(FieldLen);
  636.     memcpy(pBuffer, m_Buffer+m_nOffset, FieldLen); /* Flawfinder: ignore */
  637.     pBuffer[FieldLen] = '';
  638.     strValue.ReleaseBuffer();
  640. m_nOffset += FieldLen;
  642.     return nSize+FieldLen;
  643. }
  646. /////////////////////////////////////////////////////////////////////
  647. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadAndAllocLargeCString(char*& pszValue)
  648. {
  649.     UINT16 FieldLen = 0;
  650.     UINT32 nSize = ReadUINT16(FieldLen);
  652.     pszValue = new char[FieldLen+1];
  653.     memcpy(pszValue, m_Buffer+m_nOffset, FieldLen); /* Flawfinder: ignore */
  654.     pszValue[FieldLen] = '';
  656. m_nOffset += FieldLen;
  658.     return nSize+FieldLen;
  659. }
  662. /////////////////////////////////////////////////////////////////////
  663. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadBuffer(char* szBuffer, UINT32 nSize)
  664. {
  665.     memcpy(szBuffer, m_Buffer+m_nOffset, (int)nSize); /* Flawfinder: ignore */
  666. m_nOffset += nSize;
  667.     return nSize;
  668. }
  670. #if 0
  671. /////////////////////////////////////////////////////////////////////
  672. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadUTCTime(UTCTimeRep& TimeRep)
  673. {
  674. UINT32 time, nSize;
  676. nSize = ReadUINT32(time);
  678. TimeRep.SetUTCTime(time);
  679. return(nSize);
  680. }
  681. #endif
  683. /////////////////////////////////////////////////////////////////////
  684. STDMETHODIMP CHXInfoDecoder::Seek(UINT32 nPos)
  685. {
  686. if (nPos<=m_nDecodedLen)
  687.     {
  688. m_nOffset = nPos;
  689.     }
  690. return(HXR_OK);
  691. }
  693. /////////////////////////////////////////////////////////////////////
  694. STDMETHODIMP CHXInfoDecoder::SkipForward(UINT32 nAmount)
  695. {
  696. m_nOffset += nAmount;
  698. if (m_nOffset>m_nDecodedLen)
  699.     {
  700. m_nOffset = m_nDecodedLen;
  701.     }
  702. return(HXR_OK);
  703. }
  705. /////////////////////////////////////////////////////////////////////
  706. STDMETHODIMP_(BOOL) CHXInfoDecoder::IsEndOfData()
  707. {
  708. if (m_nDecodedLen<Perplex_ALIGNMENT)
  709. {
  710. return(TRUE);
  711. }
  713. if (m_nOffset>(m_nDecodedLen-Perplex_ALIGNMENT))
  714. return(TRUE);
  715. else
  716. return(FALSE);
  717. }
  720. /////////////////////////////////////////////////////////////////////////////
  721. //
  722. // Function:
  723. //
  724. // FromHexNibble()
  725. //
  726. // Purpose:
  727. //
  728. //
  729. // Parameters:
  730. //
  731. // char hexChar
  732. // Character representing a hex encoding of a nibble.
  733. //
  734. // Return:
  735. //
  736. // UCHAR
  737. // Actual value of the nibble encoded by hexChar.
  738. //
  739. UCHAR CHXInfoDecoder::FromHexNibble(char hexChar)
  740. {
  741. UCHAR value = 0;
  742. if (hexChar >= '0' && hexChar <= '9')
  743. {
  744. value = hexChar - '0';
  745. }
  746. else if (hexChar >= 'A' && hexChar <= 'F')
  747. {
  748. value = hexChar - 'A' + 10;
  749. }
  750. else if (hexChar >= 'a' && hexChar <= 'f')
  751. {
  752. value = hexChar - 'a' + 10;
  753. }
  754. #ifdef _DEBUG
  755. else
  756. {
  757. // Bad hex character!
  758. HX_ASSERT(FALSE);
  759. }
  760. #endif
  762. return value;
  763. }
  766. /////////////////////////////////////////////////////////////////////////////
  767. //
  768. // Function:
  769. //
  770. // HXClientLicense::SetFromHex()
  771. //
  772. // Purpose:
  773. //
  774. // Sets items of the license key from a hexidecimal encoding of the
  775. // license key bits.
  776. //
  777. // Parameters:
  778. //
  779. // const char* hex
  780. // Pointer to a buffer that contains a hexidecimal encoding of the
  781. // license key.
  782. //
  783. // UCHAR* Bits
  784. // Pointer to a buffer that will be filled on output with a bitwise
  785. // decoding of the license key.
  786. //
  787. // UINT32 nSize
  788. // Size of the hex string on input
  789. //
  790. // Return:
  791. //
  792. // int
  793. // Size in bytes of decoded size!
  794. //
  795. // Note:
  796. //
  797. //  Hex representations of the License Key consist of the
  798. //  representation of the bits in human readable form in a
  799. //  HEX encoding. This basically uses a pointer to a memory
  800. //  buffer of charcters encoded as hex representing the bits.
  801. //  Valid characters are 0-9,A-F. Buffers out will be upper
  802. //  case letters, buffers in will be converted to upper case.
  803. //
  804. //  These char's are hex encoding. They are never DBCS, the only
  805. // valid characters are 0-9,A-F
  806. //
  807. UINT32 CHXInfoDecoder::SetFromHex(const char* hex, UCHAR* Bits, UINT32 nSize)
  808. {
  809. UINT32 ndxBits;
  810. UINT32 ndxHex = 0;
  811. UCHAR nibble1;
  812. UCHAR nibble2;
  813. UCHAR byte;
  815. for (ndxBits = 0; ndxHex < nSize; ndxBits++)
  816. {
  817. nibble1 = FromHexNibble(hex[ndxHex]);
  818. nibble1 = nibble1 << 4;
  819. ndxHex++;
  820. nibble2 = FromHexNibble(hex[ndxHex]);
  821. byte = nibble1 | nibble2;
  822. ndxHex++;
  823. Bits[ndxBits] = byte;
  824. }
  825. return ndxBits;
  826. }
  828. /////////////////////////////////////////////////////////////////////////////
  829. //
  830. // Function:
  831. //
  832. // ToHexNibble()
  833. //
  834. // Purpose:
  835. //
  836. // Converts a nibble into the appropriate character for Hex encoding.
  837. //
  838. // Parameters:
  839. //
  840. // UCHAR hexValue
  841. // Value of the nibble.
  842. //
  843. // Return:
  844. //
  845. // char
  846. // Character representing the hex encoding of the nibble.
  847. //
  848. char CHXInfoEncoder::ToHexNibble(UCHAR hexValue)
  849. {
  850. char hexChar = '0';
  852. if (hexValue <= 0x9)
  853. {
  854. hexChar = '0' + hexValue;
  855. }
  856. else if (hexValue >= 0xA && hexValue <= 0xF)
  857. {
  858. hexChar = 'A' + (hexValue - 10);
  859. }
  860. #ifdef _DEBUG
  861. else
  862. {
  863. // Bad hex character!
  864. HX_ASSERT(FALSE);
  865. }
  866. #endif
  868. return hexChar;
  869. }
  871. /////////////////////////////////////////////////////////////////////////////
  872. //
  873. // Function:
  874. //
  875. // DumpToHex()
  876. //
  877. // Purpose:
  878. //
  879. // Formats the license key in human readable hexadecimal encoding.
  880. //
  881. // Parameters:
  882. //
  883. // char* hex
  884. // Pointer to buffer to be filled with hexadecimal encoding of
  885. // license key
  886. //
  887. // Return:
  888. //
  889. // None.
  890. //
  891. void CHXInfoEncoder::DumpToHex(char* hex, UCHAR* Bits, UINT32 nSize)
  892. {
  893. UINT32 ndxBits;
  894. UINT32 ndxHex = 0;
  895. UCHAR nibble1;
  896. UCHAR nibble2;
  897. UCHAR byte;
  899. for (ndxBits = 0; ndxBits < nSize; ndxBits++)
  900. {
  901. byte = Bits[ndxBits];
  902. nibble1 = (byte & 0xF0) >> 4;
  903. nibble2 = (byte & 0x0F);
  905. hex[ndxHex] = ToHexNibble(nibble1);
  906. ndxHex++;
  907. hex[ndxHex] = ToHexNibble(nibble2);
  908. ndxHex++;
  909. }
  910. hex[ndxHex] = '';
  911. }
  913. /////////////////////////////////////////////////////////////////////////////
  914. //
  915. // Function:
  916. //
  917. // MapFromPerplex()
  918. //
  919. // Purpose:
  920. //
  921. // Converts appropriate characters for Perplex encoding into a ULONG32.
  922. //
  923. #ifdef _WIN16
  924. extern char* zPerplexChars;
  925. #else
  926. // A copy of this is kept in in pnmiscpubwinpnmisc16.h.  If you change 
  927. // this (which is very unlikely), then be sure to change it there.  
  928. static const char zPerplexChars[] =
  929. {
  930. '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  931. 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
  932. 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
  933. 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D',
  934. 'E'
  935. };
  937. static const char zDePerplexMap[] = 
  938. { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  939. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  940. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  941. 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,
  942. 0,36,37,38,39,40,0,0,0,0,0,0,0,0,0,0,
  943. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  944. 0,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
  945. 25,26,27,28,29,30,31,32,33,34,35,0,0,0,0,0,
  946. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  947. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  948. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  949. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  950. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  951. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  952. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  953. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  954. };
  956. #endif /* _WIN16 */
  958. UCHAR CHXInfoDecoder::MapFromPerplex(char Perplex)
  959. {
  960.     return zDePerplexMap[Perplex];
  961. }
  963. /////////////////////////////////////////////////////////////////////////////
  964. //
  965. // Function:
  966. //
  967. // MapToPerplex()
  968. //
  969. // Purpose:
  970. //
  971. // Converts a digit ordinal to the Perplex digit...
  972. //
  973. char CHXInfoEncoder::MapToPerplex(UCHAR Perplex)
  974. {                                                  
  975. #ifdef _DEBUG
  976. #ifndef _WIN16
  977. // On win16, zPerplexChars is a char *, rather than an array, so this
  978. // doesn't work.
  979. int size_zPerplexChars  = sizeof(zPerplexChars); 
  980. int size_zPerplexChars0 = sizeof(zPerplexChars[0]);
  981. HX_ASSERT(Perplex < size_zPerplexChars/size_zPerplexChars0);
  982. #endif
  983. #endif
  984. return zPerplexChars[Perplex];
  985. }
  987. /////////////////////////////////////////////////////////////////////////////
  988. //
  989. // Function:
  990. //
  991. // FromPerplex()
  992. //
  993. // Purpose:
  994. //
  995. // Converts appropriate characters for Perplex encoding into a ULONG32.
  996. //
  997. ULONG32 CHXInfoDecoder::FromPerplex(const char* Perplex)
  998. {
  999. ULONG32 value = 0;
  1000. ULONG32 PerplexBase = 1;
  1002. for (int n = 0; n < Perplex_PER_ULONG32; n++)
  1003. {
  1004. value += MapFromPerplex(Perplex[n]) * PerplexBase;
  1005. PerplexBase *= Perplex_BASE;
  1006. }
  1008. // Convert to local byte order!
  1009. value = DwToHost(value);
  1011. return value;
  1012. }
  1014. /////////////////////////////////////////////////////////////////////////////
  1015. //
  1016. // Function:
  1017. //
  1018. // ToPerplexNibble()
  1019. //
  1020. // Purpose:
  1021. //
  1022. // Converts a ULONG32 into the appropriate characters for Perplex encoding.
  1023. //
  1024. void CHXInfoEncoder::ToPerplex(ULONG32 Input, char* Perplex)
  1025. {
  1026. ULONG32 value;
  1027. UCHAR charValue;
  1029. // Convert to net byte order!
  1030. value = DwToNet(Input);
  1032. for (int n = 0; n < Perplex_PER_ULONG32; n++)
  1033. {
  1034. charValue = (UCHAR)(value % Perplex_BASE);
  1035. Perplex[n] = MapToPerplex(charValue);
  1036. value = value / Perplex_BASE;
  1037. }
  1038. }
  1040. /////////////////////////////////////////////////////////////////////////////
  1041. //
  1042. // Function:
  1043. //
  1044. // HXClientLicense::SetFromPerplex()
  1045. //
  1046. // Purpose:
  1047. //
  1048. // Sets items of the license key from a Perplexidecimal encoding of the
  1049. // license key bits.
  1050. //
  1051. // Parameters:
  1052. //
  1053. // const char* Perplex
  1054. // Pointer to a buffer that contains a Perplexidecimal encoding of the
  1055. // license key.
  1056. //
  1057. // UCHAR* Bits
  1058. // Pointer to a buffer that will contain decoded bytes of information
  1059. //
  1060. //              UINT32 ulBitsLen
  1061. //              Number of bytes in Bits output buffer
  1062. //
  1063. // int nSize
  1064. // Input size in bytes
  1065. //
  1066. // Return:
  1067. //
  1068. // int
  1069. // Size in bytes of decoded information
  1070. //
  1071. // Note:
  1072. //
  1073. //  Perplex representations of the License Key consist of the
  1074. //  representation of the bits in human readable form in a
  1075. //  Perplex encoding. This basically uses a pointer to a memory
  1076. //  buffer of charcters encoded as Perplex representing the bits.
  1077. //  Valid characters are 0-9,A-F. Buffers out will be upper
  1078. //  case letters, buffers in will be converted to upper case.
  1079. //
  1080. //  These char's are Perplex encoding. They are never DBCS, the only
  1081. // valid characters are 0-9,A-F
  1082. //
  1083. UINT32 CHXInfoDecoder::SetFromPerplex(const char* Perplex, UCHAR* Bits, UINT32 ulBitsLen, UINT32 nSize)
  1084. {
  1085. UINT32 ndxBits;
  1086. UINT32 ndxPerplex = 0;
  1087. ULONG32 temp32;
  1089. for (ndxBits = 0; ndxPerplex < nSize; )
  1090. {
  1091. temp32 = FromPerplex(&Perplex[ndxPerplex]);
  1092. ndxPerplex+=Perplex_PER_ULONG32;
  1093. if (ndxBits+4 <= ulBitsLen) memcpy(&Bits[ndxBits],&temp32,sizeof(temp32)); /* Flawfinder: ignore */
  1094. ndxBits+=sizeof(temp32);
  1095. }
  1096. return ndxBits;
  1097. }
  1099. /////////////////////////////////////////////////////////////////////////////
  1100. //
  1101. // Function:
  1102. //
  1103. // DumpToPerplex()
  1104. //
  1105. // Purpose:
  1106. //
  1107. // Formats the license key in human readable Perplexadecimal encoding.
  1108. //
  1109. // Parameters:
  1110. //
  1111. // char* Perplex
  1112. // Pointer to buffer to be filled with Perplexadecimal encoding of
  1113. // license key
  1114. //
  1115. // Return:
  1116. //
  1117. // None.
  1118. //
  1119. void CHXInfoEncoder::DumpToPerplex(char* Perplex, UINT32 ulPerplexSize, UCHAR* Bits, UINT32 nSize)
  1120. {
  1121. UINT32 ndxBits;
  1122. UINT32 ndxPerplex = 0;
  1123. ULONG32 temp32;
  1125. for (ndxBits = 0; ndxBits < nSize; )
  1126. {
  1127. if (ndxBits+4 <= nSize) memcpy(&temp32,&Bits[ndxBits],sizeof(temp32)); /* Flawfinder: ignore */
  1128.                 ndxBits+=sizeof(temp32);
  1129. if (ndxPerplex+Perplex_PER_ULONG32 <= ulPerplexSize) ToPerplex(temp32,&Perplex[ndxPerplex]);
  1130. ndxPerplex+=Perplex_PER_ULONG32;
  1131. }
  1132. Perplex[ndxPerplex] = '';
  1133. }
  1137. /////////////////////////////////////////////////////////////////////////////
  1138. //
  1139. // Function:
  1140. //
  1141. // MapFromMIMEBase64()
  1142. //
  1143. // Purpose:
  1144. //
  1145. // Converts appropriate characters for MIME-Base64 encoding into a the
  1146. // Base64 ordinal.
  1147. //
  1148. #ifdef _WIN16
  1149. extern char* zMIMEBase64Chars;
  1150. #else
  1151. // A copy of this is kept in in pnmiscpubwinpnmisc16.h.  If you change 
  1152. // this (which is very unlikely), then be sure to change it there.  
  1153. static const char zMIMEBase64Chars[] =
  1154. {
  1155. 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
  1156. 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
  1157. 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
  1158. 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
  1159. 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
  1160. 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
  1161. '8', '9', '+', '/'
  1162. };
  1163. #endif /* _WIN16 */
  1165. #define MIME_BASE64_PADDING '='
  1166. #define FROM_MIME_BASE64_BYTES_IN 4
  1167. #define FROM_MIME_BASE64_BYTES_OUT 3
  1168. #define TO_MIME_BASE64_BYTES_IN FROM_MIME_BASE64_BYTES_OUT
  1169. #define TO_MIME_BASE64_BYTES_OUT FROM_MIME_BASE64_BYTES_IN
  1171. UCHAR CHXInfoDecoder::MapFromMIMEBase64(char MIMEBase64)
  1172. {
  1173. for (UCHAR n = 0; n < sizeof(zMIMEBase64Chars)/sizeof(zMIMEBase64Chars[0]); n++)
  1174. {
  1175. if (MIMEBase64 == zMIMEBase64Chars[n])
  1176. {
  1177. return n;
  1178. }
  1179. }
  1180. HX_ASSERT(FALSE);
  1181. return 0;
  1182. }
  1184. /////////////////////////////////////////////////////////////////////////////
  1185. //
  1186. // Function:
  1187. //
  1188. // MapToMIMEBase64()
  1189. //
  1190. // Purpose:
  1191. //
  1192. // Converts a digit ordinal to the MIMEBase64 digit...
  1193. //
  1194. char CHXInfoEncoder::MapToMIMEBase64(UCHAR MIMEBase64)
  1195. {
  1196. HX_ASSERT( MIMEBase64 < sizeof(zMIMEBase64Chars)/sizeof(zMIMEBase64Chars[0]));
  1197. return zMIMEBase64Chars[MIMEBase64];
  1198. }
  1200. /////////////////////////////////////////////////////////////////////////////
  1201. //
  1202. // Function:
  1203. //
  1204. // SetFromMIMEBase64()
  1205. //
  1206. // Purpose:
  1207. //
  1208. // ...
  1209. //
  1210. // Parameters:
  1211. //
  1212. // ...
  1213. //
  1214. // Return:
  1215. //
  1216. // int
  1217. // Size in bytes of decoded information
  1218. //
  1219. UINT32 CHXInfoDecoder::SetFromMIMEBase64(const char* MIMEBase64, char* Bits, UINT32 nSize)
  1220. {
  1221. UINT32 ndxBits = 0;
  1222. UINT32 ndxMIMEBase64 = 0;
  1223. BOOL bDone = FALSE;
  1224. UINT32 ndxTempIn = 0;
  1225. UCHAR tempBitsIn [FROM_MIME_BASE64_BYTES_IN];
  1226. UINT32 padding = 0;
  1228. HX_ASSERT(strlen(MIMEBase64) <= nSize);
  1230. while (!bDone)
  1231. {
  1232. HX_ASSERT(ndxMIMEBase64 <= nSize);
  1233. HX_ASSERT(ndxBits <= nSize);
  1235. // Fill in our "temporary" in buffer with the Base64 characters.
  1236. for ( ndxTempIn = 0;
  1237. ndxTempIn < FROM_MIME_BASE64_BYTES_IN && (padding == 0);
  1238. ndxTempIn++
  1239. )
  1240. {
  1241. HX_ASSERT(ndxMIMEBase64 <= nSize);
  1243. UCHAR MIMEBase64char = MIMEBase64[ndxMIMEBase64];
  1245. switch (MIMEBase64char)
  1246. {
  1247. case MIME_BASE64_PADDING:
  1248. case '':
  1249. {
  1250. tempBitsIn[ndxTempIn] = 0;
  1251. bDone = TRUE;
  1252. padding = (FROM_MIME_BASE64_BYTES_IN - ndxTempIn);
  1253. }
  1254. break;
  1256. default:
  1257. {
  1258. tempBitsIn[ndxTempIn] = MapFromMIMEBase64(MIMEBase64char);
  1259. }
  1260. break;
  1261. }
  1262. ndxMIMEBase64++;
  1263. }
  1265. HX_ASSERT(padding == 2 || padding == 1 || padding == 0);
  1267. // Map the Base64 in buffer to the the output buffer...
  1268. // This should map the 6 pertinate bits of each IN byte, to the
  1269. // the correct bits of the OUT byte.
  1270. {
  1271. Bits[ndxBits] = (tempBitsIn[0] << 2) + (tempBitsIn[1]>>4);
  1272. ndxBits++;
  1274. if (padding < 2)
  1275. {
  1276. Bits[ndxBits] = (tempBitsIn[1] << 4) + (tempBitsIn[2]>>2);
  1277. ndxBits++;
  1278. }
  1280. if (padding < 1)
  1281. {
  1282. Bits[ndxBits] = (tempBitsIn[2] << 6) + (tempBitsIn[3]);
  1283. ndxBits++;
  1284. }
  1285. }
  1286. }
  1288. Bits[ndxBits] = '';
  1290. return ndxBits;
  1291. }
  1293. /////////////////////////////////////////////////////////////////////////////
  1294. //
  1295. // Function:
  1296. //
  1297. // DumpToMIMEBase64()
  1298. //
  1299. // Purpose:
  1300. //
  1301. // ...
  1302. //
  1303. // Parameters:
  1304. //
  1305. // ...
  1306. //
  1307. // Return:
  1308. //
  1309. // None.
  1310. //
  1311. void CHXInfoEncoder::DumpToMIMEBase64(char* MIMEBase64, const char* Bits, UINT32 nSize)
  1312. {
  1313. UINT32 ndxBits = 0;
  1314. UINT32 ndxMIMEBase64 = 0;
  1315. BOOL bDone = FALSE;
  1316. UINT32 ndxTempIn = 0;
  1317. UINT32 ndxTempOut = 0;
  1318. UCHAR tempBitsIn [TO_MIME_BASE64_BYTES_IN];
  1319. UINT32 padding = 0;
  1321. HX_ASSERT(strlen(Bits) <= nSize);
  1323. while (!bDone)
  1324. {
  1325. HX_ASSERT(ndxMIMEBase64 <= nSize);
  1326. HX_ASSERT(ndxBits <= nSize);
  1328. // Fill in our "temporary" out buffer with the 6 bit chunks of the input.
  1329. for ( ndxTempIn = 0;
  1330. ndxTempIn < TO_MIME_BASE64_BYTES_IN && (padding == 0);
  1331. ndxTempIn++
  1332. )
  1333. {
  1334. UCHAR rawChar = Bits[ndxBits];
  1336. if (rawChar != '')
  1337. {
  1338. switch (ndxTempIn)
  1339. {
  1340. case 0:
  1341. {
  1342. tempBitsIn[0] = rawChar >> 2;
  1343. tempBitsIn[1] = (rawChar & 0x3) << 4;
  1344. }
  1345. break;
  1347. case 1:
  1348. {
  1349. tempBitsIn[1] += rawChar >> 4;
  1350. tempBitsIn[2] = (rawChar & 0xF) << 2;
  1351. }
  1352. break;
  1354. case 2:
  1355. {
  1356. tempBitsIn[2] += rawChar >> 6;
  1357. tempBitsIn[3] = (rawChar & 0x3F);
  1358. }
  1359. break;
  1360. }
  1361. }
  1362. else
  1363. {
  1364. bDone = TRUE;
  1365. padding = (TO_MIME_BASE64_BYTES_IN - ndxTempIn);
  1366. }
  1367. ndxBits++;
  1368. }
  1370. HX_ASSERT(padding == 2 || padding == 1 || padding == 0);
  1372. // Map the Base64 in buffer to the output buffer...
  1373. // This should map the 6 pertinate bits of each IN byte, as an
  1374. // entire OUT byte
  1375. for ( ndxTempOut = 0;
  1376. ndxTempOut < TO_MIME_BASE64_BYTES_OUT;
  1377. ndxTempOut++
  1378. )
  1379. {
  1380. if (ndxTempOut < (TO_MIME_BASE64_BYTES_OUT-padding))
  1381. {
  1382. MIMEBase64[ndxMIMEBase64] = MapToMIMEBase64(tempBitsIn[ndxTempOut]);
  1383. }
  1384. else
  1385. {
  1386. MIMEBase64[ndxMIMEBase64] = MIME_BASE64_PADDING;
  1387. }
  1388. ndxMIMEBase64++;
  1389. }
  1391. }
  1393. MIMEBase64[ndxMIMEBase64] = '';
  1394. }
  1398. //*******************************************************************
  1399. //  CHXSimpleBuffer
  1400. //*******************************************************************
  1403. /////////////////////////////////////////////////////////////////////
  1404. CHXSimpleBuffer::CHXSimpleBuffer()
  1405. :  m_nSize(0), m_pData(NULL), m_nGrowBy(DEFAULT_GROW_SIZE)
  1406. {
  1407. }
  1409. /////////////////////////////////////////////////////////////////////
  1410. CHXSimpleBuffer::CHXSimpleBuffer(UINT32 nSize, UINT32 nGrowBy)
  1411. :  m_nSize(0), m_pData(NULL), m_nGrowBy(nGrowBy)
  1412. {
  1413. Resize(nSize);
  1414. }
  1416. /////////////////////////////////////////////////////////////////////
  1417. CHXSimpleBuffer::~CHXSimpleBuffer()
  1418. {
  1419. Free();
  1420. }
  1423. /////////////////////////////////////////////////////////////////////
  1424. BOOL CHXSimpleBuffer::IsValidOffset(UINT32 n) const
  1425. {
  1426. if (n<m_nSize)
  1427. return(TRUE);
  1428. else return(FALSE);
  1429. }
  1432. /////////////////////////////////////////////////////////////////////
  1433. // make sure that pPos is in the buffer.
  1434. // If not, the buffer is automatically resized and contents copied.
  1435. // pPos must be > pData.
  1436. BOOL CHXSimpleBuffer::EnsureValidOffset(UINT32 n)
  1437. {
  1438. if (IsValidOffset(n)==TRUE)
  1439.     {
  1440. return(TRUE);
  1441.     }
  1443. return (this->Resize(n));
  1444. }
  1447. /////////////////////////////////////////////////////////////////////
  1448. // copy data into the buffer at the given offset, and if the buffer
  1449. // is too small we'll resize the buffer first.
  1450. BOOL CHXSimpleBuffer::SafeMemCopy(UINT32 nOffset, const void* data, UINT32 len)
  1451. {
  1452.     if ((len > 0) && (EnsureValidOffset(nOffset+len-1)==TRUE))
  1453.     {
  1454.      memcpy( m_pData+nOffset, data, (int)len ); /* Flawfinder: ignore */
  1455. return(TRUE);
  1456.     }
  1458.     return(FALSE);
  1459. }
  1462. /////////////////////////////////////////////////////////////////////
  1463. BOOL CHXSimpleBuffer::Resize(UINT32 nNewSize)
  1464. {
  1465. if (nNewSize==0)
  1466.     {
  1467. Free();
  1468. return(TRUE);
  1469.     }
  1471. nNewSize = RoundUpToGrowSize(nNewSize);
  1473. UCHAR* pNewBuffer = new UCHAR[nNewSize];
  1474. if (pNewBuffer==NULL) return(FALSE);
  1477. if (m_pData!=NULL)
  1478.     {
  1479. // copy MIN(oldSize,newSize) elements
  1480. memcpy(pNewBuffer,m_pData, (nNewSize<m_nSize) ? (int)nNewSize : (int)m_nSize); /* Flawfinder: ignore */
  1481. delete [] m_pData;
  1482.     }
  1484. m_pData = pNewBuffer;
  1485. m_nSize = nNewSize;
  1487. return(TRUE);
  1488. }
  1491. /////////////////////////////////////////////////////////////////////
  1492. UINT32 CHXSimpleBuffer::RoundUpToGrowSize(UINT32 nSize)
  1493. {
  1494. // check for div-by-zero errors (as long as DEFAULT!=0)
  1495. if (m_nGrowBy==0)
  1496. {
  1497. m_nGrowBy = DEFAULT_GROW_SIZE;
  1498. }
  1500. return ( (int)(nSize/m_nGrowBy)+1 ) * m_nGrowBy;
  1501. }
  1504. /////////////////////////////////////////////////////////////////////
  1505. void CHXSimpleBuffer::Free()
  1506. {
  1507. if (m_pData!=NULL)
  1508. delete [] m_pData;
  1510. m_pData=NULL;
  1511. m_nSize=0;
  1512. }