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

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

Symbian

开发平台：

C/C++

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