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

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

Symbian

开发平台：

C/C++

sdpchunk.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.  *  Defines
  38.  */
  39. #define DFLT_PAYLOAD_MIME_TYPE   "data/x-unknown"
  41. #define CHAR_LF 0x0a
  42. #define CHAR_CR 0x0d
  44. #define BAD_PULL_TABLE_IDX  0xFFFFFFFF
  46. #define MAX_INT_TEXT_LENGTH 10
  48. #define N_CLIPRECT_COORDS   4
  50. #define FMPT_PREFIX     "FMTP"
  51. #define FMPT_PREFIX_SIZE    (sizeof(FMPT_PREFIX) - 1)
  54. /****************************************************************************
  55.  *  Includes
  56.  */
  57. //#include "hlxclib/stdlib.h"
  58. #include "hxstrutl.h"
  59. #include "hxassert.h"
  60. #include "sdpchunk.h"
  62. #include "hxstring.h"
  63. #include "hxslist.h"
  64. #include "sdppyldinfo.h"
  67. /****************************************************************************
  68.  *  Locals
  69.  */
  70. /****************************************************************************
  71.  *  Pull Functions
  72. */
  73. static HX_RESULT PullSessionName(char* pData,
  74.                                  ULONG32 ulLength,
  75.                                  IHXValues* pSDPValues,
  76.                                  IHXCommonClassFactory* pClassFactory);
  77. static HX_RESULT PullMediaDesc (char* pData,
  78.                                  ULONG32 ulLength, 
  79.                                  IHXValues* pSDPValues,
  80.                                  IHXCommonClassFactory* pClassFactory);
  81. static HX_RESULT PullRTPMap (char* pData,
  82.                                  ULONG32 ulLength, 
  83.                                  IHXValues* pSDPValues,
  84.                                  IHXCommonClassFactory* pClassFactory);
  85. static HX_RESULT PullControl (char* pData,
  86.                                  ULONG32 ulLength, 
  87.                                  IHXValues* pSDPValues,
  88.                                  IHXCommonClassFactory* pClassFactory);
  89. static HX_RESULT PullClipRect (char* pData, 
  90.                                  ULONG32 ulLength, 
  91.                                  IHXValues* pSDPValues,
  92.                                  IHXCommonClassFactory* pClassFactory);
  94. static HX_RESULT PullBufferDelay(char* pData, 
  95.                                  ULONG32 ulLength, 
  96.                                  IHXValues* pSDPValues,
  97.                                  IHXCommonClassFactory* pClassFactory);
  99. static HX_RESULT PullFormatParams(char* pData, 
  100.                                  ULONG32 ulLength, 
  101.                                  IHXValues* pSDPValues,
  102.                                  IHXCommonClassFactory* pClassFactory);
  104. static HX_RESULT PullGroupID (char* pData, 
  105.                                  ULONG32 ulLength, 
  106.                                  IHXValues* pSDPValues,
  107.                                  IHXCommonClassFactory* pClassFactory);
  109. static HX_RESULT PullGroupBitrate(char* pData, 
  110.                                  ULONG32 ulLength, 
  111.                                  IHXValues* pSDPValues,
  112.                                  IHXCommonClassFactory* pClassFactory);
  113. static HX_RESULT PullBandwidth (char* pData,
  114.                                  ULONG32 ulLength, 
  115.                                  IHXValues* pSDPValues,
  116.                                  IHXCommonClassFactory* pClassFactory);
  118. /****************************************************************************
  119.  *  Local Utilities
  120.  */
  121. inline static ULONG32 GetPullTableIdx(const SDPRecordPuller* pTable,
  122.                                       char* pData, 
  123.                                       ULONG32 ulRecordSize);
  125. inline static char* FindSDPFieldByIdx(char* pData, 
  126.                                       ULONG32 ulLength, 
  127.                                       ULONG32 ulIdx);
  129. inline static char* FindSDPFieldEnd(char* pData, 
  130.                                     ULONG32 ulLength);
  132. inline static char* FindCRLF(char* pData, 
  133.                              ULONG32 ulLength);
  135. inline static HX_RESULT  PullLine(char* pData, 
  136.                              ULONG32 ulLength,
  137.                              REF(IHXBuffer*) pLine,
  138.                              IHXCommonClassFactory* pClassFactory);
  140. inline static char* SkipSDPFieldEnd(char* pData,
  141.                                     ULONG32 ulLength);
  144. inline static void OrderUp(LONG32 &l1, LONG32 &l2);
  146. /****************************************************************************
  147.  *  Pull Tables - must be NULL terminated
  148.  */
  149. const SDPRecordPuller SessionPullTable[] =
  150. {
  151.     {"s=",     sizeof("s=") - 1, PullSessionName},
  152.     {"b=",     sizeof("b=") - 1, PullBandwidth},
  153.     {NULL,     0, NULL}
  154. };
  156. const SDPRecordPuller MediaPullTable[] =
  157. {
  158.     {"m=",     sizeof("m=") - 1, PullMediaDesc},
  159.     {"a=rtpmap:",    sizeof("a=rtpmap:") - 1, PullRTPMap},
  160.     {"a=control:",   sizeof("a=control:") - 1, NULL},
  161.     {"b=",     sizeof("b=") - 1, PullBandwidth},
  162.     {NULL,     0, NULL}
  163. };
  165. const SDPRecordPuller TimePullTable[] =
  166. {
  167.     {NULL,     0, NULL}
  168. };
  170. const SDPRecordPuller GenericPullTable[] =
  171. {
  172.     {NULL,     0, NULL}
  173. };
  175. const SDPRecordPuller RendererPullTable[] =
  176. {
  177.     {"a=cliprect:", sizeof("a=cliprect:") - 1, PullClipRect},
  178.     {"a=x-bufferdelay:", sizeof("a=x-bufferdelay:") - 1, PullBufferDelay}, 
  179.     {"a=fmtp:", sizeof("a=fmtp:") - 1, PullFormatParams},
  180.     {NULL, 0, NULL}
  181. };
  183. const SDPRecordPuller GroupPullTable[] =
  184. {
  185.     {"a=x-alternate:group=", sizeof("a=x-alternate:group=") - 1, PullGroupID},
  186.     {"a=x-alternate:datarate=", sizeof("a=x-alternate:datarate=") - 1, PullGroupBitrate},
  187.     {NULL, 0, NULL}
  188. };
  190. /****************************************************************************
  191.  *  Global Utility fuinctions
  192.  */
  193. /****************************************************************************
  194.  *  SDPParseChunk - use context
  195.  */
  196. HX_RESULT SDPParseChunk(char* pData,
  197.                         ULONG32 ulDataLen,
  198.                         IHXValues* &pSDPValues,
  199.                         IHXCommonClassFactory *pClassFactory,
  200.                         SDPChunkContext SDPContext,
  201.                         BOOL bPullRecords)
  202. {
  203.     HX_RESULT retVal = HXR_OK;
  204.     const SDPRecordPuller* pPullTable = NULL;
  206.     switch (SDPContext)
  207.     {
  208.     case SDPCTX_Media:
  209.         pPullTable = MediaPullTable;
  210.         break;
  211.     case SDPCTX_Session:
  212.         pPullTable = SessionPullTable;
  213.         break;
  214.     case SDPCTX_Group:
  215.         pPullTable = GroupPullTable;
  216.         break;
  217.     case SDPCTX_Time:
  218.         pPullTable = TimePullTable;
  219.         break;
  220.     case SDPCTX_Generic:
  221.         pPullTable = GenericPullTable;
  222.         break;
  223.     case SDPCTX_Renderer:
  224.         pPullTable = RendererPullTable;
  225.         break;
  226.     default:
  227.         retVal = HXR_INVALID_PARAMETER;
  228.         break;
  229.     }
  231.     if (SUCCEEDED(retVal))
  232.     {
  233.         retVal = SDPParseChunk(pData,
  234.                                ulDataLen,
  235.                                pSDPValues,
  236.                                pClassFactory,
  237.                                pPullTable,
  238.                                bPullRecords);
  239.     }
  241.     return retVal;
  242. }
  244. /****************************************************************************
  245.  *  SDPParseChunk - use custom pull table
  246.  */
  247. HX_RESULT SDPParseChunk(char* pData,
  248.                         ULONG32 ulDataLen,
  249.                         IHXValues* &pSDPValues,
  250.                         IHXCommonClassFactory *pClassFactory,
  251.                         const SDPRecordPuller* pPullTable,
  252.                         BOOL bPullRecords)
  253. {
  254.     HX_RESULT retVal = HXR_OK;
  255.     IHXBuffer* pSDPBuffer = NULL;
  256.     char* pSDPData = NULL;
  257.     char* pPattern;
  258.     ULONG32 ulRecordSize;
  259.     ULONG32 ulPullTableIdx;
  260.     BOOL bSDPValuesMadeHere = FALSE;
  261.     
  262.     if ((pData == NULL) || (ulDataLen == 0))
  263.     {
  264.         if (pSDPValues == NULL)
  265.         {
  266.             retVal = HXR_FAIL;
  267.         }
  269.         return retVal;
  270.     }
  272.     if (!pSDPValues)
  273.     {
  274.         bSDPValuesMadeHere = TRUE;
  275.         retVal = pClassFactory->CreateInstance(CLSID_IHXValues,
  276.                                                  (void**) &pSDPValues);
  277.     }
  279.     if (bPullRecords)
  280.     {
  281.         if (SUCCEEDED(retVal))
  282.         {
  283.             retVal = pClassFactory->CreateInstance(CLSID_IHXBuffer,
  284.                 (void**) &pSDPBuffer);
  285.         }
  286.         
  287.         if (SUCCEEDED(retVal))
  288.         {
  289.             retVal = pSDPBuffer->SetSize(ulDataLen + 1);
  290.         }
  291.     }
  293.     if (SUCCEEDED(retVal))
  294.     {
  295.         if (pPullTable == NULL)
  296.         {
  297.             retVal = HXR_INVALID_PARAMETER;
  298.         }
  299.     }
  301.     if (SUCCEEDED(retVal))
  302.     {
  303.         if (pSDPBuffer)
  304.         {
  305.             pSDPData = (char*) pSDPBuffer->GetBuffer();
  306.         }
  307.         
  308.         do
  309.         {
  310.             pPattern = StrNChr(pData, CHAR_LF, ulDataLen);
  312.             if (pPattern == NULL)
  313.             {
  314.                 ulRecordSize = ulDataLen;
  315.             }
  316.             else
  317.             {
  318.                 ulRecordSize = pPattern - pData;
  319.                 pPattern = SkipSDPFieldEnd(pPattern, 
  320.                                            ulDataLen - ulRecordSize);
  321.                 ulRecordSize = pPattern - pData;
  322.             }
  323.             
  324.             ulPullTableIdx = GetPullTableIdx(pPullTable, 
  325.                                              pData,
  326.                                              ulRecordSize);
  328.             if (ulPullTableIdx == BAD_PULL_TABLE_IDX)
  329.             {
  330.                 if (pSDPData)
  331.                 {
  332.                     // keep this entry as SDP data
  333.                     memcpy(pSDPData, pData, ulRecordSize); /* Flawfinder: ignore */
  334.                     pSDPData += ulRecordSize;
  335.                 }
  336.             }
  337.             else
  338.             {
  339.                 // pull this record out of SDP data
  340.                 if (pPullTable[ulPullTableIdx].pPullFunc)
  341.                 {
  342.                     retVal = (*(pPullTable[ulPullTableIdx].pPullFunc))(
  343.                                     pData,
  344.                                     ulRecordSize,
  345.                                     pSDPValues,
  346.                                     pClassFactory);
  347.                 }
  348.             }
  350.             pData +=  ulRecordSize;
  351.             ulDataLen -= ulRecordSize;
  352.         } while ((ulDataLen != 0) && SUCCEEDED(retVal));
  353.     }
  354.    
  355.     if (SUCCEEDED(retVal) && pSDPData)
  356.     {
  357.         HX_ASSERT(((ULONG32) (pSDPData - ((char *) pSDPBuffer->GetBuffer())) )
  358.                   < pSDPBuffer->GetSize());
  360.         if (((char *) pSDPBuffer->GetBuffer()) != pSDPData)
  361.         {
  362.             *pSDPData = '';
  363.             pSDPValues->SetPropertyCString("SDPData", pSDPBuffer);
  364.         }
  365.     }
  367.     HX_RELEASE(pSDPBuffer);
  369.     if (FAILED(retVal) && bSDPValuesMadeHere)
  370.     {
  371.         HX_RELEASE(pSDPValues);
  372.     }
  374.     return retVal;
  375. }
  378. /****************************************************************************
  379.  *  SDPMapPayloadToMime
  380.  */
  381. HX_RESULT SDPMapPayloadToMime(ULONG32 ulPayloadType,
  382.                               IHXBuffer* &pMimeType,
  383.                               IHXCommonClassFactory *pClassFactory)
  384. {
  385.     HX_RESULT retVal = HXR_OK;
  387.     HX_ASSERT(pClassFactory);
  389.     if (!pMimeType)
  390.     {
  391.         retVal = pClassFactory->CreateInstance(CLSID_IHXBuffer,
  392.                                                (void**) &pMimeType);
  393.     }
  395.     if (SUCCEEDED(retVal))
  396.     {
  397.         const char* pPayloadMime = DFLT_PAYLOAD_MIME_TYPE;
  399.         if (SDPIsKnownPayload(ulPayloadType))
  400.         {
  401.             pPayloadMime = SDPMapPayloadToMimeType(ulPayloadType);
  402.         }
  404.         retVal = pMimeType->Set((UCHAR*) pPayloadMime, 
  405.                                 strlen(pPayloadMime) + 1);
  406.     }
  408.     return retVal;
  409. }
  412. /****************************************************************************
  413.  *  SDPIsFixedRatePayload
  414.  */
  415. BOOL SDPIsFixedRatePayload(ULONG32 ulPayloadType)
  416. {
  417.     if (SDPIsStaticPayload(ulPayloadType))
  418.     {
  419.         return !SDPIsTimestampDeliverable(ulPayloadType);
  420.     }
  422.     return FALSE;
  423. }
  426. /****************************************************************************
  427.  *  SDPMapMimeToSamplesPerSecond
  428.  */
  429. ULONG32 SDPMapMimeToSamplesPerSecond(IHXBuffer* pMimeTypeBuffer)
  430. {
  431.     ULONG32 ulPayload = 0;
  432.     ULONG32 ulSamplesPerSecond = 0;
  434.     if (SUCCEEDED(SDPMapMimeToPayload(pMimeTypeBuffer, ulPayload)))
  435.     {
  436.         ulSamplesPerSecond = SDPMapPayloadToSamplesPerSecond(ulPayload);
  437.     }
  438.     else
  439.     {
  440.         const char* pTargetMimeType = (const char*)pMimeTypeBuffer->GetBuffer();
  441.         ulSamplesPerSecond = SDPMapMimeTypeToSampleRate(pTargetMimeType);
  442.     }
  444.     return ulSamplesPerSecond;
  445. }
  447. /****************************************************************************
  448.  *  SDPIsKnownPayload
  449.  */
  450. BOOL SDPIsKnownPayload(ULONG32 ulPayloadType)
  451. {
  452.     return (SDPIsStaticPayload(ulPayloadType) &&
  453.             (SDPMapPayloadToMimeType(ulPayloadType) != NULL));
  454. }
  457. /****************************************************************************
  458.  *  SDPMapMimeToPayloadID
  459.  */
  460. HX_RESULT SDPMapMimeToPayload(IHXBuffer* pMimeTypeBuffer, ULONG32 &ulPayload)
  461. {
  462.     ULONG32 ulId;
  463.     HX_RESULT retVal = HXR_FAIL;
  464.     char* pMimeType = NULL;
  465.     char* pEncodingName;
  467.     if (pMimeTypeBuffer)
  468.     {
  469.         pMimeType = (char *) pMimeTypeBuffer->GetBuffer();
  470.     }
  472.     if (pMimeType &&
  473.         (pEncodingName = strchr((char*) pMimeType, '/')))
  474.     {
  475.         pEncodingName++;
  476.         
  477.         for (ulId = 0; SDPIsStaticPayload(ulId); ulId++)
  478.         {
  479.             if (SDPMapPayloadToEncodingName(ulId) &&
  480.                 !strcasecmp(SDPMapPayloadToEncodingName(ulId),
  481.                             pEncodingName))
  482.             {
  483.                 ulPayload = ulId;
  484.                 retVal = HXR_OK;
  485.                 break;
  486.             }
  487.         }
  488.     }
  490.     return retVal;
  491. }
  494. /****************************************************************************
  495.  *  Pull Functions
  496.  */
  497. /****************************************************************************
  498.  *  Pull Functions
  499.  */
  500. /*
  501.  * "s=" text CRLF
  502.  */
  503. static HX_RESULT PullSessionName(char* pData,
  504.                                  ULONG32 ulLength,
  505.                                  IHXValues* pSDPValues,
  506.                                  IHXCommonClassFactory* pClassFactory)
  507. {
  508.     HX_ASSERT(pData && !strncmp(pData, "s=", 2));
  510.     HX_RESULT retVal = HXR_FAIL;
  511.     IHXBuffer* pSessionName = NULL;
  513.     retVal = PullLine(pData + 2, ulLength - 2, pSessionName, pClassFactory);
  514.     if (SUCCEEDED(retVal))
  515.     {
  516.       retVal = pSDPValues->SetPropertyCString("Title", pSessionName);
  517.     }
  518.     HX_RELEASE(pSessionName);
  519.     return retVal;
  520. }
  521. static HX_RESULT PullMediaDesc (char* pData, 
  522.                                  ULONG32 ulLength, 
  523.                                  IHXValues* pSDPValues,
  524.                                  IHXCommonClassFactory* pClassFactory)
  525. {
  526.     char* pPattern;
  527.     ULONG32 ulPayloadType = 0;
  528.     IHXBuffer* pMimeType = NULL;
  529.     HX_RESULT retVal = HXR_FAIL;
  531.     // Extract Payload Type
  532.     pPattern = FindSDPFieldByIdx(pData, ulLength, 3);
  533.     if (pPattern != NULL)
  534.     {
  535.         char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
  536.         char* pNumEnd;
  538.         ULONG32 ulNumTextLength = (ulLength - (pPattern - pData));
  540.         if (ulNumTextLength > MAX_INT_TEXT_LENGTH)
  541.         {
  542.             ulNumTextLength = MAX_INT_TEXT_LENGTH;
  543.         }
  545.         memcpy(pNumBuffer, pPattern, ulNumTextLength); /* Flawfinder: ignore */
  546.         pNumBuffer[ulNumTextLength] = '';
  548.         ulPayloadType = strtol(pNumBuffer, &pNumEnd, 10);
  550.         if (pNumEnd > pNumBuffer)
  551.         {
  552.             retVal = HXR_OK;
  553.         }
  554.     }
  556.     // Prepare Mime Type
  557.     if (SUCCEEDED(retVal))
  558.     {
  559.         const char* pPayloadMime = NULL;
  560.         ULONG32 ulPayloadMimeLength = 0;
  561.         char* pMimeStart = NULL;
  562.         ULONG32 ulMimeLength = 0;
  564.         if (SDPIsStaticPayload(ulPayloadType))
  565.         {
  566.             pPayloadMime = SDPMapPayloadToEncodingName(ulPayloadType);
  568.             retVal = HXR_FAIL;
  569.             if (pPayloadMime != NULL)
  570.             {
  571.                 ulPayloadMimeLength = strlen(pPayloadMime) + 1;
  573.                 pSDPValues->SetPropertyULONG32(
  574.                     "SamplesPerSecond",
  575.                     SDPMapPayloadToSamplesPerSecond(ulPayloadType));
  577.                 UINT16 uChannels = 
  578.                     SDPMapPayloadToChannels(ulPayloadType);
  579.                 if (uChannels > 0)
  580.                 {
  581.                     pSDPValues->SetPropertyULONG32(
  582.                         "Channels",
  583.                         uChannels);
  584.                 }
  586.                 retVal = HXR_OK;
  587.             }
  588.         }
  590.         if (SUCCEEDED(retVal))
  591.         {
  592.             // extract portion of mime type
  593.             // - will be completed when rtp map encountered
  594.             // if this is not a static payload
  595.             pPattern = StrNChr((char *) pData, ' ', ulLength);
  596.             pMimeStart = pData + 2;
  597.             
  598.             retVal = HXR_FAIL;
  599.             
  600.             if ((pPattern != NULL) &&
  601.                 ((pPattern - pData) > 2))
  602.             {
  603.                 ulMimeLength = pPattern - pData - 2;
  604.                 
  605.                 retVal = pClassFactory->CreateInstance(
  606.                     CLSID_IHXBuffer,
  607.                     (void**) &pMimeType);
  608.             }
  609.             
  610.             if (SUCCEEDED(retVal))
  611.             {
  612.                 retVal = pMimeType->SetSize(ulMimeLength + 
  613.                                             ulPayloadMimeLength + 
  614.                                             1);
  615.             }
  616.             
  617.             if (SUCCEEDED(retVal))
  618.             {
  619.                 memcpy(pMimeType->GetBuffer(), /* Flawfinder: ignore */
  620.                        pMimeStart, 
  621.                        ulMimeLength);
  623.                 if (ulPayloadMimeLength > 0)
  624.                 {
  625.                     memcpy(pMimeType->GetBuffer() + ulMimeLength + 1, /* Flawfinder: ignore */
  626.                            pPayloadMime, 
  627.                            ulPayloadMimeLength - 1);
  629.                     pMimeType->GetBuffer()[ulMimeLength] = '/';
  630.                 }
  631.                 
  632.                 pMimeType->GetBuffer()[ulMimeLength + 
  633.                                        ulPayloadMimeLength] = '';
  634.             }
  635.         }
  636.     }
  638.     if (SUCCEEDED(retVal))
  639.     {
  640.         pSDPValues->SetPropertyULONG32("RTPPayloadType", ulPayloadType);
  641.         pSDPValues->SetPropertyCString("MimeType", pMimeType);
  642.     }
  644.     HX_RELEASE(pMimeType);
  646.     return retVal;
  647. }
  650. static HX_RESULT PullRTPMap(char* pData, 
  651.                             ULONG32 ulLength, 
  652.                             IHXValues* pSDPValues,
  653.                             IHXCommonClassFactory* pClassFactory)
  654. {
  655.     char* pPattern = NULL;
  656.     char* pPatternEnd = NULL;
  657.     char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
  658.     char* pNumEnd = NULL;
  659.     ULONG32 ulPatternLength = 0;
  660.     ULONG32 ulPayloadType = 0;
  661.     ULONG32 ulMediaPayloadType = 0;
  662.     HX_RESULT retVal = HXR_FAIL;
  664.     // Extract the Payload Type
  665.     pPattern = StrNChr((char *) pData, ':',  ulLength);
  666.     if (pPattern)
  667.     {
  668.         ulPatternLength = (ulLength - ((++pPattern) - pData));
  670.         if (ulPatternLength > MAX_INT_TEXT_LENGTH)
  671.         {
  672.             ulPatternLength = MAX_INT_TEXT_LENGTH;
  673.         }
  675.         memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
  676.         pNumBuffer[ulPatternLength] = '';
  678.         ulPayloadType = strtol(pNumBuffer, &pNumEnd, 10);
  679.         
  680.         if (pNumEnd > pNumBuffer)
  681.         {
  682.             retVal = pSDPValues->GetPropertyULONG32(
  683.                 "RTPPayloadType", ulMediaPayloadType);
  684.         }
  685.     }
  687.     // Check if this is the payload type entry we are looking for
  688.     if (SUCCEEDED(retVal) && 
  689.         (ulMediaPayloadType == ulPayloadType))
  690.     {
  691.         IHXBuffer* pMimeType = NULL;
  692.         ULONG32 ulOldMimeTextLength;
  693.         BOOL bHasParams = TRUE;
  695.         // Locate New and Old Mime Name Section
  696.         pPattern = StrNChr((char *) pData, ' ',  ulLength);
  697.         retVal = HXR_FAIL;
  699.         if (pPattern)
  700.         {
  701.             pPattern++;
  702.             
  703.             pPatternEnd = StrNChr(pPattern, 
  704.                                   '/',
  705.                                   ulLength - (pPattern - pData));
  706.             if (pPatternEnd == NULL)
  707.             {
  708.                 bHasParams = FALSE;
  709.                 pPatternEnd = FindSDPFieldEnd(pPattern,
  710.                                               ulLength - (pPattern - pData));
  711.             }
  712.             
  713.             ulPatternLength = pPatternEnd - pPattern;
  714.             
  715.             if (ulPatternLength != 0)
  716.             {
  717.                 retVal = pSDPValues->GetPropertyCString(
  718.                     "MimeType", pMimeType);
  719.             }
  720.         }
  722.         // Realocate memory for combined name
  723.         if (SUCCEEDED(retVal))
  724.         {
  725.             pMimeType->Release();   // OK since pSDPValues has ref.
  726.             ulOldMimeTextLength = pMimeType->GetSize() - 1;
  727.             retVal = pMimeType->SetSize(
  728.                 ulOldMimeTextLength + ulPatternLength + 2);
  729.         }
  731.         // Copy in new Mime Name section
  732.         if (SUCCEEDED(retVal))
  733.         {
  734.             char *pMimeData = (char*) pMimeType->GetBuffer();
  736.             memcpy(pMimeData + ulOldMimeTextLength + 1, /* Flawfinder: ignore */
  737.                    pPattern,
  738.                    ulPatternLength);
  740.             pMimeData[ulOldMimeTextLength] = '/';
  741.             pMimeData[pMimeType->GetSize() - 1] = '';
  742.         }
  744.         // Check for parameters following mime type
  745.         if (SUCCEEDED(retVal))
  746.         {
  747.             ULONG32 ulParamIdx = 0;
  749.             while (bHasParams)
  750.             {
  751.                 pPattern += ulPatternLength + 1;
  752.                  
  753.                 pPatternEnd = StrNChr(pPattern, 
  754.                                       '/',
  755.                                       ulLength - (pPattern - pData));
  756.                 if (pPatternEnd == NULL)
  757.                 {
  758.                     bHasParams = FALSE;
  759.                     pPatternEnd = FindSDPFieldEnd(
  760.                                     pPattern,
  761.                                     ulLength - (pPattern - pData));
  762.                 }
  764.                 ulPatternLength = pPatternEnd - pPattern;
  765.             
  766.                 if (ulPatternLength != 0)
  767.                 {
  768.                     LONG32 lValue;
  770.                     if (ulPatternLength > MAX_INT_TEXT_LENGTH)
  771.                     {
  772.                         ulPatternLength = MAX_INT_TEXT_LENGTH;
  773.                     }
  774.                     
  775.                     memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
  776.                     pNumBuffer[ulPatternLength] = '';
  777.                     
  778.                     lValue = strtol(pNumBuffer, &pNumEnd, 10);
  780.                     if (pNumEnd > pNumBuffer)
  781.                     {
  782.                         switch (ulParamIdx)
  783.                         {
  784.                         case 0:
  785.                             pSDPValues->SetPropertyULONG32(
  786.                                 "SamplesPerSecond", (ULONG32) lValue);
  787.                             break;
  788.                         case 1:
  789.                             pSDPValues->SetPropertyULONG32(
  790.                                 "Channels", (ULONG32) lValue);
  791.                             break;
  792.                         default:
  793.                             // do nothing
  794.                             break;
  795.                         }
  796.                     }
  797.                 }
  799.                 ulParamIdx++;
  800.             }
  801.         }
  802.     }
  804.     return retVal;
  805. }
  808. static HX_RESULT PullControl(char* pData, 
  809.                              ULONG32 ulLength, 
  810.                              IHXValues* pSDPValues,
  811.                              IHXCommonClassFactory* pClassFactory)
  812. {
  813.     char* pPattern = NULL;
  814.     char* pPatternEnd = NULL;
  815.     ULONG32 ulPatternLength = 0;
  816.     IHXBuffer* pControl = NULL;
  817.     HX_RESULT retVal = HXR_FAIL;
  819.     pPattern = StrNChr((char *) pData, ':', ulLength);
  821.     if (pPattern)
  822.     {
  823.         pPattern++;
  824.         pPatternEnd = FindSDPFieldEnd(
  825.             pPattern, ulLength - (pPattern - pData));
  827.         ulPatternLength = pPatternEnd - pPattern;
  829.         if (ulPatternLength > 0)
  830.         {
  831.             retVal = pClassFactory->CreateInstance(
  832.                 CLSID_IHXBuffer,
  833.                 (void**) &pControl);
  834.         }
  835.     }
  837.     if (SUCCEEDED(retVal))
  838.     {
  839.         retVal = pControl->SetSize(ulPatternLength + 1);
  840.         memcpy(pControl->GetBuffer(), /* Flawfinder: ignore */
  841.                pPattern, 
  842.                ulPatternLength);
  843.         (pControl->GetBuffer())[ulPatternLength] = '';
  845.         pSDPValues->SetPropertyCString("Control", pControl);
  847.         HX_RELEASE(pControl);
  848.     }
  850.     return retVal;
  851. }
  854. static HX_RESULT PullClipRect(char* pData, 
  855.                               ULONG32 ulLength, 
  856.                               IHXValues* pSDPValues,
  857.                               IHXCommonClassFactory* pClassFactory)
  858. {
  859.     char* pPattern;
  860.     ULONG32 ulPatternLength;
  861.     char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
  862.     char* pNumEnd;
  863.     ULONG32 ulIdx = 0;
  864.     LONG32 lCoord[N_CLIPRECT_COORDS];
  865.     HX_RESULT retVal = HXR_FAIL;
  867.     pPattern = StrNChr((char *) pData, ':', ulLength);
  869.     if (pPattern)
  870.     {
  871.         do
  872.         {
  873.             ulPatternLength = (ulLength - ((++pPattern) - pData));
  874.             
  875.             if (ulPatternLength > MAX_INT_TEXT_LENGTH)
  876.             {
  877.                 ulPatternLength = MAX_INT_TEXT_LENGTH;
  878.             }
  879.             
  880.             memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
  881.             pNumBuffer[ulPatternLength] = '';
  882.             
  883.             lCoord[ulIdx] = strtol(pNumBuffer, &pNumEnd, 10);
  885.             if (pNumEnd == pNumBuffer)
  886.             {
  887.                 break;
  888.             }
  889.         } while (((++ulIdx) < N_CLIPRECT_COORDS) &&
  890.                  (pPattern = StrNChr((char *) pPattern, ',', ulLength)));
  892.         if (ulIdx == N_CLIPRECT_COORDS)
  893.         {
  894.             retVal = HXR_OK;
  895.         }
  896.     }
  898.     if (SUCCEEDED(retVal))
  899.     {
  900.         OrderUp(lCoord[0], lCoord[2]);
  901.         OrderUp(lCoord[1], lCoord[3]);
  903.         pSDPValues->SetPropertyULONG32("ClipFrameLeft", lCoord[1]);
  904.         pSDPValues->SetPropertyULONG32("ClipFrameRight", lCoord[3]);
  905.         pSDPValues->SetPropertyULONG32("ClipFrameTop", lCoord[0]);
  906.         pSDPValues->SetPropertyULONG32("ClipFrameBottom", lCoord[2]);
  907.     }
  909.     return retVal;
  910. }
  913. static HX_RESULT PullFormatParams(char* pData, 
  914.                                   ULONG32 ulLength, 
  915.                                   IHXValues* pSDPValues,
  916.                                   IHXCommonClassFactory* pClassFactory)
  917. {
  918.     char* pPattern = NULL;
  919.     char* pPatternEnd = NULL;
  920.     BOOL bParmNumeric = FALSE;
  921.     ULONG32 ulParmValue = 0;
  922.     ULONG32 ulPatternLength = 0;
  923.     char* pParmName = NULL;
  924.     IHXBuffer* pParmValue = NULL;
  925.     HX_RESULT retVal = HXR_FAIL;
  927.     // Find the start of name-value tuple
  928.     pPattern = FindSDPFieldEnd((char*) pData, ulLength);
  929.     if (pPattern)
  930.     {
  931.         ulPatternLength = (ulLength - (pPattern - pData));
  932.         retVal = HXR_OK;
  933.     }
  935.     do
  936.     {
  937.         // Find the start of name-value tuple
  938.         if (SUCCEEDED(retVal))
  939.         {
  940.             retVal = HXR_FAIL;
  941.             
  942.             pPattern = SkipSDPFieldEnd(pPattern, ulPatternLength);
  943.             if (pPattern)
  944.             {
  945.                 ulPatternLength = (ulLength - (pPattern - pData));
  946.                 retVal = HXR_OK;
  947.             }
  948.         }
  950.         if (SUCCEEDED(retVal))
  951.         {
  952.             if (ulPatternLength == 0)
  953.             {
  954.                 // Done: no more tuples
  955.                 break;
  956.             }
  957.         }
  959.         // Parse the tuple name
  960.         if (SUCCEEDED(retVal))
  961.         {
  962.             retVal = HXR_FAIL;
  963.             pPatternEnd = StrNChr((char*) pPattern, '=', ulPatternLength);
  964.             if (pPatternEnd)
  965.             {
  966.                 retVal = HXR_OK;
  967.             }
  968.         }
  970.         if (SUCCEEDED(retVal))
  971.         {
  972.             retVal = HXR_FAIL;
  973.             ulPatternLength = pPatternEnd - pPattern;
  974.             if (ulPatternLength > 0)
  975.             {
  976.                 retVal = HXR_OK;
  977.             }
  978.         }
  980.         if (SUCCEEDED(retVal))
  981.         {
  982.             retVal = HXR_OUTOFMEMORY;
  983.             pParmName = new char [ulPatternLength + FMPT_PREFIX_SIZE + 1];
  984.             if (pParmName)
  985.             {
  986.                 retVal = HXR_OK;
  987.             }
  988.         }
  990.         if (SUCCEEDED(retVal))
  991.         {
  992.             memcpy(pParmName, /* Flawfinder: ignore */
  993.                    FMPT_PREFIX,
  994.                    FMPT_PREFIX_SIZE);
  995.             memcpy(pParmName + FMPT_PREFIX_SIZE, /* Flawfinder: ignore */
  996.                    pPattern, 
  997.                    ulPatternLength);
  998.             pParmName[ulPatternLength + FMPT_PREFIX_SIZE] = '';
  1000.             pPattern = pPatternEnd;
  1001.             ulPatternLength = (ulLength - ((++pPattern) - pData));
  1002.         }
  1004.         // Parse the tuple value
  1005.         if (SUCCEEDED(retVal))
  1006.         {
  1007.             retVal = HXR_FAIL;
  1009.             pPatternEnd = StrNChr(pPattern, ';', ulPatternLength);
  1011.             if (!pPatternEnd)
  1012.             {
  1013.                 pPatternEnd = FindSDPFieldEnd(pPattern, ulPatternLength);
  1014.             }
  1016.             if (pPatternEnd)
  1017.             {
  1018.                 ulPatternLength = pPatternEnd - pPattern;
  1019.             }
  1021.             if (ulPatternLength > 0)
  1022.             {
  1023.                 retVal = HXR_OK;
  1024.             }
  1025.         }
  1027.         bParmNumeric = FALSE;
  1029.         if (SUCCEEDED(retVal) && (ulPatternLength <= (MAX_INT_TEXT_LENGTH - 1)))
  1030.         {
  1031.             char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
  1032.             char* pNumEnd = NULL;
  1034.             memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
  1035.             pNumBuffer[ulPatternLength] = '';
  1037.             ulParmValue = strtol(pNumBuffer, &pNumEnd, 10);
  1038.             if (pNumEnd && (pNumEnd == (pNumBuffer + ulPatternLength)))
  1039.             {
  1040.                 bParmNumeric = TRUE;
  1041.             }
  1042.         }
  1044.         if (bParmNumeric)
  1045.         {
  1046.             if (SUCCEEDED(retVal))
  1047.             {
  1048.                 retVal = pSDPValues->SetPropertyULONG32(pParmName, 
  1049.                                                         ulParmValue);
  1050.             }
  1051.         }
  1052.         else
  1053.         {
  1054.             if (SUCCEEDED(retVal))
  1055.             {
  1056.                 retVal = pClassFactory->CreateInstance(CLSID_IHXBuffer,
  1057.                     (void**) &pParmValue);
  1058.             }
  1059.             
  1060.             if (SUCCEEDED(retVal))
  1061.             {
  1062.                 retVal = pParmValue->SetSize(ulPatternLength + 1);
  1063.             }
  1064.             
  1065.             if (SUCCEEDED(retVal))
  1066.             {
  1067.                 UINT8* pBufferData = pParmValue->GetBuffer();
  1068.                 memcpy(pBufferData, pPattern, ulPatternLength); /* Flawfinder: ignore */
  1069.                 pBufferData[ulPatternLength] = '';
  1070.                 
  1071.                 retVal = pSDPValues->SetPropertyCString(pParmName, pParmValue);
  1072.             }
  1073.         }
  1075.         if (SUCCEEDED(retVal))
  1076.         {
  1077.             ulPatternLength = 0;
  1078.             pPattern = pPatternEnd;
  1079.             if (pPattern)
  1080.             {
  1081.                 ulPatternLength = (ulLength - ((++pPattern) - pData));
  1082.             }
  1083.         }
  1085.         HX_VECTOR_DELETE(pParmName);
  1086.         HX_RELEASE(pParmValue);
  1087.     } while (SUCCEEDED(retVal) && (ulPatternLength != 0));
  1089.     return retVal;
  1090. }
  1093. static HX_RESULT PullBufferDelay(char* pData, 
  1094.                                  ULONG32 ulLength, 
  1095.                                  IHXValues* pSDPValues,
  1096.                                  IHXCommonClassFactory* pClassFactory)
  1097. {
  1098.     char* pPattern;
  1099.     ULONG32 ulPatternLength;
  1100.     char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
  1101.     char* pNumEnd;
  1102.     ULONG32 ulPreroll;
  1103.     double fPreroll;
  1104.     HX_RESULT retVal = HXR_FAIL;
  1106.     if (pSDPValues->GetPropertyULONG32("Preroll", ulPreroll) != HXR_OK)
  1107.     {
  1108.         pPattern = StrNChr((char *) pData, ':', ulLength);
  1110.         if (pPattern)
  1111.         {
  1112.             ulPatternLength = (ulLength - ((++pPattern) - pData));
  1113.             
  1114.             if (ulPatternLength > MAX_INT_TEXT_LENGTH)
  1115.             {
  1116.                 ulPatternLength = MAX_INT_TEXT_LENGTH;
  1117.             }
  1118.             
  1119.             memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
  1120.             pNumBuffer[ulPatternLength] = '';
  1121.             
  1122.             fPreroll = strtod(pNumBuffer, &pNumEnd);
  1123.             
  1124.             if (pNumEnd > pNumBuffer)
  1125.             {
  1126.                 retVal = pSDPValues->SetPropertyULONG32(
  1127.                     "Preroll", 
  1128.                     (ULONG32) (fPreroll * 1000.0 + 0.5));
  1129.             }
  1130.         }
  1131.     }
  1133.     return retVal;
  1134. }
  1136. static HX_RESULT PullGroupID(char* pData, 
  1137.                              ULONG32 ulLength, 
  1138.                              IHXValues* pSDPValues,
  1139.                              IHXCommonClassFactory* pClassFactory)
  1140. {
  1141.     char* pPattern;
  1142.     ULONG32 ulPatternLength;
  1143.     char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
  1144.     char* pNumEnd;
  1145.     ULONG32 ulGroupID;
  1146.     HX_RESULT retVal = HXR_FAIL;
  1148.     pPattern = StrNChr((char *) pData, ':', ulLength);
  1150.     if (pPattern)
  1151.     {
  1152.         ulPatternLength = (ulLength - ((++pPattern) - pData));
  1154.         pPattern = StrNChr((char *) pPattern, '=', ulPatternLength);
  1155.     }
  1156.     
  1157.     if (pPattern)
  1158.     {
  1159.         ulPatternLength = (ulLength - ((++pPattern) - pData));
  1160.         
  1161.         if (ulPatternLength > MAX_INT_TEXT_LENGTH)
  1162.         {
  1163.             ulPatternLength = MAX_INT_TEXT_LENGTH;
  1164.         }
  1165.         
  1166.         memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
  1167.         pNumBuffer[ulPatternLength] = '';
  1168.         
  1169.         ulGroupID = strtol(pNumBuffer, &pNumEnd, 10);
  1170.                 
  1171.         if (pNumEnd > pNumBuffer)
  1172.         {
  1173.             retVal = pSDPValues->SetPropertyULONG32(
  1174.                 "AlternateGroupID",
  1175.                 ulGroupID);
  1176.         }
  1177.     }
  1179.     return retVal;
  1180. }
  1182. static HX_RESULT PullGroupBitrate(char* pData, 
  1183.                                   ULONG32 ulLength, 
  1184.                                   IHXValues* pSDPValues,
  1185.                                   IHXCommonClassFactory* pClassFactory)
  1186. {
  1187.     char* pPattern;
  1188.     ULONG32 ulPatternLength;
  1189.     char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
  1190.     char* pNumEnd;
  1191.     ULONG32 ulGroupBitrate;
  1192.     HX_RESULT retVal = HXR_FAIL;
  1194.     pPattern = StrNChr((char *) pData, ':', ulLength);
  1195.    
  1196.     if (pPattern)
  1197.     {
  1198.         ulPatternLength = (ulLength - ((++pPattern) - pData));
  1199.         
  1200.         pPattern = StrNChr((char *) pPattern, '=', ulPatternLength);
  1201.     }
  1203.     if (pPattern)
  1204.     {
  1205.         ulPatternLength = (ulLength - ((++pPattern) - pData));
  1206.         
  1207.         if (ulPatternLength > MAX_INT_TEXT_LENGTH)
  1208.         {
  1209.             ulPatternLength = MAX_INT_TEXT_LENGTH;
  1210.         }
  1211.         
  1212.         memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
  1213.         pNumBuffer[ulPatternLength] = '';
  1214.         
  1215.         ulGroupBitrate = strtol(pNumBuffer, &pNumEnd, 10);
  1216.                 
  1217.         if (pNumEnd > pNumBuffer)
  1218.         {
  1219.             retVal = pSDPValues->SetPropertyULONG32(
  1220.                 "AlternateGroupBitrate",
  1221.                 ulGroupBitrate);
  1222.         }
  1223.     }
  1225.     return retVal;
  1226. }
  1229. static HX_RESULT PullBandwidth (char* pData,
  1230.                                  ULONG32 ulLength, 
  1231.                                  IHXValues* pSDPValues,
  1232.                                  IHXCommonClassFactory* pClassFactory)
  1233. {        
  1234.     char* pPattern;
  1235.     ULONG32 ulPatternLength;
  1236.     char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
  1237.     char* pNumEnd;
  1238.     HX_RESULT retVal = HXR_FAIL;
  1240.     char* pPropName = NULL;
  1241.     ULONG32 ulBandwidth = 0;
  1242.     
  1243.     pPattern = StrNChr((char *) pData, ':', ulLength);           
  1244.     if (pPattern)
  1245.     {
  1246.         ulPatternLength = (ulLength - ((++pPattern) - pData));
  1247.         
  1248.         if (ulPatternLength > MAX_INT_TEXT_LENGTH)
  1249.         {
  1250.             ulPatternLength = MAX_INT_TEXT_LENGTH;
  1251.         }
  1252.         
  1253.         memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
  1254.         pNumBuffer[ulPatternLength] = '';
  1255.         
  1256.         ulBandwidth = strtol(pNumBuffer, &pNumEnd, 10);
  1258.         if (pNumEnd > pNumBuffer)
  1259.         {     
  1260.     // skip b=
  1261.     pData += 2;
  1262.     ulLength -= 2;
  1263.     if (StrNStr((char*)pData, "AS:", ulLength, 3))
  1264.     {        
  1265. pPropName = "AvgBitRate";
  1266. ulBandwidth *= 1000;
  1267.     }
  1268.     else if (StrNStr((char*)pData, "RR:", ulLength, 3))
  1269.     {        
  1270. pPropName = "RtcpRRRate";
  1271.     }
  1272.     else if (StrNStr((char*)pData, "RS:", ulLength, 3))
  1273.     {        
  1274. pPropName = "RtcpRSRate";
  1275.     }
  1276.     else
  1277.     {
  1278. // fine, ignore
  1279. retVal = HXR_OK;
  1280.     }    
  1281.         }
  1283. if (pPropName)
  1284. {
  1285.     retVal = pSDPValues->SetPropertyULONG32(pPropName, ulBandwidth);     
  1286. }
  1287.     }
  1289.     return retVal;
  1290. }
  1292. /****************************************************************************
  1293.  *  Local Utilities
  1294.  */
  1295. inline static ULONG32 GetPullTableIdx(const SDPRecordPuller* pTable,
  1296.                                       char* pData, 
  1297.                                       ULONG32 ulRecordSize)
  1298. {
  1299.     ULONG32 ulIdx = 0;
  1301.     HX_ASSERT(pTable);
  1303.     while (pTable->pSDPMatch != NULL)
  1304.     {
  1305.         if (pTable->ulSDPMatchSize <= ulRecordSize)
  1306.         {
  1307.             if (!strncmp(pTable->pSDPMatch, 
  1308.                          pData, 
  1309.                          pTable->ulSDPMatchSize))
  1310.             {
  1311.                 return ulIdx;
  1312.             }
  1313.         }
  1315.         pTable++;
  1316.         ulIdx++;
  1317.     }
  1319.     return BAD_PULL_TABLE_IDX;
  1320. }
  1323. inline static char* FindSDPFieldByIdx(char* pData, 
  1324.                                        ULONG32 ulLength, 
  1325.                                        ULONG32 ulIdx)
  1326. {
  1327.     char* pField;
  1329.     while((ulIdx != 0) && (pData != NULL))
  1330.     {
  1331.         pField = StrNChr((char *) pData, ' ', ulLength);
  1332.         if (pField)
  1333.         {
  1334.             ulLength -= ((++pField) - pData);  
  1335.             ulIdx--;
  1336.         }
  1337.         pData = pField;
  1338.     } 
  1340.     if (ulLength == 0)
  1341.     {
  1342.         pData = NULL;
  1343.     }
  1345.     return pData;
  1346. }
  1348. inline static char* FindSDPFieldEnd(char* pData, 
  1349.                                      ULONG32 ulLength)
  1350. {
  1351.     while((ulLength != 0) &&
  1352.           (*pData != ' ') &&
  1353.           (*pData != CHAR_CR) &&
  1354.           (*pData != CHAR_LF))
  1355.     {
  1356.         pData++;
  1357.         ulLength--;
  1358.     } 
  1360.     return pData;
  1361. }
  1363. inline static char* FindCRLF(char* pData, 
  1364.                              ULONG32 ulLength)
  1365. {
  1366.     HX_ASSERT(pData && ulLength);
  1367.     
  1368.     while((0 != ulLength) &&
  1369.           (CHAR_CR != *pData))
  1370.     {
  1371.         pData++;
  1372.         ulLength--;
  1373.     } 
  1375.     if (ulLength)
  1376.     {
  1377.         if (*(pData+1) == CHAR_LF)
  1378.         {
  1379.             // found it
  1380.             return pData;
  1381.         }
  1382.         else
  1383.         {
  1384.             pData++;
  1385.             ulLength--;
  1386.             return FindCRLF(pData, ulLength);
  1387.         }
  1388.     }
  1390.     return NULL;
  1391. }
  1393. /*
  1394.  * saves what pData points to upto CRLF sequence in pLine ('' terminated)
  1395.  */
  1396. inline static HX_RESULT PullLine(char* pData, 
  1397.                              ULONG32 ulLength,
  1398.                              REF(IHXBuffer*) pLine,
  1399.                              IHXCommonClassFactory* pClassFactory)
  1400. {
  1401.     HX_ASSERT(pData && ulLength);
  1402.     
  1403.     char* pc = NULL;
  1404.     HX_RESULT retVal = HXR_FAIL;
  1406.     pc = FindCRLF((char*)pData, ulLength);
  1407.     if (pc)
  1408.     {
  1409.         HX_ASSERT((pc > pData) && (ulLength > (ULONG32)(pc - pData)));
  1410.         ulLength = pc - pData;
  1411.         retVal = HXR_OK;
  1412.     }
  1414.     if (SUCCEEDED(retVal))
  1415.     {
  1416.         retVal = pClassFactory->CreateInstance
  1417.             (CLSID_IHXBuffer, (void**) &pLine);
  1418.     }
  1420.     if (SUCCEEDED(retVal))
  1421.     {
  1422.         retVal = pLine->SetSize(ulLength + 1);
  1423.         BYTE* pcLine = pLine->GetBuffer();
  1424.         memcpy(pcLine, pData, ulLength); /* Flawfinder: ignore */
  1425.         pcLine[ulLength] = '';
  1426.     }
  1428.     return retVal;            
  1429. }
  1432. inline static char* SkipSDPFieldEnd(char* pData, ULONG32 ulSize)
  1433. {
  1434.     while((ulSize > 0) &&
  1435.           ((*pData == CHAR_CR) ||
  1436.            (*pData == CHAR_LF) ||
  1437.            (*pData == ' ')))
  1438.     {
  1439.         pData++;
  1440.         ulSize--;
  1441.     } 
  1443.     return pData;
  1444. }
  1446. inline static void OrderUp(LONG32 &l1, LONG32 &l2)
  1447. {
  1448.     LONG32 temp;
  1450.     if (l1 > l2)
  1451.     {
  1452.         temp = l1;
  1453.         l1 = l2;
  1454.         l2 = temp;
  1455.     }
  1456. }