httpmsg.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:9k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. //#include "hlxclib/stdlib.h"
  36. //#include "hlxclib/stdio.h"
  37. #include "hxcom.h"
  38. #include "hxtypes.h"
  39. #include "hxstrutl.h"
  40. #include "hxstring.h"
  41. #include "hxslist.h"
  42. #include "mimehead.h"
  43. #include "ihxpckts.h"
  44. #include "hxauth.h"
  45. #include "httpmsg.h"
  46. #include "hxheap.h"
  47. #ifdef _DEBUG
  48. #undef HX_THIS_FILE
  49. static const char HX_THIS_FILE[] = __FILE__;
  50. #endif
  51. // static definitions
  52. const int HTTPMessage::MAJ_VERSION = 1;
  53. const int HTTPMessage::MIN_VERSION = 0;
  54. /*
  55.  * HTTPAuthentication methods
  56.  */
  57. HTTPAuthentication::HTTPAuthentication(const char* authString,
  58.     AuthenticationType authType):
  59.     m_authString(authString),
  60.     m_authValues(NULL),
  61.     m_authType(authType)
  62. {
  63. }
  64. HTTPAuthentication::HTTPAuthentication(IHXValues* pAuth):
  65.     m_authValues(pAuth),
  66.     m_authType(AU_DIGEST)
  67. {
  68.     if(m_authValues)
  69.         m_authValues->AddRef();
  70. }
  71. HTTPAuthentication::~HTTPAuthentication()
  72. {
  73.     if(m_authValues)
  74.         m_authValues->Release();
  75. }
  76. void
  77. HTTPAuthentication::asString(CHXString& str)
  78. {
  79.     if(m_authType == AU_HX_PRIVATE)
  80.     {
  81.         str = CHXString("HXPrivate nonce="") + m_authString + """;
  82.     }
  83.     else if(m_authType == AU_DIGEST)
  84.     {
  85.         UINT32 subAuthType;
  86.         if(HXR_OK != m_authValues->GetPropertyULONG32("AuthType", subAuthType))
  87.         {
  88.             str = "";
  89.             return;
  90.         }
  91.         switch(subAuthType)
  92.         {
  93.             case HX_AUTH_DIGEST:
  94.             {
  95.                 IHXBuffer* pRealm = 0;
  96.                 IHXBuffer* pNonce = 0;
  97.                 IHXBuffer* pOpaque= 0;
  98.                 if(HXR_OK == m_authValues->GetPropertyCString("Realm", pRealm) &&
  99.                    HXR_OK == m_authValues->GetPropertyCString("Nonce", pNonce) &&
  100.                    HXR_OK == m_authValues->GetPropertyCString("Opaque", pOpaque))
  101.                 {
  102.                     str = CHXString("Digest realm=") +
  103.                         pRealm->GetBuffer() + ",rn" +
  104.                         "    nonce=" + pNonce->GetBuffer() + ",rn" +
  105.                         "    opaque=" + pOpaque->GetBuffer();
  106.                 }
  107.                 if(pRealm) pRealm->Release();
  108.                 if(pNonce) pNonce->Release();
  109.                 if(pOpaque) pOpaque->Release();
  110.                 break;
  111.             }
  112.             case HX_AUTH_BASIC:
  113.             {
  114.                 IHXBuffer* pRealm = 0;
  115.                 IHXBuffer* pUserName = 0;
  116.                 IHXBuffer* pPassword = 0;
  117.                 IHXBuffer* pResponse = 0;
  118.                 if(HXR_OK == m_authValues->GetPropertyCString("Realm", pRealm))
  119.                 {
  120.                     str = CHXString("Basic realm=") +
  121.                         pRealm->GetBuffer();
  122.                 }
  123.                 else if(HXR_OK == m_authValues->GetPropertyCString(
  124.                     "Response", pResponse))
  125.                 {
  126.                     str = CHXString("Basic ") + pResponse->GetBuffer();
  127.                 }
  128.                 else if(HXR_OK == m_authValues->GetPropertyCString(
  129.                                                    "UserName", pUserName) &&
  130.                     HXR_OK == m_authValues->GetPropertyCString("Password",
  131.                                                                pPassword))
  132.                 {
  133.                     str = CHXString(pUserName->GetBuffer()) +
  134.                         ":" + pPassword->GetBuffer();
  135.                 }
  136.                 if(pUserName) pUserName->Release();
  137.                 if(pPassword) pPassword->Release();
  138.                 if(pResponse) pResponse->Release();
  139.                 if(pRealm) pRealm->Release();
  140.                 break;
  141.             }
  142.             default:
  143.                 str = "";
  144.                 break;
  145.         }
  146.     }
  147.     else
  148.     {
  149.         str = "";
  150.     }
  151. }
  152. CHXString
  153. HTTPAuthentication::asString()
  154. {
  155.     CHXString str;
  156.     asString(str);
  157.     return str;
  158. }
  159. HTTPMessage::HTTPMessage()
  160. {
  161.     setVersion(MAJ_VERSION, MIN_VERSION);
  162. }
  163. HTTPMessage::~HTTPMessage()
  164. {
  165.     clearHeaderList();
  166. }
  167. void
  168. HTTPMessage::addHeader(MIMEHeader* pHeader)
  169. {
  170.     m_headers.AddTail(pHeader);
  171. }
  172. void 
  173. HTTPMessage::addHeader(const char* pName, const char* pValue)
  174. {
  175.     MIMEHeader* pHeader = new MIMEHeader(pName);
  176.     pHeader->addHeaderValue(pValue);
  177.     addHeader(pHeader);
  178. }
  179. MIMEHeader*
  180. HTTPMessage::getHeader(const char* pName)
  181. {
  182.     LISTPOSITION pos = m_headers.GetHeadPosition();
  183.     while(pos)
  184.     {
  185. MIMEHeader* pHeader = (MIMEHeader*)m_headers.GetNext(pos);
  186. if(strcasecmp(pHeader->name(), pName) == 0)
  187. {
  188.     return pHeader;
  189. }
  190.     }
  191.     return 0;
  192. }
  193. CHXString
  194. HTTPMessage::getHeaderValue(const char* pName)
  195. {
  196.     MIMEHeader* pHeader = getHeader(pName);
  197.     if(pHeader)
  198.     {
  199. MIMEHeaderValue* pHeaderValue = pHeader->getFirstHeaderValue();
  200. if(pHeaderValue)
  201. {
  202.     return pHeaderValue->value();
  203. }
  204.     }
  205.     return CHXString("");
  206. }
  207. int
  208. HTTPMessage::getHeaderValue(const char* pName, UINT32& value)
  209. {
  210.     CHXString strValue = getHeaderValue(pName);
  211.     if(strValue != "")
  212.     {
  213. value = strtol((const char*)strValue, 0, 10);
  214. return 1;
  215.     }
  216.     return 0;
  217. }
  218. MIMEHeader*
  219. HTTPMessage::getFirstHeader()
  220. {
  221.     m_listpos = m_headers.GetHeadPosition();
  222.     if(m_listpos)
  223. return (MIMEHeader*)m_headers.GetNext(m_listpos);
  224.     return 0;
  225. }
  226. MIMEHeader*
  227. HTTPMessage::getNextHeader()
  228. {
  229.     if(m_listpos)
  230. return (MIMEHeader*)m_headers.GetNext(m_listpos);
  231.     return 0;
  232. }
  233. void
  234. HTTPMessage::clearHeaderList()
  235. {
  236.     MIMEHeader* pHeader = getFirstHeader();
  237.     while(pHeader)
  238.     {
  239. delete pHeader;
  240. pHeader = getNextHeader();
  241.     }
  242. }
  243. void 
  244. HTTPMessage::setContent(BYTE* pBuf, UINT32 pBufLen)
  245. {
  246.     m_content = CHXString((const char*)pBuf, HX_SAFEUINT(pBufLen));
  247. }
  248. int
  249. HTTPMessage::contentLength()
  250. {
  251.     return m_content.GetLength();
  252. }
  253. void
  254. HTTPRequestMessage::asString(char* pBuf, int& msgLen, UINT32 ulBufLen)
  255. {
  256. int lenTmpBuf = strlen(url()) + strlen(tagStr()) + 80;
  257.     char* tmpBuf = new char[lenTmpBuf];
  258.     SafeSprintf(tmpBuf, lenTmpBuf, "%s %s HTTP/%d.%drn",
  259. tagStr(), url(), majorVersion(), minorVersion());
  260.     CHXString msgStr = tmpBuf;
  261.     MIMEHeader* pHeader = getFirstHeader();
  262.     while(pHeader)
  263.     {
  264. msgStr += pHeader->name();
  265. msgStr += ": ";
  266. pHeader->asString(msgStr);
  267. pHeader = getNextHeader();
  268.     }
  269.     msgStr += "rn";
  270.     if(contentLength() > 0)
  271.     {
  272. msgStr += getContent();
  273.     }
  274.     SafeStrCpy(pBuf, msgStr, ulBufLen);
  275.     msgLen = strlen(pBuf);
  276.     delete[] tmpBuf;
  277. }
  278. void
  279. HTTPResponseMessage::asString(char* pMsg, int& msgLen, UINT32 ulBufLen)
  280. {
  281. int lenTmpBuf = 64 + m_errorMsg.GetLength();
  282.     char* pTmpBuf = new char[lenTmpBuf];
  283.     SafeSprintf
  284.     (
  285. pTmpBuf,  lenTmpBuf,
  286. "HTTP/%d.%d %s %srn",
  287. majorVersion(), 
  288. minorVersion(), 
  289. (const char*)m_errorCode,
  290. (const char*)m_errorMsg
  291.     );
  292.     CHXString msgStr = pTmpBuf;
  293.     delete[] pTmpBuf;
  294.     MIMEHeader* pHeader = getFirstHeader();
  295.     while(pHeader)
  296.     {
  297. msgStr += pHeader->name();
  298. msgStr += ": ";
  299. pHeader->asString(msgStr);
  300. pHeader = getNextHeader();
  301.     }
  302.     if(contentLength() > 0)
  303.     {
  304. msgStr += getContent();
  305.     }
  306.     msgStr += "rn";
  307.     SafeStrCpy(pMsg, msgStr, ulBufLen);
  308.     msgLen = strlen(pMsg);
  309. }