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

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

Symbian

开发平台：

C/C++

hxcloakedtcp.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 ***** */ 
  35. #include "hlxclib/stdio.h"   
  36. #include "hxcloakedtcp.h"
  38. #include "safestring.h"
  40. #include "hxnetutil.h"
  42. #include "ihxpckts.h"
  43. #include "hxccf.h" // IHXCommonClassFactory
  45. #include "hxthread.h" // HXMutex
  46. #include "hxbuffer.h" // CHXBuffer
  47. #include "conn.h"     // TCP_BUF_SIZE
  48. #include "dbcs.h"     // HXFindString
  49. #include "hxmarsh.h"  // getshort()
  50. #include "chxuuid.h"  // CHXuuid
  51. #include "hxtick.h"   // HX_GET_TICKCOUNT
  52. #include "rtsputil.h" // BinTo64
  53. #include "hxfiles.h"  // CLSID_IHXRequest
  54. #include "hxplnsp.h"  // _CIHXObjectConfiguration_SP
  55. #include "hxcomsp.h"  // _CIHXCommonClassFactory_SP
  57. // necessary for authentication
  58. #include "hxmon.h"
  59. #include "httppars.h"
  60. #include "hxplgns.h"
  61. #include "hxcore.h"
  63. #include "httpclk.h"
  65. #ifdef _MACINTOSH
  66. #include "hx_moreprocesses.h"
  67. #endif
  69. /******************* HTTP Cloaking*****************/
  71. #define QUEUE_START_SIZE    512
  73. #define HTTPCLOAK_PUTRESPONSE_TIMEOUT 2000
  75. #define MAX_HTTP_METHOD_BUFSIZE           2048
  77. #define HXGUID_SIZE  16 // 16 byte GUID plus rn
  79. #define ENQUEUE_DATA(x,y,z) (x)->EnQueue((y),(z))
  81. #define ENQUEUE_BYTE(x,y) {UCHAR uChar = (y); 
  82. (x)->EnQueue(&uChar,sizeof(uChar));}
  84. #define ENQUEUE_WORD(x,y) {UINT16 wTemp = (y); 
  85. wTemp = WToNet(wTemp); 
  86. (x)->EnQueue(&wTemp,sizeof(UINT16));}
  88. #define ENQUEUE_DWORD(x,y) {ULONG32 dTemp = (y); 
  89. dTemp = DwToNet(dTemp); 
  90. (x)->EnQueue(&dTemp,sizeof(ULONG32));}
  92. #define DEFAULT_HTTP_HEADER_LENGTH 256
  93. #define DEFAULT_OPTION_PADDING_LENGTH 16381
  95. #ifdef _WINCE
  96. #define SCHED_GRANULARITY 10
  97. #else
  98. #define SCHED_GRANULARITY 50
  99. #endif
  101. enum
  102. {
  103.     HTTP_OK = 0,
  104.     HTTP_GENERAL_ERROR, // for any error that is not defined below
  105.     POST_NOT_RECEIVED,  // POST message was not received
  106.     INVALID_GUID  // sent only if the GUID from the Player is already in use
  107. };
  110. /* HXClientCloakedTCPSocket */
  111. HXClientCloakedTCPSocket::HXClientCloakedTCPSocket(IUnknown* pContext):
  112.      m_lRefCount(0)
  113.     ,m_pContext(pContext)
  114.     ,m_pTCPResponse(0)
  115.     ,m_pNetworkServices(0)
  116.     ,m_pGetCtrl(0)
  117.     ,m_pPutCtrl(0)
  118.     ,m_pGetCtrlResponse(0)
  119.     ,m_pPutCtrlResponse(0)
  120.     ,m_bGetReadPending(FALSE)
  121.     ,m_bPutReadPending(FALSE)
  122.     ,m_bPutWantWritePending(FALSE)
  123.     ,m_lForeignAddress(0)
  124.     ,m_nForeignPort(0)
  125.     ,m_bReadPending(FALSE)
  126.     ,m_nRequired(0)
  127.     ,m_pSendTCP(0)
  128.     ,m_pReceiveGetTCP(0)
  129.     ,m_pReceivePutTCP(0)
  130.     ,m_pPreEncodedSendHTTP(0)
  131.     ,m_pPostEncodedSendHTTP(0)
  132.     ,m_pOutBuf(0)
  133.     ,m_pOutEncodedBuf(0)
  134.     ,m_pInBuf(0)
  135.     ,m_bConnected(FALSE)
  136.     ,m_pForiegnHost(0)
  137.     ,m_pGuid(0)
  138.     ,m_bGetConnectDone(FALSE)
  139.     ,m_bPutConnectDone(FALSE)
  140.     ,m_bGetConnectSuccessful(FALSE)
  141.     ,m_bPutConnectSuccessful(FALSE)
  142.     ,m_bConnectResponsePending(TRUE)
  143.     ,m_bOptionsReceived(FALSE)
  144.     ,m_bUseExactContentLength(FALSE)
  145.     ,m_bCloseHttpAfterWrite(FALSE)
  146.     ,m_bMustCloseHTTP(FALSE)
  147.     ,m_bHttpInitialized(FALSE)
  148.     ,m_LastError(HXR_OK)
  149.     ,m_pHTTPHeaderBuffer(0)
  150.     ,m_nHTTPHeaderBufferLength(0)
  151.     ,m_bHTTPGetHeaderReadDone(FALSE)
  152.     ,m_bHTTPPutHeaderReadDone(FALSE)
  153.     ,m_pProxyHostName(0)
  154.     ,m_nProxyPortNumber(0)
  155.     ,m_bInDestructor(FALSE)
  156.     ,m_pScheduler(0)
  157.     ,m_pSchedulerCallback(0)
  158.     ,m_pNonInterruptCallback(0)
  159.     ,m_bInDoRead(FALSE)
  160.     ,m_bInDoGetWrite(FALSE)
  161.     ,m_bInDoPutWrite(FALSE)
  162.     ,m_bInTransferBuffers(FALSE)
  163.     ,m_bInitComplete(FALSE)
  164.     ,m_bDeletePadding(FALSE)
  165.     ,m_uPadLength(10+DEFAULT_OPTION_PADDING_LENGTH) // 10 for the opts and 16381 for the padding
  166.     ,m_pInterruptState(NULL)
  167.     ,m_pResponseInterruptSafe(NULL)
  168.     ,m_pMutex(NULL)
  169.     ,m_pCloakValues(NULL)
  170.     ,m_pCloakContext(NULL)
  171.     ,m_bGetResponsed(FALSE)
  172.     ,m_bPutResponsed(FALSE)
  173.     ,m_pszGetServerIP(NULL)
  174.     ,m_pszPutServerIP(NULL)
  175.     ,m_bReconnectToSameServerIP(FALSE)
  176.     ,m_bConnectToSameServerIP(FALSE)
  177.     ,m_pPreferredTransport(NULL)
  178.     ,m_pPreferredTransportManager(NULL)
  179. #ifdef _MACINTOSH
  180.     ,m_pAuthenticationCallback(NULL)
  181. #endif
  182.     ,m_bInAuthenticationKludge(FALSE)
  183. {
  184.     if(m_pContext)
  185.     {
  186. m_pContext->AddRef();
  187. m_pContext->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  188. m_pContext->QueryInterface(IID_IHXNetworkServices, (void**) &m_pNetworkServices);
  189. m_pContext->QueryInterface(IID_IHXInterruptState, (void**) &m_pInterruptState);
  190. m_pContext->QueryInterface(IID_IHXPreferredTransportManager, (void**)&m_pPreferredTransportManager);
  191.     }
  193. #if defined(THREADS_SUPPORTED) 
  194.     HXMutex::MakeMutex(m_pMutex);
  195. #elif defined(_UNIX_THREADED_NETWORK_IO)
  196.     if( ReadNetworkThreadingPref((IUnknown*)pContext) )
  197.     {
  198.         HXMutex::MakeMutex(m_pMutex);
  199.     }
  200.     else
  201.     { 
  202.         HXMutex::MakeStubMutex(m_pMutex);
  203.     }
  204. #else
  205.     HXMutex::MakeStubMutex(m_pMutex);
  206. #endif
  208. #ifdef _MACINTOSH
  209.     m_pAuthenticationCallback = new MacCloakedTCPSocketAuthenticationCallback(this);
  210.     m_pAuthenticationCallback->AddRef();
  211. #endif
  212. }
  214. HXClientCloakedTCPSocket::~HXClientCloakedTCPSocket()
  215. {
  216.     m_bInDestructor = TRUE;
  217.     
  218.     m_pMutex->Lock();
  220. #ifdef _MACINTOSH
  221.     if (m_pAuthenticationCallback && m_pAuthenticationCallback->m_ulPendingCallbackID &&
  222. m_pScheduler)
  223.     {
  224. m_pScheduler->Remove(m_pAuthenticationCallback->m_ulPendingCallbackID);
  225. m_pAuthenticationCallback->m_ulPendingCallbackID = NULL;
  226.     }
  227.     HX_RELEASE(m_pAuthenticationCallback);
  228. #endif
  230.     while (m_PendingWriteBuffers.GetCount() > 0)
  231.     {
  232. IHXBuffer* pBuffer = (IHXBuffer*) m_PendingWriteBuffers.RemoveHead();
  233. pBuffer->Release();
  234.     }
  236.     FlushQueues();
  238.     /* Send a final HTTP done message */
  239.     if (m_bHttpInitialized)
  240.     {
  241. SendHTTPDone();
  242.     }
  244.     if (m_pSchedulerCallback)
  245.     {
  246. m_pSchedulerCallback->Unschedule(m_pScheduler);
  247. HX_RELEASE(m_pSchedulerCallback);
  248.     }
  250.     if (m_pNonInterruptCallback)
  251.     {
  252. m_pNonInterruptCallback->Unschedule(m_pScheduler);
  253. HX_RELEASE(m_pNonInterruptCallback);
  254.     }
  256.     HX_RELEASE(m_pGetCtrl);
  257.     HX_RELEASE(m_pPutCtrl);
  258.     HX_RELEASE(m_pGetCtrlResponse);
  259.     HX_RELEASE(m_pPutCtrlResponse);
  261.     HX_RELEASE(m_pCloakValues);
  262.     HX_RELEASE(m_pCloakContext);
  263.     HX_RELEASE(m_pTCPResponse);
  264.     HX_RELEASE(m_pNetworkServices);
  266.     HX_DELETE(m_pSendTCP);
  267.     HX_DELETE(m_pReceiveGetTCP);
  268.     HX_DELETE(m_pReceivePutTCP);
  269.     HX_DELETE(m_pPreEncodedSendHTTP);
  270.     HX_DELETE(m_pPostEncodedSendHTTP);
  272.     HX_VECTOR_DELETE(m_pInBuf);
  273.     HX_VECTOR_DELETE(m_pOutBuf);
  274.     HX_VECTOR_DELETE(m_pOutEncodedBuf);
  275.     HX_VECTOR_DELETE(m_pForiegnHost);
  276.     HX_VECTOR_DELETE(m_pGuid);
  277.     HX_VECTOR_DELETE(m_pHTTPHeaderBuffer);
  278.     HX_VECTOR_DELETE(m_pProxyHostName);
  279.     HX_VECTOR_DELETE(m_pszGetServerIP);
  280.     HX_VECTOR_DELETE(m_pszPutServerIP);
  282.     HX_RELEASE(m_pPreferredTransport);
  283.     HX_RELEASE(m_pPreferredTransportManager);
  284.     HX_RELEASE(m_pInterruptState);
  285.     HX_RELEASE(m_pResponseInterruptSafe);
  286.     HX_RELEASE(m_pScheduler);
  288.     HX_RELEASE(m_pContext);
  289.     m_pMutex->Unlock();
  290.     HX_DELETE(m_pMutex);
  291. }
  293. STDMETHODIMP HXClientCloakedTCPSocket::QueryInterface(REFIID riid, void** ppvObj)
  294. {
  295.     QInterfaceList qiList[] =
  296.         {
  297.             { GET_IIDHANDLE(IID_IHXTCPSocket), (IHXTCPSocket*)this },
  298.             { GET_IIDHANDLE(IID_IHXCloakedTCPSocket), (IHXCloakedTCPSocket*)this },
  299.             { GET_IIDHANDLE(IID_IHXHTTPProxy), (IHXHTTPProxy*)this },
  300.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXTCPSocket*)this },
  301.         };
  302.     
  303.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  304. }
  306. STDMETHODIMP_(ULONG32) HXClientCloakedTCPSocket::AddRef()
  307. {
  308.     return InterlockedIncrement(&m_lRefCount);
  309. }
  311. STDMETHODIMP_(ULONG32) HXClientCloakedTCPSocket::Release()
  312. {
  313.     if (InterlockedDecrement(&m_lRefCount) > 0)
  314.     {
  315.         return m_lRefCount;
  316.     }
  318.     delete this;
  319.     return 0;
  320. }
  322. STDMETHODIMP HXClientCloakedTCPSocket::Init(IHXTCPResponse* pTCPResponse)
  323. {
  324.     HX_RESULT rc = HXR_OK;
  326.     if (!pTCPResponse)
  327.     {
  328. return HXR_UNEXPECTED;
  329.     }
  331.     if (!m_pSchedulerCallback)
  332.     {
  333. m_pSchedulerCallback = new ScheduledSocketCallback(this, TRUE);
  334. m_pSchedulerCallback->AddRef();
  335.     }
  337.     if (!m_pNonInterruptCallback)
  338.     {
  339. m_pNonInterruptCallback = new ScheduledSocketCallback(this, TRUE);
  340. m_pNonInterruptCallback->AddRef();
  341.     }
  343.     m_pTCPResponse = pTCPResponse;
  344.     m_pTCPResponse->AddRef();
  346.     m_pTCPResponse->QueryInterface(IID_IHXInterruptSafe, 
  347.    (void**) &m_pResponseInterruptSafe);
  349.     if (!m_pNetworkServices)
  350.     {
  351. return HXR_FAILED;
  352.     }
  353.     
  354.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pGetCtrl))
  355.     {
  356. return HXR_FAILED;
  357.     }
  359.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pPutCtrl))
  360.     {
  361. return HXR_FAILED;
  362.     }
  364.     m_pGetCtrlResponse = new HTTPCloakTCPResponse(this, TRUE);
  365.     m_pPutCtrlResponse = new HTTPCloakTCPResponse(this, FALSE);
  366.     if (!m_pGetCtrlResponse || !m_pPutCtrlResponse)
  367.     {
  368. return HXR_OUTOFMEMORY;
  369.     }
  371.     m_pGetCtrlResponse->AddRef();
  372.     m_pPutCtrlResponse->AddRef();
  374.     if (HXR_OK != m_pGetCtrl->Init(m_pGetCtrlResponse) || 
  375. HXR_OK != m_pPutCtrl->Init(m_pPutCtrlResponse))
  376.     {
  377. return HXR_FAILED;
  378.     }
  380.     if (HXR_OK != m_pGetCtrl->Bind(HXR_INADDR_ANY, 0) || 
  381. HXR_OK != m_pPutCtrl->Bind(HXR_INADDR_ANY, 0))
  382.     {
  383.      return HXR_FAILED;
  384.     }
  386.     // allocate TCP send and receive queue
  387.     m_pSendTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  388.     if (!m_pSendTCP || !m_pSendTCP->IsQueueValid())
  389.     {
  390. return HXR_OUTOFMEMORY;
  391.     }
  392.     m_pSendTCP->SetMaxSize(TCP_BUF_SIZE);
  394.     m_pReceiveGetTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  395.     if (!m_pReceiveGetTCP || !m_pReceiveGetTCP->IsQueueValid())
  396.     {
  397. return HXR_OUTOFMEMORY;
  398.     }
  399.     m_pReceiveGetTCP->SetMaxSize(TCP_BUF_SIZE);
  401.     m_pPreEncodedSendHTTP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  402.     if (!m_pPreEncodedSendHTTP || !m_pPreEncodedSendHTTP->IsQueueValid())
  403.     {
  404. return HXR_OUTOFMEMORY;
  405.     }
  407.     /* Approx. MAX POST header size : 3000*/
  408.     m_pPreEncodedSendHTTP ->SetMaxSize((TCP_BUF_SIZE-1)/2 - 3000);
  410.     m_pPostEncodedSendHTTP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  411.     if (!m_pPostEncodedSendHTTP || !m_pPostEncodedSendHTTP->IsQueueValid())
  412.     {
  413. return HXR_OUTOFMEMORY;
  414.     }
  415.     m_pPostEncodedSendHTTP->SetMaxSize(TCP_BUF_SIZE);
  416.     
  417.     m_pInBuf = new char[TCP_BUF_SIZE];
  418.     if (!m_pInBuf)
  419.     {
  420. return HXR_OUTOFMEMORY;
  421.     }
  423.     m_pOutBuf = new char[TCP_BUF_SIZE];
  424.     if (!m_pOutBuf)
  425.     {
  426. return HXR_OUTOFMEMORY;
  427.     }
  429.     m_pOutEncodedBuf = new char[TCP_BUF_SIZE];
  430.     if (!m_pOutEncodedBuf)
  431.     {
  432. return HXR_OUTOFMEMORY;
  433.     }
  435.     CreateGuid();
  437.     return HXR_OK;
  438. }
  440. STDMETHODIMP HXClientCloakedTCPSocket::SetResponse(IHXTCPResponse* pTCPResponse)
  441. {
  442.     m_pMutex->Lock();
  443.     HX_RELEASE(m_pTCPResponse);
  444.     m_pTCPResponse = pTCPResponse;
  445.     m_pTCPResponse->AddRef();
  447.     HX_RELEASE(m_pResponseInterruptSafe);
  448.     m_pTCPResponse->QueryInterface(IID_IHXInterruptSafe, 
  449.    (void**) &m_pResponseInterruptSafe);
  450.     m_pMutex->Unlock();
  451.     return HXR_OK;
  452. }
  454. STDMETHODIMP HXClientCloakedTCPSocket::Bind(UINT32 ulLocalAddr, UINT16 nPort)
  455. {
  456.     return HXR_NOTIMPL;
  457. }
  459. STDMETHODIMP HXClientCloakedTCPSocket::Connect(const char* pDestination,
  460. UINT16     nPort)
  461. {
  462.     m_nForeignPort = nPort;
  464.     HX_VECTOR_DELETE(m_pForiegnHost);
  465.     m_pForiegnHost = new char [strlen(pDestination) + 1];
  466.     if (!m_pForiegnHost)
  467.     {
  468. return HXR_OUTOFMEMORY;
  469.     }
  471.     ::strcpy(m_pForiegnHost, pDestination); /* Flawfinder: ignore */
  473.     // m_pCloakValues is only set by RTSP
  474.     if (m_pPreferredTransportManager && m_pCloakValues)
  475.     {
  476. HX_RELEASE(m_pPreferredTransport);
  477. m_pPreferredTransportManager->GetPrefTransport(m_pForiegnHost,
  478.        PTP_RTSP,
  479.        m_pPreferredTransport);
  481. HX_ASSERT(m_pPreferredTransport);
  482. if (m_pPreferredTransport)
  483. {
  484.     m_bConnectToSameServerIP = m_pPreferredTransport->GetHTTPNG();
  485. }
  486.     }
  488.     return  ActualConnect();
  489. }
  491. STDMETHODIMP HXClientCloakedTCPSocket::Read(UINT16 uSize)
  492. {
  493.     HX_RESULT theErr = HXR_OK;
  494.     HX_RESULT lResult = HXR_OK;
  496.     if (m_bReadPending)
  497.     {
  498. return HXR_UNEXPECTED;
  499.     }
  501.     m_bReadPending  = TRUE;
  502.     m_nRequired     = uSize;
  504.     m_pMutex->Lock();
  505.     theErr  = DoRead();
  506.     m_pMutex->Unlock();
  507.     lResult = ConvertNetworkError(theErr);
  509.     return lResult;
  510. }
  512. STDMETHODIMP HXClientCloakedTCPSocket::Write(IHXBuffer* pBuffer)
  513. {
  514.     HX_RESULT theErr = HXR_OK;
  515.     HX_RESULT lResult = HXR_OK;
  517.     pBuffer->AddRef();
  518.     m_PendingWriteBuffers.AddTail((void*) pBuffer);
  519.     
  520.     m_pMutex->Lock();
  521.     theErr = DoPutWrite();
  522.     m_pMutex->Unlock();
  523.     lResult = ConvertNetworkError(theErr);
  525.     return lResult;
  526. }
  528. STDMETHODIMP HXClientCloakedTCPSocket::WantWrite()
  529. {
  530.     m_pTCPResponse->WriteReady(HXR_OK);
  532.     return HXR_OK;
  533. }
  535. STDMETHODIMP HXClientCloakedTCPSocket::GetLocalAddress(ULONG32& lAddress)
  536. {
  537.     return HXR_NOTIMPL;
  538. }
  540. STDMETHODIMP HXClientCloakedTCPSocket::GetForeignAddress(ULONG32& lAddress)
  541. {
  542.     if(m_bConnected && m_lForeignAddress)
  543.     {
  544. lAddress = m_lForeignAddress;
  545. return HXR_OK;
  546.     }
  547.     return HXR_FAIL;
  548. }
  550. STDMETHODIMP HXClientCloakedTCPSocket::GetLocalPort(UINT16& port)
  551. {
  552.     return HXR_NOTIMPL;
  553. }
  555. STDMETHODIMP HXClientCloakedTCPSocket::GetForeignPort(UINT16& port)
  556. {
  557.     if(m_bConnected)
  558.     {
  559. port = m_nForeignPort;
  560. return HXR_OK;
  561.     }
  562.     return HXR_FAIL;
  563. }
  565. /*
  566.  * IHXHTTPProxy methods
  567.  *
  568.  *  Network addresses and ports are in native byte order
  569.  *  
  570.  */
  572. STDMETHODIMP HXClientCloakedTCPSocket::SetProxy(
  573.     const char*     /*IN*/  pProxyHostName,
  574.     UINT16     /*IN*/  nPort)
  575. {
  576.     if(pProxyHostName == 0 || *pProxyHostName == 0) 
  577.     {
  578. return HXR_FAILED;
  579.     }
  580.     
  581.     HX_VECTOR_DELETE(m_pProxyHostName);
  582.     m_pProxyHostName = new char[::strlen(pProxyHostName) + 1];
  583.     if (!m_pProxyHostName)
  584.     {
  585. return HXR_OUTOFMEMORY;
  586.     }
  588.     ::strcpy(m_pProxyHostName, pProxyHostName); /* Flawfinder: ignore */
  589.     m_nProxyPortNumber = nPort;
  591.     return HXR_OK;
  592. }
  594. /************************************************************************
  595.  * Method:
  596.  *     IHXCloakedTCPSocket::InitCloak
  597.  */
  598. STDMETHODIMP
  599. HXClientCloakedTCPSocket::InitCloak(IHXValues* /*IN*/  pValues, IUnknown* pUnknown)
  600. {
  601.     HX_RESULT rc = HXR_OK;
  603.     if (pValues)
  604.     {
  605. m_pCloakValues = pValues;
  606. m_pCloakValues->AddRef();
  607.     }
  608.     if (pUnknown)
  609.     {
  610. m_pCloakContext = pUnknown;
  611. m_pCloakContext->AddRef();
  612.     }
  614.     return rc;
  615. }
  617. HX_RESULT
  618. HXClientCloakedTCPSocket::DoRead()
  619. {
  620.     HX_RESULT theErr = HXR_OK;
  621.     char*   pStartAfterDoubleReturn = 0;
  622.     UINT16 count = 0;
  624.     if(m_bInDoRead)
  625.     {
  626. return HXR_OK;
  627.     }
  629.     m_bInDoRead = TRUE;
  631.     if (m_LastError)
  632.     {
  633. goto exit;
  634.     }
  636.     // m_pReceivePutTCP is only initialized if we receive POST response
  637.     // from the server
  638.     if (m_pReceivePutTCP)
  639.     {
  640. count = m_pReceivePutTCP->GetMaxAvailableElements();
  641.     }
  642.     else
  643.     {
  644. count = TCP_BUF_SIZE;
  645.     }
  647.     // attempt to read from PUT if:
  648.     // * we haven't initiated PUT read already AND
  649.     // * we haven't received the complete POST response header AND
  650.     // * we are not in multi-POST mode
  651.     if (count > 0     && 
  652. !m_bPutReadPending     && 
  653. !m_bHTTPPutHeaderReadDone   &&
  654. !m_bMustCloseHTTP)
  655.     {
  656. // attempt to read data from TCP link
  657. m_bPutReadPending = TRUE;
  658. theErr = m_pPutCtrl->Read(count);
  659.     }
  661.     // check how much room we have in TCP receive queue
  662.     count = m_pReceiveGetTCP->GetMaxAvailableElements();
  663.     if (count > 0 && !m_bGetReadPending)
  664.     {
  665. // attempt to read data from TCP link
  666. m_bGetReadPending = TRUE;
  667. theErr = m_pGetCtrl->Read(count);
  668. switch(theErr)
  669. {
  670.     case HXR_AT_INTERRUPT:
  671.     case HXR_WOULD_BLOCK:
  672.     case HXR_OK:
  673. // mask out these errors
  674. theErr = HXR_OK;
  675. break;
  677.     default:
  678. theErr = ConvertNetworkError(theErr);
  679. break;
  680. }
  681.     }
  683. exit:
  684.     if (theErr && !m_LastError)
  685.     {
  686. m_LastError = theErr;
  687.     }
  689.     if (m_LastError)
  690.     {
  691. if (m_bReadPending)
  692. {
  693.     if (IsSafe())
  694.     {
  695. m_bReadPending = FALSE;
  696. m_pTCPResponse->ReadDone(m_LastError, 0);
  697.     }
  698. }
  699.     }
  700.     else
  701.     {
  702. count = m_pReceiveGetTCP->GetQueuedItemCount();
  704. if (m_bReadPending && count > 0 && m_bOptionsReceived 
  705.     && m_bHTTPGetHeaderReadDone)
  706. {
  707.     /* mask any kind of errors */
  708.     theErr = HXR_OK;
  710.     if (IsSafe())
  711.     {
  712. m_bReadPending = FALSE;
  713. if (m_nRequired < count)
  714. {
  715.     count = m_nRequired;
  716. }
  718. CHXBuffer* pBuffer = new CHXBuffer;
  719. pBuffer->AddRef();
  720. m_pReceiveGetTCP->DeQueue(m_pInBuf, count);
  721. pBuffer->Set((UCHAR*) m_pInBuf, count);
  723. m_pTCPResponse->ReadDone(HXR_OK, pBuffer);
  724. pBuffer->Release();
  725.     }
  726. }
  728. if (m_pSchedulerCallback && m_bReadPending)
  729. {
  730.     m_pSchedulerCallback->ScheduleCallback(CLOAKED_TCP_READ_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  731. }
  732.     }
  733.  
  734.     m_bInDoRead = FALSE;
  735.     return theErr;
  736. }
  738. HX_RESULT
  739. HXClientCloakedTCPSocket::DoGetWrite()
  740. {
  741.     HX_RESULT theErr = HXR_OK;
  743.     if (m_bInDoGetWrite)
  744.     {
  745. return HXR_OK;
  746.     }
  748.     m_bInDoGetWrite = TRUE;
  750.     // check how data we have in TCP send queue
  751.     UINT16 count    = m_pSendTCP->GetQueuedItemCount();
  752.     UINT16 actual   = count;
  753.     
  754.     if(count > 0) 
  755.     {
  756. m_pSendTCP->DeQueue(m_pOutBuf,count);
  757. CHXBuffer* pBuffer = new CHXBuffer;
  758. pBuffer->AddRef();
  759. pBuffer->Set((UCHAR*) m_pOutBuf, (ULONG32) count);
  760. theErr = m_pGetCtrl->Write(pBuffer);
  761. pBuffer->Release();
  762.     }
  763.     
  764.     if (theErr)
  765.     {
  766. switch(theErr)
  767. {
  768.     case HXR_AT_INTERRUPT:
  769.     case HXR_WOULD_BLOCK:
  770. m_pSendTCP->EnQueue(m_pOutBuf, count);
  771. // mask out these errors
  772. theErr = HXR_OK;
  773. break;
  775.     default:
  776. theErr = ConvertNetworkError(theErr);
  777. break;
  778. }
  779.     }
  781.     if (!theErr && !m_bInDestructor &&
  782. m_pSendTCP->GetQueuedItemCount() > 0 ) {
  783.     m_pSchedulerCallback->ScheduleCallback(CLOAKED_TCP_GETWRITE_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  784.     }
  786.     m_bInDoGetWrite = FALSE;
  787.     return theErr;
  788. }
  790. HX_RESULT
  791. HXClientCloakedTCPSocket::DoPutWrite()
  792. {
  793.     HX_RESULT theErr = HXR_OK;
  795.     if (m_bInDoPutWrite)
  796.     {
  797. return HXR_OK;
  798.     }
  800.     m_bInDoPutWrite = TRUE;
  802.     /* Transfer pending buffers to TCP send queue */
  803.     if (m_bOptionsReceived && m_pPostEncodedSendHTTP->GetQueuedItemCount() == 0 && !m_bPutWantWritePending)
  804.     {
  805. TransferBuffers();
  806.     }
  808.     if (!m_bPutConnectDone)
  809.     {
  810. goto exit;
  811.     }
  813.     // check how data we have in TCP send queue
  814.     UINT16 count;
  815.     UINT16 actual;
  816.     
  817.     count    = m_pPostEncodedSendHTTP->GetQueuedItemCount();
  818.     actual   = count;
  820.     if(count > 0) 
  821.     {
  822. m_pPostEncodedSendHTTP->DeQueue(m_pOutEncodedBuf,count);
  823. CHXBuffer* pBuffer = new CHXBuffer;
  824. pBuffer->AddRef();
  825. pBuffer->Set((UCHAR*) m_pOutEncodedBuf, (ULONG32) count);
  826. theErr = m_pPutCtrl->Write(pBuffer);
  827. pBuffer->Release();
  828. m_bPutWantWritePending = TRUE;
  829. m_pPutCtrl->WantWrite();
  830.     }
  831.     
  832.     if (theErr)
  833.     {
  834. switch(theErr)
  835. {
  836.     case HXR_AT_INTERRUPT:
  837.     case HXR_WOULD_BLOCK:
  838. m_pPostEncodedSendHTTP->EnQueue(m_pOutEncodedBuf, count);
  839. // mask out these errors
  840. theErr = HXR_OK;
  841. break;
  843.     default:
  844. theErr = ConvertNetworkError(theErr);
  845. break;
  846. }
  847.     }
  849. exit:
  851.     if (!theErr && !m_bInDestructor &&
  852. (m_pPostEncodedSendHTTP->GetQueuedItemCount() > 0 ||
  853.  m_PendingWriteBuffers.GetCount() > 0)){
  854.     m_pSchedulerCallback->ScheduleCallback(CLOAKED_TCP_PUTWRITE_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  855.     }
  857.     if (!theErr)
  858.     {
  859. theErr = DoGetWrite();
  860.     }
  862.     m_bInDoPutWrite = FALSE;
  864.     return theErr;
  865. }
  867. void 
  868. HXClientCloakedTCPSocket::GetConnectDone(BOOL bResult)
  869. {
  870.     m_bGetConnectDone = TRUE;
  872.     if (!m_bInDestructor)
  873.     {
  874. AddRef();
  875.     }
  877.     if (bResult == TRUE)
  878.     {
  879. m_bGetConnectSuccessful = TRUE;
  880. m_pGetCtrl->GetForeignAddress(m_lForeignAddress);
  881.     }
  882.     else
  883.     {
  884. m_bGetConnectSuccessful = FALSE;
  885.     }
  887.     // PUT connection has to been done at this point
  888.     if (m_bPutConnectDone && m_bConnectResponsePending)
  889.     {
  890. m_bConnectResponsePending = FALSE;
  892. // either its HTTP-NG server or we are in re-GET mode
  893. // where we send GET to the same serverIP returned from
  894. // POST response
  895. if (m_bConnectToSameServerIP || m_bReconnectToSameServerIP)
  896. {
  897.     if (m_bPutConnectSuccessful && m_bGetConnectSuccessful)
  898.     {
  899. m_bConnected = TRUE;
  900. m_pMutex->Lock();
  901. PrepareGetMessage();
  902. DoGetWrite();
  903. Read(TCP_BUF_SIZE);
  904. m_pMutex->Unlock();
  905. if (m_bConnectToSameServerIP)
  906. {
  907.     // we haven't call ConnectDone yet
  908.     m_pTCPResponse->ConnectDone(HXR_OK);
  909. }
  910. else if (m_bReconnectToSameServerIP)
  911. {
  912.     // we already called ConnectDone upon the initial
  913.     // GET/POST connect done
  914.     Read(TCP_BUF_SIZE);
  915. }
  916.     }
  917.     else
  918.     {
  919. m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  920.     }
  921. }
  922. // don't know the server type yet, keep the old behavior
  923. // where we send both GET and POST
  924. else
  925. {
  926.     if (m_bPutConnectSuccessful && m_bGetConnectSuccessful)
  927.     {
  928. m_bConnected = TRUE;
  929. m_pMutex->Lock();
  930. PreparePostMessage(NULL, 0);
  931. DoPutWrite();
  932. PrepareGetMessage();
  933. DoGetWrite();
  934. m_pMutex->Unlock();
  935. m_pTCPResponse->ConnectDone(HXR_OK);
  936.     }
  937.     else
  938.     {
  939. m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  940.     }
  942. }
  943.     }
  945.     if (!m_bInDestructor)
  946.     {
  947.         Release();
  948.     }
  949. }
  951. void 
  952. HXClientCloakedTCPSocket::PutConnectDone(BOOL bResult)
  953. {
  954.     HX_RESULT theErr = HXR_OK;
  955.     m_bPutConnectDone = TRUE;
  957.     if (!m_bInDestructor)
  958.     {
  959. AddRef();
  960.     }
  962.     if (bResult == TRUE)
  963.     {
  964. m_bPutConnectSuccessful = TRUE;
  965.     }
  966.     else
  967.     {
  968. m_bPutConnectSuccessful = FALSE;
  969.     }
  971.     // it's HTTP-NG server, we send POST first
  972.     if (m_bConnectToSameServerIP)
  973.     {
  974. if (m_bPutConnectSuccessful)
  975. {
  976.     m_pMutex->Lock();
  977.     PreparePostMessage(NULL, 0);
  978.     DoPutWrite();
  979.     if (!m_bPutReadPending)
  980.     {
  981. m_bPutReadPending = TRUE;
  982. m_pPutCtrl->Read(TCP_BUF_SIZE);
  983.     }
  984.     m_pMutex->Unlock();
  985. }
  986. else
  987. {
  988.     m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  989. }
  990.     }
  991.     // don't know the server type yet, so we send both POST
  992.     // and GET
  993.     else if (m_bGetConnectDone && m_bConnectResponsePending)
  994.     {
  995. m_bConnectResponsePending = FALSE;
  996. if (m_bPutConnectSuccessful && m_bGetConnectSuccessful)
  997. {
  998.     m_bConnected = TRUE;
  999.     m_pMutex->Lock();
  1000.     PreparePostMessage(NULL, 0);
  1001.     DoPutWrite();
  1002.     PrepareGetMessage();
  1003.     theErr = DoGetWrite();
  1004.     m_pMutex->Unlock();
  1005.     m_pTCPResponse->ConnectDone(HXR_OK);
  1006. }
  1007. else
  1008. {
  1009.     m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  1010. }
  1011.     }
  1013.     if (!m_bInDestructor)
  1014.     {
  1015. Release();
  1016.     }
  1018.     if (m_bConnected && m_pPostEncodedSendHTTP->GetQueuedItemCount() > 0)
  1019.     {
  1020. m_pMutex->Lock();
  1021. DoPutWrite();
  1022. m_pMutex->Unlock();
  1023.     }
  1024. }
  1026. HX_RESULT
  1027. HXClientCloakedTCPSocket::DoGetReadDone(HX_RESULT   status, IHXBuffer* pInBuffer)
  1028. {
  1029.     HX_RESULT theErr = HXR_OK;
  1030.     char* pStartAfterDoubleReturn = 0;
  1031.     UINT16 count = 0;
  1033.     if (AuthenticationRequired(status, pInBuffer))
  1034.     {
  1035. return HXR_OK;
  1036.     }
  1038.     m_pMutex->Lock();
  1040.     m_bGetReadPending = FALSE;
  1041.     if (status != HXR_OK && m_LastError == HXR_OK)
  1042.     {
  1043. m_LastError = status;
  1044.     }
  1046.     if (m_LastError)
  1047.     {
  1048. goto exit;
  1049.     }
  1051.     if (pInBuffer)
  1052.     {
  1053. m_pReceiveGetTCP->EnQueue(pInBuffer->GetBuffer(), (UINT16) pInBuffer->GetSize());
  1054.     }
  1056.     count = m_pReceiveGetTCP->GetQueuedItemCount();
  1058.     /*
  1059.      * if the 16k padding was not received in one big packet
  1060.      * delete the remaining padding
  1061.      */
  1062.     if (m_bDeletePadding && m_uPadLength > 0)
  1063.     {
  1064. UINT16 len = (m_uPadLength <= count ? m_uPadLength : count); 
  1065. BYTE* tmpBuf = new BYTE[len];
  1067. m_pReceiveGetTCP->DeQueue(tmpBuf, len);
  1068. m_uPadLength -= len;
  1070. if (m_uPadLength == 0)
  1071. {
  1072.     m_bDeletePadding = FALSE;
  1073. }
  1074. HX_VECTOR_DELETE(tmpBuf);
  1075. count = m_pReceiveGetTCP->GetQueuedItemCount();
  1076.     }
  1078.     if (!theErr && !m_bHTTPGetHeaderReadDone && count >= 2 )
  1079.     {
  1080. char* pEndLineLocation = 0;
  1082. if (!m_pHTTPHeaderBuffer || m_nHTTPHeaderBufferLength < count+1)
  1083. {
  1084.     HX_VECTOR_DELETE(m_pHTTPHeaderBuffer);
  1085.     m_nHTTPHeaderBufferLength = count+1 > DEFAULT_HTTP_HEADER_LENGTH ?
  1086. count+1 : DEFAULT_HTTP_HEADER_LENGTH;
  1087.     m_pHTTPHeaderBuffer = new char[m_nHTTPHeaderBufferLength];
  1088.     if (!m_pHTTPHeaderBuffer)
  1089.     {
  1090. theErr = HXR_OUTOFMEMORY;
  1091. goto exit;
  1092.     }
  1093. }
  1095. m_pReceiveGetTCP->DeQueue(m_pHTTPHeaderBuffer, count);
  1096. m_pHTTPHeaderBuffer[count] = '';
  1098. if ((pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "nn")) ||
  1099.     (pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "rr")) )
  1100. {
  1101.     pStartAfterDoubleReturn = pEndLineLocation+2;
  1102.     m_bHTTPGetHeaderReadDone = TRUE;
  1103. }
  1104. else if (count >= 4 &&
  1105.     (pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "rnrn")))
  1106. {
  1107.     pStartAfterDoubleReturn = pEndLineLocation+4;
  1108.     m_bHTTPGetHeaderReadDone = TRUE;
  1109. }
  1110. else
  1111. {
  1112.     /* Put back everything in receive queue*/
  1113.     m_pReceiveGetTCP->EnQueue(m_pHTTPHeaderBuffer, count);
  1114.     goto exit;
  1115. }
  1117. // determine whether we need to issue re-GET to the same serverIP
  1118. // from the POST response
  1119. if (!m_bGetResponsed && !m_bConnectToSameServerIP)
  1120. {
  1121.     m_bGetResponsed = TRUE;
  1122.     GetServerIPFromResponse(TRUE, m_pHTTPHeaderBuffer);
  1124.     if (m_pszGetServerIP && m_pszPutServerIP)
  1125.     {
  1126. m_bReconnectToSameServerIP = strcasecmp(m_pszGetServerIP, m_pszPutServerIP);
  1127.     }
  1129.     if (m_bReconnectToSameServerIP)
  1130.     {
  1131. theErr = ReconnectToSameServerIP();
  1132. goto quit;
  1133.     }
  1134. }
  1136. /* If we have read the complete header, see if the content is OK..*/
  1137. char* pFound = (char*) HXFindString(m_pHTTPHeaderBuffer, "HTTP/1.0 200 OK");
  1138. if (!pFound)
  1139. {
  1140.     pFound = (char*) HXFindString(m_pHTTPHeaderBuffer, "200 OK");
  1141. }
  1143. // XXX HP we are phasing out PNM protocol
  1144. // m_pCloakValues is only set in RTSP so we use this to exclude
  1145. // support for redirect in PNM Cloaking
  1146. if (!pFound)
  1147. {
  1148.     if (m_pCloakValues)
  1149.     {
  1150. pFound = (char*) HXFindString(m_pHTTPHeaderBuffer, "HTTP/1.0 302");
  1151. if (pFound)
  1152. {
  1153.     strncpy(pFound, "RTSP", 4); /* Flawfinder: ignore */
  1155.     IHXBuffer* pBuffer = new CHXBuffer;
  1156.     pBuffer->AddRef();
  1157.     pBuffer->Set((UCHAR*) m_pHTTPHeaderBuffer, count);
  1158.     
  1159.     m_pTCPResponse->ReadDone(HXR_OK, pBuffer);
  1160.     pBuffer->Release();
  1161.     goto exit;
  1162. }
  1163.     }
  1165.     theErr = HXR_DOC_MISSING;
  1166. }
  1168. if (!theErr)
  1169. {
  1170.     m_pReceiveGetTCP->EnQueue(pStartAfterDoubleReturn, 
  1171.     (m_pHTTPHeaderBuffer + count) - pStartAfterDoubleReturn);
  1172.     
  1173.     count = m_pReceiveGetTCP->GetQueuedItemCount();
  1174. }
  1175.     }
  1177.     /* hmmm... time to read options */ 
  1178.     if (!theErr && count > 0 && !m_bOptionsReceived && m_bHTTPGetHeaderReadDone)
  1179.     {
  1180. /* There needs to be atleast 4 bytes to have the response
  1181.  * reponse_opcode(HTTP_RV_RESPONSE), response len, 
  1182.  * actual response(minimum one byte)
  1183.  */
  1184. if (count < 3)
  1185. {
  1186.     goto exit;
  1187. }
  1189. m_pReceiveGetTCP->DeQueue(m_pInBuf, count);
  1191. if (m_pInBuf[0] == HTTP_RESPONSE)
  1192. {
  1193.     m_bOptionsReceived = TRUE;
  1194.     
  1195.     UINT16 nOptionLen = m_pInBuf[1];
  1196.     /* Place any data after the response back in Receive queue.
  1197.      * This data needs to be sent to the user*/
  1198.     if (count > 2+nOptionLen)
  1199.     {
  1200. m_pReceiveGetTCP->EnQueue(m_pInBuf+2+nOptionLen, (count - (2+nOptionLen)));
  1201.     }
  1203.     theErr = HandleHTTPResponse((UCHAR) m_pInBuf[2]);
  1205.     if (!theErr)
  1206.     {
  1207. count = m_pReceiveGetTCP->GetQueuedItemCount();
  1208.     }
  1209. }
  1210. else if (m_pInBuf[0] == HTTP_RV_RESPONSE)
  1211. {
  1212.     if (count < 9)
  1213.     {
  1214. m_pReceiveGetTCP->EnQueue(m_pInBuf, count);
  1215. goto exit;
  1216.     }
  1217.     /*
  1218.      * this involves receiving a message from the server of the format:
  1219.      * HTTP/1.0 200 OK
  1220.      * ...
  1221.      * Content-length:2147483000
  1222.      * r...O?...16k padding of ZEROs...e
  1223.      *
  1224.      * r -- HTTP_RV_RESPONSE (same as the 5.0 player)
  1225.      * O -- HTTP_OPTION_RESPONSE
  1226.      * e -- HTTP_OPT_RESPONSE_END
  1227.      */
  1228.     BYTE* ptr = (BYTE *)m_pInBuf;
  1229.     m_bOptionsReceived = TRUE;
  1230.     
  1231.     ptr += 2;
  1232.     UINT16 nOptionLen = *ptr;
  1233.     ptr++;
  1234.     
  1235.     theErr = HandleHTTPResponse((UCHAR)*ptr);
  1236.     ptr++;
  1238.     if (!theErr)
  1239.     {
  1240. ptr++;  // get past the HTTP_OPTION_RESPONSE char 'O'
  1241. m_uPadLength = (UINT16)getshort(ptr); 
  1242. ptr += 2;
  1244. // skip over the short padding option
  1245. m_uPadLength += 1; // for the 'e' at the end of the 16k padding
  1247. m_pReceiveGetTCP->EnQueue(ptr, 
  1248.     (m_uPadLength <= (count - (ptr - (BYTE *)m_pInBuf)) 
  1249.     ? m_uPadLength : (count - (ptr - (BYTE *)m_pInBuf))));
  1251. count = m_pReceiveGetTCP->GetQueuedItemCount();
  1253. // get rid of the padding sent with the first response
  1254. UINT16 len = (m_uPadLength <= count ? m_uPadLength : count); 
  1255. BYTE* tmpBuf = new BYTE[len];
  1257. m_pReceiveGetTCP->DeQueue(tmpBuf, len);
  1258. m_uPadLength -= len;
  1260. if (m_uPadLength > 0)
  1261. {
  1262.     m_bDeletePadding = TRUE;
  1263. }
  1264. // if we got more than the 16k initial buffer, put it back
  1265. if (len && len < count)
  1266.     m_pReceiveGetTCP->EnQueue(&m_pInBuf[len], count-len);
  1267. HX_VECTOR_DELETE(tmpBuf);
  1268.      count = m_pReceiveGetTCP->GetQueuedItemCount();
  1269.     }
  1270. }
  1271. else
  1272. {
  1273.     theErr = HXR_BAD_SERVER;
  1274.     goto exit;
  1275. }
  1277.     }
  1279.     if (!theErr && m_bReadPending && count > 0 && m_bOptionsReceived 
  1280. && m_bHTTPGetHeaderReadDone)
  1281.     {
  1282. /* mask any kind of errors */
  1283. theErr = HXR_OK;
  1285. if (IsSafe())
  1286. {
  1287.     m_bReadPending = FALSE;
  1288.     if (m_nRequired < count)
  1289.     {
  1290. count = m_nRequired;
  1291.     }
  1293.     CHXBuffer* pBuffer = new CHXBuffer;
  1294.     pBuffer->AddRef();
  1295.     m_pReceiveGetTCP->DeQueue(m_pInBuf, count);
  1296.     pBuffer->Set((UCHAR*) m_pInBuf, count);
  1297.     
  1298.     m_pTCPResponse->ReadDone(HXR_OK, pBuffer);
  1299.     pBuffer->Release();
  1300. }
  1301.     }
  1303. exit:
  1304.     if (theErr && !m_LastError)
  1305.     {
  1306. m_LastError = theErr;
  1307.     }
  1309.     if (m_LastError)
  1310.     {
  1311. if (m_bReadPending)
  1312. {
  1313.     if (IsSafe())
  1314.     {
  1315. m_bReadPending = FALSE;
  1316. m_pTCPResponse->ReadDone(m_LastError, 0);
  1317.     }
  1318. }
  1319.     }
  1321.     if (!m_LastError)
  1322.     {
  1323. DoPutWrite();
  1324. DoRead();
  1325.     }
  1327. quit:
  1328.     m_pMutex->Unlock();
  1330.     return HXR_OK;
  1331. }
  1333. HX_RESULT
  1334. HXClientCloakedTCPSocket::DoPutReadDone(HX_RESULT   status, IHXBuffer* pInBuffer)
  1335. {
  1336.     HX_RESULT rc = HXR_OK;
  1337.     UINT16 count = 0;
  1339.     m_bPutReadPending = FALSE;
  1341.     if (HXR_OK != status)
  1342.     {
  1343. rc = status;
  1344. goto cleanup;
  1345.     }
  1347.     // stop processing either we already processed one PUT response or
  1348.     // we are in multi-post mode
  1349.     if (!m_bPutResponsed && !m_bMustCloseHTTP)
  1350.     {
  1351. if (!m_pReceivePutTCP)
  1352. {
  1353.     m_pReceivePutTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  1354.     if (!m_pReceivePutTCP || !m_pReceivePutTCP->IsQueueValid())
  1355.     {
  1356. rc = HXR_OUTOFMEMORY;
  1357. goto cleanup;
  1358.     }
  1359.     m_pReceivePutTCP->SetMaxSize(TCP_BUF_SIZE);
  1360. }
  1362. if (pInBuffer)
  1363. {
  1364.     m_pReceivePutTCP->EnQueue(pInBuffer->GetBuffer(), (UINT16) pInBuffer->GetSize());
  1365. }
  1367. count = m_pReceivePutTCP->GetQueuedItemCount();
  1369. if (count >= 2)
  1370. {
  1371.     char* pEndLineLocation = 0;
  1372.     if (!m_pHTTPHeaderBuffer || m_nHTTPHeaderBufferLength < count+1)
  1373.     {
  1374. HX_VECTOR_DELETE(m_pHTTPHeaderBuffer);
  1375. m_nHTTPHeaderBufferLength = count+1 > DEFAULT_HTTP_HEADER_LENGTH ?
  1376.     count+1 : DEFAULT_HTTP_HEADER_LENGTH;
  1377. m_pHTTPHeaderBuffer = new char[m_nHTTPHeaderBufferLength];
  1378. if (!m_pHTTPHeaderBuffer)
  1379. {
  1380.     rc = HXR_OUTOFMEMORY;
  1381.     goto cleanup;
  1382. }
  1383.     }
  1385.     m_pReceivePutTCP->DeQueue(m_pHTTPHeaderBuffer, count);
  1386.     m_pHTTPHeaderBuffer[count] = '';
  1388.     if ((pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "nn")) ||
  1389.      (pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "rr")) )
  1390.     {
  1391. m_bHTTPPutHeaderReadDone = TRUE;
  1392.     }
  1393.     else if (count >= 4 &&
  1394.     (pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "rnrn")))
  1395.     {
  1396. m_bHTTPPutHeaderReadDone = TRUE;
  1397.     }
  1398.     else
  1399.     {
  1400. /* Put back everything in receive queue*/
  1401. m_pReceivePutTCP->EnQueue(m_pHTTPHeaderBuffer, count);
  1402. goto cleanup;
  1403.     }
  1405.     m_bPutResponsed = TRUE;
  1406.     GetServerIPFromResponse(FALSE, m_pHTTPHeaderBuffer);
  1408.     if (m_bConnectToSameServerIP)
  1409.     {
  1410. rc = ActualConnect();
  1411.     }
  1412.     else
  1413.     {
  1414. if (m_pszPutServerIP && m_pPreferredTransport)
  1415. {
  1416.     m_pPreferredTransport->SetHTTPNG(TRUE);
  1417. }
  1419. // determine whether we need to issue re-GET to the same serverIP
  1420. // from the POST response
  1421. if (m_pszGetServerIP && m_pszPutServerIP)
  1422. {
  1423.     m_bReconnectToSameServerIP = strcasecmp(m_pszGetServerIP, m_pszPutServerIP);
  1424. }
  1426. if (m_bReconnectToSameServerIP)
  1427. {
  1428.     rc = ReconnectToSameServerIP();
  1429. }
  1430.     }
  1431. }
  1432.     }
  1434. cleanup:
  1436.     return rc;
  1437. }
  1439. void
  1440. HXClientCloakedTCPSocket::TransferBuffers()
  1441. {
  1442.     IHXBuffer* pBuffer = 0;
  1443.     HX_RESULT theErr = HXR_OK;
  1445.     if (m_bInTransferBuffers)
  1446.     {
  1447. return;
  1448.     }
  1450.     m_bInTransferBuffers = TRUE;
  1452.     /*This is where we need to add POST header for multiple POST case*/
  1454.     while (m_PendingWriteBuffers.GetCount() > 0)
  1455.     {
  1456. pBuffer = (IHXBuffer*) m_PendingWriteBuffers.GetHead();
  1457. if ((UINT16) pBuffer->GetSize() < m_pPreEncodedSendHTTP->GetMaxAvailableElements())
  1458. {
  1459.     m_pPreEncodedSendHTTP->EnQueue(pBuffer->GetBuffer(), 
  1460. (UINT16) pBuffer->GetSize());
  1461.     pBuffer->Release();
  1462.     m_PendingWriteBuffers.RemoveHead();
  1463. }
  1464. else
  1465. {
  1466.     break;
  1467. }
  1468.     }
  1470.     UINT16 nCount = m_pPreEncodedSendHTTP->GetQueuedItemCount();
  1471.     if (nCount > 0)
  1472.     {
  1473. if (m_bCloseHttpAfterWrite)
  1474. {
  1475.     ENQUEUE_BYTE(m_pPreEncodedSendHTTP, HTTP_POSTDONE);
  1476.     nCount++;
  1477. }
  1479. if (m_bMustCloseHTTP && m_pPutCtrl)
  1480. {
  1481.     m_pPutCtrl->Release();
  1482.     m_pPutCtrl = 0;
  1483.     m_bPutConnectDone = FALSE;
  1485.     m_pNetworkServices->CreateTCPSocket(&m_pPutCtrl);
  1486.     if (!m_pPutCtrl)
  1487.     {
  1488. m_LastError = HXR_OUTOFMEMORY;
  1489. m_bInTransferBuffers = FALSE;
  1490. return;
  1491.     }
  1493.     m_pPutCtrl->Init(m_pPutCtrlResponse);
  1495.     const char* pActualHost = m_pForiegnHost;
  1496.     UINT16  nActualPort = m_nForeignPort;
  1497.     if (m_pProxyHostName)
  1498.     {
  1499. pActualHost = m_pProxyHostName;
  1500. nActualPort = m_nProxyPortNumber;
  1501.     }
  1503.     m_pPutCtrl->Connect(pActualHost,nActualPort);
  1504. }
  1506. m_pPreEncodedSendHTTP->DeQueue(m_pOutBuf, nCount);
  1507. UINT16 nEncodedCount = TCP_BUF_SIZE;
  1508. EncodeBase64((UCHAR*) m_pOutBuf, nCount, (UCHAR*) m_pOutEncodedBuf, nEncodedCount);
  1510.         HX_ASSERT(nEncodedCount <= TCP_BUF_SIZE);
  1512. if (m_bCloseHttpAfterWrite)
  1513. {
  1514.     theErr = PreparePostMessage((UCHAR*) m_pOutEncodedBuf, nEncodedCount);
  1515. }
  1516. else
  1517. {
  1518.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,m_pOutEncodedBuf, nEncodedCount);
  1519. }
  1520.     }
  1522.     m_bInTransferBuffers = FALSE;
  1523. }
  1525. /***************************General routines*******/
  1527. HX_RESULT
  1528. HXClientCloakedTCPSocket::PreparePostMessage(const UCHAR *inData, UINT16 inLength) 
  1529. {
  1530.     HX_RESULT theErr = HXR_OK;
  1531.     int count = 0;
  1532.     UINT16 postLength = inLength;
  1533.     
  1534.     // create a temp buffer to help build the HTTP POST message
  1535.     char* s = new char[MAX_HTTP_METHOD_BUFSIZE];
  1536.     if(s == NULL)
  1537.     {
  1538. return HXR_OUTOFMEMORY;
  1539.     }
  1540.     // build the HTTP POST message
  1541.     if(m_pProxyHostName)
  1542.     {
  1543. if (m_nForeignPort)
  1544. {
  1545.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"POST http://%s:%d/SmpDsBhgRl",m_pForiegnHost, m_nForeignPort);
  1546. }
  1547. else
  1548. {
  1549.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"POST http://%s/SmpDsBhgRl",m_pForiegnHost);
  1550. }
  1551.     }
  1552.     else
  1553.     {
  1554. //count = sprintf(s,"POST /SmpDsBhgRl"); /* Flawfinder: ignore */
  1555. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"POST /SmpDsBhgRl"); /* Flawfinder: ignore */
  1556.     }
  1557.     
  1558.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1560.     // enqueue the remainder of the POST line
  1561.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE," HTTP/1.0rn"); /* Flawfinder: ignore */
  1562.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1564.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"User-Agent: RealPlayer G2rn"); /* Flawfinder: ignore */
  1565.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1567.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Pragma: no-cachern"); /* Flawfinder: ignore */
  1568.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1570.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Expires: Mon, 18 May 1974 00:00:00 GMTrn"); /* Flawfinder: ignore */
  1571.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1573.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Accept: application/x-rtsp-tunnelled, */*rn"); /* Flawfinder: ignore */
  1574.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1576.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Content-type: application/x-pncmdrn"); /* Flawfinder: ignore */
  1577.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1579.     CHXString strAuth;
  1580.     ObtainAuthenticationInformation(strAuth);
  1581.     
  1582.     if (!strAuth.IsEmpty())
  1583.     {
  1584. strAuth += "rn";    
  1585. ENQUEUE_DATA(m_pPostEncodedSendHTTP, (void*)(const char*)strAuth, 
  1586.      (UINT16)strAuth.GetLength());
  1587.     }
  1589.     UINT16 guidSize = ::strlen(m_pGuid);
  1591.     if(m_bUseExactContentLength)
  1592.     {
  1593. // add in the size of the GUID (which was not base64 encoded)
  1594. postLength += guidSize + 2; // 2 is for the rn at the end of the GUID!
  1596. // we must report the exact size of the post data in the Content-length parameter
  1597. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Content-length: %hurn",postLength); /* Flawfinder: ignore */
  1598.     }
  1599.     else
  1600.     {
  1601. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Content-length: 32767rn"); /* Flawfinder: ignore */
  1602.     }
  1604.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1606.     // enqueue the CR LF to indicate end of the POST header
  1607.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"rn"); /* Flawfinder: ignore */
  1608.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1610.     // enqueue the GUID (Must be sent with every POST and not base64 encoded)
  1611.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,&m_pGuid[0],guidSize);
  1612.     
  1613.     // enqueue the CR LF to indicate end of the GUID
  1614.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"rn"); /* Flawfinder: ignore */
  1615.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1617.     if(inLength > 0)
  1618.     {
  1619. // enqueue the actual POST data
  1620. ENQUEUE_DATA(m_pPostEncodedSendHTTP,(char *)inData,inLength);
  1621.     }
  1622.     
  1623.     // clean up allocated buffers
  1624.     if(s)
  1625.     {
  1626. delete [] s;
  1627.     }
  1629.     return theErr;
  1630. }
  1632. HX_RESULT
  1633. HXClientCloakedTCPSocket::PrepareGetMessage(void) 
  1634. {
  1635.     HX_RESULT theErr = HXR_OK;
  1636.     IHXBuffer* pBuffer = NULL;
  1638.     // create a temp buffer for the HTTP GET message
  1639.     char* s = new char[MAX_HTTP_METHOD_BUFSIZE];
  1640.     
  1641.     if(s == NULL)
  1642.     {
  1643. theErr = HXR_OUTOFMEMORY;
  1644.     }
  1645.     
  1646.     /* Flush any prior data in the send queue */
  1647.     m_pSendTCP->FlushQueue();
  1649.     /* Create a fresh GUID */
  1650.     CreateGuid();
  1652.     // format the HTTP GET message
  1653.     if(!theErr)
  1654.     {
  1655. int count = 0;
  1657. // build the HTTP POST message
  1658. if(m_pProxyHostName)
  1659. {   
  1660.     if (m_nForeignPort)
  1661.     {
  1662. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"GET http://%s:%d/SmpDsBhgRl",m_pForiegnHost, m_nForeignPort);
  1663.     }
  1664.     else
  1665.     {
  1666. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"GET http://%s/SmpDsBhgRl",m_pForiegnHost);
  1667.     }
  1668. }
  1669. else
  1670. {
  1671.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"GET /SmpDsBhgRl"); /* Flawfinder: ignore */
  1672. }
  1674. ENQUEUE_DATA(m_pSendTCP,s,count);
  1676. #if 0 // XXX HP enable this to test re-GET after initial GET/POST response 
  1677. // returned with different serverIP
  1678. if (!m_bReconnectToSameServerIP)
  1679. {
  1680.     char* pGuid = new char[strlen(m_pGuid)+1];
  1681.     memcpy(pGuid, m_pGuid, strlen(m_pGuid)); /* Flawfinder: ignore */
  1682.     pGuid[0] = 'z';
  1683.     // enqueue the GUID directly after the SmpDsBhgRl tag
  1684.     ENQUEUE_DATA(m_pSendTCP,&pGuid[0],::strlen(pGuid));
  1685.     HX_VECTOR_DELETE(pGuid);
  1686. }
  1687. else
  1688. #endif
  1689. {
  1690.     // enqueue the GUID directly after the SmpDsBhgRl tag
  1691.     ENQUEUE_DATA(m_pSendTCP,&m_pGuid[0],::strlen(m_pGuid));
  1692. }
  1694. if (m_pProxyHostName)
  1695. {
  1696.     /* 
  1697.      * enqueue dummy option to tell the server to send a padding
  1698.      * of 16k of ZEROs with the first response
  1699.      */
  1700.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"?1="1""); /* Flawfinder: ignore */
  1701.     ENQUEUE_DATA(m_pSendTCP,s,count);
  1702. }
  1704. // enqueue the HTTP 1.0 and CR LF
  1705. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE," HTTP/1.0rn"); /* Flawfinder: ignore */
  1706. ENQUEUE_DATA(m_pSendTCP,s,count);
  1708. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"User-Agent: RealPlayer G2rn"); /* Flawfinder: ignore */
  1709. ENQUEUE_DATA(m_pSendTCP,s,count);
  1711. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Expires: Mon, 18 May 1974 00:00:00 GMTrn"); /* Flawfinder: ignore */
  1712. ENQUEUE_DATA(m_pSendTCP,s,count);
  1714. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Pragma: no-cachern"); /* Flawfinder: ignore */
  1715. ENQUEUE_DATA(m_pSendTCP,s,count);
  1717. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Accept: application/x-rtsp-tunnelled, */*rn"); /* Flawfinder: ignore */
  1718. ENQUEUE_DATA(m_pSendTCP,s,count);
  1720. CHXString strAuth;
  1721. ObtainAuthenticationInformation(strAuth);
  1723. if (!strAuth.IsEmpty())
  1724. {
  1725.     strAuth += "rn";    
  1726.     ENQUEUE_DATA(m_pSendTCP, (void*)(const char*)strAuth, 
  1727.  (UINT16)strAuth.GetLength());
  1728. }
  1730. // send client information so that GoldPass Admin
  1731. // can generate redirect URL via HTTPCloaking
  1732. if (m_pCloakValues)
  1733. {
  1734.     if (HXR_OK == m_pCloakValues->GetPropertyCString("ClientID", pBuffer))
  1735.     {
  1736. UINT32 ulNewSize = pBuffer->GetSize()+25;
  1737. s = (char*)realloc(s, ulNewSize);
  1738.                 if(s)
  1739.                 {
  1740.                     count = SafeSprintf(s,ulNewSize,"ClientID: %srn", pBuffer->GetBuffer()); /* Flawfinder: ignore */
  1741.                     ENQUEUE_DATA(m_pSendTCP,s,count);
  1742.                 }
  1743.                 else
  1744.                 {
  1745.                     theErr = HXR_OUTOFMEMORY;
  1746.                 }
  1747.                 
  1748.     }
  1749.     HX_RELEASE(pBuffer);
  1751.     if (HXR_OK == m_pCloakValues->GetPropertyCString("Cookie", pBuffer))
  1752.     {
  1753. UINT32 ulNewSize = pBuffer->GetSize()+25;
  1754. s = (char*)realloc(s, ulNewSize);
  1755.                 if(s)
  1756.                 {
  1757.                     count = SafeSprintf(s,ulNewSize,"Cookie: %srn", pBuffer->GetBuffer()); /* Flawfinder: ignore */
  1758.                     ENQUEUE_DATA(m_pSendTCP,s,count);
  1759.                 }
  1760.                 else
  1761.                 {
  1762.                     theErr = HXR_OUTOFMEMORY;
  1763.                 }
  1764.             }
  1765.     HX_RELEASE(pBuffer);
  1767.     if (HXR_OK == m_pCloakValues->GetPropertyCString("url", pBuffer))
  1768.     {
  1769. UINT32 ulNewSize = pBuffer->GetSize()+25;
  1770.                 s = (char*)realloc(s, ulNewSize);
  1771.                 if(s)
  1772.                 {
  1773.                     count = SafeSprintf(s,ulNewSize,"X-Actual-URL: %srn", pBuffer->GetBuffer()); /* Flawfinder: ignore */
  1774.                     ENQUEUE_DATA(m_pSendTCP,s,count);
  1775.                 }
  1776.                 else
  1777.                 {
  1778.                     theErr = HXR_OUTOFMEMORY;
  1779.                 }
  1780.     }
  1781.     HX_RELEASE(pBuffer);
  1782. }
  1784. // enqueue the CR LF to indicate the end of the HTTP GET header
  1785.         s = (char*)realloc(s, 25);
  1786.         if(s)
  1787.         {
  1788.             count = SafeSprintf(s,25,"rn"); /* Flawfinder: ignore */
  1789.             ENQUEUE_DATA(m_pSendTCP,s,count);
  1790.         }
  1791.         else
  1792.         {
  1793.             theErr = HXR_OUTOFMEMORY;
  1794.         }
  1795.     }
  1796.     
  1797.     // clean up
  1798.     HX_DELETE(s);
  1799.     
  1800.     return theErr;
  1801. }
  1803. void
  1804. HXClientCloakedTCPSocket::CreateGuid(void)
  1805. {
  1806.     CHXuuid theGuid;
  1807.     uuid_tt uuid;
  1808.     
  1809.     if (m_pGuid)
  1810.     {
  1811. return;
  1812.     }
  1814.     if(m_pGuid)
  1815.     {
  1816. delete [] m_pGuid;
  1817. m_pGuid = NULL;
  1818.     }
  1819.     
  1820.     // generate a new GUID
  1821.     HX_RESULT theErr = theGuid.GetUuid(&uuid);
  1822. //    HX_RESULT theErr = HXR_OK;
  1824.     if(!theErr)
  1825.     {
  1826. CHXString theString;
  1828. CHXuuid::HXUuidToString((const uuid_tt*)&uuid,&theString);
  1830. int length = theString.GetLength();
  1832. m_pGuid = new char[length + 1];
  1834. if(!m_pGuid)
  1835. {
  1836. theErr = HXR_OUTOFMEMORY;
  1837. }
  1839. if(!theErr)
  1840. {
  1841. ::strcpy(m_pGuid,(const char *)theString); /* Flawfinder: ignore */
  1842. m_pGuid[length] = '';
  1843. }
  1845. if(theErr && m_pGuid)
  1846. {
  1847. delete [] m_pGuid;
  1848. m_pGuid = NULL;
  1849. }
  1850.     }
  1851.     
  1852.     if(theErr)  // use our own GUID generator
  1853.     {
  1854. theErr = HXR_OK;
  1855. ULONG32 temp = HX_GET_TICKCOUNT();
  1857. if(m_pGuid)
  1858. {
  1859.     delete [] m_pGuid;
  1860.     m_pGuid = NULL;
  1861. }
  1862.     
  1863. m_pGuid = new char[HXGUID_SIZE + 1];
  1865. UINT16 length = SafeSprintf(m_pGuid,HXGUID_SIZE + 1,"%ld",temp);
  1867. while(length < HXGUID_SIZE)
  1868. {
  1869. m_pGuid[length++] = '1';
  1870. }
  1872. m_pGuid[HXGUID_SIZE] = '';
  1873.     }
  1874. }
  1876. HX_RESULT 
  1877. HXClientCloakedTCPSocket::EncodeBase64(const UCHAR* inData, UINT16 inLength, UCHAR* outData, UINT16& outLength)
  1878. {
  1879.     HX_RESULT theErr = HXR_OK;
  1880.     
  1881.     HX_ASSERT(inData != NULL);
  1882.     HX_ASSERT(outData != NULL);
  1883.     HX_ASSERT(inLength != 0);
  1884.     
  1885.     // first base64 encode the buffer
  1886.     outLength = (UINT16) BinTo64((const UCHAR*) inData, (ULONG32) inLength,(char *)outData);
  1888.     HX_ASSERT(outLength >= inLength);
  1890.     return HXR_OK;
  1891. }
  1894. HX_RESULT
  1895. HXClientCloakedTCPSocket::HandleHTTPResponse(UCHAR response)
  1896. {
  1897.     HX_RESULT theErr = HXR_OK;
  1898.     
  1899.     switch(response)
  1900.     {
  1901. case HTTP_OK:
  1902. {
  1903.     m_bUseExactContentLength = FALSE;
  1904.     m_bCloseHttpAfterWrite = FALSE;
  1905.     m_bHttpInitialized = TRUE;
  1906.     /*force a write of the cached data to be sent to the server*/
  1907. //     theErr = control_write();
  1908. }
  1909. break;
  1911. case POST_NOT_RECEIVED: // POST message was not received
  1912. {
  1913.     if (m_pszGetServerIP)
  1914.     {
  1915. HX_VECTOR_DELETE(m_pForiegnHost);
  1916. // use serverIP from GET response for multi-POST
  1917. m_pForiegnHost = new char [strlen(m_pszGetServerIP) + 1];
  1918. if (m_pForiegnHost)
  1919. {
  1920.     ::strcpy(m_pForiegnHost, m_pszGetServerIP); /* Flawfinder: ignore */
  1921. }
  1922. else
  1923. {
  1924.     theErr = HXR_OUTOFMEMORY;
  1925. }
  1926.     }
  1927.  
  1928.     m_bUseExactContentLength = TRUE;
  1929.     m_bCloseHttpAfterWrite = TRUE;
  1930.     m_bHttpInitialized = TRUE;
  1931.     m_bMustCloseHTTP = TRUE;
  1933.     /*force a write of the cached data to be sent to the server*/
  1934. //     theErr = control_write();
  1935. }
  1936. break;
  1938. case INVALID_GUID: 
  1939. {
  1940.     /* sent only if the GUID from the Player is already in use
  1941.      * Need to regenerate GUID and send everything again
  1942.      */
  1943.     /// TBD - Rahul     
  1944.     if (m_pGuid)
  1945.     {
  1946. delete [] m_pGuid;
  1947. m_pGuid = 0;
  1948.     }
  1950.     PrepareGetMessage();
  1951.     theErr = DoGetWrite();
  1952. }
  1953. break;
  1955. default:
  1956. {
  1957.     // shut this clip down and report an appropriate error
  1958.     theErr = HXR_HTTP_CONTENT_NOT_FOUND;
  1959. }
  1960. break;
  1961.     }
  1962.     
  1963.     return theErr;
  1964. }
  1966. /* If we are at interrupt time and the response object is not interrupt safe,
  1967.  * schedule a callback to return back the data
  1968.  */
  1969. BOOL
  1970. HXClientCloakedTCPSocket::IsSafe()
  1971. {
  1972.     if (m_pInterruptState && m_pInterruptState->AtInterruptTime() && 
  1973. (!m_pResponseInterruptSafe || 
  1974.  !m_pResponseInterruptSafe->IsInterruptSafe()))
  1975.     {
  1976. if (m_pNonInterruptCallback){
  1977.     m_pNonInterruptCallback->ScheduleCallback(CLOAKED_TCP_READ_COMMAND, m_pScheduler, 0);
  1978. }
  1980. return FALSE;
  1981.     }
  1983.     return TRUE;
  1984. }
  1986. void
  1987. HXClientCloakedTCPSocket::FlushQueues(void)
  1988. {
  1989.     if (m_pSendTCP)
  1990.     {
  1991. m_pSendTCP->FlushQueue();
  1992.     }
  1994.     if (m_pReceiveGetTCP)
  1995.     {
  1996. m_pReceiveGetTCP->FlushQueue();
  1997.     }
  1999.     if (m_pReceivePutTCP)
  2000.     {
  2001. m_pReceivePutTCP->FlushQueue();
  2002.     }
  2004.     if (m_pPreEncodedSendHTTP)
  2005.     {
  2006. m_pPreEncodedSendHTTP->FlushQueue();
  2007.     }
  2009.     if (m_pPostEncodedSendHTTP)
  2010.     {
  2011. m_pPostEncodedSendHTTP->FlushQueue();
  2012.     }
  2013. }
  2015. void
  2016. HXClientCloakedTCPSocket::SendHTTPDone(void)
  2017. {
  2018.     CHXBuffer* pBuffer = new CHXBuffer;
  2019.     pBuffer->AddRef();
  2021.     BYTE http_done = HTTP_DONE;
  2022.     pBuffer->Set((UCHAR*) &http_done, 1);
  2023.     m_PendingWriteBuffers.AddTail((void*) pBuffer);
  2025.     TransferBuffers();
  2026.     DoPutWrite();
  2027. }
  2029. HX_RESULT
  2030. HXClientCloakedTCPSocket::ActualConnect(void)
  2031. {
  2032.     HX_RESULT rc = HXR_OK;
  2034.     const char* pActualHost = m_pForiegnHost;
  2035.     UINT16  nActualPort = m_nForeignPort;
  2036.     if (m_pProxyHostName)
  2037.     {
  2038. pActualHost = m_pProxyHostName;
  2039. nActualPort = m_nProxyPortNumber;
  2040.     }
  2042.     if (m_bConnectToSameServerIP)
  2043.     {
  2044. if (m_bPutConnectSuccessful)
  2045. {
  2046.     rc = m_pGetCtrl->Connect(pActualHost,nActualPort);
  2047. }
  2048. else
  2049. {
  2050.     rc = m_pPutCtrl->Connect(pActualHost,nActualPort);
  2051. }
  2052. rc = ConvertNetworkError(rc);
  2053.     }
  2054.     else
  2055.     {
  2056. rc = m_pGetCtrl->Connect(pActualHost,nActualPort);
  2057. rc = ConvertNetworkError(rc);
  2059. if (rc == HXR_OK && !m_bReconnectToSameServerIP)
  2060. {
  2061.     rc = m_pPutCtrl->Connect(pActualHost,nActualPort);
  2062.     rc = ConvertNetworkError(rc);
  2063. }
  2064.     }
  2066.     return rc;
  2067. }
  2069. HX_RESULT
  2070. HXClientCloakedTCPSocket::GetServerIPFromResponse(BOOL bGetResponse, const char* pszInBuffer)
  2071. {
  2072.     HX_RESULT rc = HXR_OK;
  2073.     UINT8 nLength = 0;
  2074.     char* pszServerIPStart = NULL;    
  2075.     char* pszServerIPEnd = NULL;
  2076.     char* pszServerIP = NULL;
  2078.     if (!pszInBuffer)
  2079.     {
  2080. rc = HXR_FAILED;
  2081. goto cleanup;
  2082.     }
  2084.     pszServerIPStart = (char*)HXFindString(pszInBuffer, "x-server-ip-address:");
  2086.     if (pszServerIPStart)
  2087.     {
  2088. pszServerIPStart += strlen("x-server-ip-address:");
  2090. // removing leading spaces
  2091. while (*pszServerIPStart == ' ')
  2092. {
  2093.     pszServerIPStart++;
  2094. }
  2096. pszServerIPEnd = (char*)HXFindString(pszServerIPStart, "rn");
  2097. if (pszServerIPEnd)
  2098. {
  2099.     nLength = pszServerIPEnd - pszServerIPStart;
  2101.     pszServerIP = new char[nLength + 1];
  2102.     memset(pszServerIP, 0, nLength + 1);
  2104.     strncpy(pszServerIP, pszServerIPStart, nLength); /* Flawfinder: ignore */
  2106.     if (bGetResponse)
  2107.     {
  2108. HX_VECTOR_DELETE(m_pszGetServerIP);
  2109. m_pszGetServerIP = pszServerIP;
  2110.     }
  2111.     else
  2112.     {
  2113. HX_VECTOR_DELETE(m_pszPutServerIP);
  2114. m_pszPutServerIP = pszServerIP;
  2115.     }
  2116. }
  2117.     }
  2119. cleanup:
  2121.     return rc;
  2122. }
  2125. HX_RESULT
  2126. HXClientCloakedTCPSocket::CleanUpAndReInitializeStuff(void)
  2127. {
  2128.     HX_RESULT rc = HXR_OK;
  2129.     IHXBuffer* pBuffer = NULL;
  2131.     m_pMutex->Lock();
  2133.     const char* pActualHost = m_pForiegnHost;
  2134.     UINT16  nActualPort = m_nForeignPort;
  2135.     if (m_pProxyHostName)
  2136.     {
  2137. pActualHost = m_pProxyHostName;
  2138. nActualPort = m_nProxyPortNumber;
  2139.     }
  2141.     if (m_pReceiveGetTCP)
  2142.     {
  2143. m_pReceiveGetTCP->FlushQueue();
  2144.     }
  2146.     /* Send a final HTTP done message */
  2147.     if (m_bHttpInitialized)
  2148.     {
  2149. SendHTTPDone();
  2150.     }
  2152.     if (m_pSchedulerCallback)
  2153.     {
  2154. m_pSchedulerCallback->Unschedule(m_pScheduler);
  2155.     }
  2157.     if (m_pNonInterruptCallback)
  2158.     {
  2159. m_pNonInterruptCallback->Unschedule(m_pScheduler);
  2160.     }
  2162.     HX_RELEASE(m_pGetCtrl);
  2163.     HX_RELEASE(m_pPutCtrl);
  2164.     
  2165.     m_bHTTPGetHeaderReadDone = FALSE;
  2166.     m_bOptionsReceived = FALSE;
  2167.     m_bReadPending = FALSE;
  2168.     m_bGetReadPending = FALSE;
  2169.     m_bGetConnectDone = FALSE;
  2170.     m_bGetConnectSuccessful = FALSE;
  2171.     m_bConnectResponsePending = TRUE;
  2172.     m_bConnected = FALSE;
  2174.     m_bPutConnectDone = FALSE;
  2175.     m_bPutReadPending = FALSE;
  2177.     m_bInAuthenticationKludge = TRUE;
  2178.     
  2179.     // OK, clean up is done so now we re-initialize.
  2180.     
  2181.     
  2182.     // use serverIP from PUT response for GET reconnect
  2183.     
  2184.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pGetCtrl))
  2185.     {
  2186. rc = HXR_FAILED;
  2187. goto cleanup;
  2188.     }
  2190.     if (HXR_OK != m_pGetCtrl->Init(m_pGetCtrlResponse))
  2191.     {
  2192. rc = HXR_FAILED;
  2193. goto cleanup;
  2194.     }
  2196.     if (HXR_OK != m_pGetCtrl->Bind(HXR_INADDR_ANY, 0))
  2197.     {
  2198. rc = HXR_FAILED;
  2199. goto cleanup;
  2200.     }
  2201.     
  2202.     rc = m_pGetCtrl->Connect(pActualHost, nActualPort);    
  2203.     if (HXR_OK != rc)
  2204.     {
  2205. goto cleanup;
  2206.     }
  2208.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pPutCtrl))
  2209.     {
  2210. rc = HXR_FAILED;
  2211. goto cleanup;
  2212.     }
  2214.     if (HXR_OK != m_pPutCtrl->Init(m_pPutCtrlResponse))
  2215.     {
  2216. rc = HXR_FAILED;
  2217. goto cleanup;
  2218.     }
  2220.     if (HXR_OK != m_pPutCtrl->Bind(HXR_INADDR_ANY, 0))
  2221.     {
  2222. rc = HXR_FAILED;
  2223. goto cleanup;
  2224.     }
  2226.     rc = m_pPutCtrl->Connect(pActualHost, nActualPort);
  2227.     if (HXR_OK != rc) goto cleanup;
  2230. cleanup:
  2231.     m_pMutex->Unlock();
  2233.     return rc;
  2234. }
  2236. HX_RESULT
  2237. HXClientCloakedTCPSocket::ReconnectToSameServerIP(void)
  2238. {
  2239.     HX_RESULT rc = HXR_OK;
  2240.     IHXBuffer* pBuffer = NULL;
  2242.     m_pMutex->Lock();
  2244.     if (m_pReceiveGetTCP)
  2245.     {
  2246. m_pReceiveGetTCP->FlushQueue();
  2247.     }
  2249.     /* Send a final HTTP done message */
  2250.     if (m_bHttpInitialized)
  2251.     {
  2252. SendHTTPDone();
  2253.     }
  2255.     if (m_pSchedulerCallback)
  2256.     {
  2257. m_pSchedulerCallback->Unschedule(m_pScheduler);
  2258.     }
  2260.     if (m_pNonInterruptCallback)
  2261.     {
  2262. m_pNonInterruptCallback->Unschedule(m_pScheduler);
  2263.     }
  2265.     HX_RELEASE(m_pGetCtrl);
  2266.     HX_RELEASE(m_pGetCtrlResponse);
  2267.     
  2268.     m_bHTTPGetHeaderReadDone = FALSE;
  2269.     m_bOptionsReceived = FALSE;
  2270.     m_bReadPending = FALSE;
  2271.     m_bGetReadPending = FALSE;
  2272.     m_bGetConnectDone = FALSE;
  2273.     m_bGetConnectSuccessful = FALSE;
  2274.     m_bConnectResponsePending = TRUE;
  2275.     m_bConnected = FALSE;
  2277.     HX_VECTOR_DELETE(m_pForiegnHost);
  2278.     // use serverIP from PUT response for GET reconnect
  2279.     m_pForiegnHost = new char [strlen(m_pszPutServerIP) + 1];
  2280.     if (!m_pForiegnHost)
  2281.     {
  2282. rc = HXR_OUTOFMEMORY;
  2283. goto cleanup;
  2284.     }
  2285.     ::strcpy(m_pForiegnHost, m_pszPutServerIP); /* Flawfinder: ignore */
  2286.     
  2287.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pGetCtrl))
  2288.     {
  2289. rc = HXR_FAILED;
  2290. goto cleanup;
  2291.     }
  2293.     m_pGetCtrlResponse = new HTTPCloakTCPResponse(this, TRUE);
  2294.     if (!m_pGetCtrlResponse)
  2295.     {
  2296. rc = HXR_FAILED;
  2297. goto cleanup;
  2298.     }
  2300.     m_pGetCtrlResponse->AddRef();
  2302.     if (HXR_OK != m_pGetCtrl->Init(m_pGetCtrlResponse))
  2303.     {
  2304. rc = HXR_FAILED;
  2305. goto cleanup;
  2306.     }
  2308.     if (HXR_OK != m_pGetCtrl->Bind(HXR_INADDR_ANY, 0))
  2309.     {
  2310. rc = HXR_FAILED;
  2311. goto cleanup;
  2312.     }
  2314.     rc = ActualConnect();
  2316. cleanup:
  2318.     m_pMutex->Unlock();
  2320.     return rc;
  2321. }
  2323. BOOL
  2324. HXClientCloakedTCPSocket::AuthenticationRequired(HX_RESULT   status, IHXBuffer* pInBuffer)
  2325. {
  2326.     if (!pInBuffer)
  2327.     {
  2328. return FALSE;
  2329.     }
  2331.     // start of authenticated proxy logic.
  2333.     HTTPParser Parser;
  2334.     char* pBufferContents = (char*)(const char*)pInBuffer->GetBuffer();
  2335.     ULONG32 nMsgLen = pInBuffer->GetSize();
  2336.     HTTPResponseMessage* pMessage = (HTTPResponseMessage*)Parser.parse( pBufferContents, nMsgLen );
  2338.     // ignore non-HTTP responses which will be processed by the response object:
  2339.     // RTSPClientProtocol
  2340.     if (HTTPMessage::T_UNKNOWN == pMessage->tag())
  2341.     {
  2342. return FALSE;
  2343.     }
  2345.     ULONG32 ulHTTPStatus = 0;
  2346.     if (strlen(pMessage->errorCode()) > 0)
  2347.     {
  2348. ulHTTPStatus = atoi(pMessage->errorCode());
  2349.     }
  2351.     if (ulHTTPStatus == 401 || ulHTTPStatus == 407)
  2352.     {
  2353. #ifdef _MACINTOSH
  2354. if (!IsMacInCooperativeThread())
  2355. {
  2356.     // xxxbobclark Since there's UI involved with authentication,
  2357.     // we'll ensure that we're not at interrupt time.
  2358.     if (m_pAuthenticationCallback && !m_pAuthenticationCallback->m_ulPendingCallbackID)
  2359.     {
  2360. m_pAuthenticationCallback->m_ulPendingCallbackID  =
  2361. m_pScheduler->RelativeEnter(m_pAuthenticationCallback, 0);
  2362. m_pAuthenticationCallback->m_Status = status;
  2363. pInBuffer->AddRef();
  2364. m_pAuthenticationCallback->m_pInBuffer = pInBuffer;
  2365.     }
  2367.     HX_DELETE(pMessage);
  2368.     return TRUE;  
  2369. }
  2370. #endif
  2371. IHXRequest* pRequest = NULL;
  2373. IHXCommonClassFactory* pCCF;
  2374. HX_RESULT retVal = m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCCF);
  2376. if (SUCCEEDED(retVal))
  2377. {
  2378.     retVal = pCCF->CreateInstance(CLSID_IHXRequest, (void**)&pRequest);
  2380.     if(retVal == HXR_OK)
  2381.     {
  2382. PrepareGetMessage(); // set up m_pSendTCP
  2384. UINT16 count    = m_pSendTCP->GetQueuedItemCount();
  2385. m_pSendTCP->DeQueue(m_pOutBuf,count);
  2387. retVal = pRequest->SetURL(m_pOutBuf);
  2389. IHXKeyValueList* pResponseHeaders = NULL;
  2391. pCCF->CreateInstance(CLSID_IHXKeyValueList, (void**)&pResponseHeaders);
  2393. MIMEHeaderValue* pHeaderValue = NULL;
  2394. MIMEHeader* pHeader = pMessage->getFirstHeader();
  2395. while (pHeader)
  2396. {
  2397.     pHeaderValue = pHeader->getFirstHeaderValue();
  2398.     CHXString strHeader;
  2399.     while (pHeaderValue)
  2400.     {
  2401. CHXString strTemp;
  2402. pHeaderValue->asString(strTemp);
  2403. strHeader += strTemp;
  2404. pHeaderValue = pHeader->getNextHeaderValue();
  2405. if (pHeaderValue)
  2406. {
  2407.     strHeader += ", ";
  2408. }
  2409.     }
  2410.     IHXBuffer* pBuffer = NULL;
  2411.     CHXBuffer::FromCharArray((const char*)strHeader, &pBuffer);
  2412.     pResponseHeaders->AddKeyValue(pHeader->name(), pBuffer);
  2413.     HX_RELEASE(pBuffer);
  2415.     pHeader = pMessage->getNextHeader();
  2416. }
  2418. IHXValues* pResponseValues = NULL;             
  2420. if (HXR_OK == pResponseHeaders->QueryInterface(IID_IHXValues, (void**)&pResponseValues))
  2421. {
  2422.     pRequest->SetResponseHeaders(pResponseValues);
  2423. }
  2425. HandleAuthentication(pRequest, pMessage, m_pForiegnHost, m_pProxyHostName);
  2427. HX_RELEASE(pResponseValues);
  2428. HX_RELEASE(pResponseHeaders);
  2430.     }
  2432.     HX_RELEASE(pCCF);
  2433. }
  2434. HX_DELETE(pMessage);
  2435. return TRUE;
  2436.     }
  2437.     HX_DELETE(pMessage);
  2438.     return FALSE;
  2439. }
  2441. #define CLOAKED_WWW_AUTHENTICATION_RECENT_KEY "authentication.http.realm.recent"
  2442. #define CLOAKED_PROXY_AUTHENTICATION_RECENT_KEY "proxy-authentication.http.realm.recent"
  2444. void
  2445. HXClientCloakedTCPSocket::ObtainAuthenticationInformation(CHXString& strAuth)
  2446. {
  2447.     IHXBuffer* pBuffer = NULL;
  2449.     CHXString key("no-authentication-information");
  2451.     CHXString recentAuthRealmInfo;
  2452.     CHXString recentProxyAuthRealmInfo;
  2454.     IHXBuffer* pHeaderBuffer = NULL;
  2455.     
  2456.     HX_RESULT theErr = HXR_OK;
  2458.     IHXRegistry* pRegistry = NULL;
  2459.     
  2460.     m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);
  2461.     HX_ASSERT(pRegistry);
  2462.     
  2463.     if (!pRegistry) return;
  2464.     
  2465.     theErr = pRegistry->GetStrByName(CLOAKED_WWW_AUTHENTICATION_RECENT_KEY, pHeaderBuffer);
  2466.     if (SUCCEEDED(theErr))
  2467.     {
  2468. HX_ASSERT(pHeaderBuffer);
  2469. recentAuthRealmInfo = CHXString((const char*)pHeaderBuffer->GetBuffer(), pHeaderBuffer->GetSize());
  2470. HX_RELEASE(pHeaderBuffer);
  2471.     }
  2473.     theErr = pRegistry->GetStrByName(CLOAKED_PROXY_AUTHENTICATION_RECENT_KEY, pHeaderBuffer);
  2474.     if (SUCCEEDED(theErr))
  2475.     {
  2476. HX_ASSERT(pHeaderBuffer);
  2477. recentProxyAuthRealmInfo = CHXString((const char*)pHeaderBuffer->GetBuffer(), pHeaderBuffer->GetSize());
  2478. HX_RELEASE(pHeaderBuffer);
  2479.     }
  2481.     key = "proxy-authentication.http:";
  2482.     key += m_pProxyHostName;
  2483.     key += ":";
  2484.     key += recentProxyAuthRealmInfo;
  2486.     if (HXR_OK == pRegistry->GetStrByName((const char*)key, pBuffer) )
  2487.     {
  2488. if (pBuffer)
  2489. {
  2490.     CHXString authString((const char*)pBuffer->GetBuffer(), pBuffer->GetSize());
  2492.     strAuth = "Proxy-Authorization: ";
  2493.     strAuth += (const char*)authString;
  2494. }
  2495.     }
  2496.     HX_RELEASE(pBuffer);
  2498.     HX_RELEASE(pRegistry);
  2499. }
  2501. HX_RESULT
  2502. HXClientCloakedTCPSocket::HandleAuthentication(IHXRequest* pRequest, HTTPResponseMessage* pMessage,
  2503. const char* pHost, const char* pProxyHost)
  2504. {
  2505.     HX_RESULT   ResultStatus = HXR_OK;
  2506.     UINT32      ulAltURL = 0;
  2507.     CHXString   sConnection;
  2508.     IHXValues* pNewHeaders = NULL;
  2511.     // xxxbobclark The reason we need to extract the IHXPlayer is that
  2512.     // later on the authenticator smart pointer needs a context which knows
  2513.     // about authentication conversations. this->m_pContext does not know
  2514.     // about the authentication conversation. That's why we have to iterate
  2515.     // through the players looking for someone. Sheesh.
  2517.     if (!pRequest)
  2518.     {
  2519.         return HXR_UNEXPECTED;
  2520.     }
  2522.     HX_RESULT retVal = HXR_OK;
  2523.     IHXRegistry* pRegistry = NULL;
  2524.     retVal = m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);
  2525.     if (SUCCEEDED(retVal))
  2526.     {
  2527. IHXCommonClassFactory* pCCF;
  2528. retVal = m_pCloakContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCCF);
  2530. if (SUCCEEDED(retVal))
  2531. {
  2532.     IHXValues* pResponseHeaders = NULL;
  2533.     
  2534.     HX_ASSERT(pRequest);
  2535.     if (HXR_OK == pRequest->GetResponseHeaders(pResponseHeaders))
  2536.     {
  2537. IHXBuffer* pServerHeaderBuffer = NULL;
  2539. HX_ASSERT(pHost);
  2540. if (pHost)
  2541. {
  2542.     retVal = pCCF->CreateInstance(CLSID_IHXBuffer,
  2543.      (void**)&pServerHeaderBuffer);
  2544.     if (SUCCEEDED(retVal))
  2545.     {
  2546. UINT32 ulHTTPStatus = atoi(pMessage->errorCode());
  2547. if (ulHTTPStatus == 407 && pProxyHost)
  2548. {
  2549.     pServerHeaderBuffer->Set((UCHAR*)pProxyHost, strlen(pProxyHost)+1);
  2550. }
  2551. else
  2552. {
  2553.     pServerHeaderBuffer->Set((UCHAR*)pHost, strlen(pHost)+1);
  2554. }
  2555. pResponseHeaders->SetPropertyCString("_server", pServerHeaderBuffer);
  2556. HX_RELEASE(pServerHeaderBuffer);
  2557.     }
  2558. }
  2560.     // Add the protocol to the response headers because TLC needs it
  2561.     IHXBuffer* pProtocol = NULL;
  2562.     if (SUCCEEDED(pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pProtocol)))
  2563.     {
  2564. pProtocol->Set((UCHAR*)"http", strlen("http") + 1);
  2565. pResponseHeaders->SetPropertyCString("_protocol", pProtocol);
  2566. HX_RELEASE(pProtocol);
  2567.     }
  2568.     }
  2570.     if (!spClientAuthConversationAuthenticator.IsValid())
  2571.     {
  2572. DECLARE_SMART_POINTER_UNKNOWN spUnknownAuthenticator;
  2573. DECLARE_SMART_POINTER
  2574. (
  2575. IHXObjectConfiguration
  2576. ) spObjectConfigurationAuthenticator;
  2577. DECLARE_SMART_POINTER
  2578. (
  2579. IHXCommonClassFactory
  2580. ) spCommonClassFactoryHXCore;
  2582. spCommonClassFactoryHXCore = m_pCloakContext;
  2584. // Starting conversation
  2585. ResultStatus = spCommonClassFactoryHXCore->CreateInstance
  2586. (
  2587. CLSID_CHXClientAuthenticator,
  2588. (void**)&spUnknownAuthenticator
  2589. );
  2591. if ( SUCCEEDED(ResultStatus) && spUnknownAuthenticator.IsValid() )
  2592. {
  2593.     spObjectConfigurationAuthenticator = 
  2594. (
  2595. spUnknownAuthenticator
  2596. );
  2598.     spObjectConfigurationAuthenticator->SetContext(m_pCloakContext);
  2600.     spClientAuthConversationAuthenticator = 
  2601. (
  2602. spUnknownAuthenticator
  2603. );
  2604. }
  2605.     }
  2607.     if ( spClientAuthConversationAuthenticator.IsValid()
  2608. && !spClientAuthConversationAuthenticator->IsDone() )
  2609.     {
  2610. HX_ASSERT(pRequest);
  2611. if (pRequest)
  2612. {
  2613.     ResultStatus = 
  2614. (
  2615. spClientAuthConversationAuthenticator->MakeResponse
  2616. (
  2617. this,
  2618. pRequest
  2619. )
  2620. );
  2622. // Flow continues in ResponseReady()
  2623. }
  2624. else
  2625. {
  2626.     // Auth Failed!
  2627.     spClientAuthConversationAuthenticator->Authenticated(FALSE);
  2628.     ResponseReady(HXR_NOT_AUTHORIZED, pRequest);
  2629. }
  2630.     }
  2632.     HX_RELEASE(pCCF);
  2633. }
  2635. HX_RELEASE(pRegistry);
  2636.     }
  2637.     
  2639.     return ResultStatus;
  2640. }
  2642. // IHXClientAuthResponse
  2643. STDMETHODIMP 
  2644. HXClientCloakedTCPSocket::ResponseReady( HX_RESULT ResultStatus, IHXRequest* pRequestResponse)
  2645. {
  2646.     // now if it's an OK result, then I can use pRequestResponse in a new get.
  2648.     if (FAILED(ResultStatus))
  2649.     {
  2650. return ResultStatus;
  2651.     }
  2653.     IHXValues* pHeaders = NULL;
  2655.     HX_ASSERT(pRequestResponse);
  2656.     if (HXR_OK == pRequestResponse->GetRequestHeaders(pHeaders))
  2657.     {
  2658. const char* pName;
  2659. IHXBuffer* pBuf;
  2660. HX_RESULT res = pHeaders->GetFirstPropertyCString(pName, pBuf);
  2661. while (res == HXR_OK)
  2662. {
  2664.     if (!strcasecmp(pName, "Proxy-Authorization"))
  2665.     {
  2666. HX_RESULT retVal = HXR_OK;
  2667. IHXRegistry* pRegistry = NULL;
  2668. retVal = m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);
  2670. IHXCommonClassFactory* pCCF = NULL;
  2672. if (m_pContext)
  2673. {
  2674.     m_pContext->AddRef();
  2676.     // get the CCF
  2677.     m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCCF);
  2678. }
  2680. if (SUCCEEDED(retVal))
  2681. {
  2682.     IHXBuffer* pBuffer = NULL;
  2683.     retVal = pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer);
  2684.     UINT32 regid = 0;
  2685.     
  2686.     HX_ASSERT(SUCCEEDED(retVal));
  2687.     if (SUCCEEDED(retVal))
  2688.     {
  2689. IHXBuffer* pHeaderBuffer = NULL;
  2691. CHXString key;
  2692. CHXString recentRealmInfo = "";
  2694. if (!strcasecmp(pName, "Proxy-Authorization"))
  2695. {
  2696.     key = "proxy-authentication.http:";
  2697.     retVal = pRegistry->GetStrByName(CLOAKED_PROXY_AUTHENTICATION_RECENT_KEY,
  2698. pHeaderBuffer);
  2700.     if (SUCCEEDED(retVal))
  2701.     {
  2702. HX_ASSERT(pHeaderBuffer);
  2703. recentRealmInfo = CHXString((const char*)pHeaderBuffer->GetBuffer(), pHeaderBuffer->GetSize());
  2704. HX_RELEASE(pHeaderBuffer);
  2705.     }
  2707. key += m_pProxyHostName;
  2708. }
  2710. key += ":";
  2711. key += recentRealmInfo;
  2713. HX_ASSERT(!key.IsEmpty());
  2714. pBuffer->Set(pBuf->GetBuffer(), pBuf->GetSize());
  2716. regid = pRegistry->GetId((const char*)key);
  2717. if (!regid)
  2718. {
  2719.     pRegistry->AddStr((const char*)key, pBuffer);
  2720. }
  2721. else
  2722. {
  2723.     pRegistry->SetStrByName((const char*)key, pBuffer);
  2724. }
  2726. HX_RELEASE(pBuffer);
  2727. HX_RELEASE(pHeaderBuffer);
  2728.     }
  2729. }
  2730. HX_RELEASE(pCCF);
  2731.     }
  2732.     HX_RELEASE(pBuf);
  2734.     res = pHeaders->GetNextPropertyCString(pName, pBuf);
  2735. }
  2736.     }
  2738.     CleanUpAndReInitializeStuff();
  2740.     return HXR_OK;
  2741. }
  2743. STDMETHODIMP
  2744. HXClientCloakedTCPSocket::HandleCallback(INT32 theCommand, HX_RESULT theError)
  2745. {
  2746.     if (!m_bInDestructor)
  2747.     {
  2748. m_pMutex->Lock();
  2750. DoGetWrite();
  2751. DoPutWrite();
  2752. DoRead();
  2754. m_pMutex->Unlock();
  2755.     }
  2757.     return HXR_OK;
  2758. }
  2760. HXClientCloakedTCPSocket::HTTPCloakTCPResponse::HTTPCloakTCPResponse(HXClientCloakedTCPSocket* pOwner, BOOL bIsRead) :
  2761.      m_pOwner(pOwner)
  2762.     ,m_lRefCount(0) 
  2763.     ,m_bIsRead(bIsRead)
  2764. {
  2765. }
  2767. HXClientCloakedTCPSocket::HTTPCloakTCPResponse::~HTTPCloakTCPResponse()
  2768. {
  2769. }
  2771. /*
  2772.  *  IUnknown methods
  2773.  */
  2775. /////////////////////////////////////////////////////////////////////////
  2776. //  Method:
  2777. // IUnknown::QueryInterface
  2778. //  Purpose:
  2779. // Implement this to export the interfaces supported by your 
  2780. // object.
  2781. //
  2782. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::QueryInterface(REFIID riid, void** ppvObj)
  2783. {
  2784.     QInterfaceList qiList[] =
  2785.         {
  2786.             { GET_IIDHANDLE(IID_IHXTCPResponse), (IHXTCPResponse*)this },
  2787.             { GET_IIDHANDLE(IID_IHXInterruptSafe), (IHXInterruptSafe*)this },
  2788.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXTCPResponse*)this },
  2789.         };
  2790.     
  2791.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  2792. }
  2794. /////////////////////////////////////////////////////////////////////////
  2795. //  Method:
  2796. // IUnknown::AddRef
  2797. //  Purpose:
  2798. // Everyone usually implements this the same... feel free to use
  2799. // this implementation.
  2800. //
  2801. STDMETHODIMP_(ULONG32) HXClientCloakedTCPSocket::HTTPCloakTCPResponse::AddRef()
  2802. {
  2803.     return InterlockedIncrement(&m_lRefCount);
  2804. }
  2806. /////////////////////////////////////////////////////////////////////////
  2807. //  Method:
  2808. // IUnknown::Release
  2809. //  Purpose:
  2810. // Everyone usually implements this the same... feel free to use
  2811. // this implementation.
  2812. //
  2813. STDMETHODIMP_(ULONG32) HXClientCloakedTCPSocket::HTTPCloakTCPResponse::Release()
  2814. {
  2815.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2816.     {
  2817.         return m_lRefCount;
  2818.     }
  2820.     delete this;
  2821.     return 0;
  2822. }
  2825. /*
  2826.  * IHXTCPResponse methods
  2827.  */
  2829. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::ConnectDone(HX_RESULT status)
  2830. {
  2832.     // xxxbobclark this authentication kludge is to ensure that layers "above" me
  2833.     // never have to care whether they're using an authenticated proxy or not.
  2834.     // So since this cloaked socket has already called its owner with ConnectDone
  2835.     // messages, it won't resend those... rather, it will reconstruct the same state
  2836.     // that the above layer expects.
  2837.     // So we set it up so the next ReadDone will work through the proxy and pass
  2838.     // through to the above layer and everything should be cool.
  2840.     if (m_pOwner->m_bInAuthenticationKludge)
  2841.     {
  2842. m_pOwner->m_bInAuthenticationKludge = FALSE;
  2844. if (m_bIsRead)
  2845. {
  2846.     m_pOwner->PreparePostMessage(NULL, 0);
  2847.     m_pOwner->DoPutWrite();
  2849.     m_pOwner->PrepareGetMessage();
  2850.     m_pOwner->DoGetWrite();
  2851. }
  2853. m_pOwner->Read(4096);
  2856. m_pOwner->m_bConnected = TRUE;
  2857. return HXR_OK;
  2858.     }
  2860.     if (m_bIsRead)
  2861.     {
  2862. m_pOwner->GetConnectDone(status == HXR_OK ? TRUE : FALSE);/*m_pGetCtrl*/
  2863.     }
  2864.     else
  2865.     {
  2866. m_pOwner->PutConnectDone(status == HXR_OK ? TRUE : FALSE);/*m_pPutCtrl*/
  2867.     }
  2869.     return HXR_OK;
  2870. }
  2873. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::ReadDone( HX_RESULT   status,
  2874. IHXBuffer* pBuffer)
  2875. {
  2876.     if (m_bIsRead)
  2877.     {
  2878. m_pOwner->DoGetReadDone(status, pBuffer); /*m_pGetCtrl*/
  2879.     }
  2880.     else 
  2881.     {
  2882. m_pOwner->DoPutReadDone(status, pBuffer); /*m_pPutCtrl*/
  2883.     }
  2885.     return HXR_OK;
  2886. }
  2888. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::WriteReady(HX_RESULT status)
  2889. {
  2890.     if (m_bIsRead)
  2891.     {
  2892. m_pOwner->m_pMutex->Lock();
  2893. m_pOwner->DoGetWrite(); /*m_pGetCtrl*/
  2894. m_pOwner->m_pMutex->Unlock();
  2895.     }
  2896.     else
  2897.     {
  2898. m_pOwner->m_bPutWantWritePending = FALSE;
  2899. m_pOwner->m_pMutex->Lock();
  2900. m_pOwner->DoPutWrite(); /*m_pPutCtrl*/
  2901. m_pOwner->m_pMutex->Unlock();
  2902.     }
  2904.     return HXR_OK;
  2905. }
  2907. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::Closed(HX_RESULT status)
  2908. {
  2909.     return HXR_OK;
  2910. }
  2912. #ifdef _MACINTOSH
  2914. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::MacCloakedTCPSocketAuthenticationCallback (
  2915. HXClientCloakedTCPSocket* pSocket)
  2916.     : m_lRefCount(0)
  2917.     , m_ulPendingCallbackID(NULL)
  2918.     , m_pSocket(pSocket)
  2919.     , m_Status(HXR_OK)
  2920.     , m_pInBuffer(NULL)
  2921. {
  2922. }
  2924. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::~MacCloakedTCPSocketAuthenticationCallback()
  2925. {
  2926. }
  2928. STDMETHODIMP
  2929. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::QueryInterface(
  2930. REFIID riid, void** ppvObj)
  2931. {
  2932.     QInterfaceList qiList[] =
  2933.         {
  2934.             { GET_IIDHANDLE(IID_IHXCallback), (IHXCallback*)this },
  2935.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXCallback*)this },
  2936.         };
  2937.     
  2938.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  2939. }
  2941. STDMETHODIMP_(ULONG32)
  2942. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::AddRef()
  2943. {
  2944.     return InterlockedIncrement( &m_lRefCount );
  2945. }
  2947. STDMETHODIMP_(ULONG32)
  2948. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::Release()
  2949. {
  2950.     if ( InterlockedDecrement( &m_lRefCount ) > 0 )
  2951.     {
  2952. return m_lRefCount;
  2953.     }
  2954.     
  2955.     delete this;
  2956.     return 0;
  2957. }
  2959. STDMETHODIMP
  2960. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::Func()
  2961. {
  2962.     m_ulPendingCallbackID = NULL;
  2963.     
  2964.     if (m_pInBuffer)
  2965.     {
  2966. m_pSocket->DoGetReadDone(m_Status, m_pInBuffer);
  2967. HX_RELEASE(m_pInBuffer);
  2968.     }
  2969.     
  2970.     return HXR_OK;
  2971. }
  2973. #endif