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

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

Symbian

开发平台：

C/C++

hxinfcod.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. /****************************************************************************
  37.  *
  38.  * This file contains implementation of classes that support
  39.  * the encoding of raw bytes of upgrade negotiation messages
  40.  * into a clear text representaion of the raw data.
  41.  *
  42.  */
  44. #include "hxinfcod.h"
  45. #include "hxassert.h"
  46. #include "hlxclib/string.h"
  47. //#include "hlxclib/stdio.h"
  48. #include "netbyte.h"
  49. #include "hxheap.h"
  51. #ifdef _DEBUG
  52. #undef HX_THIS_FILE
  53. static const char HX_THIS_FILE[] = __FILE__;
  54. #endif
  57. /////////////////////////////////////////////////////////////////////
  58. static UINT16  FourByteAlign(UINT16 number)
  59. {
  60. return( ((number+3)>>2)<<2 );
  61. }
  64. //*******************************************************************
  65. // CHXInfoEncoder
  66. //*******************************************************************
  68. // IUnknown interface listing
  69. BEGIN_INTERFACE_LIST(CHXInfoEncoder)
  70.     INTERFACE_LIST_ENTRY(IID_IHXObjOutStream, IHXObjOutStream)
  71. END_INTERFACE_LIST
  73. /////////////////////////////////////////////////////////////////////
  74. CHXInfoEncoder::CHXInfoEncoder()
  75. {
  76. m_FinalBuffer = NULL;
  77. m_bFinalBufferAllocFlag = FALSE;
  78. m_nFinalLen = 0;
  80. m_nOffset = 0;
  81. }
  83. /////////////////////////////////////////////////////////////////////
  84. // get ptr to encoded data - either the data buffer that's been Dump()'d
  85. // to, or a secondary buffer where data was further encoded (ie,
  86. // Hex'd or perplex'd).
  87. STDMETHODIMP_(const char*) CHXInfoEncoder::GetBuffer()
  88. {
  89. if (m_FinalBuffer)
  90. return((char*)m_FinalBuffer);
  92. return((char*)m_Buffer.GetPtr());
  93. }
  96. /////////////////////////////////////////////////////////////////////
  97. STDMETHODIMP_(UINT32) CHXInfoEncoder::GetLength()
  98. {
  99. if (m_FinalBuffer)
  100. return(m_nFinalLen);
  102. return(m_nOffset);
  103. }
  106. /////////////////////////////////////////////////////////////////////
  107. CHXInfoEncoder::~CHXInfoEncoder()
  108. {
  109. if ( (m_bFinalBufferAllocFlag==TRUE) && (m_FinalBuffer!=NULL) )
  110.     {
  111. delete [] m_FinalBuffer;
  112.     }
  113. }
  116. /////////////////////////////////////////////////////////////////////
  117. void CHXInfoEncoder::EncodeObj(IHXStreamableObj* pObj)
  118. {
  119. this->Initialize();
  120. this->WriteObj(pObj);
  121. }
  124. /////////////////////////////////////////////////////////////////////
  125. void CHXInfoEncoder::PerplexEncodeObj(IHXStreamableObj* pObj)
  126. {
  127. this->Initialize();
  128. this->WriteObj(pObj);
  129. this->Perplex();
  130. }
  132. /////////////////////////////////////////////////////////////////////
  133. BOOL CHXInfoEncoder::Perplex()
  134. {
  135. // no data to perplex?
  136. if (m_nOffset==0) return(FALSE);
  138. // if final buffer already exists, return error.....
  139. // That means we already did an encoding, and the user should
  140. // call Initialize() before the encoder is reused.
  141. if (m_FinalBuffer!=NULL) return(FALSE);
  143. // Make sure we're 4byte aligned. Needed by Perplex alg.
  144.     UINT32 nAlign =  (m_nOffset) % sizeof(ULONG32);
  146.     if (nAlign > 0)
  147.     {
  148. m_Buffer.EnsureValidOffset(m_nOffset+sizeof(ULONG32)-nAlign);
  149. for (; nAlign < sizeof(ULONG32); nAlign++)
  150. {
  151. m_Buffer.SetUCHAR(m_nOffset++,0);
  152. }
  153.     }
  155. // calc size of Perplexed buffer.
  156.     m_nFinalLen = m_nOffset * Perplex_PER_ULONG32 / sizeof(ULONG32);
  158. // alloc mem for final perplexed buffer
  159. // Add one to length 'cause low level perplex adds
  160. // a '' to the resulting string
  161. m_bFinalBufferAllocFlag = TRUE;
  162. m_FinalBuffer = new UCHAR[m_nFinalLen+1];
  163. HX_ASSERT(m_FinalBuffer!=NULL);
  165.     if( m_FinalBuffer==NULL)
  166.     {
  167. m_nFinalLen=0;
  168. return(FALSE);
  169.     }
  170. else
  171.     {
  172.         CHXInfoEncoder::DumpToPerplex((char*)m_FinalBuffer, m_nFinalLen+1, m_Buffer.GetPtr(), m_nOffset);
  173.     }
  175. return(TRUE);
  176. }
  179. /////////////////////////////////////////////////////////////////////
  180. void CHXInfoEncoder::HexEncodeObj(IHXStreamableObj* pObj)
  181. {
  182. this->Initialize();
  183. this->WriteObj(pObj);
  184. this->Hex();
  185. }
  187. /////////////////////////////////////////////////////////////////////
  188. BOOL CHXInfoEncoder::Hex()
  189. {
  190. // no data to perplex?
  191. if (m_nOffset==0) return(FALSE);
  193. // if final buffer already exists, return error.....
  194. // That means we already did an encoding, and the user should
  195. // call Initialize() before the encoder is reused.
  196. if (m_FinalBuffer!=NULL) return(FALSE);
  198. // calc size of hexed buffer.
  199.     m_nFinalLen = m_nOffset * 2;
  201. // alloc mem for final perplexed buffer
  202. m_bFinalBufferAllocFlag = TRUE;
  203. // Add one to length 'cause low level perplex adds
  204. // a '' to the resulting string
  205. m_FinalBuffer = new UCHAR[m_nFinalLen+1];
  206. HX_ASSERT(m_FinalBuffer!=NULL);
  208.     if( m_FinalBuffer==NULL)
  209.     {
  210. m_nFinalLen=0;
  211. return(FALSE);
  212.     }
  213. else
  214.     {
  215.         CHXInfoEncoder::DumpToHex((char*)m_FinalBuffer, m_Buffer.GetPtr(), m_nOffset);
  216.     }
  218. return(TRUE);
  219. }
  222. /////////////////////////////////////////////////////////////////////
  223. STDMETHODIMP CHXInfoEncoder::Initialize()
  224. {
  225. if (m_bFinalBufferAllocFlag==TRUE)
  226.     {
  227. if (m_FinalBuffer!=NULL)
  228. delete [] m_FinalBuffer;
  229.     }
  230. m_bFinalBufferAllocFlag = FALSE;
  231. m_FinalBuffer = NULL;
  232. m_nFinalLen    = 0;
  234. m_Buffer.Free();
  235. m_nOffset=0;
  237. return(HXR_OK);
  238. }
  240. /////////////////////////////////////////////////////////////////////
  241. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteObj(IHXStreamableObj* pObj) 
  242. {
  243. UINT32 nLen=this->GetOffset();
  245. if (pObj->WriteObjToBits(this)==HXR_OK)
  246. return this->GetOffset()-nLen;
  248. #if 0
  249. // reading object
  250. this->Seek(nLen);
  251. #endif
  252. return(0);
  253. }
  255. /////////////////////////////////////////////////////////////////////
  256. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUCHAR(UCHAR nValue)
  257. {
  258.     m_Buffer.SafeMemCopy(m_nOffset,&nValue, sizeof(nValue));
  259. m_nOffset += sizeof(nValue);
  260.     return sizeof(nValue);
  261. }
  265. /////////////////////////////////////////////////////////////////////
  266. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUINT16(UINT16 nValue)
  267. {
  268.     UINT16 temp16 = WToNet(nValue);
  270.     m_Buffer.SafeMemCopy(m_nOffset,&temp16, sizeof(temp16));
  272. m_nOffset += sizeof(temp16);
  273.     return sizeof(temp16);
  274. }
  276. /////////////////////////////////////////////////////////////////////
  277. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUINT32(UINT32 nValue)
  278. {
  279.     UINT32 temp32 = DwToNet(nValue);
  281. m_Buffer.SafeMemCopy(m_nOffset, &temp32, sizeof(temp32));
  283. m_nOffset += sizeof(temp32);
  284.     return sizeof(temp32);
  285. }
  287. /////////////////////////////////////////////////////////////////////
  288. // Dump at a specific position. Doesn't advance offset pointer
  289. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUINT16At(UINT32 nOffset, UINT16 nValue)
  290. {
  291.     UINT16 temp16 = WToNet(nValue);
  293. if (m_Buffer.IsValidOffset(nOffset+sizeof(temp16))==TRUE)
  294.     {
  295.      m_Buffer.MemCopy(nOffset,&temp16, sizeof(temp16));
  296.     }
  298.     return sizeof(temp16);
  299. }
  301. /////////////////////////////////////////////////////////////////////
  302. // Dump at a specific position. Doesn't advance offset pointer
  303. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUINT32At(UINT32 nOffset, UINT32 nValue)
  304. {
  305.     UINT32 temp32 = DwToNet(nValue);
  307. if (m_Buffer.IsValidOffset(nOffset+sizeof(temp32))==TRUE)
  308.     {
  309. m_Buffer.MemCopy(nOffset, &temp32, sizeof(temp32));
  310.     }
  312.     return sizeof(temp32);
  313. }
  316. /////////////////////////////////////////////////////////////////////
  317. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteString(const char* szValue)
  318. {
  319. if (szValue==NULL)
  320.     {
  321. szValue="";
  322.     }
  324.     UINT32 FieldLen = strlen(szValue);
  325.     HX_ASSERT(FieldLen < 0xFF);
  327. // ensure the buffer has enough room for us.
  328. if (m_Buffer.EnsureValidOffset(m_nOffset+FieldLen+1)==TRUE)
  329.     {
  330. m_Buffer.SetUCHAR(m_nOffset, (UCHAR)FieldLen );
  331.         m_Buffer.MemCopy(m_nOffset + 1, szValue, FieldLen);
  332.     }
  334.     FieldLen ++; //account for first SIZE byte
  336. m_nOffset += FieldLen;
  337.     return FieldLen;
  338. }
  341. /////////////////////////////////////////////////////////////////////
  342. // Similar to DumpString, except this one is handy when you need
  343. // to concat 2 or 3 strings and Dump them. Instead of allocating
  344. // a buffer, concating the strings and calling DumpString, use
  345. // this routine instead. It will take 2 or 3 strings as a parameters,
  346. // and dump them concatenated. The original strings are not modified.
  347. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteStringCat(const char* szValue1,const char* szValue2,const char* szValue3)
  348. {
  349. if (szValue1==NULL) { szValue1=""; }
  350. if (szValue2==NULL) { szValue2=""; }
  351. if (szValue3==NULL) { szValue3=""; }
  353.     UINT16 nLen1=strlen(szValue1);
  354.     UINT16 nLen2=strlen(szValue2);
  355.     UINT16 nLen3=strlen(szValue3);
  357.     UINT32 FieldLen = nLen1 + nLen2 + nLen3;
  359.     HX_ASSERT(FieldLen < 0xFF);
  361. // ensure the buffer has enough room for us.
  362. if (m_Buffer.EnsureValidOffset(m_nOffset+FieldLen+1)==TRUE)
  363.     {
  364. m_Buffer.SetUCHAR(m_nOffset, (UCHAR)FieldLen );
  365. m_nOffset++;
  367. if (nLen1)
  368.         {
  369.         m_Buffer.MemCopy(m_nOffset, szValue1, nLen1);
  370. m_nOffset+=nLen1;
  371.         }
  373. if (nLen2)
  374.         {
  375.         m_Buffer.MemCopy(m_nOffset, szValue2, nLen2);
  376. m_nOffset+=nLen2;
  377.         }
  379. if (nLen3)
  380.         {
  381.         m_Buffer.MemCopy(m_nOffset, szValue3, nLen3);
  382. m_nOffset+=nLen3;
  383.         }
  384.     }
  386.     FieldLen ++; //account for first SIZE byte
  387.     return FieldLen;
  388. }
  391. /////////////////////////////////////////////////////////////////////
  392. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteLargeString(const char* szValue)
  393. {
  394. if (szValue==NULL)
  395.     {
  396. szValue="";
  397.     }
  399. // get the length of the string
  400.     UINT32 FieldLen = strlen(szValue);
  401.     HX_ASSERT(FieldLen < 0xFFFF);
  403. // dump the size (this increments m_nOffset for us too)
  404. UINT32 nSize = WriteUINT16((UINT16)FieldLen);
  406.     m_Buffer.SafeMemCopy(m_nOffset, szValue, FieldLen);
  407. m_nOffset += FieldLen;
  409.     return (FieldLen+nSize);
  410. }
  413. /////////////////////////////////////////////////////////////////////
  414. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteBuffer(const char* szBuffer, UINT32 nSize)
  415. {
  416. HX_ASSERT(szBuffer!=NULL);
  418. if (szBuffer!=NULL)
  419.     {
  420.      m_Buffer.SafeMemCopy(m_nOffset, szBuffer, nSize);
  421.     }
  423. m_nOffset += nSize;
  424.     return (nSize);
  425. }
  427. #if 0
  428. /////////////////////////////////////////////////////////////////////
  429. STDMETHODIMP_(UINT32) CHXInfoEncoder::WriteUTCTime(UTCTimeRep& TimeRep)
  430. {
  431. return(this->WriteUINT32( TimeRep.asUTCTimeT() ));
  433. //    return this->WriteString(( TimeRep.asUTCString() );
  434. }
  435. #endif
  438. //*******************************************************************
  439. // CHXInfoDecoder
  440. //*******************************************************************
  442. // IUnknown interface listing
  443. BEGIN_INTERFACE_LIST(CHXInfoDecoder)
  444.     INTERFACE_LIST_ENTRY(IID_IHXObjInStream, IHXObjInStream)
  445. END_INTERFACE_LIST
  447. /////////////////////////////////////////////////////////////////////
  450. BOOL  CHXInfoDecoder::DecodeObj(const UCHAR* buffer, UINT32 nSize, IHXStreamableObj* pObj)
  451. {
  452. HX_ASSERT(buffer!=NULL);
  453. if (buffer==NULL)
  454.     {
  455. return(FALSE);
  456.     }
  458. this->Initialize();
  460. // Casting away the const, so we must promise not to mess with the
  461. // contents...
  462. m_Buffer = (UCHAR *)buffer;
  463. m_nDecodedLen = nSize;
  465. // ReadObj returns 0 on failure
  466. return (this->ReadObj(pObj)>0);
  467. }
  469. /////////////////////////////////////////////////////////////////////
  470. BOOL  CHXInfoDecoder::PerplexDecodeObj(const char* szPerplex, IHXStreamableObj* pObj)
  471. {
  472. if (szPerplex)
  473.     {
  474. return this->PerplexDecodeObj(szPerplex,strlen(szPerplex),pObj);
  475.     }
  476. return(FALSE);
  477. }
  479. /////////////////////////////////////////////////////////////////////
  480. // We'll unperplex the data into our own buffer, then decode the obj.
  481. BOOL  CHXInfoDecoder::PerplexDecodeObj(const char* szPerplex, UINT32 nPlexLen, IHXStreamableObj* pObj)
  482. {
  483. UINT32 nBitLen  = nPlexLen * sizeof(ULONG32) / Perplex_PER_ULONG32;
  485. UCHAR* Buffer = new UCHAR[nBitLen + 4];
  486. HX_ASSERT(Buffer!=NULL);
  487. if (Buffer==NULL) return(FALSE);
  489.     UINT32 nBitLenActual = CHXInfoDecoder::SetFromPerplex(szPerplex, Buffer, nBitLen+4, nPlexLen);
  491. BOOL bRetVal = FALSE;
  492. if (nBitLenActual==nBitLen)
  493.     {
  494. bRetVal  = this->DecodeObj(Buffer, nBitLen, pObj);
  495.     }
  497. delete [] Buffer;
  499.     return bRetVal;
  500. }
  503. /////////////////////////////////////////////////////////////////////
  504. BOOL  CHXInfoDecoder::HexDecodeObj(const char* szHex, IHXStreamableObj* pObj)
  505. {
  506. if (szHex)
  507.     {
  508. return this->HexDecodeObj(szHex,strlen(szHex),pObj);
  509.     }
  510. return(FALSE);
  511. }
  513. /////////////////////////////////////////////////////////////////////
  514. BOOL  CHXInfoDecoder::HexDecodeObj(const char* szHex, UINT32 nHexLen, IHXStreamableObj* pObj)
  515. {
  516. UINT32 nBitLen  = nHexLen>>1; // unhexed length is 1/2 of hex'd length
  518. UCHAR* Buffer=new UCHAR[nBitLen];
  519. HX_ASSERT(Buffer!=NULL);
  520. if (Buffer==NULL) return(FALSE);
  522.     UINT32 nBitLenActual = CHXInfoDecoder::SetFromHex(szHex, Buffer, nHexLen);
  524. BOOL bRetVal = FALSE;
  525. if (nBitLenActual==nBitLen)
  526.     {
  527. bRetVal  = this->DecodeObj(Buffer,nBitLen,pObj);
  528.     }
  530. delete [] Buffer;
  532.     return bRetVal;
  533. }
  535. /////////////////////////////////////////////////////////////////////
  536. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadObj(IHXStreamableObj* pObj) 
  537. {
  538. UINT32 nLen=this->GetOffset();
  539. if (pObj->ReadObjFromBits(this)==HXR_OK)
  540. return this->GetOffset()-nLen;
  542. #if 0
  543. // reading object
  544. this->Seek(nLen);
  545. #endif
  546. return(0);
  547. }
  549. /////////////////////////////////////////////////////////////////////
  550. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadUCHAR(UCHAR& nValue)
  551. {
  552.     UCHAR temp;
  553.     memcpy(&temp, m_Buffer+m_nOffset, sizeof(temp)); /* Flawfinder: ignore */
  554.     nValue = temp;
  555. m_nOffset += sizeof(temp);
  556.     return sizeof(temp);
  557. }
  561. /////////////////////////////////////////////////////////////////////
  562. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadUINT16(UINT16& nValue)
  563. {
  564.     UINT16 temp16;
  565.     memcpy(&temp16, m_Buffer+m_nOffset, sizeof(temp16)); /* Flawfinder: ignore */
  566.     nValue = WToHost(temp16);
  568. m_nOffset += sizeof(temp16);
  569.     return sizeof(temp16);
  570. }
  572. /////////////////////////////////////////////////////////////////////
  573. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadUINT32(UINT32& nValue)
  574. {
  575.     UINT32 temp32;
  576.     memcpy(&temp32, m_Buffer+m_nOffset, sizeof(temp32)); /* Flawfinder: ignore */
  577.     nValue = DwToHost(temp32);
  579. m_nOffset += sizeof(temp32);
  580.     return sizeof(temp32);
  581. }
  584. /////////////////////////////////////////////////////////////////////
  585. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadString(CHXString& strValue)
  586. {
  587.     UINT32 FieldLen = *(m_Buffer+m_nOffset++);
  589.     char* pBuffer = strValue.GetBuffer((int)FieldLen);
  590.     memcpy(pBuffer, m_Buffer+m_nOffset, (int)FieldLen); /* Flawfinder: ignore */
  591.     pBuffer[FieldLen] = '';
  592.     strValue.ReleaseBuffer();
  594. m_nOffset += FieldLen;
  596.     return FieldLen+1;
  597. }
  600. /////////////////////////////////////////////////////////////////////
  601. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadAndAllocCString(char*& pszValue)
  602. {
  603.     UINT32 FieldLen = *(m_Buffer+m_nOffset++);
  605.     pszValue = new char[FieldLen+1];
  606.     memcpy(pszValue, m_Buffer+m_nOffset, (int)FieldLen); /* Flawfinder: ignore */
  607.     pszValue[FieldLen] = '';
  609. m_nOffset += FieldLen;
  611.     return FieldLen+1;
  612. }
  614. /////////////////////////////////////////////////////////////////////
  616. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadLargeString(CHXString& strValue)
  617. {
  618.     UINT16 FieldLen = 0;
  619.     UINT32 nSize = ReadUINT16(FieldLen);
  621.     char* pBuffer = strValue.GetBuffer(FieldLen);
  622.     memcpy(pBuffer, m_Buffer+m_nOffset, FieldLen); /* Flawfinder: ignore */
  623.     pBuffer[FieldLen] = '';
  624.     strValue.ReleaseBuffer();
  626. m_nOffset += FieldLen;
  628.     return nSize+FieldLen;
  629. }
  632. /////////////////////////////////////////////////////////////////////
  633. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadAndAllocLargeCString(char*& pszValue)
  634. {
  635.     UINT16 FieldLen = 0;
  636.     UINT32 nSize = ReadUINT16(FieldLen);
  638.     pszValue = new char[FieldLen+1];
  639.     memcpy(pszValue, m_Buffer+m_nOffset, FieldLen); /* Flawfinder: ignore */
  640.     pszValue[FieldLen] = '';
  642. m_nOffset += FieldLen;
  644.     return nSize+FieldLen;
  645. }
  648. /////////////////////////////////////////////////////////////////////
  649. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadBuffer(char* szBuffer, UINT32 nSize)
  650. {
  651.     memcpy(szBuffer, m_Buffer+m_nOffset, (int)nSize); /* Flawfinder: ignore */
  652. m_nOffset += nSize;
  653.     return nSize;
  654. }
  656. #if 0
  657. /////////////////////////////////////////////////////////////////////
  658. STDMETHODIMP_(UINT32) CHXInfoDecoder::ReadUTCTime(UTCTimeRep& TimeRep)
  659. {
  660. UINT32 time, nSize;
  662. nSize = ReadUINT32(time);
  664. TimeRep.SetUTCTime(time);
  665. return(nSize);
  666. }
  667. #endif
  669. /////////////////////////////////////////////////////////////////////
  670. STDMETHODIMP CHXInfoDecoder::Seek(UINT32 nPos)
  671. {
  672. if (nPos<=m_nDecodedLen)
  673.     {
  674. m_nOffset = nPos;
  675.     }
  676. return(HXR_OK);
  677. }
  679. /////////////////////////////////////////////////////////////////////
  680. STDMETHODIMP CHXInfoDecoder::SkipForward(UINT32 nAmount)
  681. {
  682. m_nOffset += nAmount;
  684. if (m_nOffset>m_nDecodedLen)
  685.     {
  686. m_nOffset = m_nDecodedLen;
  687.     }
  688. return(HXR_OK);
  689. }
  691. /////////////////////////////////////////////////////////////////////
  692. STDMETHODIMP_(BOOL) CHXInfoDecoder::IsEndOfData()
  693. {
  694. if (m_nDecodedLen<Perplex_ALIGNMENT)
  695. {
  696. return(TRUE);
  697. }
  699. if (m_nOffset>(m_nDecodedLen-Perplex_ALIGNMENT))
  700. return(TRUE);
  701. else
  702. return(FALSE);
  703. }
  706. /////////////////////////////////////////////////////////////////////////////
  707. //
  708. // Function:
  709. //
  710. // FromHexNibble()
  711. //
  712. // Purpose:
  713. //
  714. //
  715. // Parameters:
  716. //
  717. // char hexChar
  718. // Character representing a hex encoding of a nibble.
  719. //
  720. // Return:
  721. //
  722. // UCHAR
  723. // Actual value of the nibble encoded by hexChar.
  724. //
  725. UCHAR CHXInfoDecoder::FromHexNibble(char hexChar)
  726. {
  727. UCHAR value = 0;
  728. if (hexChar >= '0' && hexChar <= '9')
  729. {
  730. value = hexChar - '0';
  731. }
  732. else if (hexChar >= 'A' && hexChar <= 'F')
  733. {
  734. value = hexChar - 'A' + 10;
  735. }
  736. else if (hexChar >= 'a' && hexChar <= 'f')
  737. {
  738. value = hexChar - 'a' + 10;
  739. }
  740. #ifdef _DEBUG
  741. else
  742. {
  743. // Bad hex character!
  744. HX_ASSERT(FALSE);
  745. }
  746. #endif
  748. return value;
  749. }
  752. /////////////////////////////////////////////////////////////////////////////
  753. //
  754. // Function:
  755. //
  756. // HXClientLicense::SetFromHex()
  757. //
  758. // Purpose:
  759. //
  760. // Sets items of the license key from a hexidecimal encoding of the
  761. // license key bits.
  762. //
  763. // Parameters:
  764. //
  765. // const char* hex
  766. // Pointer to a buffer that contains a hexidecimal encoding of the
  767. // license key.
  768. //
  769. // UCHAR* Bits
  770. // Pointer to a buffer that will be filled on output with a bitwise
  771. // decoding of the license key.
  772. //
  773. // UINT32 nSize
  774. // Size of the hex string on input
  775. //
  776. // Return:
  777. //
  778. // int
  779. // Size in bytes of decoded size!
  780. //
  781. // Note:
  782. //
  783. //  Hex representations of the License Key consist of the
  784. //  representation of the bits in human readable form in a
  785. //  HEX encoding. This basically uses a pointer to a memory
  786. //  buffer of charcters encoded as hex representing the bits.
  787. //  Valid characters are 0-9,A-F. Buffers out will be upper
  788. //  case letters, buffers in will be converted to upper case.
  789. //
  790. //  These char's are hex encoding. They are never DBCS, the only
  791. // valid characters are 0-9,A-F
  792. //
  793. UINT32 CHXInfoDecoder::SetFromHex(const char* hex, UCHAR* Bits, UINT32 nSize)
  794. {
  795. UINT32 ndxBits;
  796. UINT32 ndxHex = 0;
  797. UCHAR nibble1;
  798. UCHAR nibble2;
  799. UCHAR byte;
  801. for (ndxBits = 0; ndxHex < nSize; ndxBits++)
  802. {
  803. nibble1 = FromHexNibble(hex[ndxHex]);
  804. nibble1 = nibble1 << 4;
  805. ndxHex++;
  806. nibble2 = FromHexNibble(hex[ndxHex]);
  807. byte = nibble1 | nibble2;
  808. ndxHex++;
  809. Bits[ndxBits] = byte;
  810. }
  811. return ndxBits;
  812. }
  814. /////////////////////////////////////////////////////////////////////////////
  815. //
  816. // Function:
  817. //
  818. // ToHexNibble()
  819. //
  820. // Purpose:
  821. //
  822. // Converts a nibble into the appropriate character for Hex encoding.
  823. //
  824. // Parameters:
  825. //
  826. // UCHAR hexValue
  827. // Value of the nibble.
  828. //
  829. // Return:
  830. //
  831. // char
  832. // Character representing the hex encoding of the nibble.
  833. //
  834. char CHXInfoEncoder::ToHexNibble(UCHAR hexValue)
  835. {
  836. char hexChar = '0';
  838. if (hexValue <= 0x9)
  839. {
  840. hexChar = '0' + hexValue;
  841. }
  842. else if (hexValue >= 0xA && hexValue <= 0xF)
  843. {
  844. hexChar = 'A' + (hexValue - 10);
  845. }
  846. #ifdef _DEBUG
  847. else
  848. {
  849. // Bad hex character!
  850. HX_ASSERT(FALSE);
  851. }
  852. #endif
  854. return hexChar;
  855. }
  857. /////////////////////////////////////////////////////////////////////////////
  858. //
  859. // Function:
  860. //
  861. // DumpToHex()
  862. //
  863. // Purpose:
  864. //
  865. // Formats the license key in human readable hexadecimal encoding.
  866. //
  867. // Parameters:
  868. //
  869. // char* hex
  870. // Pointer to buffer to be filled with hexadecimal encoding of
  871. // license key
  872. //
  873. // Return:
  874. //
  875. // None.
  876. //
  877. void CHXInfoEncoder::DumpToHex(char* hex, UCHAR* Bits, UINT32 nSize)
  878. {
  879. UINT32 ndxBits;
  880. UINT32 ndxHex = 0;
  881. UCHAR nibble1;
  882. UCHAR nibble2;
  883. UCHAR byte;
  885. for (ndxBits = 0; ndxBits < nSize; ndxBits++)
  886. {
  887. byte = Bits[ndxBits];
  888. nibble1 = (byte & 0xF0) >> 4;
  889. nibble2 = (byte & 0x0F);
  891. hex[ndxHex] = ToHexNibble(nibble1);
  892. ndxHex++;
  893. hex[ndxHex] = ToHexNibble(nibble2);
  894. ndxHex++;
  895. }
  896. hex[ndxHex] = '';
  897. }
  899. /////////////////////////////////////////////////////////////////////////////
  900. //
  901. // Function:
  902. //
  903. // MapFromPerplex()
  904. //
  905. // Purpose:
  906. //
  907. // Converts appropriate characters for Perplex encoding into a ULONG32.
  908. //
  909. #ifdef _WIN16
  910. extern char* zPerplexChars;
  911. #else
  912. // A copy of this is kept in in pnmiscpubwinpnmisc16.h.  If you change 
  913. // this (which is very unlikely), then be sure to change it there.  
  914. static const char zPerplexChars[] =
  915. {
  916. '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  917. 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
  918. 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
  919. 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D',
  920. 'E'
  921. };
  923. static const char zDePerplexMap[] = 
  924. { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  925. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  926. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  927. 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,
  928. 0,36,37,38,39,40,0,0,0,0,0,0,0,0,0,0,
  929. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  930. 0,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
  931. 25,26,27,28,29,30,31,32,33,34,35,0,0,0,0,0,
  932. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  933. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  934. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  935. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  936. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  937. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  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. };
  942. #endif /* _WIN16 */
  944. UCHAR CHXInfoDecoder::MapFromPerplex(char Perplex)
  945. {
  946.     return zDePerplexMap[Perplex];
  947. }
  949. /////////////////////////////////////////////////////////////////////////////
  950. //
  951. // Function:
  952. //
  953. // MapToPerplex()
  954. //
  955. // Purpose:
  956. //
  957. // Converts a digit ordinal to the Perplex digit...
  958. //
  959. char CHXInfoEncoder::MapToPerplex(UCHAR Perplex)
  960. {                                                  
  961. #ifdef _DEBUG
  962. #ifndef _WIN16
  963. // On win16, zPerplexChars is a char *, rather than an array, so this
  964. // doesn't work.
  965. int size_zPerplexChars  = sizeof(zPerplexChars); 
  966. int size_zPerplexChars0 = sizeof(zPerplexChars[0]);
  967. HX_ASSERT(Perplex < size_zPerplexChars/size_zPerplexChars0);
  968. #endif
  969. #endif
  970. return zPerplexChars[Perplex];
  971. }
  973. /////////////////////////////////////////////////////////////////////////////
  974. //
  975. // Function:
  976. //
  977. // FromPerplex()
  978. //
  979. // Purpose:
  980. //
  981. // Converts appropriate characters for Perplex encoding into a ULONG32.
  982. //
  983. ULONG32 CHXInfoDecoder::FromPerplex(const char* Perplex)
  984. {
  985. ULONG32 value = 0;
  986. ULONG32 PerplexBase = 1;
  988. for (int n = 0; n < Perplex_PER_ULONG32; n++)
  989. {
  990. value += MapFromPerplex(Perplex[n]) * PerplexBase;
  991. PerplexBase *= Perplex_BASE;
  992. }
  994. // Convert to local byte order!
  995. value = DwToHost(value);
  997. return value;
  998. }
  1000. /////////////////////////////////////////////////////////////////////////////
  1001. //
  1002. // Function:
  1003. //
  1004. // ToPerplexNibble()
  1005. //
  1006. // Purpose:
  1007. //
  1008. // Converts a ULONG32 into the appropriate characters for Perplex encoding.
  1009. //
  1010. void CHXInfoEncoder::ToPerplex(ULONG32 Input, char* Perplex)
  1011. {
  1012. ULONG32 value;
  1013. UCHAR charValue;
  1015. // Convert to net byte order!
  1016. value = DwToNet(Input);
  1018. for (int n = 0; n < Perplex_PER_ULONG32; n++)
  1019. {
  1020. charValue = (UCHAR)(value % Perplex_BASE);
  1021. Perplex[n] = MapToPerplex(charValue);
  1022. value = value / Perplex_BASE;
  1023. }
  1024. }
  1026. /////////////////////////////////////////////////////////////////////////////
  1027. //
  1028. // Function:
  1029. //
  1030. // HXClientLicense::SetFromPerplex()
  1031. //
  1032. // Purpose:
  1033. //
  1034. // Sets items of the license key from a Perplexidecimal encoding of the
  1035. // license key bits.
  1036. //
  1037. // Parameters:
  1038. //
  1039. // const char* Perplex
  1040. // Pointer to a buffer that contains a Perplexidecimal encoding of the
  1041. // license key.
  1042. //
  1043. // UCHAR* Bits
  1044. // Pointer to a buffer that will contain decoded bytes of information
  1045. //
  1046. //              UINT32 ulBitsLen
  1047. //              Number of bytes in Bits output buffer
  1048. //
  1049. // int nSize
  1050. // Input size in bytes
  1051. //
  1052. // Return:
  1053. //
  1054. // int
  1055. // Size in bytes of decoded information
  1056. //
  1057. // Note:
  1058. //
  1059. //  Perplex representations of the License Key consist of the
  1060. //  representation of the bits in human readable form in a
  1061. //  Perplex encoding. This basically uses a pointer to a memory
  1062. //  buffer of charcters encoded as Perplex representing the bits.
  1063. //  Valid characters are 0-9,A-F. Buffers out will be upper
  1064. //  case letters, buffers in will be converted to upper case.
  1065. //
  1066. //  These char's are Perplex encoding. They are never DBCS, the only
  1067. // valid characters are 0-9,A-F
  1068. //
  1069. UINT32 CHXInfoDecoder::SetFromPerplex(const char* Perplex, UCHAR* Bits, UINT32 ulBitsLen, UINT32 nSize)
  1070. {
  1071. UINT32 ndxBits;
  1072. UINT32 ndxPerplex = 0;
  1073. ULONG32 temp32;
  1075. for (ndxBits = 0; ndxPerplex < nSize; )
  1076. {
  1077. temp32 = FromPerplex(&Perplex[ndxPerplex]);
  1078. ndxPerplex+=Perplex_PER_ULONG32;
  1079. if (ndxBits+4 <= ulBitsLen) memcpy(&Bits[ndxBits],&temp32,sizeof(temp32)); /* Flawfinder: ignore */
  1080. ndxBits+=sizeof(temp32);
  1081. }
  1082. return ndxBits;
  1083. }
  1085. /////////////////////////////////////////////////////////////////////////////
  1086. //
  1087. // Function:
  1088. //
  1089. // DumpToPerplex()
  1090. //
  1091. // Purpose:
  1092. //
  1093. // Formats the license key in human readable Perplexadecimal encoding.
  1094. //
  1095. // Parameters:
  1096. //
  1097. // char* Perplex
  1098. // Pointer to buffer to be filled with Perplexadecimal encoding of
  1099. // license key
  1100. //
  1101. // Return:
  1102. //
  1103. // None.
  1104. //
  1105. void CHXInfoEncoder::DumpToPerplex(char* Perplex, UINT32 ulPerplexSize, UCHAR* Bits, UINT32 nSize)
  1106. {
  1107. UINT32 ndxBits;
  1108. UINT32 ndxPerplex = 0;
  1109. ULONG32 temp32;
  1111. for (ndxBits = 0; ndxBits < nSize; )
  1112. {
  1113. if (ndxBits+4 <= nSize) memcpy(&temp32,&Bits[ndxBits],sizeof(temp32)); /* Flawfinder: ignore */
  1114.                 ndxBits+=sizeof(temp32);
  1115. if (ndxPerplex+Perplex_PER_ULONG32 <= ulPerplexSize) ToPerplex(temp32,&Perplex[ndxPerplex]);
  1116. ndxPerplex+=Perplex_PER_ULONG32;
  1117. }
  1118. Perplex[ndxPerplex] = '';
  1119. }
  1123. /////////////////////////////////////////////////////////////////////////////
  1124. //
  1125. // Function:
  1126. //
  1127. // MapFromMIMEBase64()
  1128. //
  1129. // Purpose:
  1130. //
  1131. // Converts appropriate characters for MIME-Base64 encoding into a the
  1132. // Base64 ordinal.
  1133. //
  1134. #ifdef _WIN16
  1135. extern char* zMIMEBase64Chars;
  1136. #else
  1137. // A copy of this is kept in in pnmiscpubwinpnmisc16.h.  If you change 
  1138. // this (which is very unlikely), then be sure to change it there.  
  1139. static const char zMIMEBase64Chars[] =
  1140. {
  1141. 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
  1142. 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
  1143. 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
  1144. 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
  1145. 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
  1146. 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
  1147. '8', '9', '+', '/'
  1148. };
  1149. #endif /* _WIN16 */
  1151. #define MIME_BASE64_PADDING '='
  1152. #define FROM_MIME_BASE64_BYTES_IN 4
  1153. #define FROM_MIME_BASE64_BYTES_OUT 3
  1154. #define TO_MIME_BASE64_BYTES_IN FROM_MIME_BASE64_BYTES_OUT
  1155. #define TO_MIME_BASE64_BYTES_OUT FROM_MIME_BASE64_BYTES_IN
  1157. UCHAR CHXInfoDecoder::MapFromMIMEBase64(char MIMEBase64)
  1158. {
  1159. for (UCHAR n = 0; n < sizeof(zMIMEBase64Chars)/sizeof(zMIMEBase64Chars[0]); n++)
  1160. {
  1161. if (MIMEBase64 == zMIMEBase64Chars[n])
  1162. {
  1163. return n;
  1164. }
  1165. }
  1166. HX_ASSERT(FALSE);
  1167. return 0;
  1168. }
  1170. /////////////////////////////////////////////////////////////////////////////
  1171. //
  1172. // Function:
  1173. //
  1174. // MapToMIMEBase64()
  1175. //
  1176. // Purpose:
  1177. //
  1178. // Converts a digit ordinal to the MIMEBase64 digit...
  1179. //
  1180. char CHXInfoEncoder::MapToMIMEBase64(UCHAR MIMEBase64)
  1181. {
  1182. HX_ASSERT( MIMEBase64 < sizeof(zMIMEBase64Chars)/sizeof(zMIMEBase64Chars[0]));
  1183. return zMIMEBase64Chars[MIMEBase64];
  1184. }
  1186. /////////////////////////////////////////////////////////////////////////////
  1187. //
  1188. // Function:
  1189. //
  1190. // SetFromMIMEBase64()
  1191. //
  1192. // Purpose:
  1193. //
  1194. // ...
  1195. //
  1196. // Parameters:
  1197. //
  1198. // ...
  1199. //
  1200. // Return:
  1201. //
  1202. // int
  1203. // Size in bytes of decoded information
  1204. //
  1205. UINT32 CHXInfoDecoder::SetFromMIMEBase64(const char* MIMEBase64, char* Bits, UINT32 nSize)
  1206. {
  1207. UINT32 ndxBits = 0;
  1208. UINT32 ndxMIMEBase64 = 0;
  1209. BOOL bDone = FALSE;
  1210. UINT32 ndxTempIn = 0;
  1211. UCHAR tempBitsIn [FROM_MIME_BASE64_BYTES_IN];
  1212. UINT32 padding = 0;
  1214. HX_ASSERT(strlen(MIMEBase64) <= nSize);
  1216. while (!bDone)
  1217. {
  1218. HX_ASSERT(ndxMIMEBase64 <= nSize);
  1219. HX_ASSERT(ndxBits <= nSize);
  1221. // Fill in our "temporary" in buffer with the Base64 characters.
  1222. for ( ndxTempIn = 0;
  1223. ndxTempIn < FROM_MIME_BASE64_BYTES_IN && (padding == 0);
  1224. ndxTempIn++
  1225. )
  1226. {
  1227. HX_ASSERT(ndxMIMEBase64 <= nSize);
  1229. UCHAR MIMEBase64char = MIMEBase64[ndxMIMEBase64];
  1231. switch (MIMEBase64char)
  1232. {
  1233. case MIME_BASE64_PADDING:
  1234. case '':
  1235. {
  1236. tempBitsIn[ndxTempIn] = 0;
  1237. bDone = TRUE;
  1238. padding = (FROM_MIME_BASE64_BYTES_IN - ndxTempIn);
  1239. }
  1240. break;
  1242. default:
  1243. {
  1244. tempBitsIn[ndxTempIn] = MapFromMIMEBase64(MIMEBase64char);
  1245. }
  1246. break;
  1247. }
  1248. ndxMIMEBase64++;
  1249. }
  1251. HX_ASSERT(padding == 2 || padding == 1 || padding == 0);
  1253. // Map the Base64 in buffer to the the output buffer...
  1254. // This should map the 6 pertinate bits of each IN byte, to the
  1255. // the correct bits of the OUT byte.
  1256. {
  1257. Bits[ndxBits] = (tempBitsIn[0] << 2) + (tempBitsIn[1]>>4);
  1258. ndxBits++;
  1260. if (padding < 2)
  1261. {
  1262. Bits[ndxBits] = (tempBitsIn[1] << 4) + (tempBitsIn[2]>>2);
  1263. ndxBits++;
  1264. }
  1266. if (padding < 1)
  1267. {
  1268. Bits[ndxBits] = (tempBitsIn[2] << 6) + (tempBitsIn[3]);
  1269. ndxBits++;
  1270. }
  1271. }
  1272. }
  1274. Bits[ndxBits] = '';
  1276. return ndxBits;
  1277. }
  1279. /////////////////////////////////////////////////////////////////////////////
  1280. //
  1281. // Function:
  1282. //
  1283. // DumpToMIMEBase64()
  1284. //
  1285. // Purpose:
  1286. //
  1287. // ...
  1288. //
  1289. // Parameters:
  1290. //
  1291. // ...
  1292. //
  1293. // Return:
  1294. //
  1295. // None.
  1296. //
  1297. void CHXInfoEncoder::DumpToMIMEBase64(char* MIMEBase64, const char* Bits, UINT32 nSize)
  1298. {
  1299. UINT32 ndxBits = 0;
  1300. UINT32 ndxMIMEBase64 = 0;
  1301. BOOL bDone = FALSE;
  1302. UINT32 ndxTempIn = 0;
  1303. UINT32 ndxTempOut = 0;
  1304. UCHAR tempBitsIn [TO_MIME_BASE64_BYTES_IN];
  1305. UINT32 padding = 0;
  1307. HX_ASSERT(strlen(Bits) <= nSize);
  1309. while (!bDone)
  1310. {
  1311. HX_ASSERT(ndxMIMEBase64 <= nSize);
  1312. HX_ASSERT(ndxBits <= nSize);
  1314. // Fill in our "temporary" out buffer with the 6 bit chunks of the input.
  1315. for ( ndxTempIn = 0;
  1316. ndxTempIn < TO_MIME_BASE64_BYTES_IN && (padding == 0);
  1317. ndxTempIn++
  1318. )
  1319. {
  1320. UCHAR rawChar = Bits[ndxBits];
  1322. if (rawChar != '')
  1323. {
  1324. switch (ndxTempIn)
  1325. {
  1326. case 0:
  1327. {
  1328. tempBitsIn[0] = rawChar >> 2;
  1329. tempBitsIn[1] = (rawChar & 0x3) << 4;
  1330. }
  1331. break;
  1333. case 1:
  1334. {
  1335. tempBitsIn[1] += rawChar >> 4;
  1336. tempBitsIn[2] = (rawChar & 0xF) << 2;
  1337. }
  1338. break;
  1340. case 2:
  1341. {
  1342. tempBitsIn[2] += rawChar >> 6;
  1343. tempBitsIn[3] = (rawChar & 0x3F);
  1344. }
  1345. break;
  1346. }
  1347. }
  1348. else
  1349. {
  1350. bDone = TRUE;
  1351. padding = (TO_MIME_BASE64_BYTES_IN - ndxTempIn);
  1352. }
  1353. ndxBits++;
  1354. }
  1356. HX_ASSERT(padding == 2 || padding == 1 || padding == 0);
  1358. // Map the Base64 in buffer to the output buffer...
  1359. // This should map the 6 pertinate bits of each IN byte, as an
  1360. // entire OUT byte
  1361. for ( ndxTempOut = 0;
  1362. ndxTempOut < TO_MIME_BASE64_BYTES_OUT;
  1363. ndxTempOut++
  1364. )
  1365. {
  1366. if (ndxTempOut < (TO_MIME_BASE64_BYTES_OUT-padding))
  1367. {
  1368. MIMEBase64[ndxMIMEBase64] = MapToMIMEBase64(tempBitsIn[ndxTempOut]);
  1369. }
  1370. else
  1371. {
  1372. MIMEBase64[ndxMIMEBase64] = MIME_BASE64_PADDING;
  1373. }
  1374. ndxMIMEBase64++;
  1375. }
  1377. }
  1379. MIMEBase64[ndxMIMEBase64] = '';
  1380. }
  1384. //*******************************************************************
  1385. //  CHXSimpleBuffer
  1386. //*******************************************************************
  1389. /////////////////////////////////////////////////////////////////////
  1390. CHXSimpleBuffer::CHXSimpleBuffer()
  1391. :  m_nSize(0), m_pData(NULL), m_nGrowBy(DEFAULT_GROW_SIZE)
  1392. {
  1393. }
  1395. /////////////////////////////////////////////////////////////////////
  1396. CHXSimpleBuffer::CHXSimpleBuffer(UINT32 nSize, UINT32 nGrowBy)
  1397. :  m_nSize(0), m_pData(NULL), m_nGrowBy(nGrowBy)
  1398. {
  1399. Resize(nSize);
  1400. }
  1402. /////////////////////////////////////////////////////////////////////
  1403. CHXSimpleBuffer::~CHXSimpleBuffer()
  1404. {
  1405. Free();
  1406. }
  1409. /////////////////////////////////////////////////////////////////////
  1410. BOOL CHXSimpleBuffer::IsValidOffset(UINT32 n) const
  1411. {
  1412. if (n<m_nSize)
  1413. return(TRUE);
  1414. else return(FALSE);
  1415. }
  1418. /////////////////////////////////////////////////////////////////////
  1419. // make sure that pPos is in the buffer.
  1420. // If not, the buffer is automatically resized and contents copied.
  1421. // pPos must be > pData.
  1422. BOOL CHXSimpleBuffer::EnsureValidOffset(UINT32 n)
  1423. {
  1424. if (IsValidOffset(n)==TRUE)
  1425.     {
  1426. return(TRUE);
  1427.     }
  1429. return (this->Resize(n));
  1430. }
  1433. /////////////////////////////////////////////////////////////////////
  1434. // copy data into the buffer at the given offset, and if the buffer
  1435. // is too small we'll resize the buffer first.
  1436. BOOL CHXSimpleBuffer::SafeMemCopy(UINT32 nOffset, const void* data, UINT32 len)
  1437. {
  1438.     if ((len > 0) && (EnsureValidOffset(nOffset+len-1)==TRUE))
  1439.     {
  1440.      memcpy( m_pData+nOffset, data, (int)len ); /* Flawfinder: ignore */
  1441. return(TRUE);
  1442.     }
  1444.     return(FALSE);
  1445. }
  1448. /////////////////////////////////////////////////////////////////////
  1449. BOOL CHXSimpleBuffer::Resize(UINT32 nNewSize)
  1450. {
  1451. if (nNewSize==0)
  1452.     {
  1453. Free();
  1454. return(TRUE);
  1455.     }
  1457. nNewSize = RoundUpToGrowSize(nNewSize);
  1459. UCHAR* pNewBuffer = new UCHAR[nNewSize];
  1460. if (pNewBuffer==NULL) return(FALSE);
  1463. if (m_pData!=NULL)
  1464.     {
  1465. // copy MIN(oldSize,newSize) elements
  1466. memcpy(pNewBuffer,m_pData, (nNewSize<m_nSize) ? (int)nNewSize : (int)m_nSize); /* Flawfinder: ignore */
  1467. delete [] m_pData;
  1468.     }
  1470. m_pData = pNewBuffer;
  1471. m_nSize = nNewSize;
  1473. return(TRUE);
  1474. }
  1477. /////////////////////////////////////////////////////////////////////
  1478. UINT32 CHXSimpleBuffer::RoundUpToGrowSize(UINT32 nSize)
  1479. {
  1480. // check for div-by-zero errors (as long as DEFAULT!=0)
  1481. if (m_nGrowBy==0)
  1482. {
  1483. m_nGrowBy = DEFAULT_GROW_SIZE;
  1484. }
  1486. return ( (int)(nSize/m_nGrowBy)+1 ) * m_nGrowBy;
  1487. }
  1490. /////////////////////////////////////////////////////////////////////
  1491. void CHXSimpleBuffer::Free()
  1492. {
  1493. if (m_pData!=NULL)
  1494. delete [] m_pData;
  1496. m_pData=NULL;
  1497. m_nSize=0;
  1498. }