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

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

Symbian

开发平台：

Visual C++

threngin.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: threngin.cpp,v 1.4.2.3 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 <stdio.h>
  51. #include "hxresult.h"
  52. #include "hxassert.h"
  53. #include "hxmap.h"
  54. #include "hxcom.h"
  55. #include "hxengin.h"
  56. #include "hxthread.h"
  57. #include "conn.h"
  58. #include "thrdconn.h"
  59. #include "threngin.h"
  60. #include "hxtick.h"
  62. #if defined(_UNIX) && (defined( _UNIX_THREADED_NETWORK_IO ) || defined(THREADS_SUPPORTED))
  63. #include "platform/unix/UnixThreads.h"
  64. #include "platform/unix/unix_net.h"
  65. #endif
  67. #if defined(_MACINTOSH) && defined(_CARBON) && defined(THREADS_SUPPORTED)
  68. #include "carbthrd.h"
  69. #endif
  71. #include "hxheap.h"
  72. #ifdef _DEBUG
  73. #undef HX_THIS_FILE
  74. static const char HX_THIS_FILE[] = __FILE__;
  75. #endif  
  77. #define ALLFS     0xFFFFFFFF
  78. #define LOCAL_LOOPBACK_ADDR 0x7F000001 // 127.0.0.1
  79. #define LOCAL_LOOPBACK_NAME "127.0.0.1"
  80. #define LOCAL_LOOPBACK_PORT 0x1234
  82. void* NetworkThreadMainLoop(void* pArg);
  84. ThreadEngine*   ThreadEngine::m_pzThreadEngine = NULL;
  86. /* Global destructor will be called at DLL shutdown and thread engine
  87.  * will be destroyed
  88.  */ 
  89. DestructEngine selfDestructor;
  91. ThreadEngine*    
  92. ThreadEngine::GetThreadEngine(void)
  93. {
  94.     if (!m_pzThreadEngine)
  95.     {
  96. m_pzThreadEngine = new ThreadEngine; 
  97.     }
  99.     return m_pzThreadEngine;
  100. }
  102. ThreadEngine::ThreadEngine()
  103.     : m_pNetworkThread(0)
  104.     , m_pMainAppThread(0)
  105.     , m_pMutex(0)
  106.     , m_pSockMap(0)
  107.     , m_pQuitEvent(NULL)
  108.     , m_bInDestructor(FALSE)
  109. #if defined(_MACINTOSH) && defined(_CARBON) && defined(THREADS_SUPPORTED)
  110.     , m_ThreadedNetworkingCarbonTimerUPP(NULL)
  111.     , m_ThreadedNetworkingCarbonTimerRef(NULL)
  112. #endif
  113. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  114.     , m_pLocalListener(NULL)
  115.     , m_pLocalReader(NULL)
  116.     , m_pLocalWriter(NULL)
  117. #endif // HELIX_FEATURE_NETWORK_USE_SELECT
  118. {
  119.     m_pzThreadEngine = this;
  120. #if defined( THREADS_SUPPORTED ) || defined( _UNIX_THREADED_NETWORK_IO )
  121.     HXMutex::MakeMutex(m_pMutex);
  122.     HXThread::MakeThread(m_pNetworkThread);
  123.     HXEvent::MakeEvent(m_pQuitEvent, NULL);
  124. #else
  125.     HXMutex::MakeStubMutex(m_pMutex);
  126.     HXThread::MakeStubThread(m_pNetworkThread);
  127.     HXEvent::MakeStubEvent(m_pQuitEvent, NULL);
  128. #endif
  130.     m_pNetworkThread->CreateThread(NetworkThreadMainLoop, (void*) this);
  131.     m_pSockMap = new CHXMapPtrToPtr;
  132.     
  133.     /* This is just a wrapper thread for the main application 
  134.      * It is really a hack. Will do it the right way sometime soon*/
  135. #if defined( THREADS_SUPPORTED ) || defined( _UNIX_THREADED_NETWORK_IO )
  136.     HXThread::MakeThread(m_pMainAppThread);
  137. #else
  138.     HXThread::MakeStubThread(m_pMainAppThread);
  139. #endif
  140.     m_pMainAppThread->YieldTimeSlice();
  142. #if defined(_MACINTOSH) && defined(_CARBON) && defined(THREADS_SUPPORTED)
  143.     HX_ASSERT(!m_ThreadedNetworkingCarbonTimerUPP);
  144.     HX_ASSERT(!m_ThreadedNetworkingCarbonTimerRef);
  146.     m_ThreadedNetworkingCarbonTimerUPP = ::NewEventLoopTimerUPP(
  147. (EventLoopTimerProcPtr)FauxMainAppCarbonTimer);
  148.     InstallEventLoopTimer(GetCurrentEventLoop(), 0, 50 * kEventDurationMillisecond,
  149. m_ThreadedNetworkingCarbonTimerUPP, this, &m_ThreadedNetworkingCarbonTimerRef);
  151. #endif
  152. }
  154. ThreadEngine::~ThreadEngine()
  155. {
  156.     m_pMutex->Lock();
  158.     m_bInDestructor = TRUE;
  159.     if (m_pSockMap && m_pSockMap->GetCount() > 0)
  160.     {
  161. CHXMapPtrToPtr::Iterator ndxConn = m_pSockMap->Begin();
  162. for (; ndxConn != m_pSockMap->End(); ++ndxConn)
  163. {
  164.     ThreadedConn* pConn = (ThreadedConn*) (*ndxConn);
  165.     pConn->AddRef();
  166. }
  167.     }
  169.     m_pMutex->Unlock();
  171.     if (m_pSockMap)
  172.     {
  173. //HX_ASSERT(m_pSockMap->GetCount() == 0);
  174. if (m_pSockMap->GetCount() > 0)
  175. {
  176.     CHXMapPtrToPtr::Iterator ndxConn = m_pSockMap->Begin();
  177.     for (; ndxConn != m_pSockMap->End(); ++ndxConn)
  178.     {
  179. ThreadedConn* pConn = (ThreadedConn*) (*ndxConn);
  180. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  181. if (pConn == m_pLocalReader ||
  182.     pConn == m_pLocalWriter ||
  183.     pConn == m_pLocalListener)
  184.     continue;
  185. #endif // HELIX_FEATURE_NETWORK_USE_SELECT
  186. pConn->finaldone();
  187. pConn->Release();
  188.     }
  189. }   
  190.     }
  192.     if (m_pNetworkThread)
  193.     {
  194. HXThreadMessage msg(HXMSG_QUIT, NULL, NULL);
  196. if (m_pNetworkThread->PostMessage(&msg) == HXR_OK)
  197. {
  198.       m_pQuitEvent->Wait(ALLFS);
  199. }
  200.         
  201. m_pNetworkThread->Exit(0);
  202. delete m_pNetworkThread;
  203. m_pNetworkThread = 0;
  204.     }
  206. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  207.     m_pLocalReader->Release();
  208.     m_pLocalWriter->Release();
  209.     m_pLocalListener->Release();
  210. #endif // HELIX_FEATURE_NETWORK_USE_SELECT
  212. #if defined(_MACINTOSH) && defined(_CARBON) && defined(THREADS_SUPPORTED)
  213.     ::RemoveEventLoopTimer(m_ThreadedNetworkingCarbonTimerRef);
  214.     m_ThreadedNetworkingCarbonTimerRef;
  215.     
  216.     ::DisposeEventLoopTimerUPP(m_ThreadedNetworkingCarbonTimerUPP);
  217.     m_ThreadedNetworkingCarbonTimerUPP;
  218. #endif
  220.     if (m_pMainAppThread)
  221.     {
  222. delete m_pMainAppThread;
  223. m_pMainAppThread = 0;
  224.     }
  226.     if (m_pMutex)
  227.     {
  228. delete m_pMutex;
  229. m_pMutex = 0;
  230.     }
  232.     if (m_pQuitEvent)
  233.     {
  234. delete m_pQuitEvent;
  235. m_pQuitEvent = 0;
  236.     }
  238.     if (m_pSockMap)
  239.     {
  240. m_pSockMap->RemoveAll();
  241. delete m_pSockMap;
  242. m_pSockMap = 0;
  243.     }
  244. }
  246. void 
  247. ThreadEngine::DestroyThreadEngine(void)
  248. {
  249.     if (m_pzThreadEngine)
  250.     {
  251. ThreadEngine* pThreadEngine = m_pzThreadEngine;
  252. m_pzThreadEngine = NULL;
  253. delete pThreadEngine;
  254.     }
  255. }
  257. HX_RESULT
  258. ThreadEngine::AttachSocket(ThreadedConn* pConn)
  259. {
  260.     void* pVoid = 0;
  261.     HX_RESULT theErr = HXR_OK;
  263.     m_pMutex->Lock();
  264.     if (m_pSockMap->Lookup(pConn, pVoid))
  265.     {
  266. theErr = HXR_FAIL;
  267.     }
  268.     else
  269.     {
  270. pConn->AddRef();
  271. m_pSockMap->SetAt((void*) pConn, (void*) pConn);
  272.     }
  274.     if (m_pSockMap->GetCount() == 1)
  275.     {
  276. #ifdef WIN32_PLATFORM_PSPC
  277. HXThreadMessage msg(HXMSG_ASYNC_RESUME, (void*) 200, NULL);
  278. #else
  279. HXThreadMessage msg(HXMSG_ASYNC_RESUME, (void*) 20, NULL);
  280. #endif
  281. m_pNetworkThread->PostMessage(&msg);
  282.     }
  284.     m_pMutex->Unlock();
  286.     return theErr;
  287. }
  289. HX_RESULT
  290. ThreadEngine::DetachSocket(ThreadedConn* pConn)
  291. {
  292.     void* pVoid = 0;
  293.     HX_RESULT theErr = HXR_OK;
  295.     m_pMutex->Lock();
  297.     void* blah;
  298.     if (!m_pSockMap->Lookup((void*) pConn, (void*&) blah))
  299.     {
  300. theErr = HXR_FAIL;
  301.     }
  302.     else
  303.     {
  304. /* if we are in the destructor, no need to remove from the map */
  305. if (!m_bInDestructor)
  306. {
  307.     m_pSockMap->RemoveKey((void*) pConn);
  308. }
  310. pConn->Detached();
  311. pConn->Release();
  312.     }
  314.     if (m_pSockMap->GetCount() == 0)
  315.     {
  316. HXThreadMessage msg(HXMSG_ASYNC_STOP, NULL, NULL);
  317. m_pNetworkThread->PostMessage(&msg);
  318.     }
  320.     m_pMutex->Unlock();
  322.     return theErr;
  323. }
  325. //-----------------------------------------------------------
  326. void
  327. ThreadEngine::DoAsyncCallback(ThreadedConn* pConn, IHXCallback* pCallback)
  328. {
  329.     void* pVoid = 0;
  331.     m_pMutex->Lock();
  333.     /* Fire callback ONLY if the connected socket is still active*/
  334.     if (m_pSockMap->Lookup(pConn, pVoid))
  335.     {
  336. pCallback->Func();
  337.     }
  338.     pCallback->Release();
  340.     m_pMutex->Unlock();
  341. }
  342. //-----------------------------------------------------------
  343. void
  344. ThreadEngine::DoNetworkIO(ThreadedConn* pConn)
  345. {
  346.     CHXMapPtrToPtr::Iterator ndxConn;
  348.     m_pMutex->Lock();
  350.     if (m_bInDestructor)
  351.     {
  352. goto exit;
  353.     }
  355.     if (pConn)
  356.     {
  357. void* pVoid = 0;
  358. if (m_pSockMap->Lookup(pConn, pVoid))
  359. {
  360.     pConn->DoNetworkIO();
  361. }
  362. goto exit;
  363.     }
  365.     ndxConn = m_pSockMap->Begin();
  366.     for (; ndxConn != m_pSockMap->End(); ++ndxConn)
  367.     {
  368. ThreadedConn* pConn = (ThreadedConn*) (*ndxConn);
  369. pConn->DoNetworkIO();
  370.     }
  372. exit:
  373.     m_pMutex->Unlock();
  374. }
  375. //-----------------------------------------------------------
  376. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  377. HX_RESULT 
  378. ThreadEngine::WaitforSelect()
  379. {
  380.     HX_RESULT theErr = HXR_FAIL;
  381.     ThreadedConn *pConn = NULL;
  383.     if (m_bInDestructor)
  384. pConn = m_pLocalReader;
  386.     if (m_pLocalReader && m_pLocalReader->GetActualConn())
  387. theErr = m_pLocalReader->GetActualConn()->WaitforSelect(this,pConn);
  388.     return theErr;
  389. }
  391. #endif // HELIX_FEATURE_NETWORK_USE_SELECT
  393. //-----------------------------------------------------------
  394. void*
  395. NetworkThreadMainLoop(void* pArg)
  396. {
  397.     ThreadEngine*   pEngine = (ThreadEngine*) pArg;
  398.     HXMutex*     pMutex  = pEngine->m_pMutex; 
  399.     HXThread*     pThread = pEngine->m_pNetworkThread;
  400.     HXThreadMessage msg;
  401.     BOOL     bDone   = FALSE;
  402.     UINT32     ulSleepTime = 0;
  403.     ULONG32     ulLastTimerCallback = HX_GET_TICKCOUNT();
  404.     
  405. #if defined( _WIN32 ) || defined( _UNIX_THREADED_NETWORK_IO ) || defined(THREADS_SUPPORTED)
  406.     UINT32  ulTimerId = 0;
  407. #endif /*_WIN32 || _UNIX_THREADED_NETWORK_IO */
  408.     
  409. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  410.     unsigned short iSize;
  411.     HX_RESULT theErr = HXR_FAIL;
  412.     UINT32 ulPlatformData = 0;
  413.     BOOL bRWStartup = FALSE;
  414.     BOOL bMoreToRead = FALSE;
  415.     BOOL bDebug = FALSE;
  417.     pEngine->m_pLocalListener  = new ThreadedConn(HX_TCP_SOCKET);
  418.     pEngine->m_pLocalWriter  = new ThreadedConn(HX_TCP_SOCKET);
  419.     pEngine->m_pLocalReader  = NULL;
  421.     pThread->SetPriority(THREAD_PRIORITY_ABOVE_NORMAL);
  422. //    pThread->SetPriority(THREAD_PRIORITY_HIGHEST);
  424. #if defined (_WIN32)
  425.     ulPlatformData = (UINT32)GetModuleHandle(NULL);
  426. #elif defined (_WIN16)
  427.     ulPlatformData = (UINT32)(int)g_hInstance;
  428. #endif
  430.     if (pEngine->m_pLocalListener && pEngine->m_pLocalWriter)
  431. theErr = pEngine->m_pLocalListener->listen(
  432.     LOCAL_LOOPBACK_ADDR
  433.     , LOCAL_LOOPBACK_PORT
  434.     , 4 // backlog
  435.     , 0 // blocking
  436.     , ulPlatformData // ulPlatform
  437.     );
  438.     if (SUCCEEDED(theErr))
  439.     // writer connects and reader accepts
  440. theErr = pEngine->m_pLocalWriter->connect(
  441.     LOCAL_LOOPBACK_NAME
  442.     , LOCAL_LOOPBACK_PORT
  443.     , 0 // blocking
  444.     , ulPlatformData // ulPlatform
  445.     );
  447.     if (SUCCEEDED(theErr) && !bDebug)
  448.     // writer connects and reader accepts
  449. theErr = pEngine->m_pLocalListener->accept(LOCAL_LOOPBACK_ADDR);
  451.     if (FAILED(theErr))
  452.     {
  453. if (pEngine->m_pLocalListener)
  454. {
  455.     pEngine->DetachSocket(pEngine->m_pLocalListener);
  456.     pEngine->m_pLocalListener = NULL;
  457. }
  458. if (pEngine->m_pLocalWriter)
  459. {
  460.     pEngine->DetachSocket(pEngine->m_pLocalWriter);
  461.     pEngine->m_pLocalWriter = NULL;
  462. }
  463. if (pEngine->m_pLocalReader)
  464. {
  465.     pEngine->DetachSocket(pEngine->m_pLocalReader);
  466.     pEngine->m_pLocalReader = NULL;
  467. }
  468.     }
  470.     while (!bDone)
  471.     {
  472. if (bDebug || FAILED(theErr) 
  473.     || !pEngine->m_pLocalWriter 
  474.     || !pEngine->m_pLocalReader 
  475.     || !pEngine->m_pLocalWriter->connection_really_open()
  476.     || !pEngine->m_pLocalReader->connection_really_open()
  477.     )
  478. { // process connect and accept messages, then use select
  479.     pEngine->m_pNetworkThread->m_bUseReaderWriter = FALSE;
  480.            if (ulTimerId <= 0)
  481.            {
  482.                ulSleepTime = 20;
  483.                ulTimerId = HXAsyncTimer::SetTimer( ulSleepTime, pThread );
  484.            }
  485.     if (pThread->GetMessage(&msg, 0, 0) != HXR_OK)
  486. break;
  487. }
  488. else
  489. {
  490.     if (!pEngine->m_pNetworkThread->m_bUseReaderWriter || bRWStartup)
  491.     { // process messages in queue
  492. if (!bRWStartup)
  493. {
  494.     if (ulTimerId > 0)
  495.     {
  496.        HXAsyncTimer::KillTimer(ulTimerId);
  497.        ulTimerId = 0;
  498.     }
  499.     msg.m_ulMessage = HXMSG_ASYNC_START_READERWRITER;
  500.     theErr = pEngine->m_pNetworkThread->PostMessage(&msg);
  501. }
  502. pEngine->m_pNetworkThread->m_bUseReaderWriter = TRUE;
  503. pEngine->m_pLocalWriter->set_callback(pEngine->m_pLocalWriter->get_callback()); // for post network msg
  504. pThread->SetNetworkMessageConnection(pEngine->m_pLocalWriter);
  505. bRWStartup = TRUE;
  506. if (pThread->GetMessage(&msg, 0, 0) != HXR_OK)
  507.     break;
  508.     }
  509.     else
  510.     {
  511. if (!bMoreToRead)
  512. {
  513.     if (HXR_FAIL == pEngine->WaitforSelect())
  514. break;
  515. }
  516. msg.m_ulMessage = 0;
  517. iSize = sizeof(HXThreadMessage);
  518. pEngine->m_pLocalReader->m_bNetworkIOPending = TRUE;
  519. theErr = pEngine->m_pLocalReader->read(&msg,&iSize);
  520. if (HXR_OK != theErr)
  521. {
  522.     if (HXR_WOULD_BLOCK == theErr)
  523.     {
  524. bMoreToRead = FALSE;
  525. theErr = HXR_OK;
  526. continue;
  527.     }
  528.     // reader failed, must be disconnected, return to msg loop
  529.     break;
  530. }
  531. if (iSize != sizeof(HXThreadMessage)) // fixme
  532. {
  533.     bMoreToRead = FALSE;
  534.     continue;
  535. }
  536. else
  537.     bMoreToRead = TRUE;
  538.     }
  539. }
  540. #else
  541.     while (!bDone && pThread->GetMessage(&msg, 0, 0) == HXR_OK)
  542.     {
  543. #endif // HELIX_FEATURE_NETWORK_USE_SELECT
  544. switch (msg.m_ulMessage)
  545. {
  546. #if defined( _WIN32 ) || defined( _UNIX_THREADED_NETWORK_IO ) || defined(THREADS_SUPPORTED)
  547.            case HXMSG_ASYNC_TIMER: //Look in hxmsgs.h (WM_TIMER under win32)
  548.            {
  549. #if defined(_UNIX_THREADED_NETWORK_IO) || (defined(THREADS_SUPPORTED) && defined(_UNIX))
  550.                unix_TCP::process_idle();
  551. #endif                    
  552.                ULONG32 ulCurrentTime = HX_GET_TICKCOUNT();
  553.                
  554.                if (CALCULATE_ELAPSED_TICKS(ulLastTimerCallback, 
  555.                                            ulCurrentTime) >= ulSleepTime)
  556.                {
  557.                    ulLastTimerCallback = ulCurrentTime;
  558.                    pEngine->DoNetworkIO(); 
  559.                }
  560.            }
  561.            break;
  562. #endif /* _WIN32 || _UNIX_THREADED_NETWORK_IO */
  563.            case HXMSG_ASYNC_NETWORKIO:
  564.            {
  565.                ThreadedConn* pConn = (ThreadedConn*) msg.m_pParam1; 
  566.                pEngine->DoNetworkIO(pConn);
  567.            }
  568.            break;
  569.            case HXMSG_ASYNC_CALLBACK:
  570.            {
  571.                ThreadedConn* pConn = (ThreadedConn*) msg.m_pParam1; 
  572.                IHXCallback* pCallback = (IHXCallback*) msg.m_pParam2;
  573.                pEngine->DoAsyncCallback(pConn, pCallback);
  574.            }
  575.            break;
  576. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  577.            case HXMSG_ASYNC_SETREADER_CONNECTION:
  578.            {
  579.                pEngine->m_pLocalReader = (ThreadedConn*) msg.m_pParam2; 
  580.            }
  581.            break;
  582.            case HXMSG_ASYNC_START_READERWRITER:
  583.            {
  584. pEngine->m_pNetworkThread->m_bUseReaderWriter = TRUE;
  585. bRWStartup = FALSE;
  586.            }
  587.            break;
  588. #endif //HELIX_FEATURE_NETWORK_USE_SELECT
  589.            case HXMSG_ASYNC_DETACH:
  590.            {
  591.                ThreadedConn* pConn = (ThreadedConn*) msg.m_pParam1; 
  592.                pEngine->DetachSocket(pConn); 
  593.            }
  594.            break;
  595.            case HXMSG_QUIT:
  596.            {
  597.                bDone = TRUE;
  598.            }
  599.            
  600.            break;
  601.            case HXMSG_ASYNC_RESUME:
  602. #if defined( _WIN32 ) || defined( _UNIX_THREADED_NETWORK_IO ) || defined(THREADS_SUPPORTED)
  603.            {
  604.                if (ulTimerId > 0)
  605.                {
  606.                    HXAsyncTimer::KillTimer(ulTimerId);
  607.                    ulTimerId = 0;
  608.                }
  609.                
  610.                ulSleepTime = (UINT32)(PTR_INT)msg.m_pParam1;
  611.                ulTimerId = HXAsyncTimer::SetTimer( ulSleepTime, pThread );
  612.            }
  613. #endif /* _WIN32 || _UNIX_THREADED_NETWORK_IO */
  614.            break;
  615.            
  616.            case HXMSG_ASYNC_STOP:
  617. #if defined( _WIN32 ) || defined( _UNIX_THREADED_NETWORK_IO ) || defined(THREADS_SUPPORTED)
  618.            {
  619.                if (ulTimerId > 0)
  620.                {
  621.                    HXAsyncTimer::KillTimer( ulTimerId );
  622.                    ulTimerId   = 0;
  623.                    ulSleepTime = 0;
  624.                }
  625.            }
  626. #endif /* _WIN32 || _UNIX_THREADED_NETWORK_IO */
  627.            break;
  628.            default:
  629.                pThread->DispatchMessage(&msg);
  630.                break;
  631. }
  632.     }
  633.     
  634. #if defined( _WIN32 ) || defined( _UNIX_THREADED_NETWORK_IO ) || defined(THREADS_SUPPORTED)
  635.     if (ulTimerId > 0)
  636.     {
  637.         HXAsyncTimer::KillTimer( ulTimerId );
  638.     }
  639. #endif /* _WIN32 || _UNIX_THREADED_NETWORK_IO */
  640.     
  641.     pEngine->m_pQuitEvent->SignalEvent();
  642.     
  643.     return (void*) 0;
  644. }
  647. #if defined(_MACINTOSH) && defined(_CARBON) && defined(THREADS_SUPPORTED)
  649. void ThreadEngine::FauxMainAppCarbonTimer(EventLoopTimerRef, void* /* unused */)
  650. {
  651.     // xxxbobclark this is essentially just ripped off from Greg Wright's
  652.     // similar message handling loop for Unix.
  653.     //
  654.     // It's been moved to pnio because more places than just rmacore
  655.     // (i.e. rmacleng) use the threaded implementation of networking,
  656.     // viz. rnqueue for Auto-Update. Using a Carbon Timer to get time
  657.     // periodically can luckily be implemented in pnio; it's sure to
  658.     // get actual System Time.
  659.     
  660.     ThreadEngine* pEngine = ThreadEngine::GetThreadEngine();
  661.     HX_ASSERT(pEngine);
  662.     HXCarbonThread* pMainAppThread = (HXCarbonThread*)pEngine->GetMainAppThread();
  663.     HX_ASSERT(pMainAppThread);
  664.     HXThreadMessage msg;
  665.     
  666.     while (pMainAppThread->PeekMessage(&msg, 0, 0, TRUE) == HXR_OK)
  667.     {
  668. if (msg.m_ulMessage != 0)
  669. {
  670.     ThreadedConn* pThreadedConn = (ThreadedConn*)msg.m_pParam1;
  671.     if (pThreadedConn)
  672.     {
  673. switch (msg.m_ulMessage)
  674. {
  675.     case HXMSG_ASYNC_DNS:
  676. pThreadedConn->OnAsyncDNS((BOOL)msg.m_pParam2);
  677. break;
  679.     case HXMSG_ASYNC_CONNECT:
  680. pThreadedConn->OnConnect((BOOL)msg.m_pParam2);
  681. break;
  683.     case HXMSG_ASYNC_READ:
  684. pThreadedConn->OnReadNotification();
  685. break;
  687.     case HXMSG_ASYNC_WRITE:
  688. pThreadedConn->OnWriteNotification();
  689. break;
  691.     case HXMSG_ASYNC_ACCEPT:
  692. pThreadedConn->OnAcceptNotification();
  693. break;
  695.     default:
  696. HX_ASSERT(!"Unknown message in threaded networking Carbon Timer");
  697. break;
  699. }
  700.     }
  701. }
  702.     }
  703. }
  705. #endif