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

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

Symbian

开发平台：

C/C++

hxnetapi.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: RCSL 1.0/RPSL 1.0
  3.  *
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved.
  5.  *
  6.  * The contents of this file, and the files included with this file, are
  7.  * subject to the current version of the RealNetworks Public Source License
  8.  * Version 1.0 (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the RealNetworks Community Source License Version 1.0
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl,
  12.  * in which case the RCSL will apply. You may also obtain the license terms
  13.  * directly from RealNetworks.  You may not use this file except in
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or
  16.  * RCSL for the rights, obligations and limitations governing use of the
  17.  * contents of the file.
  18.  *
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the
  20.  * developer of the Original Code and owns the copyrights in the portions
  21.  * it created.
  22.  *
  23.  * This file, and the files included with this file, is distributed and made
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  28.  *
  29.  * Technology Compatibility Kit Test Suite(s) Location:
  30.  *    http://www.helixcommunity.org/content/tck
  31.  *
  32.  * Contributor(s):
  33.  *
  34.  * ***** END LICENSE BLOCK ***** */
  36. #include "hxtypes.h"
  37. #include "hxresult.h"
  38. #include "hxcom.h"
  39. #include "hxcomm.h"
  40. #include "hxprefs.h"
  41. #include "hxerror.h"
  43. #if defined(_MACINTOSH)
  44. #include "hx_moreprocesses.h"
  45. #endif /* _MACINTOSH. */
  47. #include "ihxpckts.h"
  48. #include "hxfiles.h"
  49. #include "chxpckts.h"
  50. #include "hxengin.h"
  51. #include "hxpnets.h"
  53. #include "hxtick.h"
  54. #include "hxstrutl.h"
  56. #include "chxuuid.h"
  57. #include "rtsputil.h"
  59. #include "hxslist.h"
  60. #include "cbqueue.h"
  61. #include "growingq.h"
  62. #include "dbcs.h"
  63. #include "conn.h"
  64. #include "hxmarsh.h"
  65. #include "hxthread.h"
  66. #include "hxcore.h"
  68. #if defined (_UNIX)
  69. #include "unix_net.h"
  70. #include "platform/unix/hxsignal.h"
  71. #elif defined (_WIN32) || defined (_WINDOWS)
  72. #include "win_net.h"
  73. #elif defined(__TCS__)
  74. #include "platform/tm1/tm1_net.h"
  75. #elif defined (_MACINTOSH)
  76. #ifndef _MAC_MACHO
  77. #include "OpenTptInternet.h" //for AF_INET
  78. #endif
  79. #include "mac_net.h"
  80. #include "macsockets.h"
  81. #endif
  83. #include "threngin.h"
  85. #include "netbyte.h"
  86. #include "hxnetapi.h"
  87. #include "hxnetutil.h"
  89. #if defined(HELIX_FEATURE_HTTPCLOAK)
  90. #include "hxcloakedtcp.h"
  91. #endif /* HELIX_FEATURE_HTTPCLOAK */
  93. #include "hxheap.h"
  95. #include "hxprefs.h"
  96. #include "hxprefutil.h"
  98. #ifdef _DEBUG
  99. #undef HX_THIS_FILE
  100. static const char HX_THIS_FILE[] = __FILE__;
  101. #endif
  103. #ifdef _WIN16
  104. extern HINSTANCE g_hInstance;       // initialized inside DLLMAIN.CPP(core.dll)
  105. #endif
  107. const int UDP_CHUNK_SIZE = 1024;
  109. #define QUEUE_START_SIZE    512
  111. #if defined _WINDOWS && !defined _WIN32  // for win16
  112. #define DESIRED_RCV_BUFSIZE 0xFFFF  // ~ 525 KBits
  113. #else
  114. #define DESIRED_RCV_BUFSIZE 0x0002FFFF // ~ 1.5 MBits
  115. #endif //defined _WINDOWS && !defined _WIN32
  117. #ifdef _WINCE
  118. #define SCHED_GRANULARITY 10
  119. #else
  120. #define SCHED_GRANULARITY 50
  121. #endif
  123. // same for all the platforms...may need to tweak it, if necessary
  124. #define MAX_ITERATION_COUNT 200
  126. #if defined( _UNIX )
  127. BOOL ReadAsyncDNSPref( IUnknown* pContext )
  128. {
  129.     static BOOL bNoAsyncDNS  = FALSE;
  130.     static BOOL bNeedToLoad  = TRUE;
  132.     if( bNeedToLoad && NULL!=pContext)
  133.     {
  134.         IHXPreferences* pPreferences = NULL;
  136.         bNeedToLoad = FALSE;
  137.         pContext->QueryInterface(IID_IHXPreferences, (void **)&pPreferences);
  139.         IHXBuffer *pBuffer = NULL;
  140.         if( NULL!=pPreferences )
  141.         {
  142.             pPreferences->ReadPref("NoAsyncDNS", pBuffer);
  143.             if (pBuffer)
  144.             {
  145.                 bNoAsyncDNS = (atoi((const char*)pBuffer->GetBuffer()) == 1);
  146.                 HX_RELEASE(pBuffer);
  147.             }
  148.             HX_RELEASE( pPreferences );
  149.         } // NULL!=pPreferences
  150.     }//bNeedToLoad && NULL!=pContext
  152.     return bNoAsyncDNS;
  153. }
  155. BOOL ReadThreadedDNSPref( IUnknown* pContext )
  156. {
  157.     static BOOL bThreadedDNS = TRUE;
  158.     static BOOL bNeedToLoad  = TRUE;
  160.     if( bNeedToLoad && NULL!=pContext)
  161.     {
  162.         IHXPreferences* pPreferences = NULL;
  164.         bNeedToLoad = FALSE;
  165.         pContext->QueryInterface(IID_IHXPreferences, (void **)&pPreferences);
  167.         IHXBuffer *pBuffer = NULL;
  168.         if( NULL!=pPreferences )
  169.         {
  170.             pPreferences->ReadPref("ThreadedDNS", pBuffer);
  171.             if (pBuffer)
  172.             {
  173.                 bThreadedDNS = (atoi((const char*)pBuffer->GetBuffer()) == 1);
  174.                 HX_RELEASE(pBuffer);
  175.             }
  176.             else
  177.             {
  178.                 //XXXGFW HACK!! REMOVE AFTER RNC
  179.                 //Pref was not found. It defaults to ON now so lets see if we
  180.                 //are running under a player. If not, turn it off.
  181.                 IHXClientEngine* pEngine = NULL;
  182.                 if(HXR_OK == pContext->QueryInterface(IID_IHXClientEngine, (void**)&pEngine))
  183.                 {
  184.                     //We have client Engine. Do nothing.
  185.                     HX_RELEASE( pEngine );
  186.                 }
  187.                 else
  188.                 {
  189.                     //We don't have a client engine. Turn off threading...
  190.                     bThreadedDNS = FALSE;
  191.                 }
  192.             }
  194.             HX_RELEASE( pPreferences );
  195.         } // NULL!=pPreferences
  196.     }//bNeedToLoad && NULL!=pContext
  198.     return bThreadedDNS;
  199. }
  201. #endif
  203. #if !defined(HELIX_CONFIG_NOSTATICS)
  204. UINT16 HXNetworkServices::z_muNumDriverInstance = 0;
  205. #else
  206. #include "globals/hxglobals.h"
  207. const UINT16 HXNetworkServices::z_muNumDriverInstance = 0;
  208. #endif
  210. /* HXNetworkServices */
  211. HXNetworkServices::HXNetworkServices(IUnknown* pContext)
  212. {
  213.     m_bNeedToCleanupDrivers = FALSE;
  214.     m_lRefCount = 0;
  215.     m_pContext = pContext;
  217.     if (m_pContext)
  218.     {
  219. m_pContext->AddRef();
  220.     }
  221. }
  223. HXNetworkServices::~HXNetworkServices()
  224. {
  225.     Close();
  226. }
  228. STDMETHODIMP HXNetworkServices::QueryInterface(REFIID riid, void** ppvObj)
  229. {
  230.     QInterfaceList qiList[] =
  231.         {
  232.             { GET_IIDHANDLE(IID_IHXNetworkServices), (IHXNetworkServices*)this },
  233.             { GET_IIDHANDLE(IID_IHXNetworkInterfaceEnumerator), (IHXNetworkInterfaceEnumerator*)this },
  234. #if defined(HELIX_FEATURE_HTTPCLOAK)
  235.             { GET_IIDHANDLE(IID_IHXCloakedNetworkServices), (IHXCloakedNetworkServices*)this },
  236. #endif /* HELIX_FEATURE_HTTPCLOAK */
  237.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXNetworkServices*)this },
  238.         };
  240.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  241. }
  243. STDMETHODIMP_(ULONG32) HXNetworkServices::AddRef()
  244. {
  245.     return InterlockedIncrement(&m_lRefCount);
  246. }
  248. STDMETHODIMP_(ULONG32) HXNetworkServices::Release()
  249. {
  250.     if (InterlockedDecrement(&m_lRefCount) > 0)
  251.     {
  252.         return m_lRefCount;
  253.     }
  255.     delete this;
  256.     return 0;
  257. }
  259. void
  260. HXNetworkServices::UseDrivers()
  261. {
  262.     if (!m_bNeedToCleanupDrivers)
  263.     {
  264. m_bNeedToCleanupDrivers = TRUE;
  266. #if defined(HELIX_CONFIG_NOSTATICS)
  267. UINT16& z_muNumDriverInstance = (UINT16&)
  268.     HXGlobalInt16::Get(&HXNetworkServices::z_muNumDriverInstance);
  269. #endif
  270. z_muNumDriverInstance++;
  271.     }
  272. }
  274. void
  275. HXNetworkServices::Close()
  276. {
  277.     HX_RELEASE(m_pContext);
  279.     if (m_bNeedToCleanupDrivers)
  280.     {
  281. m_bNeedToCleanupDrivers = FALSE;
  283. #if defined(HELIX_CONFIG_NOSTATICS)
  284. UINT16& z_muNumDriverInstance = (UINT16&)
  285.     HXGlobalInt16::Get(&HXNetworkServices::z_muNumDriverInstance);
  286. #endif
  288. z_muNumDriverInstance--;
  290. if (z_muNumDriverInstance == 0)
  291. {
  292. #if defined(THREADS_SUPPORTED)
  293.             ThreadEngine::DestroyThreadEngine();
  294. #elif defined(_UNIX_THREADED_NETWORK_IO)
  295.             if( ReadNetworkThreadingPref((IUnknown*)m_pContext) )
  296.                 ThreadEngine::DestroyThreadEngine();
  297. #endif
  298.     conn::close_drivers(NULL);
  299. }
  300.     }
  301. }
  303. STDMETHODIMP
  304. HXNetworkServices::CreateTCPSocket(IHXTCPSocket** ppTCPSocket)
  305. {
  306.     *ppTCPSocket = new HXTCPSocket(m_pContext, this);
  307.     if (*ppTCPSocket == NULL)
  308.     {
  309. return HXR_OUTOFMEMORY;
  310.     }
  312.     (*ppTCPSocket)->AddRef();
  313.     return HXR_OK;
  314. }
  316. STDMETHODIMP
  317. HXNetworkServices::CreateUDPSocket(IHXUDPSocket** ppUDPSocket)
  318. {
  319.     *ppUDPSocket = new HXUDPSocket(m_pContext, this);
  320.     if (*ppUDPSocket == NULL)
  321.     {
  322. return HXR_OUTOFMEMORY;
  323.     }
  325.     (*ppUDPSocket)->AddRef();
  326.     return HXR_OK;
  327. }
  329. STDMETHODIMP
  330. HXNetworkServices::CreateListenSocket(IHXListenSocket** ppListenSocket)
  331. {
  332.     *ppListenSocket = new HXListenSocket(m_pContext, this);
  333.     if (*ppListenSocket == NULL)
  334.     {
  335. return HXR_OUTOFMEMORY;
  336.     }
  338.     (*ppListenSocket)->AddRef();
  339.     return HXR_OK;
  340. }
  342. STDMETHODIMP
  343. HXNetworkServices::CreateResolver(IHXResolver** ppResolver)
  344. {
  345.     *ppResolver = new HXResolver(this, m_pContext);
  346.     if(*ppResolver == NULL)
  347.     {
  348. return HXR_OUTOFMEMORY;
  349.     }
  350.     (*ppResolver)->AddRef();
  351.     return HXR_OK;
  352. }
  354. STDMETHODIMP
  355. HXNetworkServices::CreateClientCloakedSocket(IHXTCPSocket** ppTCPSocket)
  356. {
  357. #if defined(HELIX_FEATURE_HTTPCLOAK)
  358.     *ppTCPSocket = new HXClientCloakedTCPSocket(m_pContext);
  359.     if (*ppTCPSocket == NULL)
  360.     {
  361. return HXR_OUTOFMEMORY;
  362.     }
  364.     (*ppTCPSocket)->AddRef();
  365.     return HXR_OK;
  366. #else
  367.     return HXR_NOTIMPL;
  368. #endif /* HELIX_FEATURE_HTTPCLOAK */
  369. }
  371. STDMETHODIMP
  372. HXNetworkServices::CreateServerCloakedSocket(IHXListenSocket** ppListenSocket)
  373. {
  374.     return HXR_NOTIMPL;
  375. }
  377. /* IHXNetworkInterfaceEnumerator */
  378. STDMETHODIMP
  379. HXNetworkServices::EnumerateInterfaces
  380.     (REF(UINT32*) pulInterfaces, REF(UINT32) ulNumInterfaces)
  381. {
  382.     return conn::EnumerateInterfaces(pulInterfaces, ulNumInterfaces);
  383. }
  385. /* HXResolver */
  386. HXResolver::HXResolver(HXNetworkServices* pNetworkServices):
  387.      m_lRefCount(0)
  388.     ,m_pCallback(0)
  389.     ,m_pResp(0)
  390.     ,m_bResolverPending(FALSE)
  391.     ,m_pData(0)
  392.     ,m_pNetworkServices(NULL)
  393. {
  394.     m_pNetworkServices = pNetworkServices;
  395.     m_pNetworkServices->AddRef();
  396. }
  398. HXResolver::HXResolver( HXNetworkServices* pNetworkServices,
  399.                           IUnknown*           pContext):
  400.      m_lRefCount(0)
  401.     ,m_pCallback(0)
  402.     ,m_pResp(0)
  403.     ,m_bResolverPending(FALSE)
  404.     ,m_pData(0)
  405.     ,m_pNetworkServices(NULL)
  406.     ,m_pContext( pContext )
  407. {
  408.     m_pNetworkServices = pNetworkServices;
  409.     m_pNetworkServices->AddRef();
  410. }
  412. HXResolver::~HXResolver()
  413. {
  414.     if (m_pData)
  415.     {
  416. m_pData->done();
  417. m_pData->Release();
  418. m_pData = 0;
  419.     }
  421.     if (m_pCallback)
  422.     {
  423. delete m_pCallback;
  424. m_pCallback = 0;
  425.     }
  427.     if (m_pResp)
  428.     {
  429. m_pResp->Release();
  430. m_pResp = 0;
  431.     }
  433. #if defined( _WIN32 ) || defined( _WINDOWS )
  434.     win_net::ReleaseWinsockUsage(this);
  435. #endif
  436.     HX_RELEASE(m_pNetworkServices);
  437. }
  439. STDMETHODIMP
  440. HXResolver::QueryInterface(REFIID riid, void** ppvObj)
  441. {
  442.     QInterfaceList qiList[] =
  443.         {
  444.             { GET_IIDHANDLE(IID_IHXResolver), (IHXResolver*)this },
  445.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXResolver*)this },
  446.         };
  448.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  449. }
  451. STDMETHODIMP_(ULONG32) HXResolver::AddRef()
  452. {
  453.     return InterlockedIncrement(&m_lRefCount);
  454. }
  456. STDMETHODIMP_(ULONG32) HXResolver::Release()
  457. {
  458.     if (InterlockedDecrement(&m_lRefCount) > 0)
  459.     {
  460.         return m_lRefCount;
  461.     }
  463.     delete this;
  464.     return 0;
  465. }
  467. STDMETHODIMP HXResolver::Init(IHXResolverResponse* pResp)
  468. {
  469.     if (!pResp)
  470.     {
  471. return HXR_UNEXPECTED;
  472.     }
  474.     if (m_pResp)
  475.     {
  476. m_pResp->Release();
  477. m_pResp = 0;
  478.     }
  480.     m_pResp = pResp;
  481.     m_pResp->AddRef();
  482.     return HXR_OK;
  483. }
  485. STDMETHODIMP HXResolver::GetHostByName(const char* pHostName)
  486. {
  487.     HX_RESULT theErr = HXR_OK;
  489.     if (!pHostName || m_bResolverPending)
  490.     {
  491. return HXR_UNEXPECTED;
  492.     }
  494.     if (!m_pCallback)
  495.     {
  496. m_pCallback = new HXResolverCallback;
  497. if (!m_pCallback)
  498. {
  499.     return HXR_OUTOFMEMORY;
  500. }
  501. m_pCallback->m_pContext = this;
  502.     }
  504.     /* Is this the first time we are calling gethostbyname */
  505.     if (!m_pData)
  506.     {
  507. #if defined( _WIN32 ) || defined( _WINDOWS )
  508. // Have we been able to load and initialize the winsock stuff yet?
  509. if (!win_net::IsWinsockAvailable(this))
  510. {
  511.     return HXR_FAIL; // HXR_GENERAL_NONET;
  512. }
  513. #endif
  514. m_pNetworkServices->UseDrivers();
  516. conn::init_drivers(NULL);
  517.     }
  519.     if (m_pData)
  520.     {
  521. m_pData->done();
  522. m_pData->Release();
  523. m_pData = 0;
  524.     }
  526. #ifdef _UNIX
  527.     //This one has to be set before we create a new socket.
  528.     conn::SetNetworkThreadingPref( ReadNetworkThreadingPref((IUnknown*)m_pContext) );
  529.     conn::SetThreadedDNSPref( ReadThreadedDNSPref((IUnknown*)m_pContext) );
  530. #endif
  532.     m_pData = conn::new_socket(HX_UDP_SOCKET);
  533.     if (!m_pData)
  534.     {
  535. return HXR_OUTOFMEMORY;
  536.     }
  538. #ifdef _UNIX
  539.     m_pData->SetAsyncDNSPref( ReadAsyncDNSPref((IUnknown*)m_pContext) );
  540. #endif
  542.     // XXXAAK -- local addr binding stuff
  543.     theErr = m_pData->init(INADDR_ANY, 0);
  545.     m_pData->nonblocking();
  546.     m_pData->set_callback(m_pCallback);
  548. #ifdef _WINDOWS
  549. #if defined (_WIN32)
  550.     ULONG32 ulPlatformData = (ULONG32)GetModuleHandle(NULL);
  551. #elif defined (_WIN16)
  552.     ULONG32 ulPlatformData = (ULONG32)(int)g_hInstance;
  553. #endif
  554.     m_pData->SetWindowHandle(ulPlatformData);
  555. #endif /* defined (_WINDOWS) */
  557.     m_bResolverPending = TRUE;
  558. #ifndef _WINCE
  559.     m_pData->dns_find_ip_addr(pHostName);
  560. #else
  561.     // Only blocking DNS
  562.     m_pData->dns_find_ip_addr(pHostName, 1);
  563. #endif
  565.     return HXR_OK;
  566. }
  568. void
  569. HXResolver::DNSDone(BOOL bSuccess)
  570. {
  571.     ULONG32 ulAddr = 0;
  572.     BOOL bIsValid = TRUE;
  573.     char*   pDottedIP = 0;
  575.     m_bResolverPending = FALSE;
  577.     AddRef();
  579.     if (bSuccess)
  580.     {
  581. m_pData->dns_ip_addr_found(&bIsValid, &ulAddr);
  582. UINT32 ulHostAddr = DwToHost(ulAddr);
  583. m_pResp->GetHostByNameDone(HXR_OK, ulHostAddr);
  584.     }
  585.     else
  586.     {
  587. m_pResp->GetHostByNameDone(HXR_DNR, 0);
  588.     }
  590.     Release();
  591. }
  594. HX_RESULT
  595. HXResolver::HXResolverCallback::Func(NotificationType Type,
  596.        BOOL bSuccess, conn* pConn)
  597. {
  598.     if(m_pContext)
  599.     {
  600. switch (Type)
  601. {
  602. case DNS_NOTIFICATION:
  603.     m_pContext->DNSDone(bSuccess);
  604.     break;
  605. case READ_NOTIFICATION:
  606. case WRITE_NOTIFICATION:
  607. case CONNECT_NOTIFICATION:
  608. default:
  609.     break;
  610. }
  611.     }
  612.     return HXR_OK;
  613. }
  616. /* HXTCPSocket */
  617. HXTCPSocket::HXTCPSocket(IUnknown* pContext, HXNetworkServices* pNetworkServices):
  618.      m_lRefCount(0)
  619.     ,m_pTCPResponse(0)
  620.     ,m_pCtrl(0)
  621.     ,m_lForeignAddress(0)
  622.     ,m_nForeignPort(0)
  623.     ,m_bReadPending(FALSE)
  624.     ,m_nRequired(0)
  625.     ,mSendTCP(0)
  626.     ,mReceiveTCP(0)
  627.     ,m_pBuffer(0)
  628.     ,m_pCallback(0)
  629.     ,m_bConnected(FALSE)
  630.     ,m_bWantWritePending(FALSE)
  631.     ,m_bInitComplete(FALSE)
  632.     ,m_bWriteFlushPending(FALSE)
  633.     ,m_pScheduler(0)
  634.     ,m_pSchedulerReadCallback(0)
  635.     ,m_pSchedulerWriteCallback(0)
  636.     ,m_bInRead(FALSE)
  637.     ,m_bInWrite(FALSE)
  638.     ,m_bInDoRead(FALSE)
  639.     ,m_pInterruptState(NULL)
  640.     ,m_pResponseInterruptSafe(NULL)
  641.     ,m_pMutex(NULL)
  642.     ,m_bInDestructor(FALSE)
  643.     ,m_pNonInterruptReadCallback(NULL)
  644.     ,m_pNetworkServices(NULL)
  645.     ,m_pPreferences(NULL)
  646.     ,m_bReuseAddr(FALSE)
  647.     ,m_bReusePort(FALSE)
  648.     ,m_pContext(pContext)
  649.     ,m_bSecureSocket(FALSE)
  650. {
  651.     m_pNetworkServices = pNetworkServices;
  652.     m_pNetworkServices->AddRef();
  654. #ifdef _MACINTOSH
  655. m_pInterruptSafeMacWriteQueue = new InterruptSafeMacQueue();
  656. HX_ASSERT(m_pInterruptSafeMacWriteQueue != NULL);
  657. #endif
  659.     if (pContext)
  660.     {
  661. pContext->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  662. pContext->QueryInterface(IID_IHXInterruptState, (void**) &m_pInterruptState);
  663. pContext->QueryInterface(IID_IHXPreferences, (void**) &m_pPreferences);
  664.     }
  666.     if (m_pScheduler)
  667.     {
  668. m_pSchedulerReadCallback = new ScheduledSocketCallback(this, TRUE);
  669. m_pSchedulerReadCallback->AddRef();
  671. m_pSchedulerWriteCallback = new ScheduledSocketCallback(this, TRUE);
  672. m_pSchedulerWriteCallback->AddRef();
  674. m_pNonInterruptReadCallback = new ScheduledSocketCallback(this, FALSE);
  675. m_pNonInterruptReadCallback->AddRef();
  677. #ifdef _MACINTOSH
  678. m_pMacCommandCallback = new ScheduledSocketCallback(this, FALSE);
  679. m_pMacCommandCallback->AddRef();
  680. #endif
  681.     }
  683. #if defined(_UNIX) && defined(HELIX_FEATURE_IGNORE_SIGPIPE)
  684.         // When the connection is closed by the server, SIGPIPE will be thrown
  685.         // in next write() and terminates the program abruptly.
  686.         //
  687.         // In order to gracefully exists the program, it's recommended to:
  688.         // - ignore the SIGPIPE and
  689.         // - checks the return code(errno) from write()
  690.         //
  691.         // for read(), it simply returns 0 when the connection is closed.
  692.         SIGNAL(SIGPIPE, SIG_IGN);
  693. #endif /* _UNIX  && HELIX_FEATURE_IGNORE_SIGPIPE */
  695. #if defined(THREADS_SUPPORTED)
  696.     HXMutex::MakeMutex(m_pMutex);
  697. #elif defined(_UNIX_THREADED_NETWORK_IO)
  698.     if( ReadNetworkThreadingPref((IUnknown*)m_pContext) )
  699.         HXMutex::MakeMutex(m_pMutex);
  700.     else
  701.         HXMutex::MakeStubMutex(m_pMutex);
  702. #else
  703.     HXMutex::MakeStubMutex(m_pMutex);
  704. #endif
  705. }
  707. HXTCPSocket::~HXTCPSocket()
  708. {
  709.     m_bInDestructor = TRUE; // set it early
  710.     m_pMutex->Lock();
  712. #ifdef _MACINTOSH
  713. HX_DELETE(m_pInterruptSafeMacWriteQueue); // will release any objects in its nodes
  714. #endif
  716.    if (m_pSchedulerReadCallback)
  717. m_pSchedulerReadCallback->Unschedule(m_pScheduler);
  719.    if (m_pSchedulerWriteCallback)
  720. m_pSchedulerWriteCallback->Unschedule(m_pScheduler);
  722.    if (m_pNonInterruptReadCallback)
  723. m_pNonInterruptReadCallback->Unschedule(m_pScheduler);
  725. #ifdef _MACINTOSH
  726. if (m_pMacCommandCallback)
  727. m_pMacCommandCallback->Unschedule(m_pScheduler);
  728. #endif
  730.     /*
  731.      * XXX...While handling the m_pCtrl->done it's possible for the
  732.      *       DispatchMessage call in CancelSelect to cause an
  733.      *       asynchronous DoRead to occur. The resulting AddRef/Release
  734.      *       would cause this object to be deleted again, so to prevent
  735.      *       this we set the m_pCallback->m_pContext = 0
  736.      */
  738.    if (m_pCallback)
  739.     {
  740. m_pCallback->m_pContext = 0;
  741.     }
  743. //#ifndef _UNIX
  744.     /* XXXJR I feel certain this is related to the above comment somehow.
  745.      *       Deleting the ctrl here wreaks havoc on the encoder.
  746.      *       This is a bad solution, but I don't really know
  747.      *       what the right one is.  This at least prevents random crashes
  748.      *       in the encoder.
  749.      *
  750.      * XXXGH commented out the #ifndef because it was breaking my
  751.      *       connectionless control stuff
  752.      *
  753.      */
  754.     if (m_pCtrl)
  755.     {
  756. m_pCtrl->done();
  757. m_pCtrl->Release(); // A deleted (0xdddddddd) pointer was used here.
  758. m_pCtrl = 0;
  759.     }
  760. //#endif
  762.     HX_RELEASE(m_pTCPResponse);
  763.     HX_DELETE(m_pCallback);
  764.     HX_DELETE(mSendTCP);
  765.     HX_DELETE(mReceiveTCP);
  766.     HX_VECTOR_DELETE(m_pBuffer);
  768.     while (m_PendingWriteBuffers.GetCount() > 0)
  769.     {
  770. IHXBuffer* pBuffer =
  771.     (IHXBuffer*) m_PendingWriteBuffers.RemoveHead();
  772. pBuffer->Release();
  773.     }
  775.     if (m_pSchedulerReadCallback)
  776.     {
  777.      m_pSchedulerReadCallback->m_pSocket = NULL;
  778.      m_pSchedulerReadCallback->Release();
  779.      m_pSchedulerReadCallback = NULL;
  780.     }
  782.     if (m_pSchedulerWriteCallback)
  783.     {
  784.      m_pSchedulerWriteCallback->m_pSocket = NULL;
  785.      m_pSchedulerWriteCallback->Release();
  786.      m_pSchedulerWriteCallback = NULL;
  787.     }
  789.     if (m_pNonInterruptReadCallback)
  790.     {
  791.      m_pNonInterruptReadCallback->m_pSocket = NULL;
  792.      m_pNonInterruptReadCallback->Release();
  793.      m_pNonInterruptReadCallback = NULL;
  794.     }
  796. #ifdef _MACINTOSH
  797.    if (m_pMacCommandCallback)
  798.     {
  799. m_pMacCommandCallback->m_pSocket = NULL;
  800. m_pMacCommandCallback->Release();
  801. m_pMacCommandCallback = NULL;
  802.     }
  803. #endif
  805.     HX_RELEASE(m_pInterruptState);
  806.     HX_RELEASE(m_pResponseInterruptSafe);
  807.     HX_RELEASE(m_pScheduler);
  809.     m_pMutex->Unlock();
  810.     HX_DELETE(m_pMutex);
  812. #if defined( _WIN32 ) || defined( _WINDOWS )
  813.     win_net::ReleaseWinsockUsage(this);
  814. #endif
  816.     HX_RELEASE(m_pNetworkServices);
  817.     HX_RELEASE(m_pPreferences);
  818. }
  820. STDMETHODIMP HXTCPSocket::QueryInterface(REFIID riid, void** ppvObj)
  821. {
  822.     QInterfaceList qiList[] =
  823.         {
  824.             { GET_IIDHANDLE(IID_IHXTCPSocket), (IHXTCPSocket*)this },
  825.             { GET_IIDHANDLE(IID_IHXSetSocketOption), (IHXSetSocketOption*)this },
  826.             { GET_IIDHANDLE(IID_IHXTCPSecureSocket), (IHXTCPSecureSocket*)this },
  827.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXTCPSocket*)this },
  828.         };
  830.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  831. }
  833. STDMETHODIMP_(ULONG32) HXTCPSocket::AddRef()
  834. {
  835.     return InterlockedIncrement(&m_lRefCount);
  836. }
  838. STDMETHODIMP_(ULONG32) HXTCPSocket::Release()
  839. {
  840.     if (InterlockedDecrement(&m_lRefCount) > 0)
  841.     {
  842.         return m_lRefCount;
  843.     }
  844.     else if (m_lRefCount < 0)
  845.     {
  846.      // double delete
  847.      return 0;
  848.     }
  850.     delete this;
  851.     return 0;
  852. }
  854. STDMETHODIMP HXTCPSocket::Init(IHXTCPResponse* pTCPResponse)
  855. {
  856.     if (!pTCPResponse)
  857.     {
  858. return HXR_UNEXPECTED;
  859.     }
  861.     m_pTCPResponse = pTCPResponse;
  862.     m_pTCPResponse->AddRef();
  864.     m_pTCPResponse->QueryInterface(IID_IHXInterruptSafe,
  865.    (void**) &m_pResponseInterruptSafe);
  867.     // allocate TCP send and receive queue
  868.     mSendTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  869.     if (!mSendTCP || !mSendTCP->IsQueueValid())
  870.     {
  871. return HXR_OUTOFMEMORY;
  872.     }
  873.     mSendTCP->SetMaxSize(TCP_BUF_SIZE);
  875.     mReceiveTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  876.     if (!mReceiveTCP || !mReceiveTCP->IsQueueValid())
  877.     {
  878. return HXR_OUTOFMEMORY;
  879.     }
  880.     mReceiveTCP->SetMaxSize(TCP_BUF_SIZE);
  882.     m_pBuffer = new char[TCP_BUF_SIZE];
  883.     if (!m_pBuffer)
  884.     {
  885. return HXR_OUTOFMEMORY;
  886.     }
  888.     return HXR_OK;
  889. }
  891. STDMETHODIMP HXTCPSocket::SetResponse(IHXTCPResponse* pTCPResponse)
  892. {
  893.     m_pMutex->Lock();
  894.     HX_RELEASE(m_pTCPResponse);
  895.     m_pTCPResponse = pTCPResponse;
  896.     m_pTCPResponse->AddRef();
  898.     HX_RELEASE(m_pResponseInterruptSafe);
  899.     m_pTCPResponse->QueryInterface(IID_IHXInterruptSafe,
  900.    (void**) &m_pResponseInterruptSafe);
  901.     m_pMutex->Unlock();
  902.     return HXR_OK;
  903. }
  905. STDMETHODIMP HXTCPSocket::Bind(UINT32 ulLocalAddr, UINT16 nPort)
  906. {
  907.     UINT32 ulMaxBandwidth = 0;
  908.     BOOL bEnforceMaxBandwidth = TRUE;
  909.     BOOL        bLoadTest = FALSE;
  910.     IHXBuffer* pBuffer = NULL;
  912.     if (m_bInitComplete)
  913. return HXR_UNEXPECTED;
  915.     m_nLocalPort = nPort;
  917. #if defined( _WIN32 ) || defined( _WINDOWS )
  918.     // Have we been able to load and initialize the winsock stuff yet?
  919.     if (!win_net::IsWinsockAvailable(this))
  920.     {
  921. return HXR_FAIL; // HXR_GENERAL_NONET;
  922.     }
  923. #endif
  925.     m_pNetworkServices->UseDrivers();
  927.     HX_RESULT theErr = conn::init_drivers(NULL);
  929. #ifdef _UNIX
  930.     //This one has to be set before we create a new socket.
  931.     conn::SetNetworkThreadingPref( ReadNetworkThreadingPref((IUnknown*)m_pContext) );
  932.     conn::SetThreadedDNSPref( ReadThreadedDNSPref((IUnknown*)m_pContext) );
  933. #endif
  936.     m_pCtrl = NULL;
  938. #if defined(HELIX_FEATURE_SECURECONN)
  939.     if (m_bSecureSocket)
  940.     {
  941. IHXSSL* pHXSSL = NULL;
  942. IHXCommonClassFactory* pCCF = NULL;
  944. if (m_pContext)
  945. {
  946.     m_pContext->AddRef();
  948.     // get the CCF
  949.     m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCCF);
  951.     HX_RELEASE(m_pContext);
  952. }
  954. if (pCCF)
  955. {
  956.     pCCF->CreateInstance(IID_IHXSSL, (void**) &pHXSSL);
  957.     HX_RELEASE(pCCF);
  958. }
  960. if (pHXSSL)
  961. {
  962.     m_pCtrl = new secureconn(pHXSSL);
  963.     pHXSSL->Release();
  964. }
  965.     }
  966.     else
  967. #endif /* HELIX_FEATURE_SECURECONN */
  968.     {
  969. m_pCtrl  = conn::new_socket(HX_TCP_SOCKET);
  970.     }
  973.     if (!m_pCtrl)
  974.     {
  975. return HXR_OUTOFMEMORY;
  976.     }
  978.     // XXXGo - As it is implemented, this is the only way...
  979.     if (m_bReuseAddr)
  980.     {
  981. if (m_pCtrl->reuse_addr(m_bReuseAddr) != HXR_OK)
  982. {
  983.     // err...what do we need to do?
  984.     HX_ASSERT(!"reuse_addr() failed");
  985. }
  986.     }
  987.     if (m_bReusePort)
  988.     {
  989. if (m_pCtrl->reuse_port(m_bReusePort) != HXR_OK)
  990. {
  991.     // err...what do we need to do?
  992.     HX_ASSERT(!"reuse_port() failed");
  993. }
  994.     }
  996. #ifdef _UNIX
  997.     m_pCtrl->SetAsyncDNSPref( ReadAsyncDNSPref((IUnknown*)m_pContext) );
  998. #endif
  1000.     m_pCtrl->nonblocking();
  1002.     m_pCallback = new TCPSocketCallback;
  1003.     if (!m_pCallback)
  1004.     {
  1005. return HXR_OUTOFMEMORY;
  1006.     }
  1007.     m_pCallback->m_pContext = this;
  1008.     m_pCtrl->set_callback(m_pCallback);
  1009.     m_bInitComplete = TRUE;
  1011.     if (m_pPreferences)
  1012.     {
  1013. /* Get MaxBandwidth from Prefs */
  1014. ReadPrefINT32(m_pPreferences, "MaxBandwidth", ulMaxBandwidth);
  1015. ReadPrefBOOL(m_pPreferences, "LoadTest", bLoadTest);
  1016. ReadPrefBOOL(m_pPreferences, "EnforceMaxBandwidth", bEnforceMaxBandwidth);
  1018. //If we are in load test mode, never enforce the MaxBandwidth.
  1019. bEnforceMaxBandwidth = bEnforceMaxBandwidth&&!bLoadTest;
  1021. if (ulMaxBandwidth && bEnforceMaxBandwidth)
  1022. {
  1023.     conn::m_ulMaxBandwidth = ulMaxBandwidth / 8;
  1024. }
  1025. else if (!bEnforceMaxBandwidth)
  1026. {
  1027.     conn::m_ulMaxBandwidth = MAX_UINT32;
  1028. }
  1029.     }
  1031.     return HXR_OK;
  1032. }
  1034. STDMETHODIMP HXTCPSocket::Connect(const char* pDestination,
  1035.    UINT16 nPort)
  1036. {
  1037.     if (!m_bInitComplete)
  1038.     {
  1039. HX_RESULT ret = Bind(HXR_INADDR_ANY, 0);
  1040. if (HXR_OK != ret)
  1041. return ret;
  1042.     }
  1044.     HX_RESULT theErr = HXR_OK;
  1045.     UINT32 ulPlatformData = 0;
  1047. #if defined (_WIN32)
  1048.     ulPlatformData = (UINT32)GetModuleHandle(NULL);
  1049. #elif defined (_WIN16)
  1050.     ulPlatformData = (UINT32)(int)g_hInstance;
  1051. #endif
  1053.     m_nForeignPort = nPort;
  1055. #ifndef _WINCE
  1056.     theErr = m_pCtrl->connect(pDestination,nPort,0,ulPlatformData);
  1057. #else
  1058.     theErr = m_pCtrl->connect(pDestination,nPort,1,ulPlatformData);
  1059. #endif
  1061.     theErr = ConvertNetworkError(theErr);
  1062.     return theErr;
  1063. }
  1065. STDMETHODIMP HXTCPSocket::Read(UINT16 uSize)
  1066. {
  1067.     HX_RESULT theErr = HXR_OK;
  1068.     HX_RESULT lResult = HXR_OK;
  1070.     if (m_bReadPending)
  1071.     {
  1072. return HXR_UNEXPECTED;
  1073.     }
  1075.     m_bReadPending  = TRUE;
  1076.     m_nRequired     = uSize;
  1078.     m_pMutex->Lock();
  1079.     theErr  = DoRead();
  1080.     m_pMutex->Unlock();
  1081.     lResult = ConvertNetworkError(theErr);
  1083.     return lResult;
  1084. }
  1086. STDMETHODIMP HXTCPSocket::Write(IHXBuffer* pBuffer)
  1087. {
  1088.     HX_RESULT theErr = HXR_OK;
  1089.     HX_RESULT lResult = HXR_OK;
  1091. #ifdef _MACINTOSH
  1092. if (m_pInterruptSafeMacWriteQueue)
  1093. m_pInterruptSafeMacWriteQueue->AddTail(pBuffer); // AddRef called inside
  1094. #else
  1095. pBuffer->AddRef();
  1096. m_PendingWriteBuffers.AddTail((void*) pBuffer);
  1097.     /* Transfer pending buffers to TCP send queue */
  1098.     TransferBuffers();
  1099. #endif
  1101. m_pMutex->Lock();
  1102.     theErr = DoWrite();
  1103.     m_pMutex->Unlock();
  1104.     lResult = ConvertNetworkError(theErr);
  1106.     return lResult;
  1107. }
  1109. STDMETHODIMP HXTCPSocket::WantWrite()
  1110. {
  1111.     if (mSendTCP->GetQueuedItemCount() == 0)
  1112.     {
  1113. m_pTCPResponse->WriteReady(HXR_OK);
  1114.     }
  1115.     else
  1116.     {
  1117. m_bWantWritePending = TRUE;
  1118.     }
  1120.     return HXR_OK;
  1121. }
  1123. STDMETHODIMP HXTCPSocket::GetLocalAddress(ULONG32& lAddress)
  1124. {
  1125.     return HXR_NOTIMPL;
  1126. }
  1128. STDMETHODIMP HXTCPSocket::GetForeignAddress(ULONG32& lAddress)
  1129. {
  1130.     if(m_bConnected && m_lForeignAddress)
  1131.     {
  1132. lAddress = m_lForeignAddress;
  1133. return HXR_OK;
  1134.     }
  1135.     return HXR_FAIL;
  1136. }
  1138. STDMETHODIMP HXTCPSocket::GetLocalPort(UINT16& port)
  1139. {
  1140.     return HXR_NOTIMPL;
  1141. }
  1143. STDMETHODIMP HXTCPSocket::GetForeignPort(UINT16& port)
  1144. {
  1145.     if(m_bConnected)
  1146.     {
  1147. port = m_nForeignPort;
  1148. return HXR_OK;
  1149.     }
  1150.     return HXR_FAIL;
  1151. }
  1153. // the tcp socket will still need to be inited
  1154. STDMETHODIMP
  1155. HXTCPSocket::AcceptConnection(conn* pNewConn)
  1156. {
  1157.     HX_ASSERT(!m_bConnected);
  1158.     HX_ASSERT(!m_bInitComplete);
  1159.     HX_ASSERT(m_pCtrl == NULL);
  1160.     m_pCtrl = pNewConn;
  1161.     m_pCtrl->AddRef();
  1162.     m_pCtrl->nonblocking();
  1164.     if ( m_pCallback )
  1165.     {
  1166. HX_DELETE(m_pCallback);
  1167.     }
  1168.     m_pCallback = new TCPSocketCallback;
  1169.     if ( !m_pCallback )
  1170.     {
  1171. return HXR_OUTOFMEMORY;
  1172.     }
  1173.     m_pCallback->m_pContext = this;
  1174.     m_pCtrl->set_callback(m_pCallback);
  1175.     m_lForeignAddress = DwToHost(m_pCtrl->get_addr());
  1177.     m_bInitComplete = TRUE;
  1178.     m_bConnected = TRUE;
  1180.     return HXR_OK;
  1181. }
  1183. HX_RESULT
  1184. HXTCPSocket::DoRead()
  1185. {
  1186. #ifdef _MACINTOSH
  1187. if (m_bInDoRead)
  1188. {
  1189. return HXR_OK; // whatever needs to be done will be done by the caller that's already here.
  1191. // xxxbobclark the m_bInDoRead flag is hacked around calling ReadDone(), because
  1192. //             ReadDone() may call Read() which in turn calls us here, and we do
  1193. //             not want to bail out in that instance. (Otherwise we only remove
  1194. //             one packet at a time, which, given the scheduler granularity and
  1195. //             high bit rates, implies that our bandwidth would be too low.)
  1196. }
  1197. #endif
  1198. m_bInDoRead = TRUE;
  1200.     HX_RESULT theErr = HXR_OK;
  1201.     // check how much room we have in TCP receive queue
  1202.     UINT16 count = mReceiveTCP->GetMaxAvailableElements();
  1204.     if (count > 0)
  1205.     {
  1206. #if !defined(THREADS_SUPPORTED) && !defined(_UNIX_THREADED_NETWORK_IO)
  1207. UINT32 ulBytesToRead = conn::bytes_to_preparetcpread(m_pCtrl);
  1209. if (ulBytesToRead > 0)
  1210. {
  1211.     if ((UINT32)count > ulBytesToRead)
  1212.     {
  1213. count = (UINT16)ulBytesToRead;
  1214.     }
  1216.     // attempt to read data from TCP link
  1217.     theErr = m_pCtrl->read(m_pBuffer, &count);
  1218.     if (!theErr && count > 0)
  1219.     {
  1220. conn::bytes_to_actualtcpread(m_pCtrl, (UINT32)count);
  1221. mReceiveTCP->EnQueue(m_pBuffer, count);
  1222.     }
  1223.     else if (theErr)
  1224.     {
  1225. theErr = ConvertNetworkError(theErr);
  1226.     }
  1227. }
  1228. #elif defined(_UNIX_THREADED_NETWORK_IO)
  1229.         //XXXgfw duplicated code. Clean this up...
  1230.         if( ReadNetworkThreadingPref((IUnknown*)m_pContext) )
  1231.         {
  1232.             // in THREADS_SUPPORTED mode, this will be taken care by the thrdconn.cpp
  1233.             // attempt to read data from TCP link
  1234.             theErr = m_pCtrl->read(m_pBuffer, &count);
  1235.             if (!theErr && count > 0)
  1236.             {
  1237.                 mReceiveTCP->EnQueue(m_pBuffer, count);
  1238.             }
  1239.             else if (theErr)
  1240.             {
  1241.                 theErr = ConvertNetworkError(theErr);
  1242.             }
  1243.         }
  1244.         else
  1245.         {
  1246.             UINT32 ulBytesToRead = conn::bytes_to_preparetcpread(m_pCtrl);
  1248.             if (ulBytesToRead > 0)
  1249.             {
  1250.                 if ((UINT32)count > ulBytesToRead)
  1251.                 {
  1252.                     count = (UINT16)ulBytesToRead;
  1253.                 }
  1255.                 // attempt to read data from TCP link
  1256.                 theErr = m_pCtrl->read(m_pBuffer, &count);
  1257.                 if (!theErr && count > 0)
  1258.                 {
  1259.                     conn::bytes_to_actualtcpread(m_pCtrl, (UINT32)count);
  1260.                     mReceiveTCP->EnQueue(m_pBuffer, count);
  1261.                 }
  1262.                 else if (theErr)
  1263.                 {
  1264.                     theErr = ConvertNetworkError(theErr);
  1265.                 }
  1266.             }
  1268.         }
  1269. #else
  1270. // in THREADS_SUPPORTED mode, this will be taken care by the thrdconn.cpp
  1271. // attempt to read data from TCP link
  1272. theErr = m_pCtrl->read(m_pBuffer, &count);
  1273. if (!theErr && count > 0)
  1274. {
  1275.     mReceiveTCP->EnQueue(m_pBuffer, count);
  1276. }
  1277. else if (theErr)
  1278. {
  1279.     theErr = ConvertNetworkError(theErr);
  1280. }
  1281. #endif /* !THREADS_SUPPORTED */
  1282.     }
  1284.     count = mReceiveTCP->GetQueuedItemCount();
  1285.     if (m_bReadPending && count > 0)
  1286.     {
  1287. /* If we are at interrupt time and the response object is not interrupt safe,
  1288.  * schedule a callback to return back the data
  1289.  */
  1290. if (!IsSafe())
  1291. {
  1292. m_bInDoRead = FALSE;
  1293.     return HXR_OK;
  1294. }
  1296. m_bReadPending = FALSE;
  1297. if (m_nRequired < count)
  1298. {
  1299.     // XXXAAK -- UINT32 down to UINT16 - possible truncation???
  1300.     count = (UINT16)m_nRequired;
  1301. }
  1303. CHXBuffer* pBuffer = new CHXBuffer;
  1304. pBuffer->AddRef();
  1305. mReceiveTCP->DeQueue(m_pBuffer, count);
  1306. pBuffer->Set((UCHAR*) m_pBuffer, count);
  1308. m_bInDoRead = FALSE;
  1309. theErr = m_pTCPResponse->ReadDone(HXR_OK, pBuffer);
  1310. m_bInDoRead = TRUE;
  1312. pBuffer->Release();
  1314. /* mask any kind of errors */
  1315.         // Huh??? Don't mask OUTOFMEMORY errors!
  1316.         if( theErr != HXR_OUTOFMEMORY )
  1317.         {
  1318.     theErr = HXR_OK;
  1319.         }
  1320.     }
  1322.     if (theErr && m_bReadPending)
  1323.     {
  1324. /* If we are at interrupt time and the response object is not interrupt safe,
  1325.  * schedule a callback to return back the data
  1326.  */
  1327. if (!IsSafe())
  1328. {
  1329. m_bInDoRead = FALSE;
  1330.     return HXR_OK;
  1331. }
  1333. #ifdef _MACINTOSH
  1334. if (m_pMacCommandCallback && m_pMacCommandCallback->ScheduleCallback(TCP_READ_DONE_COMMAND, m_pScheduler, 0, theErr))
  1335. {
  1336.     m_bReadPending = FALSE;
  1337.          m_bInDoRead = FALSE;
  1338.     return HXR_OK;
  1339. }
  1340. else
  1341. {
  1342.     // failed to schedule a callback, notify the responser with error directly
  1343.     m_bReadPending = FALSE;
  1344.     m_pTCPResponse->ReadDone(theErr, NULL);
  1345. }
  1346. #else
  1347. m_bReadPending = FALSE;
  1348. m_pTCPResponse->ReadDone(theErr, NULL);
  1349. #endif
  1350.     }
  1352.     if (!theErr     &&
  1353. m_bReadPending     &&
  1354. m_pSchedulerReadCallback)
  1355. {
  1356.     m_pSchedulerReadCallback->ScheduleCallback(TCP_READ_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  1357.     }
  1359.   m_bInDoRead = FALSE;
  1360.     return theErr;
  1361. }
  1363. HX_RESULT
  1364. HXTCPSocket::DoWrite()
  1365. {
  1366.     HX_RESULT theErr = HXR_OK;
  1368.     if (m_bInWrite) return HXR_OK;
  1369.     m_bInWrite = TRUE;
  1371. #ifdef _MACINTOSH
  1372. if (m_pInterruptSafeMacWriteQueue)
  1373. m_pInterruptSafeMacWriteQueue->TransferToSimpleList(m_PendingWriteBuffers);
  1374. TransferBuffers(); // PENDING_BUFFERS_ARE_EMPTIED_AT_START_OF_DO_WRITE
  1375. #endif
  1377.     // check how data we have in TCP send queue
  1378.     UINT16 count    = mSendTCP->GetQueuedItemCount();
  1379.     UINT16 actual   = count;
  1381.     if(count > 0)
  1382.     {
  1383. mSendTCP->DeQueue(m_pBuffer,count);
  1384. theErr = m_pCtrl->write(m_pBuffer, &actual);
  1385.     }
  1387.     switch(theErr)
  1388.     {
  1389. case HXR_AT_INTERRUPT:
  1390. case HXR_WOULD_BLOCK:
  1391. case HXR_OK:
  1392.     // enqueue the data that was not sent
  1393.     if(actual != count)
  1394.     {
  1395. mSendTCP->EnQueue(m_pBuffer + actual, count - actual);
  1396.     }
  1398.     // mask out these errors
  1399.     theErr = HXR_OK;
  1400.     break;
  1401. default:
  1402.     theErr = ConvertNetworkError(theErr);
  1403.     break;
  1404.     }
  1406.     if (!theErr && m_bWantWritePending && mSendTCP->GetQueuedItemCount() == 0)
  1407.     {
  1408. m_bWantWritePending = FALSE;
  1409. m_pTCPResponse->WriteReady(HXR_OK);
  1410.     }
  1412. #ifndef _MACINTOSH
  1413. // m_PendingWriteBuffers will always be empty due to the full buffer transfer at the top of this routine.
  1414. // see PENDING_BUFFERS_ARE_EMPTIED_AT_START_OF_DO_WRITE
  1415.     if (!theErr && m_PendingWriteBuffers.GetCount()  > 0)
  1416.     {
  1417. TransferBuffers();
  1418.     }
  1419. #endif
  1421.     if (!theErr &&
  1422. ((mSendTCP && mSendTCP->GetQueuedItemCount() > 0) ||
  1423. m_PendingWriteBuffers.GetCount() > 0)) // see PENDING_BUFFERS_ARE_EMPTIED_AT_START_OF_DO_WRITE
  1424.     {
  1425. if (m_pSchedulerWriteCallback)
  1426. {
  1427.     m_pSchedulerWriteCallback->ScheduleCallback(TCP_WRITE_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  1428. }
  1429.     }
  1431.     if (m_bWriteFlushPending &&
  1432. ((mSendTCP->GetQueuedItemCount() == 0 &&
  1433.  m_PendingWriteBuffers.GetCount() == 0) ||
  1434.  theErr))
  1435.     {
  1436. m_bWriteFlushPending = FALSE;
  1437. Release();
  1438.     }
  1439.     else if (!theErr && !m_bWriteFlushPending &&
  1440. (mSendTCP->GetQueuedItemCount() > 0 || m_PendingWriteBuffers.GetCount() > 0))
  1441.     {
  1442. m_bWriteFlushPending = TRUE;
  1443. AddRef();
  1444.     }
  1446.     m_bInWrite = FALSE;
  1447.     return theErr;
  1448. }
  1450. /* If we are at interrupt time and the response object is not interrupt safe,
  1451.  * schedule a callback to return back the data
  1452.  */
  1453. BOOL
  1454. HXTCPSocket::IsSafe()
  1455. {
  1456.     if (m_pInterruptState && m_pInterruptState->AtInterruptTime() &&
  1457. (!m_pResponseInterruptSafe ||
  1458.  !m_pResponseInterruptSafe->IsInterruptSafe()))
  1459.     {
  1460. if (m_pNonInterruptReadCallback)
  1461. {
  1462.     m_pNonInterruptReadCallback->ScheduleCallback(TCP_READ_COMMAND, m_pScheduler, 0);
  1463. }
  1465. return FALSE;
  1466.     }
  1468.     return TRUE;
  1469. }
  1472. void
  1473. HXTCPSocket::ConnectDone(BOOL bResult)
  1474. {
  1475.     AddRef();
  1476.     if (bResult == TRUE)
  1477.     {
  1478. m_bConnected = TRUE;
  1479. //XXX need to set m_lForeignAddr here
  1480. //XXXJR hack!
  1481. m_lForeignAddress = DwToHost(m_pCtrl->get_addr());
  1482. m_pTCPResponse->ConnectDone(HXR_OK);
  1483.     }
  1484.     else
  1485.     {
  1486. #ifdef _MACINTOSH
  1487. if (!(m_pMacCommandCallback && m_pMacCommandCallback->ScheduleCallback(TCP_CONNECT_DONE_COMMAND, m_pScheduler, 0, HXR_NET_CONNECT)))
  1488. {
  1489. //note: only happens when there's a problem (e.g. macleod 1/2 server problem)
  1490. m_pTCPResponse->ConnectDone(HXR_NET_CONNECT); // couldn't use the delayed callback... take our chances.
  1491. }
  1492. #else
  1493. m_pTCPResponse->ConnectDone(HXR_NET_CONNECT);
  1494. #endif
  1495.     }
  1496.     Release();
  1497. }
  1499. void
  1500. HXTCPSocket::CloseDone()
  1501. {
  1502.     m_pTCPResponse->Closed(HXR_OK);
  1503. }
  1505. void
  1506. HXTCPSocket::DNSDone(BOOL bSuccess)
  1507. {
  1508.     AddRef();
  1509.     if (!bSuccess)
  1510.     {
  1511. m_pTCPResponse->ConnectDone(HXR_DNR);
  1512.     }
  1513.     Release();
  1514. }
  1516. void
  1517. HXTCPSocket::TransferBuffers()
  1518. {
  1519.     IHXBuffer* pBuffer = 0;
  1521.     while (m_PendingWriteBuffers.GetCount() > 0)
  1522.     {
  1523. pBuffer = (IHXBuffer*) m_PendingWriteBuffers.GetHead();
  1524. if ((UINT16) pBuffer->GetSize() < mSendTCP->GetMaxAvailableElements())
  1525. {
  1526.     mSendTCP->EnQueue( pBuffer->GetBuffer(),
  1527. (UINT16) pBuffer->GetSize());
  1528.     pBuffer->Release();
  1529.     m_PendingWriteBuffers.RemoveHead();
  1530. }
  1531. else
  1532. {
  1533.     break;
  1534. }
  1535.     }
  1536. }
  1538. STDMETHODIMP
  1539. HXTCPSocket::SetOption(HX_SOCKET_OPTION option, UINT32 ulValue)
  1540. {
  1541.     HX_RESULT res = HXR_OK;
  1543.     switch(option)
  1544.     {
  1545.     case HX_SOCKOPT_REUSE_ADDR:
  1546. m_bReuseAddr = (BOOL)ulValue;
  1547.     break;
  1548.     case HX_SOCKOPT_REUSE_PORT:
  1549. m_bReusePort = (BOOL)ulValue;
  1550.     break;
  1551.     case HX_SOCKOPT_MULTICAST_IF:
  1552. res = HXR_UNEXPECTED;
  1553.     break;
  1554.     default:
  1555. HX_ASSERT(!"I don't know this option");
  1556. res = HXR_FAIL;
  1557.     }
  1559.     return res;
  1560. }
  1562. STDMETHODIMP
  1563. HXTCPSocket::SetSecure(BOOL bSecure)
  1564. {
  1565.     HX_RESULT res = HXR_OK;
  1567.     m_bSecureSocket = bSecure;
  1569.     return res;
  1570. }
  1572. STDMETHODIMP HXTCPSocket::HandleCallback(INT32 theCommand, HX_RESULT theError)
  1573. {
  1574.     HX_RESULT theErr = HXR_OK;
  1575.     if (!m_bInDestructor)
  1576.     {
  1577. AddRef();
  1578. m_pMutex->Lock();
  1579. if (!m_bInDestructor)
  1580. {
  1581. switch(theCommand)
  1582. {
  1583. case TCP_READ_COMMAND:
  1584.     theErr = DoRead();
  1585.     break;
  1587. case TCP_WRITE_COMMAND:
  1588.     DoWrite(); // protected from re-entry by m_bInWrite
  1589.     break;
  1591. case TCP_READ_DONE_COMMAND:
  1592.      m_bReadPending = FALSE;
  1593. m_pTCPResponse->ReadDone(theError, NULL);
  1594.     break;
  1596. case TCP_CONNECT_DONE_COMMAND:
  1597. m_pTCPResponse->ConnectDone(theError);
  1598. break;
  1600. case TCP_BIND_COMMAND:
  1601. default:
  1602.     theErr = DoRead();
  1603.     DoWrite();
  1604.     break;
  1605.     }
  1606. }
  1607. m_pMutex->Unlock();
  1609.         // we want out of memory errors to be reported immediately
  1610.         // because fiddling around waiting for the error to propagate
  1611.         // normally will just make the situation worse; mask out all
  1612.         // other errors, as they will eventually get dealt with in
  1613.         // ReadDone() or similar functions.
  1614.         
  1615.         if (theErr != HXR_OUTOFMEMORY)
  1616.         {
  1617.             theErr = HXR_OK;
  1618.         }
  1619.         
  1620. if( theErr )
  1621. {
  1622.     IHXErrorMessages * pErrorNotifier = NULL;
  1623.     IUnknown * pPlayer = NULL;
  1624.     IHXClientEngine* pEngine = NULL;
  1625.     UINT32 nNumPlayers = 0;
  1627.     m_pContext->QueryInterface(IID_IHXClientEngine, (void**)&pEngine);
  1628.     if( pEngine )
  1629.     {
  1630. nNumPlayers = pEngine->GetPlayerCount();
  1631. for( int ii=0; ii<nNumPlayers; ii++ )
  1632. {
  1633.     pEngine->GetPlayer(ii,pPlayer);
  1634.     if( pPlayer )
  1635.     {
  1636. pPlayer->QueryInterface( IID_IHXErrorMessages, (void**)&pErrorNotifier );
  1637.     }
  1638.     if( pErrorNotifier )
  1639.     {
  1640. pErrorNotifier->Report( HXLOG_ERR, theErr, 0, NULL, NULL );
  1641. pErrorNotifier->Release();
  1642.     }
  1643.     HX_RELEASE( pPlayer );
  1644. }
  1645.     }
  1646.     HX_RELEASE( pEngine );
  1647. }
  1648. Release();
  1649.     }
  1650.     return theErr;
  1651. }
  1653. HX_RESULT HXTCPSocket::TCPSocketCallback::Func(NotificationType Type,
  1654.    BOOL bSuccess, conn* pConn)
  1655. {
  1656.     if(m_pContext)
  1657.     {
  1659. switch (Type)
  1660. {
  1661. case READ_NOTIFICATION:
  1662. //
  1663. //  This clears up a problem on the Macintosh where we were getting
  1664. //  interrupt callbacks from the Network device, and could possibly
  1665. //  collide when adding/removing data the same time from the same
  1666. //  socket, at interrupt time, and at system level time.
  1667. //
  1668. #if defined(_UNIX_THREADED_NETWORK_IO)
  1669.             if( !ReadNetworkThreadingPref((IUnknown*)(m_pContext->m_pContext) ))
  1670.             {
  1671.                 m_pContext->AddRef();
  1672.                 m_pContext->m_pMutex->Lock();
  1673.                 m_pContext->DoRead();
  1674.                 m_pContext->m_pMutex->Unlock();
  1675.                 m_pContext->Release();
  1676.             }
  1677. #elif !defined (THREADS_SUPPORTED) && !defined(_MACINTOSH)
  1678.     m_pContext->AddRef();
  1679.     m_pContext->m_pMutex->Lock();
  1680.     m_pContext->DoRead();
  1681.     m_pContext->m_pMutex->Unlock();
  1682.     m_pContext->Release();
  1683. #endif
  1684.     break;
  1685. case WRITE_NOTIFICATION:
  1686. #if defined(_UNIX_THREADED_NETWORK_IO)
  1687.             if( !ReadNetworkThreadingPref((IUnknown*)(m_pContext->m_pContext)) )
  1688.             {
  1689.                 m_pContext->AddRef();
  1690.                 m_pContext->m_pMutex->Lock();
  1691.                 m_pContext->DoWrite();
  1692.                 m_pContext->m_pMutex->Unlock();
  1693.                 m_pContext->Release();
  1694.             }
  1695. #elif !defined (THREADS_SUPPORTED) && !defined(_MACINTOSH)
  1696.     m_pContext->AddRef();
  1697.     m_pContext->m_pMutex->Lock();
  1698.     m_pContext->DoWrite();
  1699.     m_pContext->m_pMutex->Unlock();
  1700.     m_pContext->Release();
  1701. #endif
  1702.     break;
  1703. case CONNECT_NOTIFICATION:
  1704.     m_pContext->ConnectDone(bSuccess);
  1705.     break;
  1706. case CLOSE_NOTIFICATION:
  1707.     m_pContext->CloseDone();
  1708.     break;
  1709. case DNS_NOTIFICATION:
  1710.     m_pContext->DNSDone(bSuccess);
  1711.     break;
  1712. default:
  1713.     break;
  1714. }
  1715.     }
  1716.     return HXR_OK;
  1717. }
  1719. HXListenSocket::HXListenSocket(IUnknown* pContext,
  1720.  HXNetworkServices* pNetworkServices)
  1721. : m_pListenConn(NULL)
  1722. , m_pCallback(NULL)
  1723. , m_pContext(NULL)
  1724.   , m_bReuseAddr(FALSE)
  1725.   , m_bReusePort(FALSE)
  1726. {
  1727.     m_pContext = pContext;
  1728.     m_pContext->AddRef();
  1730.     m_pNetworkServices = pNetworkServices;
  1731.     m_pNetworkServices->AddRef();
  1733.     m_lRefCount = 0;
  1734.     m_pListenResponse = 0;
  1736. }
  1738. HXListenSocket::~HXListenSocket()
  1739. {
  1740.     if (m_pCallback)
  1741.     {
  1742. m_pCallback->m_pContext = 0;
  1743.     }
  1745.     if (m_pListenConn)
  1746.     {
  1747. m_pListenConn->done();
  1748.         m_pListenConn->Release();
  1749.         m_pListenConn = NULL;
  1750.     }
  1752.     HX_RELEASE(m_pContext);
  1753.     HX_DELETE(m_pCallback);
  1755.     HX_RELEASE(m_pListenResponse);
  1756.     HX_RELEASE(m_pNetworkServices);
  1757. }
  1759. STDMETHODIMP HXListenSocket::QueryInterface(REFIID riid, void** ppvObj)
  1760. {
  1761.     QInterfaceList qiList[] =
  1762.         {
  1763.             { GET_IIDHANDLE(IID_IHXListenSocket), (IHXListenSocket*)this },
  1764.             { GET_IIDHANDLE(IID_IHXSetSocketOption), (IHXSetSocketOption*)this },
  1765.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXListenSocket*)this },
  1766.         };
  1768.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  1769. }
  1771. STDMETHODIMP_(ULONG32) HXListenSocket::AddRef()
  1772. {
  1773.     return InterlockedIncrement(&m_lRefCount);
  1774. }
  1776. STDMETHODIMP_(ULONG32) HXListenSocket::Release()
  1777. {
  1778.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1779.     {
  1780.         return m_lRefCount;
  1781.     }
  1783.     delete this;
  1784.     return HXR_OK;
  1785. }
  1787. STDMETHODIMP HXListenSocket::SetOption(HX_SOCKET_OPTION option,
  1788. UINT32 ulValue)
  1789. {
  1790.     HX_RESULT  ret = HXR_OK;
  1792.     switch (option)
  1793.     {
  1794.     case HX_SOCKOPT_REUSE_ADDR:
  1795. m_bReuseAddr = ulValue;
  1796. break;
  1798.     case HX_SOCKOPT_REUSE_PORT:
  1799. m_bReusePort = ulValue;
  1800. break;
  1802.     default:
  1803. ret = HXR_NOTIMPL;
  1804.     }
  1806.     return ret;
  1807. }
  1809. STDMETHODIMP HXListenSocket::Init(UINT32 ulLocalAddr, UINT16 port,
  1810.    IHXListenResponse* pListenResponse)
  1811. {
  1812.     if (!pListenResponse)
  1813.     {
  1814. return HXR_UNEXPECTED;
  1815.     }
  1817.     HX_RELEASE(m_pListenResponse);
  1818.     m_pListenResponse = pListenResponse;
  1819.     m_pListenResponse->AddRef();
  1821. #if defined( _WIN32 ) || defined( _WINDOWS )
  1822.     // Have we been able to load and initialize the winsock stuff yet?
  1823.     if (!win_net::IsWinsockAvailable(this))
  1824.     {
  1825. return HXR_FAIL; // HXR_GENERAL_NONET;
  1826.     }
  1827. #endif
  1829.     m_pNetworkServices->UseDrivers();
  1831. #ifdef _UNIX
  1832.     //This one has to be set before we create a new socket.
  1833.     conn::SetNetworkThreadingPref( ReadNetworkThreadingPref((IUnknown*)m_pContext) );
  1834.     conn::SetThreadedDNSPref( ReadThreadedDNSPref((IUnknown*)m_pContext) );
  1835. #endif
  1837.     HX_RESULT ret = conn::init_drivers(NULL);
  1838.     m_pListenConn = conn::new_socket(HX_TCP_SOCKET);
  1839.     if ( m_pListenConn == NULL )
  1840.     {
  1841. return HXR_OUTOFMEMORY;
  1842.     }
  1844. #ifdef _UNIX
  1845.     m_pListenConn->SetAsyncDNSPref( ReadAsyncDNSPref((IUnknown*)m_pContext) );
  1846. #endif
  1848.     m_pListenConn->nonblocking();
  1849.     m_pListenConn->reuse_addr(m_bReuseAddr);
  1850.     m_pListenConn->reuse_port(m_bReusePort);
  1852.     if ( m_pCallback == NULL)
  1853.     {
  1854. m_pCallback = new ListenSocketCallback();
  1855. m_pCallback->m_pContext = this;
  1856.     }
  1857.     m_pListenConn->set_callback(m_pCallback);
  1859.     UINT32 ulPlatformData = 0;
  1861. #if defined (_WIN32)
  1862.     ulPlatformData = (UINT32)GetModuleHandle(NULL);
  1863. #elif defined (_WIN16)
  1864.     ulPlatformData = (UINT32)(int)g_hInstance;
  1865. #endif
  1866.     return m_pListenConn->listen(ulLocalAddr, port, 2, 0, ulPlatformData);
  1867. }
  1870. HX_RESULT HXListenSocket::ListenSocketCallback::Func(NotificationType Type,
  1871.    BOOL bSuccess, conn* pConn)
  1872. {
  1873.     if(m_pContext)
  1874.     {
  1875. switch (Type)
  1876. {
  1877. case ACCEPT_NOTIFICATION:
  1879.     if ( bSuccess )
  1880.     {
  1881. HXTCPSocket* pSock = new HXTCPSocket(m_pContext->m_pContext,
  1882.     m_pContext->m_pNetworkServices);
  1883.         if ( pSock )
  1884. {
  1885.     pSock->AddRef();
  1886.     if ( SUCCEEDED(pSock->AcceptConnection(pConn)) )
  1887.     {
  1888. m_pContext->m_pListenResponse->NewConnection(HXR_OK,
  1889.     (IHXTCPSocket*)pSock);
  1890.     }
  1891.     HX_RELEASE(pSock);
  1892. }
  1893.     }
  1894.     break;
  1895. case CONNECT_NOTIFICATION:
  1896.     break;
  1897. case READ_NOTIFICATION:
  1898.     break;
  1899. case CLOSE_NOTIFICATION:
  1900.     break;
  1901. case DNS_NOTIFICATION:
  1902. default:
  1903.     break;
  1904. }
  1905.     }
  1906.     return HXR_OK;
  1907. }
  1910. HXUDPSocket::HXUDPSocket(IUnknown* pContext, HXNetworkServices* pNetworkServices):
  1911.     m_lRefCount(0),
  1912.     m_pCallback(0),
  1913.     m_pUDPResponse(0),
  1914.     m_pData(0),
  1915.     m_bReadPending(FALSE),
  1916.     m_bInRead(FALSE),
  1917.     m_bInDoRead(FALSE),
  1918.     m_bInWrite(FALSE),
  1919.     m_nRequired(0),
  1920.     m_pSchedulerReadCallback(NULL),
  1921.     m_pSchedulerWriteCallback(NULL),
  1922.     m_pNonInterruptReadCallback(NULL),
  1923.     m_pScheduler(0),
  1924.     m_nDestPort(0),
  1925.     m_bInitComplete(FALSE),
  1926.     m_pInterruptState(NULL),
  1927.     m_pResponseInterruptSafe(NULL),
  1928.     m_pMutex(NULL),
  1929.     m_bReuseAddr(FALSE),
  1930.     m_bReusePort(FALSE),
  1931.     m_bInDestructor(FALSE),
  1932.     m_pContext(pContext)
  1933. {
  1934. #ifdef _MACINTOSH
  1935. m_pInterruptSafeMacWriteQueue = new InterruptSafeMacQueue();
  1936. HX_ASSERT(m_pInterruptSafeMacWriteQueue != NULL);
  1937. #endif
  1939.     m_pNetworkServices = pNetworkServices;
  1940.     m_pNetworkServices->AddRef();
  1942.     if (pContext)
  1943.     {
  1944. pContext->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  1945. pContext->QueryInterface(IID_IHXInterruptState, (void**) &m_pInterruptState);
  1946.     }
  1948.     if (m_pScheduler)
  1949.     {
  1950. m_pSchedulerReadCallback = new ScheduledSocketCallback(this, TRUE);
  1951. m_pSchedulerReadCallback->AddRef();
  1953. m_pSchedulerWriteCallback = new ScheduledSocketCallback(this, TRUE);
  1954. m_pSchedulerWriteCallback->AddRef();
  1956. m_pNonInterruptReadCallback = new ScheduledSocketCallback(this, FALSE);
  1957. m_pNonInterruptReadCallback->AddRef();
  1958.     }
  1960. #if defined(THREADS_SUPPORTED)
  1961.     HXMutex::MakeMutex(m_pMutex);
  1962. #elif defined(_UNIX_THREADED_NETWORK_IO)
  1963.     if( ReadNetworkThreadingPref((IUnknown*)m_pContext) )
  1964.     {
  1965.         HXMutex::MakeMutex(m_pMutex);
  1966.     }
  1967.     else
  1968.     {
  1969.         HXMutex::MakeStubMutex(m_pMutex);
  1970.     }
  1971. #else
  1972.     HXMutex::MakeStubMutex(m_pMutex);
  1973. #endif
  1974. }
  1977. HXUDPSocket::~HXUDPSocket()
  1978. {
  1979.     m_bInDestructor = TRUE;
  1980. m_pMutex->Lock();
  1982. #ifdef _MACINTOSH
  1983. HX_DELETE(m_pInterruptSafeMacWriteQueue); // will release any objects in its nodes
  1984. #endif
  1986.     if (m_pSchedulerReadCallback)
  1987.     m_pSchedulerReadCallback->Unschedule(m_pScheduler);
  1989.     if (m_pSchedulerWriteCallback)
  1990.     m_pSchedulerWriteCallback->Unschedule(m_pScheduler);
  1992.     if (m_pNonInterruptReadCallback)
  1993.     m_pNonInterruptReadCallback->Unschedule(m_pScheduler);
  1995.     /*
  1996.      * XXX...While handling the m_pData->done it's possible for the
  1997.      *       DispatchMessage call in CancelSelect to cause an
  1998.      *       asynchronous DoRead to occur. The resulting AddRef/Release
  1999.      *       would cause this object to be deleted again, so to prevent
  2000.      *       this we set the m_pCallback->m_pContext = 0
  2001.      */
  2003.     if (m_pCallback)
  2004.     {
  2005. m_pCallback->m_pContext = 0;
  2006.     }
  2008.     if (m_pData)
  2009.     {
  2010. m_pData->done();
  2011. m_pData->Release();
  2012. m_pData = 0;
  2013.     }
  2015.     if(m_pUDPResponse)
  2016.     {
  2017. m_pUDPResponse->Release();
  2018. m_pUDPResponse = 0;
  2019.     }
  2021.     if (m_pCallback)
  2022.     {
  2023. delete m_pCallback;
  2024. m_pCallback = 0;
  2025.     }
  2027.     if (m_pScheduler)
  2028.     {
  2029. m_pScheduler->Release();
  2030. m_pScheduler = 0;
  2031.     }
  2033.     while (!m_ReadBuffers.IsEmpty())
  2034.     {
  2035. UDP_PACKET* pPacket = (UDP_PACKET*)m_ReadBuffers.RemoveHead();
  2037. HX_RELEASE(pPacket->pBuffer);
  2038. HX_DELETE(pPacket);
  2039.     }
  2041.     HX_RELEASE(m_pInterruptState);
  2042.     HX_RELEASE(m_pResponseInterruptSafe);
  2044.     if (m_pSchedulerReadCallback)
  2045.     {
  2046.      m_pSchedulerReadCallback->m_pSocket = NULL;
  2047.      m_pSchedulerReadCallback->Release();
  2048.      m_pSchedulerReadCallback = NULL;
  2049.     }
  2051.     if (m_pSchedulerWriteCallback)
  2052.     {
  2053.      m_pSchedulerWriteCallback->m_pSocket = NULL;
  2054.      m_pSchedulerWriteCallback->Release();
  2055.      m_pSchedulerWriteCallback = NULL;
  2056.     }
  2058.     if (m_pNonInterruptReadCallback)
  2059.     {
  2060.      m_pNonInterruptReadCallback->m_pSocket = NULL;
  2061.      m_pNonInterruptReadCallback->Release();
  2062.      m_pNonInterruptReadCallback = NULL;
  2063.     }
  2065.     m_pMutex->Unlock();
  2066.     HX_DELETE(m_pMutex);
  2068. #if defined( _WIN32 ) || defined( _WINDOWS )
  2069.     win_net::ReleaseWinsockUsage(this);
  2070. #endif
  2072.     HX_RELEASE(m_pNetworkServices);
  2073. }
  2075. STDMETHODIMP HXUDPSocket::QueryInterface(REFIID riid, void** ppvObj)
  2076. {
  2077.     QInterfaceList qiList[] =
  2078.         {
  2079.             { GET_IIDHANDLE(IID_IHXUDPSocket), (IHXUDPSocket*)this },
  2080.             { GET_IIDHANDLE(IID_IHXSetSocketOption), (IHXSetSocketOption*)this },
  2081.             { GET_IIDHANDLE(IID_IHXUDPMulticastInit), (IHXUDPMulticastInit*)this },
  2082.             { GET_IIDHANDLE(IID_IHXSetPrivateSocketOption), (IHXSetPrivateSocketOption*)this },
  2083.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXUDPSocket*)this },
  2084.         };
  2086.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  2087. }
  2089. STDMETHODIMP_(ULONG32) HXUDPSocket::AddRef()
  2090. {
  2091.     return InterlockedIncrement(&m_lRefCount);
  2092. }
  2094. STDMETHODIMP_(ULONG32) HXUDPSocket::Release()
  2095. {
  2096.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2097.     {
  2098.         return m_lRefCount;
  2099.     }
  2100.     delete this;
  2101.     return 0;
  2102. }
  2104. STDMETHODIMP
  2105. HXUDPSocket::InitMulticast(UINT8 uTTL)
  2106. {
  2107.     if (HXR_OK != m_pData->set_multicast())
  2108.     {
  2109. return HXR_FAIL;
  2110.     }
  2112.     if (HXR_OK != m_pData->set_multicast_ttl(uTTL))
  2113.     {
  2114. return HXR_FAIL;
  2115.     }
  2117.     return HXR_OK;
  2118. }
  2120. STDMETHODIMP HXUDPSocket::Init(ULONG32 ulAddr, UINT16 nPort,
  2121. IHXUDPResponse* pUDPResponse)
  2122. {
  2123.     if (!pUDPResponse && !m_pUDPResponse)
  2124.     {
  2125.         /*
  2126.          * if the response object hasn't been set up yet, then
  2127.          * require a response object (i.e. the first call to Init
  2128.          * must always specify a response object
  2129.          */
  2130. return HXR_UNEXPECTED;
  2131.     }
  2133.     HX_RESULT theErr = HXR_OK;
  2134.     UINT32 ulPlatformData = 0;
  2136.     if (pUDPResponse != NULL)
  2137.     {
  2138.         HX_RELEASE(m_pUDPResponse);
  2139.         m_pUDPResponse = pUDPResponse;
  2140.         m_pUDPResponse->AddRef();
  2141.     }
  2143.     HX_RELEASE(m_pResponseInterruptSafe);
  2144.     m_pUDPResponse->QueryInterface(IID_IHXInterruptSafe,
  2145.    (void**) &m_pResponseInterruptSafe);
  2147.     m_sockAddr.sin_family = AF_INET;
  2148.     m_sockAddr.sin_addr.s_addr = DwToNet(ulAddr);  //*(long*)&ulAddr;
  2149.     m_sockAddr.sin_port = WToNet(nPort);
  2151.     m_nDestPort = nPort;
  2153.     return HXR_OK;
  2154. }
  2156. STDMETHODIMP HXUDPSocket::Bind(UINT32 ulLocalAddr, UINT16 nPort)
  2157. {
  2158.     if (m_bInitComplete)
  2159. return HXR_UNEXPECTED;
  2161. #if defined( _WIN32 ) || defined( _WINDOWS )
  2162.     // Have we been able to load and initialize the winsock stuff yet?
  2163.     if (!win_net::IsWinsockAvailable(this))
  2164.     {
  2165. return HXR_FAIL; // HXR_GENERAL_NONET;
  2166.     }
  2167. #endif
  2169.     m_pNetworkServices->UseDrivers();
  2171.     HX_RESULT theErr = conn::init_drivers(NULL);
  2172.     if (theErr)
  2173.     {
  2174. return (theErr);
  2175.     }
  2177.     theErr = HXR_OK;
  2178.     UINT32 ulPlatformData = 0;
  2180. #ifdef _UNIX
  2181.     //This one has to be set before we create a new socket.
  2182.     conn::SetNetworkThreadingPref( ReadNetworkThreadingPref((IUnknown*)m_pContext) );
  2183.     conn::SetThreadedDNSPref( ReadThreadedDNSPref((IUnknown*)m_pContext) );
  2184. #endif
  2186.     m_pData = conn::new_socket(HX_UDP_SOCKET);
  2187.     if (!m_pData)
  2188.     {
  2189. return HXR_OUTOFMEMORY;
  2190.     }
  2192.     // XXXGo - As it is implemented, this is the only way...
  2193.     if (m_bReuseAddr)
  2194.     {
  2195. if (m_pData->reuse_addr(m_bReuseAddr) != HXR_OK)
  2196. {
  2197.     // err...what do we need to do?
  2198.     HX_ASSERT(!"reuse_addr() failed");
  2199. }
  2200.     }
  2201.     if (m_bReusePort)
  2202.     {
  2203. if (m_pData->reuse_port(m_bReusePort) != HXR_OK)
  2204. {
  2205.     // err...what do we need to do?
  2206.     HX_ASSERT(!"reuse_port() failed");
  2207. }
  2208.     }
  2210. #ifdef _UNIX
  2211.     m_pData->SetAsyncDNSPref( ReadAsyncDNSPref((IUnknown*)m_pContext) );
  2212. #endif
  2215.     // XXXST -- local addr binding stuff, removed dependency to m_nLocalPort
  2216.     // 0 for local port will make the system choose a free port
  2217.     theErr = m_pData->init(ulLocalAddr, nPort);
  2219.     if (theErr)
  2220.     {
  2221. theErr = ConvertNetworkError(theErr);
  2222. if (theErr)
  2223. {
  2224.     m_pData->done();
  2225.     m_pData->Release();
  2226.     m_pData = 0;
  2227.     return theErr;
  2228. }
  2229.     }
  2231.     m_pData->nonblocking();
  2233.     m_pData->set_receive_buf_size(DESIRED_RCV_BUFSIZE);
  2234.     if (!m_pCallback)
  2235.     {
  2236. m_pCallback = new UDPSocketCallback;
  2237. m_pCallback->m_pContext = this;
  2238.     }
  2239.     m_pData->set_callback(m_pCallback);
  2241. #ifdef _WINDOWS
  2242. #if defined (_WIN32)
  2243.     ulPlatformData = (UINT32)GetModuleHandle(NULL);
  2244. #elif defined (_WIN16)
  2245.     ulPlatformData = (UINT32)(int)g_hInstance;
  2246. #endif
  2247.     m_pData->SetWindowHandle(ulPlatformData);
  2248. #endif /* defined (_WINDOWS) */
  2250.     if (m_pSchedulerReadCallback)
  2251.     {
  2252.     m_pSchedulerReadCallback->ScheduleCallback(UDP_BIND_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  2253.     }
  2255.     m_bInitComplete = TRUE;
  2256.     return theErr;
  2257. }
  2259. STDMETHODIMP HXUDPSocket::Read(UINT16 nBytes)
  2260. {
  2261.     if (!m_bInitComplete)
  2262.     {
  2263. HX_RESULT ret = Bind(HXR_INADDR_ANY, 0);
  2264. if (HXR_OK != ret)
  2265.     return HXR_UNEXPECTED;
  2266.     }
  2268.     HX_RESULT theErr = HXR_OK;
  2270.     if(m_bReadPending)
  2271.     {
  2272. return HXR_UNEXPECTED;
  2273.     }
  2275.     m_bReadPending = TRUE;
  2277.     if (m_bInRead)
  2278.     {
  2279. return HXR_OK;
  2280.     }
  2282.     m_bInRead = TRUE;
  2284.     m_pMutex->Lock();
  2285.     UINT16 uNumIterations = 0;
  2286.     do
  2287.     {
  2288. theErr = DoRead();
  2289. uNumIterations++;
  2290.     } while (m_bReadPending && !theErr && m_ReadBuffers.GetCount() > 0 && uNumIterations < MAX_ITERATION_COUNT);
  2292.     m_pMutex->Unlock();
  2293.     theErr = ConvertNetworkError(theErr);
  2295.     if (m_bReadPending && m_pSchedulerReadCallback)
  2296.     m_pSchedulerReadCallback->ScheduleCallback(UDP_READ_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  2298.     m_bInRead = FALSE;
  2300.     return theErr;
  2301. }
  2303. STDMETHODIMP HXUDPSocket::Write(IHXBuffer* pBuffer)
  2304. {
  2305.     if (!m_bInitComplete)
  2306.     {
  2307. HX_RESULT ret = Bind(HXR_INADDR_ANY, 0);
  2308. if (HXR_OK != ret)
  2309.     return HXR_UNEXPECTED;
  2310.     }
  2311.     HX_RESULT theErr = HXR_OK;
  2312.     HX_RESULT lResult = HXR_OK;
  2314. #if 0
  2315.     struct in_addr in;
  2316.     in.s_addr = m_sockAddr.sin_addr.s_addr;
  2317.     char* address = inet_ntoa(in);
  2318.     printf("address = %s:", address);
  2319.     UINT32 port = ntohl(m_sockAddr.sin_port);
  2320.     printf("%dn", port);
  2321. #endif /* 0 */
  2323. #ifdef _MACINTOSH
  2324. if (m_pInterruptSafeMacWriteQueue)
  2325. m_pInterruptSafeMacWriteQueue->AddTail(pBuffer); // AddRef called inside
  2326. #else
  2327. pBuffer->AddRef();
  2328. m_WriteBuffers.AddTail((void*) pBuffer);
  2329. #endif
  2332.     m_pMutex->Lock();
  2333.     theErr = DoWrite();
  2334.     m_pMutex->Unlock();
  2336.     lResult = ConvertNetworkError(theErr);
  2338.     return lResult;
  2339. }
  2341. STDMETHODIMP HXUDPSocket::WriteTo(ULONG32 ulAddr,
  2342.     UINT16 nPort, IHXBuffer* pBuffer)
  2343. {
  2344.     if (!m_bInitComplete)
  2345.     {
  2346. HX_RESULT ret = Bind(HXR_INADDR_ANY, 0);
  2347. if (HXR_OK != ret)
  2348.     return HXR_UNEXPECTED;
  2349.     }
  2351.     m_sockAddr.sin_family = AF_INET;
  2352.     m_sockAddr.sin_addr.s_addr = DwToNet(ulAddr);   //*(long*)&ulAddr;
  2353.     m_sockAddr.sin_port = WToNet(nPort);
  2355.     return (Write(pBuffer));
  2356. }
  2358. STDMETHODIMP HXUDPSocket::GetLocalPort(UINT16& nPort)
  2359. {
  2360.     // Get the local port from the socket info
  2361.     nPort = m_pData->get_local_port();
  2363.     return (INT16)nPort < 0 ? HXR_OK : HXR_FAIL;
  2364. }
  2366. STDMETHODIMP HXUDPSocket::JoinMulticastGroup(
  2367.     ULONG32     ulMulticastAddr,
  2368.     ULONG32     ulInterfaceAddr)
  2369. {
  2370. #if defined(HELIX_FEATURE_TRANSPORT_MULTICAST)
  2371.     HX_RESULT theErr = HXR_OK;
  2372.     HX_RESULT lResult = HXR_OK;
  2374.     m_pMutex->Lock();
  2375.     theErr = m_pData->join_multicast_group(ulMulticastAddr, ulInterfaceAddr);
  2376.     lResult = ConvertNetworkError(theErr);
  2377.     m_pMutex->Unlock();
  2379.     return lResult;
  2380. #else
  2381.     return HXR_NOTIMPL;
  2382. #endif /* HELIX_FEATURE_TRANSPORT_MULTICAST */
  2383. }
  2385. STDMETHODIMP HXUDPSocket::LeaveMulticastGroup(
  2386.     ULONG32     ulMulticastAddr,
  2387.     ULONG32     ulInterfaceAddr)
  2388. {
  2389. #if defined(HELIX_FEATURE_TRANSPORT_MULTICAST)
  2390.     HX_RESULT theErr = HXR_OK;
  2391.     HX_RESULT lResult = HXR_OK;
  2393.     m_pMutex->Lock();
  2394.     theErr = m_pData->leave_multicast_group(ulMulticastAddr, ulInterfaceAddr);
  2395.     while (!m_ReadBuffers.IsEmpty())
  2396.     {
  2397. UDP_PACKET* pPacket = (UDP_PACKET*)m_ReadBuffers.RemoveHead();
  2399. HX_RELEASE(pPacket->pBuffer);
  2400. HX_DELETE(pPacket);
  2401.     }
  2402.     lResult = ConvertNetworkError(theErr);
  2403.     m_pMutex->Unlock();
  2405.     return lResult;
  2406. #else
  2407.     return HXR_NOTIMPL;
  2408. #endif /* HELIX_FEATURE_TRANSPORT_MULTICAST */
  2409. }
  2411. HX_RESULT
  2412. HXUDPSocket::DoRead()
  2413. {
  2414. #ifdef _MACINTOSH
  2415. if (m_bInDoRead)
  2416. return HXR_OK; // whatever needs to be done will be done by the caller that's already here.
  2418. // xxxbobclark the m_bInDoRead flag is hacked around calling ReadDone(), because
  2419. //             ReadDone() may call Read() which in turn calls us here, and we do
  2420. //             not want to bail out in that instance. (Otherwise we only remove
  2421. //             one packet at a time, which, given the scheduler granularity and
  2422. //             high bit rates, implies that our bandwidth would be too low.)
  2423. #endif
  2424. m_bInDoRead = TRUE;
  2426.     HX_RESULT theErr = HXR_OK;
  2427.     IHXBuffer* pBuffer = 0;
  2428.     UINT32  ulAddress = 0;
  2429.     UINT16  ulPort = 0;
  2430.     UINT16  count = 0;
  2433.     do
  2434.     {
  2435. /*
  2436.  * Must reset count before every read
  2437.  */
  2438. count = TCP_BUF_SIZE;
  2440. theErr = m_pData->readfrom(pBuffer, ulAddress, ulPort);
  2442. if (!theErr && pBuffer)
  2443. {
  2444.     UDP_PACKET* pPacket = new UDP_PACKET;
  2446.     pPacket->pBuffer = pBuffer;
  2447.     pPacket->ulAddress = ulAddress;
  2448.     pPacket->ulPort = ulPort;
  2450.     m_ReadBuffers.AddTail((void*)pPacket);
  2451. }
  2452. else
  2453. {
  2454.     count = 0;
  2455. }
  2456.     } while (!theErr && count > 0);
  2458.     if (m_bReadPending && m_ReadBuffers.GetCount() > 0)
  2459.     {
  2460. /* If we are at interrupt time and the response object is not
  2461.  * interrupt safe, schedule a callback to return back the data
  2462.  */
  2463. if (!IsSafe())
  2464. {
  2465. m_bInDoRead = FALSE;
  2466.     return HXR_AT_INTERRUPT;
  2467. }
  2469. m_bReadPending = FALSE;
  2471. UDP_PACKET* pPacket = (UDP_PACKET*)m_ReadBuffers.RemoveHead();
  2472. pBuffer = pPacket->pBuffer;
  2473. ulAddress = pPacket->ulAddress;
  2474. ulPort = pPacket->ulPort;
  2476. AddRef();
  2479. m_bInDoRead = FALSE;
  2480. m_pUDPResponse->ReadDone(HXR_OK, pBuffer, ulAddress, ulPort);
  2481. m_bInDoRead = TRUE;
  2483. HX_RELEASE(pBuffer);
  2484. HX_DELETE(pPacket);
  2486. Release();
  2488. m_bInDoRead = FALSE;
  2489. return HXR_OK;
  2490.     }
  2492.     /* if we called from within Read(), we will schedule a callback there, if necessary */
  2493.     if (!m_bInRead && m_pSchedulerReadCallback)
  2494.     m_pSchedulerReadCallback->ScheduleCallback(UDP_READ_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  2496. m_bInDoRead = FALSE;
  2497. return theErr;
  2498. }
  2500. HX_RESULT
  2501. HXUDPSocket::DoWrite()
  2502. {
  2503.     HX_RESULT theErr = HXR_OK;
  2505.     if (m_bInWrite) return HXR_OK;
  2506.     m_bInWrite = TRUE;
  2508. #ifdef _MACINTOSH
  2509. if (m_pInterruptSafeMacWriteQueue)
  2510. m_pInterruptSafeMacWriteQueue->TransferToSimpleList(m_WriteBuffers);
  2511. #endif
  2513.     while (!theErr && m_WriteBuffers.GetCount() > 0)
  2514.     {
  2515. IHXBuffer* pBuffer = (IHXBuffer*) m_WriteBuffers.GetHead();
  2516. UINT16 uLength = (UINT16) pBuffer->GetSize();
  2517. theErr = m_pData->writeto(  pBuffer->GetBuffer(),   // sendto
  2518.     &uLength,
  2519.     (UINT32) m_sockAddr.sin_addr.s_addr,
  2520.     WToHost(m_sockAddr.sin_port));
  2521. if (!theErr)
  2522. {
  2523.     pBuffer->Release();
  2524.     m_WriteBuffers.RemoveHead();
  2525. }
  2526.     }
  2528.     if (m_pSchedulerWriteCallback &&
  2529. m_WriteBuffers.GetCount() > 0)
  2530.     {
  2531.     m_pSchedulerWriteCallback->ScheduleCallback(UDP_WRITE_COMMAND, m_pScheduler, SCHED_GRANULARITY);
  2532.     }
  2534.     m_bInWrite = FALSE;
  2536.     return theErr;
  2537. }
  2539. /* If we are at interrupt time and the response object is not interrupt safe,
  2540.  * schedule a callback to return back the data
  2541.  */
  2542. BOOL
  2543. HXUDPSocket::IsSafe()
  2544. {
  2545.     if (m_pInterruptState && m_pInterruptState->AtInterruptTime() &&
  2546. (!m_pResponseInterruptSafe ||
  2547.  !m_pResponseInterruptSafe->IsInterruptSafe()))
  2548.     {
  2549. if (m_pNonInterruptReadCallback){
  2550. m_pNonInterruptReadCallback->ScheduleCallback(UDP_READ_COMMAND, m_pScheduler, 0);
  2551. }
  2553. return FALSE;
  2554.     }
  2556.     return TRUE;
  2557. }
  2559. STDMETHODIMP HXUDPSocket::HandleCallback(INT32  theCommand, HX_RESULT theError)
  2560. {
  2561.     HX_RESULT theErr = HXR_OK;
  2562.     if (!m_bInDestructor)
  2563.     {
  2564. AddRef();
  2565. m_pMutex->Lock();
  2566. if (!m_bInDestructor)
  2567. {
  2568. switch(theCommand)
  2569. {
  2570. case UDP_READ_COMMAND:
  2571.     theErr = DoRead();
  2572.     break;
  2574. case UDP_WRITE_COMMAND:
  2575.     theErr = DoWrite();  // protected from re-entry by m_bInWrite
  2576.     break;
  2578. default:
  2579.     theErr = DoRead();
  2580.                             if( theErr == HXR_OK )
  2581.                             {
  2582.         theErr = DoWrite();
  2583.                             }
  2584.     break;
  2585.     }
  2586. }
  2587. m_pMutex->Unlock();
  2588. Release();
  2589.     }
  2591.     return theErr;
  2592. }
  2595. HX_RESULT HXUDPSocket::UDPSocketCallback::Func(NotificationType Type,
  2596.        BOOL bSuccess, conn* pConn)
  2597. {
  2598.     if(m_pContext)
  2599.     {
  2600. switch (Type)
  2601. {
  2602. case READ_NOTIFICATION:
  2603. #if defined(_UNIX_THREADED_NETWORK_IO)
  2604.             if( !ReadNetworkThreadingPref((IUnknown*)(m_pContext->m_pContext)) )
  2605.             {
  2606.                 m_pContext->AddRef();
  2607.                 m_pContext->m_pMutex->Lock();
  2608.                 m_pContext->DoRead();
  2609.                 m_pContext->m_pMutex->Unlock();
  2610.                 m_pContext->Release();
  2611.             }
  2612. #elif !defined (THREADS_SUPPORTED) && !defined(_MACINTOSH)
  2613.     m_pContext->AddRef();
  2614.     m_pContext->m_pMutex->Lock();
  2615.     m_pContext->DoRead();
  2616.     m_pContext->m_pMutex->Unlock();
  2617.     m_pContext->Release();
  2618. #endif
  2619.     break;
  2620. case WRITE_NOTIFICATION:
  2621. #if defined(_UNIX_THREADED_NETWORK_IO)
  2622.             if( !ReadNetworkThreadingPref((IUnknown*)(m_pContext->m_pContext)) )
  2623.             {
  2624.                 m_pContext->AddRef();
  2625.                 m_pContext->m_pMutex->Lock();
  2626.                 m_pContext->DoWrite();
  2627.                 m_pContext->m_pMutex->Unlock();
  2628.                 m_pContext->Release();
  2629.             }
  2630. #elif !defined (THREADS_SUPPORTED) && !defined(_MACINTOSH)
  2631.     m_pContext->AddRef();
  2632.     m_pContext->m_pMutex->Lock();
  2633.     m_pContext->DoWrite();
  2634.     m_pContext->m_pMutex->Unlock();
  2635.     m_pContext->Release();
  2636. #endif
  2637.     break;
  2638. case CONNECT_NOTIFICATION:
  2639. default:
  2640.     break;
  2641. }
  2642.     }
  2643.     return HXR_OK;
  2644. }
  2647. STDMETHODIMP
  2648. HXUDPSocket::SetOption(HX_SOCKET_OPTION option, UINT32 ulValue)
  2649. {
  2650.     HX_RESULT res = HXR_OK;
  2652.     switch(option)
  2653.     {
  2654.     case HX_SOCKOPT_REUSE_ADDR:
  2655. m_bReuseAddr = (BOOL)ulValue;
  2656.     break;
  2657.     case HX_SOCKOPT_REUSE_PORT:
  2658. m_bReusePort = (BOOL)ulValue;
  2659.     break;
  2660. case HX_SOCKOPT_BROADCAST:
  2661. {
  2662. HX_RESULT theErr = HXR_OK;
  2663. if(m_pData)
  2664. {
  2665. m_pMutex->Lock();
  2666. theErr = m_pData->set_broadcast(ulValue);
  2667. res = ConvertNetworkError(theErr);
  2668. m_pMutex->Unlock();
  2669. }
  2670. }
  2671. break;
  2672.     case HX_SOCKOPT_MULTICAST_IF:
  2673. if (m_pData)
  2674. {
  2675.     res = m_pData->set_multicast_if(ulValue);
  2676. }
  2677. break;
  2678.     case HX_SOCKOPT_SET_SENDBUF_SIZE:
  2679.     {
  2680.       if (m_pData)
  2681.       {
  2682.           HX_RESULT theErr = HXR_OK;
  2684.            m_pMutex->Lock();
  2685.            theErr = m_pData->set_send_size(ulValue);
  2686.            res = ConvertNetworkError(theErr);
  2687.            m_pMutex->Unlock();
  2688.       }
  2689.       break;
  2690.     }
  2691.     default:
  2692. HX_ASSERT(!"I don't know this option");
  2693. res = HXR_FAIL;
  2694.     }
  2696.     return res;
  2697. }
  2699. STDMETHODIMP
  2700. HXUDPSocket::SetOption(HX_PRIVATE_SOCKET_OPTION option, UINT32 ulValue)
  2701. {
  2702.     HX_RESULT res = HXR_OK;
  2704.     switch(option)
  2705.     {
  2706.     case HX_PRIVATE_SOCKOPT_IGNORE_WSAECONNRESET:
  2707.     {
  2708. if (m_pData)
  2709. {
  2710.     m_pMutex->Lock();
  2711.     m_pData->IgnoreWSAECONNRESET((BOOL)ulValue);
  2712.     m_pMutex->Unlock();
  2713. }
  2714. break;
  2715.     }
  2716.     default:
  2717. HX_ASSERT(!"I don't know this option");
  2718. res = HXR_FAIL;
  2719.     }
  2720.     return HXR_OK;
  2721. }
  2723. #ifdef _MACINTOSH
  2725. /////////////////////////////////////////////////////////////////////////
  2726. //
  2727. // InterruptSafeMacQueue
  2728. //
  2729. // For passing data between an interrupt and anything else (mac only).
  2730. //
  2731. InterruptSafeMacQueue::InterruptSafeMacQueue()
  2732. {
  2733.   mQueueHeader.qFlags=0;
  2734. mQueueHeader.qHead=0;
  2735. mQueueHeader.qTail=0;
  2736. mDestructing = FALSE; // just a safety check
  2737. }
  2739. /////////////////////////////////////////////////////////////////////////
  2740. //
  2741. HX_RESULT InterruptSafeMacQueue::AddTail(IUnknown* pObject)
  2742. {
  2743. if (pObject && !mDestructing)
  2744. {
  2745.     IhxQueueElement * theElement = new IhxQueueElement();
  2747.     if (theElement)
  2748.     {
  2749.     theElement->mNextElementInQueue = NULL;
  2750.     theElement->mObject = pObject;
  2751.     theElement->mObject->AddRef();
  2752.     ::Enqueue((QElem *)theElement, &mQueueHeader);
  2754.     //
  2755.     // If someone interrupts and enters the destructor while we're in here,
  2756.     // then the pObject and the new node will be leaked.  This shouldn't
  2757.     // happen since we should have shut down all interrupts that would
  2758.     // be adding items to the queue long before we start destructing it.
  2759.     //
  2761.     HX_ASSERT(!mDestructing); // if we DID enter the destructor, let the programmer know...
  2762.     }
  2764.     return HXR_OK;
  2765.     }
  2767.     return HXR_FAILED;
  2768. }
  2770. /////////////////////////////////////////////////////////////////////////
  2771. //
  2772. IUnknown * InterruptSafeMacQueue::RemoveHead()
  2773. {
  2774. //
  2775.     // POINT A
  2776.     //
  2777.     // You can look at the qHead anytime you want, but you can't USE a
  2778.     // pointer unless it's OFF of the queue.  Basically you do a Dequeue,
  2779.     // and if it succeeds then you know nobody else has it.  If it fails,
  2780.     // an error is returned and you don't mess with it.
  2781.     //
  2783. if (mQueueHeader.qHead)
  2784.     {
  2785.   IhxQueueElement * theElement = (IhxQueueElement *) mQueueHeader.qHead;
  2787. if (theElement)
  2788. {
  2789. OSErr e = ::Dequeue( (QElemPtr) theElement, &mQueueHeader );
  2791. //
  2792. // Between points A and D, we can't be guaranteed that the queue header and theElement are valid.  But
  2793. // Dequeue will TELL us if that pointer is still valid by its return code.  If it can't remove the item
  2794. // from the queue, then somebody else did and the pointer is no longer ours.  If no error was returned
  2795. // from dequeue, then it's ours to mess with.
  2796. //
  2798. if (e == noErr)
  2799. {
  2800. // at this point we know that we can do whatever we need to with the object.
  2801. IUnknown * theObj = theElement->mObject;
  2802. delete theElement; // delete the node
  2803. return theObj;
  2804. }
  2805. }
  2806.    }
  2808.    return NULL;
  2809. }
  2811. /////////////////////////////////////////////////////////////////////////
  2812. //
  2813. HX_RESULT InterruptSafeMacQueue::TransferToSimpleList(CHXSimpleList &simpleList)
  2814. {
  2815. IUnknown * theObject;
  2817. // we did an AddRef in the AddTail call -- just pass it along to the simplelist
  2818. while ((theObject = RemoveHead()) != 0)
  2819. {
  2820. simpleList.AddTail((void *)theObject);
  2821. }
  2823.    return HXR_OK;
  2824. }
  2826. /////////////////////////////////////////////////////////////////////////
  2827. //
  2828. InterruptSafeMacQueue::~InterruptSafeMacQueue()
  2829. {
  2830. mDestructing = TRUE; // don't add anything else to the queue
  2832. IUnknown * theObject;
  2834. while ((theObject = RemoveHead()) != 0)
  2835.     {
  2836. theObject->Release();
  2837.     }
  2839.     // and just to be safe...
  2840. mQueueHeader.qHead=0;
  2841. mQueueHeader.qTail=0;
  2842. }
  2844. #endif // _MACINTOSH