home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / rtutils.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-25  |  27.8 KB  |  745 lines
  1. /*++
  2.  
  3. Copyright (c) 1995 - 1997  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     rtutils.h
  8.  
  9. Abstract:
  10.      Public declarations for the Router process  utility functions.
  11.  
  12. --*/
  13.  
  14. #ifndef __ROUTING_RTUTILS_H__
  15. #define __ROUTING_RTUTILS_H__
  16.  
  17. #ifdef __cplusplus
  18. extern "C" {
  19. #endif
  20.  
  21. //////////////////////////////////////////////////////////////////////////////
  22. //                                                                          //
  23. // TRACING FUNCTION PROTOTYPES                                              //
  24. //                                                                          //
  25. // See DOCUMENT for more information                                        //
  26. //                                                                          //
  27. //////////////////////////////////////////////////////////////////////////////
  28.  
  29. //////////////////////////////////////////////////////////////////////////////    
  30. //                                                                          //
  31. // Definitions for flags and constants                                      //
  32. //                                                                          //
  33. //////////////////////////////////////////////////////////////////////////////
  34.     
  35. #define TRACE_USE_FILE      0x00000001
  36. #define TRACE_USE_CONSOLE   0x00000002
  37. #define TRACE_NO_SYNCH      0x00000004
  38.  
  39. #define TRACE_NO_STDINFO    0x00000001
  40. #define TRACE_USE_MASK      0x00000002
  41. #define TRACE_USE_MSEC      0x00000004
  42.  
  43. #define INVALID_TRACEID     0xFFFFFFFF
  44.  
  45.  
  46. //////////////////////////////////////////////////////////////////////////////
  47. //                                                                          //
  48. // ANSI entry-points                                                        //
  49. //                                                                          //
  50. //////////////////////////////////////////////////////////////////////////////
  51.     
  52. DWORD
  53. APIENTRY
  54. TraceRegisterExA(
  55.     IN  LPCSTR      lpszCallerName,
  56.     IN  DWORD       dwFlags
  57.     );
  58.  
  59. DWORD
  60. APIENTRY
  61. TraceDeregisterA(
  62.     IN  DWORD       dwTraceID
  63.     );
  64.  
  65. DWORD
  66. APIENTRY
  67. TraceDeregisterExA(
  68.     IN  DWORD       dwTraceID,
  69.     IN  DWORD       dwFlags
  70.     );
  71.  
  72. DWORD
  73. APIENTRY
  74. TraceGetConsoleA(
  75.     IN  DWORD       dwTraceID,
  76.     OUT LPHANDLE    lphConsole
  77.     );
  78.  
  79. DWORD
  80. APIENTRY
  81. TracePrintfA(
  82.     IN  DWORD       dwTraceID,
  83.     IN  LPCSTR      lpszFormat,
  84.     IN  ...         OPTIONAL
  85.     );
  86.  
  87. DWORD
  88. APIENTRY
  89. TracePrintfExA(
  90.     IN  DWORD       dwTraceID,
  91.     IN  DWORD       dwFlags,
  92.     IN  LPCSTR      lpszFormat,
  93.     IN  ...         OPTIONAL
  94.     );
  95.  
  96. DWORD
  97. APIENTRY
  98. TraceVprintfExA(
  99.     IN  DWORD       dwTraceID,
  100.     IN  DWORD       dwFlags,
  101.     IN  LPCSTR      lpszFormat,
  102.     IN  va_list     arglist
  103.     );
  104.  
  105. DWORD
  106. APIENTRY
  107. TracePutsExA(
  108.     IN  DWORD       dwTraceID,
  109.     IN  DWORD       dwFlags,
  110.     IN  LPCSTR      lpszString
  111.     );
  112.  
  113. DWORD
  114. APIENTRY
  115. TraceDumpExA(
  116.     IN  DWORD       dwTraceID,
  117.     IN  DWORD       dwFlags,
  118.     IN  LPBYTE      lpbBytes,
  119.     IN  DWORD       dwByteCount,
  120.     IN  DWORD       dwGroupSize,
  121.     IN  BOOL        bAddressPrefix,
  122.     IN  LPCSTR      lpszPrefix
  123.     );
  124.  
  125.  
  126. //////////////////////////////////////////////////////////////////////////////
  127. //                                                                          //
  128. // ANSI entry-points macros                                                 //
  129. //                                                                          //
  130. //////////////////////////////////////////////////////////////////////////////
  131.  
  132. #define TraceRegisterA(a)               TraceRegisterExA(a,0)
  133. #define TraceVprintfA(a,b,c)            TraceVprintfExA(a,0,b,c)
  134. #define TracePutsA(a,b)                 TracePutsExA(a,0,b)
  135. #define TraceDumpA(a,b,c,d,e,f)         TraceDumpExA(a,0,b,c,d,e,f)
  136.  
  137.  
  138.  
  139. //////////////////////////////////////////////////////////////////////////////
  140. //                                                                          //
  141. // Unicode entry-points                                                     //
  142. //                                                                          //
  143. //////////////////////////////////////////////////////////////////////////////
  144.  
  145. DWORD
  146. APIENTRY
  147. TraceRegisterExW(
  148.     IN  LPCWSTR     lpszCallerName,
  149.     IN  DWORD       dwFlags
  150.     );
  151.  
  152. DWORD
  153. APIENTRY
  154. TraceDeregisterW(
  155.     IN  DWORD       dwTraceID
  156.     );
  157.  
  158. DWORD
  159. APIENTRY
  160. TraceDeregisterExW(
  161.     IN  DWORD       dwTraceID,
  162.     IN  DWORD       dwFlags
  163.     );
  164.  
  165. DWORD
  166. APIENTRY
  167. TraceGetConsoleW(
  168.     IN  DWORD       dwTraceID,
  169.     OUT LPHANDLE    lphConsole
  170.     );
  171.  
  172. DWORD
  173. APIENTRY
  174. TracePrintfW(
  175.     IN  DWORD       dwTraceID,
  176.     IN  LPCWSTR     lpszFormat,
  177.     IN  ...         OPTIONAL
  178.     );
  179.  
  180. DWORD
  181. APIENTRY
  182. TracePrintfExW(
  183.     IN  DWORD       dwTraceID,
  184.     IN  DWORD       dwFlags,
  185.     IN  LPCWSTR     lpszFormat,
  186.     IN  ...         OPTIONAL
  187.     );
  188.  
  189. DWORD
  190. APIENTRY
  191. TraceVprintfExW(
  192.     IN  DWORD       dwTraceID,
  193.     IN  DWORD       dwFlags,
  194.     IN  LPCWSTR     lpszFormat,
  195.     IN  va_list     arglist
  196.     );
  197.  
  198. DWORD
  199. APIENTRY
  200. TracePutsExW(
  201.     IN  DWORD       dwTraceID,
  202.     IN  DWORD       dwFlags,
  203.     IN  LPCWSTR     lpszString
  204.     );
  205.  
  206. DWORD
  207. APIENTRY
  208. TraceDumpExW(
  209.     IN  DWORD       dwTraceID,
  210.     IN  DWORD       dwFlags,
  211.     IN  LPBYTE      lpbBytes,
  212.     IN  DWORD       dwByteCount,
  213.     IN  DWORD       dwGroupSize,
  214.     IN  BOOL        bAddressPrefix,
  215.     IN  LPCWSTR     lpszPrefix
  216.     );
  217.  
  218.  
  219. //////////////////////////////////////////////////////////////////////////////
  220. //                                                                          //
  221. // Unicode entry-points macros                                              //
  222. //                                                                          //
  223. //////////////////////////////////////////////////////////////////////////////
  224.  
  225. #define TraceRegisterW(a)               TraceRegisterExW(a,0)
  226. #define TraceVprintfW(a,b,c)            TraceVprintfExW(a,0,b,c)
  227. #define TracePutsW(a,b)                 TracePutsExW(a,0,b)
  228. #define TraceDumpW(a,b,c,d,e,f)         TraceDumpExW(a,0,b,c,d,e,f)
  229.  
  230.  
  231.  
  232. //////////////////////////////////////////////////////////////////////////////
  233. //                                                                          //
  234. // Code-page dependent entry-point macros                                   //
  235. //                                                                          //
  236. //////////////////////////////////////////////////////////////////////////////
  237.  
  238. #ifdef UNICODE
  239. #define TraceRegister           TraceRegisterW
  240. #define TraceDeregister         TraceDeregisterW
  241. #define TraceDeregisterEx       TraceDeregisterExW
  242. #define TraceGetConsole         TraceGetConsoleW
  243. #define TracePrintf             TracePrintfW
  244. #define TraceVprintf            TraceVprintfW
  245. #define TracePuts               TracePutsW
  246. #define TraceDump               TraceDumpW
  247. #define TraceRegisterEx         TraceRegisterExW
  248. #define TracePrintfEx           TracePrintfExW
  249. #define TraceVprintfEx          TraceVprintfExW
  250. #define TracePutsEx             TracePutsExW
  251. #define TraceDumpEx             TraceDumpExW
  252. #else
  253. #define TraceRegister           TraceRegisterA
  254. #define TraceDeregister         TraceDeregisterA
  255. #define TraceDeregisterEx       TraceDeregisterExA
  256. #define TraceGetConsole         TraceGetConsoleA
  257. #define TracePrintf             TracePrintfA
  258. #define TraceVprintf            TraceVprintfA
  259. #define TracePuts               TracePutsA
  260. #define TraceDump               TraceDumpA
  261. #define TraceRegisterEx         TraceRegisterExA
  262. #define TracePrintfEx           TracePrintfExA
  263. #define TraceVprintfEx          TraceVprintfExA
  264. #define TracePutsEx             TracePutsExA
  265. #define TraceDumpEx             TraceDumpExA
  266. #endif
  267.  
  268.  
  269.  
  270. //////////////////////////////////////////////////////////////////////////////
  271. //                                                                          //
  272. // EVENT LOGGING FUNCTION PROTOTYPES                                        //
  273. //                                                                          //
  274. //////////////////////////////////////////////////////////////////////////////
  275.  
  276. //////////////////////////////////////////////////////////////////////////////
  277. //                                                                          //
  278. // ANSI prototypes                                                          //
  279. //                                                                          //
  280. //////////////////////////////////////////////////////////////////////////////
  281.  
  282.  
  283. VOID
  284. APIENTRY
  285. LogErrorA(
  286.     IN DWORD    dwMessageId,
  287.     IN DWORD    cNumberOfSubStrings,
  288.     IN LPSTR   *plpwsSubStrings,
  289.     IN DWORD    dwErrorCode
  290. );
  291.  
  292. VOID
  293. APIENTRY
  294. LogEventA(
  295.     IN DWORD   wEventType,
  296.     IN DWORD   dwMessageId,
  297.     IN DWORD   cNumberOfSubStrings,
  298.     IN LPSTR  *plpwsSubStrings
  299. );
  300.  
  301.  
  302. //////////////////////////////////////////////////////////////////////////////
  303. //                                                                          //
  304. // Unicode prototypes                                                       //
  305. //                                                                          //
  306. //////////////////////////////////////////////////////////////////////////////
  307.  
  308. VOID
  309. LogErrorW(
  310.     IN DWORD    dwMessageId,
  311.     IN DWORD    cNumberOfSubStrings,
  312.     IN LPWSTR  *plpwsSubStrings,
  313.     IN DWORD    dwErrorCode
  314. );
  315.  
  316. VOID
  317. LogEventW(
  318.     IN DWORD   wEventType,
  319.     IN DWORD   dwMessageId,
  320.     IN DWORD   cNumberOfSubStrings,
  321.     IN LPWSTR *plpwsSubStrings
  322. );
  323.  
  324.  
  325. #ifdef UNICODE
  326. #define LogError                LogErrorW
  327. #define LogEvent                LogEventW
  328. #else
  329. #define LogError                LogErrorA
  330. #define LogEvent                LogEventA
  331. #endif
  332.  
  333.  
  334. //////////////////////////////////////////////////////////////////////////////
  335. //                                                                          //
  336. // The following functions allow the caller to specify the event source.    //
  337. //                                                                          //
  338. // Call RouterLogRegister with the strings which would be passed to         //
  339. // RegisterEventSource; this returns a handle which can be passed           //
  340. // to the functions RouterLogEvent and RouterLogEventData.                  //
  341. //                                                                          //
  342. // Call RouterLogDeregister to close the handle.                            //
  343. //                                                                          //
  344. // Macros are provided for the different kinds of event log entrys:         //
  345. //  RouterLogError          logs an error (EVENTLOG_ERROR_TYPE)             //
  346. //  RouterLogWarning        logs a warning (EVENTLOG_WARNING_TYPE)          //
  347. //  RouterLogInformation    logs information (EVENTLOG_INFORMATION_TYPE)    //
  348. //                                                                          //
  349. //////////////////////////////////////////////////////////////////////////////
  350.  
  351. //////////////////////////////////////////////////////////////////////////////
  352. //                                                                          //
  353. // ANSI prototypes                                                          //
  354. //                                                                          //
  355. //////////////////////////////////////////////////////////////////////////////
  356.  
  357. HANDLE
  358. RouterLogRegisterA(
  359.     LPCSTR lpszSource
  360.     );
  361.  
  362. VOID
  363. RouterLogDeregisterA(
  364.     HANDLE hLogHandle
  365.     );
  366.  
  367. VOID
  368. RouterLogEventA(
  369.     IN HANDLE hLogHandle,
  370.     IN DWORD dwEventType,
  371.     IN DWORD dwMessageId,
  372.     IN DWORD dwSubStringCount,
  373.     IN LPSTR *plpszSubStringArray,
  374.     IN DWORD dwErrorCode
  375.     );
  376.  
  377. VOID
  378. RouterLogEventDataA(
  379.     IN HANDLE hLogHandle,
  380.     IN DWORD dwEventType,
  381.     IN DWORD dwMessageId,
  382.     IN DWORD dwSubStringCount,
  383.     IN LPSTR *plpszSubStringArray,
  384.     IN DWORD dwDataBytes,
  385.     IN LPBYTE lpDataBytes
  386.     );
  387.  
  388. VOID
  389. RouterLogEventStringA(
  390.     IN HANDLE hLogHandle,
  391.     IN DWORD dwEventType,
  392.     IN DWORD dwMessageId,
  393.     IN DWORD dwSubStringCount,
  394.     IN LPSTR *plpszSubStringArray,
  395.     IN DWORD dwErrorCode,
  396.     IN DWORD dwErrorIndex
  397.     );
  398.  
  399. DWORD
  400. RouterGetErrorStringA(
  401.     IN  DWORD   dwErrorCode,
  402.     OUT LPSTR * lplpszErrorString
  403.     );
  404.  
  405. #define RouterLogErrorA(h,msg,count,array,err) \
  406.         RouterLogEventA(h,EVENTLOG_ERROR_TYPE,msg,count,array,err)
  407. #define RouterLogWarningA(h,msg,count,array,err) \
  408.         RouterLogEventA(h,EVENTLOG_WARNING_TYPE,msg,count,array,err)
  409. #define RouterLogInformationA(h,msg,count,array,err) \
  410.         RouterLogEventA(h,EVENTLOG_INFORMATION_TYPE,msg,count,array,err)
  411.  
  412. #define RouterLogErrorDataA(h,msg,count,array,c,buf) \
  413.         RouterLogEventDataA(h,EVENTLOG_ERROR_TYPE,msg,count,array,c,buf)
  414. #define RouterLogWarningDataA(h,msg,count,array,c,buf) \
  415.         RouterLogEventDataA(h,EVENTLOG_WARNING_TYPE,msg,count,array,c,buf)
  416. #define RouterLogInformationDataA(h,msg,count,array,c,buf) \
  417.         RouterLogEventDataA(h,EVENTLOG_INFORMATION_TYPE,msg,count,array,c,buf)
  418.  
  419. #define RouterLogErrorStringA(h,msg,count,array,err,index) \
  420.         RouterLogEventStringA(h,EVENTLOG_ERROR_TYPE,msg,count,array, err,index)
  421. #define RouterLogWarningStringA(h,msg,count,array,err,index) \
  422.         RouterLogEventStringA(h,EVENTLOG_WARNING_TYPE,msg,count,array,err,index)
  423. #define RouterLogInformationStringA(h,msg,count,array, err,index) \
  424.         RouterLogEventStringA(h,EVENTLOG_INFORMATION_TYPE,msg,count,array,err,\
  425.                               index)
  426.  
  427.  
  428. //////////////////////////////////////////////////////////////////////////////
  429. //                                                                          //
  430. // Unicode prototypes                                                       //
  431. //                                                                          //
  432. //////////////////////////////////////////////////////////////////////////////
  433.  
  434. HANDLE
  435. RouterLogRegisterW(
  436.     LPCWSTR lpszSource
  437.     );
  438.  
  439. VOID
  440. RouterLogDeregisterW(
  441.     HANDLE hLogHandle
  442.     );
  443.  
  444. VOID
  445. RouterLogEventW(
  446.     IN HANDLE hLogHandle,
  447.     IN DWORD dwEventType,
  448.     IN DWORD dwMessageId,
  449.     IN DWORD dwSubStringCount,
  450.     IN LPWSTR *plpszSubStringArray,
  451.     IN DWORD dwErrorCode
  452.     );
  453.  
  454. VOID
  455. RouterLogEventDataW(
  456.     IN HANDLE hLogHandle,
  457.     IN DWORD dwEventType,
  458.     IN DWORD dwMessageId,
  459.     IN DWORD dwSubStringCount,
  460.     IN LPWSTR *plpszSubStringArray,
  461.     IN DWORD dwDataBytes,
  462.     IN LPBYTE lpDataBytes
  463.     );
  464.  
  465. VOID
  466. RouterLogEventStringW(
  467.     IN HANDLE hLogHandle,
  468.     IN DWORD dwEventType,
  469.     IN DWORD dwMessageId,
  470.     IN DWORD dwSubStringCount,
  471.     IN LPWSTR *plpszSubStringArray,
  472.     IN DWORD dwErrorCode,
  473.     IN DWORD dwErrorIndex
  474.     );
  475.  
  476. DWORD
  477. RouterGetErrorStringW(
  478.     IN  DWORD    dwErrorCode,
  479.     OUT LPWSTR * lplpwszErrorString
  480.     );
  481.  
  482.  
  483. #define RouterLogErrorW(h,msg,count,array,err) \
  484.         RouterLogEventW(h,EVENTLOG_ERROR_TYPE,msg,count,array,err)
  485. #define RouterLogWarningW(h,msg,count,array,err) \
  486.         RouterLogEventW(h,EVENTLOG_WARNING_TYPE,msg,count,array,err)
  487. #define RouterLogInformationW(h,msg,count,array,err) \
  488.         RouterLogEventW(h,EVENTLOG_INFORMATION_TYPE,msg,count,array,err)
  489.  
  490. #define RouterLogErrorDataW(h,msg,count,array,c,buf) \
  491.         RouterLogEventDataW(h,EVENTLOG_ERROR_TYPE,msg,count,array,c,buf)
  492. #define RouterLogWarningDataW(h,msg,count,array,c,buf) \
  493.         RouterLogEventDataW(h,EVENTLOG_WARNING_TYPE,msg,count,array,c,buf)
  494. #define RouterLogInformationDataW(h,msg,count,array,c,buf) \
  495.         RouterLogEventDataW(h,EVENTLOG_INFORMATION_TYPE,msg,count,array,c,buf)
  496.  
  497. #define RouterLogErrorStringW(h,msg,count,array,err,index) \
  498.         RouterLogEventStringW(h,EVENTLOG_ERROR_TYPE,msg,count,array,err,index)
  499. #define RouterLogWarningStringW(h,msg,count,array,err,index) \
  500.         RouterLogEventStringW(h,EVENTLOG_WARNING_TYPE,msg,count,array,err,index)
  501. #define RouterLogInformationStringW(h,msg,count,array,err,index) \
  502.         RouterLogEventStringW(h,EVENTLOG_INFORMATION_TYPE,msg,count,array,err,\
  503.                               index)
  504.  
  505.  
  506. #ifdef UNICODE
  507. #define RouterLogRegister           RouterLogRegisterW
  508. #define RouterLogDeregister         RouterLogDeregisterW
  509. #define RouterLogEvent              RouterLogEventW
  510. #define RouterLogError              RouterLogErrorW
  511. #define RouterLogWarning            RouterLogWarningW
  512. #define RouterLogInformation        RouterLogInformationW
  513. #define RouterLogEventData          RouterLogEventDataW
  514. #define RouterLogErrorData          RouterLogErrorDataW
  515. #define RouterLogWarningData        RouterLogWarningDataW
  516. #define RouterLogInformationData    RouterLogInformationDataW
  517. #define RouterLogEventString        RouterLogEventStringW
  518. #define RouterLogErrorString        RouterLogErrorStringW
  519. #define RouterLogWarningString      RouterLogWarningStringW
  520. #define RouterLogInformationString  RouterLogInformationStringW
  521. #define RouterGetErrorString        RouterGetErrorStringW        
  522. #
  523. #else
  524. #define RouterLogRegister           RouterLogRegisterA
  525. #define RouterLogDeregister         RouterLogDeregisterA
  526. #define RouterLogEvent              RouterLogEventA
  527. #define RouterLogError              RouterLogErrorA
  528. #define RouterLogWarning            RouterLogWarningA
  529. #define RouterLogInformation        RouterLogInformationA
  530. #define RouterLogEventData          RouterLogEventDataA
  531. #define RouterLogErrorData          RouterLogErrorDataA
  532. #define RouterLogWarningData        RouterLogWarningDataA
  533. #define RouterLogInformationData    RouterLogInformationDataA
  534. #define RouterLogEventString        RouterLogEventStringA
  535. #define RouterLogErrorString        RouterLogErrorStringA
  536. #define RouterLogWarningString      RouterLogWarningStringA
  537. #define RouterLogInformationString  RouterLogInformationStringA
  538. #define RouterGetErrorString        RouterGetErrorStringA        
  539. #endif
  540.  
  541.  
  542.  
  543.  
  544. //////////////////////////////////////////////////////////////////////////////
  545. //                                                                          //
  546. // WORKER THREAD POOL FUNCTIONS                                             //
  547. //                                                                          //
  548. //////////////////////////////////////////////////////////////////////////////
  549.  
  550. //////////////////////////////////////////////////////////////////////////////
  551. //                                                                          //            
  552. // definition of worker function passed in QueueWorkItem API                //
  553. //                                                                          //
  554. //////////////////////////////////////////////////////////////////////////////
  555.             
  556. typedef VOID (APIENTRY * WORKERFUNCTION)(PVOID);
  557.  
  558.  
  559. //////////////////////////////////////////////////////////////////////////////
  560. //                                                                          //            
  561. //  Function: Queues the supplied work item in the work queue.              //
  562. //                                                                          //
  563. //  functionptr: function to be called must be of WORKERFUNCTION type       //
  564. //  context:     opaque ptr                                                 //
  565. //  serviceinalertablethread: if TRUE gets scheduled in                     //
  566. //               a alertably waiting thread that never dies                 //
  567. //  Returns:  0 (success)                                                   //
  568. //            Win32 error codes for cases like out of memory                //
  569. //                                                                          //
  570. //////////////////////////////////////////////////////////////////////////////        
  571.  
  572. DWORD
  573. APIENTRY
  574. QueueWorkItem(
  575.     IN WORKERFUNCTION functionptr,
  576.     IN PVOID context,
  577.     IN BOOL serviceinalertablethread
  578.     );
  579.  
  580.  
  581. //////////////////////////////////////////////////////////////////////////////
  582. //                                                                          //
  583. // Function:        Associates file handle with the completion port (all    //
  584. //                  asynchronous i/o on this handle will be queued to       //
  585. //                    the completion port)                                    //
  586. //                                                                          //
  587. // FileHandle:        File handle to be associated with completion port       //
  588. //                                                                          //
  589. // CompletionProc:  Procedure to be called when io associated with the file //
  590. //                    handle completes. This function will be executed in     //
  591. //                    the context of non-alertable worker thread              //
  592. //                                                                          //
  593. //////////////////////////////////////////////////////////////////////////////
  594.  
  595. DWORD
  596. APIENTRY
  597. SetIoCompletionProc (
  598.     IN HANDLE                            FileHandle,
  599.     IN LPOVERLAPPED_COMPLETION_ROUTINE    CompletionProc
  600.     );
  601.  
  602.  
  603.  
  604. //////////////////////////////////////////////////////////////////////////////
  605. //                                                                          //
  606. // The following defines are included here as a hint on how the worker      //
  607. // thread pool is managed:                                                  //
  608. //                                                                          // 
  609. // There are NUM_ALERTABLE_THREADS permanent threads that never quit and    //
  610. // wait alertably on a alertable worker queue.  These threads should solely //
  611. // be used for work items that intiate asyncronous operation (file io,      //
  612. // waitable timer) that ABSOLUTELY require APCs to complete (preferable     //
  613. // method for IO is the usage of completio port API)                        //
  614. //                                                                          //
  615. // There is a pool of the threads that wait on completion port              //
  616. // that used both for processing of IO and non-IO related work items        //
  617. //                                                                          // 
  618. // The minimum number of threads is Number of processors                    //
  619. // The maximum number of threads is MAX_WORKER_THREADS                      //
  620. //                                                                          //
  621. // A new thread is created if worker queue has not been served for more     //
  622. // that WORK_QUEUE_TIMEOUT                                                  //
  623. // The existing thread will be shut down if it is not used for more than    //
  624. // THREAD_IDLE_TIMEOUT                                                      //
  625. //                                                                          //
  626. // Note that worker threads age guaranteed to be alive for at least         //
  627. // THREAD_IDLE_TIMEOUT after the last work item is executed.  This timeout  //
  628. // is chosen such that bulk of IO request could be completed before it      //
  629. // expires.  If it is not enough for your case, use alertable thread with   //
  630. // APC, or create your own thread.                                          //
  631. //                                                                          //
  632. // Note: changing these flags will not change anything.                     //
  633. //                                                                          //
  634. //////////////////////////////////////////////////////////////////////////////
  635.  
  636.  
  637. //////////////////////////////////////////////////////////////////////////////
  638. //                                                                          //
  639. // Number of alertable threads                                              //
  640. //                                                                          //
  641. //////////////////////////////////////////////////////////////////////////////
  642.  
  643. #define NUM_ALERTABLE_THREADS        2
  644.  
  645. //////////////////////////////////////////////////////////////////////////////
  646. //                                                                          //
  647. // Max number of threads at any time                                        //
  648. //                                                                          //
  649. //////////////////////////////////////////////////////////////////////////////
  650.  
  651. #define MAX_WORKER_THREADS          10
  652.  
  653. //////////////////////////////////////////////////////////////////////////////
  654. //                                                                          //
  655. // Time that the worker queue is not served before starting new thread      //
  656. //                                                                          //
  657. //////////////////////////////////////////////////////////////////////////////
  658.  
  659. #define WORK_QUEUE_TIMEOUT            1 //sec
  660.  
  661. //////////////////////////////////////////////////////////////////////////////
  662. //                                                                          //
  663. // Time that thread has to be idle before exiting                           //
  664. //                                                                          //
  665. //////////////////////////////////////////////////////////////////////////////
  666.  
  667. #define THREAD_IDLE_TIMEOUT            10 //sec
  668.  
  669.  
  670. //////////////////////////////////////////////////////////////////////////////
  671. //                                                                          //
  672. // ROUTER ASSERT DECLARATION                                                //
  673. //                                                                          //
  674. //////////////////////////////////////////////////////////////////////////////
  675.  
  676. VOID
  677. RouterAssert(
  678.     IN PSTR pszFailedAssertion,
  679.     IN PSTR pszFileName,
  680.     IN DWORD dwLineNumber,
  681.     IN PSTR pszMessage OPTIONAL
  682.     );
  683.  
  684.  
  685. #if DBG
  686. #define RTASSERT(exp) \
  687.         if (!(exp)) \
  688.             RouterAssert(#exp, __FILE__, __LINE__, NULL)
  689. #define RTASSERTMSG(msg, exp) \
  690.         if (!(exp)) \
  691.             RouterAssert(#exp, __FILE__, __LINE__, msg)
  692. #else
  693. #define RTASSERT(exp)
  694. #define RTASSERTMSG(msg, exp)
  695. #endif
  696.  
  697. //////////////////////////////////////////////////////////////////////////////
  698. //                                                                          //
  699. // REGISTRY CONFIGURATION FUNCTIONS                                         //
  700. //                                                                          //
  701. // The following definitions are used to read configuration information     //
  702. // about installed protocols.                                               //
  703. //                                                                          //
  704. // Call 'MprSetupProtocolEnum' to enumerate the routing-protocols           //
  705. // for transport 'dwTransportId'. This fills an array with entries          //
  706. // of type 'MPR_PROTOCOL_0'.                                                //
  707. //                                                                          //
  708. // The array loaded can be destroyed by calling 'MprSetupProtocolFree'.     //
  709. //                                                                          //
  710. //////////////////////////////////////////////////////////////////////////////
  711.  
  712. #define MAX_PROTOCOL_NAME_LEN                           40
  713. #define MAX_PROTOCOL_DLL_LEN                            48
  714.  
  715. typedef struct _MPR_PROTOCOL_0 {
  716.  
  717.     DWORD       dwProtocolId;                           // e.g. IP_RIP
  718.     WCHAR       wszProtocol[MAX_PROTOCOL_NAME_LEN+1];   // e.g. "IPRIP"
  719.     WCHAR       wszDLLName[MAX_PROTOCOL_DLL_LEN+1];     // e.g. "iprip2.dll"
  720.  
  721. } MPR_PROTOCOL_0;
  722.  
  723.  
  724. DWORD APIENTRY
  725. MprSetupProtocolEnum(
  726.     IN      DWORD                   dwTransportId,
  727.     OUT     LPBYTE*                 lplpBuffer,         // MPR_PROTOCOL_0
  728.     OUT     LPDWORD                 lpdwEntriesRead
  729.     );
  730.  
  731.  
  732. DWORD APIENTRY
  733. MprSetupProtocolFree(
  734.     IN      LPVOID                  lpBuffer
  735.     );
  736.  
  737.  
  738. #ifdef __cplusplus
  739. }
  740. #endif
  741.  
  742. #endif // ___ROUTING_RTUTILS_H__
  743.  
  744.  
  745.