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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxcloakedtcp.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：73k
源码类别：

Symbian

开发平台：

Visual C++

hxcloakedtcp.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxcloakedtcp.cpp,v 1.7.8.2 2004/07/13 18:06:24 bobclark Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #include "hlxclib/stdio.h"   
  50. #include "hxcloakedtcp.h"
  52. #include "safestring.h"
  54. #include "hxnetutil.h"
  56. #include "ihxpckts.h"
  57. #include "hxccf.h" // IHXCommonClassFactory
  59. #include "hxthread.h" // HXMutex
  60. #include "hxbuffer.h" // CHXBuffer
  61. #include "conn.h"     // TCP_BUF_SIZE
  62. #include "dbcs.h"     // HXFindString
  63. #include "hxmarsh.h"  // getshort()
  64. #include "chxuuid.h"  // CHXuuid
  65. #include "hxtick.h"   // HX_GET_TICKCOUNT
  66. #include "rtsputil.h" // BinTo64
  67. #include "hxfiles.h"  // CLSID_IHXRequest
  68. #include "hxplnsp.h"  // _CIHXObjectConfiguration_SP
  69. #include "hxcomsp.h"  // _CIHXCommonClassFactory_SP
  71. // necessary for authentication
  72. #include "hxmon.h"
  73. #include "httppars.h"
  74. #include "hxplgns.h"
  75. #include "hxcore.h"
  77. #include "httpclk.h"
  79. #ifdef _MACINTOSH
  80. #include "hx_moreprocesses.h"
  81. #endif
  83. /******************* HTTP Cloaking*****************/
  85. #define QUEUE_START_SIZE    512
  87. #define HTTPCLOAK_PUTRESPONSE_TIMEOUT 2000
  89. #define MAX_HTTP_METHOD_BUFSIZE           2048
  91. #define HXGUID_SIZE  16 // 16 byte GUID plus rn
  93. #define ENQUEUE_DATA(x,y,z) (x)->EnQueue((y),(z))
  95. #define ENQUEUE_BYTE(x,y) {UCHAR uChar = (y); 
  96. (x)->EnQueue(&uChar,sizeof(uChar));}
  98. #define ENQUEUE_WORD(x,y) {UINT16 wTemp = (y); 
  99. wTemp = WToNet(wTemp); 
  100. (x)->EnQueue(&wTemp,sizeof(UINT16));}
  102. #define ENQUEUE_DWORD(x,y) {ULONG32 dTemp = (y); 
  103. dTemp = DwToNet(dTemp); 
  104. (x)->EnQueue(&dTemp,sizeof(ULONG32));}
  106. #define DEFAULT_HTTP_HEADER_LENGTH 256
  107. #define DEFAULT_OPTION_PADDING_LENGTH 16381
  109. #ifdef _WINCE
  110. #define SCHED_GRANULARITY 10
  111. #else
  112. #define SCHED_GRANULARITY 50
  113. #endif
  115. enum
  116. {
  117.     HTTP_OK = 0,
  118.     HTTP_GENERAL_ERROR, // for any error that is not defined below
  119.     POST_NOT_RECEIVED,  // POST message was not received
  120.     INVALID_GUID  // sent only if the GUID from the Player is already in use
  121. };
  124. /* HXClientCloakedTCPSocket */
  125. HXClientCloakedTCPSocket::HXClientCloakedTCPSocket(IUnknown* pContext):
  126.      m_lRefCount(0)
  127.     ,m_pContext(pContext)
  128.     ,m_pTCPResponse(0)
  129.     ,m_pNetworkServices(0)
  130.     ,m_pGetCtrl(0)
  131.     ,m_pPutCtrl(0)
  132.     ,m_pGetCtrlResponse(0)
  133.     ,m_pPutCtrlResponse(0)
  134.     ,m_bGetReadPending(FALSE)
  135.     ,m_bPutReadPending(FALSE)
  136.     ,m_bPutWantWritePending(FALSE)
  137.     ,m_lForeignAddress(0)
  138.     ,m_nForeignPort(0)
  139.     ,m_bReadPending(FALSE)
  140.     ,m_nRequired(0)
  141.     ,m_pSendTCP(0)
  142.     ,m_pReceiveGetTCP(0)
  143.     ,m_pReceivePutTCP(0)
  144.     ,m_pPreEncodedSendHTTP(0)
  145.     ,m_pPostEncodedSendHTTP(0)
  146.     ,m_pOutBuf(0)
  147.     ,m_pOutEncodedBuf(0)
  148.     ,m_pInBuf(0)
  149.     ,m_bConnected(FALSE)
  150.     ,m_pForiegnHost(0)
  151.     ,m_pGuid(0)
  152.     ,m_bGetConnectDone(FALSE)
  153.     ,m_bPutConnectDone(FALSE)
  154.     ,m_bGetConnectSuccessful(FALSE)
  155.     ,m_bPutConnectSuccessful(FALSE)
  156.     ,m_bConnectResponsePending(TRUE)
  157.     ,m_bOptionsReceived(FALSE)
  158.     ,m_bUseExactContentLength(FALSE)
  159.     ,m_bCloseHttpAfterWrite(FALSE)
  160.     ,m_bMustCloseHTTP(FALSE)
  161.     ,m_bHttpInitialized(FALSE)
  162.     ,m_LastError(HXR_OK)
  163.     ,m_pHTTPHeaderBuffer(0)
  164.     ,m_nHTTPHeaderBufferLength(0)
  165.     ,m_bHTTPGetHeaderReadDone(FALSE)
  166.     ,m_bHTTPPutHeaderReadDone(FALSE)
  167.     ,m_pProxyHostName(0)
  168.     ,m_nProxyPortNumber(0)
  169.     ,m_bInDestructor(FALSE)
  170.     ,m_pScheduler(0)
  171.     ,m_pSchedulerCallback(0)
  172.     ,m_pNonInterruptCallback(0)
  173.     ,m_bInDoRead(FALSE)
  174.     ,m_bInDoGetWrite(FALSE)
  175.     ,m_bInDoPutWrite(FALSE)
  176.     ,m_bInTransferBuffers(FALSE)
  177.     ,m_bInitComplete(FALSE)
  178.     ,m_bDeletePadding(FALSE)
  179.     ,m_uPadLength(10+DEFAULT_OPTION_PADDING_LENGTH) // 10 for the opts and 16381 for the padding
  180.     ,m_pInterruptState(NULL)
  181.     ,m_pResponseInterruptSafe(NULL)
  182.     ,m_pMutex(NULL)
  183.     ,m_pCloakValues(NULL)
  184.     ,m_pCloakContext(NULL)
  185.     ,m_bGetResponsed(FALSE)
  186.     ,m_bPutResponsed(FALSE)
  187.     ,m_pszGetServerIP(NULL)
  188.     ,m_pszPutServerIP(NULL)
  189.     ,m_bReconnectToSameServerIP(FALSE)
  190.     ,m_bConnectToSameServerIP(FALSE)
  191.     ,m_pPreferredTransport(NULL)
  192.     ,m_pPreferredTransportManager(NULL)
  193. #ifdef _MACINTOSH
  194.     ,m_pAuthenticationCallback(NULL)
  195. #endif
  196.     ,m_bInAuthenticationKludge(FALSE)
  197. {
  198.     if(m_pContext)
  199.     {
  200. m_pContext->AddRef();
  201. m_pContext->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  202. m_pContext->QueryInterface(IID_IHXNetworkServices, (void**) &m_pNetworkServices);
  203. m_pContext->QueryInterface(IID_IHXInterruptState, (void**) &m_pInterruptState);
  204. m_pContext->QueryInterface(IID_IHXPreferredTransportManager, (void**)&m_pPreferredTransportManager);
  205.     }
  207. #if defined(THREADS_SUPPORTED) 
  208.     HXMutex::MakeMutex(m_pMutex);
  209. #elif defined(_UNIX_THREADED_NETWORK_IO)
  210.     if( ReadNetworkThreadingPref((IUnknown*)pContext) )
  211.     {
  212.         HXMutex::MakeMutex(m_pMutex);
  213.     }
  214.     else
  215.     { 
  216.         HXMutex::MakeStubMutex(m_pMutex);
  217.     }
  218. #else
  219.     HXMutex::MakeStubMutex(m_pMutex);
  220. #endif
  222. #ifdef _MACINTOSH
  223.     m_pAuthenticationCallback = new MacCloakedTCPSocketAuthenticationCallback(this);
  224.     m_pAuthenticationCallback->AddRef();
  225. #endif
  226. }
  228. HXClientCloakedTCPSocket::~HXClientCloakedTCPSocket()
  229. {
  230.     m_bInDestructor = TRUE;
  231.     
  232.     m_pMutex->Lock();
  234. #ifdef _MACINTOSH
  235.     if (m_pAuthenticationCallback && m_pAuthenticationCallback->m_ulPendingCallbackID &&
  236. m_pScheduler)
  237.     {
  238. m_pScheduler->Remove(m_pAuthenticationCallback->m_ulPendingCallbackID);
  239. m_pAuthenticationCallback->m_ulPendingCallbackID = NULL;
  240.     }
  241.     HX_RELEASE(m_pAuthenticationCallback);
  242. #endif
  244.     while (m_PendingWriteBuffers.GetCount() > 0)
  245.     {
  246. IHXBuffer* pBuffer = (IHXBuffer*) m_PendingWriteBuffers.RemoveHead();
  247. pBuffer->Release();
  248.     }
  250.     FlushQueues();
  252.     /* Send a final HTTP done message */
  253.     if (m_bHttpInitialized)
  254.     {
  255. SendHTTPDone();
  256.     }
  258.     if (m_pSchedulerCallback)
  259.     {
  260. m_pSchedulerCallback->Unschedule(m_pScheduler);
  261. HX_RELEASE(m_pSchedulerCallback);
  262.     }
  264.     if (m_pNonInterruptCallback)
  265.     {
  266. m_pNonInterruptCallback->Unschedule(m_pScheduler);
  267. HX_RELEASE(m_pNonInterruptCallback);
  268.     }
  270.     HX_RELEASE(m_pGetCtrl);
  271.     HX_RELEASE(m_pPutCtrl);
  272.     HX_RELEASE(m_pGetCtrlResponse);
  273.     HX_RELEASE(m_pPutCtrlResponse);
  275.     HX_RELEASE(m_pCloakValues);
  276.     HX_RELEASE(m_pCloakContext);
  277.     HX_RELEASE(m_pTCPResponse);
  278.     HX_RELEASE(m_pNetworkServices);
  280.     HX_DELETE(m_pSendTCP);
  281.     HX_DELETE(m_pReceiveGetTCP);
  282.     HX_DELETE(m_pReceivePutTCP);
  283.     HX_DELETE(m_pPreEncodedSendHTTP);
  284.     HX_DELETE(m_pPostEncodedSendHTTP);
  286.     HX_VECTOR_DELETE(m_pInBuf);
  287.     HX_VECTOR_DELETE(m_pOutBuf);
  288.     HX_VECTOR_DELETE(m_pOutEncodedBuf);
  289.     HX_VECTOR_DELETE(m_pForiegnHost);
  290.     HX_VECTOR_DELETE(m_pGuid);
  291.     HX_VECTOR_DELETE(m_pHTTPHeaderBuffer);
  292.     HX_VECTOR_DELETE(m_pProxyHostName);
  293.     HX_VECTOR_DELETE(m_pszGetServerIP);
  294.     HX_VECTOR_DELETE(m_pszPutServerIP);
  296.     HX_RELEASE(m_pPreferredTransport);
  297.     HX_RELEASE(m_pPreferredTransportManager);
  298.     HX_RELEASE(m_pInterruptState);
  299.     HX_RELEASE(m_pResponseInterruptSafe);
  300.     HX_RELEASE(m_pScheduler);
  302.     HX_RELEASE(m_pContext);
  303.     m_pMutex->Unlock();
  304.     HX_DELETE(m_pMutex);
  305. }
  307. STDMETHODIMP HXClientCloakedTCPSocket::QueryInterface(REFIID riid, void** ppvObj)
  308. {
  309.     QInterfaceList qiList[] =
  310.         {
  311.             { GET_IIDHANDLE(IID_IHXTCPSocket), (IHXTCPSocket*)this },
  312.             { GET_IIDHANDLE(IID_IHXCloakedTCPSocket), (IHXCloakedTCPSocket*)this },
  313.             { GET_IIDHANDLE(IID_IHXHTTPProxy), (IHXHTTPProxy*)this },
  314.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXTCPSocket*)this },
  315.         };
  316.     
  317.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  318. }
  320. STDMETHODIMP_(ULONG32) HXClientCloakedTCPSocket::AddRef()
  321. {
  322.     return InterlockedIncrement(&m_lRefCount);
  323. }
  325. STDMETHODIMP_(ULONG32) HXClientCloakedTCPSocket::Release()
  326. {
  327.     if (InterlockedDecrement(&m_lRefCount) > 0)
  328.     {
  329.         return m_lRefCount;
  330.     }
  332.     delete this;
  333.     return 0;
  334. }
  336. STDMETHODIMP HXClientCloakedTCPSocket::Init(IHXTCPResponse* pTCPResponse)
  337. {
  338.     HX_RESULT rc = HXR_OK;
  340.     if (!pTCPResponse)
  341.     {
  342. return HXR_UNEXPECTED;
  343.     }
  345.     if (!m_pSchedulerCallback)
  346.     {
  347. m_pSchedulerCallback = new ScheduledSocketCallback(this, TRUE);
  348. m_pSchedulerCallback->AddRef();
  349.     }
  351.     if (!m_pNonInterruptCallback)
  352.     {
  353. m_pNonInterruptCallback = new ScheduledSocketCallback(this, TRUE);
  354. m_pNonInterruptCallback->AddRef();
  355.     }
  357.     m_pTCPResponse = pTCPResponse;
  358.     m_pTCPResponse->AddRef();
  360.     m_pTCPResponse->QueryInterface(IID_IHXInterruptSafe, 
  361.    (void**) &m_pResponseInterruptSafe);
  363.     if (!m_pNetworkServices)
  364.     {
  365. return HXR_FAILED;
  366.     }
  367.     
  368.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pGetCtrl))
  369.     {
  370. return HXR_FAILED;
  371.     }
  373.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pPutCtrl))
  374.     {
  375. return HXR_FAILED;
  376.     }
  378.     m_pGetCtrlResponse = new HTTPCloakTCPResponse(this, TRUE);
  379.     m_pPutCtrlResponse = new HTTPCloakTCPResponse(this, FALSE);
  380.     if (!m_pGetCtrlResponse || !m_pPutCtrlResponse)
  381.     {
  382. return HXR_OUTOFMEMORY;
  383.     }
  385.     m_pGetCtrlResponse->AddRef();
  386.     m_pPutCtrlResponse->AddRef();
  388.     if (HXR_OK != m_pGetCtrl->Init(m_pGetCtrlResponse) || 
  389. HXR_OK != m_pPutCtrl->Init(m_pPutCtrlResponse))
  390.     {
  391. return HXR_FAILED;
  392.     }
  394.     if (HXR_OK != m_pGetCtrl->Bind(HXR_INADDR_ANY, 0) || 
  395. HXR_OK != m_pPutCtrl->Bind(HXR_INADDR_ANY, 0))
  396.     {
  397.      return HXR_FAILED;
  398.     }
  400.     // allocate TCP send and receive queue
  401.     m_pSendTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  402.     if (!m_pSendTCP || !m_pSendTCP->IsQueueValid())
  403.     {
  404. return HXR_OUTOFMEMORY;
  405.     }
  406.     m_pSendTCP->SetMaxSize(TCP_BUF_SIZE);
  408.     m_pReceiveGetTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  409.     if (!m_pReceiveGetTCP || !m_pReceiveGetTCP->IsQueueValid())
  410.     {
  411. return HXR_OUTOFMEMORY;
  412.     }
  413.     m_pReceiveGetTCP->SetMaxSize(TCP_BUF_SIZE);
  415.     m_pPreEncodedSendHTTP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  416.     if (!m_pPreEncodedSendHTTP || !m_pPreEncodedSendHTTP->IsQueueValid())
  417.     {
  418. return HXR_OUTOFMEMORY;
  419.     }
  421.     /* Approx. MAX POST header size : 3000*/
  422.     m_pPreEncodedSendHTTP ->SetMaxSize((TCP_BUF_SIZE-1)/2 - 3000);
  424.     m_pPostEncodedSendHTTP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  425.     if (!m_pPostEncodedSendHTTP || !m_pPostEncodedSendHTTP->IsQueueValid())
  426.     {
  427. return HXR_OUTOFMEMORY;
  428.     }
  429.     m_pPostEncodedSendHTTP->SetMaxSize(TCP_BUF_SIZE);
  430.     
  431.     m_pInBuf = new char[TCP_BUF_SIZE];
  432.     if (!m_pInBuf)
  433.     {
  434. return HXR_OUTOFMEMORY;
  435.     }
  437.     m_pOutBuf = new char[TCP_BUF_SIZE];
  438.     if (!m_pOutBuf)
  439.     {
  440. return HXR_OUTOFMEMORY;
  441.     }
  443.     m_pOutEncodedBuf = new char[TCP_BUF_SIZE];
  444.     if (!m_pOutEncodedBuf)
  445.     {
  446. return HXR_OUTOFMEMORY;
  447.     }
  449.     CreateGuid();
  451.     return HXR_OK;
  452. }
  454. STDMETHODIMP HXClientCloakedTCPSocket::SetResponse(IHXTCPResponse* pTCPResponse)
  455. {
  456.     m_pMutex->Lock();
  457.     HX_RELEASE(m_pTCPResponse);
  458.     m_pTCPResponse = pTCPResponse;
  459.     m_pTCPResponse->AddRef();
  461.     HX_RELEASE(m_pResponseInterruptSafe);
  462.     m_pTCPResponse->QueryInterface(IID_IHXInterruptSafe, 
  463.    (void**) &m_pResponseInterruptSafe);
  464.     m_pMutex->Unlock();
  465.     return HXR_OK;
  466. }
  468. STDMETHODIMP HXClientCloakedTCPSocket::Bind(UINT32 ulLocalAddr, UINT16 nPort)
  469. {
  470.     return HXR_NOTIMPL;
  471. }
  473. STDMETHODIMP HXClientCloakedTCPSocket::Connect(const char* pDestination,
  474. UINT16     nPort)
  475. {
  476.     m_nForeignPort = nPort;
  478.     HX_VECTOR_DELETE(m_pForiegnHost);
  479.     m_pForiegnHost = new char [strlen(pDestination) + 1];
  480.     if (!m_pForiegnHost)
  481.     {
  482. return HXR_OUTOFMEMORY;
  483.     }
  485.     ::strcpy(m_pForiegnHost, pDestination); /* Flawfinder: ignore */
  487.     // m_pCloakValues is only set by RTSP
  488.     if (m_pPreferredTransportManager && m_pCloakValues)
  489.     {
  490. HX_RELEASE(m_pPreferredTransport);
  491. m_pPreferredTransportManager->GetPrefTransport(m_pForiegnHost,
  492.        PTP_RTSP,
  493.        m_pPreferredTransport);
  495. HX_ASSERT(m_pPreferredTransport);
  496. if (m_pPreferredTransport)
  497. {
  498.     m_bConnectToSameServerIP = m_pPreferredTransport->GetHTTPNG();
  499. }
  500.     }
  502.     return  ActualConnect();
  503. }
  505. STDMETHODIMP HXClientCloakedTCPSocket::Read(UINT16 uSize)
  506. {
  507.     HX_RESULT theErr = HXR_OK;
  508.     HX_RESULT lResult = HXR_OK;
  510.     if (m_bReadPending)
  511.     {
  512. return HXR_UNEXPECTED;
  513.     }
  515.     m_bReadPending  = TRUE;
  516.     m_nRequired     = uSize;
  518.     m_pMutex->Lock();
  519.     theErr  = DoRead();
  520.     m_pMutex->Unlock();
  521.     lResult = ConvertNetworkError(theErr);
  523.     return lResult;
  524. }
  526. STDMETHODIMP HXClientCloakedTCPSocket::Write(IHXBuffer* pBuffer)
  527. {
  528.     HX_RESULT theErr = HXR_OK;
  529.     HX_RESULT lResult = HXR_OK;
  531.     pBuffer->AddRef();
  532.     m_PendingWriteBuffers.AddTail((void*) pBuffer);
  533.     
  534.     m_pMutex->Lock();
  535.     theErr = DoPutWrite();
  536.     m_pMutex->Unlock();
  537.     lResult = ConvertNetworkError(theErr);
  539.     return lResult;
  540. }
  542. STDMETHODIMP HXClientCloakedTCPSocket::WantWrite()
  543. {
  544.     m_pTCPResponse->WriteReady(HXR_OK);
  546.     return HXR_OK;
  547. }
  549. STDMETHODIMP HXClientCloakedTCPSocket::GetLocalAddress(ULONG32& lAddress)
  550. {
  551.     return HXR_NOTIMPL;
  552. }
  554. STDMETHODIMP HXClientCloakedTCPSocket::GetForeignAddress(ULONG32& lAddress)
  555. {
  556.     if(m_bConnected && m_lForeignAddress)
  557.     {
  558. lAddress = m_lForeignAddress;
  559. return HXR_OK;
  560.     }
  561.     return HXR_FAIL;
  562. }
  564. STDMETHODIMP HXClientCloakedTCPSocket::GetLocalPort(UINT16& port)
  565. {
  566.     return HXR_NOTIMPL;
  567. }
  569. STDMETHODIMP HXClientCloakedTCPSocket::GetForeignPort(UINT16& port)
  570. {
  571.     if(m_bConnected)
  572.     {
  573. port = m_nForeignPort;
  574. return HXR_OK;
  575.     }
  576.     return HXR_FAIL;
  577. }
  579. /*
  580.  * IHXHTTPProxy methods
  581.  *
  582.  *  Network addresses and ports are in native byte order
  583.  *  
  584.  */
  586. STDMETHODIMP HXClientCloakedTCPSocket::SetProxy(
  587.     const char*     /*IN*/  pProxyHostName,
  588.     UINT16     /*IN*/  nPort)
  589. {
  590.     if(pProxyHostName == 0 || *pProxyHostName == 0) 
  591.     {
  592. return HXR_FAILED;
  593.     }
  594.     
  595.     HX_VECTOR_DELETE(m_pProxyHostName);
  596.     m_pProxyHostName = new char[::strlen(pProxyHostName) + 1];
  597.     if (!m_pProxyHostName)
  598.     {
  599. return HXR_OUTOFMEMORY;
  600.     }
  602.     ::strcpy(m_pProxyHostName, pProxyHostName); /* Flawfinder: ignore */
  603.     m_nProxyPortNumber = nPort;
  605.     return HXR_OK;
  606. }
  608. /************************************************************************
  609.  * Method:
  610.  *     IHXCloakedTCPSocket::InitCloak
  611.  */
  612. STDMETHODIMP
  613. HXClientCloakedTCPSocket::InitCloak(IHXValues* /*IN*/  pValues, IUnknown* pUnknown)
  614. {
  615.     HX_RESULT rc = HXR_OK;
  617.     if (pValues)
  618.     {
  619. m_pCloakValues = pValues;
  620. m_pCloakValues->AddRef();
  621.     }
  622.     if (pUnknown)
  623.     {
  624. m_pCloakContext = pUnknown;
  625. m_pCloakContext->AddRef();
  626.     }
  628.     return rc;
  629. }
  631. HX_RESULT
  632. HXClientCloakedTCPSocket::DoRead()
  633. {
  634.     HX_RESULT theErr = HXR_OK;
  635.     char*   pStartAfterDoubleReturn = 0;
  636.     UINT16 count = 0;
  638.     if(m_bInDoRead)
  639.     {
  640. return HXR_OK;
  641.     }
  643.     m_bInDoRead = TRUE;
  645.     if (m_LastError)
  646.     {
  647. goto exit;
  648.     }
  650.     // m_pReceivePutTCP is only initialized if we receive POST response
  651.     // from the server
  652.     if (m_pReceivePutTCP)
  653.     {
  654. count = m_pReceivePutTCP->GetMaxAvailableElements();
  655.     }
  656.     else
  657.     {
  658. count = TCP_BUF_SIZE;
  659.     }
  661.     // attempt to read from PUT if:
  662.     // * we haven't initiated PUT read already AND
  663.     // * we haven't received the complete POST response header AND
  664.     // * we are not in multi-POST mode
  665.     if (count > 0     && 
  666. !m_bPutReadPending     && 
  667. !m_bHTTPPutHeaderReadDone   &&
  668. !m_bMustCloseHTTP)
  669.     {
  670. // attempt to read data from TCP link
  671. m_bPutReadPending = TRUE;
  672. theErr = m_pPutCtrl->Read(count);
  673.     }
  675.     // check how much room we have in TCP receive queue
  676.     count = m_pReceiveGetTCP->GetMaxAvailableElements();
  677.     if (count > 0 && !m_bGetReadPending)
  678.     {
  679. // attempt to read data from TCP link
  680. m_bGetReadPending = TRUE;
  681. theErr = m_pGetCtrl->Read(count);
  682. switch(theErr)
  683. {
  684.     case HXR_AT_INTERRUPT:
  685.     case HXR_WOULD_BLOCK:
  686.     case HXR_OK:
  687. // mask out these errors
  688. theErr = HXR_OK;
  689. break;
  691.     default:
  692. theErr = ConvertNetworkError(theErr);
  693. break;
  694. }
  695.     }
  697. exit:
  698.     if (theErr && !m_LastError)
  699.     {
  700. m_LastError = theErr;
  701.     }
  703.     if (m_LastError)
  704.     {
  705. if (m_bReadPending)
  706. {
  707.     if (IsSafe())
  708.     {
  709. m_bReadPending = FALSE;
  710. m_pTCPResponse->ReadDone(m_LastError, 0);
  711.     }
  712. }
  713.     }
  714.     else
  715.     {
  716. count = m_pReceiveGetTCP->GetQueuedItemCount();
  718. if (m_bReadPending && count > 0 && m_bOptionsReceived 
  719.     && m_bHTTPGetHeaderReadDone)
  720. {
  721.     /* mask any kind of errors */
  722.     theErr = HXR_OK;
  724.     if (IsSafe())
  725.     {
  726. m_bReadPending = FALSE;
  727. if (m_nRequired < count)
  728. {
  729.     count = m_nRequired;
  730. }
  732. CHXBuffer* pBuffer = new CHXBuffer;
  733. pBuffer->AddRef();
  734. m_pReceiveGetTCP->DeQueue(m_pInBuf, count);
  735. pBuffer->Set((UCHAR*) m_pInBuf, count);
  737. m_pTCPResponse->ReadDone(HXR_OK, pBuffer);
  738. pBuffer->Release();
  739.     }
  740. }
  742. if (m_pSchedulerCallback && m_bReadPending)
  743. {
  744.     m_pSchedulerCallback->ScheduleCallback(CLOAKED_TCP_READ_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  745. }
  746.     }
  747.  
  748.     m_bInDoRead = FALSE;
  749.     return theErr;
  750. }
  752. HX_RESULT
  753. HXClientCloakedTCPSocket::DoGetWrite()
  754. {
  755.     HX_RESULT theErr = HXR_OK;
  757.     if (m_bInDoGetWrite)
  758.     {
  759. return HXR_OK;
  760.     }
  762.     m_bInDoGetWrite = TRUE;
  764.     // check how data we have in TCP send queue
  765.     UINT16 count    = m_pSendTCP->GetQueuedItemCount();
  766.     UINT16 actual   = count;
  767.     
  768.     if(count > 0) 
  769.     {
  770. m_pSendTCP->DeQueue(m_pOutBuf,count);
  771. CHXBuffer* pBuffer = new CHXBuffer;
  772. pBuffer->AddRef();
  773. pBuffer->Set((UCHAR*) m_pOutBuf, (ULONG32) count);
  774. theErr = m_pGetCtrl->Write(pBuffer);
  775. pBuffer->Release();
  776.     }
  777.     
  778.     if (theErr)
  779.     {
  780. switch(theErr)
  781. {
  782.     case HXR_AT_INTERRUPT:
  783.     case HXR_WOULD_BLOCK:
  784. m_pSendTCP->EnQueue(m_pOutBuf, count);
  785. // mask out these errors
  786. theErr = HXR_OK;
  787. break;
  789.     default:
  790. theErr = ConvertNetworkError(theErr);
  791. break;
  792. }
  793.     }
  795.     if (!theErr && !m_bInDestructor &&
  796. m_pSendTCP->GetQueuedItemCount() > 0 ) {
  797.     m_pSchedulerCallback->ScheduleCallback(CLOAKED_TCP_GETWRITE_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  798.     }
  800.     m_bInDoGetWrite = FALSE;
  801.     return theErr;
  802. }
  804. HX_RESULT
  805. HXClientCloakedTCPSocket::DoPutWrite()
  806. {
  807.     HX_RESULT theErr = HXR_OK;
  809.     if (m_bInDoPutWrite)
  810.     {
  811. return HXR_OK;
  812.     }
  814.     m_bInDoPutWrite = TRUE;
  816.     /* Transfer pending buffers to TCP send queue */
  817.     if (m_bOptionsReceived && m_pPostEncodedSendHTTP->GetQueuedItemCount() == 0 && !m_bPutWantWritePending)
  818.     {
  819. TransferBuffers();
  820.     }
  822.     if (!m_bPutConnectDone)
  823.     {
  824. goto exit;
  825.     }
  827.     // check how data we have in TCP send queue
  828.     UINT16 count;
  829.     UINT16 actual;
  830.     
  831.     count    = m_pPostEncodedSendHTTP->GetQueuedItemCount();
  832.     actual   = count;
  834.     if(count > 0) 
  835.     {
  836. m_pPostEncodedSendHTTP->DeQueue(m_pOutEncodedBuf,count);
  837. CHXBuffer* pBuffer = new CHXBuffer;
  838. pBuffer->AddRef();
  839. pBuffer->Set((UCHAR*) m_pOutEncodedBuf, (ULONG32) count);
  840. theErr = m_pPutCtrl->Write(pBuffer);
  841. pBuffer->Release();
  842. m_bPutWantWritePending = TRUE;
  843. m_pPutCtrl->WantWrite();
  844.     }
  845.     
  846.     if (theErr)
  847.     {
  848. switch(theErr)
  849. {
  850.     case HXR_AT_INTERRUPT:
  851.     case HXR_WOULD_BLOCK:
  852. m_pPostEncodedSendHTTP->EnQueue(m_pOutEncodedBuf, count);
  853. // mask out these errors
  854. theErr = HXR_OK;
  855. break;
  857.     default:
  858. theErr = ConvertNetworkError(theErr);
  859. break;
  860. }
  861.     }
  863. exit:
  865.     if (!theErr && !m_bInDestructor &&
  866. (m_pPostEncodedSendHTTP->GetQueuedItemCount() > 0 ||
  867.  m_PendingWriteBuffers.GetCount() > 0)){
  868.     m_pSchedulerCallback->ScheduleCallback(CLOAKED_TCP_PUTWRITE_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  869.     }
  871.     if (!theErr)
  872.     {
  873. theErr = DoGetWrite();
  874.     }
  876.     m_bInDoPutWrite = FALSE;
  878.     return theErr;
  879. }
  881. void 
  882. HXClientCloakedTCPSocket::GetConnectDone(BOOL bResult)
  883. {
  884.     m_bGetConnectDone = TRUE;
  886.     if (!m_bInDestructor)
  887.     {
  888. AddRef();
  889.     }
  891.     if (bResult == TRUE)
  892.     {
  893. m_bGetConnectSuccessful = TRUE;
  894. m_pGetCtrl->GetForeignAddress(m_lForeignAddress);
  895.     }
  896.     else
  897.     {
  898. m_bGetConnectSuccessful = FALSE;
  899.     }
  901.     // PUT connection has to been done at this point
  902.     if (m_bPutConnectDone && m_bConnectResponsePending)
  903.     {
  904. m_bConnectResponsePending = FALSE;
  906. // either its HTTP-NG server or we are in re-GET mode
  907. // where we send GET to the same serverIP returned from
  908. // POST response
  909. if (m_bConnectToSameServerIP || m_bReconnectToSameServerIP)
  910. {
  911.     if (m_bPutConnectSuccessful && m_bGetConnectSuccessful)
  912.     {
  913. m_bConnected = TRUE;
  914. m_pMutex->Lock();
  915. PrepareGetMessage();
  916. DoGetWrite();
  917. Read(TCP_BUF_SIZE);
  918. m_pMutex->Unlock();
  919. if (m_bConnectToSameServerIP)
  920. {
  921.     // we haven't call ConnectDone yet
  922.     m_pTCPResponse->ConnectDone(HXR_OK);
  923. }
  924. else if (m_bReconnectToSameServerIP)
  925. {
  926.     // we already called ConnectDone upon the initial
  927.     // GET/POST connect done
  928.     Read(TCP_BUF_SIZE);
  929. }
  930.     }
  931.     else
  932.     {
  933. m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  934.     }
  935. }
  936. // don't know the server type yet, keep the old behavior
  937. // where we send both GET and POST
  938. else
  939. {
  940.     if (m_bPutConnectSuccessful && m_bGetConnectSuccessful)
  941.     {
  942. m_bConnected = TRUE;
  943. m_pMutex->Lock();
  944. PreparePostMessage(NULL, 0);
  945. DoPutWrite();
  946. PrepareGetMessage();
  947. DoGetWrite();
  948. m_pMutex->Unlock();
  949. m_pTCPResponse->ConnectDone(HXR_OK);
  950.     }
  951.     else
  952.     {
  953. m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  954.     }
  956. }
  957.     }
  959.     if (!m_bInDestructor)
  960.     {
  961.         Release();
  962.     }
  963. }
  965. void 
  966. HXClientCloakedTCPSocket::PutConnectDone(BOOL bResult)
  967. {
  968.     HX_RESULT theErr = HXR_OK;
  969.     m_bPutConnectDone = TRUE;
  971.     if (!m_bInDestructor)
  972.     {
  973. AddRef();
  974.     }
  976.     if (bResult == TRUE)
  977.     {
  978. m_bPutConnectSuccessful = TRUE;
  979.     }
  980.     else
  981.     {
  982. m_bPutConnectSuccessful = FALSE;
  983.     }
  985.     // it's HTTP-NG server, we send POST first
  986.     if (m_bConnectToSameServerIP)
  987.     {
  988. if (m_bPutConnectSuccessful)
  989. {
  990.     m_pMutex->Lock();
  991.     PreparePostMessage(NULL, 0);
  992.     DoPutWrite();
  993.     if (!m_bPutReadPending)
  994.     {
  995. m_bPutReadPending = TRUE;
  996. m_pPutCtrl->Read(TCP_BUF_SIZE);
  997.     }
  998.     m_pMutex->Unlock();
  999. }
  1000. else
  1001. {
  1002.     m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  1003. }
  1004.     }
  1005.     // don't know the server type yet, so we send both POST
  1006.     // and GET
  1007.     else if (m_bGetConnectDone && m_bConnectResponsePending)
  1008.     {
  1009. m_bConnectResponsePending = FALSE;
  1010. if (m_bPutConnectSuccessful && m_bGetConnectSuccessful)
  1011. {
  1012.     m_bConnected = TRUE;
  1013.     m_pMutex->Lock();
  1014.     PreparePostMessage(NULL, 0);
  1015.     DoPutWrite();
  1016.     PrepareGetMessage();
  1017.     theErr = DoGetWrite();
  1018.     m_pMutex->Unlock();
  1019.     m_pTCPResponse->ConnectDone(HXR_OK);
  1020. }
  1021. else
  1022. {
  1023.     m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  1024. }
  1025.     }
  1027.     if (!m_bInDestructor)
  1028.     {
  1029. Release();
  1030.     }
  1032.     if (m_bConnected && m_pPostEncodedSendHTTP->GetQueuedItemCount() > 0)
  1033.     {
  1034. m_pMutex->Lock();
  1035. DoPutWrite();
  1036. m_pMutex->Unlock();
  1037.     }
  1038. }
  1040. HX_RESULT
  1041. HXClientCloakedTCPSocket::DoGetReadDone(HX_RESULT   status, IHXBuffer* pInBuffer)
  1042. {
  1043.     HX_RESULT theErr = HXR_OK;
  1044.     char* pStartAfterDoubleReturn = 0;
  1045.     UINT16 count = 0;
  1047.     if (AuthenticationRequired(status, pInBuffer))
  1048.     {
  1049. return HXR_OK;
  1050.     }
  1052.     m_pMutex->Lock();
  1054.     m_bGetReadPending = FALSE;
  1055.     if (status != HXR_OK && m_LastError == HXR_OK)
  1056.     {
  1057. m_LastError = status;
  1058.     }
  1060.     if (m_LastError)
  1061.     {
  1062. goto exit;
  1063.     }
  1065.     if (pInBuffer)
  1066.     {
  1067. m_pReceiveGetTCP->EnQueue(pInBuffer->GetBuffer(), (UINT16) pInBuffer->GetSize());
  1068.     }
  1070.     count = m_pReceiveGetTCP->GetQueuedItemCount();
  1072.     /*
  1073.      * if the 16k padding was not received in one big packet
  1074.      * delete the remaining padding
  1075.      */
  1076.     if (m_bDeletePadding && m_uPadLength > 0)
  1077.     {
  1078. UINT16 len = (m_uPadLength <= count ? m_uPadLength : count); 
  1079. BYTE* tmpBuf = new BYTE[len];
  1081. m_pReceiveGetTCP->DeQueue(tmpBuf, len);
  1082. m_uPadLength -= len;
  1084. if (m_uPadLength == 0)
  1085. {
  1086.     m_bDeletePadding = FALSE;
  1087. }
  1088. HX_VECTOR_DELETE(tmpBuf);
  1089. count = m_pReceiveGetTCP->GetQueuedItemCount();
  1090.     }
  1092.     if (!theErr && !m_bHTTPGetHeaderReadDone && count >= 2 )
  1093.     {
  1094. char* pEndLineLocation = 0;
  1096. if (!m_pHTTPHeaderBuffer || m_nHTTPHeaderBufferLength < count+1)
  1097. {
  1098.     HX_VECTOR_DELETE(m_pHTTPHeaderBuffer);
  1099.     m_nHTTPHeaderBufferLength = count+1 > DEFAULT_HTTP_HEADER_LENGTH ?
  1100. count+1 : DEFAULT_HTTP_HEADER_LENGTH;
  1101.     m_pHTTPHeaderBuffer = new char[m_nHTTPHeaderBufferLength];
  1102.     if (!m_pHTTPHeaderBuffer)
  1103.     {
  1104. theErr = HXR_OUTOFMEMORY;
  1105. goto exit;
  1106.     }
  1107. }
  1109. m_pReceiveGetTCP->DeQueue(m_pHTTPHeaderBuffer, count);
  1110. m_pHTTPHeaderBuffer[count] = '';
  1112. if ((pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "nn")) ||
  1113.     (pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "rr")) )
  1114. {
  1115.     pStartAfterDoubleReturn = pEndLineLocation+2;
  1116.     m_bHTTPGetHeaderReadDone = TRUE;
  1117. }
  1118. else if (count >= 4 &&
  1119.     (pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "rnrn")))
  1120. {
  1121.     pStartAfterDoubleReturn = pEndLineLocation+4;
  1122.     m_bHTTPGetHeaderReadDone = TRUE;
  1123. }
  1124. else
  1125. {
  1126.     /* Put back everything in receive queue*/
  1127.     m_pReceiveGetTCP->EnQueue(m_pHTTPHeaderBuffer, count);
  1128.     goto exit;
  1129. }
  1131. // determine whether we need to issue re-GET to the same serverIP
  1132. // from the POST response
  1133. if (!m_bGetResponsed && !m_bConnectToSameServerIP)
  1134. {
  1135.     m_bGetResponsed = TRUE;
  1136.     GetServerIPFromResponse(TRUE, m_pHTTPHeaderBuffer);
  1138.     if (m_pszGetServerIP && m_pszPutServerIP)
  1139.     {
  1140. m_bReconnectToSameServerIP = strcasecmp(m_pszGetServerIP, m_pszPutServerIP);
  1141.     }
  1143.     if (m_bReconnectToSameServerIP)
  1144.     {
  1145. theErr = ReconnectToSameServerIP();
  1146. goto quit;
  1147.     }
  1148. }
  1150. /* If we have read the complete header, see if the content is OK..*/
  1151. char* pFound = (char*) HXFindString(m_pHTTPHeaderBuffer, "HTTP/1.0 200 OK");
  1152. if (!pFound)
  1153. {
  1154.     pFound = (char*) HXFindString(m_pHTTPHeaderBuffer, "200 OK");
  1155. }
  1157. // XXX HP we are phasing out PNM protocol
  1158. // m_pCloakValues is only set in RTSP so we use this to exclude
  1159. // support for redirect in PNM Cloaking
  1160. if (!pFound)
  1161. {
  1162.     if (m_pCloakValues)
  1163.     {
  1164. pFound = (char*) HXFindString(m_pHTTPHeaderBuffer, "HTTP/1.0 302");
  1165. if (pFound)
  1166. {
  1167.     strncpy(pFound, "RTSP", 4); /* Flawfinder: ignore */
  1169.     IHXBuffer* pBuffer = new CHXBuffer;
  1170.     pBuffer->AddRef();
  1171.     pBuffer->Set((UCHAR*) m_pHTTPHeaderBuffer, count);
  1172.     
  1173.     m_pTCPResponse->ReadDone(HXR_OK, pBuffer);
  1174.     pBuffer->Release();
  1175.     goto exit;
  1176. }
  1177.     }
  1179.     theErr = HXR_DOC_MISSING;
  1180. }
  1182. if (!theErr)
  1183. {
  1184.     m_pReceiveGetTCP->EnQueue(pStartAfterDoubleReturn, 
  1185.     (m_pHTTPHeaderBuffer + count) - pStartAfterDoubleReturn);
  1186.     
  1187.     count = m_pReceiveGetTCP->GetQueuedItemCount();
  1188. }
  1189.     }
  1191.     /* hmmm... time to read options */ 
  1192.     if (!theErr && count > 0 && !m_bOptionsReceived && m_bHTTPGetHeaderReadDone)
  1193.     {
  1194. /* There needs to be atleast 4 bytes to have the response
  1195.  * reponse_opcode(HTTP_RV_RESPONSE), response len, 
  1196.  * actual response(minimum one byte)
  1197.  */
  1198. if (count < 3)
  1199. {
  1200.     goto exit;
  1201. }
  1203. m_pReceiveGetTCP->DeQueue(m_pInBuf, count);
  1205. if (m_pInBuf[0] == HTTP_RESPONSE)
  1206. {
  1207.     m_bOptionsReceived = TRUE;
  1208.     
  1209.     UINT16 nOptionLen = m_pInBuf[1];
  1210.     /* Place any data after the response back in Receive queue.
  1211.      * This data needs to be sent to the user*/
  1212.     if (count > 2+nOptionLen)
  1213.     {
  1214. m_pReceiveGetTCP->EnQueue(m_pInBuf+2+nOptionLen, (count - (2+nOptionLen)));
  1215.     }
  1217.     theErr = HandleHTTPResponse((UCHAR) m_pInBuf[2]);
  1219.     if (!theErr)
  1220.     {
  1221. count = m_pReceiveGetTCP->GetQueuedItemCount();
  1222.     }
  1223. }
  1224. else if (m_pInBuf[0] == HTTP_RV_RESPONSE)
  1225. {
  1226.     if (count < 9)
  1227.     {
  1228. m_pReceiveGetTCP->EnQueue(m_pInBuf, count);
  1229. goto exit;
  1230.     }
  1231.     /*
  1232.      * this involves receiving a message from the server of the format:
  1233.      * HTTP/1.0 200 OK
  1234.      * ...
  1235.      * Content-length:2147483000
  1236.      * r...O?...16k padding of ZEROs...e
  1237.      *
  1238.      * r -- HTTP_RV_RESPONSE (same as the 5.0 player)
  1239.      * O -- HTTP_OPTION_RESPONSE
  1240.      * e -- HTTP_OPT_RESPONSE_END
  1241.      */
  1242.     BYTE* ptr = (BYTE *)m_pInBuf;
  1243.     m_bOptionsReceived = TRUE;
  1244.     
  1245.     ptr += 2;
  1246.     UINT16 nOptionLen = *ptr;
  1247.     ptr++;
  1248.     
  1249.     theErr = HandleHTTPResponse((UCHAR)*ptr);
  1250.     ptr++;
  1252.     if (!theErr)
  1253.     {
  1254. ptr++;  // get past the HTTP_OPTION_RESPONSE char 'O'
  1255. m_uPadLength = (UINT16)getshort(ptr); 
  1256. ptr += 2;
  1258. // skip over the short padding option
  1259. m_uPadLength += 1; // for the 'e' at the end of the 16k padding
  1261. m_pReceiveGetTCP->EnQueue(ptr, 
  1262.     (m_uPadLength <= (count - (ptr - (BYTE *)m_pInBuf)) 
  1263.     ? m_uPadLength : (count - (ptr - (BYTE *)m_pInBuf))));
  1265. count = m_pReceiveGetTCP->GetQueuedItemCount();
  1267. // get rid of the padding sent with the first response
  1268. UINT16 len = (m_uPadLength <= count ? m_uPadLength : count); 
  1269. BYTE* tmpBuf = new BYTE[len];
  1271. m_pReceiveGetTCP->DeQueue(tmpBuf, len);
  1272. m_uPadLength -= len;
  1274. if (m_uPadLength > 0)
  1275. {
  1276.     m_bDeletePadding = TRUE;
  1277. }
  1278. // if we got more than the 16k initial buffer, put it back
  1279. if (len && len < count)
  1280.     m_pReceiveGetTCP->EnQueue(&m_pInBuf[len], count-len);
  1281. HX_VECTOR_DELETE(tmpBuf);
  1282.      count = m_pReceiveGetTCP->GetQueuedItemCount();
  1283.     }
  1284. }
  1285. else
  1286. {
  1287.     theErr = HXR_BAD_SERVER;
  1288.     goto exit;
  1289. }
  1291.     }
  1293.     if (!theErr && m_bReadPending && count > 0 && m_bOptionsReceived 
  1294. && m_bHTTPGetHeaderReadDone)
  1295.     {
  1296. /* mask any kind of errors */
  1297. theErr = HXR_OK;
  1299. if (IsSafe())
  1300. {
  1301.     m_bReadPending = FALSE;
  1302.     if (m_nRequired < count)
  1303.     {
  1304. count = m_nRequired;
  1305.     }
  1307.     CHXBuffer* pBuffer = new CHXBuffer;
  1308.     pBuffer->AddRef();
  1309.     m_pReceiveGetTCP->DeQueue(m_pInBuf, count);
  1310.     pBuffer->Set((UCHAR*) m_pInBuf, count);
  1311.     
  1312.     m_pTCPResponse->ReadDone(HXR_OK, pBuffer);
  1313.     pBuffer->Release();
  1314. }
  1315.     }
  1317. exit:
  1318.     if (theErr && !m_LastError)
  1319.     {
  1320. m_LastError = theErr;
  1321.     }
  1323.     if (m_LastError)
  1324.     {
  1325. if (m_bReadPending)
  1326. {
  1327.     if (IsSafe())
  1328.     {
  1329. m_bReadPending = FALSE;
  1330. m_pTCPResponse->ReadDone(m_LastError, 0);
  1331.     }
  1332. }
  1333.     }
  1335.     if (!m_LastError)
  1336.     {
  1337. DoPutWrite();
  1338. DoRead();
  1339.     }
  1341. quit:
  1342.     m_pMutex->Unlock();
  1344.     return HXR_OK;
  1345. }
  1347. HX_RESULT
  1348. HXClientCloakedTCPSocket::DoPutReadDone(HX_RESULT   status, IHXBuffer* pInBuffer)
  1349. {
  1350.     HX_RESULT rc = HXR_OK;
  1351.     UINT16 count = 0;
  1353.     m_bPutReadPending = FALSE;
  1355.     if (HXR_OK != status)
  1356.     {
  1357. rc = status;
  1358. goto cleanup;
  1359.     }
  1361.     // stop processing either we already processed one PUT response or
  1362.     // we are in multi-post mode
  1363.     if (!m_bPutResponsed && !m_bMustCloseHTTP)
  1364.     {
  1365. if (!m_pReceivePutTCP)
  1366. {
  1367.     m_pReceivePutTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  1368.     if (!m_pReceivePutTCP || !m_pReceivePutTCP->IsQueueValid())
  1369.     {
  1370. rc = HXR_OUTOFMEMORY;
  1371. goto cleanup;
  1372.     }
  1373.     m_pReceivePutTCP->SetMaxSize(TCP_BUF_SIZE);
  1374. }
  1376. if (pInBuffer)
  1377. {
  1378.     m_pReceivePutTCP->EnQueue(pInBuffer->GetBuffer(), (UINT16) pInBuffer->GetSize());
  1379. }
  1381. count = m_pReceivePutTCP->GetQueuedItemCount();
  1383. if (count >= 2)
  1384. {
  1385.     char* pEndLineLocation = 0;
  1386.     if (!m_pHTTPHeaderBuffer || m_nHTTPHeaderBufferLength < count+1)
  1387.     {
  1388. HX_VECTOR_DELETE(m_pHTTPHeaderBuffer);
  1389. m_nHTTPHeaderBufferLength = count+1 > DEFAULT_HTTP_HEADER_LENGTH ?
  1390.     count+1 : DEFAULT_HTTP_HEADER_LENGTH;
  1391. m_pHTTPHeaderBuffer = new char[m_nHTTPHeaderBufferLength];
  1392. if (!m_pHTTPHeaderBuffer)
  1393. {
  1394.     rc = HXR_OUTOFMEMORY;
  1395.     goto cleanup;
  1396. }
  1397.     }
  1399.     m_pReceivePutTCP->DeQueue(m_pHTTPHeaderBuffer, count);
  1400.     m_pHTTPHeaderBuffer[count] = '';
  1402.     if ((pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "nn")) ||
  1403.      (pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "rr")) )
  1404.     {
  1405. m_bHTTPPutHeaderReadDone = TRUE;
  1406.     }
  1407.     else if (count >= 4 &&
  1408.     (pEndLineLocation = (char*) HXFindString(m_pHTTPHeaderBuffer, "rnrn")))
  1409.     {
  1410. m_bHTTPPutHeaderReadDone = TRUE;
  1411.     }
  1412.     else
  1413.     {
  1414. /* Put back everything in receive queue*/
  1415. m_pReceivePutTCP->EnQueue(m_pHTTPHeaderBuffer, count);
  1416. goto cleanup;
  1417.     }
  1419.     m_bPutResponsed = TRUE;
  1420.     GetServerIPFromResponse(FALSE, m_pHTTPHeaderBuffer);
  1422.     if (m_bConnectToSameServerIP)
  1423.     {
  1424. rc = ActualConnect();
  1425.     }
  1426.     else
  1427.     {
  1428. if (m_pszPutServerIP && m_pPreferredTransport)
  1429. {
  1430.     m_pPreferredTransport->SetHTTPNG(TRUE);
  1431. }
  1433. // determine whether we need to issue re-GET to the same serverIP
  1434. // from the POST response
  1435. if (m_pszGetServerIP && m_pszPutServerIP)
  1436. {
  1437.     m_bReconnectToSameServerIP = strcasecmp(m_pszGetServerIP, m_pszPutServerIP);
  1438. }
  1440. if (m_bReconnectToSameServerIP)
  1441. {
  1442.     rc = ReconnectToSameServerIP();
  1443. }
  1444.     }
  1445. }
  1446.     }
  1448. cleanup:
  1450.     return rc;
  1451. }
  1453. void
  1454. HXClientCloakedTCPSocket::TransferBuffers()
  1455. {
  1456.     IHXBuffer* pBuffer = 0;
  1457.     HX_RESULT theErr = HXR_OK;
  1459.     if (m_bInTransferBuffers)
  1460.     {
  1461. return;
  1462.     }
  1464.     m_bInTransferBuffers = TRUE;
  1466.     /*This is where we need to add POST header for multiple POST case*/
  1468.     while (m_PendingWriteBuffers.GetCount() > 0)
  1469.     {
  1470. pBuffer = (IHXBuffer*) m_PendingWriteBuffers.GetHead();
  1471. if ((UINT16) pBuffer->GetSize() < m_pPreEncodedSendHTTP->GetMaxAvailableElements())
  1472. {
  1473.     m_pPreEncodedSendHTTP->EnQueue(pBuffer->GetBuffer(), 
  1474. (UINT16) pBuffer->GetSize());
  1475.     pBuffer->Release();
  1476.     m_PendingWriteBuffers.RemoveHead();
  1477. }
  1478. else
  1479. {
  1480.     break;
  1481. }
  1482.     }
  1484.     UINT16 nCount = m_pPreEncodedSendHTTP->GetQueuedItemCount();
  1485.     if (nCount > 0)
  1486.     {
  1487. if (m_bCloseHttpAfterWrite)
  1488. {
  1489.     ENQUEUE_BYTE(m_pPreEncodedSendHTTP, HTTP_POSTDONE);
  1490.     nCount++;
  1491. }
  1493. if (m_bMustCloseHTTP && m_pPutCtrl)
  1494. {
  1495.     m_pPutCtrl->Release();
  1496.     m_pPutCtrl = 0;
  1497.     m_bPutConnectDone = FALSE;
  1499.     m_pNetworkServices->CreateTCPSocket(&m_pPutCtrl);
  1500.     if (!m_pPutCtrl)
  1501.     {
  1502. m_LastError = HXR_OUTOFMEMORY;
  1503. m_bInTransferBuffers = FALSE;
  1504. return;
  1505.     }
  1507.     m_pPutCtrl->Init(m_pPutCtrlResponse);
  1509.     const char* pActualHost = m_pForiegnHost;
  1510.     UINT16  nActualPort = m_nForeignPort;
  1511.     if (m_pProxyHostName)
  1512.     {
  1513. pActualHost = m_pProxyHostName;
  1514. nActualPort = m_nProxyPortNumber;
  1515.     }
  1517.     m_pPutCtrl->Connect(pActualHost,nActualPort);
  1518. }
  1520. m_pPreEncodedSendHTTP->DeQueue(m_pOutBuf, nCount);
  1521. UINT16 nEncodedCount = TCP_BUF_SIZE;
  1522. EncodeBase64((UCHAR*) m_pOutBuf, nCount, (UCHAR*) m_pOutEncodedBuf, nEncodedCount);
  1524.         HX_ASSERT(nEncodedCount <= TCP_BUF_SIZE);
  1526. if (m_bCloseHttpAfterWrite)
  1527. {
  1528.     theErr = PreparePostMessage((UCHAR*) m_pOutEncodedBuf, nEncodedCount);
  1529. }
  1530. else
  1531. {
  1532.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,m_pOutEncodedBuf, nEncodedCount);
  1533. }
  1534.     }
  1536.     m_bInTransferBuffers = FALSE;
  1537. }
  1539. /***************************General routines*******/
  1541. HX_RESULT
  1542. HXClientCloakedTCPSocket::PreparePostMessage(const UCHAR *inData, UINT16 inLength) 
  1543. {
  1544.     HX_RESULT theErr = HXR_OK;
  1545.     int count = 0;
  1546.     UINT16 postLength = inLength;
  1547.     
  1548.     // create a temp buffer to help build the HTTP POST message
  1549.     char* s = new char[MAX_HTTP_METHOD_BUFSIZE];
  1550.     if(s == NULL)
  1551.     {
  1552. return HXR_OUTOFMEMORY;
  1553.     }
  1554.     // build the HTTP POST message
  1555.     if(m_pProxyHostName)
  1556.     {
  1557. if (m_nForeignPort)
  1558. {
  1559.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"POST http://%s:%d/SmpDsBhgRl",m_pForiegnHost, m_nForeignPort);
  1560. }
  1561. else
  1562. {
  1563.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"POST http://%s/SmpDsBhgRl",m_pForiegnHost);
  1564. }
  1565.     }
  1566.     else
  1567.     {
  1568. //count = sprintf(s,"POST /SmpDsBhgRl"); /* Flawfinder: ignore */
  1569. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"POST /SmpDsBhgRl"); /* Flawfinder: ignore */
  1570.     }
  1571.     
  1572.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1574.     // enqueue the remainder of the POST line
  1575.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE," HTTP/1.0rn"); /* Flawfinder: ignore */
  1576.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1578.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"User-Agent: RealPlayer G2rn"); /* Flawfinder: ignore */
  1579.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1581.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Pragma: no-cachern"); /* Flawfinder: ignore */
  1582.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1584.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Expires: Mon, 18 May 1974 00:00:00 GMTrn"); /* Flawfinder: ignore */
  1585.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1587.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Accept: application/x-rtsp-tunnelled, */*rn"); /* Flawfinder: ignore */
  1588.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1590.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Content-type: application/x-pncmdrn"); /* Flawfinder: ignore */
  1591.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1593.     CHXString strAuth;
  1594.     ObtainAuthenticationInformation(strAuth);
  1595.     
  1596.     if (!strAuth.IsEmpty())
  1597.     {
  1598. strAuth += "rn";    
  1599. ENQUEUE_DATA(m_pPostEncodedSendHTTP, (void*)(const char*)strAuth, 
  1600.      (UINT16)strAuth.GetLength());
  1601.     }
  1603.     UINT16 guidSize = ::strlen(m_pGuid);
  1605.     if(m_bUseExactContentLength)
  1606.     {
  1607. // add in the size of the GUID (which was not base64 encoded)
  1608. postLength += guidSize + 2; // 2 is for the rn at the end of the GUID!
  1610. // we must report the exact size of the post data in the Content-length parameter
  1611. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Content-length: %hurn",postLength); /* Flawfinder: ignore */
  1612.     }
  1613.     else
  1614.     {
  1615. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Content-length: 32767rn"); /* Flawfinder: ignore */
  1616.     }
  1618.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1620.     // enqueue the CR LF to indicate end of the POST header
  1621.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"rn"); /* Flawfinder: ignore */
  1622.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1624.     // enqueue the GUID (Must be sent with every POST and not base64 encoded)
  1625.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,&m_pGuid[0],guidSize);
  1626.     
  1627.     // enqueue the CR LF to indicate end of the GUID
  1628.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"rn"); /* Flawfinder: ignore */
  1629.     ENQUEUE_DATA(m_pPostEncodedSendHTTP,s,count);
  1631.     if(inLength > 0)
  1632.     {
  1633. // enqueue the actual POST data
  1634. ENQUEUE_DATA(m_pPostEncodedSendHTTP,(char *)inData,inLength);
  1635.     }
  1636.     
  1637.     // clean up allocated buffers
  1638.     if(s)
  1639.     {
  1640. delete [] s;
  1641.     }
  1643.     return theErr;
  1644. }
  1646. HX_RESULT
  1647. HXClientCloakedTCPSocket::PrepareGetMessage(void) 
  1648. {
  1649.     HX_RESULT theErr = HXR_OK;
  1650.     IHXBuffer* pBuffer = NULL;
  1652.     // create a temp buffer for the HTTP GET message
  1653.     char* s = new char[MAX_HTTP_METHOD_BUFSIZE];
  1654.     
  1655.     if(s == NULL)
  1656.     {
  1657. theErr = HXR_OUTOFMEMORY;
  1658.     }
  1659.     
  1660.     /* Flush any prior data in the send queue */
  1661.     m_pSendTCP->FlushQueue();
  1663.     /* Create a fresh GUID */
  1664.     CreateGuid();
  1666.     // format the HTTP GET message
  1667.     if(!theErr)
  1668.     {
  1669. int count = 0;
  1671. // build the HTTP POST message
  1672. if(m_pProxyHostName)
  1673. {   
  1674.     if (m_nForeignPort)
  1675.     {
  1676. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"GET http://%s:%d/SmpDsBhgRl",m_pForiegnHost, m_nForeignPort);
  1677.     }
  1678.     else
  1679.     {
  1680. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"GET http://%s/SmpDsBhgRl",m_pForiegnHost);
  1681.     }
  1682. }
  1683. else
  1684. {
  1685.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"GET /SmpDsBhgRl"); /* Flawfinder: ignore */
  1686. }
  1688. ENQUEUE_DATA(m_pSendTCP,s,count);
  1690. #if 0 // XXX HP enable this to test re-GET after initial GET/POST response 
  1691. // returned with different serverIP
  1692. if (!m_bReconnectToSameServerIP)
  1693. {
  1694.     char* pGuid = new char[strlen(m_pGuid)+1];
  1695.     memcpy(pGuid, m_pGuid, strlen(m_pGuid)); /* Flawfinder: ignore */
  1696.     pGuid[0] = 'z';
  1697.     // enqueue the GUID directly after the SmpDsBhgRl tag
  1698.     ENQUEUE_DATA(m_pSendTCP,&pGuid[0],::strlen(pGuid));
  1699.     HX_VECTOR_DELETE(pGuid);
  1700. }
  1701. else
  1702. #endif
  1703. {
  1704.     // enqueue the GUID directly after the SmpDsBhgRl tag
  1705.     ENQUEUE_DATA(m_pSendTCP,&m_pGuid[0],::strlen(m_pGuid));
  1706. }
  1708. if (m_pProxyHostName)
  1709. {
  1710.     /* 
  1711.      * enqueue dummy option to tell the server to send a padding
  1712.      * of 16k of ZEROs with the first response
  1713.      */
  1714.     count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"?1="1""); /* Flawfinder: ignore */
  1715.     ENQUEUE_DATA(m_pSendTCP,s,count);
  1716. }
  1718. // enqueue the HTTP 1.0 and CR LF
  1719. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE," HTTP/1.0rn"); /* Flawfinder: ignore */
  1720. ENQUEUE_DATA(m_pSendTCP,s,count);
  1722. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"User-Agent: RealPlayer G2rn"); /* Flawfinder: ignore */
  1723. ENQUEUE_DATA(m_pSendTCP,s,count);
  1725. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Expires: Mon, 18 May 1974 00:00:00 GMTrn"); /* Flawfinder: ignore */
  1726. ENQUEUE_DATA(m_pSendTCP,s,count);
  1728. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Pragma: no-cachern"); /* Flawfinder: ignore */
  1729. ENQUEUE_DATA(m_pSendTCP,s,count);
  1731. count = SafeSprintf(s,MAX_HTTP_METHOD_BUFSIZE,"Accept: application/x-rtsp-tunnelled, */*rn"); /* Flawfinder: ignore */
  1732. ENQUEUE_DATA(m_pSendTCP,s,count);
  1734. CHXString strAuth;
  1735. ObtainAuthenticationInformation(strAuth);
  1737. if (!strAuth.IsEmpty())
  1738. {
  1739.     strAuth += "rn";    
  1740.     ENQUEUE_DATA(m_pSendTCP, (void*)(const char*)strAuth, 
  1741.  (UINT16)strAuth.GetLength());
  1742. }
  1744. // send client information so that GoldPass Admin
  1745. // can generate redirect URL via HTTPCloaking
  1746. if (m_pCloakValues)
  1747. {
  1748.     if (HXR_OK == m_pCloakValues->GetPropertyCString("ClientID", pBuffer))
  1749.     {
  1750. UINT32 ulNewSize = pBuffer->GetSize()+25;
  1751. s = (char*)realloc(s, ulNewSize);
  1752.                 if(s)
  1753.                 {
  1754.                     count = SafeSprintf(s,ulNewSize,"ClientID: %srn", pBuffer->GetBuffer()); /* Flawfinder: ignore */
  1755.                     ENQUEUE_DATA(m_pSendTCP,s,count);
  1756.                 }
  1757.                 else
  1758.                 {
  1759.                     theErr = HXR_OUTOFMEMORY;
  1760.                 }
  1761.                 
  1762.     }
  1763.     HX_RELEASE(pBuffer);
  1765.     if (HXR_OK == m_pCloakValues->GetPropertyCString("Cookie", pBuffer))
  1766.     {
  1767. UINT32 ulNewSize = pBuffer->GetSize()+25;
  1768. s = (char*)realloc(s, ulNewSize);
  1769.                 if(s)
  1770.                 {
  1771.                     count = SafeSprintf(s,ulNewSize,"Cookie: %srn", pBuffer->GetBuffer()); /* Flawfinder: ignore */
  1772.                     ENQUEUE_DATA(m_pSendTCP,s,count);
  1773.                 }
  1774.                 else
  1775.                 {
  1776.                     theErr = HXR_OUTOFMEMORY;
  1777.                 }
  1778.             }
  1779.     HX_RELEASE(pBuffer);
  1781.     if (HXR_OK == m_pCloakValues->GetPropertyCString("url", pBuffer))
  1782.     {
  1783. UINT32 ulNewSize = pBuffer->GetSize()+25;
  1784.                 s = (char*)realloc(s, ulNewSize);
  1785.                 if(s)
  1786.                 {
  1787.                     count = SafeSprintf(s,ulNewSize,"X-Actual-URL: %srn", pBuffer->GetBuffer()); /* Flawfinder: ignore */
  1788.                     ENQUEUE_DATA(m_pSendTCP,s,count);
  1789.                 }
  1790.                 else
  1791.                 {
  1792.                     theErr = HXR_OUTOFMEMORY;
  1793.                 }
  1794.     }
  1795.     HX_RELEASE(pBuffer);
  1796. }
  1798. // enqueue the CR LF to indicate the end of the HTTP GET header
  1799.         s = (char*)realloc(s, 25);
  1800.         if(s)
  1801.         {
  1802.             count = SafeSprintf(s,25,"rn"); /* Flawfinder: ignore */
  1803.             ENQUEUE_DATA(m_pSendTCP,s,count);
  1804.         }
  1805.         else
  1806.         {
  1807.             theErr = HXR_OUTOFMEMORY;
  1808.         }
  1809.     }
  1810.     
  1811.     // clean up
  1812.     HX_DELETE(s);
  1813.     
  1814.     return theErr;
  1815. }
  1817. void
  1818. HXClientCloakedTCPSocket::CreateGuid(void)
  1819. {
  1820.     CHXuuid theGuid;
  1821.     uuid_tt uuid;
  1822.     
  1823.     if (m_pGuid)
  1824.     {
  1825. return;
  1826.     }
  1828.     if(m_pGuid)
  1829.     {
  1830. delete [] m_pGuid;
  1831. m_pGuid = NULL;
  1832.     }
  1833.     
  1834.     // generate a new GUID
  1835.     HX_RESULT theErr = theGuid.GetUuid(&uuid);
  1836. //    HX_RESULT theErr = HXR_OK;
  1838.     if(!theErr)
  1839.     {
  1840. CHXString theString;
  1842. CHXuuid::HXUuidToString((const uuid_tt*)&uuid,&theString);
  1844. int length = theString.GetLength();
  1846. m_pGuid = new char[length + 1];
  1848. if(!m_pGuid)
  1849. {
  1850. theErr = HXR_OUTOFMEMORY;
  1851. }
  1853. if(!theErr)
  1854. {
  1855. ::strcpy(m_pGuid,(const char *)theString); /* Flawfinder: ignore */
  1856. m_pGuid[length] = '';
  1857. }
  1859. if(theErr && m_pGuid)
  1860. {
  1861. delete [] m_pGuid;
  1862. m_pGuid = NULL;
  1863. }
  1864.     }
  1865.     
  1866.     if(theErr)  // use our own GUID generator
  1867.     {
  1868. theErr = HXR_OK;
  1869. ULONG32 temp = HX_GET_TICKCOUNT();
  1871. if(m_pGuid)
  1872. {
  1873.     delete [] m_pGuid;
  1874.     m_pGuid = NULL;
  1875. }
  1876.     
  1877. m_pGuid = new char[HXGUID_SIZE + 1];
  1879. UINT16 length = SafeSprintf(m_pGuid,HXGUID_SIZE + 1,"%ld",temp);
  1881. while(length < HXGUID_SIZE)
  1882. {
  1883. m_pGuid[length++] = '1';
  1884. }
  1886. m_pGuid[HXGUID_SIZE] = '';
  1887.     }
  1888. }
  1890. HX_RESULT 
  1891. HXClientCloakedTCPSocket::EncodeBase64(const UCHAR* inData, UINT16 inLength, UCHAR* outData, UINT16& outLength)
  1892. {
  1893.     HX_RESULT theErr = HXR_OK;
  1894.     
  1895.     HX_ASSERT(inData != NULL);
  1896.     HX_ASSERT(outData != NULL);
  1897.     HX_ASSERT(inLength != 0);
  1898.     
  1899.     // first base64 encode the buffer
  1900.     outLength = (UINT16) BinTo64((const UCHAR*) inData, (ULONG32) inLength,(char *)outData);
  1902.     HX_ASSERT(outLength >= inLength);
  1904.     return HXR_OK;
  1905. }
  1908. HX_RESULT
  1909. HXClientCloakedTCPSocket::HandleHTTPResponse(UCHAR response)
  1910. {
  1911.     HX_RESULT theErr = HXR_OK;
  1912.     
  1913.     switch(response)
  1914.     {
  1915. case HTTP_OK:
  1916. {
  1917.     m_bUseExactContentLength = FALSE;
  1918.     m_bCloseHttpAfterWrite = FALSE;
  1919.     m_bHttpInitialized = TRUE;
  1920.     /*force a write of the cached data to be sent to the server*/
  1921. //     theErr = control_write();
  1922. }
  1923. break;
  1925. case POST_NOT_RECEIVED: // POST message was not received
  1926. {
  1927.     if (m_pszGetServerIP)
  1928.     {
  1929. HX_VECTOR_DELETE(m_pForiegnHost);
  1930. // use serverIP from GET response for multi-POST
  1931. m_pForiegnHost = new char [strlen(m_pszGetServerIP) + 1];
  1932. if (m_pForiegnHost)
  1933. {
  1934.     ::strcpy(m_pForiegnHost, m_pszGetServerIP); /* Flawfinder: ignore */
  1935. }
  1936. else
  1937. {
  1938.     theErr = HXR_OUTOFMEMORY;
  1939. }
  1940.     }
  1941.  
  1942.     m_bUseExactContentLength = TRUE;
  1943.     m_bCloseHttpAfterWrite = TRUE;
  1944.     m_bHttpInitialized = TRUE;
  1945.     m_bMustCloseHTTP = TRUE;
  1947.     /*force a write of the cached data to be sent to the server*/
  1948. //     theErr = control_write();
  1949. }
  1950. break;
  1952. case INVALID_GUID: 
  1953. {
  1954.     /* sent only if the GUID from the Player is already in use
  1955.      * Need to regenerate GUID and send everything again
  1956.      */
  1957.     /// TBD - Rahul     
  1958.     if (m_pGuid)
  1959.     {
  1960. delete [] m_pGuid;
  1961. m_pGuid = 0;
  1962.     }
  1964.     PrepareGetMessage();
  1965.     theErr = DoGetWrite();
  1966. }
  1967. break;
  1969. default:
  1970. {
  1971.     // shut this clip down and report an appropriate error
  1972.     theErr = HXR_HTTP_CONTENT_NOT_FOUND;
  1973. }
  1974. break;
  1975.     }
  1976.     
  1977.     return theErr;
  1978. }
  1980. /* If we are at interrupt time and the response object is not interrupt safe,
  1981.  * schedule a callback to return back the data
  1982.  */
  1983. BOOL
  1984. HXClientCloakedTCPSocket::IsSafe()
  1985. {
  1986.     if (m_pInterruptState && m_pInterruptState->AtInterruptTime() && 
  1987. (!m_pResponseInterruptSafe || 
  1988.  !m_pResponseInterruptSafe->IsInterruptSafe()))
  1989.     {
  1990. if (m_pNonInterruptCallback){
  1991.     m_pNonInterruptCallback->ScheduleCallback(CLOAKED_TCP_READ_COMMAND, m_pScheduler, 0);
  1992. }
  1994. return FALSE;
  1995.     }
  1997.     return TRUE;
  1998. }
  2000. void
  2001. HXClientCloakedTCPSocket::FlushQueues(void)
  2002. {
  2003.     if (m_pSendTCP)
  2004.     {
  2005. m_pSendTCP->FlushQueue();
  2006.     }
  2008.     if (m_pReceiveGetTCP)
  2009.     {
  2010. m_pReceiveGetTCP->FlushQueue();
  2011.     }
  2013.     if (m_pReceivePutTCP)
  2014.     {
  2015. m_pReceivePutTCP->FlushQueue();
  2016.     }
  2018.     if (m_pPreEncodedSendHTTP)
  2019.     {
  2020. m_pPreEncodedSendHTTP->FlushQueue();
  2021.     }
  2023.     if (m_pPostEncodedSendHTTP)
  2024.     {
  2025. m_pPostEncodedSendHTTP->FlushQueue();
  2026.     }
  2027. }
  2029. void
  2030. HXClientCloakedTCPSocket::SendHTTPDone(void)
  2031. {
  2032.     CHXBuffer* pBuffer = new CHXBuffer;
  2033.     pBuffer->AddRef();
  2035.     BYTE http_done = HTTP_DONE;
  2036.     pBuffer->Set((UCHAR*) &http_done, 1);
  2037.     m_PendingWriteBuffers.AddTail((void*) pBuffer);
  2039.     TransferBuffers();
  2040.     DoPutWrite();
  2041. }
  2043. HX_RESULT
  2044. HXClientCloakedTCPSocket::ActualConnect(void)
  2045. {
  2046.     HX_RESULT rc = HXR_OK;
  2048.     const char* pActualHost = m_pForiegnHost;
  2049.     UINT16  nActualPort = m_nForeignPort;
  2050.     if (m_pProxyHostName)
  2051.     {
  2052. pActualHost = m_pProxyHostName;
  2053. nActualPort = m_nProxyPortNumber;
  2054.     }
  2056.     if (m_bConnectToSameServerIP)
  2057.     {
  2058. if (m_bPutConnectSuccessful)
  2059. {
  2060.     rc = m_pGetCtrl->Connect(pActualHost,nActualPort);
  2061. }
  2062. else
  2063. {
  2064.     rc = m_pPutCtrl->Connect(pActualHost,nActualPort);
  2065. }
  2066. rc = ConvertNetworkError(rc);
  2067.     }
  2068.     else
  2069.     {
  2070. rc = m_pGetCtrl->Connect(pActualHost,nActualPort);
  2071. rc = ConvertNetworkError(rc);
  2073. if (rc == HXR_OK && !m_bReconnectToSameServerIP)
  2074. {
  2075.     rc = m_pPutCtrl->Connect(pActualHost,nActualPort);
  2076.     rc = ConvertNetworkError(rc);
  2077. }
  2078.     }
  2080.     return rc;
  2081. }
  2083. HX_RESULT
  2084. HXClientCloakedTCPSocket::GetServerIPFromResponse(BOOL bGetResponse, const char* pszInBuffer)
  2085. {
  2086.     HX_RESULT rc = HXR_OK;
  2087.     UINT8 nLength = 0;
  2088.     char* pszServerIPStart = NULL;    
  2089.     char* pszServerIPEnd = NULL;
  2090.     char* pszServerIP = NULL;
  2092.     if (!pszInBuffer)
  2093.     {
  2094. rc = HXR_FAILED;
  2095. goto cleanup;
  2096.     }
  2098.     pszServerIPStart = (char*)HXFindString(pszInBuffer, "x-server-ip-address:");
  2100.     if (pszServerIPStart)
  2101.     {
  2102. pszServerIPStart += strlen("x-server-ip-address:");
  2104. // removing leading spaces
  2105. while (*pszServerIPStart == ' ')
  2106. {
  2107.     pszServerIPStart++;
  2108. }
  2110. pszServerIPEnd = (char*)HXFindString(pszServerIPStart, "rn");
  2111. if (pszServerIPEnd)
  2112. {
  2113.     nLength = pszServerIPEnd - pszServerIPStart;
  2115.     pszServerIP = new char[nLength + 1];
  2116.     memset(pszServerIP, 0, nLength + 1);
  2118.     strncpy(pszServerIP, pszServerIPStart, nLength); /* Flawfinder: ignore */
  2120.     if (bGetResponse)
  2121.     {
  2122. HX_VECTOR_DELETE(m_pszGetServerIP);
  2123. m_pszGetServerIP = pszServerIP;
  2124.     }
  2125.     else
  2126.     {
  2127. HX_VECTOR_DELETE(m_pszPutServerIP);
  2128. m_pszPutServerIP = pszServerIP;
  2129.     }
  2130. }
  2131.     }
  2133. cleanup:
  2135.     return rc;
  2136. }
  2139. HX_RESULT
  2140. HXClientCloakedTCPSocket::CleanUpAndReInitializeStuff(void)
  2141. {
  2142.     HX_RESULT rc = HXR_OK;
  2143.     IHXBuffer* pBuffer = NULL;
  2145.     m_pMutex->Lock();
  2147.     const char* pActualHost = m_pForiegnHost;
  2148.     UINT16  nActualPort = m_nForeignPort;
  2149.     if (m_pProxyHostName)
  2150.     {
  2151. pActualHost = m_pProxyHostName;
  2152. nActualPort = m_nProxyPortNumber;
  2153.     }
  2155.     if (m_pReceiveGetTCP)
  2156.     {
  2157. m_pReceiveGetTCP->FlushQueue();
  2158.     }
  2160.     /* Send a final HTTP done message */
  2161.     if (m_bHttpInitialized)
  2162.     {
  2163. SendHTTPDone();
  2164.     }
  2166.     if (m_pSchedulerCallback)
  2167.     {
  2168. m_pSchedulerCallback->Unschedule(m_pScheduler);
  2169.     }
  2171.     if (m_pNonInterruptCallback)
  2172.     {
  2173. m_pNonInterruptCallback->Unschedule(m_pScheduler);
  2174.     }
  2176.     HX_RELEASE(m_pGetCtrl);
  2177.     HX_RELEASE(m_pPutCtrl);
  2178.     
  2179.     m_bHTTPGetHeaderReadDone = FALSE;
  2180.     m_bOptionsReceived = FALSE;
  2181.     m_bReadPending = FALSE;
  2182.     m_bGetReadPending = FALSE;
  2183.     m_bGetConnectDone = FALSE;
  2184.     m_bGetConnectSuccessful = FALSE;
  2185.     m_bConnectResponsePending = TRUE;
  2186.     m_bConnected = FALSE;
  2188.     m_bPutConnectDone = FALSE;
  2189.     m_bPutReadPending = FALSE;
  2191.     m_bInAuthenticationKludge = TRUE;
  2192.     
  2193.     // OK, clean up is done so now we re-initialize.
  2194.     
  2195.     
  2196.     // use serverIP from PUT response for GET reconnect
  2197.     
  2198.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pGetCtrl))
  2199.     {
  2200. rc = HXR_FAILED;
  2201. goto cleanup;
  2202.     }
  2204.     if (HXR_OK != m_pGetCtrl->Init(m_pGetCtrlResponse))
  2205.     {
  2206. rc = HXR_FAILED;
  2207. goto cleanup;
  2208.     }
  2210.     if (HXR_OK != m_pGetCtrl->Bind(HXR_INADDR_ANY, 0))
  2211.     {
  2212. rc = HXR_FAILED;
  2213. goto cleanup;
  2214.     }
  2215.     
  2216.     rc = m_pGetCtrl->Connect(pActualHost, nActualPort);    
  2217.     if (HXR_OK != rc)
  2218.     {
  2219. goto cleanup;
  2220.     }
  2222.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pPutCtrl))
  2223.     {
  2224. rc = HXR_FAILED;
  2225. goto cleanup;
  2226.     }
  2228.     if (HXR_OK != m_pPutCtrl->Init(m_pPutCtrlResponse))
  2229.     {
  2230. rc = HXR_FAILED;
  2231. goto cleanup;
  2232.     }
  2234.     if (HXR_OK != m_pPutCtrl->Bind(HXR_INADDR_ANY, 0))
  2235.     {
  2236. rc = HXR_FAILED;
  2237. goto cleanup;
  2238.     }
  2240.     rc = m_pPutCtrl->Connect(pActualHost, nActualPort);
  2241.     if (HXR_OK != rc) goto cleanup;
  2244. cleanup:
  2245.     m_pMutex->Unlock();
  2247.     return rc;
  2248. }
  2250. HX_RESULT
  2251. HXClientCloakedTCPSocket::ReconnectToSameServerIP(void)
  2252. {
  2253.     HX_RESULT rc = HXR_OK;
  2254.     IHXBuffer* pBuffer = NULL;
  2256.     m_pMutex->Lock();
  2258.     if (m_pReceiveGetTCP)
  2259.     {
  2260. m_pReceiveGetTCP->FlushQueue();
  2261.     }
  2263.     /* Send a final HTTP done message */
  2264.     if (m_bHttpInitialized)
  2265.     {
  2266. SendHTTPDone();
  2267.     }
  2269.     if (m_pSchedulerCallback)
  2270.     {
  2271. m_pSchedulerCallback->Unschedule(m_pScheduler);
  2272.     }
  2274.     if (m_pNonInterruptCallback)
  2275.     {
  2276. m_pNonInterruptCallback->Unschedule(m_pScheduler);
  2277.     }
  2279.     HX_RELEASE(m_pGetCtrl);
  2280.     HX_RELEASE(m_pGetCtrlResponse);
  2281.     
  2282.     m_bHTTPGetHeaderReadDone = FALSE;
  2283.     m_bOptionsReceived = FALSE;
  2284.     m_bReadPending = FALSE;
  2285.     m_bGetReadPending = FALSE;
  2286.     m_bGetConnectDone = FALSE;
  2287.     m_bGetConnectSuccessful = FALSE;
  2288.     m_bConnectResponsePending = TRUE;
  2289.     m_bConnected = FALSE;
  2291.     HX_VECTOR_DELETE(m_pForiegnHost);
  2292.     // use serverIP from PUT response for GET reconnect
  2293.     m_pForiegnHost = new char [strlen(m_pszPutServerIP) + 1];
  2294.     if (!m_pForiegnHost)
  2295.     {
  2296. rc = HXR_OUTOFMEMORY;
  2297. goto cleanup;
  2298.     }
  2299.     ::strcpy(m_pForiegnHost, m_pszPutServerIP); /* Flawfinder: ignore */
  2300.     
  2301.     if (HXR_OK != m_pNetworkServices->CreateTCPSocket(&m_pGetCtrl))
  2302.     {
  2303. rc = HXR_FAILED;
  2304. goto cleanup;
  2305.     }
  2307.     m_pGetCtrlResponse = new HTTPCloakTCPResponse(this, TRUE);
  2308.     if (!m_pGetCtrlResponse)
  2309.     {
  2310. rc = HXR_FAILED;
  2311. goto cleanup;
  2312.     }
  2314.     m_pGetCtrlResponse->AddRef();
  2316.     if (HXR_OK != m_pGetCtrl->Init(m_pGetCtrlResponse))
  2317.     {
  2318. rc = HXR_FAILED;
  2319. goto cleanup;
  2320.     }
  2322.     if (HXR_OK != m_pGetCtrl->Bind(HXR_INADDR_ANY, 0))
  2323.     {
  2324. rc = HXR_FAILED;
  2325. goto cleanup;
  2326.     }
  2328.     rc = ActualConnect();
  2330. cleanup:
  2332.     m_pMutex->Unlock();
  2334.     return rc;
  2335. }
  2337. BOOL
  2338. HXClientCloakedTCPSocket::AuthenticationRequired(HX_RESULT   status, IHXBuffer* pInBuffer)
  2339. {
  2340.     if (!pInBuffer)
  2341.     {
  2342. return FALSE;
  2343.     }
  2345.     // start of authenticated proxy logic.
  2347.     HTTPParser Parser;
  2348.     char* pBufferContents = (char*)(const char*)pInBuffer->GetBuffer();
  2349.     ULONG32 nMsgLen = pInBuffer->GetSize();
  2350.     HTTPResponseMessage* pMessage = (HTTPResponseMessage*)Parser.parse( pBufferContents, nMsgLen );
  2352.     // ignore non-HTTP responses which will be processed by the response object:
  2353.     // RTSPClientProtocol
  2354.     if (HTTPMessage::T_UNKNOWN == pMessage->tag())
  2355.     {
  2356. HX_DELETE(pMessage);
  2357. return FALSE;
  2358.     }
  2360.     ULONG32 ulHTTPStatus = 0;
  2361.     if (strlen(pMessage->errorCode()) > 0)
  2362.     {
  2363. ulHTTPStatus = atoi(pMessage->errorCode());
  2364.     }
  2366.     if (ulHTTPStatus == 401 || ulHTTPStatus == 407)
  2367.     {
  2368. #ifdef _MACINTOSH
  2369. if (!IsMacInCooperativeThread())
  2370. {
  2371.     // xxxbobclark Since there's UI involved with authentication,
  2372.     // we'll ensure that we're not at interrupt time.
  2373.     if (m_pAuthenticationCallback && !m_pAuthenticationCallback->m_ulPendingCallbackID)
  2374.     {
  2375. m_pAuthenticationCallback->m_ulPendingCallbackID  =
  2376. m_pScheduler->RelativeEnter(m_pAuthenticationCallback, 0);
  2377. m_pAuthenticationCallback->m_Status = status;
  2378. pInBuffer->AddRef();
  2379. m_pAuthenticationCallback->m_pInBuffer = pInBuffer;
  2380.     }
  2382.     HX_DELETE(pMessage);
  2383.     return TRUE;  
  2384. }
  2385. #endif
  2386. IHXRequest* pRequest = NULL;
  2388. IHXCommonClassFactory* pCCF;
  2389. HX_RESULT retVal = m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCCF);
  2391. if (SUCCEEDED(retVal))
  2392. {
  2393.     retVal = pCCF->CreateInstance(CLSID_IHXRequest, (void**)&pRequest);
  2395.     if(retVal == HXR_OK)
  2396.     {
  2397. PrepareGetMessage(); // set up m_pSendTCP
  2399. UINT16 count    = m_pSendTCP->GetQueuedItemCount();
  2400. m_pSendTCP->DeQueue(m_pOutBuf,count);
  2402. retVal = pRequest->SetURL(m_pOutBuf);
  2404. IHXKeyValueList* pResponseHeaders = NULL;
  2406. pCCF->CreateInstance(CLSID_IHXKeyValueList, (void**)&pResponseHeaders);
  2408. MIMEHeaderValue* pHeaderValue = NULL;
  2409. MIMEHeader* pHeader = pMessage->getFirstHeader();
  2410. while (pHeader)
  2411. {
  2412.     pHeaderValue = pHeader->getFirstHeaderValue();
  2413.     CHXString strHeader;
  2414.     while (pHeaderValue)
  2415.     {
  2416. CHXString strTemp;
  2417. pHeaderValue->asString(strTemp);
  2418. strHeader += strTemp;
  2419. pHeaderValue = pHeader->getNextHeaderValue();
  2420. if (pHeaderValue)
  2421. {
  2422.     strHeader += ", ";
  2423. }
  2424.     }
  2425.     IHXBuffer* pBuffer = NULL;
  2426.     CHXBuffer::FromCharArray((const char*)strHeader, &pBuffer);
  2427.     pResponseHeaders->AddKeyValue(pHeader->name(), pBuffer);
  2428.     HX_RELEASE(pBuffer);
  2430.     pHeader = pMessage->getNextHeader();
  2431. }
  2433. IHXValues* pResponseValues = NULL;             
  2435. if (HXR_OK == pResponseHeaders->QueryInterface(IID_IHXValues, (void**)&pResponseValues))
  2436. {
  2437.     pRequest->SetResponseHeaders(pResponseValues);
  2438. }
  2440. HandleAuthentication(pRequest, pMessage, m_pForiegnHost, m_pProxyHostName);
  2442. HX_RELEASE(pResponseValues);
  2443. HX_RELEASE(pResponseHeaders);
  2445.     }
  2447.     HX_RELEASE(pCCF);
  2448. }
  2449. HX_DELETE(pMessage);
  2450. return TRUE;
  2451.     }
  2452.     HX_DELETE(pMessage);
  2453.     return FALSE;
  2454. }
  2456. #define CLOAKED_WWW_AUTHENTICATION_RECENT_KEY "authentication.http.realm.recent"
  2457. #define CLOAKED_PROXY_AUTHENTICATION_RECENT_KEY "proxy-authentication.http.realm.recent"
  2459. void
  2460. HXClientCloakedTCPSocket::ObtainAuthenticationInformation(CHXString& strAuth)
  2461. {
  2462.     IHXBuffer* pBuffer = NULL;
  2464.     CHXString key("no-authentication-information");
  2466.     CHXString recentAuthRealmInfo;
  2467.     CHXString recentProxyAuthRealmInfo;
  2469.     IHXBuffer* pHeaderBuffer = NULL;
  2470.     
  2471.     HX_RESULT theErr = HXR_OK;
  2473.     IHXRegistry* pRegistry = NULL;
  2474.     
  2475.     m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);
  2476.     HX_ASSERT(pRegistry);
  2477.     
  2478.     if (!pRegistry) return;
  2479.     
  2480.     theErr = pRegistry->GetStrByName(CLOAKED_WWW_AUTHENTICATION_RECENT_KEY, pHeaderBuffer);
  2481.     if (SUCCEEDED(theErr))
  2482.     {
  2483. HX_ASSERT(pHeaderBuffer);
  2484. recentAuthRealmInfo = CHXString((const char*)pHeaderBuffer->GetBuffer(), pHeaderBuffer->GetSize());
  2485. HX_RELEASE(pHeaderBuffer);
  2486.     }
  2488.     theErr = pRegistry->GetStrByName(CLOAKED_PROXY_AUTHENTICATION_RECENT_KEY, pHeaderBuffer);
  2489.     if (SUCCEEDED(theErr))
  2490.     {
  2491. HX_ASSERT(pHeaderBuffer);
  2492. recentProxyAuthRealmInfo = CHXString((const char*)pHeaderBuffer->GetBuffer(), pHeaderBuffer->GetSize());
  2493. HX_RELEASE(pHeaderBuffer);
  2494.     }
  2496.     key = "proxy-authentication.http:";
  2497.     key += m_pProxyHostName;
  2498.     key += ":";
  2499.     key += recentProxyAuthRealmInfo;
  2501.     if (HXR_OK == pRegistry->GetStrByName((const char*)key, pBuffer) )
  2502.     {
  2503. if (pBuffer)
  2504. {
  2505.     CHXString authString((const char*)pBuffer->GetBuffer(), pBuffer->GetSize());
  2507.     strAuth = "Proxy-Authorization: ";
  2508.     strAuth += (const char*)authString;
  2509. }
  2510.     }
  2511.     HX_RELEASE(pBuffer);
  2513.     HX_RELEASE(pRegistry);
  2514. }
  2516. HX_RESULT
  2517. HXClientCloakedTCPSocket::HandleAuthentication(IHXRequest* pRequest, HTTPResponseMessage* pMessage,
  2518. const char* pHost, const char* pProxyHost)
  2519. {
  2520.     HX_RESULT   ResultStatus = HXR_OK;
  2521.     UINT32      ulAltURL = 0;
  2522.     CHXString   sConnection;
  2523.     IHXValues* pNewHeaders = NULL;
  2526.     // xxxbobclark The reason we need to extract the IHXPlayer is that
  2527.     // later on the authenticator smart pointer needs a context which knows
  2528.     // about authentication conversations. this->m_pContext does not know
  2529.     // about the authentication conversation. That's why we have to iterate
  2530.     // through the players looking for someone. Sheesh.
  2532.     if (!pRequest)
  2533.     {
  2534.         return HXR_UNEXPECTED;
  2535.     }
  2537.     HX_RESULT retVal = HXR_OK;
  2538.     IHXRegistry* pRegistry = NULL;
  2539.     retVal = m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);
  2540.     if (SUCCEEDED(retVal))
  2541.     {
  2542. IHXCommonClassFactory* pCCF;
  2543. retVal = m_pCloakContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCCF);
  2545. if (SUCCEEDED(retVal))
  2546. {
  2547.     IHXValues* pResponseHeaders = NULL;
  2548.     
  2549.     HX_ASSERT(pRequest);
  2550.     if (HXR_OK == pRequest->GetResponseHeaders(pResponseHeaders))
  2551.     {
  2552. IHXBuffer* pServerHeaderBuffer = NULL;
  2554. HX_ASSERT(pHost);
  2555. if (pHost)
  2556. {
  2557.     retVal = pCCF->CreateInstance(CLSID_IHXBuffer,
  2558.      (void**)&pServerHeaderBuffer);
  2559.     if (SUCCEEDED(retVal))
  2560.     {
  2561. UINT32 ulHTTPStatus = atoi(pMessage->errorCode());
  2562. if (ulHTTPStatus == 407 && pProxyHost)
  2563. {
  2564.     pServerHeaderBuffer->Set((UCHAR*)pProxyHost, strlen(pProxyHost)+1);
  2565. }
  2566. else
  2567. {
  2568.     pServerHeaderBuffer->Set((UCHAR*)pHost, strlen(pHost)+1);
  2569. }
  2570. pResponseHeaders->SetPropertyCString("_server", pServerHeaderBuffer);
  2571. HX_RELEASE(pServerHeaderBuffer);
  2572.     }
  2573. }
  2575.     // Add the protocol to the response headers because TLC needs it
  2576.     IHXBuffer* pProtocol = NULL;
  2577.     if (SUCCEEDED(pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pProtocol)))
  2578.     {
  2579. pProtocol->Set((UCHAR*)"http", strlen("http") + 1);
  2580. pResponseHeaders->SetPropertyCString("_protocol", pProtocol);
  2581. HX_RELEASE(pProtocol);
  2582.     }
  2583.     }
  2585.     if (!spClientAuthConversationAuthenticator.IsValid())
  2586.     {
  2587. DECLARE_SMART_POINTER_UNKNOWN spUnknownAuthenticator;
  2588. DECLARE_SMART_POINTER
  2589. (
  2590. IHXObjectConfiguration
  2591. ) spObjectConfigurationAuthenticator;
  2592. DECLARE_SMART_POINTER
  2593. (
  2594. IHXCommonClassFactory
  2595. ) spCommonClassFactoryHXCore;
  2597. spCommonClassFactoryHXCore = m_pCloakContext;
  2599. // Starting conversation
  2600. ResultStatus = spCommonClassFactoryHXCore->CreateInstance
  2601. (
  2602. CLSID_CHXClientAuthenticator,
  2603. (void**)&spUnknownAuthenticator
  2604. );
  2606. if ( SUCCEEDED(ResultStatus) && spUnknownAuthenticator.IsValid() )
  2607. {
  2608.     spObjectConfigurationAuthenticator = 
  2609. (
  2610. spUnknownAuthenticator
  2611. );
  2613.     spObjectConfigurationAuthenticator->SetContext(m_pCloakContext);
  2615.     spClientAuthConversationAuthenticator = 
  2616. (
  2617. spUnknownAuthenticator
  2618. );
  2619. }
  2620.     }
  2622.     if ( spClientAuthConversationAuthenticator.IsValid()
  2623. && !spClientAuthConversationAuthenticator->IsDone() )
  2624.     {
  2625. HX_ASSERT(pRequest);
  2626. if (pRequest)
  2627. {
  2628.     ResultStatus = 
  2629. (
  2630. spClientAuthConversationAuthenticator->MakeResponse
  2631. (
  2632. this,
  2633. pRequest
  2634. )
  2635. );
  2637. // Flow continues in ResponseReady()
  2638. }
  2639. else
  2640. {
  2641.     // Auth Failed!
  2642.     spClientAuthConversationAuthenticator->Authenticated(FALSE);
  2643.     ResponseReady(HXR_NOT_AUTHORIZED, pRequest);
  2644. }
  2645.     }
  2647.     HX_RELEASE(pCCF);
  2648. }
  2650. HX_RELEASE(pRegistry);
  2651.     }
  2652.     
  2654.     return ResultStatus;
  2655. }
  2657. // IHXClientAuthResponse
  2658. STDMETHODIMP 
  2659. HXClientCloakedTCPSocket::ResponseReady( HX_RESULT ResultStatus, IHXRequest* pRequestResponse)
  2660. {
  2661.     // now if it's an OK result, then I can use pRequestResponse in a new get.
  2663.     if (FAILED(ResultStatus))
  2664.     {
  2665. return ResultStatus;
  2666.     }
  2668.     IHXValues* pHeaders = NULL;
  2670.     HX_ASSERT(pRequestResponse);
  2671.     if (HXR_OK == pRequestResponse->GetRequestHeaders(pHeaders))
  2672.     {
  2673. const char* pName;
  2674. IHXBuffer* pBuf;
  2675. HX_RESULT res = pHeaders->GetFirstPropertyCString(pName, pBuf);
  2676. while (res == HXR_OK)
  2677. {
  2679.     if (!strcasecmp(pName, "Proxy-Authorization"))
  2680.     {
  2681. HX_RESULT retVal = HXR_OK;
  2682. IHXRegistry* pRegistry = NULL;
  2683. retVal = m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);
  2685. IHXCommonClassFactory* pCCF = NULL;
  2687. if (m_pContext)
  2688. {
  2689.     m_pContext->AddRef();
  2691.     // get the CCF
  2692.     m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCCF);
  2693. }
  2695. if (SUCCEEDED(retVal))
  2696. {
  2697.     IHXBuffer* pBuffer = NULL;
  2698.     retVal = pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer);
  2699.     UINT32 regid = 0;
  2700.     
  2701.     HX_ASSERT(SUCCEEDED(retVal));
  2702.     if (SUCCEEDED(retVal))
  2703.     {
  2704. IHXBuffer* pHeaderBuffer = NULL;
  2706. CHXString key;
  2707. CHXString recentRealmInfo = "";
  2709. if (!strcasecmp(pName, "Proxy-Authorization"))
  2710. {
  2711.     key = "proxy-authentication.http:";
  2712.     retVal = pRegistry->GetStrByName(CLOAKED_PROXY_AUTHENTICATION_RECENT_KEY,
  2713. pHeaderBuffer);
  2715.     if (SUCCEEDED(retVal))
  2716.     {
  2717. HX_ASSERT(pHeaderBuffer);
  2718. recentRealmInfo = CHXString((const char*)pHeaderBuffer->GetBuffer(), pHeaderBuffer->GetSize());
  2719. HX_RELEASE(pHeaderBuffer);
  2720.     }
  2722. key += m_pProxyHostName;
  2723. }
  2725. key += ":";
  2726. key += recentRealmInfo;
  2728. HX_ASSERT(!key.IsEmpty());
  2729. pBuffer->Set(pBuf->GetBuffer(), pBuf->GetSize());
  2731. regid = pRegistry->GetId((const char*)key);
  2732. if (!regid)
  2733. {
  2734.     pRegistry->AddStr((const char*)key, pBuffer);
  2735. }
  2736. else
  2737. {
  2738.     pRegistry->SetStrByName((const char*)key, pBuffer);
  2739. }
  2741. HX_RELEASE(pBuffer);
  2742. HX_RELEASE(pHeaderBuffer);
  2743.     }
  2744. }
  2745. HX_RELEASE(pCCF);
  2746.     }
  2747.     HX_RELEASE(pBuf);
  2749.     res = pHeaders->GetNextPropertyCString(pName, pBuf);
  2750. }
  2751.     }
  2753.     CleanUpAndReInitializeStuff();
  2755.     return HXR_OK;
  2756. }
  2758. STDMETHODIMP
  2759. HXClientCloakedTCPSocket::HandleCallback(INT32 theCommand, HX_RESULT theError)
  2760. {
  2761.     if (!m_bInDestructor)
  2762.     {
  2763. m_pMutex->Lock();
  2765. DoGetWrite();
  2766. DoPutWrite();
  2767. DoRead();
  2769. m_pMutex->Unlock();
  2770.     }
  2772.     return HXR_OK;
  2773. }
  2775. HXClientCloakedTCPSocket::HTTPCloakTCPResponse::HTTPCloakTCPResponse(HXClientCloakedTCPSocket* pOwner, BOOL bIsRead) :
  2776.      m_pOwner(pOwner)
  2777.     ,m_lRefCount(0) 
  2778.     ,m_bIsRead(bIsRead)
  2779. {
  2780. }
  2782. HXClientCloakedTCPSocket::HTTPCloakTCPResponse::~HTTPCloakTCPResponse()
  2783. {
  2784. }
  2786. /*
  2787.  *  IUnknown methods
  2788.  */
  2790. /////////////////////////////////////////////////////////////////////////
  2791. //  Method:
  2792. // IUnknown::QueryInterface
  2793. //  Purpose:
  2794. // Implement this to export the interfaces supported by your 
  2795. // object.
  2796. //
  2797. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::QueryInterface(REFIID riid, void** ppvObj)
  2798. {
  2799.     QInterfaceList qiList[] =
  2800.         {
  2801.             { GET_IIDHANDLE(IID_IHXTCPResponse), (IHXTCPResponse*)this },
  2802.             { GET_IIDHANDLE(IID_IHXInterruptSafe), (IHXInterruptSafe*)this },
  2803.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXTCPResponse*)this },
  2804.         };
  2805.     
  2806.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  2807. }
  2809. /////////////////////////////////////////////////////////////////////////
  2810. //  Method:
  2811. // IUnknown::AddRef
  2812. //  Purpose:
  2813. // Everyone usually implements this the same... feel free to use
  2814. // this implementation.
  2815. //
  2816. STDMETHODIMP_(ULONG32) HXClientCloakedTCPSocket::HTTPCloakTCPResponse::AddRef()
  2817. {
  2818.     return InterlockedIncrement(&m_lRefCount);
  2819. }
  2821. /////////////////////////////////////////////////////////////////////////
  2822. //  Method:
  2823. // IUnknown::Release
  2824. //  Purpose:
  2825. // Everyone usually implements this the same... feel free to use
  2826. // this implementation.
  2827. //
  2828. STDMETHODIMP_(ULONG32) HXClientCloakedTCPSocket::HTTPCloakTCPResponse::Release()
  2829. {
  2830.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2831.     {
  2832.         return m_lRefCount;
  2833.     }
  2835.     delete this;
  2836.     return 0;
  2837. }
  2840. /*
  2841.  * IHXTCPResponse methods
  2842.  */
  2844. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::ConnectDone(HX_RESULT status)
  2845. {
  2847.     // xxxbobclark this authentication kludge is to ensure that layers "above" me
  2848.     // never have to care whether they're using an authenticated proxy or not.
  2849.     // So since this cloaked socket has already called its owner with ConnectDone
  2850.     // messages, it won't resend those... rather, it will reconstruct the same state
  2851.     // that the above layer expects.
  2852.     // So we set it up so the next ReadDone will work through the proxy and pass
  2853.     // through to the above layer and everything should be cool.
  2855.     if (m_pOwner->m_bInAuthenticationKludge)
  2856.     {
  2857. m_pOwner->m_bInAuthenticationKludge = FALSE;
  2859. if (m_bIsRead)
  2860. {
  2861.     m_pOwner->PreparePostMessage(NULL, 0);
  2862.     m_pOwner->DoPutWrite();
  2864.     m_pOwner->PrepareGetMessage();
  2865.     m_pOwner->DoGetWrite();
  2866. }
  2868. m_pOwner->Read(4096);
  2871. m_pOwner->m_bConnected = TRUE;
  2872. return HXR_OK;
  2873.     }
  2875.     if (m_bIsRead)
  2876.     {
  2877. m_pOwner->GetConnectDone(status == HXR_OK ? TRUE : FALSE);/*m_pGetCtrl*/
  2878.     }
  2879.     else
  2880.     {
  2881. m_pOwner->PutConnectDone(status == HXR_OK ? TRUE : FALSE);/*m_pPutCtrl*/
  2882.     }
  2884.     return HXR_OK;
  2885. }
  2888. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::ReadDone( HX_RESULT   status,
  2889. IHXBuffer* pBuffer)
  2890. {
  2891.     if (m_bIsRead)
  2892.     {
  2893. m_pOwner->DoGetReadDone(status, pBuffer); /*m_pGetCtrl*/
  2894.     }
  2895.     else 
  2896.     {
  2897. m_pOwner->DoPutReadDone(status, pBuffer); /*m_pPutCtrl*/
  2898.     }
  2900.     return HXR_OK;
  2901. }
  2903. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::WriteReady(HX_RESULT status)
  2904. {
  2905.     if (m_bIsRead)
  2906.     {
  2907. m_pOwner->m_pMutex->Lock();
  2908. m_pOwner->DoGetWrite(); /*m_pGetCtrl*/
  2909. m_pOwner->m_pMutex->Unlock();
  2910.     }
  2911.     else
  2912.     {
  2913. m_pOwner->m_bPutWantWritePending = FALSE;
  2914. m_pOwner->m_pMutex->Lock();
  2915. m_pOwner->DoPutWrite(); /*m_pPutCtrl*/
  2916. m_pOwner->m_pMutex->Unlock();
  2917.     }
  2919.     return HXR_OK;
  2920. }
  2922. STDMETHODIMP HXClientCloakedTCPSocket::HTTPCloakTCPResponse::Closed(HX_RESULT status)
  2923. {
  2924.     return HXR_OK;
  2925. }
  2927. #ifdef _MACINTOSH
  2929. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::MacCloakedTCPSocketAuthenticationCallback (
  2930. HXClientCloakedTCPSocket* pSocket)
  2931.     : m_lRefCount(0)
  2932.     , m_ulPendingCallbackID(NULL)
  2933.     , m_pSocket(pSocket)
  2934.     , m_Status(HXR_OK)
  2935.     , m_pInBuffer(NULL)
  2936. {
  2937. }
  2939. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::~MacCloakedTCPSocketAuthenticationCallback()
  2940. {
  2941. }
  2943. STDMETHODIMP
  2944. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::QueryInterface(
  2945. REFIID riid, void** ppvObj)
  2946. {
  2947.     QInterfaceList qiList[] =
  2948.         {
  2949.             { GET_IIDHANDLE(IID_IHXCallback), (IHXCallback*)this },
  2950.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXCallback*)this },
  2951.         };
  2952.     
  2953.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  2954. }
  2956. STDMETHODIMP_(ULONG32)
  2957. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::AddRef()
  2958. {
  2959.     return InterlockedIncrement( &m_lRefCount );
  2960. }
  2962. STDMETHODIMP_(ULONG32)
  2963. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::Release()
  2964. {
  2965.     if ( InterlockedDecrement( &m_lRefCount ) > 0 )
  2966.     {
  2967. return m_lRefCount;
  2968.     }
  2969.     
  2970.     delete this;
  2971.     return 0;
  2972. }
  2974. STDMETHODIMP
  2975. HXClientCloakedTCPSocket::MacCloakedTCPSocketAuthenticationCallback::Func()
  2976. {
  2977.     m_ulPendingCallbackID = NULL;
  2978.     
  2979.     if (m_pInBuffer)
  2980.     {
  2981. m_pSocket->DoGetReadDone(m_Status, m_pInBuffer);
  2982. HX_RELEASE(m_pInBuffer);
  2983.     }
  2984.     
  2985.     return HXR_OK;
  2986. }
  2988. #endif