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

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

Symbian

开发平台：

C/C++

rtspmsg.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. //#include "hlxclib/stdlib.h"
  37. //#include "hlxclib/stdio.h"
  39. #include "hxcom.h"
  40. #include "hxstring.h"
  41. #include "hxslist.h"
  42. #include "hxstrutl.h"
  43. #include "hxtypes.h"
  45. #include "smpte.h"
  46. #include "nptime.h"
  48. #include "mimehead.h"
  49. #include "rtspmsg.h"
  51. #include "ihxpckts.h"
  52. #include "hxauth.h"
  54. #include "chxpckts.h"
  55. #include "hxbuffer.h"
  57. #include "hxheap.h"
  58. #ifdef _DEBUG
  59. #undef HX_THIS_FILE
  60. static const char HX_THIS_FILE[] = __FILE__;
  61. #endif
  63. RTSPRange::RTSPRange(UINT32 begin, UINT32 end, RangeType rType):
  64.     m_begin(begin),
  65.     m_end(end),
  66.     m_rangeType(rType)
  67. {
  68.     if(m_rangeType == TR_SMPTE)
  69.     {
  70. SMPTETimeCode tBegin(m_begin);
  71. SMPTETimeCode tEnd(m_end);
  72. char tmpBuf[80]; /* Flawfinder: ignore */
  74. if(m_begin != RTSP_PLAY_RANGE_BLANK && 
  75.    m_end == RTSP_PLAY_RANGE_BLANK)
  76. {
  77.     SafeSprintf(tmpBuf, 80, "%s-", (const char*)tBegin);
  78. }
  79. else if(m_begin != RTSP_PLAY_RANGE_BLANK && 
  80. m_end != RTSP_PLAY_RANGE_BLANK)
  81. {
  82.     SafeSprintf(tmpBuf, 80, "%s-%s", (const char*)tBegin, (const char*)tEnd);
  83. }
  84. else if(m_begin == RTSP_PLAY_RANGE_BLANK && 
  85.         m_end != RTSP_PLAY_RANGE_BLANK)
  86. {
  87.     SafeSprintf(tmpBuf, 80, "-%s", (const char*)tEnd);
  88. }
  89. else if(m_begin == RTSP_PLAY_RANGE_BLANK &&
  90.         m_end == RTSP_PLAY_RANGE_BLANK)
  91. {
  92.     strcpy(tmpBuf, "-"); /* Flawfinder: ignore */
  93. }
  94. else if(m_begin == 0 && m_end == 0)
  95. {
  96.     SafeSprintf(tmpBuf, 80, "0-0"); 
  97. }
  98. else
  99. {
  100.     tmpBuf[0] = 0;
  101. }
  102. addParameter(tmpBuf);
  103.     }
  104.     else if(m_rangeType == TR_NPT)
  105.     {
  106. NPTime tBegin(m_begin);
  107. NPTime tEnd(m_end);
  108. char tmpBuf[80]; /* Flawfinder: ignore */
  110. if(m_begin != RTSP_PLAY_RANGE_BLANK && 
  111.    m_end == RTSP_PLAY_RANGE_BLANK)
  112. {
  113.     SafeSprintf(tmpBuf, 80, "%s-", (const char*)tBegin);
  114. }
  115. else if(m_begin != RTSP_PLAY_RANGE_BLANK && 
  116. m_end != RTSP_PLAY_RANGE_BLANK)
  117. {
  118.     SafeSprintf(tmpBuf, 80, "%s-%s", (const char*)tBegin, (const char*)tEnd);
  119. }
  120. else if(m_begin == RTSP_PLAY_RANGE_BLANK && 
  121.         m_end != RTSP_PLAY_RANGE_BLANK)
  122. {
  123.     SafeSprintf(tmpBuf, 80, "-%s", (const char*)tEnd);
  124. }
  125. else if(m_begin == RTSP_PLAY_RANGE_BLANK &&
  126.         m_end == RTSP_PLAY_RANGE_BLANK)
  127. {
  128.     SafeSprintf(tmpBuf, 80, "-"); 
  129. }
  130. else if(m_begin == 0 && m_end == 0)
  131. {
  132.     SafeSprintf(tmpBuf, 80, "0-0"); 
  133. }
  134. else
  135. {
  136.     tmpBuf[0] = 0;
  137. }
  138. addParameter(tmpBuf);
  139.     }
  140.     else if(m_rangeType == TR_CLOCK)
  141.     {
  142.     }
  143. }
  145. void
  146. RTSPRange::asString(CHXString& str)
  147. {
  148.     MIMEParameter* pParam = getFirstParameter();
  149.     if(pParam)
  150.     {
  151. if(m_rangeType == TR_SMPTE)
  152. {
  153.     str = CHXString("smpte=") + pParam->m_attribute;
  154. }
  155. else if(m_rangeType == TR_NPT)
  156. {
  157.     str = CHXString("npt=") + pParam->m_attribute;
  158. }
  159.     }
  160.     else
  161.     {
  162. str = "";
  163.     }
  164. }
  166. CHXString
  167. RTSPRange::asString()
  168. {
  169.     CHXString str;
  170.     asString(str);
  171.     return str;
  172. }
  175. /*
  176.  * RTSPAuthentication methods
  177.  */
  179. RTSPAuthentication::RTSPAuthentication(const char* authString,
  180.     AuthenticationType authType):
  181.     m_authString(authString),
  182.     m_authValues(NULL),
  183.     m_authType(authType)
  184. {
  185. }
  187. RTSPAuthentication::RTSPAuthentication(IHXValues* pAuth):
  188.     m_authValues(pAuth),
  189.     m_authType(AU_DIGEST)
  190. {
  191.     if(m_authValues)
  192. m_authValues->AddRef();
  193. }
  195. RTSPAuthentication::~RTSPAuthentication()
  196. {
  197.     if(m_authValues)
  198. m_authValues->Release();
  199. }
  201. void
  202. RTSPAuthentication::asString(CHXString& str)
  203. {
  204.     if(m_authType == AU_HX_PRIVATE)
  205.     {
  206. str = CHXString("HXPrivate nonce="") + m_authString + """;
  207.     }
  208.     else if(m_authType == AU_DIGEST)
  209.     {
  210. UINT32 subAuthType;
  212. if(HXR_OK != m_authValues->GetPropertyULONG32("AuthType", subAuthType))
  213. {
  214.     str = "";
  215.     return;
  216. }
  218. switch(subAuthType)
  219. {
  220.     case HX_AUTH_DIGEST:
  221.     {
  222. IHXBuffer* pRealm = 0;
  223. IHXBuffer* pNonce = 0;
  224. IHXBuffer* pOpaque= 0;
  226. if(HXR_OK == m_authValues->GetPropertyCString("Realm", pRealm) &&
  227.    HXR_OK == m_authValues->GetPropertyCString("Nonce", pNonce) &&
  228.    HXR_OK == m_authValues->GetPropertyCString("Opaque", pOpaque))
  229. {
  231.     str = CHXString("Digest realm="") + 
  232. pRealm->GetBuffer() + "",rn" +
  233. "    nonce=" + pNonce->GetBuffer() + ",rn" +
  234. "    opaque=" + pOpaque->GetBuffer();
  235. }
  236. if(pRealm) pRealm->Release();
  237. if(pNonce) pNonce->Release();
  238. if(pOpaque) pOpaque->Release();
  239. break;
  240.     }
  241.     case HX_AUTH_BASIC:
  242.     {
  243. IHXBuffer* pRealm = 0;
  244. IHXBuffer* pUserName = 0;
  245. IHXBuffer* pPassword = 0;
  246. IHXBuffer* pResponse = 0;
  247. if(HXR_OK == m_authValues->GetPropertyCString("Realm", pRealm))
  248. {
  249.     str = CHXString("Basic realm="") + 
  250. pRealm->GetBuffer() + """;
  251. }
  252. else if(HXR_OK == m_authValues->GetPropertyCString(
  253.     "Response", pResponse))
  254. {
  255.     str = CHXString("Basic ") + pResponse->GetBuffer();
  256. }
  257. else if(HXR_OK == m_authValues->GetPropertyCString(
  258.                                    "UserName", pUserName) &&
  259.     HXR_OK == m_authValues->GetPropertyCString("Password",
  260.        pPassword))
  261. {
  262.     str = CHXString(pUserName->GetBuffer()) + 
  263. ":" + pPassword->GetBuffer();
  264. }
  265. if(pUserName) pUserName->Release();
  266. if(pPassword) pPassword->Release();
  267. if(pResponse) pResponse->Release();
  268. if(pRealm) pRealm->Release();
  269. break;
  270.     }
  271.     default:
  272. str = "";
  273. break;
  274. }
  275.     }
  276.     else
  277.     {
  278. str = "";
  279.     }
  280. }
  282. CHXString
  283. RTSPAuthentication::asString()
  284. {
  285.     CHXString str;
  286.     asString(str);
  287.     return str;
  288. }
  290. RTSPDigestAuthorization::RTSPDigestAuthorization(IHXValues* pValues):
  291.     m_values(pValues)
  292. {
  293.     if(m_values)
  294. m_values->AddRef();
  295. }
  297. void
  298. RTSPDigestAuthorization::asString(CHXString& str)
  299. {
  300.     char buf[1024]; /* Flawfinder: ignore */
  301.     IHXBuffer* strBuf;
  303.     INT32 lBytes = 0;
  304.     lBytes += SafeSprintf(buf, 1024, "Digest ");
  305.     if(HXR_OK == m_values->GetPropertyCString("UserName", strBuf))
  306.     {
  307. lBytes += SafeSprintf(buf + lBytes, 1024 - lBytes, "username="%s",", strBuf->GetBuffer());
  308. strBuf->Release();
  309.     }
  310.     if(HXR_OK == m_values->GetPropertyCString("Realm", strBuf))
  311.     {
  312. lBytes += SafeSprintf(buf + lBytes, 1024 - lBytes, "realm="%s",", strBuf->GetBuffer());
  313. strBuf->Release();
  314.     }
  315.     if(HXR_OK == m_values->GetPropertyCString("Response", strBuf))
  316.     {
  317. lBytes += SafeSprintf(buf + lBytes, 1024 - lBytes, "response="%s",", strBuf->GetBuffer());
  318. strBuf->Release();
  319.     }
  320.     if(HXR_OK == m_values->GetPropertyCString("URI", strBuf))
  321.     {
  322. lBytes += SafeSprintf(buf + lBytes, 1024 - lBytes, "uri="%s",", strBuf->GetBuffer());
  323. strBuf->Release();
  324.     }
  325.     if(HXR_OK == m_values->GetPropertyCString("UserName", strBuf))
  326.     {
  327. lBytes += SafeSprintf(buf + lBytes, 1024 - lBytes, "nonce="%s",", strBuf->GetBuffer());
  328. strBuf->Release();
  329.     }
  330.     if(HXR_OK == m_values->GetPropertyCString("UserName", strBuf))
  331.     {
  332. lBytes += SafeSprintf(buf + lBytes, 1024 - lBytes, "opaque="%s",", strBuf->GetBuffer());
  333. strBuf->Release();
  334.     }
  335.     char* comma = strrchr(buf, ',');
  336.     if(comma)
  337. *comma = 0;
  339.     str = CHXString(buf);
  340. }
  342. CHXString
  343. RTSPDigestAuthorization::asString()
  344. {
  345.     CHXString str;
  346.     asString(str);
  347.     return str;
  348. }
  351. /*
  352.  * RTSPPEPInfo methods
  353.  */
  355. RTSPPEPInfo::RTSPPEPInfo(BOOL bStrengthMust):
  356.     m_bStrengthMust(bStrengthMust)
  357. {
  358. }
  360. RTSPPEPInfo::~RTSPPEPInfo()
  361. {
  362. }
  364. void
  365. RTSPPEPInfo::asString(CHXString& str)
  366. {
  367.     if(m_bStrengthMust)
  368.     {
  369. str = "{ {strength must} }";
  370.     }
  371.     else
  372.     {
  373. str = "{ {strength may} }";
  374.     }
  375. }
  377. CHXString
  378. RTSPPEPInfo::asString()
  379. {
  380.     CHXString str;
  381.     asString(str);
  382.     return str;
  383. }
  386. // static definitions
  388. const int RTSPMessage::MAJ_VERSION = 1;
  389. const int RTSPMessage::MIN_VERSION = 0;
  391. RTSPMessage::RTSPMessage():
  392.     m_seqNo(0)
  393. {
  394.     setVersion(MAJ_VERSION, MIN_VERSION);
  395. }
  397. RTSPMessage::~RTSPMessage()
  398. {
  399.     clearHeaderList();
  400. }
  402. void
  403. RTSPMessage::addHeader(MIMEHeader* pHeader, BOOL bAtHead)
  404. {
  405.     if(bAtHead)
  406.     {
  407. m_headers.AddHead(pHeader);
  408.     }
  409.     else
  410.     {
  411. m_headers.AddTail(pHeader);
  412.     }
  413. }
  415. void 
  416. RTSPMessage::addHeader(const char* pName, const char* pValue, BOOL bAtHead)
  417. {
  418.     MIMEHeader* pHeader = new MIMEHeader(pName);
  419.     pHeader->addHeaderValue(pValue);
  420.     addHeader(pHeader, bAtHead);
  421. }
  423. MIMEHeader*
  424. RTSPMessage::getHeader(const char* pName)
  425. {
  426.     LISTPOSITION pos = m_headers.GetHeadPosition();
  427.     while(pos)
  428.     {
  429. MIMEHeader* pHeader = (MIMEHeader*)m_headers.GetNext(pos);
  430. if(strcasecmp(pHeader->name(), pName) == 0)
  431. {
  432.     return pHeader;
  433. }
  434.     }
  435.     return 0;
  436. }
  438. CHXString
  439. RTSPMessage::getHeaderValue(const char* pName)
  440. {
  441.     MIMEHeader* pHeader = getHeader(pName);
  442.     if(pHeader)
  443.     {
  444. MIMEHeaderValue* pHeaderValue = pHeader->getFirstHeaderValue();
  445. if(pHeaderValue)
  446. {
  447.     CHXString str = pHeaderValue->value();
  448.     return str;
  449. }
  450.     }
  451.     return CHXString("");
  452. }
  454. int
  455. RTSPMessage::getHeaderValue(const char* pName, UINT32& value)
  456. {
  457.     CHXString strValue = getHeaderValue(pName);
  458.     if(strValue.GetLength() > 0)
  459.     {
  460. value = strtol((const char*)strValue, 0, 10);
  461. return 1;
  462.     }
  463.     return 0;
  464. }
  466. MIMEHeader*
  467. RTSPMessage::getFirstHeader()
  468. {
  469.     m_listpos = m_headers.GetHeadPosition();
  470.     if(m_listpos)
  471. return (MIMEHeader*)m_headers.GetNext(m_listpos);
  472.     return 0;
  473. }
  475. MIMEHeader*
  476. RTSPMessage::getNextHeader()
  477. {
  478.     if(m_listpos)
  479. return (MIMEHeader*)m_headers.GetNext(m_listpos);
  480.     return 0;
  481. }
  483. void
  484. RTSPMessage::clearHeaderList()
  485. {
  486.     MIMEHeader* pHeader = getFirstHeader();
  487.     while(pHeader)
  488.     {
  489. delete pHeader;
  490. pHeader = getNextHeader();
  491.     }
  492. }
  494. int
  495. RTSPMessage::contentLength()
  496. {
  497.     return m_content.GetLength();
  498. }
  500. HX_RESULT 
  501. RTSPMessage::AsValues(REF(IHXValues*) pIHXValuesHeaders)
  502. {
  503.     pIHXValuesHeaders = new CHXHeader;
  505.     if(pIHXValuesHeaders)
  506.     {
  507. pIHXValuesHeaders->AddRef();
  509. IHXBuffer* pIHXBufferValue = NULL;
  510. MIMEHeader* pMIMEHeaderCurrent = getFirstHeader();
  511. CHXString CHXStringValue;
  513. while(pMIMEHeaderCurrent)
  514. {
  515.     CHXStringValue.Empty();
  516.     pMIMEHeaderCurrent->asString(CHXStringValue);
  518.     CHXBuffer::FromCharArray
  519.     (
  520. CHXStringValue,
  521. &pIHXBufferValue
  522.     );
  524.     pIHXValuesHeaders->SetPropertyCString
  525.     (
  526. pMIMEHeaderCurrent->name(),
  527. pIHXBufferValue
  528.     );
  530.     HX_RELEASE(pIHXBufferValue);
  532.     pMIMEHeaderCurrent = getNextHeader();
  533. }
  535. return HXR_OK;
  536.     }
  538.     return HXR_OUTOFMEMORY;
  539. }
  541. CHXString
  542. RTSPRequestMessage::asString()
  543. {
  544. int lenTmpBuf = strlen(tagStr()) + strlen(url()) + 80;
  545.     char* pTmpBuf = new char[lenTmpBuf];
  546.     SafeSprintf(pTmpBuf, lenTmpBuf, "%s %s RTSP/%d.%drn",
  547. tagStr(), url(), majorVersion(), minorVersion());
  549.     CHXString msgStr = pTmpBuf;
  550.     delete[] pTmpBuf;
  552.     MIMEHeader* pHeader = getFirstHeader();
  553.     while(pHeader)
  554.     {
  555. msgStr += pHeader->name();
  556. msgStr += ": ";
  557. pHeader->asString(msgStr);
  558. pHeader = getNextHeader();
  559.     }
  560.     msgStr += "rn";
  561.     if(contentLength() > 0)
  562.     {
  563. msgStr += getContent();
  564.     }
  565.     return msgStr;
  566. }
  568. void
  569. RTSPRequestMessage::asString(char* pBuf, int& msgLen)
  570. {
  571.     CHXString msgStr = asString();
  572.     SafeStrCpy(pBuf, msgStr, msgLen);
  573.     msgLen = strlen(pBuf);
  574. }
  576. CHXString
  577. RTSPResponseMessage::asString()
  578. {
  579. int lenTmpBuf = m_errorMsg.GetLength() + 80;
  580.     char* pTmpBuf = new char[lenTmpBuf];
  581.     SafeSprintf(pTmpBuf, lenTmpBuf, "RTSP/%d.%d %s %srn",
  582. majorVersion(), minorVersion(), (const char*)m_errorCode,
  583. (const char*)m_errorMsg);
  585.     CHXString msgStr = pTmpBuf;
  586.     delete[] pTmpBuf;
  588.     MIMEHeader* pHeader = getFirstHeader();
  589.     while(pHeader)
  590.     {
  591. msgStr += pHeader->name();
  592. msgStr += ": ";
  593. pHeader->asString(msgStr);
  594. pHeader = getNextHeader();
  595.     }
  596.     msgStr += "rn";
  597.     if(contentLength() > 0)
  598.     {
  599. msgStr += getContent();
  600.     }
  601.     return msgStr;
  602. }
  604. void
  605. RTSPResponseMessage::asString(char* pMsg, int& msgLen)
  606. {
  607.     CHXString msgStr = asString();
  608.     SafeStrCpy(pMsg, msgStr, msgLen);
  609.     msgLen = strlen(pMsg);
  610. }