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

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

Symbian

开发平台：

Visual C++

hxnetapi.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxnetapi.cpp,v 1.30.8.1 2004/07/09 02:09:08 hubbe 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 ***** */
  50. #include "hxtypes.h"
  51. #include "hxresult.h"
  52. #include "hxcom.h"
  53. #include "hxcomm.h"
  54. #include "hxprefs.h"
  55. #include "hxerror.h"
  57. #if defined(_MACINTOSH)
  58. #include "hx_moreprocesses.h"
  59. #endif /* _MACINTOSH. */
  61. #include "ihxpckts.h"
  62. #include "hxfiles.h"
  63. #include "chxpckts.h"
  64. #include "hxengin.h"
  65. #include "hxpnets.h"
  67. #include "hxtick.h"
  68. #include "hxstrutl.h"
  70. #include "chxuuid.h"
  71. #include "rtsputil.h"
  73. #include "hxslist.h"
  74. #include "cbqueue.h"
  75. #include "growingq.h"
  76. #include "dbcs.h"
  77. #include "conn.h"
  78. #include "hxmarsh.h"
  79. #include "hxthread.h"
  80. #include "hxcore.h"
  82. #if defined (_UNIX)
  83. #include "unix_net.h"
  84. #include "platform/unix/hxsignal.h"
  85. #elif defined (_WIN32) || defined (_WINDOWS)
  86. #include "win_net.h"
  87. #elif defined(__TCS__)
  88. #include "platform/tm1/tm1_net.h"
  89. #elif defined (_MACINTOSH)
  90. #ifndef _MAC_MACHO
  91. #include "OpenTptInternet.h" //for AF_INET
  92. #endif
  93. #include "mac_net.h"
  94. #include "macsockets.h"
  95. #endif
  97. #include "threngin.h"
  99. #include "netbyte.h"
  100. #include "hxnetapi.h"
  101. #include "hxnetutil.h"
  103. #if defined(HELIX_FEATURE_HTTPCLOAK)
  104. #include "hxcloakedtcp.h"
  105. #endif /* HELIX_FEATURE_HTTPCLOAK */
  107. #include "hxheap.h"
  109. #include "hxprefs.h"
  110. #include "hxprefutil.h"
  112. #ifdef _DEBUG
  113. #undef HX_THIS_FILE
  114. static const char HX_THIS_FILE[] = __FILE__;
  115. #endif
  117. #ifdef _WIN16
  118. extern HINSTANCE g_hInstance;       // initialized inside DLLMAIN.CPP(core.dll)
  119. #endif
  121. const int UDP_CHUNK_SIZE = 1024;
  123. #define QUEUE_START_SIZE    512
  125. #if defined _WINDOWS && !defined _WIN32  // for win16
  126. #define DESIRED_RCV_BUFSIZE 0xFFFF  // ~ 525 KBits
  127. #else
  128. #define DESIRED_RCV_BUFSIZE 0x0002FFFF // ~ 1.5 MBits
  129. #endif //defined _WINDOWS && !defined _WIN32
  131. #ifdef _WINCE
  132. #define SCHED_GRANULARITY 10
  133. #else
  134. #define SCHED_GRANULARITY 50
  135. #endif
  137. // same for all the platforms...may need to tweak it, if necessary
  138. #define MAX_ITERATION_COUNT 200
  140. #if defined( _UNIX )
  141. BOOL ReadAsyncDNSPref( IUnknown* pContext )
  142. {
  143.     static BOOL bNoAsyncDNS  = FALSE;
  144.     static BOOL bNeedToLoad  = TRUE;
  146.     if( bNeedToLoad && NULL!=pContext)
  147.     {
  148.         IHXPreferences* pPreferences = NULL;
  150.         bNeedToLoad = FALSE;
  151.         pContext->QueryInterface(IID_IHXPreferences, (void **)&pPreferences);
  153.         IHXBuffer *pBuffer = NULL;
  154.         if( NULL!=pPreferences )
  155.         {
  156.             pPreferences->ReadPref("NoAsyncDNS", pBuffer);
  157.             if (pBuffer)
  158.             {
  159.                 bNoAsyncDNS = (atoi((const char*)pBuffer->GetBuffer()) == 1);
  160.                 HX_RELEASE(pBuffer);
  161.             }
  162.             HX_RELEASE( pPreferences );
  163.         } // NULL!=pPreferences
  164.     }//bNeedToLoad && NULL!=pContext
  166.     return bNoAsyncDNS;
  167. }
  169. BOOL ReadThreadedDNSPref( IUnknown* pContext )
  170. {
  171.     static BOOL bThreadedDNS = TRUE;
  172.     static BOOL bNeedToLoad  = TRUE;
  174.     if( bNeedToLoad && NULL!=pContext)
  175.     {
  176.         IHXPreferences* pPreferences = NULL;
  178.         bNeedToLoad = FALSE;
  179.         pContext->QueryInterface(IID_IHXPreferences, (void **)&pPreferences);
  181.         IHXBuffer *pBuffer = NULL;
  182.         if( NULL!=pPreferences )
  183.         {
  184.             pPreferences->ReadPref("ThreadedDNS", pBuffer);
  185.             if (pBuffer)
  186.             {
  187.                 bThreadedDNS = (atoi((const char*)pBuffer->GetBuffer()) == 1);
  188.                 HX_RELEASE(pBuffer);
  189.             }
  190.             else
  191.             {
  192.                 //XXXGFW HACK!! REMOVE AFTER RNC
  193.                 //Pref was not found. It defaults to ON now so lets see if we
  194.                 //are running under a player. If not, turn it off.
  195.                 IHXClientEngine* pEngine = NULL;
  196.                 if(HXR_OK == pContext->QueryInterface(IID_IHXClientEngine, (void**)&pEngine))
  197.                 {
  198.                     //We have client Engine. Do nothing.
  199.                     HX_RELEASE( pEngine );
  200.                 }
  201.                 else
  202.                 {
  203.                     //We don't have a client engine. Turn off threading...
  204.                     bThreadedDNS = FALSE;
  205.                 }
  206.             }
  208.             HX_RELEASE( pPreferences );
  209.         } // NULL!=pPreferences
  210.     }//bNeedToLoad && NULL!=pContext
  212.     return bThreadedDNS;
  213. }
  215. #endif
  217. #if !defined(HELIX_CONFIG_NOSTATICS)
  218. UINT16 HXNetworkServices::z_muNumDriverInstance = 0;
  219. #else
  220. #include "globals/hxglobals.h"
  221. const UINT16 HXNetworkServices::z_muNumDriverInstance = 0;
  222. #endif
  224. /* HXNetworkServices */
  225. HXNetworkServices::HXNetworkServices(IUnknown* pContext)
  226. {
  227.     m_bNeedToCleanupDrivers = FALSE;
  228.     m_lRefCount = 0;
  229.     m_pContext = pContext;
  231.     if (m_pContext)
  232.     {
  233. m_pContext->AddRef();
  234.     }
  235. }
  237. HXNetworkServices::~HXNetworkServices()
  238. {
  239.     Close();
  240. }
  242. STDMETHODIMP HXNetworkServices::QueryInterface(REFIID riid, void** ppvObj)
  243. {
  244.     QInterfaceList qiList[] =
  245.         {
  246.             { GET_IIDHANDLE(IID_IHXNetworkServices), (IHXNetworkServices*)this },
  247.             { GET_IIDHANDLE(IID_IHXNetworkInterfaceEnumerator), (IHXNetworkInterfaceEnumerator*)this },
  248. #if defined(HELIX_FEATURE_HTTPCLOAK)
  249.             { GET_IIDHANDLE(IID_IHXCloakedNetworkServices), (IHXCloakedNetworkServices*)this },
  250. #endif /* HELIX_FEATURE_HTTPCLOAK */
  251.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXNetworkServices*)this },
  252.         };
  254.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  255. }
  257. STDMETHODIMP_(ULONG32) HXNetworkServices::AddRef()
  258. {
  259.     return InterlockedIncrement(&m_lRefCount);
  260. }
  262. STDMETHODIMP_(ULONG32) HXNetworkServices::Release()
  263. {
  264.     if (InterlockedDecrement(&m_lRefCount) > 0)
  265.     {
  266.         return m_lRefCount;
  267.     }
  269.     delete this;
  270.     return 0;
  271. }
  273. void
  274. HXNetworkServices::UseDrivers()
  275. {
  276.     if (!m_bNeedToCleanupDrivers)
  277.     {
  278. m_bNeedToCleanupDrivers = TRUE;
  280. #if defined(HELIX_CONFIG_NOSTATICS)
  281. UINT16& z_muNumDriverInstance = (UINT16&)
  282.     HXGlobalInt16::Get(&HXNetworkServices::z_muNumDriverInstance);
  283. #endif
  284. z_muNumDriverInstance++;
  285.     }
  286. }
  288. void
  289. HXNetworkServices::Close()
  290. {
  291.     HX_RELEASE(m_pContext);
  293.     if (m_bNeedToCleanupDrivers)
  294.     {
  295. m_bNeedToCleanupDrivers = FALSE;
  297. #if defined(HELIX_CONFIG_NOSTATICS)
  298. UINT16& z_muNumDriverInstance = (UINT16&)
  299.     HXGlobalInt16::Get(&HXNetworkServices::z_muNumDriverInstance);
  300. #endif
  302. z_muNumDriverInstance--;
  304. if (z_muNumDriverInstance == 0)
  305. {
  306. #if defined(THREADS_SUPPORTED)
  307.             ThreadEngine::DestroyThreadEngine();
  308. #elif defined(_UNIX_THREADED_NETWORK_IO)
  309.             if( ReadNetworkThreadingPref((IUnknown*)m_pContext) )
  310.                 ThreadEngine::DestroyThreadEngine();
  311. #endif
  312.     conn::close_drivers(NULL);
  313. }
  314.     }
  315. }
  317. STDMETHODIMP
  318. HXNetworkServices::CreateTCPSocket(IHXTCPSocket** ppTCPSocket)
  319. {
  320.     *ppTCPSocket = new HXTCPSocket(m_pContext, this);
  321.     if (*ppTCPSocket == NULL)
  322.     {
  323. return HXR_OUTOFMEMORY;
  324.     }
  326.     (*ppTCPSocket)->AddRef();
  327.     return HXR_OK;
  328. }
  330. STDMETHODIMP
  331. HXNetworkServices::CreateUDPSocket(IHXUDPSocket** ppUDPSocket)
  332. {
  333.     *ppUDPSocket = new HXUDPSocket(m_pContext, this);
  334.     if (*ppUDPSocket == NULL)
  335.     {
  336. return HXR_OUTOFMEMORY;
  337.     }
  339.     (*ppUDPSocket)->AddRef();
  340.     return HXR_OK;
  341. }
  343. STDMETHODIMP
  344. HXNetworkServices::CreateListenSocket(IHXListenSocket** ppListenSocket)
  345. {
  346.     *ppListenSocket = new HXListenSocket(m_pContext, this);
  347.     if (*ppListenSocket == NULL)
  348.     {
  349. return HXR_OUTOFMEMORY;
  350.     }
  352.     (*ppListenSocket)->AddRef();
  353.     return HXR_OK;
  354. }
  356. STDMETHODIMP
  357. HXNetworkServices::CreateResolver(IHXResolver** ppResolver)
  358. {
  359.     *ppResolver = new HXResolver(this, m_pContext);
  360.     if(*ppResolver == NULL)
  361.     {
  362. return HXR_OUTOFMEMORY;
  363.     }
  364.     (*ppResolver)->AddRef();
  365.     return HXR_OK;
  366. }
  368. STDMETHODIMP
  369. HXNetworkServices::CreateClientCloakedSocket(IHXTCPSocket** ppTCPSocket)
  370. {
  371. #if defined(HELIX_FEATURE_HTTPCLOAK)
  372.     *ppTCPSocket = new HXClientCloakedTCPSocket(m_pContext);
  373.     if (*ppTCPSocket == NULL)
  374.     {
  375. return HXR_OUTOFMEMORY;
  376.     }
  378.     (*ppTCPSocket)->AddRef();
  379.     return HXR_OK;
  380. #else
  381.     return HXR_NOTIMPL;
  382. #endif /* HELIX_FEATURE_HTTPCLOAK */
  383. }
  385. STDMETHODIMP
  386. HXNetworkServices::CreateServerCloakedSocket(IHXListenSocket** ppListenSocket)
  387. {
  388.     return HXR_NOTIMPL;
  389. }
  391. /* IHXNetworkInterfaceEnumerator */
  392. STDMETHODIMP
  393. HXNetworkServices::EnumerateInterfaces
  394.     (REF(UINT32*) pulInterfaces, REF(UINT32) ulNumInterfaces)
  395. {
  396.     return conn::EnumerateInterfaces(pulInterfaces, ulNumInterfaces);
  397. }
  399. /* HXResolver */
  400. HXResolver::HXResolver(HXNetworkServices* pNetworkServices):
  401.      m_lRefCount(0)
  402.     ,m_pCallback(0)
  403.     ,m_pResp(0)
  404.     ,m_bResolverPending(FALSE)
  405.     ,m_pData(0)
  406.     ,m_pNetworkServices(NULL)
  407. {
  408.     m_pNetworkServices = pNetworkServices;
  409.     m_pNetworkServices->AddRef();
  410. }
  412. HXResolver::HXResolver( HXNetworkServices* pNetworkServices,
  413.                           IUnknown*           pContext):
  414.      m_lRefCount(0)
  415.     ,m_pCallback(0)
  416.     ,m_pResp(0)
  417.     ,m_bResolverPending(FALSE)
  418.     ,m_pData(0)
  419.     ,m_pNetworkServices(NULL)
  420.     ,m_pContext( pContext )
  421. {
  422.     m_pNetworkServices = pNetworkServices;
  423.     m_pNetworkServices->AddRef();
  424. }
  426. HXResolver::~HXResolver()
  427. {
  428.     if (m_pData)
  429.     {
  430. m_pData->done();
  431. m_pData->Release();
  432. m_pData = 0;
  433.     }
  435.     if (m_pCallback)
  436.     {
  437. delete m_pCallback;
  438. m_pCallback = 0;
  439.     }
  441.     if (m_pResp)
  442.     {
  443. m_pResp->Release();
  444. m_pResp = 0;
  445.     }
  447. #if defined( _WIN32 ) || defined( _WINDOWS )
  448.     win_net::ReleaseWinsockUsage(this);
  449. #endif
  450.     HX_RELEASE(m_pNetworkServices);
  451. }
  453. STDMETHODIMP
  454. HXResolver::QueryInterface(REFIID riid, void** ppvObj)
  455. {
  456.     QInterfaceList qiList[] =
  457.         {
  458.             { GET_IIDHANDLE(IID_IHXResolver), (IHXResolver*)this },
  459.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXResolver*)this },
  460.         };
  462.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  463. }
  465. STDMETHODIMP_(ULONG32) HXResolver::AddRef()
  466. {
  467.     return InterlockedIncrement(&m_lRefCount);
  468. }
  470. STDMETHODIMP_(ULONG32) HXResolver::Release()
  471. {
  472.     if (InterlockedDecrement(&m_lRefCount) > 0)
  473.     {
  474.         return m_lRefCount;
  475.     }
  477.     delete this;
  478.     return 0;
  479. }
  481. STDMETHODIMP HXResolver::Init(IHXResolverResponse* pResp)
  482. {
  483.     if (!pResp)
  484.     {
  485. return HXR_UNEXPECTED;
  486.     }
  488.     if (m_pResp)
  489.     {
  490. m_pResp->Release();
  491. m_pResp = 0;
  492.     }
  494.     m_pResp = pResp;
  495.     m_pResp->AddRef();
  496.     return HXR_OK;
  497. }
  499. STDMETHODIMP HXResolver::GetHostByName(const char* pHostName)
  500. {
  501.     HX_RESULT theErr = HXR_OK;
  503.     if (!pHostName || m_bResolverPending)
  504.     {
  505. return HXR_UNEXPECTED;
  506.     }
  508.     if (!m_pCallback)
  509.     {
  510. m_pCallback = new HXResolverCallback;
  511. if (!m_pCallback)
  512. {
  513.     return HXR_OUTOFMEMORY;
  514. }
  515. m_pCallback->m_pContext = this;
  516.     }
  518.     /* Is this the first time we are calling gethostbyname */
  519.     if (!m_pData)
  520.     {
  521. #if defined( _WIN32 ) || defined( _WINDOWS )
  522. // Have we been able to load and initialize the winsock stuff yet?
  523. if (!win_net::IsWinsockAvailable(this))
  524. {
  525.     return HXR_FAIL; // HXR_GENERAL_NONET;
  526. }
  527. #endif
  528. m_pNetworkServices->UseDrivers();
  530. conn::init_drivers(NULL);
  531.     }
  533.     if (m_pData)
  534.     {
  535. m_pData->done();
  536. m_pData->Release();
  537. m_pData = 0;
  538.     }
  540. #ifdef _UNIX
  541.     //This one has to be set before we create a new socket.
  542.     conn::SetNetworkThreadingPref( ReadNetworkThreadingPref((IUnknown*)m_pContext) );
  543.     conn::SetThreadedDNSPref( ReadThreadedDNSPref((IUnknown*)m_pContext) );
  544. #endif
  546.     m_pData = conn::new_socket(HX_UDP_SOCKET);
  547.     if (!m_pData)
  548.     {
  549. return HXR_OUTOFMEMORY;
  550.     }
  552. #ifdef _UNIX
  553.     m_pData->SetAsyncDNSPref( ReadAsyncDNSPref((IUnknown*)m_pContext) );
  554. #endif
  556.     // XXXAAK -- local addr binding stuff
  557.     theErr = m_pData->init(INADDR_ANY, 0);
  559.     m_pData->nonblocking();
  560.     m_pData->set_callback(m_pCallback);
  562. #ifdef _WINDOWS
  563. #if defined (_WIN32)
  564.     ULONG32 ulPlatformData = (ULONG32)GetModuleHandle(NULL);
  565. #elif defined (_WIN16)
  566.     ULONG32 ulPlatformData = (ULONG32)(int)g_hInstance;
  567. #endif
  568.     m_pData->SetWindowHandle(ulPlatformData);
  569. #endif /* defined (_WINDOWS) */
  571.     m_bResolverPending = TRUE;
  572. #ifndef _WINCE
  573.     m_pData->dns_find_ip_addr(pHostName);
  574. #else
  575.     // Only blocking DNS
  576.     m_pData->dns_find_ip_addr(pHostName, 1);
  577. #endif
  579.     return HXR_OK;
  580. }
  582. void
  583. HXResolver::DNSDone(BOOL bSuccess)
  584. {
  585.     ULONG32 ulAddr = 0;
  586.     BOOL bIsValid = TRUE;
  587.     char*   pDottedIP = 0;
  589.     m_bResolverPending = FALSE;
  591.     AddRef();
  593.     if (bSuccess)
  594.     {
  595. m_pData->dns_ip_addr_found(&bIsValid, &ulAddr);
  596. UINT32 ulHostAddr = DwToHost(ulAddr);
  597. m_pResp->GetHostByNameDone(HXR_OK, ulHostAddr);
  598.     }
  599.     else
  600.     {
  601. m_pResp->GetHostByNameDone(HXR_DNR, 0);
  602.     }
  604.     Release();
  605. }
  608. HX_RESULT
  609. HXResolver::HXResolverCallback::Func(NotificationType Type,
  610.        BOOL bSuccess, conn* pConn)
  611. {
  612.     if(m_pContext)
  613.     {
  614. switch (Type)
  615. {
  616. case DNS_NOTIFICATION:
  617.     m_pContext->DNSDone(bSuccess);
  618.     break;
  619. case READ_NOTIFICATION:
  620. case WRITE_NOTIFICATION:
  621. case CONNECT_NOTIFICATION:
  622. default:
  623.     break;
  624. }
  625.     }
  626.     return HXR_OK;
  627. }
  630. /* HXTCPSocket */
  631. HXTCPSocket::HXTCPSocket(IUnknown* pContext, HXNetworkServices* pNetworkServices):
  632.      m_lRefCount(0)
  633.     ,m_pTCPResponse(0)
  634.     ,m_pCtrl(0)
  635.     ,m_lForeignAddress(0)
  636.     ,m_nForeignPort(0)
  637.     ,m_bReadPending(FALSE)
  638.     ,m_nRequired(0)
  639.     ,mSendTCP(0)
  640.     ,mReceiveTCP(0)
  641.     ,m_pBuffer(0)
  642.     ,m_pCallback(0)
  643.     ,m_bConnected(FALSE)
  644.     ,m_bWantWritePending(FALSE)
  645.     ,m_bInitComplete(FALSE)
  646.     ,m_bWriteFlushPending(FALSE)
  647.     ,m_pScheduler(0)
  648.     ,m_pSchedulerReadCallback(0)
  649.     ,m_pSchedulerWriteCallback(0)
  650.     ,m_bInRead(FALSE)
  651.     ,m_bInWrite(FALSE)
  652.     ,m_bInDoRead(FALSE)
  653.     ,m_pInterruptState(NULL)
  654.     ,m_pResponseInterruptSafe(NULL)
  655.     ,m_pMutex(NULL)
  656.     ,m_bInDestructor(FALSE)
  657.     ,m_pNonInterruptReadCallback(NULL)
  658.     ,m_pNetworkServices(NULL)
  659.     ,m_pPreferences(NULL)
  660.     ,m_bReuseAddr(FALSE)
  661.     ,m_bReusePort(FALSE)
  662.     ,m_pContext(pContext)
  663.     ,m_bSecureSocket(FALSE)
  664. {
  665.     m_pNetworkServices = pNetworkServices;
  666.     m_pNetworkServices->AddRef();
  668. #ifdef _MACINTOSH
  669. m_pInterruptSafeMacWriteQueue = new InterruptSafeMacQueue();
  670. HX_ASSERT(m_pInterruptSafeMacWriteQueue != NULL);
  671. #endif
  673.     if (pContext)
  674.     {
  675. pContext->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  676. pContext->QueryInterface(IID_IHXInterruptState, (void**) &m_pInterruptState);
  677. pContext->QueryInterface(IID_IHXPreferences, (void**) &m_pPreferences);
  678.     }
  680.     if (m_pScheduler)
  681.     {
  682. m_pSchedulerReadCallback = new ScheduledSocketCallback(this, TRUE);
  683. m_pSchedulerReadCallback->AddRef();
  685. m_pSchedulerWriteCallback = new ScheduledSocketCallback(this, TRUE);
  686. m_pSchedulerWriteCallback->AddRef();
  688. m_pNonInterruptReadCallback = new ScheduledSocketCallback(this, FALSE);
  689. m_pNonInterruptReadCallback->AddRef();
  691. #ifdef _MACINTOSH
  692. m_pMacCommandCallback = new ScheduledSocketCallback(this, FALSE);
  693. m_pMacCommandCallback->AddRef();
  694. #endif
  695.     }
  697. #if defined(_UNIX) && defined(HELIX_FEATURE_IGNORE_SIGPIPE)
  698.         // When the connection is closed by the server, SIGPIPE will be thrown
  699.         // in next write() and terminates the program abruptly.
  700.         //
  701.         // In order to gracefully exists the program, it's recommended to:
  702.         // - ignore the SIGPIPE and
  703.         // - checks the return code(errno) from write()
  704.         //
  705.         // for read(), it simply returns 0 when the connection is closed.
  706.         SIGNAL(SIGPIPE, SIG_IGN);
  707. #endif /* _UNIX  && HELIX_FEATURE_IGNORE_SIGPIPE */
  709. #if defined(THREADS_SUPPORTED)
  710.     HXMutex::MakeMutex(m_pMutex);
  711. #elif defined(_UNIX_THREADED_NETWORK_IO)
  712.     if( ReadNetworkThreadingPref((IUnknown*)m_pContext) )
  713.         HXMutex::MakeMutex(m_pMutex);
  714.     else
  715.         HXMutex::MakeStubMutex(m_pMutex);
  716. #else
  717.     HXMutex::MakeStubMutex(m_pMutex);
  718. #endif
  719. }
  721. HXTCPSocket::~HXTCPSocket()
  722. {
  723.     m_bInDestructor = TRUE; // set it early
  724.     m_pMutex->Lock();
  726. #ifdef _MACINTOSH
  727. HX_DELETE(m_pInterruptSafeMacWriteQueue); // will release any objects in its nodes
  728. #endif
  730.    if (m_pSchedulerReadCallback)
  731. m_pSchedulerReadCallback->Unschedule(m_pScheduler);
  733.    if (m_pSchedulerWriteCallback)
  734. m_pSchedulerWriteCallback->Unschedule(m_pScheduler);
  736.    if (m_pNonInterruptReadCallback)
  737. m_pNonInterruptReadCallback->Unschedule(m_pScheduler);
  739. #ifdef _MACINTOSH
  740. if (m_pMacCommandCallback)
  741. m_pMacCommandCallback->Unschedule(m_pScheduler);
  742. #endif
  744.     /*
  745.      * XXX...While handling the m_pCtrl->done it's possible for the
  746.      *       DispatchMessage call in CancelSelect to cause an
  747.      *       asynchronous DoRead to occur. The resulting AddRef/Release
  748.      *       would cause this object to be deleted again, so to prevent
  749.      *       this we set the m_pCallback->m_pContext = 0
  750.      */
  752.    if (m_pCallback)
  753.     {
  754. m_pCallback->m_pContext = 0;
  755.     }
  757. //#ifndef _UNIX
  758.     /* XXXJR I feel certain this is related to the above comment somehow.
  759.      *       Deleting the ctrl here wreaks havoc on the encoder.
  760.      *       This is a bad solution, but I don't really know
  761.      *       what the right one is.  This at least prevents random crashes
  762.      *       in the encoder.
  763.      *
  764.      * XXXGH commented out the #ifndef because it was breaking my
  765.      *       connectionless control stuff
  766.      *
  767.      */
  768.     if (m_pCtrl)
  769.     {
  770. m_pCtrl->done();
  771. m_pCtrl->Release(); // A deleted (0xdddddddd) pointer was used here.
  772. m_pCtrl = 0;
  773.     }
  774. //#endif
  776.     HX_RELEASE(m_pTCPResponse);
  777.     HX_DELETE(m_pCallback);
  778.     HX_DELETE(mSendTCP);
  779.     HX_DELETE(mReceiveTCP);
  780.     HX_VECTOR_DELETE(m_pBuffer);
  782.     while (m_PendingWriteBuffers.GetCount() > 0)
  783.     {
  784. IHXBuffer* pBuffer =
  785.     (IHXBuffer*) m_PendingWriteBuffers.RemoveHead();
  786. pBuffer->Release();
  787.     }
  789.     if (m_pSchedulerReadCallback)
  790.     {
  791.      m_pSchedulerReadCallback->m_pSocket = NULL;
  792.      m_pSchedulerReadCallback->Release();
  793.      m_pSchedulerReadCallback = NULL;
  794.     }
  796.     if (m_pSchedulerWriteCallback)
  797.     {
  798.      m_pSchedulerWriteCallback->m_pSocket = NULL;
  799.      m_pSchedulerWriteCallback->Release();
  800.      m_pSchedulerWriteCallback = NULL;
  801.     }
  803.     if (m_pNonInterruptReadCallback)
  804.     {
  805.      m_pNonInterruptReadCallback->m_pSocket = NULL;
  806.      m_pNonInterruptReadCallback->Release();
  807.      m_pNonInterruptReadCallback = NULL;
  808.     }
  810. #ifdef _MACINTOSH
  811.    if (m_pMacCommandCallback)
  812.     {
  813. m_pMacCommandCallback->m_pSocket = NULL;
  814. m_pMacCommandCallback->Release();
  815. m_pMacCommandCallback = NULL;
  816.     }
  817. #endif
  819.     HX_RELEASE(m_pInterruptState);
  820.     HX_RELEASE(m_pResponseInterruptSafe);
  821.     HX_RELEASE(m_pScheduler);
  823.     m_pMutex->Unlock();
  824.     HX_DELETE(m_pMutex);
  826. #if defined( _WIN32 ) || defined( _WINDOWS )
  827.     win_net::ReleaseWinsockUsage(this);
  828. #endif
  830.     HX_RELEASE(m_pNetworkServices);
  831.     HX_RELEASE(m_pPreferences);
  832. }
  834. STDMETHODIMP HXTCPSocket::QueryInterface(REFIID riid, void** ppvObj)
  835. {
  836.     QInterfaceList qiList[] =
  837.         {
  838.             { GET_IIDHANDLE(IID_IHXTCPSocket), (IHXTCPSocket*)this },
  839.             { GET_IIDHANDLE(IID_IHXSetSocketOption), (IHXSetSocketOption*)this },
  840.             { GET_IIDHANDLE(IID_IHXTCPSecureSocket), (IHXTCPSecureSocket*)this },
  841.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXTCPSocket*)this },
  842.         };
  844.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  845. }
  847. STDMETHODIMP_(ULONG32) HXTCPSocket::AddRef()
  848. {
  849.     return InterlockedIncrement(&m_lRefCount);
  850. }
  852. STDMETHODIMP_(ULONG32) HXTCPSocket::Release()
  853. {
  854.     if (InterlockedDecrement(&m_lRefCount) > 0)
  855.     {
  856.         return m_lRefCount;
  857.     }
  858.     else if (m_lRefCount < 0)
  859.     {
  860.      // double delete
  861.      return 0;
  862.     }
  864.     delete this;
  865.     return 0;
  866. }
  868. STDMETHODIMP HXTCPSocket::Init(IHXTCPResponse* pTCPResponse)
  869. {
  870.     if (!pTCPResponse)
  871.     {
  872. return HXR_UNEXPECTED;
  873.     }
  875.     m_pTCPResponse = pTCPResponse;
  876.     m_pTCPResponse->AddRef();
  878.     m_pTCPResponse->QueryInterface(IID_IHXInterruptSafe,
  879.    (void**) &m_pResponseInterruptSafe);
  881.     // allocate TCP send and receive queue
  882.     mSendTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  883.     if (!mSendTCP || !mSendTCP->IsQueueValid())
  884.     {
  885. return HXR_OUTOFMEMORY;
  886.     }
  887.     mSendTCP->SetMaxSize(TCP_BUF_SIZE);
  889.     mReceiveTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  890.     if (!mReceiveTCP || !mReceiveTCP->IsQueueValid())
  891.     {
  892. return HXR_OUTOFMEMORY;
  893.     }
  894.     mReceiveTCP->SetMaxSize(TCP_BUF_SIZE);
  896.     m_pBuffer = new char[TCP_BUF_SIZE];
  897.     if (!m_pBuffer)
  898.     {
  899. return HXR_OUTOFMEMORY;
  900.     }
  902.     return HXR_OK;
  903. }
  905. STDMETHODIMP HXTCPSocket::SetResponse(IHXTCPResponse* pTCPResponse)
  906. {
  907.     m_pMutex->Lock();
  908.     HX_RELEASE(m_pTCPResponse);
  909.     m_pTCPResponse = pTCPResponse;
  910.     m_pTCPResponse->AddRef();
  912.     HX_RELEASE(m_pResponseInterruptSafe);
  913.     m_pTCPResponse->QueryInterface(IID_IHXInterruptSafe,
  914.    (void**) &m_pResponseInterruptSafe);
  915.     m_pMutex->Unlock();
  916.     return HXR_OK;
  917. }
  919. STDMETHODIMP HXTCPSocket::Bind(UINT32 ulLocalAddr, UINT16 nPort)
  920. {
  921.     UINT32 ulMaxBandwidth = 0;
  922.     BOOL bEnforceMaxBandwidth = TRUE;
  923.     BOOL        bLoadTest = FALSE;
  924.     IHXBuffer* pBuffer = NULL;
  926.     if (m_bInitComplete)
  927. return HXR_UNEXPECTED;
  929.     m_nLocalPort = nPort;
  931. #if defined( _WIN32 ) || defined( _WINDOWS )
  932.     // Have we been able to load and initialize the winsock stuff yet?
  933.     if (!win_net::IsWinsockAvailable(this))
  934.     {
  935. return HXR_FAIL; // HXR_GENERAL_NONET;
  936.     }
  937. #endif
  939.     m_pNetworkServices->UseDrivers();
  941.     HX_RESULT theErr = conn::init_drivers(NULL);
  943. #ifdef _UNIX
  944.     //This one has to be set before we create a new socket.
  945.     conn::SetNetworkThreadingPref( ReadNetworkThreadingPref((IUnknown*)m_pContext) );
  946.     conn::SetThreadedDNSPref( ReadThreadedDNSPref((IUnknown*)m_pContext) );
  947. #endif
  950.     m_pCtrl = NULL;
  952. #if defined(HELIX_FEATURE_SECURECONN)
  953.     if (m_bSecureSocket)
  954.     {
  955. IHXSSL* pHXSSL = NULL;
  956. IHXCommonClassFactory* pCCF = NULL;
  958. if (m_pContext)
  959. {
  960.     m_pContext->AddRef();
  962.     // get the CCF
  963.     m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCCF);
  965.     HX_RELEASE(m_pContext);
  966. }
  968. if (pCCF)
  969. {
  970.     pCCF->CreateInstance(IID_IHXSSL, (void**) &pHXSSL);
  971.     HX_RELEASE(pCCF);
  972. }
  974. if (pHXSSL)
  975. {
  976.     m_pCtrl = new secureconn(pHXSSL);
  977.     pHXSSL->Release();
  978. }
  979.     }
  980.     else
  981. #endif /* HELIX_FEATURE_SECURECONN */
  982.     {
  983. m_pCtrl  = conn::new_socket(HX_TCP_SOCKET);
  984.     }
  987.     if (!m_pCtrl)
  988.     {
  989. return HXR_OUTOFMEMORY;
  990.     }
  992.     // XXXGo - As it is implemented, this is the only way...
  993.     if (m_bReuseAddr)
  994.     {
  995. if (m_pCtrl->reuse_addr(m_bReuseAddr) != HXR_OK)
  996. {
  997.     // err...what do we need to do?
  998.     HX_ASSERT(!"reuse_addr() failed");
  999. }
  1000.     }
  1001.     if (m_bReusePort)
  1002.     {
  1003. if (m_pCtrl->reuse_port(m_bReusePort) != HXR_OK)
  1004. {
  1005.     // err...what do we need to do?
  1006.     HX_ASSERT(!"reuse_port() failed");
  1007. }
  1008.     }
  1010. #ifdef _UNIX
  1011.     m_pCtrl->SetAsyncDNSPref( ReadAsyncDNSPref((IUnknown*)m_pContext) );
  1012. #endif
  1014.     m_pCtrl->nonblocking();
  1016.     m_pCallback = new TCPSocketCallback;
  1017.     if (!m_pCallback)
  1018.     {
  1019. return HXR_OUTOFMEMORY;
  1020.     }
  1021.     m_pCallback->m_pContext = this;
  1022.     m_pCtrl->set_callback(m_pCallback);
  1023.     m_bInitComplete = TRUE;
  1025.     if (m_pPreferences)
  1026.     {
  1027. /* Get MaxBandwidth from Prefs */
  1028. ReadPrefINT32(m_pPreferences, "MaxBandwidth", ulMaxBandwidth);
  1029. ReadPrefBOOL(m_pPreferences, "LoadTest", bLoadTest);
  1030. ReadPrefBOOL(m_pPreferences, "EnforceMaxBandwidth", bEnforceMaxBandwidth);
  1032. //If we are in load test mode, never enforce the MaxBandwidth.
  1033. bEnforceMaxBandwidth = bEnforceMaxBandwidth&&!bLoadTest;
  1035. if (ulMaxBandwidth && bEnforceMaxBandwidth)
  1036. {
  1037.     conn::m_ulMaxBandwidth = ulMaxBandwidth / 8;
  1038. }
  1039. else if (!bEnforceMaxBandwidth)
  1040. {
  1041.     conn::m_ulMaxBandwidth = MAX_UINT32;
  1042. }
  1043.     }
  1045.     return HXR_OK;
  1046. }
  1048. STDMETHODIMP HXTCPSocket::Connect(const char* pDestination,
  1049.    UINT16 nPort)
  1050. {
  1051.     if (!m_bInitComplete)
  1052.     {
  1053. HX_RESULT ret = Bind(HXR_INADDR_ANY, 0);
  1054. if (HXR_OK != ret)
  1055. return ret;
  1056.     }
  1058.     HX_RESULT theErr = HXR_OK;
  1059.     UINT32 ulPlatformData = 0;
  1061. #if defined (_WIN32)
  1062.     ulPlatformData = (UINT32)GetModuleHandle(NULL);
  1063. #elif defined (_WIN16)
  1064.     ulPlatformData = (UINT32)(int)g_hInstance;
  1065. #endif
  1067.     m_nForeignPort = nPort;
  1069. #ifndef _WINCE
  1070.     theErr = m_pCtrl->connect(pDestination,nPort,0,ulPlatformData);
  1071. #else
  1072.     theErr = m_pCtrl->connect(pDestination,nPort,1,ulPlatformData);
  1073. #endif
  1075.     theErr = ConvertNetworkError(theErr);
  1076.     return theErr;
  1077. }
  1079. STDMETHODIMP HXTCPSocket::Read(UINT16 uSize)
  1080. {
  1081.     HX_RESULT theErr = HXR_OK;
  1082.     HX_RESULT lResult = HXR_OK;
  1084.     if (m_bReadPending)
  1085.     {
  1086. return HXR_UNEXPECTED;
  1087.     }
  1089.     m_bReadPending  = TRUE;
  1090.     m_nRequired     = uSize;
  1092.     m_pMutex->Lock();
  1093.     theErr  = DoRead();
  1094.     m_pMutex->Unlock();
  1095.     lResult = ConvertNetworkError(theErr);
  1097.     return lResult;
  1098. }
  1100. STDMETHODIMP HXTCPSocket::Write(IHXBuffer* pBuffer)
  1101. {
  1102.     HX_RESULT theErr = HXR_OK;
  1103.     HX_RESULT lResult = HXR_OK;
  1105. #ifdef _MACINTOSH
  1106. if (m_pInterruptSafeMacWriteQueue)
  1107. m_pInterruptSafeMacWriteQueue->AddTail(pBuffer); // AddRef called inside
  1108. #else
  1109. pBuffer->AddRef();
  1110. m_PendingWriteBuffers.AddTail((void*) pBuffer);
  1111.     /* Transfer pending buffers to TCP send queue */
  1112.     TransferBuffers();
  1113. #endif
  1115. m_pMutex->Lock();
  1116.     theErr = DoWrite();
  1117.     m_pMutex->Unlock();
  1118.     lResult = ConvertNetworkError(theErr);
  1120.     return lResult;
  1121. }
  1123. STDMETHODIMP HXTCPSocket::WantWrite()
  1124. {
  1125.     if (mSendTCP->GetQueuedItemCount() == 0)
  1126.     {
  1127. m_pTCPResponse->WriteReady(HXR_OK);
  1128.     }
  1129.     else
  1130.     {
  1131. m_bWantWritePending = TRUE;
  1132.     }
  1134.     return HXR_OK;
  1135. }
  1137. STDMETHODIMP HXTCPSocket::GetLocalAddress(ULONG32& lAddress)
  1138. {
  1139.     return HXR_NOTIMPL;
  1140. }
  1142. STDMETHODIMP HXTCPSocket::GetForeignAddress(ULONG32& lAddress)
  1143. {
  1144.     if(m_bConnected && m_lForeignAddress)
  1145.     {
  1146. lAddress = m_lForeignAddress;
  1147. return HXR_OK;
  1148.     }
  1149.     return HXR_FAIL;
  1150. }
  1152. STDMETHODIMP HXTCPSocket::GetLocalPort(UINT16& port)
  1153. {
  1154.     return HXR_NOTIMPL;
  1155. }
  1157. STDMETHODIMP HXTCPSocket::GetForeignPort(UINT16& port)
  1158. {
  1159.     if(m_bConnected)
  1160.     {
  1161. port = m_nForeignPort;
  1162. return HXR_OK;
  1163.     }
  1164.     return HXR_FAIL;
  1165. }
  1167. // the tcp socket will still need to be inited
  1168. STDMETHODIMP
  1169. HXTCPSocket::AcceptConnection(conn* pNewConn)
  1170. {
  1171.     HX_ASSERT(!m_bConnected);
  1172.     HX_ASSERT(!m_bInitComplete);
  1173.     HX_ASSERT(m_pCtrl == NULL);
  1174.     m_pCtrl = pNewConn;
  1175.     m_pCtrl->AddRef();
  1176.     m_pCtrl->nonblocking();
  1178.     if ( m_pCallback )
  1179.     {
  1180. HX_DELETE(m_pCallback);
  1181.     }
  1182.     m_pCallback = new TCPSocketCallback;
  1183.     if ( !m_pCallback )
  1184.     {
  1185. return HXR_OUTOFMEMORY;
  1186.     }
  1187.     m_pCallback->m_pContext = this;
  1188.     m_pCtrl->set_callback(m_pCallback);
  1189.     m_lForeignAddress = DwToHost(m_pCtrl->get_addr());
  1191.     m_bInitComplete = TRUE;
  1192.     m_bConnected = TRUE;
  1194.     return HXR_OK;
  1195. }
  1197. HX_RESULT
  1198. HXTCPSocket::DoRead()
  1199. {
  1200. #ifdef _MACINTOSH
  1201. if (m_bInDoRead)
  1202. {
  1203. return HXR_OK; // whatever needs to be done will be done by the caller that's already here.
  1205. // xxxbobclark the m_bInDoRead flag is hacked around calling ReadDone(), because
  1206. //             ReadDone() may call Read() which in turn calls us here, and we do
  1207. //             not want to bail out in that instance. (Otherwise we only remove
  1208. //             one packet at a time, which, given the scheduler granularity and
  1209. //             high bit rates, implies that our bandwidth would be too low.)
  1210. }
  1211. #endif
  1212. m_bInDoRead = TRUE;
  1214.     HX_RESULT theErr = HXR_OK;
  1215.     // check how much room we have in TCP receive queue
  1216.     UINT16 count = mReceiveTCP->GetMaxAvailableElements();
  1218.     if (count > 0)
  1219.     {
  1220. #if !defined(THREADS_SUPPORTED) && !defined(_UNIX_THREADED_NETWORK_IO)
  1221. UINT32 ulBytesToRead = conn::bytes_to_preparetcpread(m_pCtrl);
  1223. if (ulBytesToRead > 0)
  1224. {
  1225.     if ((UINT32)count > ulBytesToRead)
  1226.     {
  1227. count = (UINT16)ulBytesToRead;
  1228.     }
  1230.     // attempt to read data from TCP link
  1231.     theErr = m_pCtrl->read(m_pBuffer, &count);
  1232.     if (!theErr && count > 0)
  1233.     {
  1234. conn::bytes_to_actualtcpread(m_pCtrl, (UINT32)count);
  1235. mReceiveTCP->EnQueue(m_pBuffer, count);
  1236.     }
  1237.     else if (theErr)
  1238.     {
  1239. theErr = ConvertNetworkError(theErr);
  1240.     }
  1241. }
  1242. #elif defined(_UNIX_THREADED_NETWORK_IO)
  1243.         //XXXgfw duplicated code. Clean this up...
  1244.         if( ReadNetworkThreadingPref((IUnknown*)m_pContext) )
  1245.         {
  1246.             // in THREADS_SUPPORTED mode, this will be taken care by the thrdconn.cpp
  1247.             // attempt to read data from TCP link
  1248.             theErr = m_pCtrl->read(m_pBuffer, &count);
  1249.             if (!theErr && count > 0)
  1250.             {
  1251.                 mReceiveTCP->EnQueue(m_pBuffer, count);
  1252.             }
  1253.             else if (theErr)
  1254.             {
  1255.                 theErr = ConvertNetworkError(theErr);
  1256.             }
  1257.         }
  1258.         else
  1259.         {
  1260.             UINT32 ulBytesToRead = conn::bytes_to_preparetcpread(m_pCtrl);
  1262.             if (ulBytesToRead > 0)
  1263.             {
  1264.                 if ((UINT32)count > ulBytesToRead)
  1265.                 {
  1266.                     count = (UINT16)ulBytesToRead;
  1267.                 }
  1269.                 // attempt to read data from TCP link
  1270.                 theErr = m_pCtrl->read(m_pBuffer, &count);
  1271.                 if (!theErr && count > 0)
  1272.                 {
  1273.                     conn::bytes_to_actualtcpread(m_pCtrl, (UINT32)count);
  1274.                     mReceiveTCP->EnQueue(m_pBuffer, count);
  1275.                 }
  1276.                 else if (theErr)
  1277.                 {
  1278.                     theErr = ConvertNetworkError(theErr);
  1279.                 }
  1280.             }
  1282.         }
  1283. #else
  1284. // in THREADS_SUPPORTED mode, this will be taken care by the thrdconn.cpp
  1285. // attempt to read data from TCP link
  1286. theErr = m_pCtrl->read(m_pBuffer, &count);
  1287. if (!theErr && count > 0)
  1288. {
  1289.     mReceiveTCP->EnQueue(m_pBuffer, count);
  1290. }
  1291. else if (theErr)
  1292. {
  1293.     theErr = ConvertNetworkError(theErr);
  1294. }
  1295. #endif /* !THREADS_SUPPORTED */
  1296.     }
  1298.     count = mReceiveTCP->GetQueuedItemCount();
  1299.     if (m_bReadPending && count > 0)
  1300.     {
  1301. /* If we are at interrupt time and the response object is not interrupt safe,
  1302.  * schedule a callback to return back the data
  1303.  */
  1304. if (!IsSafe())
  1305. {
  1306. m_bInDoRead = FALSE;
  1307.     return HXR_OK;
  1308. }
  1310. m_bReadPending = FALSE;
  1311. if (m_nRequired < count)
  1312. {
  1313.     // XXXAAK -- UINT32 down to UINT16 - possible truncation???
  1314.     count = (UINT16)m_nRequired;
  1315. }
  1317. CHXBuffer* pBuffer = new CHXBuffer;
  1318. pBuffer->AddRef();
  1319. mReceiveTCP->DeQueue(m_pBuffer, count);
  1320. pBuffer->Set((UCHAR*) m_pBuffer, count);
  1322. m_bInDoRead = FALSE;
  1323. theErr = m_pTCPResponse->ReadDone(HXR_OK, pBuffer);
  1324. m_bInDoRead = TRUE;
  1326. pBuffer->Release();
  1328. /* mask any kind of errors */
  1329.         // Huh??? Don't mask OUTOFMEMORY errors!
  1330.         if( theErr != HXR_OUTOFMEMORY )
  1331.         {
  1332.     theErr = HXR_OK;
  1333.         }
  1334.     }
  1336.     if (theErr && m_bReadPending)
  1337.     {
  1338. /* If we are at interrupt time and the response object is not interrupt safe,
  1339.  * schedule a callback to return back the data
  1340.  */
  1341. if (!IsSafe())
  1342. {
  1343. m_bInDoRead = FALSE;
  1344.     return HXR_OK;
  1345. }
  1347. #ifdef _MACINTOSH
  1348. if (m_pMacCommandCallback && m_pMacCommandCallback->ScheduleCallback(TCP_READ_DONE_COMMAND, m_pScheduler, 0, theErr))
  1349. {
  1350.     m_bReadPending = FALSE;
  1351.          m_bInDoRead = FALSE;
  1352.     return HXR_OK;
  1353. }
  1354. else
  1355. {
  1356.     // failed to schedule a callback, notify the responser with error directly
  1357.     m_bReadPending = FALSE;
  1358.     m_pTCPResponse->ReadDone(theErr, NULL);
  1359. }
  1360. #else
  1361. m_bReadPending = FALSE;
  1362. m_pTCPResponse->ReadDone(theErr, NULL);
  1363. #endif
  1364.     }
  1366.     if (!theErr     &&
  1367. m_bReadPending     &&
  1368. m_pSchedulerReadCallback)
  1369. {
  1370.     m_pSchedulerReadCallback->ScheduleCallback(TCP_READ_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  1371.     }
  1373.   m_bInDoRead = FALSE;
  1374.     return theErr;
  1375. }
  1377. HX_RESULT
  1378. HXTCPSocket::DoWrite()
  1379. {
  1380.     HX_RESULT theErr = HXR_OK;
  1382.     if (m_bInWrite) return HXR_OK;
  1383.     m_bInWrite = TRUE;
  1385. #ifdef _MACINTOSH
  1386. if (m_pInterruptSafeMacWriteQueue)
  1387. m_pInterruptSafeMacWriteQueue->TransferToSimpleList(m_PendingWriteBuffers);
  1388. TransferBuffers(); // PENDING_BUFFERS_ARE_EMPTIED_AT_START_OF_DO_WRITE
  1389. #endif
  1391.     // check how data we have in TCP send queue
  1392.     UINT16 count    = mSendTCP->GetQueuedItemCount();
  1393.     UINT16 actual   = count;
  1395.     if(count > 0)
  1396.     {
  1397. mSendTCP->DeQueue(m_pBuffer,count);
  1398. theErr = m_pCtrl->write(m_pBuffer, &actual);
  1399.     }
  1401.     switch(theErr)
  1402.     {
  1403. case HXR_AT_INTERRUPT:
  1404. case HXR_WOULD_BLOCK:
  1405. case HXR_OK:
  1406.     // enqueue the data that was not sent
  1407.     if(actual != count)
  1408.     {
  1409. mSendTCP->EnQueue(m_pBuffer + actual, count - actual);
  1410.     }
  1412.     // mask out these errors
  1413.     theErr = HXR_OK;
  1414.     break;
  1415. default:
  1416.     theErr = ConvertNetworkError(theErr);
  1417.     break;
  1418.     }
  1420.     if (!theErr && m_bWantWritePending && mSendTCP->GetQueuedItemCount() == 0)
  1421.     {
  1422. m_bWantWritePending = FALSE;
  1423. m_pTCPResponse->WriteReady(HXR_OK);
  1424.     }
  1426. #ifndef _MACINTOSH
  1427. // m_PendingWriteBuffers will always be empty due to the full buffer transfer at the top of this routine.
  1428. // see PENDING_BUFFERS_ARE_EMPTIED_AT_START_OF_DO_WRITE
  1429.     if (!theErr && m_PendingWriteBuffers.GetCount()  > 0)
  1430.     {
  1431. TransferBuffers();
  1432.     }
  1433. #endif
  1435.     if (!theErr &&
  1436. ((mSendTCP && mSendTCP->GetQueuedItemCount() > 0) ||
  1437. m_PendingWriteBuffers.GetCount() > 0)) // see PENDING_BUFFERS_ARE_EMPTIED_AT_START_OF_DO_WRITE
  1438.     {
  1439. if (m_pSchedulerWriteCallback)
  1440. {
  1441.     m_pSchedulerWriteCallback->ScheduleCallback(TCP_WRITE_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  1442. }
  1443.     }
  1445.     if (m_bWriteFlushPending &&
  1446. ((mSendTCP->GetQueuedItemCount() == 0 &&
  1447.  m_PendingWriteBuffers.GetCount() == 0) ||
  1448.  theErr))
  1449.     {
  1450. m_bWriteFlushPending = FALSE;
  1451. Release();
  1452.     }
  1453.     else if (!theErr && !m_bWriteFlushPending &&
  1454. (mSendTCP->GetQueuedItemCount() > 0 || m_PendingWriteBuffers.GetCount() > 0))
  1455.     {
  1456. m_bWriteFlushPending = TRUE;
  1457. AddRef();
  1458.     }
  1460.     m_bInWrite = FALSE;
  1461.     return theErr;
  1462. }
  1464. /* If we are at interrupt time and the response object is not interrupt safe,
  1465.  * schedule a callback to return back the data
  1466.  */
  1467. BOOL
  1468. HXTCPSocket::IsSafe()
  1469. {
  1470.     if (m_pInterruptState && m_pInterruptState->AtInterruptTime() &&
  1471. (!m_pResponseInterruptSafe ||
  1472.  !m_pResponseInterruptSafe->IsInterruptSafe()))
  1473.     {
  1474. if (m_pNonInterruptReadCallback)
  1475. {
  1476.     m_pNonInterruptReadCallback->ScheduleCallback(TCP_READ_COMMAND, m_pScheduler, 0);
  1477. }
  1479. return FALSE;
  1480.     }
  1482.     return TRUE;
  1483. }
  1486. void
  1487. HXTCPSocket::ConnectDone(BOOL bResult)
  1488. {
  1489.     AddRef();
  1490.     if (bResult == TRUE)
  1491.     {
  1492. m_bConnected = TRUE;
  1493. //XXX need to set m_lForeignAddr here
  1494. //XXXJR hack!
  1495. m_lForeignAddress = DwToHost(m_pCtrl->get_addr());
  1496. m_pTCPResponse->ConnectDone(HXR_OK);
  1497.     }
  1498.     else
  1499.     {
  1500. #ifdef _MACINTOSH
  1501. if (!(m_pMacCommandCallback && m_pMacCommandCallback->ScheduleCallback(TCP_CONNECT_DONE_COMMAND, m_pScheduler, 0, HXR_NET_CONNECT)))
  1502. {
  1503. //note: only happens when there's a problem (e.g. macleod 1/2 server problem)
  1504. m_pTCPResponse->ConnectDone(HXR_NET_CONNECT); // couldn't use the delayed callback... take our chances.
  1505. }
  1506. #else
  1507. m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  1508. #endif
  1509.     }
  1510.     Release();
  1511. }
  1513. void
  1514. HXTCPSocket::CloseDone()
  1515. {
  1516.     m_pTCPResponse->Closed(HXR_OK);
  1517. }
  1519. void
  1520. HXTCPSocket::DNSDone(BOOL bSuccess)
  1521. {
  1522.     AddRef();
  1523.     if (!bSuccess)
  1524.     {
  1525. m_pTCPResponse->ConnectDone(HXR_DNR);
  1526.     }
  1527.     Release();
  1528. }
  1530. void
  1531. HXTCPSocket::TransferBuffers()
  1532. {
  1533.     IHXBuffer* pBuffer = 0;
  1535.     while (m_PendingWriteBuffers.GetCount() > 0)
  1536.     {
  1537. pBuffer = (IHXBuffer*) m_PendingWriteBuffers.GetHead();
  1538. if ((UINT16) pBuffer->GetSize() < mSendTCP->GetMaxAvailableElements())
  1539. {
  1540.     mSendTCP->EnQueue( pBuffer->GetBuffer(),
  1541. (UINT16) pBuffer->GetSize());
  1542.     pBuffer->Release();
  1543.     m_PendingWriteBuffers.RemoveHead();
  1544. }
  1545. else
  1546. {
  1547.     break;
  1548. }
  1549.     }
  1550. }
  1552. STDMETHODIMP
  1553. HXTCPSocket::SetOption(HX_SOCKET_OPTION option, UINT32 ulValue)
  1554. {
  1555.     HX_RESULT res = HXR_OK;
  1557.     switch(option)
  1558.     {
  1559.     case HX_SOCKOPT_REUSE_ADDR:
  1560. m_bReuseAddr = (BOOL)ulValue;
  1561.     break;
  1562.     case HX_SOCKOPT_REUSE_PORT:
  1563. m_bReusePort = (BOOL)ulValue;
  1564.     break;
  1565.     case HX_SOCKOPT_MULTICAST_IF:
  1566. res = HXR_UNEXPECTED;
  1567.     break;
  1568.     default:
  1569. HX_ASSERT(!"I don't know this option");
  1570. res = HXR_FAIL;
  1571.     }
  1573.     return res;
  1574. }
  1576. STDMETHODIMP
  1577. HXTCPSocket::SetSecure(BOOL bSecure)
  1578. {
  1579.     HX_RESULT res = HXR_OK;
  1581.     m_bSecureSocket = bSecure;
  1583.     return res;
  1584. }
  1586. STDMETHODIMP HXTCPSocket::HandleCallback(INT32 theCommand, HX_RESULT theError)
  1587. {
  1588.     HX_RESULT theErr = HXR_OK;
  1589.     if (!m_bInDestructor)
  1590.     {
  1591. AddRef();
  1592. m_pMutex->Lock();
  1593. if (!m_bInDestructor)
  1594. {
  1595. switch(theCommand)
  1596. {
  1597. case TCP_READ_COMMAND:
  1598.     theErr = DoRead();
  1599.     break;
  1601. case TCP_WRITE_COMMAND:
  1602.     DoWrite(); // protected from re-entry by m_bInWrite
  1603.     break;
  1605. case TCP_READ_DONE_COMMAND:
  1606.      m_bReadPending = FALSE;
  1607. m_pTCPResponse->ReadDone(theError, NULL);
  1608.     break;
  1610. case TCP_CONNECT_DONE_COMMAND:
  1611. m_pTCPResponse->ConnectDone(theError);
  1612. break;
  1614. case TCP_BIND_COMMAND:
  1615. default:
  1616.     theErr = DoRead();
  1617.     DoWrite();
  1618.     break;
  1619.     }
  1620. }
  1621. m_pMutex->Unlock();
  1623.         // we want out of memory errors to be reported immediately
  1624.         // because fiddling around waiting for the error to propagate
  1625.         // normally will just make the situation worse; mask out all
  1626.         // other errors, as they will eventually get dealt with in
  1627.         // ReadDone() or similar functions.
  1628.         
  1629.         if (theErr != HXR_OUTOFMEMORY)
  1630.         {
  1631.             theErr = HXR_OK;
  1632.         }
  1633.         
  1634. if( theErr )
  1635. {
  1636.     IHXErrorMessages * pErrorNotifier = NULL;
  1637.     IUnknown * pPlayer = NULL;
  1638.     IHXClientEngine* pEngine = NULL;
  1639.     UINT32 nNumPlayers = 0;
  1641.     m_pContext->QueryInterface(IID_IHXClientEngine, (void**)&pEngine);
  1642.     if( pEngine )
  1643.     {
  1644. nNumPlayers = pEngine->GetPlayerCount();
  1645. for( int ii=0; ii<nNumPlayers; ii++ )
  1646. {
  1647.     pEngine->GetPlayer(ii,pPlayer);
  1648.     if( pPlayer )
  1649.     {
  1650. pPlayer->QueryInterface( IID_IHXErrorMessages, (void**)&pErrorNotifier );
  1651.     }
  1652.     if( pErrorNotifier )
  1653.     {
  1654. pErrorNotifier->Report( HXLOG_ERR, theErr, 0, NULL, NULL );
  1655. pErrorNotifier->Release();
  1656.     }
  1657.     HX_RELEASE( pPlayer );
  1658. }
  1659.     }
  1660.     HX_RELEASE( pEngine );
  1661. }
  1662. Release();
  1663.     }
  1664.     return theErr;
  1665. }
  1667. HX_RESULT HXTCPSocket::TCPSocketCallback::Func(NotificationType Type,
  1668.    BOOL bSuccess, conn* pConn)
  1669. {
  1670.     if(m_pContext)
  1671.     {
  1673. switch (Type)
  1674. {
  1675. case READ_NOTIFICATION:
  1676. //
  1677. //  This clears up a problem on the Macintosh where we were getting
  1678. //  interrupt callbacks from the Network device, and could possibly
  1679. //  collide when adding/removing data the same time from the same
  1680. //  socket, at interrupt time, and at system level time.
  1681. //
  1682. #if defined(_UNIX_THREADED_NETWORK_IO)
  1683.             if( !ReadNetworkThreadingPref((IUnknown*)(m_pContext->m_pContext) ))
  1684.             {
  1685.                 m_pContext->AddRef();
  1686.                 m_pContext->m_pMutex->Lock();
  1687.                 m_pContext->DoRead();
  1688.                 m_pContext->m_pMutex->Unlock();
  1689.                 m_pContext->Release();
  1690.             }
  1691. #elif !defined (THREADS_SUPPORTED) && !defined(_MACINTOSH)
  1692.     m_pContext->AddRef();
  1693.     m_pContext->m_pMutex->Lock();
  1694.     m_pContext->DoRead();
  1695.     m_pContext->m_pMutex->Unlock();
  1696.     m_pContext->Release();
  1697. #endif
  1698.     break;
  1699. case WRITE_NOTIFICATION:
  1700. #if defined(_UNIX_THREADED_NETWORK_IO)
  1701.             if( !ReadNetworkThreadingPref((IUnknown*)(m_pContext->m_pContext)) )
  1702.             {
  1703.                 m_pContext->AddRef();
  1704.                 m_pContext->m_pMutex->Lock();
  1705.                 m_pContext->DoWrite();
  1706.                 m_pContext->m_pMutex->Unlock();
  1707.                 m_pContext->Release();
  1708.             }
  1709. #elif !defined (THREADS_SUPPORTED) && !defined(_MACINTOSH)
  1710.     m_pContext->AddRef();
  1711.     m_pContext->m_pMutex->Lock();
  1712.     m_pContext->DoWrite();
  1713.     m_pContext->m_pMutex->Unlock();
  1714.     m_pContext->Release();
  1715. #endif
  1716.     break;
  1717. case CONNECT_NOTIFICATION:
  1718.     m_pContext->ConnectDone(bSuccess);
  1719.     break;
  1720. case CLOSE_NOTIFICATION:
  1721.     m_pContext->CloseDone();
  1722.     break;
  1723. case DNS_NOTIFICATION:
  1724.     m_pContext->DNSDone(bSuccess);
  1725.     break;
  1726. default:
  1727.     break;
  1728. }
  1729.     }
  1730.     return HXR_OK;
  1731. }
  1733. HXListenSocket::HXListenSocket(IUnknown* pContext,
  1734.  HXNetworkServices* pNetworkServices)
  1735. : m_pListenConn(NULL)
  1736. , m_pCallback(NULL)
  1737. , m_pContext(NULL)
  1738.   , m_bReuseAddr(FALSE)
  1739.   , m_bReusePort(FALSE)
  1740. {
  1741.     m_pContext = pContext;
  1742.     m_pContext->AddRef();
  1744.     m_pNetworkServices = pNetworkServices;
  1745.     m_pNetworkServices->AddRef();
  1747.     m_lRefCount = 0;
  1748.     m_pListenResponse = 0;
  1750. }
  1752. HXListenSocket::~HXListenSocket()
  1753. {
  1754.     if (m_pCallback)
  1755.     {
  1756. m_pCallback->m_pContext = 0;
  1757.     }
  1759.     if (m_pListenConn)
  1760.     {
  1761. m_pListenConn->done();
  1762.         m_pListenConn->Release();
  1763.         m_pListenConn = NULL;
  1764.     }
  1766.     HX_RELEASE(m_pContext);
  1767.     HX_DELETE(m_pCallback);
  1769.     HX_RELEASE(m_pListenResponse);
  1770.     HX_RELEASE(m_pNetworkServices);
  1771. }
  1773. STDMETHODIMP HXListenSocket::QueryInterface(REFIID riid, void** ppvObj)
  1774. {
  1775.     QInterfaceList qiList[] =
  1776.         {
  1777.             { GET_IIDHANDLE(IID_IHXListenSocket), (IHXListenSocket*)this },
  1778.             { GET_IIDHANDLE(IID_IHXSetSocketOption), (IHXSetSocketOption*)this },
  1779.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXListenSocket*)this },
  1780.         };
  1782.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  1783. }
  1785. STDMETHODIMP_(ULONG32) HXListenSocket::AddRef()
  1786. {
  1787.     return InterlockedIncrement(&m_lRefCount);
  1788. }
  1790. STDMETHODIMP_(ULONG32) HXListenSocket::Release()
  1791. {
  1792.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1793.     {
  1794.         return m_lRefCount;
  1795.     }
  1797.     delete this;
  1798.     return HXR_OK;
  1799. }
  1801. STDMETHODIMP HXListenSocket::SetOption(HX_SOCKET_OPTION option,
  1802. UINT32 ulValue)
  1803. {
  1804.     HX_RESULT  ret = HXR_OK;
  1806.     switch (option)
  1807.     {
  1808.     case HX_SOCKOPT_REUSE_ADDR:
  1809. m_bReuseAddr = ulValue;
  1810. break;
  1812.     case HX_SOCKOPT_REUSE_PORT:
  1813. m_bReusePort = ulValue;
  1814. break;
  1816.     default:
  1817. ret = HXR_NOTIMPL;
  1818.     }
  1820.     return ret;
  1821. }
  1823. STDMETHODIMP HXListenSocket::Init(UINT32 ulLocalAddr, UINT16 port,
  1824.    IHXListenResponse* pListenResponse)
  1825. {
  1826.     if (!pListenResponse)
  1827.     {
  1828. return HXR_UNEXPECTED;
  1829.     }
  1831.     HX_RELEASE(m_pListenResponse);
  1832.     m_pListenResponse = pListenResponse;
  1833.     m_pListenResponse->AddRef();
  1835. #if defined( _WIN32 ) || defined( _WINDOWS )
  1836.     // Have we been able to load and initialize the winsock stuff yet?
  1837.     if (!win_net::IsWinsockAvailable(this))
  1838.     {
  1839. return HXR_FAIL; // HXR_GENERAL_NONET;
  1840.     }
  1841. #endif
  1843.     m_pNetworkServices->UseDrivers();
  1845. #ifdef _UNIX
  1846.     //This one has to be set before we create a new socket.
  1847.     conn::SetNetworkThreadingPref( ReadNetworkThreadingPref((IUnknown*)m_pContext) );
  1848.     conn::SetThreadedDNSPref( ReadThreadedDNSPref((IUnknown*)m_pContext) );
  1849. #endif
  1851.     HX_RESULT ret = conn::init_drivers(NULL);
  1852.     m_pListenConn = conn::new_socket(HX_TCP_SOCKET);
  1853.     if ( m_pListenConn == NULL )
  1854.     {
  1855. return HXR_OUTOFMEMORY;
  1856.     }
  1858. #ifdef _UNIX
  1859.     m_pListenConn->SetAsyncDNSPref( ReadAsyncDNSPref((IUnknown*)m_pContext) );
  1860. #endif
  1862.     m_pListenConn->nonblocking();
  1863.     m_pListenConn->reuse_addr(m_bReuseAddr);
  1864.     m_pListenConn->reuse_port(m_bReusePort);
  1866.     if ( m_pCallback == NULL)
  1867.     {
  1868. m_pCallback = new ListenSocketCallback();
  1869. m_pCallback->m_pContext = this;
  1870.     }
  1871.     m_pListenConn->set_callback(m_pCallback);
  1873.     UINT32 ulPlatformData = 0;
  1875. #if defined (_WIN32)
  1876.     ulPlatformData = (UINT32)GetModuleHandle(NULL);
  1877. #elif defined (_WIN16)
  1878.     ulPlatformData = (UINT32)(int)g_hInstance;
  1879. #endif
  1880.     return m_pListenConn->listen(ulLocalAddr, port, 2, 0, ulPlatformData);
  1881. }
  1884. HX_RESULT HXListenSocket::ListenSocketCallback::Func(NotificationType Type,
  1885.    BOOL bSuccess, conn* pConn)
  1886. {
  1887.     if(m_pContext)
  1888.     {
  1889. switch (Type)
  1890. {
  1891. case ACCEPT_NOTIFICATION:
  1893.     if ( bSuccess )
  1894.     {
  1895. HXTCPSocket* pSock = new HXTCPSocket(m_pContext->m_pContext,
  1896.     m_pContext->m_pNetworkServices);
  1897.         if ( pSock )
  1898. {
  1899.     pSock->AddRef();
  1900.     if ( SUCCEEDED(pSock->AcceptConnection(pConn)) )
  1901.     {
  1902. m_pContext->m_pListenResponse->NewConnection(HXR_OK,
  1903.     (IHXTCPSocket*)pSock);
  1904.     }
  1905.     HX_RELEASE(pSock);
  1906. }
  1907.     }
  1908.     break;
  1909. case CONNECT_NOTIFICATION:
  1910.     break;
  1911. case READ_NOTIFICATION:
  1912.     break;
  1913. case CLOSE_NOTIFICATION:
  1914.     break;
  1915. case DNS_NOTIFICATION:
  1916. default:
  1917.     break;
  1918. }
  1919.     }
  1920.     return HXR_OK;
  1921. }
  1924. HXUDPSocket::HXUDPSocket(IUnknown* pContext, HXNetworkServices* pNetworkServices):
  1925.     m_lRefCount(0),
  1926.     m_pCallback(0),
  1927.     m_pUDPResponse(0),
  1928.     m_pData(0),
  1929.     m_bReadPending(FALSE),
  1930.     m_bInRead(FALSE),
  1931.     m_bInDoRead(FALSE),
  1932.     m_bInWrite(FALSE),
  1933.     m_nRequired(0),
  1934.     m_pSchedulerReadCallback(NULL),
  1935.     m_pSchedulerWriteCallback(NULL),
  1936.     m_pNonInterruptReadCallback(NULL),
  1937.     m_pScheduler(0),
  1938.     m_nDestPort(0),
  1939.     m_bInitComplete(FALSE),
  1940.     m_pInterruptState(NULL),
  1941.     m_pResponseInterruptSafe(NULL),
  1942.     m_pMutex(NULL),
  1943.     m_bReuseAddr(FALSE),
  1944.     m_bReusePort(FALSE),
  1945.     m_bInDestructor(FALSE),
  1946.     m_pContext(pContext)
  1947. {
  1948. #ifdef _MACINTOSH
  1949. m_pInterruptSafeMacWriteQueue = new InterruptSafeMacQueue();
  1950. HX_ASSERT(m_pInterruptSafeMacWriteQueue != NULL);
  1951. #endif
  1953.     m_pNetworkServices = pNetworkServices;
  1954.     m_pNetworkServices->AddRef();
  1956.     if (pContext)
  1957.     {
  1958. pContext->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  1959. pContext->QueryInterface(IID_IHXInterruptState, (void**) &m_pInterruptState);
  1960.     }
  1962.     if (m_pScheduler)
  1963.     {
  1964. m_pSchedulerReadCallback = new ScheduledSocketCallback(this, TRUE);
  1965. m_pSchedulerReadCallback->AddRef();
  1967. m_pSchedulerWriteCallback = new ScheduledSocketCallback(this, TRUE);
  1968. m_pSchedulerWriteCallback->AddRef();
  1970. m_pNonInterruptReadCallback = new ScheduledSocketCallback(this, FALSE);
  1971. m_pNonInterruptReadCallback->AddRef();
  1972.     }
  1974. #if defined(THREADS_SUPPORTED)
  1975.     HXMutex::MakeMutex(m_pMutex);
  1976. #elif defined(_UNIX_THREADED_NETWORK_IO)
  1977.     if( ReadNetworkThreadingPref((IUnknown*)m_pContext) )
  1978.     {
  1979.         HXMutex::MakeMutex(m_pMutex);
  1980.     }
  1981.     else
  1982.     {
  1983.         HXMutex::MakeStubMutex(m_pMutex);
  1984.     }
  1985. #else
  1986.     HXMutex::MakeStubMutex(m_pMutex);
  1987. #endif
  1988. }
  1991. HXUDPSocket::~HXUDPSocket()
  1992. {
  1993.     m_bInDestructor = TRUE;
  1994. m_pMutex->Lock();
  1996. #ifdef _MACINTOSH
  1997. HX_DELETE(m_pInterruptSafeMacWriteQueue); // will release any objects in its nodes
  1998. #endif
  2000.     if (m_pSchedulerReadCallback)
  2001.     m_pSchedulerReadCallback->Unschedule(m_pScheduler);
  2003.     if (m_pSchedulerWriteCallback)
  2004.     m_pSchedulerWriteCallback->Unschedule(m_pScheduler);
  2006.     if (m_pNonInterruptReadCallback)
  2007.     m_pNonInterruptReadCallback->Unschedule(m_pScheduler);
  2009.     /*
  2010.      * XXX...While handling the m_pData->done it's possible for the
  2011.      *       DispatchMessage call in CancelSelect to cause an
  2012.      *       asynchronous DoRead to occur. The resulting AddRef/Release
  2013.      *       would cause this object to be deleted again, so to prevent
  2014.      *       this we set the m_pCallback->m_pContext = 0
  2015.      */
  2017.     if (m_pCallback)
  2018.     {
  2019. m_pCallback->m_pContext = 0;
  2020.     }
  2022.     if (m_pData)
  2023.     {
  2024. m_pData->done();
  2025. m_pData->Release();
  2026. m_pData = 0;
  2027.     }
  2029.     if(m_pUDPResponse)
  2030.     {
  2031. m_pUDPResponse->Release();
  2032. m_pUDPResponse = 0;
  2033.     }
  2035.     if (m_pCallback)
  2036.     {
  2037. delete m_pCallback;
  2038. m_pCallback = 0;
  2039.     }
  2041.     if (m_pScheduler)
  2042.     {
  2043. m_pScheduler->Release();
  2044. m_pScheduler = 0;
  2045.     }
  2047.     while (!m_ReadBuffers.IsEmpty())
  2048.     {
  2049. UDP_PACKET* pPacket = (UDP_PACKET*)m_ReadBuffers.RemoveHead();
  2051. HX_RELEASE(pPacket->pBuffer);
  2052. HX_DELETE(pPacket);
  2053.     }
  2055.     HX_RELEASE(m_pInterruptState);
  2056.     HX_RELEASE(m_pResponseInterruptSafe);
  2058.     if (m_pSchedulerReadCallback)
  2059.     {
  2060.      m_pSchedulerReadCallback->m_pSocket = NULL;
  2061.      m_pSchedulerReadCallback->Release();
  2062.      m_pSchedulerReadCallback = NULL;
  2063.     }
  2065.     if (m_pSchedulerWriteCallback)
  2066.     {
  2067.      m_pSchedulerWriteCallback->m_pSocket = NULL;
  2068.      m_pSchedulerWriteCallback->Release();
  2069.      m_pSchedulerWriteCallback = NULL;
  2070.     }
  2072.     if (m_pNonInterruptReadCallback)
  2073.     {
  2074.      m_pNonInterruptReadCallback->m_pSocket = NULL;
  2075.      m_pNonInterruptReadCallback->Release();
  2076.      m_pNonInterruptReadCallback = NULL;
  2077.     }
  2079.     m_pMutex->Unlock();
  2080.     HX_DELETE(m_pMutex);
  2082. #if defined( _WIN32 ) || defined( _WINDOWS )
  2083.     win_net::ReleaseWinsockUsage(this);
  2084. #endif
  2086.     HX_RELEASE(m_pNetworkServices);
  2087. }
  2089. STDMETHODIMP HXUDPSocket::QueryInterface(REFIID riid, void** ppvObj)
  2090. {
  2091.     QInterfaceList qiList[] =
  2092.         {
  2093.             { GET_IIDHANDLE(IID_IHXUDPSocket), (IHXUDPSocket*)this },
  2094.             { GET_IIDHANDLE(IID_IHXSetSocketOption), (IHXSetSocketOption*)this },
  2095.             { GET_IIDHANDLE(IID_IHXUDPMulticastInit), (IHXUDPMulticastInit*)this },
  2096.             { GET_IIDHANDLE(IID_IHXSetPrivateSocketOption), (IHXSetPrivateSocketOption*)this },
  2097.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXUDPSocket*)this },
  2098.         };
  2100.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  2101. }
  2103. STDMETHODIMP_(ULONG32) HXUDPSocket::AddRef()
  2104. {
  2105.     return InterlockedIncrement(&m_lRefCount);
  2106. }
  2108. STDMETHODIMP_(ULONG32) HXUDPSocket::Release()
  2109. {
  2110.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2111.     {
  2112.         return m_lRefCount;
  2113.     }
  2114.     delete this;
  2115.     return 0;
  2116. }
  2118. STDMETHODIMP
  2119. HXUDPSocket::InitMulticast(UINT8 uTTL)
  2120. {
  2121.     if (HXR_OK != m_pData->set_multicast())
  2122.     {
  2123. return HXR_FAIL;
  2124.     }
  2126.     if (HXR_OK != m_pData->set_multicast_ttl(uTTL))
  2127.     {
  2128. return HXR_FAIL;
  2129.     }
  2131.     return HXR_OK;
  2132. }
  2134. STDMETHODIMP HXUDPSocket::Init(ULONG32 ulAddr, UINT16 nPort,
  2135. IHXUDPResponse* pUDPResponse)
  2136. {
  2137.     if (!pUDPResponse && !m_pUDPResponse)
  2138.     {
  2139.         /*
  2140.          * if the response object hasn't been set up yet, then
  2141.          * require a response object (i.e. the first call to Init
  2142.          * must always specify a response object
  2143.          */
  2144. return HXR_UNEXPECTED;
  2145.     }
  2147.     HX_RESULT theErr = HXR_OK;
  2148.     UINT32 ulPlatformData = 0;
  2150.     if (pUDPResponse != NULL)
  2151.     {
  2152.         HX_RELEASE(m_pUDPResponse);
  2153.         m_pUDPResponse = pUDPResponse;
  2154.         m_pUDPResponse->AddRef();
  2155.     }
  2157.     HX_RELEASE(m_pResponseInterruptSafe);
  2158.     m_pUDPResponse->QueryInterface(IID_IHXInterruptSafe,
  2159.    (void**) &m_pResponseInterruptSafe);
  2161.     m_sockAddr.sin_family = AF_INET;
  2162.     m_sockAddr.sin_addr.s_addr = DwToNet(ulAddr);  //*(long*)&ulAddr;
  2163.     m_sockAddr.sin_port = WToNet(nPort);
  2165.     m_nDestPort = nPort;
  2167.     return HXR_OK;
  2168. }
  2170. STDMETHODIMP HXUDPSocket::Bind(UINT32 ulLocalAddr, UINT16 nPort)
  2171. {
  2172.     if (m_bInitComplete)
  2173. return HXR_UNEXPECTED;
  2175. #if defined( _WIN32 ) || defined( _WINDOWS )
  2176.     // Have we been able to load and initialize the winsock stuff yet?
  2177.     if (!win_net::IsWinsockAvailable(this))
  2178.     {
  2179. return HXR_FAIL; // HXR_GENERAL_NONET;
  2180.     }
  2181. #endif
  2183.     m_pNetworkServices->UseDrivers();
  2185.     HX_RESULT theErr = conn::init_drivers(NULL);
  2186.     if (theErr)
  2187.     {
  2188. return (theErr);
  2189.     }
  2191.     theErr = HXR_OK;
  2192.     UINT32 ulPlatformData = 0;
  2194. #ifdef _UNIX
  2195.     //This one has to be set before we create a new socket.
  2196.     conn::SetNetworkThreadingPref( ReadNetworkThreadingPref((IUnknown*)m_pContext) );
  2197.     conn::SetThreadedDNSPref( ReadThreadedDNSPref((IUnknown*)m_pContext) );
  2198. #endif
  2200.     m_pData = conn::new_socket(HX_UDP_SOCKET);
  2201.     if (!m_pData)
  2202.     {
  2203. return HXR_OUTOFMEMORY;
  2204.     }
  2206.     // XXXGo - As it is implemented, this is the only way...
  2207.     if (m_bReuseAddr)
  2208.     {
  2209. if (m_pData->reuse_addr(m_bReuseAddr) != HXR_OK)
  2210. {
  2211.     // err...what do we need to do?
  2212.     HX_ASSERT(!"reuse_addr() failed");
  2213. }
  2214.     }
  2215.     if (m_bReusePort)
  2216.     {
  2217. if (m_pData->reuse_port(m_bReusePort) != HXR_OK)
  2218. {
  2219.     // err...what do we need to do?
  2220.     HX_ASSERT(!"reuse_port() failed");
  2221. }
  2222.     }
  2224. #ifdef _UNIX
  2225.     m_pData->SetAsyncDNSPref( ReadAsyncDNSPref((IUnknown*)m_pContext) );
  2226. #endif
  2229.     // XXXST -- local addr binding stuff, removed dependency to m_nLocalPort
  2230.     // 0 for local port will make the system choose a free port
  2231.     theErr = m_pData->init(ulLocalAddr, nPort);
  2233.     if (theErr)
  2234.     {
  2235. theErr = ConvertNetworkError(theErr);
  2236. if (theErr)
  2237. {
  2238.     m_pData->done();
  2239.     m_pData->Release();
  2240.     m_pData = 0;
  2241.     return theErr;
  2242. }
  2243.     }
  2245.     m_pData->nonblocking();
  2247.     m_pData->set_receive_buf_size(DESIRED_RCV_BUFSIZE);
  2248.     if (!m_pCallback)
  2249.     {
  2250. m_pCallback = new UDPSocketCallback;
  2251. m_pCallback->m_pContext = this;
  2252.     }
  2253.     m_pData->set_callback(m_pCallback);
  2255. #ifdef _WINDOWS
  2256. #if defined (_WIN32)
  2257.     ulPlatformData = (UINT32)GetModuleHandle(NULL);
  2258. #elif defined (_WIN16)
  2259.     ulPlatformData = (UINT32)(int)g_hInstance;
  2260. #endif
  2261.     m_pData->SetWindowHandle(ulPlatformData);
  2262. #endif /* defined (_WINDOWS) */
  2264.     if (m_pSchedulerReadCallback)
  2265.     {
  2266.     m_pSchedulerReadCallback->ScheduleCallback(UDP_BIND_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  2267.     }
  2269.     m_bInitComplete = TRUE;
  2270.     return theErr;
  2271. }
  2273. STDMETHODIMP HXUDPSocket::Read(UINT16 nBytes)
  2274. {
  2275.     if (!m_bInitComplete)
  2276.     {
  2277. HX_RESULT ret = Bind(HXR_INADDR_ANY, 0);
  2278. if (HXR_OK != ret)
  2279.     return HXR_UNEXPECTED;
  2280.     }
  2282.     HX_RESULT theErr = HXR_OK;
  2284.     if(m_bReadPending)
  2285.     {
  2286. return HXR_UNEXPECTED;
  2287.     }
  2289.     m_bReadPending = TRUE;
  2291.     if (m_bInRead)
  2292.     {
  2293. return HXR_OK;
  2294.     }
  2296.     m_bInRead = TRUE;
  2298.     m_pMutex->Lock();
  2299.     UINT16 uNumIterations = 0;
  2300.     do
  2301.     {
  2302. theErr = DoRead();
  2303. uNumIterations++;
  2304.     } while (m_bReadPending && !theErr && m_ReadBuffers.GetCount() > 0 && uNumIterations < MAX_ITERATION_COUNT);
  2306.     m_pMutex->Unlock();
  2307.     theErr = ConvertNetworkError(theErr);
  2309.     if (m_bReadPending && m_pSchedulerReadCallback)
  2310.     m_pSchedulerReadCallback->ScheduleCallback(UDP_READ_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  2312.     m_bInRead = FALSE;
  2314.     return theErr;
  2315. }
  2317. STDMETHODIMP HXUDPSocket::Write(IHXBuffer* pBuffer)
  2318. {
  2319.     if (!m_bInitComplete)
  2320.     {
  2321. HX_RESULT ret = Bind(HXR_INADDR_ANY, 0);
  2322. if (HXR_OK != ret)
  2323.     return HXR_UNEXPECTED;
  2324.     }
  2325.     HX_RESULT theErr = HXR_OK;
  2326.     HX_RESULT lResult = HXR_OK;
  2328. #if 0
  2329.     struct in_addr in;
  2330.     in.s_addr = m_sockAddr.sin_addr.s_addr;
  2331.     char* address = inet_ntoa(in);
  2332.     printf("address = %s:", address);
  2333.     UINT32 port = ntohl(m_sockAddr.sin_port);
  2334.     printf("%dn", port);
  2335. #endif /* 0 */
  2337. #ifdef _MACINTOSH
  2338. if (m_pInterruptSafeMacWriteQueue)
  2339. m_pInterruptSafeMacWriteQueue->AddTail(pBuffer); // AddRef called inside
  2340. #else
  2341. pBuffer->AddRef();
  2342. m_WriteBuffers.AddTail((void*) pBuffer);
  2343. #endif
  2346.     m_pMutex->Lock();
  2347.     theErr = DoWrite();
  2348.     m_pMutex->Unlock();
  2350.     lResult = ConvertNetworkError(theErr);
  2352.     return lResult;
  2353. }
  2355. STDMETHODIMP HXUDPSocket::WriteTo(ULONG32 ulAddr,
  2356.     UINT16 nPort, IHXBuffer* pBuffer)
  2357. {
  2358.     if (!m_bInitComplete)
  2359.     {
  2360. HX_RESULT ret = Bind(HXR_INADDR_ANY, 0);
  2361. if (HXR_OK != ret)
  2362.     return HXR_UNEXPECTED;
  2363.     }
  2365.     m_sockAddr.sin_family = AF_INET;
  2366.     m_sockAddr.sin_addr.s_addr = DwToNet(ulAddr);   //*(long*)&ulAddr;
  2367.     m_sockAddr.sin_port = WToNet(nPort);
  2369.     return (Write(pBuffer));
  2370. }
  2372. STDMETHODIMP HXUDPSocket::GetLocalPort(UINT16& nPort)
  2373. {
  2374.     // Get the local port from the socket info
  2375.     nPort = m_pData->get_local_port();
  2377.     return (INT16)nPort < 0 ? HXR_OK : HXR_FAIL;
  2378. }
  2380. STDMETHODIMP HXUDPSocket::JoinMulticastGroup(
  2381.     ULONG32     ulMulticastAddr,
  2382.     ULONG32     ulInterfaceAddr)
  2383. {
  2384. #if defined(HELIX_FEATURE_TRANSPORT_MULTICAST)
  2385.     HX_RESULT theErr = HXR_OK;
  2386.     HX_RESULT lResult = HXR_OK;
  2388.     m_pMutex->Lock();
  2389.     theErr = m_pData->join_multicast_group(ulMulticastAddr, ulInterfaceAddr);
  2390.     lResult = ConvertNetworkError(theErr);
  2391.     m_pMutex->Unlock();
  2393.     return lResult;
  2394. #else
  2395.     return HXR_NOTIMPL;
  2396. #endif /* HELIX_FEATURE_TRANSPORT_MULTICAST */
  2397. }
  2399. STDMETHODIMP HXUDPSocket::LeaveMulticastGroup(
  2400.     ULONG32     ulMulticastAddr,
  2401.     ULONG32     ulInterfaceAddr)
  2402. {
  2403. #if defined(HELIX_FEATURE_TRANSPORT_MULTICAST)
  2404.     HX_RESULT theErr = HXR_OK;
  2405.     HX_RESULT lResult = HXR_OK;
  2407.     m_pMutex->Lock();
  2408.     theErr = m_pData->leave_multicast_group(ulMulticastAddr, ulInterfaceAddr);
  2409.     while (!m_ReadBuffers.IsEmpty())
  2410.     {
  2411. UDP_PACKET* pPacket = (UDP_PACKET*)m_ReadBuffers.RemoveHead();
  2413. HX_RELEASE(pPacket->pBuffer);
  2414. HX_DELETE(pPacket);
  2415.     }
  2416.     lResult = ConvertNetworkError(theErr);
  2417.     m_pMutex->Unlock();
  2419.     return lResult;
  2420. #else
  2421.     return HXR_NOTIMPL;
  2422. #endif /* HELIX_FEATURE_TRANSPORT_MULTICAST */
  2423. }
  2425. HX_RESULT
  2426. HXUDPSocket::DoRead()
  2427. {
  2428. #ifdef _MACINTOSH
  2429. if (m_bInDoRead)
  2430. return HXR_OK; // whatever needs to be done will be done by the caller that's already here.
  2432. // xxxbobclark the m_bInDoRead flag is hacked around calling ReadDone(), because
  2433. //             ReadDone() may call Read() which in turn calls us here, and we do
  2434. //             not want to bail out in that instance. (Otherwise we only remove
  2435. //             one packet at a time, which, given the scheduler granularity and
  2436. //             high bit rates, implies that our bandwidth would be too low.)
  2437. #endif
  2438. m_bInDoRead = TRUE;
  2440.     HX_RESULT theErr = HXR_OK;
  2441.     IHXBuffer* pBuffer = 0;
  2442.     UINT32  ulAddress = 0;
  2443.     UINT16  ulPort = 0;
  2444.     UINT16  count = 0;
  2447.     do
  2448.     {
  2449. /*
  2450.  * Must reset count before every read
  2451.  */
  2452. count = TCP_BUF_SIZE;
  2454. theErr = m_pData->readfrom(pBuffer, ulAddress, ulPort);
  2456. if (!theErr && pBuffer)
  2457. {
  2458.     UDP_PACKET* pPacket = new UDP_PACKET;
  2460.     pPacket->pBuffer = pBuffer;
  2461.     pPacket->ulAddress = ulAddress;
  2462.     pPacket->ulPort = ulPort;
  2464.     m_ReadBuffers.AddTail((void*)pPacket);
  2465. }
  2466. else
  2467. {
  2468.     count = 0;
  2469. }
  2470.     } while (!theErr && count > 0);
  2472.     if (m_bReadPending && m_ReadBuffers.GetCount() > 0)
  2473.     {
  2474. /* If we are at interrupt time and the response object is not
  2475.  * interrupt safe, schedule a callback to return back the data
  2476.  */
  2477. if (!IsSafe())
  2478. {
  2479. m_bInDoRead = FALSE;
  2480.     return HXR_AT_INTERRUPT;
  2481. }
  2483. m_bReadPending = FALSE;
  2485. UDP_PACKET* pPacket = (UDP_PACKET*)m_ReadBuffers.RemoveHead();
  2486. pBuffer = pPacket->pBuffer;
  2487. ulAddress = pPacket->ulAddress;
  2488. ulPort = pPacket->ulPort;
  2490. AddRef();
  2493. m_bInDoRead = FALSE;
  2494. m_pUDPResponse->ReadDone(HXR_OK, pBuffer, ulAddress, ulPort);
  2495. m_bInDoRead = TRUE;
  2497. HX_RELEASE(pBuffer);
  2498. HX_DELETE(pPacket);
  2500. Release();
  2502. m_bInDoRead = FALSE;
  2503. return HXR_OK;
  2504.     }
  2506.     /* if we called from within Read(), we will schedule a callback there, if necessary */
  2507.     if (!m_bInRead && m_pSchedulerReadCallback)
  2508.     m_pSchedulerReadCallback->ScheduleCallback(UDP_READ_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  2510. m_bInDoRead = FALSE;
  2511. return theErr;
  2512. }
  2514. HX_RESULT
  2515. HXUDPSocket::DoWrite()
  2516. {
  2517.     HX_RESULT theErr = HXR_OK;
  2519.     if (m_bInWrite) return HXR_OK;
  2520.     m_bInWrite = TRUE;
  2522. #ifdef _MACINTOSH
  2523. if (m_pInterruptSafeMacWriteQueue)
  2524. m_pInterruptSafeMacWriteQueue->TransferToSimpleList(m_WriteBuffers);
  2525. #endif
  2527.     while (!theErr && m_WriteBuffers.GetCount() > 0)
  2528.     {
  2529. IHXBuffer* pBuffer = (IHXBuffer*) m_WriteBuffers.GetHead();
  2530. UINT16 uLength = (UINT16) pBuffer->GetSize();
  2531. theErr = m_pData->writeto(  pBuffer->GetBuffer(),   // sendto
  2532.     &uLength,
  2533.     (UINT32) m_sockAddr.sin_addr.s_addr,
  2534.     WToHost(m_sockAddr.sin_port));
  2535. if (!theErr)
  2536. {
  2537.     pBuffer->Release();
  2538.     m_WriteBuffers.RemoveHead();
  2539. }
  2540.     }
  2542.     if (m_pSchedulerWriteCallback &&
  2543. m_WriteBuffers.GetCount() > 0)
  2544.     {
  2545.     m_pSchedulerWriteCallback->ScheduleCallback(UDP_WRITE_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  2546.     }
  2548.     m_bInWrite = FALSE;
  2550.     return theErr;
  2551. }
  2553. /* If we are at interrupt time and the response object is not interrupt safe,
  2554.  * schedule a callback to return back the data
  2555.  */
  2556. BOOL
  2557. HXUDPSocket::IsSafe()
  2558. {
  2559.     if (m_pInterruptState && m_pInterruptState->AtInterruptTime() &&
  2560. (!m_pResponseInterruptSafe ||
  2561.  !m_pResponseInterruptSafe->IsInterruptSafe()))
  2562.     {
  2563. if (m_pNonInterruptReadCallback){
  2564. m_pNonInterruptReadCallback->ScheduleCallback(UDP_READ_COMMAND, m_pScheduler, 0);
  2565. }
  2567. return FALSE;
  2568.     }
  2570.     return TRUE;
  2571. }
  2573. STDMETHODIMP HXUDPSocket::HandleCallback(INT32  theCommand, HX_RESULT theError)
  2574. {
  2575.     HX_RESULT theErr = HXR_OK;
  2576.     if (!m_bInDestructor)
  2577.     {
  2578. AddRef();
  2579. m_pMutex->Lock();
  2580. if (!m_bInDestructor)
  2581. {
  2582. switch(theCommand)
  2583. {
  2584. case UDP_READ_COMMAND:
  2585.     theErr = DoRead();
  2586.     break;
  2588. case UDP_WRITE_COMMAND:
  2589.     theErr = DoWrite();  // protected from re-entry by m_bInWrite
  2590.     break;
  2592. default:
  2593.     theErr = DoRead();
  2594.                             if( theErr == HXR_OK )
  2595.                             {
  2596.         theErr = DoWrite();
  2597.                             }
  2598.     break;
  2599.     }
  2600. }
  2601. m_pMutex->Unlock();
  2602. Release();
  2603.     }
  2605.     return theErr;
  2606. }
  2609. HX_RESULT HXUDPSocket::UDPSocketCallback::Func(NotificationType Type,
  2610.        BOOL bSuccess, conn* pConn)
  2611. {
  2612.     if(m_pContext)
  2613.     {
  2614. switch (Type)
  2615. {
  2616. case READ_NOTIFICATION:
  2617. #if defined(_UNIX_THREADED_NETWORK_IO)
  2618.             if( !ReadNetworkThreadingPref((IUnknown*)(m_pContext->m_pContext)) )
  2619.             {
  2620.                 m_pContext->AddRef();
  2621.                 m_pContext->m_pMutex->Lock();
  2622.                 m_pContext->DoRead();
  2623.                 m_pContext->m_pMutex->Unlock();
  2624.                 m_pContext->Release();
  2625.             }
  2626. #elif !defined (THREADS_SUPPORTED) && !defined(_MACINTOSH)
  2627.     m_pContext->AddRef();
  2628.     m_pContext->m_pMutex->Lock();
  2629.     m_pContext->DoRead();
  2630.     m_pContext->m_pMutex->Unlock();
  2631.     m_pContext->Release();
  2632. #endif
  2633.     break;
  2634. case WRITE_NOTIFICATION:
  2635. #if defined(_UNIX_THREADED_NETWORK_IO)
  2636.             if( !ReadNetworkThreadingPref((IUnknown*)(m_pContext->m_pContext)) )
  2637.             {
  2638.                 m_pContext->AddRef();
  2639.                 m_pContext->m_pMutex->Lock();
  2640.                 m_pContext->DoWrite();
  2641.                 m_pContext->m_pMutex->Unlock();
  2642.                 m_pContext->Release();
  2643.             }
  2644. #elif !defined (THREADS_SUPPORTED) && !defined(_MACINTOSH)
  2645.     m_pContext->AddRef();
  2646.     m_pContext->m_pMutex->Lock();
  2647.     m_pContext->DoWrite();
  2648.     m_pContext->m_pMutex->Unlock();
  2649.     m_pContext->Release();
  2650. #endif
  2651.     break;
  2652. case CONNECT_NOTIFICATION:
  2653. default:
  2654.     break;
  2655. }
  2656.     }
  2657.     return HXR_OK;
  2658. }
  2661. STDMETHODIMP
  2662. HXUDPSocket::SetOption(HX_SOCKET_OPTION option, UINT32 ulValue)
  2663. {
  2664.     HX_RESULT res = HXR_OK;
  2666.     switch(option)
  2667.     {
  2668.     case HX_SOCKOPT_REUSE_ADDR:
  2669. m_bReuseAddr = (BOOL)ulValue;
  2670.     break;
  2671.     case HX_SOCKOPT_REUSE_PORT:
  2672. m_bReusePort = (BOOL)ulValue;
  2673.     break;
  2674. case HX_SOCKOPT_BROADCAST:
  2675. {
  2676. HX_RESULT theErr = HXR_OK;
  2677. if(m_pData)
  2678. {
  2679. m_pMutex->Lock();
  2680. theErr = m_pData->set_broadcast(ulValue);
  2681. res = ConvertNetworkError(theErr);
  2682. m_pMutex->Unlock();
  2683. }
  2684. }
  2685. break;
  2686.     case HX_SOCKOPT_MULTICAST_IF:
  2687. if (m_pData)
  2688. {
  2689.     res = m_pData->set_multicast_if(ulValue);
  2690. }
  2691. break;
  2692.     case HX_SOCKOPT_SET_SENDBUF_SIZE:
  2693.     {
  2694.       if (m_pData)
  2695.       {
  2696.           HX_RESULT theErr = HXR_OK;
  2698.            m_pMutex->Lock();
  2699.            theErr = m_pData->set_send_size(ulValue);
  2700.            res = ConvertNetworkError(theErr);
  2701.            m_pMutex->Unlock();
  2702.       }
  2703.       break;
  2704.     }
  2705.     default:
  2706. HX_ASSERT(!"I don't know this option");
  2707. res = HXR_FAIL;
  2708.     }
  2710.     return res;
  2711. }
  2713. STDMETHODIMP
  2714. HXUDPSocket::SetOption(HX_PRIVATE_SOCKET_OPTION option, UINT32 ulValue)
  2715. {
  2716.     HX_RESULT res = HXR_OK;
  2718.     switch(option)
  2719.     {
  2720.     case HX_PRIVATE_SOCKOPT_IGNORE_WSAECONNRESET:
  2721.     {
  2722. if (m_pData)
  2723. {
  2724.     m_pMutex->Lock();
  2725.     m_pData->IgnoreWSAECONNRESET((BOOL)ulValue);
  2726.     m_pMutex->Unlock();
  2727. }
  2728. break;
  2729.     }
  2730.     default:
  2731. HX_ASSERT(!"I don't know this option");
  2732. res = HXR_FAIL;
  2733.     }
  2734.     return HXR_OK;
  2735. }
  2737. #ifdef _MACINTOSH
  2739. /////////////////////////////////////////////////////////////////////////
  2740. //
  2741. // InterruptSafeMacQueue
  2742. //
  2743. // For passing data between an interrupt and anything else (mac only).
  2744. //
  2745. InterruptSafeMacQueue::InterruptSafeMacQueue()
  2746. {
  2747.   mQueueHeader.qFlags=0;
  2748. mQueueHeader.qHead=0;
  2749. mQueueHeader.qTail=0;
  2750. mDestructing = FALSE; // just a safety check
  2751. }
  2753. /////////////////////////////////////////////////////////////////////////
  2754. //
  2755. HX_RESULT InterruptSafeMacQueue::AddTail(IUnknown* pObject)
  2756. {
  2757. if (pObject && !mDestructing)
  2758. {
  2759.     IhxQueueElement * theElement = new IhxQueueElement();
  2761.     if (theElement)
  2762.     {
  2763.     theElement->mNextElementInQueue = NULL;
  2764.     theElement->mObject = pObject;
  2765.     theElement->mObject->AddRef();
  2766.     ::Enqueue((QElem *)theElement, &mQueueHeader);
  2768.     //
  2769.     // If someone interrupts and enters the destructor while we're in here,
  2770.     // then the pObject and the new node will be leaked.  This shouldn't
  2771.     // happen since we should have shut down all interrupts that would
  2772.     // be adding items to the queue long before we start destructing it.
  2773.     //
  2775.     HX_ASSERT(!mDestructing); // if we DID enter the destructor, let the programmer know...
  2776.     }
  2778.     return HXR_OK;
  2779.     }
  2781.     return HXR_FAILED;
  2782. }
  2784. /////////////////////////////////////////////////////////////////////////
  2785. //
  2786. IUnknown * InterruptSafeMacQueue::RemoveHead()
  2787. {
  2788. //
  2789.     // POINT A
  2790.     //
  2791.     // You can look at the qHead anytime you want, but you can't USE a
  2792.     // pointer unless it's OFF of the queue.  Basically you do a Dequeue,
  2793.     // and if it succeeds then you know nobody else has it.  If it fails,
  2794.     // an error is returned and you don't mess with it.
  2795.     //
  2797. if (mQueueHeader.qHead)
  2798.     {
  2799.   IhxQueueElement * theElement = (IhxQueueElement *) mQueueHeader.qHead;
  2801. if (theElement)
  2802. {
  2803. OSErr e = ::Dequeue( (QElemPtr) theElement, &mQueueHeader );
  2805. //
  2806. // Between points A and D, we can't be guaranteed that the queue header and theElement are valid.  But
  2807. // Dequeue will TELL us if that pointer is still valid by its return code.  If it can't remove the item
  2808. // from the queue, then somebody else did and the pointer is no longer ours.  If no error was returned
  2809. // from dequeue, then it's ours to mess with.
  2810. //
  2812. if (e == noErr)
  2813. {
  2814. // at this point we know that we can do whatever we need to with the object.
  2815. IUnknown * theObj = theElement->mObject;
  2816. delete theElement; // delete the node
  2817. return theObj;
  2818. }
  2819. }
  2820.    }
  2822.    return NULL;
  2823. }
  2825. /////////////////////////////////////////////////////////////////////////
  2826. //
  2827. HX_RESULT InterruptSafeMacQueue::TransferToSimpleList(CHXSimpleList &simpleList)
  2828. {
  2829. IUnknown * theObject;
  2831. // we did an AddRef in the AddTail call -- just pass it along to the simplelist
  2832. while ((theObject = RemoveHead()) != 0)
  2833. {
  2834. simpleList.AddTail((void *)theObject);
  2835. }
  2837.    return HXR_OK;
  2838. }
  2840. /////////////////////////////////////////////////////////////////////////
  2841. //
  2842. InterruptSafeMacQueue::~InterruptSafeMacQueue()
  2843. {
  2844. mDestructing = TRUE; // don't add anything else to the queue
  2846. IUnknown * theObject;
  2848. while ((theObject = RemoveHead()) != 0)
  2849.     {
  2850. theObject->Release();
  2851.     }
  2853.     // and just to be safe...
  2854. mQueueHeader.qHead=0;
  2855. mQueueHeader.qTail=0;
  2856. }
  2858. #endif // _MACINTOSH