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

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

Symbian

开发平台：

Visual C++

thrdconn.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: thrdconn.cpp,v 1.11.2.4 2004/07/09 01:47:02 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hlxclib/time.h"
  51. #include <stdio.h>
  52. #include <string.h>
  53. #include "hxcom.h"
  54. #include "conn.h"
  56. #if defined (_WIN32) || defined (WIN32)
  57. #include "platform/win/win_net.h"
  58. #include "platform/win/casynthr.h"
  59. #endif
  61. #if defined(_UNIX) && (defined( _UNIX_THREADED_NETWORK_IO ) || defined(THREADS_SUPPORTED))
  62. #include "platform/unix/UnixThreads.h"
  63. #endif /* _UNIX_THREADED_NETWORK_IO */
  65. #ifdef _CARBON
  66. #include "carbthrd.h"
  67. #endif
  70. #include "hxslist.h"
  71. #include "growingq.h"
  73. #include "hxengin.h"
  74. #include "ihxpckts.h"
  75. #include "hxbuffer.h"
  76. #include "timebuff.h"
  77. #include "hxtick.h"
  78. #include "hxthread.h"
  79. #include "threngin.h"
  80. #include "conn.h"
  81. #include "thrdconn.h"
  82. #include "hxheap.h"
  83. #ifdef _DEBUG
  84. #undef HX_THIS_FILE
  85. static const char HX_THIS_FILE[] = __FILE__;
  86. #endif
  88. #define QUEUE_START_SIZE    512
  90. ThreadedConn*
  91. ThreadedConn::new_socket(UINT16 type)
  92. {
  93.     return new ThreadedConn(type);
  94. }
  96. #ifdef THREADS_SUPPORTED
  97. #ifdef HELIX_FEATURE_ADD_NETWORK_THREAD_SLEEP
  98. #define DEFAULT_NETWORK_THREAD_SLEEP 50
  99. #endif //HELIX_FEATURE_ADD_NETWORK_THREAD_SLEEP
  100. #endif //THREADS_SUPPORTED
  102. /*
  103. HXThread*
  104. ThreadedConn::GetNetworkThread(void)
  105. {
  106. #if defined (_WIN32)
  107.     return win_net::GetNetworkThread();
  108. #else
  109.     HX_ASSERT(FALSE);
  110.     return HXR_UNEXXPECTED;
  111. #endif
  112. }
  114. void
  115. ThreadedConn::DestroyNetworkThread(void)
  116. {
  117. #if defined (_WIN32)
  118.     win_net::DestroyNetworkThread();
  119. #else
  120.     HX_ASSERT(FALSE);
  121.     return P NR_UNEXXPECTED;
  122. #endif
  123. }
  124. */
  126. ThreadedConn::ThreadedConn(UINT16 type)
  127.     : m_lRefCount(0)
  128.     , m_pActualConn(NULL)
  129.     , m_uSocketType(type)
  130.     , m_pNetworkThread(NULL)
  131.     , m_pMainAppThread(NULL)
  132.     , m_pNetCallback(0)
  133.     , m_pSendTCP (0)
  134.     , m_pReceiveTCP (0)
  135.     , m_pTempBuffer (0)
  136.     , m_ulUserHandle(0)
  137.     , m_pInternalWindowHandle(NULL)
  138.     , m_bConnected(FALSE)
  139.     , m_bIsDone(FALSE)
  140.     , m_bDetachPending(TRUE)
  141.     , m_pInitEvent(0)
  142.     , m_pQuitEvent(0)
  143.     , m_pListenEvent(NULL)
  144.     , m_pDetachEvent(0)
  145.     , m_bInitialized(FALSE)
  146.     , m_bOutstandingReadNotification(FALSE)
  147.     , m_bOutstandingWriteNotification(FALSE)
  148.     , m_bWriteFlushPending(FALSE)
  149.     , m_bNetworkIOPending(FALSE)
  150.     , m_bReadNowPending(FALSE)
  151.     , m_bReadPostPendingWouldBlock(FALSE)
  152.     , m_pIncommingConnections(NULL)
  153.     , m_bIgnoreWSAECONNRESET(FALSE)
  154. #if defined (_WIN32) || defined (WIN32)
  155.     , m_pNotifier(NULL)
  156. #endif
  157. #ifdef THREADS_SUPPORTED
  158. #ifdef HELIX_FEATURE_ADD_NETWORK_THREAD_SLEEP
  159.     , m_ulNetworkThreadSleep(DEFAULT_NETWORK_THREAD_SLEEP)
  160. #endif //HELIX_FEATURE_ADD_NETWORK_THREAD_SLEEP
  161. #endif //THREADS_SUPPORTED
  162. {
  163.     m_pActualConn = conn::actual_new_socket(type);
  164.     m_pActualConn->AddRef();
  165.     conn::add_connection_to_list (m_pActualConn);
  167.     ThreadEngine* pEngine = ThreadEngine::GetThreadEngine();
  168.     // NOTE: pEngine allocation is not checked for success.
  169.     pEngine->AttachSocket(this);
  170.     m_pNetworkThread    = pEngine->GetNetworkThread();
  171.     m_pMainAppThread    = pEngine->GetMainAppThread();
  172.     m_pNetCallback      = new ThrConnSocketCallback(this);
  174. #if defined(THREADS_SUPPORTED) || defined(_UNIX_THREADED_NETWORK_IO)
  175.     HXMutex::MakeMutex(m_pMutex);
  176.     HXEvent::MakeEvent(m_pInitEvent, NULL, FALSE);
  177.     HXEvent::MakeEvent(m_pQuitEvent, NULL);
  178.     HXEvent::MakeEvent(m_pDetachEvent, NULL);
  179.     HXEvent::MakeEvent(m_pListenEvent, NULL, FALSE);
  180. #else
  181.     HXMutex::MakeStubMutex(m_pMutex);
  182.     HXEvent::MakeStubEvent(m_pInitEvent, NULL, FALSE);
  183.     HXEvent::MakeStubEvent(m_pQuitEvent, NULL);
  184.     HXEvent::MakeStubEvent(m_pDetachEvent, NULL);
  185.     HXEvent::MakeStubEvent(m_pListenEvent, NULL, FALSE);
  186. #endif
  188.     m_pTempBuffer = new char[TCP_BUF_SIZE];
  190.     /* Allocate byte queues ONLY if it is a TCP socket */
  191.     if (m_uSocketType == HX_TCP_SOCKET)
  192.     {
  193.         // allocate TCP send and receive queue
  194.         m_pSendTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  195.         if (!m_pSendTCP || !m_pSendTCP->IsQueueValid())
  196.         {
  197.             mLastError = HXR_OUTOFMEMORY;
  198.         }
  199.         m_pSendTCP->SetMaxSize(TCP_BUF_SIZE);
  201.         m_pReceiveTCP = new CByteGrowingQueue(QUEUE_START_SIZE,1);
  202.         if (!m_pReceiveTCP || !m_pReceiveTCP->IsQueueValid())
  203.         {
  204.             mLastError = HXR_OUTOFMEMORY;
  205.         }
  206.         m_pReceiveTCP->SetMaxSize(TCP_BUF_SIZE);
  207.     }
  208. }
  210. ThreadedConn::~ThreadedConn()
  211. {
  212.     if (m_pNetCallback)
  213.     {
  214.         m_pNetCallback->m_pContext = 0;
  215.     }
  217.     if (m_pActualConn)
  218.     {
  219.         m_pActualConn->done();
  220.         m_pActualConn->Release();
  221.         m_pActualConn = 0;
  222.     }
  224.     HX_DELETE(m_pNetCallback);
  225.     HX_VECTOR_DELETE(m_pTempBuffer);
  226.     HX_DELETE(m_pSendTCP);
  227.     HX_DELETE(m_pReceiveTCP);
  229.     while (m_WriteUDPBuffers.GetCount() > 0)
  230.     {
  231.         UDPPacketInfo* pPacket = (UDPPacketInfo*) m_WriteUDPBuffers.RemoveHead();
  232.         pPacket->m_pBuffer->Release();
  233.         delete pPacket;
  234.     }
  236.     while (m_ReadUDPBuffers.GetCount() > 0)
  237.     {
  238.         UDP_PACKET* pPacket = (UDP_PACKET*) m_ReadUDPBuffers.RemoveHead();
  239.         HX_RELEASE(pPacket->pBuffer);
  240.         HX_DELETE(pPacket);
  241.     }
  243.     HX_DELETE(m_pMutex);
  244.     HX_DELETE(m_pInitEvent);
  245.     HX_DELETE(m_pQuitEvent);
  246.     HX_DELETE(m_pDetachEvent);
  247.     HX_DELETE(m_pListenEvent);
  248.     HX_DELETE(m_pIncommingConnections);
  250.     mCallBack = NULL;
  251. #ifdef _UNIX_THREADED_NETWORK_IO
  252.     if( m_bNetworkThreading )
  253.     {
  254.         //Remove any messages from the main app thread for us.
  255.         HX_ASSERT( m_pMainAppThread );
  256.         HXThreadMessage msgBack;
  257.         HXThreadMessage msgMatch(0, (void*)this, NULL, NULL);
  258.         while(((HXUnixThread*)m_pMainAppThread)->PeekMessageMatching(&msgBack, &msgMatch, TRUE )==HXR_OK)
  259.         {
  260.         }
  261.     }
  262.     m_pMainAppThread=NULL;
  263. #elif defined(_CARBON) && defined(THREADS_SUPPORTED)
  264.     // remove any messages from the main app thread for us.
  265.     HX_ASSERT(m_pMainAppThread);
  266.     HXThreadMessage msgBack;
  267.     HXThreadMessage msgMatch(0, (void*)this, NULL, NULL);
  268.     while (((HXCarbonThread*)m_pMainAppThread)->PeekMessageMatching(&msgBack, &msgMatch, TRUE) == HXR_OK)
  269.     {
  270.     }
  271.     m_pMainAppThread = NULL;
  272. #endif
  273. }
  275. ULONG32 ThreadedConn::AddRef()
  276. {
  277.     return InterlockedIncrement(&m_lRefCount);
  278. }
  280. ULONG32 ThreadedConn::Release()
  281. {
  282.     if (InterlockedDecrement(&m_lRefCount) > 0)
  283.     {
  284.         return m_lRefCount;
  285.     }
  287.     delete this;
  288.     return 0;
  289. }
  291. HX_RESULT
  292. ThreadedConn::dns_find_ip_addr(const char* host, UINT16 blocking)
  293. {
  294.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, DNS_CALLBACK_TYPE);
  295.     pCallback->m_HostName   = host;
  296.     pCallback->m_bBlocking  = (BOOL) blocking;
  297.     /* Will be released by the thread engine */
  298.     pCallback->AddRef();
  299.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  300.     return m_pNetworkThread->PostMessage(&msg);
  301. }
  304. HX_RESULT
  305. ThreadedConn::ActualDnsFindIpAddr(const char* host, UINT16 blocking)
  306. {
  307.     HX_RESULT theErr = HXR_UNEXPECTED;
  308.     HX_ASSERT(m_pActualConn);
  309.     if (m_pActualConn)
  310.     {
  311.         m_pMutex->Lock();
  312.         theErr = m_pActualConn->dns_find_ip_addr(host, blocking);
  313.         m_pMutex->Unlock();
  314.     }
  316.     return theErr;
  317. }
  319. BOOL
  320. ThreadedConn::dns_ip_addr_found(BOOL* valid, ULONG32* addr)
  321. {
  323.     BOOL bResult = FALSE;
  324.     HX_ASSERT(m_pActualConn);
  325.     if (m_pActualConn)
  326.     {
  327.         m_pMutex->Lock();
  328.         bResult = m_pActualConn->dns_ip_addr_found(valid, addr);
  329.         m_pMutex->Unlock();
  330.     }
  332.     return bResult;
  333. }
  335. void
  336. ThreadedConn::finaldone (void)
  337. {
  338.     if (!m_bIsDone)
  339.     {
  340.         done();
  341.     }
  343.     /* final attempt to cleanup */
  344.     PostDoneAndDetach();
  346.     if (m_pQuitEvent)
  347.     {
  348.         m_pQuitEvent->Wait(ALLFS);
  349.     }
  351.     if (m_pDetachEvent)
  352.     {
  353.         m_pDetachEvent->Wait(ALLFS);
  354.     }
  355. }
  357. void
  358. ThreadedConn::Detached (void)
  359. {
  360.     if (m_pDetachEvent)
  361.     {
  362.         m_pDetachEvent->SignalEvent();
  363.     }
  364. }
  366. void
  367. ThreadedConn::done (void)
  368. {
  369.     /* Do not pass any more callbacks to the client above */
  370.     mCallBack   = NULL;
  371.     m_bIsDone   = TRUE;
  372.     /* Actual message to release the socket will be posted in DoWrite() */
  374. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  375.     if (!m_pNotifier)
  376.     {
  377.         m_pNotifier =
  378.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)m_ulUserHandle,
  379.                                                         FALSE);
  380.     }
  381.     if (m_pNotifier)
  382.     {
  383.         m_pNotifier->DetachSocket(this);
  384.         m_pNotifier = NULL;
  385.     }
  386. #endif /*defined (_WINDOWS) || defined (_WIN32)*/
  388.     if (!m_bConnected)
  389.     {
  390.         PostDoneAndDetach();
  391.     }
  392. }
  394. void
  395. ThreadedConn::PostDoneAndDetach()
  396. {
  397.     // If we are out of memory, let's just get out of here. Ideally, we should
  398.     // not ever get to this point, but lots of functions here have void return
  399.     // types, so it is possible.
  400.     if( mLastError == HXR_OUTOFMEMORY )
  401.     {
  402.         return;
  403.     }
  405.     m_pMutex->Lock();
  407.     if (m_bDetachPending)
  408.     {
  409.         m_bDetachPending = FALSE;
  410.         ThrdConnGenericCallback* pCallback      = new ThrdConnGenericCallback(this, DONE_CALLBACK_TYPE);
  411.         /* Will be released by the thread engine */
  412.         pCallback->AddRef();
  413.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  414.         m_pNetworkThread->PostMessage(&msg);
  415.         HXThreadMessage msg1(HXMSG_ASYNC_DETACH, this, NULL);
  416.         m_pNetworkThread->PostMessage(&msg1);
  417.     }
  419.     m_pMutex->Unlock();
  420. }
  422. void
  423. ThreadedConn::ActualDone (void)
  424. {
  425.     HX_ASSERT(m_pActualConn);
  426.     if (m_pActualConn)
  427.     {
  428.         m_pMutex->Lock();
  429.         m_bConnected = FALSE;
  430.         m_pActualConn->done();
  431.         m_pActualConn->Release();
  432.         m_pActualConn = 0;
  433.         m_pMutex->Unlock();
  434.     }
  436.     if (m_pQuitEvent)
  437.     {
  438.         m_pQuitEvent->SignalEvent();
  439.     }
  440. }
  442. HX_RESULT
  443. ThreadedConn::init  (UINT32 local_addr,UINT16 port, UINT16 blocking)
  444. {
  445.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, INIT_CALLBACK_TYPE);
  446.     pCallback->m_ulLocalAddr    = local_addr;
  447.     pCallback->m_uPort          = port;
  448.     pCallback->m_bBlocking      = (BOOL) blocking;
  449.     /* Will be released by the thread engine */
  450.     pCallback->AddRef();
  452.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  453.     m_pNetworkThread->PostMessage(&msg);
  455.     /* Wait for the actual Initialization to complete. This is the only
  456.        function we wait for the networking thread to complete before passing
  457.        the result to the user since there is no async interface to pass the result
  458.        back and it very much possible that socket binding may fail during
  459.        initialization
  460.      */
  461.     m_pInitEvent->Wait();
  463.     if (m_bInitialized)
  464.     {
  465.         return HXR_OK;
  466.     }
  467.     else
  468.     {
  469.         return HXR_FAIL;
  470.     }
  471. }
  473. HX_RESULT
  474. ThreadedConn::ActualInit(UINT32 local_addr,UINT16 port, UINT16 blocking)
  475. {
  476.     HX_RESULT theErr = HXR_UNEXPECTED;
  477.     HX_ASSERT(m_pActualConn);
  478.     if (m_pActualConn)
  479.     {
  480.         m_pMutex->Lock();
  481.         theErr = m_pActualConn->init(local_addr, port, blocking);
  482.         if (!theErr && m_uSocketType == HX_UDP_SOCKET)
  483.         {
  484.             m_bConnected = TRUE;
  485.         }
  487.         if (!theErr)
  488.         {
  489.             m_bInitialized = TRUE;
  490.         }
  492.         /* Signal the main thread that intialization is complete */
  493.         m_pInitEvent->SignalEvent();
  494.         m_pMutex->Unlock();
  495.     }
  497.     return theErr;
  498. }
  500. HX_RESULT
  501. ThreadedConn::listen(ULONG32 ulAddr,  UINT16 port, UINT16 backlog,
  502.                      UINT16 blocking, ULONG32 ulPlatform)
  503. {
  504.     HX_RESULT theErr = HXR_OK;
  506. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  507.     m_ulUserHandle  = ulPlatform;
  509.     if (!m_pNotifier)
  510.     {
  511.         m_pNotifier =
  512.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)ulPlatform,
  513.                                                         TRUE);
  514.     }
  515.     if (m_pNotifier)
  516.     {
  517.         m_pInternalWindowHandle = (void*) m_pNotifier->GetWindowHandle();
  518.         m_pNotifier->AttachSocket(this);
  519.     }
  520.     else
  521.     {
  522.         theErr = HXR_OUTOFMEMORY;
  523.     }
  524. #endif /*defined (_WIN32) || defined (WIN32)*/
  526.     HX_DELETE(m_pIncommingConnections);
  527.     m_pIncommingConnections = new CHXSimpleList();
  529.     if (!theErr)
  530.     {
  531.         ThrdConnGenericCallback* pCallback      =
  532.                 new ThrdConnGenericCallback(this, LISTEN_CALLBACK_TYPE);
  533.         pCallback->m_ulLocalAddr = ulAddr;
  534.         pCallback->m_uPort      = port;
  535.         pCallback->m_uBacklog   = backlog;
  536.         pCallback->m_bBlocking  = (BOOL) blocking;
  537.         pCallback->m_ulHandle   = ulPlatform;
  538.         /* Will be released by the thread engine */
  539.         pCallback->AddRef();
  540.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  541.         theErr = m_pNetworkThread->PostMessage(&msg);
  543.         if ( SUCCEEDED(theErr) )
  544.         {
  545.             /*
  546.              * Wait for the actual Listen to complete.
  547.              */
  548.     // listen is called from the network thread, so this will wait forever
  549. #ifdef HELIX_FEATURE_NETWORK_USE_SELECT
  550.     m_bListenning = TRUE;
  551. #else
  552.             m_pListenEvent->Wait();
  553. #endif
  555.             if ( m_bListenning )
  556.             {
  557.                 theErr = HXR_OK;
  558.             }
  559.             else
  560.             {
  561.                 theErr = HXR_FAIL;
  562.             }
  563.         }
  564.     }
  565. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  566.     set_callback(m_pNetCallback); // for accept msg
  567. #endif //HELIX_FEATURE_NETWORK_USE_SELECT
  568.     return theErr;
  569. }
  571. HX_RESULT
  572. ThreadedConn::ActualListen( ULONG32     ulAddr,
  573.                             UINT16      port,
  574.                             UINT16      backlog,
  575.                             UINT16      blocking,
  576.                             ULONG32     ulPlatform)
  577. {
  578.     HX_RESULT err = HXR_UNEXPECTED;
  579.     HX_ASSERT(m_pActualConn);
  580.     if ( m_pActualConn )
  581.     {
  582.         m_pMutex->Lock();
  583.         err = m_pActualConn->listen(ulAddr, port, backlog, blocking, ulPlatform);
  585.         if ( SUCCEEDED(err) )
  586.         {
  587.             m_bListenning = TRUE;
  588.         }
  589.         else
  590.         {
  591.             m_bListenning = FALSE;
  592.         }
  594.         m_pListenEvent->SignalEvent();
  595.         m_pMutex->Unlock();
  596.     }
  597.     return err;
  598. }
  600. #if     defined (_WINDOWS) || defined (_WIN32)
  601. // we need it for dns_find_ip_addr since async stuff needs a window handle...
  602. HX_RESULT
  603. ThreadedConn::SetWindowHandle(ULONG32 handle)
  604. {
  605.     HX_RESULT theErr = HXR_OK;
  607.     m_pMutex->Lock();
  608.     m_ulUserHandle  = handle;
  609. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  610.     if (!m_pNotifier)
  611.     {
  612.         m_pNotifier =
  613.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)handle,
  614.                                                         TRUE);
  615.     }
  616.     if (m_pNotifier)
  617.     {
  618.         m_pInternalWindowHandle = (void*)m_pNotifier->GetWindowHandle();
  619.         m_pNotifier->AttachSocket(this);
  620.     }
  621.     else
  622.     {
  623.         theErr = HXR_OUTOFMEMORY;
  624.     }
  625. #endif /*defined (_WIN32) || defined (WIN32)*/
  627.     if (!theErr)
  628.     {
  629.         ThrdConnGenericCallback* pCallback      =
  630.                 new ThrdConnGenericCallback(this, SETWINDOWHANDLE_CALLBACK_TYPE);
  631.         pCallback->m_ulHandle   = handle;
  632.         /* Will be released by the thread engine */
  633.         pCallback->AddRef();
  634.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  635.         theErr = m_pNetworkThread->PostMessage(&msg);
  636.     }
  638.     m_pMutex->Unlock();
  640.     return theErr;
  641. }
  644. HX_RESULT
  645. ThreadedConn::ActuallSetWindowHandle(ULONG32 handle)
  646. {
  647.     HX_RESULT theErr = HXR_UNEXPECTED;
  649.     HX_ASSERT(m_pActualConn);
  650.     if (m_pActualConn)
  651.     {
  652.         m_pMutex->Lock();
  653.         theErr = m_pActualConn->SetWindowHandle(handle);
  654.         if (!theErr)
  655.         {
  656.         }
  657.         m_pMutex->Unlock();
  658.     }
  660.     return theErr;
  661. }
  663. #endif /* defined (_WINDOWS) || defined (_WIN32)*/
  665. HX_RESULT
  666. ThreadedConn::connect(const char*   host,
  667.                      UINT16         port,
  668.                      UINT16         blocking,
  669.                      ULONG32        ulPlatform)
  670. {
  671.     HX_RESULT theErr = HXR_OK;
  673. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  674.     m_ulUserHandle  = ulPlatform;
  676.     if (!m_pNotifier)
  677.     {
  678.         m_pNotifier =
  679.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)ulPlatform,
  680.                                                         TRUE);
  681.     }
  682.     if (m_pNotifier)
  683.     {
  684.         m_pInternalWindowHandle = (void*) m_pNotifier->GetWindowHandle();
  685.         m_pNotifier->AttachSocket(this);
  686.     }
  687.     else
  688.     {
  689.         theErr = HXR_OUTOFMEMORY;
  690.     }
  691. #endif /*defined (_WIN32) || defined (WIN32)*/
  693.     if (!theErr)
  694.     {
  695.         ThrdConnGenericCallback* pCallback      =
  696.                 new ThrdConnGenericCallback(this, CONNECT_CALLBACK_TYPE);
  697.         pCallback->m_HostName   = host;
  698.         pCallback->m_uPort              = port;
  699. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  700. blocking = 1; // we don't get fd_connect when doing loopback
  701. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  702.         pCallback->m_bBlocking  = (BOOL) blocking;
  703.         pCallback->m_ulHandle   = ulPlatform;
  704.         /* Will be released by the thread engine */
  705.         pCallback->AddRef();
  706.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  707.         theErr = m_pNetworkThread->PostMessage(&msg);
  708.     }
  710.     return theErr;
  711. }
  713. HX_RESULT
  714. ThreadedConn::ActualConnect(const char* host,
  715.                             UINT16      port,
  716.                             UINT16      blocking,
  717.                             ULONG32     ulPlatform)
  718. {
  719.     HX_RESULT theErr = HXR_UNEXPECTED;
  720.     HX_ASSERT(m_pActualConn);
  721.     if (m_pActualConn)
  722.     {
  723.         m_pMutex->Lock();
  724.         theErr = m_pActualConn->connect(host, port, blocking, ulPlatform);
  725.         m_pMutex->Unlock();
  726.     }
  728.     return theErr;
  729. }
  731. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  732. HX_RESULT
  733. ThreadedConn::accept (ULONG32 ulAddr)
  734. {
  735.     HX_RESULT theErr = HXR_OK;
  737. #if (defined (_WIN32) || defined (WIN32)) && !defined(WIN32_PLATFORM_PSPC)
  738.     m_ulUserHandle  = NULL; //ulPlatform;
  740.     if (!m_pNotifier)
  741.     {
  742.         m_pNotifier =
  743.             CAsyncNetThread::GetCAsyncNetThreadNotifier((HINSTANCE)m_ulUserHandle,
  744.                                                         TRUE);
  745.     }
  746.     if (m_pNotifier)
  747.     {
  748.         m_pInternalWindowHandle = (void*) m_pNotifier->GetWindowHandle();
  749.         m_pNotifier->AttachSocket(this);
  750.     }
  751.     else
  752.     {
  753.         theErr = HXR_OUTOFMEMORY;
  754.     }
  755. #endif /*defined (_WIN32) || defined (WIN32)*/
  757.     if (!theErr)
  758.     {
  759.         ThrdConnGenericCallback* pCallback      =
  760.                 new ThrdConnGenericCallback(this, ACCEPT_CALLBACK_TYPE);
  761.         pCallback->m_ulHandle   = m_ulUserHandle;
  762. pCallback->m_ulLocalAddr = ulAddr;
  763.         /* Will be released by the thread engine */
  764.         pCallback->AddRef();
  765.         HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  766.         theErr = m_pNetworkThread->PostMessage(&msg);
  767.     }
  769.     return theErr;
  770. }
  772. HX_RESULT
  773. ThreadedConn::ActualAccept(ULONG32 ulAddr,
  774.                             ULONG32     ulPlatform)
  775. {
  776.     HX_RESULT theErr = HXR_UNEXPECTED;
  777.     HX_ASSERT(m_pActualConn);
  778.     if (m_pActualConn)
  779.     {
  780.         m_pMutex->Lock();
  781.         theErr = m_pActualConn->CheckForConnection();
  782.         m_pMutex->Unlock();
  783. if (theErr == HXR_WOULD_BLOCK)
  784. {
  785.     ThrdConnGenericCallback* pCallback      =
  786.     new ThrdConnGenericCallback(this, ACCEPT_CALLBACK_TYPE);
  787.     pCallback->m_ulHandle   = ulPlatform;
  788.     pCallback->m_ulLocalAddr = ulAddr;
  789.     /* Will be released by the thread engine */
  790.     pCallback->AddRef();
  791.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  792.     theErr = m_pNetworkThread->PostMessage(&msg);
  793. }
  794.     }
  796.     return theErr;
  797. }
  798. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  800. HX_RESULT
  801. ThreadedConn::blocking(void)
  802. {
  803.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, BLOCKING_CALLBACK_TYPE);
  804.     /* Will be released by the thread engine */
  805.     pCallback->AddRef();
  806.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  807.     return m_pNetworkThread->PostMessage(&msg);
  808. }
  810. HX_RESULT
  811. ThreadedConn::ActualBlocking(void)
  812. {
  813.     HX_RESULT theErr = HXR_UNEXPECTED;
  814.     HX_ASSERT(m_pActualConn);
  815.     if (m_pActualConn)
  816.     {
  817.         m_pMutex->Lock();
  818.         theErr = m_pActualConn->blocking();
  819.         m_pMutex->Unlock();
  820.     }
  822.     return theErr;
  823. }
  825. HX_RESULT
  826. ThreadedConn::nonblocking(void)
  827. {
  828.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, NONBLOCKING_CALLBACK_TYPE);
  829.     /* Will be released by the thread engine */
  830.     pCallback->AddRef();
  831.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  832.     return m_pNetworkThread->PostMessage(&msg);
  833. }
  835. HX_RESULT
  836. ThreadedConn::ActualNonBlocking(void)
  837. {
  838.     HX_RESULT theErr = HXR_UNEXPECTED;
  839.     HX_ASSERT(m_pActualConn);
  840.     if (m_pActualConn)
  841.     {
  842.         m_pMutex->Lock();
  843.         theErr = m_pActualConn->nonblocking();
  844.         m_pMutex->Unlock();
  845.     }
  847.     return theErr;
  848. }
  851. HX_RESULT
  852. ThreadedConn::read (void* buf, UINT16* size)
  853. {
  854.     HX_RESULT theErr = HXR_OK;
  855.     UINT16 uCount = 0;
  857.     m_pMutex->Lock();
  858.     m_bOutstandingReadNotification = FALSE;
  860.     if (m_uSocketType != HX_TCP_SOCKET)
  861.     {
  862.         theErr = HXR_NET_SOCKET_INVALID;
  863.         goto cleanup;
  864.     }
  866.     uCount = m_pReceiveTCP->GetQueuedItemCount();
  867.     if (uCount > 0)
  868.     {
  869.         uCount = (uCount <= *size ? uCount : *size);
  870.         m_pReceiveTCP->DeQueue(buf, uCount);
  871.         *size = uCount;
  872.     }
  873.     else
  874.     {
  875.         *size = 0;
  876.         if (!mLastError && m_pActualConn)
  877.         {
  878.             theErr = HXR_WOULD_BLOCK;
  879.         }
  880.         else
  881.         {
  882.             theErr = mLastError;
  883.         }
  884.     }
  886. cleanup:
  888.     if (!mLastError && !m_bNetworkIOPending)
  889.     {
  890.         theErr = PostIOMessage();
  891.     }
  893.     m_pMutex->Unlock();
  895.     return theErr;
  896. }
  898. HX_RESULT
  899. ThreadedConn::readfrom (REF(IHXBuffer*)    pBuffer,
  900.                         REF(UINT32)         ulAddress,
  901.                         REF(UINT16)         ulPort)
  902. {
  903.     HX_RESULT theErr = HXR_OK;
  904.     UDP_PACKET* pPacket = NULL;
  906.     m_pMutex->Lock();
  907.     m_bOutstandingReadNotification = FALSE;
  909.     pBuffer = NULL;
  910.     ulAddress = 0;
  911.     ulPort = 0;
  913.     if (m_uSocketType != HX_UDP_SOCKET)
  914.     {
  915.         theErr = HXR_NET_SOCKET_INVALID;
  916.         goto cleanup;
  917.     }
  919.     if (m_ReadUDPBuffers.GetCount() > 0)
  920.     {
  921.         pPacket = (UDP_PACKET*)m_ReadUDPBuffers.RemoveHead();;
  923.         pBuffer = pPacket->pBuffer;
  924.         ulAddress = pPacket->ulAddress;
  925.         ulPort = pPacket->ulPort;
  927.         HX_DELETE(pPacket);
  928.     }
  929.     else
  930.     {
  931.         if (!mLastError)
  932.         {
  933.             theErr = HXR_WOULD_BLOCK;
  934.         }
  935.         else
  936.         {
  937.             theErr = mLastError;
  938.         }
  939.     }
  941. cleanup:
  943.     if (!m_bReadPostPendingWouldBlock && !mLastError && !m_bNetworkIOPending)
  944.     {
  945.         theErr = PostIOMessage();
  946.     }
  948.     m_pMutex->Unlock();
  950.     if( mLastError == HXR_OUTOFMEMORY )
  951.     {
  952.         theErr = mLastError;
  953.     }
  954.     return theErr;
  955. }
  957. HX_RESULT
  958. ThreadedConn::write (void* buf, UINT16* size)
  959. {
  960.     HX_RESULT theErr = HXR_OK;
  961.     HX_ASSERT(m_pActualConn && m_uSocketType == HX_TCP_SOCKET);
  963.     m_pMutex->Lock();
  964.     m_bOutstandingWriteNotification = FALSE;
  965.     UINT16 uCount = m_pSendTCP->GetMaxAvailableElements();
  966.     if (uCount > 0)
  967.     {
  968.         uCount = (uCount <= *size ? uCount : *size);
  969.         m_pSendTCP->EnQueue(buf, uCount);
  970.         *size = uCount;
  971.     }
  972.     else
  973.     {
  974.         *size = 0;
  975.         if (!mLastError)
  976.         {
  977.             theErr = HXR_WOULD_BLOCK;
  978.         }
  979.         else
  980.         {
  981.             theErr = mLastError;
  982.         }
  983.     }
  985.     if (!m_bWriteFlushPending && m_pSendTCP->GetQueuedItemCount() > 0 && m_bConnected)
  986.     {
  987.         m_bWriteFlushPending    = TRUE;
  988.         AddRef();
  989.     }
  991.     if (!mLastError && !m_bNetworkIOPending)
  992.     {
  993.         theErr = PostIOMessage();
  994.     }
  996.     m_pMutex->Unlock();
  998.     return theErr;
  999. }
  1001. HX_RESULT
  1002. ThreadedConn::writeto(void* buf,UINT16* len, ULONG32 addr, UINT16 port)
  1003. {
  1004.     HX_RESULT theErr = HXR_OK;
  1005.     HX_ASSERT(m_pActualConn && m_uSocketType == HX_UDP_SOCKET);
  1007.     m_pMutex->Lock();
  1008.     m_bOutstandingWriteNotification = FALSE;
  1009.     if (!mLastError)
  1010.     {
  1011.         UDPPacketInfo* pPacket  = new UDPPacketInfo;
  1012.         pPacket->m_pBuffer  = new CHXBuffer;
  1013.         pPacket->m_pBuffer->AddRef();
  1014.         pPacket->m_pBuffer->Set((UCHAR*) buf, (ULONG32) *len);
  1015.         pPacket->m_ulAddr   = addr;
  1016.         pPacket->m_uPort    = port;
  1017.         m_WriteUDPBuffers.AddTail((void*) pPacket);
  1018.     }
  1019.     else
  1020.     {
  1021.         theErr = mLastError;
  1022.     }
  1024.     if (!theErr && !m_bWriteFlushPending && m_WriteUDPBuffers.GetCount() > 0 && m_bConnected)
  1025.     {
  1026.         m_bWriteFlushPending    = TRUE;
  1027.         AddRef();
  1028.     }
  1030.     if (!mLastError && !m_bNetworkIOPending)
  1031.     {
  1032.         theErr = PostIOMessage();
  1033.     }
  1035.     m_pMutex->Unlock();
  1037.     return theErr;
  1038. }
  1040. ULONG32
  1041. ThreadedConn::get_addr(void)
  1042. {
  1043.     ULONG32 ulAddr = 0;
  1044.     HX_ASSERT(m_pActualConn);
  1045.     if (m_pActualConn)
  1046.     {
  1047.         m_pMutex->Lock();
  1048.         ulAddr = m_pActualConn->get_addr();
  1049.         m_pMutex->Unlock();
  1050.     }
  1052.     return ulAddr;
  1053. }
  1055. UINT16
  1056. ThreadedConn::get_local_port(void)
  1057. {
  1058.     UINT16 nPort = 0;
  1059.     HX_ASSERT(m_pActualConn);
  1060.     if (m_pActualConn)
  1061.     {
  1062.         m_pMutex->Lock();
  1063.         nPort = m_pActualConn->get_local_port();
  1064.         m_pMutex->Unlock();
  1065.     }
  1067.     return nPort;
  1068. }
  1071. /* join_multicast_group() has this socket join a multicast group */
  1072. HX_RESULT
  1073. ThreadedConn::join_multicast_group(ULONG32 addr, ULONG32 if_addr)
  1074. {
  1075.     HX_RESULT theErr = HXR_UNEXPECTED;
  1076.     HX_ASSERT(m_pActualConn);
  1077.     if (m_pActualConn)
  1078.     {
  1079.         m_pMutex->Lock();
  1080.         theErr = m_pActualConn->join_multicast_group(addr, if_addr);
  1081.         m_pMutex->Unlock();
  1082.     }
  1084.     return theErr;
  1085. }
  1087. HX_RESULT
  1088. ThreadedConn::leave_multicast_group(ULONG32 addr, ULONG32 if_addr)
  1089. {
  1090.     HX_RESULT theErr = HXR_UNEXPECTED;
  1091.     HX_ASSERT(m_pActualConn);
  1092.     if (m_pActualConn)
  1093.     {
  1094.         m_pMutex->Lock();
  1095.         theErr = m_pActualConn->leave_multicast_group(addr, if_addr);
  1096.         while (!m_ReadUDPBuffers.IsEmpty())
  1097.         {
  1098.             UDP_PACKET* pPacket = (UDP_PACKET*)m_ReadUDPBuffers.RemoveHead();
  1100.             HX_RELEASE(pPacket->pBuffer);
  1101.             HX_DELETE(pPacket);
  1102.         }
  1103.         m_pMutex->Unlock();
  1104.     }
  1106.     return theErr;
  1107. }
  1109. HX_RESULT
  1110. ThreadedConn::reuse_addr(BOOL enabled)
  1111. {
  1112.     HX_RESULT theErr = HXR_UNEXPECTED;
  1113.     HX_ASSERT(m_pActualConn);
  1114.     if (m_pActualConn)
  1115.     {
  1116.         m_pMutex->Lock();
  1117.         theErr = m_pActualConn->reuse_addr(enabled);
  1118.         m_pMutex->Unlock();
  1119.     }
  1120.     return theErr;
  1121. }
  1123. HX_RESULT
  1124. ThreadedConn::reuse_port(BOOL enabled)
  1125. {
  1126.     HX_RESULT theErr = HXR_UNEXPECTED;
  1127.     HX_ASSERT(m_pActualConn);
  1128.     if (m_pActualConn)
  1129.     {
  1130.         m_pMutex->Lock();
  1131.         theErr = m_pActualConn->reuse_port(enabled);
  1132.         m_pMutex->Unlock();
  1133.     }
  1134.     return theErr;
  1135. }
  1137. HX_RESULT
  1138. ThreadedConn::set_broadcast(BOOL enable)
  1139. {
  1140.         HX_RESULT theErr = HXR_UNEXPECTED;
  1141.         HX_ASSERT(m_pActualConn);
  1142.         if(m_pActualConn)
  1143.         {
  1144.         m_pMutex->Lock();
  1145.         theErr = m_pActualConn->set_broadcast(enable);
  1146.         m_pMutex->Unlock();
  1147.         }
  1148.         return theErr;
  1149. }
  1151. HX_RESULT
  1152. ThreadedConn::set_multicast_if(ULONG32 ulInterface)
  1153. {
  1154.     HX_RESULT theErr = HXR_UNEXPECTED;
  1155.     HX_ASSERT(m_pActualConn);
  1156.     if(m_pActualConn)
  1157.     {
  1158.         m_pMutex->Lock();
  1159.         theErr = m_pActualConn->set_multicast_if(ulInterface);
  1160.         m_pMutex->Unlock();
  1161.     }
  1162.     return theErr;
  1163. }
  1165. void
  1166. ThreadedConn::IgnoreWSAECONNRESET(BOOL b)
  1167. {
  1168.     HX_RESULT theErr = HXR_UNEXPECTED;
  1169.     HX_ASSERT(m_pActualConn);
  1170.     if(m_pActualConn)
  1171.     {
  1172.         m_pMutex->Lock();
  1173.         m_pActualConn->IgnoreWSAECONNRESET(b);
  1174.         m_pMutex->Unlock();
  1175.     }
  1176. }
  1178. HX_RESULT
  1179. ThreadedConn::last_error(void)
  1180. {
  1181.     HX_ASSERT(m_pActualConn);
  1182.     if (m_pActualConn)
  1183.     {
  1184.         m_pMutex->Lock();
  1185.         mLastError = m_pActualConn->last_error();
  1186.         m_pMutex->Unlock();
  1187.     }
  1189.     return mLastError;
  1190. }
  1192. void
  1193. ThreadedConn::set_callback(HXAsyncNetCallback* pCallback)
  1194. {
  1195.     m_pMutex->Lock();
  1196.     HX_ASSERT(m_pActualConn);
  1197.     if (m_pActualConn)
  1198.     {
  1199.         /* Set our callback as the callback */
  1200.         m_pActualConn->set_callback(m_pNetCallback);
  1201.     }
  1203.     mCallBack = pCallback;
  1204.     m_pMutex->Unlock();
  1205. }
  1208. UINT16
  1209. ThreadedConn::connection_open(void)
  1210. {
  1211.     UINT16 uConnOpen = 0;
  1212.     HX_ASSERT(m_pActualConn);
  1213.     if (m_pActualConn)
  1214.     {
  1215.         m_pMutex->Lock();
  1216.         uConnOpen = m_pActualConn->connection_open();
  1217.         m_pMutex->Unlock();
  1218.     }
  1220.     return uConnOpen;
  1221. }
  1223. UINT16
  1224. ThreadedConn::connection_really_open(void)
  1225. {
  1226.     UINT16 uConnOpen = 0;
  1227.     //HX_ASSERT(m_pActualConn);
  1228.     if (m_pActualConn)
  1229.     {
  1230.         m_pMutex->Lock();
  1231.         uConnOpen = m_pActualConn->connection_really_open();
  1232.         m_pMutex->Unlock();
  1233.     }
  1235.     return uConnOpen;
  1236. }
  1238. int
  1239. ThreadedConn::get_sock(void)
  1240. {
  1241.     int iSockNum = -1;
  1242.     HX_ASSERT(m_pActualConn);
  1243.     if (m_pActualConn)
  1244.     {
  1245.         m_pMutex->Lock();
  1246.         iSockNum =  m_pActualConn->get_sock();
  1247.         m_pMutex->Unlock();
  1248.     }
  1249.     return iSockNum;
  1250. }
  1252. void
  1253. ThreadedConn::set_sock(int theSock)
  1254. {
  1255.     m_pMutex->Lock();
  1256.     HX_ASSERT(m_pActualConn);
  1257.     if (m_pActualConn)
  1258.     {
  1259.         m_pActualConn->set_sock(theSock);
  1260.     }
  1262.     mSock = theSock;
  1263.     m_pMutex->Unlock();
  1264. }
  1266. BOOL
  1267. ThreadedConn::set_receive_buf_size(int DesiredSize)
  1268. {
  1269.     ThrdConnGenericCallback* pCallback  = new ThrdConnGenericCallback(this, SET_BUFFER_SIZE_CALLBACK_TYPE);
  1270.     pCallback->m_ulBufferSize = (UINT32) DesiredSize;
  1271.     /* Will be released by the thread engine */
  1272.     pCallback->AddRef();
  1273.     HXThreadMessage msg(HXMSG_ASYNC_CALLBACK, this, pCallback);
  1274.     m_pNetworkThread->PostMessage(&msg);
  1275.     return TRUE;
  1276. }
  1279. BOOL
  1280. ThreadedConn::ActualSetReceiveBufSize(UINT32 ulBufferSize)
  1281. {
  1282.     BOOL bResult = FALSE;
  1283.     HX_ASSERT(m_pActualConn);
  1284.     if (m_pActualConn)
  1285.     {
  1286.         m_pMutex->Lock();
  1287.         bResult = m_pActualConn->set_receive_buf_size((int) ulBufferSize);
  1288.         m_pMutex->Unlock();
  1289.     }
  1291.     return bResult;
  1292. }
  1294. void
  1295. ThreadedConn::OnAsyncDNS(BOOL bResult)
  1296. {
  1297.     if (mCallBack)
  1298.     {
  1299.         mCallBack->Func(DNS_NOTIFICATION, bResult);
  1300.     }
  1301. }
  1303. void
  1304. ThreadedConn::OnReadNotification(void)
  1305. {
  1306.     if (mCallBack)
  1307.     {
  1308.         mCallBack->Func(READ_NOTIFICATION);
  1309.     }
  1310. }
  1312. void
  1313. ThreadedConn::OnWriteNotification(void)
  1314. {
  1315.     if (mCallBack)
  1316.     {
  1317.         mCallBack->Func(WRITE_NOTIFICATION);
  1318.     }
  1319. }
  1321. void
  1322. ThreadedConn::OnConnect(BOOL bResult)
  1323. {
  1324.     if (mCallBack)
  1325.     {
  1326.         mCallBack->Func(CONNECT_NOTIFICATION, bResult);
  1327.     }
  1328. }
  1330. void
  1331. ThreadedConn::OnAcceptNotification()
  1332. {
  1333.     if( m_pIncommingConnections )
  1334.     {
  1335.         conn* pConn = (conn*)m_pIncommingConnections->RemoveHead();
  1336. // accept_notification is posted in win_net:checkforconnection
  1337. // callback->func(accept_notification..) calls this function
  1338. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1339.         if (mCallBack)
  1340.         {
  1341.             mCallBack->Func(ACCEPT_NOTIFICATION, TRUE, pConn);
  1342.         }
  1343.         if (pConn)
  1344.         {
  1345.             pConn->Release();
  1346.             pConn = NULL;
  1347.         }
  1348. #else
  1349. // at this point we need to set pengine->reader = pconn
  1350.         HXThreadMessage msg(HXMSG_ASYNC_SETREADER_CONNECTION, this, pConn);
  1351.         m_pNetworkThread->PostMessage(&msg);
  1352. #endif
  1354.     }
  1355. }
  1357. void
  1358. ThreadedConn::HandleDNSNotification(BOOL bSuccess)
  1359. {
  1360. #if !defined( WIN32_PLATFORM_PSPC ) && !defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1361.     HXThreadMessage msg(HXMSG_ASYNC_DNS, this, (void*) bSuccess);
  1362.     m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1363. #else
  1364.     OnAsyncDNS(bSuccess);
  1365. #endif
  1366. }
  1368. void
  1369. ThreadedConn::HandleConnectNotification(BOOL bSuccess)
  1370. {
  1371.     if (bSuccess)
  1372.     {
  1373.         m_bConnected = TRUE;
  1374.     }
  1376. #if !defined( WIN32_PLATFORM_PSPC ) && !defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1377.     HXThreadMessage msg(HXMSG_ASYNC_CONNECT, this, (void*) bSuccess);
  1378.     m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1379. #else // No notifier on CE
  1380.     OnConnect(bSuccess);
  1381. #endif
  1382. }
  1384. void
  1385. ThreadedConn::HandleAcceptNotification(conn* pConn)
  1386. {
  1387.     ThreadedConn* pTConn = (ThreadedConn*)conn::new_socket(HX_TCP_SOCKET);
  1388.     pTConn->SetActualConn(pConn, m_ulUserHandle);
  1389.     m_pIncommingConnections->AddHead((conn*)pTConn);
  1391. #if !defined( WIN32_PLATFORM_PSPC ) && !defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1392.     HXThreadMessage msg(HXMSG_ASYNC_ACCEPT, this, NULL);
  1393.     m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1394. #else // No notifier on CE
  1395.     OnAcceptNotification();
  1396. #endif
  1397. }
  1399. void
  1400. ThreadedConn::HandleCloseNotification()
  1401. {
  1402.     /* make one more read call to get back the actual error */
  1403.     m_bReadPostPendingWouldBlock = FALSE;
  1404. }
  1406. HX_RESULT
  1407. ThreadedConn::SetActualConn(conn* pConn, ULONG32 ulPlatform)
  1408. {
  1409.     if ( m_pActualConn )
  1410.     {
  1411.         m_pActualConn->done();
  1412.         m_pActualConn->Release();
  1413.     }
  1414.     m_pActualConn = pConn;
  1415.     m_pActualConn->AddRef();
  1416.     m_ulUserHandle = ulPlatform;
  1417.     m_bConnected = TRUE;
  1418.     return HXR_OK;
  1419. }
  1421. HX_RESULT
  1422. ThreadedConn::DoRead(BOOL bFromReadNotification)
  1423. {
  1424. #ifdef _CARBON
  1425.     AddRef(); // ensure that this object doesn't encounter its dtor before routine completes
  1426. #endif
  1427.     HX_RESULT theErr = HXR_OK;
  1428.     m_pMutex->Lock();
  1430.     /* Reset reading heuristing if we just got data. */
  1431.     if( bFromReadNotification )
  1432.     {
  1433.         m_bReadNowPending = m_bReadPostPendingWouldBlock = FALSE;
  1434.     }
  1436.     /* If the socket done has already been called, do not attempt to read
  1437.      * any more data
  1438.      */
  1439.     if (m_bIsDone)
  1440.     {
  1441.         goto exit;
  1442.     }
  1444. #ifdef THREADS_SUPPORTED
  1445. #ifdef HELIX_FEATURE_ADD_NETWORK_THREAD_SLEEP
  1446.     Sleep( m_ulNetworkThreadSleep ); // gives other threads a quote to run
  1447. #endif //HELIX_FEATURE_ADD_NETWORK_THREAD_SLEEP
  1448. #endif //THREADS_SUPPORTED
  1450.     if (m_uSocketType == HX_TCP_SOCKET)
  1451.     {
  1452.         UINT16 uCount = m_pReceiveTCP->GetMaxAvailableElements();
  1454.         if (uCount > 0)
  1455.         {
  1456.             UINT32 ulBytesToRead = conn::bytes_to_preparetcpread(this);
  1458.             if (ulBytesToRead > 0)
  1459.             {
  1460.                 if ((UINT32)uCount > ulBytesToRead)
  1461.                 {
  1462.                     uCount = (UINT16)ulBytesToRead;
  1463.                 }
  1465.                 if ( m_bReadPostPendingWouldBlock )
  1466.                 {
  1467.                     /* fake a call return */
  1468.                     theErr = HXR_WOULD_BLOCK;
  1469.                 }
  1470.                 else
  1471.                 {
  1472.                     /* call read and do heuristinc bookkeeping */
  1473.                     theErr = m_pActualConn->read(m_pTempBuffer, &uCount);
  1474. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1475.                     m_bReadPostPendingWouldBlock = (m_bReadNowPending && theErr == HXR_WOULD_BLOCK);
  1476. #endif
  1477.                     m_bReadNowPending = (theErr == HXR_WOULD_BLOCK ? TRUE : FALSE);
  1478.                 }
  1479.                 if (!theErr && uCount > 0)
  1480.                 {
  1481.                     conn::bytes_to_actualtcpread(this, uCount);
  1482.                     m_pReceiveTCP->EnQueue(m_pTempBuffer, uCount);
  1483.                 }
  1484.             }
  1485.         }
  1487. #ifndef _WINCE
  1488.         if (!m_bOutstandingReadNotification && m_pReceiveTCP->GetQueuedItemCount() > 0)
  1489.         {
  1490. #ifdef HELIX_FEATURE_NETWORK_USE_SELECT
  1491.             m_bOutstandingReadNotification  = TRUE;
  1492.             HXThreadMessage msg(HXMSG_ASYNC_READ, this, NULL);
  1493.             theErr = m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1494.     if ( theErr == HXR_NOT_INITIALIZED )
  1495.     {
  1496. theErr = HXR_OK;
  1497.     }
  1498. #endif
  1499.         }
  1500. #endif /* _WINCE */
  1501.     }
  1502.     else /*if (m_uSocketType == HX_UDP_SOCKET)*/
  1503.     {
  1504.         UINT32 ulAddress = 0;
  1505.         UINT16 ulPort = 0;
  1507.         /* Read as much UDP data as possible */
  1508.         while (!theErr)
  1509.         {
  1510.             IHXBuffer* pBuffer = NULL;
  1512.             if ( m_bReadPostPendingWouldBlock )
  1513.             {
  1514.                 /* fake a call return */
  1515.                 theErr = HXR_WOULD_BLOCK;
  1516.             }
  1517.             else
  1518.             {
  1519.                 /* call read and do heuristinc bookkeeping */
  1520.                 theErr = m_pActualConn->readfrom(pBuffer, ulAddress, ulPort);
  1521.                 if( theErr == HXR_OUTOFMEMORY )
  1522.                 {
  1523.                     mLastError = HXR_OUTOFMEMORY;
  1524.                 }
  1525.                 /* If this is a single WOULDBLOCK, ReadNowPending gets set.  If this is the second
  1526.                    consecutive blocking call, ReadPostPendingWouldBlock gets set.
  1527.                    Feel free to suggest better variable names. */
  1528. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1529.                 m_bReadPostPendingWouldBlock = (m_bReadNowPending && theErr == HXR_WOULD_BLOCK);
  1530. #endif
  1531.                 m_bReadNowPending = (theErr == HXR_WOULD_BLOCK ? TRUE : FALSE);
  1532.             }
  1534.             if (!theErr && pBuffer)
  1535.             {
  1536.                 UDP_PACKET* pPacket = new UDP_PACKET;
  1538.                 if(pPacket)
  1539.                 {
  1540.                     pPacket->pBuffer = pBuffer;
  1541.                     pPacket->ulAddress = ulAddress;
  1542.                     pPacket->ulPort = ulPort;
  1543.                     m_ReadUDPBuffers.AddTail((void*)pPacket);
  1544.                 }
  1545.                 else
  1546.                 {
  1547.                     theErr = HXR_OUTOFMEMORY;
  1548.                 }
  1549.             }
  1550.         }
  1553. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1554.         if ( !theErr && !m_bOutstandingReadNotification && m_ReadUDPBuffers.GetCount() > 0)
  1555.         {
  1556.             m_bOutstandingReadNotification  = TRUE;
  1557.             HXThreadMessage msg(HXMSG_ASYNC_READ, this, NULL);
  1558.             m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1559.         }
  1560. #endif
  1561.     }
  1564.     if (!mLastError && theErr)
  1565.     {
  1566.         mLastError = ConvertNetworkError(theErr);
  1567.     }
  1569.     /* If there is an error, issue a Read Available message
  1570.      * so that error can be reported back on next Read
  1571.      */
  1572.     if (!m_bOutstandingReadNotification && mLastError && theErr != HXR_OUTOFMEMORY)
  1573.     {
  1574.         m_bOutstandingReadNotification  = TRUE;
  1575.         HXThreadMessage msg(HXMSG_ASYNC_READ, this, NULL);
  1576. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1577.         m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1578. #else
  1579. m_pNetworkThread->PostMessage(&msg, m_pInternalWindowHandle);
  1580. #endif
  1581.     }
  1583. exit:
  1584.     m_pMutex->Unlock();
  1585. #ifdef _CARBON
  1586.     Release();
  1587. #endif
  1588.     return theErr;
  1589. }
  1591. void
  1592. ThreadedConn::DoWrite()
  1593. {
  1594.     // If we are out of memory, let's just get out of here. Ideally, we should
  1595.     // not ever get to this point, but lots of functions here have void return
  1596.     // types, so it is possible to lose an OOM error.
  1597.     if( mLastError == HXR_OUTOFMEMORY )
  1598.     {
  1599.         return;
  1600.     }
  1601. #ifdef _CARBON
  1602.     AddRef();
  1603. #endif
  1604.     HX_RESULT theErr = HXR_OK;
  1605.     m_pMutex->Lock();
  1606.     if (m_uSocketType == HX_TCP_SOCKET)
  1607.     {
  1608.         UINT16 uCount = m_pSendTCP->GetQueuedItemCount();
  1609.         if (uCount > 0)
  1610.         {
  1611.             m_pSendTCP->DeQueue(m_pTempBuffer, uCount);
  1612.             UINT16 uActualCount = uCount;
  1613.             theErr = m_pActualConn->write(m_pTempBuffer, &uActualCount);
  1614.             switch(theErr)
  1615.             {
  1616.                 case HXR_AT_INTERRUPT:
  1617.                 case HXR_WOULD_BLOCK:
  1618.                 case HXR_OK:
  1619.                     // enqueue the data that was not sent
  1620.                     if(uActualCount != uCount)
  1621.                     {
  1622.                         m_pSendTCP->EnQueue(m_pTempBuffer + uActualCount,
  1623.                                             uCount - uActualCount);
  1624.                     }
  1626.                     // mask out these errors
  1627.                     theErr = HXR_OK;
  1628.                     break;
  1630.                 default:
  1631.                     break;
  1632.             }
  1633.         }
  1635. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1636.         if (!m_bIsDone && !m_bOutstandingWriteNotification && m_pSendTCP->GetMaxAvailableElements() > 0)
  1637.         {
  1638.             m_bOutstandingWriteNotification = TRUE;
  1639.             HXThreadMessage msg(HXMSG_ASYNC_WRITE, this, NULL);
  1640.             m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1641.         }
  1642. #endif
  1643.     }
  1644.     else /*if (m_uSocketType == HX_UDP_SOCKET)*/
  1645.     {
  1646.         while (!theErr && m_WriteUDPBuffers.GetCount() > 0)
  1647.         {
  1648.             UDPPacketInfo* pPacket = (UDPPacketInfo*) m_WriteUDPBuffers.GetHead();
  1649.             UINT16 uLength = (UINT16) pPacket->m_pBuffer->GetSize();
  1650.             theErr = m_pActualConn->writeto(pPacket->m_pBuffer->GetBuffer(),   // sendto
  1651.                                         &uLength,
  1652.                                         pPacket->m_ulAddr,
  1653.                                         pPacket->m_uPort);
  1654.             if (!theErr)
  1655.             {
  1656.                 pPacket->m_pBuffer->Release();
  1657.                 delete pPacket;
  1658.                 m_WriteUDPBuffers.RemoveHead();
  1659.             }
  1660.         }
  1662. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1663.         if (!m_bIsDone && !m_bOutstandingWriteNotification && m_WriteUDPBuffers.GetCount() == 0)
  1664.         {
  1665.             m_bOutstandingWriteNotification = TRUE;
  1666.             HXThreadMessage msg(HXMSG_ASYNC_WRITE, this, NULL);
  1667.             m_pMainAppThread->PostMessage(&msg, m_pInternalWindowHandle);
  1668.         }
  1669. #endif
  1670.     }
  1672.     if (!mLastError && theErr)
  1673.     {
  1674.         mLastError = ConvertNetworkError(theErr);
  1675.     }
  1677. #ifndef HELIX_FEATURE_NETWORK_USE_SELECT
  1678.     if (!mLastError && !m_bNetworkIOPending &&
  1679.         ((m_uSocketType == HX_TCP_SOCKET && m_pSendTCP->GetQueuedItemCount() > 0) ||
  1680.          (m_uSocketType == HX_UDP_SOCKET && m_WriteUDPBuffers.GetCount() > 0)))
  1681.     {
  1682.         theErr = PostIOMessage();
  1683.     }
  1684. #endif
  1686.     m_pMutex->Unlock();
  1688.     if (m_bWriteFlushPending &&
  1689.         ((m_uSocketType == HX_TCP_SOCKET && m_pSendTCP->GetQueuedItemCount() == 0) ||
  1690.          (m_uSocketType == HX_UDP_SOCKET && m_WriteUDPBuffers.GetCount() == 0)))
  1691.     {
  1692.         m_bWriteFlushPending    = FALSE;
  1693.         Release();
  1694.     }
  1696.     /* We are done and there is no more data pending to bw written out */
  1697.     /* This is the time socket actually gets destroyed */
  1698.     if (m_bIsDone && !m_bWriteFlushPending)
  1699.     {
  1700.         m_bConnected = FALSE;
  1701.         PostDoneAndDetach();
  1702.     }
  1703. #ifdef _CARBON
  1704.     Release();
  1705. #endif
  1706. }
  1708. //--------------------------------------------------
  1709. void
  1710. ThreadedConn::DoNetworkIO(void)
  1711. {
  1712.     m_bNetworkIOPending = FALSE;
  1713.     if (m_bConnected)
  1714.     {
  1715.         // DoRead now has a return type, but since DoNetworkIO does not we
  1716.         // are going to ignore any errors returned. This may not be a good idea.
  1717. #if !defined( WIN32_PLATFORM_PSPC ) /*&& !defined( _UNIX )*/
  1718. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1719. if (!m_pNetworkThread->m_bUseReaderWriter)
  1720. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1721.         DoRead();
  1722.         DoWrite();
  1723. #else
  1724. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1725. if (!m_pNetworkThread->m_bUseReaderWriter)
  1726. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1727.         DoRead(TRUE);
  1728.         DoWrite();
  1729. #endif
  1730.     }
  1731. }
  1732. HX_RESULT
  1733. ThreadedConn::ConvertNetworkError(HX_RESULT theErr)
  1734. {
  1735.     HX_RESULT lResult = theErr;
  1736.     if (!IS_SERVER_ALERT(theErr))
  1737.     {
  1738.         switch(theErr)
  1739.         {
  1740.             case HXR_AT_INTERRUPT:                      // mask out these errors
  1741.             case HXR_WOULD_BLOCK:
  1742.             case HXR_NO_DATA:
  1743.             case HXR_OK:
  1744.                 lResult = HXR_OK;
  1745.                 break;
  1747.             case HXR_DNR:
  1748.             case HXR_NET_CONNECT:
  1749.             case HXR_DOC_MISSING:
  1750.             case HXR_OUTOFMEMORY:
  1751.             case HXR_ADVANCED_SERVER:
  1752.             case HXR_BAD_SERVER:
  1753.             case HXR_OLD_SERVER:
  1754.             case HXR_INVALID_FILE:
  1755.             case HXR_REDIRECTION:
  1756.             case HXR_PROXY:
  1757.             case HXR_PROXY_RESPONSE:
  1758.             case HXR_ADVANCED_PROXY:
  1759.             case HXR_OLD_PROXY:
  1760.             case HXR_PERFECTPLAY_NOT_SUPPORTED:
  1761.             case HXR_NO_LIVE_PERFECTPLAY:
  1762.             case HXR_PERFECTPLAY_NOT_ALLOWED:
  1763.                 break;
  1765.             default:
  1766.                 lResult = HXR_FAIL;
  1767.                 break;
  1768.         }
  1769.     }
  1771.     return lResult;
  1772. }
  1774. HX_RESULT
  1775. ThreadedConn::PostIOMessage(void)
  1776. {
  1777.     m_bNetworkIOPending = TRUE;
  1778.     HXThreadMessage msg(HXMSG_ASYNC_NETWORKIO, this, NULL);
  1779.     return m_pNetworkThread->PostMessage(&msg);
  1780. }
  1783. HX_RESULT ThreadedConn::ThrConnSocketCallback::Func(NotificationType Type,
  1784.                                                BOOL bSuccess, conn* pConn)
  1785. {
  1786.     ThreadedConn* pContext = m_pContext;
  1787.     // It would be nice to set theErr for all of the calls below, but the
  1788.     // effects of that are unknown to this developer. XXXJHHB
  1789.     HX_RESULT theErr = HXR_OK;
  1790.     if(pContext)
  1791.     {
  1792.         switch (Type)
  1793.         {
  1794.         case READ_NOTIFICATION:
  1795.             theErr = pContext->DoRead(TRUE);
  1796.             break;
  1797.         case WRITE_NOTIFICATION:
  1798.             pContext->DoWrite();
  1799.             break;
  1800.         case CONNECT_NOTIFICATION:
  1801.             pContext->HandleConnectNotification(bSuccess);
  1802.             break;
  1803.         case DNS_NOTIFICATION:
  1804.             pContext->HandleDNSNotification(bSuccess);
  1805.             break;
  1806.         case ACCEPT_NOTIFICATION:
  1807.             pContext->HandleAcceptNotification(pConn);
  1808. #ifdef HELIX_FEATURE_NETWORK_USE_SELECT
  1809.             break;
  1810. #endif
  1811.         case CLOSE_NOTIFICATION:
  1812.             pContext->HandleCloseNotification();
  1813.             break;
  1814. #ifdef HELIX_FEATURE_NETWORK_USE_SELECT
  1815.         case SEND_BUFFER_NOTIFICATION:
  1816.     UINT16 len;
  1817.     len = sizeof(HXThreadMessage);
  1818.     pContext->m_bNetworkIOPending = TRUE;
  1819.             pContext->write((char *)bSuccess,&len);
  1820.             pContext->DoWrite();
  1821.     pContext->m_bNetworkIOPending = FALSE;
  1822.             break;
  1823. #endif
  1824.         default:
  1825.             break;
  1826.         }
  1827.     }
  1829.     return theErr;
  1830. }
  1834. ThreadedConn::ThrdConnGenericCallback::ThrdConnGenericCallback(ThreadedConn* pConn, UINT16 uCallbackType)
  1835.     : m_lRefCount (0)
  1836.     , m_uCallbackType (uCallbackType)
  1837.     , m_pConn (pConn)
  1838.     , m_bBlocking (FALSE)
  1839.     , m_ulLocalAddr (0)
  1840.     , m_uPort (0)
  1841.     , m_ulBufferSize (0)
  1842.     , m_uBacklog(0)
  1843. //    , m_pNewConn(NULL)
  1844. {
  1845. }
  1847. ThreadedConn::ThrdConnGenericCallback::~ThrdConnGenericCallback()
  1848. {
  1849. //    HX_RELEASE(m_pNewConn);
  1850. }
  1852. /*
  1853.  * IUnknown methods
  1854.  */
  1856. /////////////////////////////////////////////////////////////////////////
  1857. //      Method:
  1858. //              IUnknown::QueryInterface
  1859. //      Purpose:
  1860. //              Implement this to export the interfaces supported by your
  1861. //              object.
  1862. //
  1863. STDMETHODIMP ThreadedConn::ThrdConnGenericCallback::QueryInterface(REFIID riid, void** ppvObj)
  1864. {
  1865.     if (IsEqualIID(riid, IID_IUnknown))
  1866.     {
  1867.         AddRef();
  1868.         *ppvObj = this;
  1869.         return HXR_OK;
  1870.     }
  1871.     else if (IsEqualIID(riid, IID_IHXCallback))
  1872.     {
  1873.         AddRef();
  1874.         *ppvObj = (IHXCallback*)this;
  1875.         return HXR_OK;
  1876.     }
  1878.     *ppvObj = NULL;
  1879.     return HXR_NOINTERFACE;
  1880. }
  1882. /////////////////////////////////////////////////////////////////////////
  1883. //      Method:
  1884. //              IUnknown::AddRef
  1885. //      Purpose:
  1886. //              Everyone usually implements this the same... feel free to use
  1887. //              this implementation.
  1888. //
  1889. STDMETHODIMP_(ULONG32) ThreadedConn::ThrdConnGenericCallback::AddRef()
  1890. {
  1891.     return InterlockedIncrement(&m_lRefCount);
  1892. }
  1894. /////////////////////////////////////////////////////////////////////////
  1895. //      Method:
  1896. //              IUnknown::Release
  1897. //      Purpose:
  1898. //              Everyone usually implements this the same... feel free to use
  1899. //              this implementation.
  1900. //
  1901. STDMETHODIMP_(ULONG32) ThreadedConn::ThrdConnGenericCallback::Release()
  1902. {
  1903.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1904.     {
  1905.         return m_lRefCount;
  1906.     }
  1908.     delete this;
  1909.     return 0;
  1910. }
  1912. /*
  1913.  *      IHXCallback methods
  1914.  */
  1915. STDMETHODIMP ThreadedConn::ThrdConnGenericCallback::Func(void)
  1916. {
  1917.     if (m_pConn)
  1918.     {
  1919.         switch (m_uCallbackType)
  1920.         {
  1921.             case DNS_CALLBACK_TYPE:
  1922.                 m_pConn->ActualDnsFindIpAddr(m_HostName, m_bBlocking);
  1923.                 break;
  1924.             case INIT_CALLBACK_TYPE:
  1925.                 m_pConn->ActualInit(m_ulLocalAddr, m_uPort, m_bBlocking);
  1926.                 break;
  1927.             case SETWINDOWHANDLE_CALLBACK_TYPE:
  1928. #if defined (_WIN32) || defined (_WINDOWS)
  1929.                 m_pConn->ActuallSetWindowHandle(m_ulHandle);
  1930. #endif /*defined (_WIN32) || defined (_WINDOWS)*/
  1931.                 break;
  1932.             case CONNECT_CALLBACK_TYPE:
  1933.                 m_pConn->ActualConnect(m_HostName, m_uPort, m_bBlocking,
  1934.                                         m_ulHandle);
  1935.                 break;
  1936. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1937.             case ACCEPT_CALLBACK_TYPE:
  1938.                 m_pConn->ActualAccept(m_ulLocalAddr,
  1939.                                         m_ulHandle);
  1940.                 break;
  1941. #endif //defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  1942.             case BLOCKING_CALLBACK_TYPE:
  1943.                 m_pConn->ActualBlocking();
  1944.                 break;
  1945.             case NONBLOCKING_CALLBACK_TYPE:
  1946.                 m_pConn->ActualNonBlocking();
  1947.                 break;
  1948.             case DONE_CALLBACK_TYPE:
  1949.                 m_pConn->ActualDone();
  1950.                 break;
  1951.             case SET_BUFFER_SIZE_CALLBACK_TYPE:
  1952.                 m_pConn->ActualSetReceiveBufSize(m_ulBufferSize);
  1953.                 break;
  1954.             case LISTEN_CALLBACK_TYPE:
  1955.                 m_pConn->ActualListen(m_ulLocalAddr, m_uPort, m_uBacklog,
  1956.                                 m_bBlocking, m_ulHandle);
  1957.                 break;
  1958.             default:
  1959.                 break;
  1960.         }
  1961.     }
  1962.     return HXR_OK;
  1963. }