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

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

Symbian

开发平台：

C/C++

thrdconn.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 "hlxclib/time.h"
  37. #include <stdio.h>
  38. #include <string.h>
  39. #include "hxcom.h"
  40. #include "conn.h"
  42. #if defined (_WIN32) || defined (WIN32)
  43. #include "platform/win/win_net.h"
  44. #include "platform/win/casynthr.h"
  45. #endif
  47. #if defined(_UNIX) && (defined( _UNIX_THREADED_NETWORK_IO ) || defined(THREADS_SUPPORTED))
  48. #include "platform/unix/UnixThreads.h"
  49. #endif /* _UNIX_THREADED_NETWORK_IO */
  51. #ifdef _CARBON
  52. #include "carbthrd.h"
  53. #endif
  56. #include "hxslist.h"
  57. #include "growingq.h"
  59. #include "hxengin.h"
  60. #include "ihxpckts.h"
  61. #include "hxbuffer.h"
  62. #include "timebuff.h"
  63. #include "hxtick.h"
  64. #include "hxthread.h"
  65. #include "threngin.h"
  66. #include "conn.h"
  67. #include "thrdconn.h"
  68. #include "hxheap.h"
  69. #ifdef _DEBUG
  70. #undef HX_THIS_FILE
  71. static const char HX_THIS_FILE[] = __FILE__;
  72. #endif
  74. #define QUEUE_START_SIZE    512
  76. ThreadedConn*
  77. ThreadedConn::new_socket(UINT16 type)
  78. {
  79.     return new ThreadedConn(type);
  80. }
  82. /*
  83. HXThread*
  84. ThreadedConn::GetNetworkThread(void)
  85. {
  86. #if defined (_WIN32)
  87.     return win_net::GetNetworkThread();
  88. #else
  89.     HX_ASSERT(FALSE);
  90.     return HXR_UNEXXPECTED;
  91. #endif
  92. }
  94. void
  95. ThreadedConn::DestroyNetworkThread(void)
  96. {
  97. #if defined (_WIN32)
  98.     win_net::DestroyNetworkThread();
  99. #else
  100.     HX_ASSERT(FALSE);
  101.     return P NR_UNEXXPECTED;
  102. #endif
  103. }
  104. */
  106. ThreadedConn::ThreadedConn(UINT16 type)
  107.     : m_lRefCount(0)
  108.     , m_pActualConn(NULL)
  109.     , m_uSocketType(type)
  110.     , m_pNetworkThread(NULL)
  111.     , m_pMainAppThread(NULL)
  112.     , m_pNetCallback(0)
  113.     , m_pSendTCP (0)
  114.     , m_pReceiveTCP (0)
  115.     , m_pTempBuffer (0)
  116.     , m_ulUserHandle(0)
  117.     , m_pInternalWindowHandle(NULL)
  118.     , m_bConnected(FALSE)
  119.     , m_bIsDone(FALSE)
  120.     , m_bDetachPending(TRUE)
  121.     , m_pInitEvent(0)
  122.     , m_pQuitEvent(0)
  123.     , m_pListenEvent(NULL)
  124.     , m_pDetachEvent(0)
  125.     , m_bInitialized(FALSE)
  126.     , m_bOutstandingReadNotification(FALSE)
  127.     , m_bOutstandingWriteNotification(FALSE)
  128.     , m_bWriteFlushPending(FALSE)
  129.     , m_bNetworkIOPending(FALSE)
  130.     , m_bReadNowPending(FALSE)
  131.     , m_bReadPostPendingWouldBlock(FALSE)
  132.     , m_pIncommingConnections(NULL)
  133.     , m_bIgnoreWSAECONNRESET(FALSE)
  134. #if defined (_WIN32) || defined (WIN32)
  135.     , m_pNotifier(NULL)
  136. #endif
  137. {
  138.     m_pActualConn = conn::actual_new_socket(type);
  139.     m_pActualConn->AddRef();
  140.     conn::add_connection_to_list (m_pActualConn);
  142.     ThreadEngine* pEngine = ThreadEngine::GetThreadEngine();
  143.     // NOTE: pEngine allocation is not checked for success.
  144.     pEngine->AttachSocket(this);
  145.     m_pNetworkThread    = pEngine->GetNetworkThread();
  146.     m_pMainAppThread    = pEngine->GetMainAppThread();
  147.     m_pNetCallback      = new ThrConnSocketCallback(this);
  149. #if defined(THREADS_SUPPORTED) || defined(_UNIX_THREADED_NETWORK_IO)
  150.     HXMutex::MakeMutex(m_pMutex);
  151.     HXEvent::MakeEvent(m_pInitEvent, NULL, FALSE);
  152.     HXEvent::MakeEvent(m_pQuitEvent, NULL);
  153.     HXEvent::MakeEvent(m_pDetachEvent, NULL);
  154.     HXEvent::MakeEvent(m_pListenEvent, NULL, FALSE);
  155. #else
  156.     HXMutex::MakeStubMutex(m_pMutex);
  157.     HXEvent::MakeStubEvent(m_pInitEvent, NULL, FALSE);
  158.     HXEvent::MakeStubEvent(m_pQuitEvent, NULL);
  159.     HXEvent::MakeStubEvent(m_pDetachEvent, NULL);
  160.     HXEvent::MakeStubEvent(m_pListenEvent, NULL, FALSE);
  161. #endif
  163.     m_pTempBuffer = new char[TCP_BUF_SIZE];
  165.     /* Allocate byte queues ONLY if it is a TCP socket */
  166.     if (m_uSocketType == HX_TCP_SOCKET)
  167.     {
  168.         // allocate TCP send and receive queue
  169.         m_pSendTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  170.         if (!m_pSendTCP || !m_pSendTCP->IsQueueValid())
  171.         {
  172.             mLastError = HXR_OUTOFMEMORY;
  173.         }
  174.         m_pSendTCP->SetMaxSize(TCP_BUF_SIZE);
  176.         m_pReceiveTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  177.         if (!m_pReceiveTCP || !m_pReceiveTCP->IsQueueValid())
  178.         {
  179.             mLastError = HXR_OUTOFMEMORY;
  180.         }
  181.         m_pReceiveTCP->SetMaxSize(TCP_BUF_SIZE);
  182.     }
  184. }
  186. ThreadedConn::~ThreadedConn()
  187. {
  188.     if (m_pNetCallback)
  189.     {
  190.         m_pNetCallback->m_pContext = 0;
  191.     }
  193.     if (m_pActualConn)
  194.     {
  195.         m_pActualConn->done();
  196.         m_pActualConn->Release();
  197.         m_pActualConn = 0;
  198.     }
  200.     HX_DELETE(m_pNetCallback);
  201.     HX_VECTOR_DELETE(m_pTempBuffer);
  202.     HX_DELETE(m_pSendTCP);
  203.     HX_DELETE(m_pReceiveTCP);
  205.     while (m_WriteUDPBuffers.GetCount() > 0)
  206.     {
  207.         UDPPacketInfo* pPacket = (UDPPacketInfo*) m_WriteUDPBuffers.RemoveHead();
  208.         pPacket->m_pBuffer->Release();
  209.         delete pPacket;
  210.     }
  212.     while (m_ReadUDPBuffers.GetCount() > 0)
  213.     {
  214.         UDP_PACKET* pPacket = (UDP_PACKET*) m_ReadUDPBuffers.RemoveHead();
  215.         HX_RELEASE(pPacket->pBuffer);
  216.         HX_DELETE(pPacket);
  217.     }
  219.     HX_DELETE(m_pMutex);
  220.     HX_DELETE(m_pInitEvent);
  221.     HX_DELETE(m_pQuitEvent);
  222.     HX_DELETE(m_pDetachEvent);
  223.     HX_DELETE(m_pListenEvent);
  224.     HX_DELETE(m_pIncommingConnections);
  226.     mCallBack = NULL;
  227. #ifdef _UNIX_THREADED_NETWORK_IO
  228.     if( m_bNetworkThreading )
  229.     {
  230.         //Remove any messages from the main app thread for us.
  231.         HX_ASSERT( m_pMainAppThread );
  232.         HXThreadMessage msgBack;
  233.         HXThreadMessage msgMatch(0, (void*)this, NULL, NULL);
  234.         while(((HXUnixThread*)m_pMainAppThread)->PeekMessageMatching(&msgBack, &msgMatch, TRUE )==HXR_OK)
  235.         {
  236.         }
  237.     }
  238.     m_pMainAppThread=NULL;
  239. #elif defined(_CARBON) && defined(THREADS_SUPPORTED)
  240.     // remove any messages from the main app thread for us.
  241.     HX_ASSERT(m_pMainAppThread);
  242.     HXThreadMessage msgBack;
  243.     HXThreadMessage msgMatch(0, (void*)this, NULL, NULL);
  244.     while (((HXCarbonThread*)m_pMainAppThread)->PeekMessageMatching(&msgBack, &msgMatch, TRUE) == HXR_OK)
  245.     {
  246.     }
  247.     m_pMainAppThread = NULL;
  248. #endif
  249. }
  251. ULONG32 ThreadedConn::AddRef()
  252. {
  253.     return InterlockedIncrement(&m_lRefCount);
  254. }
  256. ULONG32 ThreadedConn::Release()
  257. {
  258.     if (InterlockedDecrement(&m_lRefCount) > 0)
  259.     {
  260.         return m_lRefCount;
  261.     }
  263.     delete this;
  264.     return 0;
  265. }
  267. HX_RESULT
  268. ThreadedConn::dns_find_ip_addr(const char* host, UINT16 blocking)
  269. {
  270.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, DNS_CALLBACK_TYPE);
  271.     pCallback->m_HostName   = host;
  272.     pCallback->m_bBlocking  = (BOOL) blocking;
  273.     /* Will be released by the thread engine */
  274.     pCallback->AddRef();
  275.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  276.     return m_pNetworkThread->PostMessage(&msg);
  277. }
  280. HX_RESULT
  281. ThreadedConn::ActualDnsFindIpAddr(const char* host, UINT16 blocking)
  282. {
  283.     HX_RESULT theErr = HXR_UNEXPECTED;
  284.     HX_ASSERT(m_pActualConn);
  285.     if (m_pActualConn)
  286.     {
  287.         m_pMutex->Lock();
  288.         theErr = m_pActualConn->dns_find_ip_addr(host, blocking);
  289.         m_pMutex->Unlock();
  290.     }
  292.     return theErr;
  293. }
  295. BOOL
  296. ThreadedConn::dns_ip_addr_found(BOOL* valid, ULONG32* addr)
  297. {
  299.     BOOL bResult = FALSE;
  300.     HX_ASSERT(m_pActualConn);
  301.     if (m_pActualConn)
  302.     {
  303.         m_pMutex->Lock();
  304.         bResult = m_pActualConn->dns_ip_addr_found(valid, addr);
  305.         m_pMutex->Unlock();
  306.     }
  308.     return bResult;
  309. }
  311. void
  312. ThreadedConn::finaldone (void)
  313. {
  314.     if (!m_bIsDone)
  315.     {
  316.         done();
  317.     }
  319.     /* final attempt to cleanup */
  320.     PostDoneAndDetach();
  322.     if (m_pQuitEvent)
  323.     {
  324.         m_pQuitEvent->Wait(ALLFS);
  325.     }
  327.     if (m_pDetachEvent)
  328.     {
  329.         m_pDetachEvent->Wait(ALLFS);
  330.     }
  331. }
  333. void
  334. ThreadedConn::Detached (void)
  335. {
  336.     if (m_pDetachEvent)
  337.     {
  338.         m_pDetachEvent->SignalEvent();
  339.     }
  340. }
  342. void
  343. ThreadedConn::done (void)
  344. {
  345.     /* Do not pass any more callbacks to the client above */
  346.     mCallBack   = NULL;
  347.     m_bIsDone   = TRUE;
  348.     /* Actual message to release the socket will be posted in DoWrite() */
  350. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  351.     if (!m_pNotifier)
  352.     {
  353.         m_pNotifier =
  354.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)m_ulUserHandle,
  355.                                                         FALSE);
  356.     }
  357.     if (m_pNotifier)
  358.     {
  359.         m_pNotifier->DetachSocket(this);
  360.         m_pNotifier = NULL;
  361.     }
  362. #endif /*defined (_WINDOWS) || defined (_WIN32)*/
  364.     if (!m_bConnected)
  365.     {
  366.         PostDoneAndDetach();
  367.     }
  368. }
  370. void
  371. ThreadedConn::PostDoneAndDetach()
  372. {
  373.     // If we are out of memory, let's just get out of here. Ideally, we should
  374.     // not ever get to this point, but lots of functions here have void return
  375.     // types, so it is possible.
  376.     if( mLastError == HXR_OUTOFMEMORY )
  377.     {
  378.         return;
  379.     }
  381.     m_pMutex->Lock();
  383.     if (m_bDetachPending)
  384.     {
  385.         m_bDetachPending = FALSE;
  386.         ThrdConnGenericCallback* pCallback      = new ThrdConnGenericCallback(this, DONE_CALLBACK_TYPE);
  387.         /* Will be released by the thread engine */
  388.         pCallback->AddRef();
  389.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  390.         m_pNetworkThread->PostMessage(&msg);
  391.         HXThreadMessage msg1(HXMSG_ASYNC_DETACH, this, NULL);
  392.         m_pNetworkThread->PostMessage(&msg1);
  393.     }
  395.     m_pMutex->Unlock();
  396. }
  398. void
  399. ThreadedConn::ActualDone (void)
  400. {
  401.     HX_ASSERT(m_pActualConn);
  402.     if (m_pActualConn)
  403.     {
  404.         m_pMutex->Lock();
  405.         m_bConnected = FALSE;
  406.         m_pActualConn->done();
  407.         m_pActualConn->Release();
  408.         m_pActualConn = 0;
  409.         m_pMutex->Unlock();
  410.     }
  412.     if (m_pQuitEvent)
  413.     {
  414.         m_pQuitEvent->SignalEvent();
  415.     }
  416. }
  418. HX_RESULT
  419. ThreadedConn::init  (UINT32 local_addr,UINT16 port, UINT16 blocking)
  420. {
  421.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, INIT_CALLBACK_TYPE);
  422.     pCallback->m_ulLocalAddr    = local_addr;
  423.     pCallback->m_uPort          = port;
  424.     pCallback->m_bBlocking      = (BOOL) blocking;
  425.     /* Will be released by the thread engine */
  426.     pCallback->AddRef();
  428.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  429.     m_pNetworkThread->PostMessage(&msg);
  431.     /* Wait for the actual Initialization to complete. This is the only
  432.        function we wait for the networking thread to complete before passing
  433.        the result to the user since there is no async interface to pass the result
  434.        back and it very much possible that socket binding may fail during
  435.        initialization
  436.      */
  437.     m_pInitEvent->Wait();
  439.     if (m_bInitialized)
  440.     {
  441.         return HXR_OK;
  442.     }
  443.     else
  444.     {
  445.         return HXR_FAIL;
  446.     }
  447. }
  449. HX_RESULT
  450. ThreadedConn::ActualInit(UINT32 local_addr,UINT16 port, UINT16 blocking)
  451. {
  452.     HX_RESULT theErr = HXR_UNEXPECTED;
  453.     HX_ASSERT(m_pActualConn);
  454.     if (m_pActualConn)
  455.     {
  456.         m_pMutex->Lock();
  457.         theErr = m_pActualConn->init(local_addr, port, blocking);
  458.         if (!theErr && m_uSocketType == HX_UDP_SOCKET)
  459.         {
  460.             m_bConnected = TRUE;
  461.         }
  463.         if (!theErr)
  464.         {
  465.             m_bInitialized = TRUE;
  466.         }
  468.         /* Signal the main thread that intialization is complete */
  469.         m_pInitEvent->SignalEvent();
  470.         m_pMutex->Unlock();
  471.     }
  473.     return theErr;
  474. }
  476. HX_RESULT
  477. ThreadedConn::listen(ULONG32 ulAddr,  UINT16 port, UINT16 backlog,
  478.                      UINT16 blocking, ULONG32 ulPlatform)
  479. {
  480.     HX_RESULT theErr = HXR_OK;
  482. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  483.     m_ulUserHandle  = ulPlatform;
  485.     if (!m_pNotifier)
  486.     {
  487.         m_pNotifier =
  488.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)ulPlatform,
  489.                                                         TRUE);
  490.     }
  491.     if (m_pNotifier)
  492.     {
  493.         m_pInternalWindowHandle = (void*) m_pNotifier->GetWindowHandle();
  494.         m_pNotifier->AttachSocket(this);
  495.     }
  496.     else
  497.     {
  498.         theErr = HXR_OUTOFMEMORY;
  499.     }
  500. #endif /*defined (_WIN32) || defined (WIN32)*/
  502.     HX_DELETE(m_pIncommingConnections);
  503.     m_pIncommingConnections = new CHXSimpleList();
  505.     if (!theErr)
  506.     {
  507.         ThrdConnGenericCallback* pCallback      =
  508.                 new ThrdConnGenericCallback(this, LISTEN_CALLBACK_TYPE);
  509.         pCallback->m_ulLocalAddr = ulAddr;
  510.         pCallback->m_uPort      = port;
  511.         pCallback->m_uBacklog   = backlog;
  512.         pCallback->m_bBlocking  = (BOOL) blocking;
  513.         pCallback->m_ulHandle   = ulPlatform;
  514.         /* Will be released by the thread engine */
  515.         pCallback->AddRef();
  516.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  517.         theErr = m_pNetworkThread->PostMessage(&msg);
  519.         if ( SUCCEEDED(theErr) )
  520.         {
  521.             /*
  522.              * Wait for the actual Listen to complete.
  523.              */
  524.     // listen is called from the network thread, so this will wait forever
  525. #ifdef HELIX_FEATURE_NETWORK_USE_SELECT
  526.     m_bListenning = TRUE;
  527. #else
  528.             m_pListenEvent->Wait();
  529. #endif
  531.             if ( m_bListenning )
  532.             {
  533.                 theErr = HXR_OK;
  534.             }
  535.             else
  536.             {
  537.                 theErr = HXR_FAIL;
  538.             }
  539.         }
  540.     }
  541. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  542.     set_callback(m_pNetCallback); // for accept msg
  543. #endif //HELIX_FEATURE_NETWORK_USE_SELECT
  544.     return theErr;
  545. }
  547. HX_RESULT
  548. ThreadedConn::ActualListen( ULONG32     ulAddr,
  549.                             UINT16      port,
  550.                             UINT16      backlog,
  551.                             UINT16      blocking,
  552.                             ULONG32     ulPlatform)
  553. {
  554.     HX_RESULT err = HXR_UNEXPECTED;
  555.     HX_ASSERT(m_pActualConn);
  556.     if ( m_pActualConn )
  557.     {
  558.         m_pMutex->Lock();
  559.         err = m_pActualConn->listen(ulAddr, port, backlog, blocking, ulPlatform);
  561.         if ( SUCCEEDED(err) )
  562.         {
  563.             m_bListenning = TRUE;
  564.         }
  565.         else
  566.         {
  567.             m_bListenning = FALSE;
  568.         }
  570.         m_pListenEvent->SignalEvent();
  571.         m_pMutex->Unlock();
  572.     }
  573.     return err;
  574. }
  576. #if     defined (_WINDOWS) || defined (_WIN32)
  577. // we need it for dns_find_ip_addr since async stuff needs a window handle...
  578. HX_RESULT
  579. ThreadedConn::SetWindowHandle(ULONG32 handle)
  580. {
  581.     HX_RESULT theErr = HXR_OK;
  583.     m_pMutex->Lock();
  584.     m_ulUserHandle  = handle;
  585. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  586.     if (!m_pNotifier)
  587.     {
  588.         m_pNotifier =
  589.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)handle,
  590.                                                         TRUE);
  591.     }
  592.     if (m_pNotifier)
  593.     {
  594.         m_pInternalWindowHandle = (void*)m_pNotifier->GetWindowHandle();
  595.         m_pNotifier->AttachSocket(this);
  596.     }
  597.     else
  598.     {
  599.         theErr = HXR_OUTOFMEMORY;
  600.     }
  601. #endif /*defined (_WIN32) || defined (WIN32)*/
  603.     if (!theErr)
  604.     {
  605.         ThrdConnGenericCallback* pCallback      =
  606.                 new ThrdConnGenericCallback(this, SETWINDOWHANDLE_CALLBACK_TYPE);
  607.         pCallback->m_ulHandle   = handle;
  608.         /* Will be released by the thread engine */
  609.         pCallback->AddRef();
  610.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  611.         theErr = m_pNetworkThread->PostMessage(&msg);
  612.     }
  614.     m_pMutex->Unlock();
  616.     return theErr;
  617. }
  620. HX_RESULT
  621. ThreadedConn::ActuallSetWindowHandle(ULONG32 handle)
  622. {
  623.     HX_RESULT theErr = HXR_UNEXPECTED;
  625.     HX_ASSERT(m_pActualConn);
  626.     if (m_pActualConn)
  627.     {
  628.         m_pMutex->Lock();
  629.         theErr = m_pActualConn->SetWindowHandle(handle);
  630.         if (!theErr)
  631.         {
  632.         }
  633.         m_pMutex->Unlock();
  634.     }
  636.     return theErr;
  637. }
  639. #endif /* defined (_WINDOWS) || defined (_WIN32)*/
  641. HX_RESULT
  642. ThreadedConn::connect(const char*   host,
  643.                      UINT16         port,
  644.                      UINT16         blocking,
  645.                      ULONG32        ulPlatform)
  646. {
  647.     HX_RESULT theErr = HXR_OK;
  649. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  650.     m_ulUserHandle  = ulPlatform;
  652.     if (!m_pNotifier)
  653.     {
  654.         m_pNotifier =
  655.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)ulPlatform,
  656.                                                         TRUE);
  657.     }
  658.     if (m_pNotifier)
  659.     {
  660.         m_pInternalWindowHandle = (void*) m_pNotifier->GetWindowHandle();
  661.         m_pNotifier->AttachSocket(this);
  662.     }
  663.     else
  664.     {
  665.         theErr = HXR_OUTOFMEMORY;
  666.     }
  667. #endif /*defined (_WIN32) || defined (WIN32)*/
  669.     if (!theErr)
  670.     {
  671.         ThrdConnGenericCallback* pCallback      =
  672.                 new ThrdConnGenericCallback(this, CONNECT_CALLBACK_TYPE);
  673.         pCallback->m_HostName   = host;
  674.         pCallback->m_uPort              = port;
  675. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  676. blocking = 1; // we don't get fd_connect when doing loopback
  677. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  678.         pCallback->m_bBlocking  = (BOOL) blocking;
  679.         pCallback->m_ulHandle   = ulPlatform;
  680.         /* Will be released by the thread engine */
  681.         pCallback->AddRef();
  682.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  683.         theErr = m_pNetworkThread->PostMessage(&msg);
  684.     }
  686.     return theErr;
  687. }
  689. HX_RESULT
  690. ThreadedConn::ActualConnect(const char* host,
  691.                             UINT16      port,
  692.                             UINT16      blocking,
  693.                             ULONG32     ulPlatform)
  694. {
  695.     HX_RESULT theErr = HXR_UNEXPECTED;
  696.     HX_ASSERT(m_pActualConn);
  697.     if (m_pActualConn)
  698.     {
  699.         m_pMutex->Lock();
  700.         theErr = m_pActualConn->connect(host, port, blocking, ulPlatform);
  701.         m_pMutex->Unlock();
  702.     }
  704.     return theErr;
  705. }
  707. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  708. HX_RESULT
  709. ThreadedConn::accept (ULONG32 ulAddr)
  710. {
  711.     HX_RESULT theErr = HXR_OK;
  713. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  714.     m_ulUserHandle  = NULL; //ulPlatform;
  716.     if (!m_pNotifier)
  717.     {
  718.         m_pNotifier =
  719.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)m_ulUserHandle,
  720.                                                         TRUE);
  721.     }
  722.     if (m_pNotifier)
  723.     {
  724.         m_pInternalWindowHandle = (void*) m_pNotifier->GetWindowHandle();
  725.         m_pNotifier->AttachSocket(this);
  726.     }
  727.     else
  728.     {
  729.         theErr = HXR_OUTOFMEMORY;
  730.     }
  731. #endif /*defined (_WIN32) || defined (WIN32)*/
  733.     if (!theErr)
  734.     {
  735.         ThrdConnGenericCallback* pCallback      =
  736.                 new ThrdConnGenericCallback(this, ACCEPT_CALLBACK_TYPE);
  737.         pCallback->m_ulHandle   = m_ulUserHandle;
  738. pCallback->m_ulLocalAddr = ulAddr;
  739.         /* Will be released by the thread engine */
  740.         pCallback->AddRef();
  741.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  742.         theErr = m_pNetworkThread->PostMessage(&msg);
  743.     }
  745.     return theErr;
  746. }
  748. HX_RESULT
  749. ThreadedConn::ActualAccept(ULONG32 ulAddr,
  750.                             ULONG32     ulPlatform)
  751. {
  752.     HX_RESULT theErr = HXR_UNEXPECTED;
  753.     HX_ASSERT(m_pActualConn);
  754.     if (m_pActualConn)
  755.     {
  756.         m_pMutex->Lock();
  757.         theErr = m_pActualConn->CheckForConnection();
  758.         m_pMutex->Unlock();
  759. if (theErr == HXR_WOULD_BLOCK)
  760. {
  761.     ThrdConnGenericCallback* pCallback      =
  762.     new ThrdConnGenericCallback(this, ACCEPT_CALLBACK_TYPE);
  763.     pCallback->m_ulHandle   = ulPlatform;
  764.     pCallback->m_ulLocalAddr = ulAddr;
  765.     /* Will be released by the thread engine */
  766.     pCallback->AddRef();
  767.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  768.     theErr = m_pNetworkThread->PostMessage(&msg);
  769. }
  770.     }
  772.     return theErr;
  773. }
  774. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  776. HX_RESULT
  777. ThreadedConn::blocking(void)
  778. {
  779.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, BLOCKING_CALLBACK_TYPE);
  780.     /* Will be released by the thread engine */
  781.     pCallback->AddRef();
  782.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  783.     return m_pNetworkThread->PostMessage(&msg);
  784. }
  786. HX_RESULT
  787. ThreadedConn::ActualBlocking(void)
  788. {
  789.     HX_RESULT theErr = HXR_UNEXPECTED;
  790.     HX_ASSERT(m_pActualConn);
  791.     if (m_pActualConn)
  792.     {
  793.         m_pMutex->Lock();
  794.         theErr = m_pActualConn->blocking();
  795.         m_pMutex->Unlock();
  796.     }
  798.     return theErr;
  799. }
  801. HX_RESULT
  802. ThreadedConn::nonblocking(void)
  803. {
  804.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, NONBLOCKING_CALLBACK_TYPE);
  805.     /* Will be released by the thread engine */
  806.     pCallback->AddRef();
  807.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  808.     return m_pNetworkThread->PostMessage(&msg);
  809. }
  811. HX_RESULT
  812. ThreadedConn::ActualNonBlocking(void)
  813. {
  814.     HX_RESULT theErr = HXR_UNEXPECTED;
  815.     HX_ASSERT(m_pActualConn);
  816.     if (m_pActualConn)
  817.     {
  818.         m_pMutex->Lock();
  819.         theErr = m_pActualConn->nonblocking();
  820.         m_pMutex->Unlock();
  821.     }
  823.     return theErr;
  824. }
  827. HX_RESULT
  828. ThreadedConn::read (void* buf, UINT16* size)
  829. {
  830.     HX_RESULT theErr = HXR_OK;
  831.     UINT16 uCount = 0;
  833.     m_pMutex->Lock();
  834.     m_bOutstandingReadNotification = FALSE;
  836.     if (m_uSocketType != HX_TCP_SOCKET)
  837.     {
  838.         theErr = HXR_NET_SOCKET_INVALID;
  839.         goto cleanup;
  840.     }
  842.     uCount = m_pReceiveTCP->GetQueuedItemCount();
  843.     if (uCount > 0)
  844.     {
  845.         uCount = (uCount <= *size ? uCount : *size);
  846.         m_pReceiveTCP->DeQueue(buf, uCount);
  847.         *size = uCount;
  848.     }
  849.     else
  850.     {
  851.         *size = 0;
  852.         if (!mLastError && m_pActualConn)
  853.         {
  854.             theErr = HXR_WOULD_BLOCK;
  855.         }
  856.         else
  857.         {
  858.             theErr = mLastError;
  859.         }
  860.     }
  862. cleanup:
  864.     if (!mLastError && !m_bNetworkIOPending)
  865.     {
  866.         theErr = PostIOMessage();
  867.     }
  869.     m_pMutex->Unlock();
  871.     return theErr;
  872. }
  874. HX_RESULT
  875. ThreadedConn::readfrom (REF(IHXBuffer*)    pBuffer,
  876.                         REF(UINT32)         ulAddress,
  877.                         REF(UINT16)         ulPort)
  878. {
  879.     HX_RESULT theErr = HXR_OK;
  880.     UDP_PACKET* pPacket = NULL;
  882.     m_pMutex->Lock();
  883.     m_bOutstandingReadNotification = FALSE;
  885.     pBuffer = NULL;
  886.     ulAddress = 0;
  887.     ulPort = 0;
  889.     if (m_uSocketType != HX_UDP_SOCKET)
  890.     {
  891.         theErr = HXR_NET_SOCKET_INVALID;
  892.         goto cleanup;
  893.     }
  895.     if (m_ReadUDPBuffers.GetCount() > 0)
  896.     {
  897.         pPacket = (UDP_PACKET*)m_ReadUDPBuffers.RemoveHead();;
  899.         pBuffer = pPacket->pBuffer;
  900.         ulAddress = pPacket->ulAddress;
  901.         ulPort = pPacket->ulPort;
  903.         HX_DELETE(pPacket);
  904.     }
  905.     else
  906.     {
  907.         if (!mLastError)
  908.         {
  909.             theErr = HXR_WOULD_BLOCK;
  910.         }
  911.         else
  912.         {
  913.             theErr = mLastError;
  914.         }
  915.     }
  917. cleanup:
  919.     if (!m_bReadPostPendingWouldBlock && !mLastError && !m_bNetworkIOPending)
  920.     {
  921.         theErr = PostIOMessage();
  922.     }
  924.     m_pMutex->Unlock();
  926.     if( mLastError == HXR_OUTOFMEMORY )
  927.     {
  928.         theErr = mLastError;
  929.     }
  930.     return theErr;
  931. }
  933. HX_RESULT
  934. ThreadedConn::write (void* buf, UINT16* size)
  935. {
  936.     HX_RESULT theErr = HXR_OK;
  937.     HX_ASSERT(m_pActualConn && m_uSocketType == HX_TCP_SOCKET);
  939.     m_pMutex->Lock();
  940.     m_bOutstandingWriteNotification = FALSE;
  941.     UINT16 uCount = m_pSendTCP->GetMaxAvailableElements();
  942.     if (uCount > 0)
  943.     {
  944.         uCount = (uCount <= *size ? uCount : *size);
  945.         m_pSendTCP->EnQueue(buf, uCount);
  946.         *size = uCount;
  947.     }
  948.     else
  949.     {
  950.         *size = 0;
  951.         if (!mLastError)
  952.         {
  953.             theErr = HXR_WOULD_BLOCK;
  954.         }
  955.         else
  956.         {
  957.             theErr = mLastError;
  958.         }
  959.     }
  961.     if (!m_bWriteFlushPending && m_pSendTCP->GetQueuedItemCount() > 0 && m_bConnected)
  962.     {
  963.         m_bWriteFlushPending    = TRUE;
  964.         AddRef();
  965.     }
  967.     if (!mLastError && !m_bNetworkIOPending)
  968.     {
  969.         theErr = PostIOMessage();
  970.     }
  972.     m_pMutex->Unlock();
  974.     return theErr;
  975. }
  977. HX_RESULT
  978. ThreadedConn::writeto(void* buf,UINT16* len, ULONG32 addr, UINT16 port)
  979. {
  980.     HX_RESULT theErr = HXR_OK;
  981.     HX_ASSERT(m_pActualConn && m_uSocketType == HX_UDP_SOCKET);
  983.     m_pMutex->Lock();
  984.     m_bOutstandingWriteNotification = FALSE;
  985.     if (!mLastError)
  986.     {
  987.         UDPPacketInfo* pPacket  = new UDPPacketInfo;
  988.         pPacket->m_pBuffer  = new CHXBuffer;
  989.         pPacket->m_pBuffer->AddRef();
  990.         pPacket->m_pBuffer->Set((UCHAR*) buf, (ULONG32) *len);
  991.         pPacket->m_ulAddr   = addr;
  992.         pPacket->m_uPort    = port;
  993.         m_WriteUDPBuffers.AddTail((void*) pPacket);
  994.     }
  995.     else
  996.     {
  997.         theErr = mLastError;
  998.     }
  1000.     if (!theErr && !m_bWriteFlushPending && m_WriteUDPBuffers.GetCount() > 0 && m_bConnected)
  1001.     {
  1002.         m_bWriteFlushPending    = TRUE;
  1003.         AddRef();
  1004.     }
  1006.     if (!mLastError && !m_bNetworkIOPending)
  1007.     {
  1008.         theErr = PostIOMessage();
  1009.     }
  1011.     m_pMutex->Unlock();
  1013.     return theErr;
  1014. }
  1016. ULONG32
  1017. ThreadedConn::get_addr(void)
  1018. {
  1019.     ULONG32 ulAddr = 0;
  1020.     HX_ASSERT(m_pActualConn);
  1021.     if (m_pActualConn)
  1022.     {
  1023.         m_pMutex->Lock();
  1024.         ulAddr = m_pActualConn->get_addr();
  1025.         m_pMutex->Unlock();
  1026.     }
  1028.     return ulAddr;
  1029. }
  1031. UINT16
  1032. ThreadedConn::get_local_port(void)
  1033. {
  1034.     UINT16 nPort = 0;
  1035.     HX_ASSERT(m_pActualConn);
  1036.     if (m_pActualConn)
  1037.     {
  1038.         m_pMutex->Lock();
  1039.         nPort = m_pActualConn->get_local_port();
  1040.         m_pMutex->Unlock();
  1041.     }
  1043.     return nPort;
  1044. }
  1047. /* join_multicast_group() has this socket join a multicast group */
  1048. HX_RESULT
  1049. ThreadedConn::join_multicast_group(ULONG32 addr, ULONG32 if_addr)
  1050. {
  1051.     HX_RESULT theErr = HXR_UNEXPECTED;
  1052.     HX_ASSERT(m_pActualConn);
  1053.     if (m_pActualConn)
  1054.     {
  1055.         m_pMutex->Lock();
  1056.         theErr = m_pActualConn->join_multicast_group(addr, if_addr);
  1057.         m_pMutex->Unlock();
  1058.     }
  1060.     return theErr;
  1061. }
  1063. HX_RESULT
  1064. ThreadedConn::leave_multicast_group(ULONG32 addr, ULONG32 if_addr)
  1065. {
  1066.     HX_RESULT theErr = HXR_UNEXPECTED;
  1067.     HX_ASSERT(m_pActualConn);
  1068.     if (m_pActualConn)
  1069.     {
  1070.         m_pMutex->Lock();
  1071.         theErr = m_pActualConn->leave_multicast_group(addr, if_addr);
  1072.         while (!m_ReadUDPBuffers.IsEmpty())
  1073.         {
  1074.             UDP_PACKET* pPacket = (UDP_PACKET*)m_ReadUDPBuffers.RemoveHead();
  1076.             HX_RELEASE(pPacket->pBuffer);
  1077.             HX_DELETE(pPacket);
  1078.         }
  1079.         m_pMutex->Unlock();
  1080.     }
  1082.     return theErr;
  1083. }
  1085. HX_RESULT
  1086. ThreadedConn::reuse_addr(BOOL enabled)
  1087. {
  1088.     HX_RESULT theErr = HXR_UNEXPECTED;
  1089.     HX_ASSERT(m_pActualConn);
  1090.     if (m_pActualConn)
  1091.     {
  1092.         m_pMutex->Lock();
  1093.         theErr = m_pActualConn->reuse_addr(enabled);
  1094.         m_pMutex->Unlock();
  1095.     }
  1096.     return theErr;
  1097. }
  1099. HX_RESULT
  1100. ThreadedConn::reuse_port(BOOL enabled)
  1101. {
  1102.     HX_RESULT theErr = HXR_UNEXPECTED;
  1103.     HX_ASSERT(m_pActualConn);
  1104.     if (m_pActualConn)
  1105.     {
  1106.         m_pMutex->Lock();
  1107.         theErr = m_pActualConn->reuse_port(enabled);
  1108.         m_pMutex->Unlock();
  1109.     }
  1110.     return theErr;
  1111. }
  1113. HX_RESULT
  1114. ThreadedConn::set_broadcast(BOOL enable)
  1115. {
  1116.         HX_RESULT theErr = HXR_UNEXPECTED;
  1117.         HX_ASSERT(m_pActualConn);
  1118.         if(m_pActualConn)
  1119.         {
  1120.         m_pMutex->Lock();
  1121.         theErr = m_pActualConn->set_broadcast(enable);
  1122.         m_pMutex->Unlock();
  1123.         }
  1124.         return theErr;
  1125. }
  1127. HX_RESULT
  1128. ThreadedConn::set_multicast_if(ULONG32 ulInterface)
  1129. {
  1130.     HX_RESULT theErr = HXR_UNEXPECTED;
  1131.     HX_ASSERT(m_pActualConn);
  1132.     if(m_pActualConn)
  1133.     {
  1134.         m_pMutex->Lock();
  1135.         theErr = m_pActualConn->set_multicast_if(ulInterface);
  1136.         m_pMutex->Unlock();
  1137.     }
  1138.     return theErr;
  1139. }
  1141. void
  1142. ThreadedConn::IgnoreWSAECONNRESET(BOOL b)
  1143. {
  1144.     HX_RESULT theErr = HXR_UNEXPECTED;
  1145.     HX_ASSERT(m_pActualConn);
  1146.     if(m_pActualConn)
  1147.     {
  1148.         m_pMutex->Lock();
  1149.         m_pActualConn->IgnoreWSAECONNRESET(b);
  1150.         m_pMutex->Unlock();
  1151.     }
  1152. }
  1154. HX_RESULT
  1155. ThreadedConn::last_error(void)
  1156. {
  1157.     HX_ASSERT(m_pActualConn);
  1158.     if (m_pActualConn)
  1159.     {
  1160.         m_pMutex->Lock();
  1161.         mLastError = m_pActualConn->last_error();
  1162.         m_pMutex->Unlock();
  1163.     }
  1165.     return mLastError;
  1166. }
  1168. void
  1169. ThreadedConn::set_callback(HXAsyncNetCallback* pCallback)
  1170. {
  1171.     m_pMutex->Lock();
  1172.     HX_ASSERT(m_pActualConn);
  1173.     if (m_pActualConn)
  1174.     {
  1175.         /* Set our callback as the callback */
  1176.         m_pActualConn->set_callback(m_pNetCallback);
  1177.     }
  1179.     mCallBack = pCallback;
  1180.     m_pMutex->Unlock();
  1181. }
  1184. UINT16
  1185. ThreadedConn::connection_open(void)
  1186. {
  1187.     UINT16 uConnOpen = 0;
  1188.     HX_ASSERT(m_pActualConn);
  1189.     if (m_pActualConn)
  1190.     {
  1191.         m_pMutex->Lock();
  1192.         uConnOpen = m_pActualConn->connection_open();
  1193.         m_pMutex->Unlock();
  1194.     }
  1196.     return uConnOpen;
  1197. }
  1199. UINT16
  1200. ThreadedConn::connection_really_open(void)
  1201. {
  1202.     UINT16 uConnOpen = 0;
  1203.     //HX_ASSERT(m_pActualConn);
  1204.     if (m_pActualConn)
  1205.     {
  1206.         m_pMutex->Lock();
  1207.         uConnOpen = m_pActualConn->connection_really_open();
  1208.         m_pMutex->Unlock();
  1209.     }
  1211.     return uConnOpen;
  1212. }
  1214. int
  1215. ThreadedConn::get_sock(void)
  1216. {
  1217.     int iSockNum = -1;
  1218.     HX_ASSERT(m_pActualConn);
  1219.     if (m_pActualConn)
  1220.     {
  1221.         m_pMutex->Lock();
  1222.         iSockNum =  m_pActualConn->get_sock();
  1223.         m_pMutex->Unlock();
  1224.     }
  1225.     return iSockNum;
  1226. }
  1228. void
  1229. ThreadedConn::set_sock(int theSock)
  1230. {
  1231.     m_pMutex->Lock();
  1232.     HX_ASSERT(m_pActualConn);
  1233.     if (m_pActualConn)
  1234.     {
  1235.         m_pActualConn->set_sock(theSock);
  1236.     }
  1238.     mSock = theSock;
  1239.     m_pMutex->Unlock();
  1240. }
  1242. BOOL
  1243. ThreadedConn::set_receive_buf_size(int DesiredSize)
  1244. {
  1245.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, SET_BUFFER_SIZE_CALLBACK_TYPE);
  1246.     pCallback->m_ulBufferSize = (UINT32) DesiredSize;
  1247.     /* Will be released by the thread engine */
  1248.     pCallback->AddRef();
  1249.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  1250.     m_pNetworkThread->PostMessage(&msg);
  1251.     return TRUE;
  1252. }
  1255. BOOL
  1256. ThreadedConn::ActualSetReceiveBufSize(UINT32 ulBufferSize)
  1257. {
  1258.     BOOL bResult = FALSE;
  1259.     HX_ASSERT(m_pActualConn);
  1260.     if (m_pActualConn)
  1261.     {
  1262.         m_pMutex->Lock();
  1263.         bResult = m_pActualConn->set_receive_buf_size((int) ulBufferSize);
  1264.         m_pMutex->Unlock();
  1265.     }
  1267.     return bResult;
  1268. }
  1270. void
  1271. ThreadedConn::OnAsyncDNS(BOOL bResult)
  1272. {
  1273.     if (mCallBack)
  1274.     {
  1275.         mCallBack->Func(DNS_NOTIFICATION, bResult);
  1276.     }
  1277. }
  1279. void
  1280. ThreadedConn::OnReadNotification(void)
  1281. {
  1282.     if (mCallBack)
  1283.     {
  1284.         mCallBack->Func(READ_NOTIFICATION);
  1285.     }
  1286. }
  1288. void
  1289. ThreadedConn::OnWriteNotification(void)
  1290. {
  1291.     if (mCallBack)
  1292.     {
  1293.         mCallBack->Func(WRITE_NOTIFICATION);
  1294.     }
  1295. }
  1297. void
  1298. ThreadedConn::OnConnect(BOOL bResult)
  1299. {
  1300.     if (mCallBack)
  1301.     {
  1302.         mCallBack->Func(CONNECT_NOTIFICATION, bResult);
  1303.     }
  1304. }
  1306. void
  1307. ThreadedConn::OnAcceptNotification()
  1308. {
  1309.     if( m_pIncommingConnections )
  1310.     {
  1311.         conn* pConn = (conn*)m_pIncommingConnections->RemoveHead();
  1312. // accept_notification is posted in win_net:checkforconnection
  1313. // callback->func(accept_notification..) calls this function
  1314. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1315.         if (mCallBack)
  1316.         {
  1317.             mCallBack->Func(ACCEPT_NOTIFICATION, TRUE, pConn);
  1318.         }
  1319.         if (pConn)
  1320.         {
  1321.             pConn->Release();
  1322.             pConn = NULL;
  1323.         }
  1324. #else
  1325. // at this point we need to set pengine->reader = pconn
  1326.         HXThreadMessage msg(HXMSG_ASYNC_SETREADER_CONNECTION, this, pConn);
  1327.         m_pNetworkThread->PostMessage(&msg);
  1328. #endif
  1330.     }
  1331. }
  1333. void
  1334. ThreadedConn::HandleDNSNotification(BOOL bSuccess)
  1335. {
  1336. #if !defined( WIN32_PLATFORM_PSPC ) && !defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1337.     HXThreadMessage msg(HXMSG_ASYNC_DNS, this, (void*) bSuccess);
  1338.     m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1339. #else
  1340.     OnAsyncDNS(bSuccess);
  1341. #endif
  1342. }
  1344. void
  1345. ThreadedConn::HandleConnectNotification(BOOL bSuccess)
  1346. {
  1347.     if (bSuccess)
  1348.     {
  1349.         m_bConnected = TRUE;
  1350.     }
  1352. #if !defined( WIN32_PLATFORM_PSPC ) && !defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1353.     HXThreadMessage msg(HXMSG_ASYNC_CONNECT, this, (void*) bSuccess);
  1354.     m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1355. #else // No notifier on CE
  1356.     OnConnect(bSuccess);
  1357. #endif
  1358. }
  1360. void
  1361. ThreadedConn::HandleAcceptNotification(conn* pConn)
  1362. {
  1363.     ThreadedConn* pTConn = (ThreadedConn*)conn::new_socket(HX_TCP_SOCKET);
  1364.     pTConn->SetActualConn(pConn, m_ulUserHandle);
  1365.     m_pIncommingConnections->AddHead((conn*)pTConn);
  1367. #if !defined( WIN32_PLATFORM_PSPC ) && !defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1368.     HXThreadMessage msg(HXMSG_ASYNC_ACCEPT, this, NULL);
  1369.     m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1370. #else // No notifier on CE
  1371.     OnAcceptNotification();
  1372. #endif
  1373. }
  1375. void
  1376. ThreadedConn::HandleCloseNotification()
  1377. {
  1378.     /* make one more read call to get back the actual error */
  1379.     m_bReadPostPendingWouldBlock = FALSE;
  1380. }
  1382. HX_RESULT
  1383. ThreadedConn::SetActualConn(conn* pConn, ULONG32 ulPlatform)
  1384. {
  1385.     if ( m_pActualConn )
  1386.     {
  1387.         m_pActualConn->done();
  1388.         m_pActualConn->Release();
  1389.     }
  1390.     m_pActualConn = pConn;
  1391.     m_pActualConn->AddRef();
  1392.     m_ulUserHandle = ulPlatform;
  1393.     m_bConnected = TRUE;
  1394.     return HXR_OK;
  1395. }
  1397. HX_RESULT
  1398. ThreadedConn::DoRead(BOOL bFromReadNotification)
  1399. {
  1400. #ifdef _CARBON
  1401.     AddRef(); // ensure that this object doesn't encounter its dtor before routine completes
  1402. #endif
  1403.     HX_RESULT theErr = HXR_OK;
  1404.     m_pMutex->Lock();
  1406.     /* Reset reading heuristing if we just got data. */
  1407.     if( bFromReadNotification )
  1408.     {
  1409.         m_bReadNowPending = m_bReadPostPendingWouldBlock = FALSE;
  1410.     }
  1412.     /* If the socket done has already been called, do not attempt to read
  1413.      * any more data
  1414.      */
  1415.     if (m_bIsDone)
  1416.     {
  1417.         goto exit;
  1418.     }
  1421.     if (m_uSocketType == HX_TCP_SOCKET)
  1422.     {
  1423.         UINT16 uCount = m_pReceiveTCP->GetMaxAvailableElements();
  1425.         if (uCount > 0)
  1426.         {
  1427.             UINT32 ulBytesToRead = conn::bytes_to_preparetcpread(this);
  1429.             if (ulBytesToRead > 0)
  1430.             {
  1431.                 if ((UINT32)uCount > ulBytesToRead)
  1432.                 {
  1433.                     uCount = (UINT16)ulBytesToRead;
  1434.                 }
  1436.                 if ( m_bReadPostPendingWouldBlock )
  1437.                 {
  1438.                     /* fake a call return */
  1439.                     theErr = HXR_WOULD_BLOCK;
  1440.                 }
  1441.                 else
  1442.                 {
  1443.                     /* call read and do heuristinc bookkeeping */
  1444.                     theErr = m_pActualConn->read(m_pTempBuffer, &uCount);
  1445. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1446.                     m_bReadPostPendingWouldBlock = (m_bReadNowPending && theErr == HXR_WOULD_BLOCK);
  1447. #endif
  1448.                     m_bReadNowPending = (theErr == HXR_WOULD_BLOCK ? TRUE : FALSE);
  1449.                 }
  1450.                 if (!theErr && uCount > 0)
  1451.                 {
  1452.                     conn::bytes_to_actualtcpread(this, uCount);
  1453.                     m_pReceiveTCP->EnQueue(m_pTempBuffer, uCount);
  1454.                 }
  1455.             }
  1456.         }
  1458. #ifndef _WINCE
  1459.         if (!m_bOutstandingReadNotification && m_pReceiveTCP->GetQueuedItemCount() > 0)
  1460.         {
  1461. #ifdef HELIX_FEATURE_NETWORK_USE_SELECT
  1462.             m_bOutstandingReadNotification  = TRUE;
  1463.             HXThreadMessage msg(HXMSG_ASYNC_READ, this, NULL);
  1464.             theErr = m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1465.     if ( theErr == HXR_NOT_INITIALIZED )
  1466.     {
  1467. theErr = HXR_OK;
  1468.     }
  1469. #endif
  1470.         }
  1471. #endif /* _WINCE */
  1472.     }
  1473.     else /*if (m_uSocketType == HX_UDP_SOCKET)*/
  1474.     {
  1475.         UINT32 ulAddress = 0;
  1476.         UINT16 ulPort = 0;
  1478.         /* Read as much UDP data as possible */
  1479.         while (!theErr)
  1480.         {
  1481.             IHXBuffer* pBuffer = NULL;
  1483.             if ( m_bReadPostPendingWouldBlock )
  1484.             {
  1485.                 /* fake a call return */
  1486.                 theErr = HXR_WOULD_BLOCK;
  1487.             }
  1488.             else
  1489.             {
  1490.                 /* call read and do heuristinc bookkeeping */
  1491.                 theErr = m_pActualConn->readfrom(pBuffer, ulAddress, ulPort);
  1492.                 if( theErr == HXR_OUTOFMEMORY )
  1493.                 {
  1494.                     mLastError = HXR_OUTOFMEMORY;
  1495.                 }
  1496.                 /* If this is a single WOULDBLOCK, ReadNowPending gets set.  If this is the second
  1497.                    consecutive blocking call, ReadPostPendingWouldBlock gets set.
  1498.                    Feel free to suggest better variable names. */
  1499. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1500.                 m_bReadPostPendingWouldBlock = (m_bReadNowPending && theErr == HXR_WOULD_BLOCK);
  1501. #endif
  1502.                 m_bReadNowPending = (theErr == HXR_WOULD_BLOCK ? TRUE : FALSE);
  1503.             }
  1505.             if (!theErr && pBuffer)
  1506.             {
  1507.                 UDP_PACKET* pPacket = new UDP_PACKET;
  1509.                 if(pPacket)
  1510.                 {
  1511.                     pPacket->pBuffer = pBuffer;
  1512.                     pPacket->ulAddress = ulAddress;
  1513.                     pPacket->ulPort = ulPort;
  1514.                     m_ReadUDPBuffers.AddTail((void*)pPacket);
  1515.                 }
  1516.                 else
  1517.                 {
  1518.                     theErr = HXR_OUTOFMEMORY;
  1519.                 }
  1520.             }
  1521.         }
  1524. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1525.         if ( !theErr && !m_bOutstandingReadNotification && m_ReadUDPBuffers.GetCount() > 0)
  1526.         {
  1527.             m_bOutstandingReadNotification  = TRUE;
  1528.             HXThreadMessage msg(HXMSG_ASYNC_READ, this, NULL);
  1529.             m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1530.         }
  1531. #endif
  1532.     }
  1535.     if (!mLastError && theErr)
  1536.     {
  1537.         mLastError = ConvertNetworkError(theErr);
  1538.     }
  1540.     /* If there is an error, issue a Read Available message
  1541.      * so that error can be reported back on next Read
  1542.      */
  1543.     if (!m_bOutstandingReadNotification && mLastError && theErr != HXR_OUTOFMEMORY)
  1544.     {
  1545.         m_bOutstandingReadNotification  = TRUE;
  1546.         HXThreadMessage msg(HXMSG_ASYNC_READ, this, NULL);
  1547. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1548.         m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1549. #else
  1550. m_pNetworkThread->PostMessage(&msg, m_pInternalWindowHandle);
  1551. #endif
  1552.     }
  1554. exit:
  1555.     m_pMutex->Unlock();
  1556. #ifdef _CARBON
  1557.     Release();
  1558. #endif
  1559.     return theErr;
  1560. }
  1562. void
  1563. ThreadedConn::DoWrite()
  1564. {
  1565.     // If we are out of memory, let's just get out of here. Ideally, we should
  1566.     // not ever get to this point, but lots of functions here have void return
  1567.     // types, so it is possible to lose an OOM error.
  1568.     if( mLastError == HXR_OUTOFMEMORY )
  1569.     {
  1570.         return;
  1571.     }
  1572. #ifdef _CARBON
  1573.     AddRef();
  1574. #endif
  1575.     HX_RESULT theErr = HXR_OK;
  1576.     m_pMutex->Lock();
  1577.     if (m_uSocketType == HX_TCP_SOCKET)
  1578.     {
  1579.         UINT16 uCount = m_pSendTCP->GetQueuedItemCount();
  1580.         if (uCount > 0)
  1581.         {
  1582.             m_pSendTCP->DeQueue(m_pTempBuffer, uCount);
  1583.             UINT16 uActualCount = uCount;
  1584.             theErr = m_pActualConn->write(m_pTempBuffer, &uActualCount);
  1585.             switch(theErr)
  1586.             {
  1587.                 case HXR_AT_INTERRUPT:
  1588.                 case HXR_WOULD_BLOCK:
  1589.                 case HXR_OK:
  1590.                     // enqueue the data that was not sent
  1591.                     if(uActualCount != uCount)
  1592.                     {
  1593.                         m_pSendTCP->EnQueue(m_pTempBuffer + uActualCount,
  1594.                                             uCount - uActualCount);
  1595.                     }
  1597.                     // mask out these errors
  1598.                     theErr = HXR_OK;
  1599.                     break;
  1601.                 default:
  1602.                     break;
  1603.             }
  1604.         }
  1606. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1607.         if (!m_bIsDone && !m_bOutstandingWriteNotification && m_pSendTCP->GetMaxAvailableElements() > 0)
  1608.         {
  1609.             m_bOutstandingWriteNotification = TRUE;
  1610.             HXThreadMessage msg(HXMSG_ASYNC_WRITE, this, NULL);
  1611.             m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1612.         }
  1613. #endif
  1614.     }
  1615.     else /*if (m_uSocketType == HX_UDP_SOCKET)*/
  1616.     {
  1617.         while (!theErr && m_WriteUDPBuffers.GetCount() > 0)
  1618.         {
  1619.             UDPPacketInfo* pPacket = (UDPPacketInfo*) m_WriteUDPBuffers.GetHead();
  1620.             UINT16 uLength = (UINT16) pPacket->m_pBuffer->GetSize();
  1621.             theErr = m_pActualConn->writeto(pPacket->m_pBuffer->GetBuffer(),   // sendto
  1622.                                         &uLength,
  1623.                                         pPacket->m_ulAddr,
  1624.                                         pPacket->m_uPort);
  1625.             if (!theErr)
  1626.             {
  1627.                 pPacket->m_pBuffer->Release();
  1628.                 delete pPacket;
  1629.                 m_WriteUDPBuffers.RemoveHead();
  1630.             }
  1631.         }
  1633. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1634.         if (!m_bIsDone && !m_bOutstandingWriteNotification && m_WriteUDPBuffers.GetCount() == 0)
  1635.         {
  1636.             m_bOutstandingWriteNotification = TRUE;
  1637.             HXThreadMessage msg(HXMSG_ASYNC_WRITE, this, NULL);
  1638.             m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1639.         }
  1640. #endif
  1641.     }
  1643.     if (!mLastError && theErr)
  1644.     {
  1645.         mLastError = ConvertNetworkError(theErr);
  1646.     }
  1648. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1649.     if (!mLastError && !m_bNetworkIOPending &&
  1650.         ((m_uSocketType == HX_TCP_SOCKET && m_pSendTCP->GetQueuedItemCount() > 0) ||
  1651.          (m_uSocketType == HX_UDP_SOCKET && m_WriteUDPBuffers.GetCount() > 0)))
  1652.     {
  1653.         theErr = PostIOMessage();
  1654.     }
  1655. #endif
  1657.     m_pMutex->Unlock();
  1659.     if (m_bWriteFlushPending &&
  1660.         ((m_uSocketType == HX_TCP_SOCKET && m_pSendTCP->GetQueuedItemCount() == 0) ||
  1661.          (m_uSocketType == HX_UDP_SOCKET && m_WriteUDPBuffers.GetCount() == 0)))
  1662.     {
  1663.         m_bWriteFlushPending    = FALSE;
  1664.         Release();
  1665.     }
  1667.     /* We are done and there is no more data pending to bw written out */
  1668.     /* This is the time socket actually gets destroyed */
  1669.     if (m_bIsDone && !m_bWriteFlushPending)
  1670.     {
  1671.         m_bConnected = FALSE;
  1672.         PostDoneAndDetach();
  1673.     }
  1674. #ifdef _CARBON
  1675.     Release();
  1676. #endif
  1677. }
  1679. //--------------------------------------------------
  1680. void
  1681. ThreadedConn::DoNetworkIO(void)
  1682. {
  1683.     m_bNetworkIOPending = FALSE;
  1684.     if (m_bConnected)
  1685.     {
  1686.         // DoRead now has a return type, but since DoNetworkIO does not we
  1687.         // are going to ignore any errors returned. This may not be a good idea.
  1688. #if !defined( WIN32_PLATFORM_PSPC ) /*&& !defined( _UNIX )*/
  1689. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1690. if (!m_pNetworkThread->m_bUseReaderWriter)
  1691. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1692.         DoRead();
  1693.         DoWrite();
  1694. #else
  1695. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1696. if (!m_pNetworkThread->m_bUseReaderWriter)
  1697. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1698.         DoRead(TRUE);
  1699.         DoWrite();
  1700. #endif
  1701.     }
  1702. }
  1703. HX_RESULT
  1704. ThreadedConn::ConvertNetworkError(HX_RESULT theErr)
  1705. {
  1706.     HX_RESULT lResult = theErr;
  1707.     if (!IS_SERVER_ALERT(theErr))
  1708.     {
  1709.         switch(theErr)
  1710.         {
  1711.             case HXR_AT_INTERRUPT:                      // mask out these errors
  1712.             case HXR_WOULD_BLOCK:
  1713.             case HXR_NO_DATA:
  1714.             case HXR_OK:
  1715.                 lResult = HXR_OK;
  1716.                 break;
  1718.             case HXR_DNR:
  1719.             case HXR_NET_CONNECT:
  1720.             case HXR_DOC_MISSING:
  1721.             case HXR_OUTOFMEMORY:
  1722.             case HXR_ADVANCED_SERVER:
  1723.             case HXR_BAD_SERVER:
  1724.             case HXR_OLD_SERVER:
  1725.             case HXR_INVALID_FILE:
  1726.             case HXR_REDIRECTION:
  1727.             case HXR_PROXY:
  1728.             case HXR_PROXY_RESPONSE:
  1729.             case HXR_ADVANCED_PROXY:
  1730.             case HXR_OLD_PROXY:
  1731.             case HXR_PERFECTPLAY_NOT_SUPPORTED:
  1732.             case HXR_NO_LIVE_PERFECTPLAY:
  1733.             case HXR_PERFECTPLAY_NOT_ALLOWED:
  1734.                 break;
  1736.             default:
  1737.                 lResult = HXR_FAIL;
  1738.                 break;
  1739.         }
  1740.     }
  1742.     return lResult;
  1743. }
  1745. HX_RESULT
  1746. ThreadedConn::PostIOMessage(void)
  1747. {
  1748.     m_bNetworkIOPending = TRUE;
  1749.     HXThreadMessage msg(HXMSG_ASYNC_NETWORKIO, this, NULL);
  1750.     return m_pNetworkThread->PostMessage(&msg);
  1751. }
  1754. HX_RESULT ThreadedConn::ThrConnSocketCallback::Func(NotificationType Type,
  1755.                                                BOOL bSuccess, conn* pConn)
  1756. {
  1757.     ThreadedConn* pContext = m_pContext;
  1758.     // It would be nice to set theErr for all of the calls below, but the
  1759.     // effects of that are unknown to this developer. XXXJHHB
  1760.     HX_RESULT theErr = HXR_OK;
  1761.     if(pContext)
  1762.     {
  1763.         switch (Type)
  1764.         {
  1765.         case READ_NOTIFICATION:
  1766.             theErr = pContext->DoRead(TRUE);
  1767.             break;
  1768.         case WRITE_NOTIFICATION:
  1769.             pContext->DoWrite();
  1770.             break;
  1771.         case CONNECT_NOTIFICATION:
  1772.             pContext->HandleConnectNotification(bSuccess);
  1773.             break;
  1774.         case DNS_NOTIFICATION:
  1775.             pContext->HandleDNSNotification(bSuccess);
  1776.             break;
  1777.         case ACCEPT_NOTIFICATION:
  1778.             pContext->HandleAcceptNotification(pConn);
  1779. #ifdef HELIX_FEATURE_NETWORK_USE_SELECT
  1780.             break;
  1781. #endif
  1782.         case CLOSE_NOTIFICATION:
  1783.             pContext->HandleCloseNotification();
  1784.             break;
  1785. #ifdef HELIX_FEATURE_NETWORK_USE_SELECT
  1786.         case SEND_BUFFER_NOTIFICATION:
  1787.     UINT16 len;
  1788.     len = sizeof(HXThreadMessage);
  1789.     pContext->m_bNetworkIOPending = TRUE;
  1790.             pContext->write((char *)bSuccess,&len);
  1791.             pContext->DoWrite();
  1792.     pContext->m_bNetworkIOPending = FALSE;
  1793.             break;
  1794. #endif
  1795.         default:
  1796.             break;
  1797.         }
  1798.     }
  1800.     return theErr;
  1801. }
  1805. ThreadedConn::ThrdConnGenericCallback::ThrdConnGenericCallback(ThreadedConn* pConn, UINT16 uCallbackType)
  1806.     : m_lRefCount (0)
  1807.     , m_uCallbackType (uCallbackType)
  1808.     , m_pConn (pConn)
  1809.     , m_bBlocking (FALSE)
  1810.     , m_ulLocalAddr (0)
  1811.     , m_uPort (0)
  1812.     , m_ulBufferSize (0)
  1813.     , m_uBacklog(0)
  1814. //    , m_pNewConn(NULL)
  1815. {
  1816. }
  1818. ThreadedConn::ThrdConnGenericCallback::~ThrdConnGenericCallback()
  1819. {
  1820. //    HX_RELEASE(m_pNewConn);
  1821. }
  1823. /*
  1824.  * IUnknown methods
  1825.  */
  1827. /////////////////////////////////////////////////////////////////////////
  1828. //      Method:
  1829. //              IUnknown::QueryInterface
  1830. //      Purpose:
  1831. //              Implement this to export the interfaces supported by your
  1832. //              object.
  1833. //
  1834. STDMETHODIMP ThreadedConn::ThrdConnGenericCallback::QueryInterface(REFIID riid, void** ppvObj)
  1835. {
  1836.     if (IsEqualIID(riid, IID_IUnknown))
  1837.     {
  1838.         AddRef();
  1839.         *ppvObj = this;
  1840.         return HXR_OK;
  1841.     }
  1842.     else if (IsEqualIID(riid, IID_IHXCallback))
  1843.     {
  1844.         AddRef();
  1845.         *ppvObj = (IHXCallback*)this;
  1846.         return HXR_OK;
  1847.     }
  1849.     *ppvObj = NULL;
  1850.     return HXR_NOINTERFACE;
  1851. }
  1853. /////////////////////////////////////////////////////////////////////////
  1854. //      Method:
  1855. //              IUnknown::AddRef
  1856. //      Purpose:
  1857. //              Everyone usually implements this the same... feel free to use
  1858. //              this implementation.
  1859. //
  1860. STDMETHODIMP_(ULONG32) ThreadedConn::ThrdConnGenericCallback::AddRef()
  1861. {
  1862.     return InterlockedIncrement(&m_lRefCount);
  1863. }
  1865. /////////////////////////////////////////////////////////////////////////
  1866. //      Method:
  1867. //              IUnknown::Release
  1868. //      Purpose:
  1869. //              Everyone usually implements this the same... feel free to use
  1870. //              this implementation.
  1871. //
  1872. STDMETHODIMP_(ULONG32) ThreadedConn::ThrdConnGenericCallback::Release()
  1873. {
  1874.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1875.     {
  1876.         return m_lRefCount;
  1877.     }
  1879.     delete this;
  1880.     return 0;
  1881. }
  1883. /*
  1884.  *      IHXCallback methods
  1885.  */
  1886. STDMETHODIMP ThreadedConn::ThrdConnGenericCallback::Func(void)
  1887. {
  1888.     if (m_pConn)
  1889.     {
  1890.         switch (m_uCallbackType)
  1891.         {
  1892.             case DNS_CALLBACK_TYPE:
  1893.                 m_pConn->ActualDnsFindIpAddr(m_HostName, m_bBlocking);
  1894.                 break;
  1895.             case INIT_CALLBACK_TYPE:
  1896.                 m_pConn->ActualInit(m_ulLocalAddr, m_uPort, m_bBlocking);
  1897.                 break;
  1898.             case SETWINDOWHANDLE_CALLBACK_TYPE:
  1899. #if defined (_WIN32) || defined (_WINDOWS)
  1900.                 m_pConn->ActuallSetWindowHandle(m_ulHandle);
  1901. #endif /*defined (_WIN32) || defined (_WINDOWS)*/
  1902.                 break;
  1903.             case CONNECT_CALLBACK_TYPE:
  1904.                 m_pConn->ActualConnect(m_HostName, m_uPort, m_bBlocking,
  1905.                                         m_ulHandle);
  1906.                 break;
  1907. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1908.             case ACCEPT_CALLBACK_TYPE:
  1909.                 m_pConn->ActualAccept(m_ulLocalAddr,
  1910.                                         m_ulHandle);
  1911.                 break;
  1912. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1913.             case BLOCKING_CALLBACK_TYPE:
  1914.                 m_pConn->ActualBlocking();
  1915.                 break;
  1916.             case NONBLOCKING_CALLBACK_TYPE:
  1917.                 m_pConn->ActualNonBlocking();
  1918.                 break;
  1919.             case DONE_CALLBACK_TYPE:
  1920.                 m_pConn->ActualDone();
  1921.                 break;
  1922.             case SET_BUFFER_SIZE_CALLBACK_TYPE:
  1923.                 m_pConn->ActualSetReceiveBufSize(m_ulBufferSize);
  1924.                 break;
  1925.             case LISTEN_CALLBACK_TYPE:
  1926.                 m_pConn->ActualListen(m_ulLocalAddr, m_uPort, m_uBacklog,
  1927.                                 m_bBlocking, m_ulHandle);
  1928.                 break;
  1929.             default:
  1930.                 break;
  1931.         }
  1932.     }
  1933.     return HXR_OK;
  1934. }