home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / k95source / ckosyn.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  89KB  |  4,034 lines
  1. /* C K O S Y N  --  Kermit synchronization functions for OS/2 and NT systems */
  2.  
  3. /*
  4.   Author:
  5.     Jeffrey Altman (jaltman@secure-endpoints.com),
  6.       Secure Endpoints Inc., New York City.
  7.  
  8.   Copyright (C) 1996,2004 Trustees of Columbia University in the City of New
  9.   York.
  10. */
  11.  
  12. /*
  13.  * =============================#includes=====================================
  14.  */
  15.  
  16. #include "ckcdeb.h"             /* Typedefs, debug formats, etc */
  17. #include "ckcker.h"             /* Kermit definitions */
  18. #include "ckuusr.h"             /* needed for Priority definitions */
  19. #include <signal.h>
  20.  
  21. #ifdef NT
  22. #include <windows.h>
  23. #include <tapi.h>
  24. #include "cknalm.h"
  25. #include "ckntap.h"
  26.  
  27. #include "ckocon.h"
  28.  
  29. HANDLE hmtxKeyStroke[VNUM] = {(HANDLE) 0,(HANDLE) 0,(HANDLE) 0}  ;
  30. HANDLE hmtxLocalEcho = (HANDLE) 0 ;
  31. HANDLE hmtxTCPIP = (HANDLE) 0 ;
  32. HANDLE hmtxComm = (HANDLE) 0;
  33. #ifdef NETCMD
  34. HANDLE hmtxNetCmd = (HANDLE) 0 ;
  35. #endif /* NETCMD */
  36. HANDLE hmtxKeyboard  = (HANDLE) 0 ;
  37. HANDLE hmtxAlarm = (HANDLE) 0 ;
  38. HANDLE hmtxScreen = (HANDLE) 0 ;
  39. HANDLE hmtxVscrn[VNUM] = { (HANDLE) 0,(HANDLE) 0, (HANDLE) 0} ;
  40. HANDLE hmtxVscrnDirty[VNUM] = { (HANDLE) 0, (HANDLE) 0, (HANDLE) 0 } ;
  41. HANDLE hmtxConnectMode = (HANDLE) 0 ;
  42. HANDLE hmtxDebug = (HANDLE) 0;
  43. HANDLE hmtxTelnet = (HANDLE) 0;
  44. HANDLE hmtxSerial = (HANDLE) 0 ;
  45. HANDLE hmtxThreadMgmt = (HANDLE) 0 ;
  46. #ifdef CK_SSL
  47. HANDLE hmtxSSL = (HANDLE) 0;
  48. #endif /* CK_SSL */
  49.  
  50. HANDLE hevEventAvail[VNUM] = {(HANDLE) 0,(HANDLE) 0,(HANDLE) 0} ;
  51. HANDLE hevLocalEchoAvail = (HANDLE) 0 ;
  52. #ifdef NETCMD
  53. HANDLE hevNetCmdAvail = (HANDLE) 0 ;
  54. #endif
  55. HANDLE hevAlarm = (HANDLE) 0 ;
  56. HANDLE hevTerminalMode = (HANDLE) 0 ;
  57. HANDLE hevCommandMode = (HANDLE) 0 ;
  58. HANDLE hevRdComWrtScrThread = (HANDLE) 0 ;
  59. HANDLE hevConKbdHandlerThread = (HANDLE) 0 ;
  60. HANDLE hevTermScrnUpdThread = (HANDLE) 0 ;
  61. HANDLE hevRdComWrtScrThreadDown = (HANDLE) 0 ;
  62. HANDLE hevConKbdHandlerThreadDown = (HANDLE) 0 ;
  63. HANDLE hevTermScrnUpdThreadDown = (HANDLE) 0 ;
  64. HANDLE hevKeyMapInit = (HANDLE) 0 ;
  65. HANDLE hevKbdThread = (HANDLE) 0 ;
  66. HANDLE hevCtrlC[4]      = {(HANDLE) 0,(HANDLE) 0,(HANDLE) 0,(HANDLE) 0} ;
  67. HANDLE hevAlarmSig[4]   = {(HANDLE) 0,(HANDLE) 0,(HANDLE) 0,(HANDLE) 0} ;
  68.  
  69. UINT htimAlarm = (UINT) 0 ;
  70. UINT htimVscrn[VNUM] = {(UINT) 0, (UINT) 0, (UINT) 0} ;
  71.  
  72. HANDLE hevVscrnTimer[VNUM] = { (HANDLE) 0, (HANDLE) 0,(HANDLE) 0 } ;
  73. HANDLE hevVscrnDirty[VNUM] = { (HANDLE) 0, (HANDLE) 0,(HANDLE) 0 } ;
  74.  
  75. HANDLE hevVscrnUpdate[VNUM][2] = {{(HANDLE) NULL, (HANDLE) NULL},
  76.    {(HANDLE) NULL, (HANDLE) NULL},
  77.    {(HANDLE) NULL, (HANDLE) NULL}};
  78. HANDLE hmuxCtrlC[4][2] = { { (HANDLE) NULL, (HANDLE) NULL },
  79.                           { (HANDLE) NULL, (HANDLE) NULL },
  80.                           { (HANDLE) NULL, (HANDLE) NULL },
  81.                           { (HANDLE) NULL, (HANDLE) NULL } } ;
  82. HANDLE hmuxAlarmSig[4][2] = { { (HANDLE) NULL, (HANDLE) NULL },
  83.                           { (HANDLE) NULL, (HANDLE) NULL },
  84.                           { (HANDLE) NULL, (HANDLE) NULL },
  85.                           { (HANDLE) NULL, (HANDLE) NULL } } ;
  86. HANDLE hmuxCtrlCAlarmSig[3] = { (HANDLE) NULL, (HANDLE) NULL, (HANDLE) NULL } ;
  87.  
  88. #ifdef CK_TAPI
  89. HANDLE hevTAPIConnect = (HANDLE) 0 ;
  90. HANDLE hevTAPIAnswer = (HANDLE) 0 ;
  91. HANDLE hevTAPIInit = (HANDLE) 0 ;
  92. #endif /* CK_TAPI */
  93.  
  94. HANDLE hevRichEditInit = (HANDLE) 0;
  95. HANDLE hevRichEditClose = (HANDLE) 0;
  96. HANDLE hmtxRichEdit = (HANDLE) 0 ;
  97. #else /* NT */
  98. #ifdef OS2MOUSE
  99. #define INCL_MOU
  100. #endif /* OS2MOUSE */
  101.  
  102. #define INCL_WIN
  103. #define INCL_VIO
  104. #define INCL_ERRORS
  105. #define INCL_DOSPROCESS
  106. #define INCL_DOSSEMAPHORES
  107. #define INCL_DOSDEVIOCTL
  108. #define INCL_WINCLIPBOARD
  109. #define INCL_DOSDATETIME
  110. #include <os2.h>
  111. #undef COMMENT                /* COMMENT is defined in os2.h */
  112.  
  113. #include "ckocon.h"
  114.  
  115. HMTX hmtxKeyStroke[VNUM] = {(HMTX) 0,(HMTX) 0,(HMTX) 0} ;
  116. #ifdef NETCMD
  117. HMTX hmtxNetCmd = (HMTX) 0 ;
  118. #endif
  119. HMTX hmtxLocalEcho = (HMTX) 0 ;
  120. HMTX hmtxTCPIP = (HMTX) 0 ;
  121. HMTX hmtxComm = (HMTX) 0 ;
  122. HMTX hmtxKeyboard  = (HMTX) 0 ;
  123. HMTX hmtxAlarm = (HMTX) 0 ;
  124. HMTX hmtxScreen = (HMTX) 0 ;
  125. HMTX hmtxVscrn[VNUM] = { (HMTX) 0, (HMTX) 0, (HMTX) 0}  ;
  126. HMTX hmtxVscrnDirty[VNUM] = { (HMTX) 0, (HMTX) 0, (HMTX) 0} ;
  127. HMTX hmtxConnectMode = (HMTX) 0 ;
  128. HMTX hmtxDebug = (HMTX) 0 ;
  129. HMTX hmtxTelnet = (HMTX) 0 ;
  130. HMTX hmtxThreadMgmt = (HMTX) 0 ;
  131. #ifdef CK_SSL
  132. HMTX hmtxSSL = (HMTX) 0;
  133. #endif /* CK_SSL */
  134.  
  135. HEV  hevEventAvail[VNUM] = {(HEV) 0,(HEV) 0,(HEV) 0} ;
  136. HEV  hevLocalEchoAvail = (HEV) 0 ;
  137. #ifdef NETCMD
  138. HEV  hevNetCmdAvail = (HEV) 0 ;
  139. #endif
  140. HEV  hevAlarm = (HEV) 0 ;
  141. HEV  hevTerminalMode = (HEV) 0 ;
  142. HEV  hevCommandMode = (HEV) 0 ;
  143. HEV  hevRdComWrtScrThread = (HEV) 0 ;
  144. HEV  hevConKbdHandlerThread = (HEV) 0 ;
  145. HEV  hevTermScrnUpdThread = (HEV) 0 ;
  146. HEV  hevRdComWrtScrThreadDown = (HEV) 0 ;
  147. HEV  hevConKbdHandlerThreadDown = (HEV) 0 ;
  148. HEV  hevTermScrnUpdThreadDown = (HEV) 0 ;
  149. HEV  hevKeyMapInit = (HEV) 0 ;
  150. HEV  hevKbdThread = (HEV) 0 ;
  151. HEV  hevVscrnTimer[VNUM] = { (HEV) 0, (HEV) 0, (HEV) 0 } ;
  152. HEV  hevVscrnDirty[VNUM] = { (HEV) 0, (HEV) 0, (HEV) 0 } ;
  153. HEV  hevCtrlC[4]   = { (HEV) 0,(HEV) 0,(HEV) 0,(HEV) 0 } ;
  154. HEV  hevAlarmSig[4] = { (HEV) 0,(HEV) 0,(HEV) 0,(HEV) 0 } ;
  155.  
  156. HTIMER htimAlarm = (HTIMER) 0 ;
  157. HTIMER htimVscrn[VNUM] = {(HTIMER) 0,(HTIMER) 0,(HTIMER) 0} ;
  158.  
  159. HMUX hmuxVscrnUpdate[VNUM] = {(HMUX) 0,(HMUX) 0,(HMUX) 0} ;
  160. HMUX hmuxCtrlC[4]    = { (HMUX) 0,(HMUX) 0,(HMUX) 0,(HMUX) 0 } ;
  161. HMUX hmuxAlarmSig[4] = { (HMUX) 0,(HMUX) 0,(HMUX) 0,(HMUX) 0 } ;
  162. HMUX hmuxCtrlCAlarmSig = (HMUX) 0 ;
  163. #endif /* NT */
  164.  
  165. int CtrlCCount = -1 ;
  166. #define MAXCTRLC 3
  167. int AlarmSigCount = -1 ;
  168. #define MAXALARMSIG 3
  169.  
  170.  
  171. /* Semaphore functions */
  172.  
  173. APIRET
  174. CreateKeyStrokeMutex( BOOL owned )
  175. {
  176.     int j ;
  177.  
  178.     for ( j=0; j<VNUM ; j++ )
  179.     {
  180.         if ( hmtxKeyStroke[j] )
  181. #ifdef NT
  182.           CloseHandle( hmtxKeyStroke[j] ) ;
  183.         hmtxKeyStroke[j] = CreateMutex( NULL, owned, NULL ) ;
  184.         if (hmtxKeyStroke[j] == NULL)
  185.           return GetLastError();
  186. #else /* not NT */
  187.         DosCloseMutexSem( hmtxKeyStroke[j] ) ;
  188.         DosCreateMutexSem( NULL, &hmtxKeyStroke[j], 0, owned ) ;
  189. #endif /* NT */
  190.     }
  191.     return 0;
  192. }
  193.  
  194. APIRET
  195. RequestKeyStrokeMutex( int vmode, ULONG timo )
  196. {
  197. #ifdef NT
  198.     DWORD rc = 0 ;
  199.  
  200.     rc = WaitForSingleObjectEx( hmtxKeyStroke[vmode], timo, TRUE ) ;
  201.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  202. #else /* not NT */
  203.     return DosRequestMutexSem( hmtxKeyStroke[vmode], timo ) ;
  204. #endif /* NT */
  205. }
  206.  
  207. APIRET
  208. ReleaseKeyStrokeMutex( int vmode )
  209. {
  210. #ifdef NT
  211.     BOOL rc = 0 ;
  212.  
  213.     rc = ReleaseMutex( hmtxKeyStroke[vmode] ) ;
  214.     return rc == TRUE ? 0 : GetLastError() ;
  215. #else /* not NT */
  216.     return DosReleaseMutexSem( hmtxKeyStroke[vmode] ) ;
  217. #endif /* NT */
  218. }
  219.  
  220. APIRET
  221. CloseKeyStrokeMutex( void )
  222. {
  223.     int j;
  224. #ifdef NT
  225.     BOOL rc = 0 ;
  226.     for ( j=0; j<VNUM ; j++ )
  227.     {
  228.         rc = CloseHandle( hmtxKeyStroke[j] ) ;
  229.         hmtxKeyStroke[j] = (HANDLE) NULL ;
  230.     }
  231.     return rc == TRUE ? 0 : GetLastError() ;
  232. #else /* not NT */
  233.     APIRET rc ;
  234.     for ( j=0; j<VNUM ; j++ )
  235.     {
  236.         rc = DosCloseMutexSem( hmtxKeyStroke[j] ) ;
  237.         hmtxKeyStroke[j] = 0 ;
  238.     }
  239.     return rc ;
  240. #endif /* NT */
  241. }
  242.  
  243. APIRET
  244. CreateKeyboardMutex( BOOL owned )
  245. {
  246.     if ( hmtxKeyboard )
  247. #ifdef NT
  248.       CloseHandle( hmtxKeyboard ) ;
  249.     hmtxKeyboard = CreateMutex( NULL, owned, NULL ) ;
  250.     if (hmtxKeyboard == NULL)
  251.           return GetLastError() ;
  252. #else /* not NT */
  253.         DosCloseMutexSem( hmtxKeyboard ) ;
  254.         DosCreateMutexSem( NULL, &hmtxKeyboard, 0, owned ) ;
  255. #endif /* NT */
  256.     return 0;
  257. }
  258.  
  259. APIRET
  260. RequestKeyboardMutex( ULONG timo )
  261. {
  262. #ifdef NT
  263.     DWORD rc = 0 ;
  264.  
  265.     rc = WaitForSingleObjectEx( hmtxKeyboard, timo, TRUE ) ;
  266.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  267. #else /* not NT */
  268.     return DosRequestMutexSem( hmtxKeyboard, timo ) ;
  269. #endif /* NT */
  270. }
  271.  
  272. APIRET
  273. ReleaseKeyboardMutex( void )
  274. {
  275. #ifdef NT
  276.     BOOL rc = 0 ;
  277.  
  278.     rc = ReleaseMutex( hmtxKeyboard ) ;
  279.     return rc == TRUE ? 0 : GetLastError() ;
  280. #else /* not NT */
  281.     return DosReleaseMutexSem( hmtxKeyboard ) ;
  282. #endif /* NT */
  283. }
  284.  
  285. APIRET
  286. CloseKeyboardMutex( void )
  287. {
  288. #ifdef NT
  289.     BOOL rc = 0 ;
  290.     rc = CloseHandle( hmtxKeyboard ) ;
  291.     hmtxKeyboard = (HANDLE) NULL ;
  292.     return rc == TRUE ? 0 : GetLastError() ;
  293. #else /* not NT */
  294.     APIRET rc ;
  295.     rc = DosCloseMutexSem( hmtxKeyboard ) ;
  296.     hmtxKeyboard = 0 ;
  297.     return rc ;
  298. #endif /* NT */
  299. }
  300.  
  301. APIRET
  302. CreateAlarmMutex( BOOL owned )
  303. {
  304.     if ( hmtxAlarm )
  305. #ifdef NT
  306.         CloseHandle( hmtxAlarm ) ;
  307.     hmtxAlarm = CreateMutex( NULL, owned, NULL ) ;
  308.     return hmtxAlarm == NULL ? GetLastError() : 0 ;
  309. #else /* not NT */
  310.         DosCloseMutexSem( hmtxAlarm ) ;
  311.     return DosCreateMutexSem( NULL, &hmtxAlarm, 0, owned ) ;
  312. #endif /* NT */
  313. }
  314.  
  315. APIRET
  316. RequestAlarmMutex( ULONG timo )
  317. {
  318. #ifdef NT
  319.     DWORD rc = 0 ;
  320.  
  321.     rc = WaitForSingleObjectEx( hmtxAlarm, timo, TRUE ) ;
  322.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  323. #else /* not NT */
  324.     return DosRequestMutexSem( hmtxAlarm, timo ) ;
  325. #endif /* NT */
  326. }
  327.  
  328. APIRET
  329. ReleaseAlarmMutex( void )
  330. {
  331. #ifdef NT
  332.     BOOL rc = 0 ;
  333.  
  334.     rc = ReleaseMutex( hmtxAlarm ) ;
  335.     return rc == TRUE ? 0 : GetLastError() ;
  336. #else /* not NT */
  337.     return DosReleaseMutexSem( hmtxAlarm ) ;
  338. #endif /* NT */
  339. }
  340.  
  341. APIRET
  342. CloseAlarmMutex( void )
  343. {
  344. #ifdef NT
  345.     BOOL rc = 0 ;
  346.     rc = CloseHandle( hmtxAlarm ) ;
  347.     hmtxAlarm = (HANDLE) NULL ;
  348.     return rc == TRUE ? 0 : GetLastError() ;
  349. #else /* not NT */
  350.     APIRET rc ;
  351.     rc = DosCloseMutexSem( hmtxAlarm ) ;
  352.     hmtxAlarm = 0 ;
  353.     return rc ;
  354. #endif /* NT */
  355. }
  356.  
  357. APIRET
  358. CreateScreenMutex( BOOL owned )
  359. {
  360.     if ( hmtxScreen )
  361. #ifdef NT
  362.         CloseHandle( hmtxScreen ) ;
  363.     hmtxScreen = CreateMutex( NULL, owned, NULL ) ;
  364.     return hmtxScreen == NULL ? GetLastError() : 0 ;
  365. #else /* not NT */
  366.         DosCloseMutexSem( hmtxScreen ) ;
  367.     return DosCreateMutexSem( NULL, &hmtxScreen, 0, owned ) ;
  368. #endif /* NT */
  369. }
  370.  
  371. APIRET
  372. RequestScreenMutex( ULONG timo )
  373. {
  374. #ifdef NT
  375.     DWORD rc = 0 ;
  376.  
  377.     rc = WaitForSingleObjectEx( hmtxScreen, timo, TRUE ) ;
  378.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  379. #else /* not NT */
  380.     return DosRequestMutexSem( hmtxScreen, timo ) ;
  381. #endif /* NT */
  382. }
  383.  
  384. APIRET
  385. ReleaseScreenMutex( void )
  386. {
  387. #ifdef NT
  388.     BOOL rc = 0 ;
  389.  
  390.     rc = ReleaseMutex( hmtxScreen ) ;
  391.     return rc == TRUE ? 0 : GetLastError() ;
  392. #else /* not NT */
  393.     return DosReleaseMutexSem( hmtxScreen ) ;
  394. #endif /* NT */
  395. }
  396.  
  397. APIRET
  398. CloseScreenMutex( void )
  399. {
  400. #ifdef NT
  401.     BOOL rc = 0 ;
  402.     rc = CloseHandle( hmtxScreen ) ;
  403.     hmtxScreen = (HANDLE) NULL ;
  404.     return rc == TRUE ? 0 : GetLastError() ;
  405. #else /* not NT */
  406.     APIRET rc ;
  407.     rc = DosCloseMutexSem( hmtxScreen ) ;
  408.     hmtxScreen = 0 ;
  409.     return rc ;
  410. #endif /* NT */
  411. }
  412.  
  413. APIRET
  414. CreateVscrnMutex( BOOL owned )
  415. {
  416.    int i, rc = 0 ;
  417.    for ( i = 0 ; i < VNUM ; i++ )
  418.    {
  419.     if ( hmtxVscrn[i] )
  420. #ifdef NT
  421.         CloseHandle( hmtxVscrn[i] ) ;
  422.     hmtxVscrn[i] = CreateMutex( NULL, owned, NULL ) ;
  423.     if (hmtxVscrn[i] == NULL)
  424.        return GetLastError() ;
  425. #else /* not NT */
  426.       DosCloseMutexSem( hmtxVscrn[i] ) ;
  427.       rc = DosCreateMutexSem( NULL, &hmtxVscrn[i], 0, owned ) ;
  428.       if ( rc )
  429.          return rc;
  430. #endif /* NT */
  431.    }
  432.    return 0;
  433. }
  434.  
  435. APIRET
  436. RequestVscrnMutex( int vmode, ULONG timo )
  437. {
  438. #ifdef NT
  439.     DWORD rc = 0 ;
  440.     rc = WaitForSingleObjectEx( hmtxVscrn[vmode], timo, TRUE ) ;
  441.     return rc == WAIT_OBJECT_0 ? 0 : GetLastError() ;
  442. #else /* not NT */
  443.     return DosRequestMutexSem( hmtxVscrn[vmode], timo ) ;
  444. #endif /* NT */
  445. }
  446.  
  447. APIRET
  448. ReleaseVscrnMutex( int vmode )
  449. {
  450. #ifdef NT
  451.     BOOL rc = 0 ;
  452.  
  453.     rc = ReleaseMutex( hmtxVscrn[vmode] ) ;
  454.     return rc == TRUE ? 0 : GetLastError() ;
  455. #else /* not NT */
  456.     return DosReleaseMutexSem( hmtxVscrn[vmode] ) ;
  457. #endif /* NT */
  458. }
  459.  
  460. APIRET
  461. CloseVscrnMutex( void )
  462. {
  463.    int i ;
  464.    int rc  = 0 ;
  465.    for ( i=0 ; i<VNUM ; i++ )
  466.    {
  467. #ifdef NT
  468.     rc = CloseHandle( hmtxVscrn[i] ) ;
  469.     hmtxVscrn[i] = (HANDLE) NULL ;
  470.     if (!rc)
  471.        return GetLastError() ;
  472. #else /* not NT */
  473.     rc = DosCloseMutexSem( hmtxVscrn[i] ) ;
  474.     hmtxVscrn[i] = 0 ;
  475.     if (rc)
  476.        return rc ;
  477. #endif /* NT */
  478.    }
  479.    return 0;
  480. }
  481.  
  482. APIRET
  483. CreateVscrnDirtyMutex( BOOL owned )
  484. {
  485.    int i, rc ;
  486.    for ( i=0; i<VNUM; i++)
  487.    {
  488.     if ( hmtxVscrnDirty[i] )
  489. #ifdef NT
  490.         CloseHandle( hmtxVscrnDirty[i] ) ;
  491.     hmtxVscrnDirty[i] = CreateMutex( NULL, owned, NULL ) ;
  492.     if ( hmtxVscrnDirty[i] == NULL)
  493.        return GetLastError() ;
  494. #else /* not NT */
  495.         DosCloseMutexSem( hmtxVscrnDirty[i] ) ;
  496.     rc = DosCreateMutexSem( NULL, &hmtxVscrnDirty[i], 0, owned ) ;
  497.       if ( rc )
  498.          return rc;
  499. #endif /* NT */
  500.    }
  501.    return 0;
  502. }
  503.  
  504. APIRET
  505. RequestVscrnDirtyMutex( int vmode, ULONG timo )
  506. {
  507. #ifdef NT
  508.     DWORD rc = 0 ;
  509.  
  510.     rc = WaitForSingleObjectEx( hmtxVscrnDirty[vmode], timo, TRUE ) ;
  511.     return rc == WAIT_OBJECT_0 ? 0 : GetLastError() ;
  512. #else /* not NT */
  513.     return DosRequestMutexSem( hmtxVscrnDirty[vmode], timo ) ;
  514. #endif /* NT */
  515. }
  516.  
  517. APIRET
  518. ReleaseVscrnDirtyMutex( int vmode )
  519. {
  520. #ifdef NT
  521.     BOOL rc = 0 ;
  522.  
  523.     rc = ReleaseMutex( hmtxVscrnDirty[vmode] ) ;
  524.     return rc == TRUE ? 0 : GetLastError() ;
  525. #else /* not NT */
  526.     return DosReleaseMutexSem( hmtxVscrnDirty[vmode] ) ;
  527. #endif /* NT */
  528. }
  529.  
  530. APIRET
  531. CloseVscrnDirtyMutex( void )
  532. {
  533.    int i, rc = 0 ;
  534.    for ( i=0 ; i<VNUM ; i++ )
  535.    {
  536. #ifdef NT
  537.     rc = CloseHandle( hmtxVscrnDirty[i] ) ;
  538.     hmtxVscrnDirty[i] = (HANDLE) NULL ;
  539.     if (!rc)
  540.        return GetLastError() ;
  541. #else /* not NT */
  542.     rc = DosCloseMutexSem( hmtxVscrnDirty[i] ) ;
  543.     hmtxVscrnDirty[i] = 0 ;
  544.     if (rc)
  545.        return rc ;
  546. #endif /* NT */
  547.    }
  548.    return 0;
  549. }
  550.  
  551.  
  552. APIRET
  553. CreateConnectModeMutex( BOOL owned )
  554. {
  555.     if ( hmtxConnectMode )
  556. #ifdef NT
  557.         CloseHandle( hmtxConnectMode ) ;
  558.     hmtxConnectMode = CreateMutex( NULL, owned, NULL ) ;
  559.     return hmtxConnectMode == NULL ? GetLastError() : 0 ;
  560. #else /* not NT */
  561.         DosCloseMutexSem( hmtxConnectMode ) ;
  562.     return DosCreateMutexSem( NULL, &hmtxConnectMode, 0, owned ) ;
  563. #endif /* NT */
  564. }
  565.  
  566. APIRET
  567. RequestConnectModeMutex( ULONG timo )
  568. {
  569. #ifdef NT
  570.     DWORD rc = 0 ;
  571.  
  572.     rc = WaitForSingleObjectEx( hmtxConnectMode, timo, TRUE ) ;
  573.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  574. #else /* not NT */
  575.     return DosRequestMutexSem( hmtxConnectMode, timo ) ;
  576. #endif /* NT */
  577. }
  578.  
  579. APIRET
  580. ReleaseConnectModeMutex( void )
  581. {
  582. #ifdef NT
  583.     BOOL rc = 0 ;
  584.  
  585.     rc = ReleaseMutex( hmtxConnectMode ) ;
  586.     return rc == TRUE ? 0 : GetLastError() ;
  587. #else /* not NT */
  588.     return DosReleaseMutexSem( hmtxConnectMode ) ;
  589. #endif /* NT */
  590. }
  591.  
  592. APIRET
  593. CloseConnectModeMutex( void )
  594. {
  595. #ifdef NT
  596.     BOOL rc = 0 ;
  597.     rc = CloseHandle( hmtxConnectMode ) ;
  598.     hmtxConnectMode = (HANDLE) NULL ;
  599.     return rc == TRUE ? 0 : GetLastError() ;
  600. #else /* not NT */
  601.     APIRET rc ;
  602.     rc = DosCloseMutexSem( hmtxConnectMode ) ;
  603.     hmtxConnectMode = 0 ;
  604.     return rc ;
  605. #endif /* NT */
  606. }
  607.  
  608. APIRET
  609. CreateDebugMutex( BOOL owned )
  610. {
  611.     if ( hmtxDebug )
  612. #ifdef NT
  613.         CloseHandle( hmtxDebug ) ;
  614.     hmtxDebug = CreateMutex( NULL, owned, NULL ) ;
  615.     return hmtxDebug == NULL ? GetLastError() : 0 ;
  616. #else /* not NT */
  617.         DosCloseMutexSem( hmtxDebug ) ;
  618.     return DosCreateMutexSem( NULL, &hmtxDebug, 0, owned ) ;
  619. #endif /* NT */
  620. }
  621.  
  622. APIRET
  623. RequestDebugMutex( ULONG timo )
  624. {
  625. #ifdef NT
  626.     DWORD rc = 0 ;
  627.  
  628.     rc = WaitForSingleObjectEx( hmtxDebug, timo, TRUE ) ;
  629.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  630. #else /* not NT */
  631.     return DosRequestMutexSem( hmtxDebug, timo ) ;
  632. #endif /* NT */
  633. }
  634.  
  635. APIRET
  636. ReleaseDebugMutex( void )
  637. {
  638. #ifdef NT
  639.     BOOL rc = 0 ;
  640.  
  641.     rc = ReleaseMutex( hmtxDebug ) ;
  642.     return rc == TRUE ? 0 : GetLastError() ;
  643. #else /* not NT */
  644.     return DosReleaseMutexSem( hmtxDebug ) ;
  645. #endif /* NT */
  646. }
  647.  
  648. APIRET
  649. CloseDebugMutex( void )
  650. {
  651. #ifdef NT
  652.     BOOL rc = 0 ;
  653.     rc = CloseHandle( hmtxDebug ) ;
  654.     hmtxDebug = (HANDLE) NULL ;
  655.     return rc == TRUE ? 0 : GetLastError() ;
  656. #else /* not NT */
  657.     APIRET rc ;
  658.     rc = DosCloseMutexSem( hmtxDebug ) ;
  659.     hmtxDebug = 0 ;
  660.     return rc ;
  661. #endif /* NT */
  662. }
  663.  
  664. APIRET
  665. CreateTelnetMutex( BOOL owned )
  666. {
  667.     if ( hmtxTelnet )
  668. #ifdef NT
  669.         CloseHandle( hmtxTelnet ) ;
  670.     hmtxTelnet = CreateMutex( NULL, owned, NULL ) ;
  671.     return hmtxTelnet == NULL ? GetLastError() : 0 ;
  672. #else /* not NT */
  673.         DosCloseMutexSem( hmtxTelnet ) ;
  674.     return DosCreateMutexSem( NULL, &hmtxTelnet, 0, owned ) ;
  675. #endif /* NT */
  676. }
  677.  
  678. APIRET
  679. RequestTelnetMutex( ULONG timo )
  680. {
  681. #ifdef NT
  682.     DWORD rc = 0 ;
  683.  
  684.     rc = WaitForSingleObjectEx( hmtxTelnet, timo, TRUE ) ;
  685.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  686. #else /* not NT */
  687.     return DosRequestMutexSem( hmtxTelnet, timo ) ;
  688. #endif /* NT */
  689. }
  690.  
  691. APIRET
  692. ReleaseTelnetMutex( void )
  693. {
  694. #ifdef NT
  695.     BOOL rc = 0 ;
  696.  
  697.     rc = ReleaseMutex( hmtxTelnet ) ;
  698.     return rc == TRUE ? 0 : GetLastError() ;
  699. #else /* not NT */
  700.     return DosReleaseMutexSem( hmtxTelnet ) ;
  701. #endif /* NT */
  702. }
  703.  
  704. APIRET
  705. CloseTelnetMutex( void )
  706. {
  707. #ifdef NT
  708.     BOOL rc = 0 ;
  709.     rc = CloseHandle( hmtxTelnet ) ;
  710.     hmtxTelnet = (HANDLE) NULL ;
  711.     return rc == TRUE ? 0 : GetLastError() ;
  712. #else /* not NT */
  713.     APIRET rc ;
  714.     rc = DosCloseMutexSem( hmtxTelnet ) ;
  715.     hmtxTelnet = 0 ;
  716.     return rc ;
  717. #endif /* NT */
  718. }
  719.  
  720. APIRET
  721. CreateEventAvailSem( BOOL posted )
  722. {
  723.     int j;
  724.  
  725.     for ( j=0; j<VNUM; j++ )
  726.     {
  727.         if ( hevEventAvail[j] )
  728. #ifdef NT
  729.         CloseHandle( hevEventAvail[j] ) ;
  730.     hevEventAvail[j] = CreateEvent( NULL, TRUE, posted, NULL ) ;
  731.     if (hevEventAvail == NULL)
  732.       return GetLastError() ;
  733. #else /* not NT */
  734.         DosCloseEventSem( hevEventAvail[j] ) ;
  735.         DosCreateEventSem( NULL, &hevEventAvail[j], 0, posted ) ;
  736. #endif /* NT */
  737.     }
  738.     return 0;
  739. }
  740.  
  741. APIRET
  742. PostEventAvailSem( int vmode )
  743. {
  744. #ifdef NT
  745.     BOOL rc = 0 ;
  746.  
  747.     rc = SetEvent( hevEventAvail[vmode] ) ;
  748.     return rc == TRUE ? 0 : GetLastError() ;
  749. #else /* not NT */
  750.     return DosPostEventSem( hevEventAvail[vmode] ) ;
  751. #endif /* NT */
  752. }
  753.  
  754. APIRET
  755. WaitEventAvailSem( int vmode, ULONG timo )
  756. {
  757. #ifdef NT
  758.     DWORD rc = 0 ;
  759.  
  760.     rc = WaitForSingleObjectEx( hevEventAvail[vmode], timo, TRUE ) ;
  761.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  762. #else /* not NT */
  763.     APIRET rc = 0 ;
  764.     rc = DosWaitEventSem( hevEventAvail[vmode], timo ) ;
  765.     return rc ;
  766. #endif /* NT */
  767. }
  768.  
  769. APIRET
  770. WaitAndResetEventAvailSem( int vmode, ULONG timo )
  771. {
  772. #ifdef NT
  773.     DWORD rc = 0 ;
  774.  
  775.     rc = WaitForSingleObjectEx( hevEventAvail[vmode], timo, TRUE ) ;
  776.     if ( rc == WAIT_OBJECT_0 )
  777.         ResetEvent( hevEventAvail[vmode] ) ;
  778.     return rc == WAIT_OBJECT_0 ;
  779. #else /* not NT */
  780.     APIRET rc = 0 ;
  781.     ULONG  semcount = 0 ;
  782.  
  783.     rc = DosWaitEventSem( hevEventAvail[vmode], timo ) ;
  784.     if ( !rc )
  785.         DosResetEventSem( hevEventAvail[vmode], &semcount ) ;
  786.     return semcount ;
  787. #endif /* NT */
  788. }
  789.  
  790. APIRET
  791. ResetEventAvailSem( int vmode )
  792. {
  793. #ifdef NT
  794.     BOOL rc = 0 ;
  795.  
  796.     rc = ResetEvent( hevEventAvail[vmode] ) ;
  797.     return rc ;
  798. #else /* not NT */
  799.     APIRET rc = 0 ;
  800.     ULONG semcount = 0 ;
  801.  
  802.     rc = DosResetEventSem( hevEventAvail[vmode], &semcount ) ;
  803.     return semcount ;
  804. #endif /* NT */
  805. }
  806.  
  807. APIRET
  808. CloseEventAvailSem( void )
  809. {
  810.     int j;
  811. #ifdef NT
  812.     BOOL rc = 0 ;
  813.     for ( j=0 ; j<VNUM ; j++ )
  814.     {
  815.         rc = CloseHandle( hevEventAvail[j] ) ;
  816.         hevEventAvail[j] = (HANDLE) NULL ;
  817.     }
  818.     return rc == TRUE ? 0 : GetLastError() ;
  819. #else /* not NT */
  820.     APIRET rc ;
  821.     for ( j=0 ; j<VNUM ; j++ )
  822.     {
  823.         rc = DosCloseEventSem( hevEventAvail[j] ) ;
  824.         hevEventAvail[j] = 0 ;
  825.     }
  826.     return rc ;
  827. #endif /* NT */
  828. }
  829.  
  830. APIRET
  831. CreateAlarmSem( BOOL posted )
  832. {
  833.     if ( hevAlarm )
  834. #ifdef NT
  835.         CloseHandle( hevAlarm ) ;
  836.     hevAlarm = CreateEvent( NULL, TRUE, posted, NULL ) ;
  837.     return hevAlarm == NULL ? GetLastError() : 0 ;
  838. #else /* not NT */
  839.         DosCloseEventSem( hevAlarm ) ;
  840.     return DosCreateEventSem( NULL, &hevAlarm, DC_SEM_SHARED, posted ) ;
  841. #endif /* NT */
  842. }
  843.  
  844. APIRET
  845. PostAlarmSem( void )
  846. {
  847. #ifdef NT
  848.     BOOL rc = 0 ;
  849.  
  850.     rc = SetEvent( hevAlarm ) ;
  851.     return rc == TRUE ? 0 : GetLastError() ;
  852. #else /* not NT */
  853.     return DosPostEventSem( hevAlarm ) ;
  854. #endif /* NT */
  855. }
  856.  
  857. APIRET
  858. WaitAlarmSem( ULONG timo )
  859. {
  860. #ifdef NT
  861.     DWORD rc = 0 ;
  862.  
  863.     rc = WaitForSingleObjectEx( hevAlarm, timo, TRUE ) ;
  864.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  865. #else /* not NT */
  866.     APIRET rc = 0 ;
  867.  
  868.     rc = DosWaitEventSem( hevAlarm, timo ) ;
  869.     return rc ;
  870. #endif /* NT */
  871. }
  872.  
  873. APIRET
  874. WaitAndResetAlarmSem( ULONG timo )
  875. {
  876. #ifdef NT
  877.     DWORD rc = 0 ;
  878.  
  879.     rc = WaitForSingleObjectEx( hevAlarm, timo, TRUE ) ;
  880.     if ( rc == WAIT_OBJECT_0 )
  881.         ResetEvent( hevAlarm ) ;
  882.     return rc == WAIT_OBJECT_0 ;
  883. #else /* not NT */
  884.     APIRET rc = 0 ;
  885.     ULONG  semcount = 0 ;
  886.  
  887.     rc = DosWaitEventSem( hevAlarm, timo ) ;
  888.     if ( !rc )
  889.         DosResetEventSem( hevAlarm, &semcount ) ;
  890.     return semcount ;
  891. #endif /* NT */
  892. }
  893.  
  894. APIRET
  895. ResetAlarmSem( void )
  896. {
  897. #ifdef NT
  898.     BOOL rc = 0 ;
  899.  
  900.     rc = ResetEvent( hevAlarm ) ;
  901.     return rc ;
  902. #else /* not NT */
  903.     APIRET rc = 0 ;
  904.     ULONG semcount = 0 ;
  905.  
  906.     rc = DosResetEventSem( hevAlarm, &semcount ) ;
  907.     return semcount ;
  908. #endif /* NT */
  909. }
  910.  
  911. APIRET
  912. CloseAlarmSem( void )
  913. {
  914. #ifdef NT
  915.     BOOL rc = 0 ;
  916.     rc = CloseHandle( hevAlarm ) ;
  917.     hevAlarm = (HANDLE) NULL ;
  918.     return rc == TRUE ? 0 : GetLastError() ;
  919. #else /* not NT */
  920.     APIRET rc ;
  921.     rc = DosCloseEventSem( hevAlarm ) ;
  922.     hevAlarm = 0 ;
  923.     return rc ;
  924. #endif /* NT */
  925. }
  926.  
  927. APIRET
  928. CreateRdComWrtScrThreadSem( BOOL posted )
  929. {
  930.     if ( hevRdComWrtScrThread )
  931. #ifdef NT
  932.         CloseHandle( hevRdComWrtScrThread ) ;
  933.     hevRdComWrtScrThread = CreateEvent( NULL, TRUE, posted, NULL ) ;
  934.     return hevRdComWrtScrThread == NULL ? GetLastError() : 0 ;
  935. #else /* not NT */
  936.         DosCloseEventSem( hevRdComWrtScrThread ) ;
  937.     return DosCreateEventSem( NULL, &hevRdComWrtScrThread, 0, posted ) ;
  938. #endif /* NT */
  939. }
  940.  
  941. APIRET
  942. PostRdComWrtScrThreadSem( void )
  943. {
  944. #ifdef NT
  945.     BOOL rc = 0 ;
  946.  
  947.     rc = SetEvent( hevRdComWrtScrThread ) ;
  948.     return rc == TRUE ? 0 : GetLastError() ;
  949. #else /* not NT */
  950.     return DosPostEventSem( hevRdComWrtScrThread ) ;
  951. #endif /* NT */
  952. }
  953.  
  954. APIRET
  955. WaitRdComWrtScrThreadSem( ULONG timo )
  956. {
  957. #ifdef NT
  958.     DWORD rc = 0 ;
  959.  
  960.     rc = WaitForSingleObjectEx( hevRdComWrtScrThread, timo, TRUE ) ;
  961.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  962. #else /* not NT */
  963.     APIRET rc = 0 ;
  964.  
  965.     rc = DosWaitEventSem( hevRdComWrtScrThread, timo ) ;
  966.     return rc ;
  967. #endif /* NT */
  968. }
  969.  
  970. APIRET
  971. WaitAndResetRdComWrtScrThreadSem( ULONG timo )
  972. {
  973. #ifdef NT
  974.     DWORD rc = 0 ;
  975.  
  976.     rc = WaitForSingleObjectEx( hevRdComWrtScrThread, timo, TRUE ) ;
  977.     if ( rc == WAIT_OBJECT_0 )
  978.         ResetEvent( hevRdComWrtScrThread ) ;
  979.     return rc == WAIT_OBJECT_0 ;
  980. #else /* not NT */
  981.     APIRET rc = 0 ;
  982.     ULONG  semcount = 0 ;
  983.  
  984.     rc = DosWaitEventSem( hevRdComWrtScrThread, timo ) ;
  985.     if ( !rc )
  986.         DosResetEventSem( hevRdComWrtScrThread, &semcount ) ;
  987.     return semcount ;
  988. #endif /* NT */
  989. }
  990.  
  991. APIRET
  992. ResetRdComWrtScrThreadSem( void )
  993. {
  994. #ifdef NT
  995.     BOOL rc = 0 ;
  996.  
  997.     rc = ResetEvent( hevRdComWrtScrThread ) ;
  998.     return rc ;
  999. #else /* not NT */
  1000.     APIRET rc = 0 ;
  1001.     ULONG semcount = 0 ;
  1002.  
  1003.     rc = DosResetEventSem( hevRdComWrtScrThread, &semcount ) ;
  1004.     return semcount ;
  1005. #endif /* NT */
  1006. }
  1007.  
  1008. APIRET
  1009. CloseRdComWrtScrThreadSem( void )
  1010. {
  1011. #ifdef NT
  1012.     BOOL rc = 0 ;
  1013.     rc = CloseHandle( hevRdComWrtScrThread ) ;
  1014.     hevRdComWrtScrThread = (HANDLE) NULL ;
  1015.     return rc == TRUE ? 0 : GetLastError() ;
  1016. #else /* not NT */
  1017.     APIRET rc ;
  1018.     rc = DosCloseEventSem( hevRdComWrtScrThread ) ;
  1019.     hevRdComWrtScrThread = 0 ;
  1020.     return rc ;
  1021. #endif /* NT */
  1022. }
  1023.  
  1024. APIRET
  1025. CreateConKbdHandlerThreadSem( BOOL posted )
  1026. {
  1027.     if ( hevConKbdHandlerThread )
  1028. #ifdef NT
  1029.         CloseHandle( hevConKbdHandlerThread ) ;
  1030.     hevConKbdHandlerThread = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1031.     return hevConKbdHandlerThread == NULL ? GetLastError() : 0 ;
  1032. #else /* not NT */
  1033.         DosCloseEventSem( hevConKbdHandlerThread ) ;
  1034.     return DosCreateEventSem( NULL, &hevConKbdHandlerThread, 0, posted ) ;
  1035. #endif /* NT */
  1036. }
  1037.  
  1038. APIRET
  1039. PostConKbdHandlerThreadSem( void )
  1040. {
  1041. #ifdef NT
  1042.     BOOL rc = 0 ;
  1043.  
  1044.     rc = SetEvent( hevConKbdHandlerThread ) ;
  1045.     return rc == TRUE ? 0 : GetLastError() ;
  1046. #else /* not NT */
  1047.     return DosPostEventSem( hevConKbdHandlerThread ) ;
  1048. #endif /* NT */
  1049. }
  1050.  
  1051. APIRET
  1052. WaitConKbdHandlerThreadSem( ULONG timo )
  1053. {
  1054. #ifdef NT
  1055.     DWORD rc = 0 ;
  1056.  
  1057.     rc = WaitForSingleObjectEx( hevConKbdHandlerThread, timo, TRUE ) ;
  1058.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1059. #else /* not NT */
  1060.     APIRET rc = 0 ;
  1061.  
  1062.     rc = DosWaitEventSem( hevConKbdHandlerThread, timo ) ;
  1063.     return rc ;
  1064. #endif /* NT */
  1065. }
  1066.  
  1067. APIRET
  1068. WaitAndResetConKbdHandlerThreadSem( ULONG timo )
  1069. {
  1070. #ifdef NT
  1071.     DWORD rc = 0 ;
  1072.  
  1073.     rc = WaitForSingleObjectEx( hevConKbdHandlerThread, timo, TRUE ) ;
  1074.     if ( rc == WAIT_OBJECT_0 )
  1075.         ResetEvent( hevConKbdHandlerThread ) ;
  1076.     return rc == WAIT_OBJECT_0 ;
  1077. #else /* not NT */
  1078.     APIRET rc = 0 ;
  1079.     ULONG  semcount = 0 ;
  1080.  
  1081.     rc = DosWaitEventSem( hevConKbdHandlerThread, timo ) ;
  1082.     if ( !rc )
  1083.         DosResetEventSem( hevConKbdHandlerThread, &semcount ) ;
  1084.     return semcount ;
  1085. #endif /* NT */
  1086. }
  1087.  
  1088. APIRET
  1089. ResetConKbdHandlerThreadSem( void )
  1090. {
  1091. #ifdef NT
  1092.     BOOL rc = 0 ;
  1093.  
  1094.     rc = ResetEvent( hevConKbdHandlerThread ) ;
  1095.     return rc ;
  1096. #else /* not NT */
  1097.     APIRET rc = 0 ;
  1098.     ULONG semcount = 0 ;
  1099.  
  1100.     rc = DosResetEventSem( hevConKbdHandlerThread, &semcount ) ;
  1101.     return rc ;
  1102. #endif /* NT */
  1103. }
  1104.  
  1105. APIRET
  1106. CloseConKbdHandlerThreadSem( void )
  1107. {
  1108. #ifdef NT
  1109.     BOOL rc = 0 ;
  1110.     rc = CloseHandle( hevConKbdHandlerThread ) ;
  1111.     hevConKbdHandlerThread = (HANDLE) NULL ;
  1112.     return rc == TRUE ? 0 : GetLastError() ;
  1113. #else /* not NT */
  1114.     APIRET rc ;
  1115.     rc = DosCloseEventSem( hevConKbdHandlerThread ) ;
  1116.     hevConKbdHandlerThread = 0 ;
  1117.     return rc ;
  1118. #endif /* NT */
  1119. }
  1120.  
  1121. APIRET
  1122. CreateTermScrnUpdThreadSem( BOOL posted )
  1123. {
  1124.     if ( hevTermScrnUpdThread )
  1125. #ifdef NT
  1126.         CloseHandle( hevTermScrnUpdThread ) ;
  1127.     hevTermScrnUpdThread = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1128.     return hevTermScrnUpdThread == NULL ? GetLastError() : 0 ;
  1129. #else /* not NT */
  1130.         DosCloseEventSem( hevTermScrnUpdThread ) ;
  1131.     return DosCreateEventSem( NULL, &hevTermScrnUpdThread, 0, posted ) ;
  1132. #endif /* NT */
  1133. }
  1134.  
  1135. APIRET
  1136. PostTermScrnUpdThreadSem( void )
  1137. {
  1138. #ifdef NT
  1139.     BOOL rc = 0 ;
  1140.  
  1141.     rc = SetEvent( hevTermScrnUpdThread ) ;
  1142.     return rc == TRUE ? 0 : GetLastError() ;
  1143. #else /* not NT */
  1144.     return DosPostEventSem( hevTermScrnUpdThread ) ;
  1145. #endif /* NT */
  1146. }
  1147.  
  1148. APIRET
  1149. WaitTermScrnUpdThreadSem( ULONG timo )
  1150. {
  1151. #ifdef NT
  1152.     DWORD rc = 0 ;
  1153.  
  1154.     rc = WaitForSingleObjectEx( hevTermScrnUpdThread, timo, TRUE ) ;
  1155.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1156. #else /* not NT */
  1157.     APIRET rc = 0 ;
  1158.  
  1159.     rc = DosWaitEventSem( hevTermScrnUpdThread, timo ) ;
  1160.     return rc ;
  1161. #endif /* NT */
  1162. }
  1163.  
  1164. APIRET
  1165. WaitAndResetTermScrnUpdThreadSem( ULONG timo )
  1166. {
  1167. #ifdef NT
  1168.     DWORD rc = 0 ;
  1169.  
  1170.     rc = WaitForSingleObjectEx( hevTermScrnUpdThread, timo, TRUE ) ;
  1171.     if ( rc == WAIT_OBJECT_0 )
  1172.         ResetEvent( hevTermScrnUpdThread ) ;
  1173.     return rc == WAIT_OBJECT_0 ;
  1174. #else /* not NT */
  1175.     APIRET rc = 0 ;
  1176.     ULONG  semcount = 0 ;
  1177.  
  1178.     rc = DosWaitEventSem( hevTermScrnUpdThread, timo ) ;
  1179.     if ( !rc )
  1180.         DosResetEventSem( hevTermScrnUpdThread, &semcount ) ;
  1181.     return semcount ;
  1182. #endif /* NT */
  1183. }
  1184.  
  1185. APIRET
  1186. ResetTermScrnUpdThreadSem( void )
  1187. {
  1188. #ifdef NT
  1189.     BOOL rc = 0 ;
  1190.  
  1191.     rc = ResetEvent( hevTermScrnUpdThread ) ;
  1192.     return rc ;
  1193. #else /* not NT */
  1194.     APIRET rc = 0 ;
  1195.     ULONG semcount = 0 ;
  1196.  
  1197.     rc = DosResetEventSem( hevTermScrnUpdThread, &semcount ) ;
  1198.     return rc ;
  1199. #endif /* NT */
  1200. }
  1201.  
  1202. APIRET
  1203. CloseTermScrnUpdThreadSem( void )
  1204. {
  1205. #ifdef NT
  1206.     BOOL rc = 0 ;
  1207.     rc = CloseHandle( hevTermScrnUpdThread ) ;
  1208.     hevTermScrnUpdThread = (HANDLE) NULL ;
  1209.     return rc == TRUE ? 0 : GetLastError() ;
  1210. #else /* not NT */
  1211.     APIRET rc ;
  1212.     rc = DosCloseEventSem( hevTermScrnUpdThread ) ;
  1213.     hevTermScrnUpdThread = 0 ;
  1214.     return rc ;
  1215. #endif /* NT */
  1216. }
  1217.  
  1218. APIRET
  1219. CreateRdComWrtScrThreadDownSem( BOOL posted )
  1220. {
  1221.     if ( hevRdComWrtScrThreadDown )
  1222. #ifdef NT
  1223.         CloseHandle( hevRdComWrtScrThreadDown ) ;
  1224.     hevRdComWrtScrThreadDown = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1225.     return hevRdComWrtScrThreadDown == NULL ? GetLastError() : 0 ;
  1226. #else /* not NT */
  1227.         DosCloseEventSem( hevRdComWrtScrThreadDown ) ;
  1228.     return DosCreateEventSem( NULL, &hevRdComWrtScrThreadDown, 0, posted ) ;
  1229. #endif /* NT */
  1230. }
  1231.  
  1232. APIRET
  1233. PostRdComWrtScrThreadDownSem( void )
  1234. {
  1235. #ifdef NT
  1236.     BOOL rc = 0 ;
  1237.  
  1238.     rc = SetEvent( hevRdComWrtScrThreadDown ) ;
  1239.     return rc == TRUE ? 0 : GetLastError() ;
  1240. #else /* not NT */
  1241.     return DosPostEventSem( hevRdComWrtScrThreadDown ) ;
  1242. #endif /* NT */
  1243. }
  1244.  
  1245. APIRET
  1246. WaitRdComWrtScrThreadDownSem( ULONG timo )
  1247. {
  1248. #ifdef NT
  1249.     DWORD rc = 0 ;
  1250.  
  1251.     rc = WaitForSingleObjectEx( hevRdComWrtScrThreadDown, timo, TRUE ) ;
  1252.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1253. #else /* not NT */
  1254.     APIRET rc = 0 ;
  1255.  
  1256.     rc = DosWaitEventSem( hevRdComWrtScrThreadDown, timo ) ;
  1257.     return rc ;
  1258. #endif /* NT */
  1259. }
  1260.  
  1261. APIRET
  1262. WaitAndResetRdComWrtScrThreadDownSem( ULONG timo )
  1263. {
  1264. #ifdef NT
  1265.     DWORD rc = 0 ;
  1266.  
  1267.     rc = WaitForSingleObjectEx( hevRdComWrtScrThreadDown, timo, TRUE ) ;
  1268.     if ( rc == WAIT_OBJECT_0 )
  1269.         ResetEvent( hevRdComWrtScrThreadDown ) ;
  1270.     return rc == WAIT_OBJECT_0 ;
  1271. #else /* not NT */
  1272.     APIRET rc = 0 ;
  1273.     ULONG  semcount = 0 ;
  1274.  
  1275.     rc = DosWaitEventSem( hevRdComWrtScrThreadDown, timo ) ;
  1276.     if ( !rc )
  1277.         DosResetEventSem( hevRdComWrtScrThreadDown, &semcount ) ;
  1278.     return semcount ;
  1279. #endif /* NT */
  1280. }
  1281.  
  1282. APIRET
  1283. ResetRdComWrtScrThreadDownSem( void )
  1284. {
  1285. #ifdef NT
  1286.     BOOL rc = 0 ;
  1287.  
  1288.     rc = ResetEvent( hevRdComWrtScrThreadDown ) ;
  1289.     return rc ;
  1290. #else /* not NT */
  1291.     APIRET rc = 0 ;
  1292.     ULONG semcount = 0 ;
  1293.  
  1294.     rc = DosResetEventSem( hevRdComWrtScrThreadDown, &semcount ) ;
  1295.     return semcount ;
  1296. #endif /* NT */
  1297. }
  1298.  
  1299. APIRET
  1300. CloseRdComWrtScrThreadDownSem( void )
  1301. {
  1302. #ifdef NT
  1303.     BOOL rc = 0 ;
  1304.     rc = CloseHandle( hevRdComWrtScrThreadDown ) ;
  1305.     hevRdComWrtScrThreadDown = (HANDLE) NULL ;
  1306.     return rc == TRUE ? 0 : GetLastError() ;
  1307. #else /* not NT */
  1308.     APIRET rc ;
  1309.     rc = DosCloseEventSem( hevRdComWrtScrThreadDown ) ;
  1310.     hevRdComWrtScrThreadDown = 0 ;
  1311.     return rc ;
  1312. #endif /* NT */
  1313. }
  1314.  
  1315. APIRET
  1316. CreateConKbdHandlerThreadDownSem( BOOL posted )
  1317. {
  1318.     if ( hevConKbdHandlerThreadDown )
  1319. #ifdef NT
  1320.         CloseHandle( hevConKbdHandlerThreadDown ) ;
  1321.     hevConKbdHandlerThreadDown = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1322.     return hevConKbdHandlerThreadDown == NULL ? GetLastError() : 0 ;
  1323. #else /* not NT */
  1324.         DosCloseEventSem( hevConKbdHandlerThreadDown ) ;
  1325.     return DosCreateEventSem( NULL, &hevConKbdHandlerThreadDown, 0, posted ) ;
  1326. #endif /* NT */
  1327. }
  1328.  
  1329. APIRET
  1330. PostConKbdHandlerThreadDownSem( void )
  1331. {
  1332. #ifdef NT
  1333.     BOOL rc = 0 ;
  1334.  
  1335.     rc = SetEvent( hevConKbdHandlerThreadDown ) ;
  1336.     return rc == TRUE ? 0 : GetLastError() ;
  1337. #else /* not NT */
  1338.     return DosPostEventSem( hevConKbdHandlerThreadDown ) ;
  1339. #endif /* NT */
  1340. }
  1341.  
  1342. APIRET
  1343. WaitConKbdHandlerThreadDownSem( ULONG timo )
  1344. {
  1345. #ifdef NT
  1346.     DWORD rc = 0 ;
  1347.  
  1348.     rc = WaitForSingleObjectEx( hevConKbdHandlerThreadDown, timo, TRUE ) ;
  1349.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1350. #else /* not NT */
  1351.     APIRET rc = 0 ;
  1352.  
  1353.     rc = DosWaitEventSem( hevConKbdHandlerThreadDown, timo ) ;
  1354.     return rc ;
  1355. #endif /* NT */
  1356. }
  1357.  
  1358. APIRET
  1359. WaitAndResetConKbdHandlerThreadDownSem( ULONG timo )
  1360. {
  1361. #ifdef NT
  1362.     DWORD rc = 0 ;
  1363.  
  1364.     rc = WaitForSingleObjectEx( hevConKbdHandlerThreadDown, timo, TRUE ) ;
  1365.     if ( rc == WAIT_OBJECT_0 )
  1366.         ResetEvent( hevConKbdHandlerThreadDown ) ;
  1367.     return rc == WAIT_OBJECT_0 ;
  1368. #else /* not NT */
  1369.     APIRET rc = 0 ;
  1370.     ULONG  semcount = 0 ;
  1371.  
  1372.     rc = DosWaitEventSem( hevConKbdHandlerThreadDown, timo ) ;
  1373.     if ( !rc )
  1374.         DosResetEventSem( hevConKbdHandlerThreadDown, &semcount ) ;
  1375.     return semcount ;
  1376. #endif /* NT */
  1377. }
  1378.  
  1379. APIRET
  1380. ResetConKbdHandlerThreadDownSem( void )
  1381. {
  1382. #ifdef NT
  1383.     BOOL rc = 0 ;
  1384.  
  1385.     rc = ResetEvent( hevConKbdHandlerThreadDown ) ;
  1386.     return rc ;
  1387. #else /* not NT */
  1388.     APIRET rc = 0 ;
  1389.     ULONG semcount = 0 ;
  1390.  
  1391.     rc = DosResetEventSem( hevConKbdHandlerThreadDown, &semcount ) ;
  1392.     return rc ;
  1393. #endif /* NT */
  1394. }
  1395.  
  1396. APIRET
  1397. CloseConKbdHandlerThreadDownSem( void )
  1398. {
  1399. #ifdef NT
  1400.     BOOL rc = 0 ;
  1401.     rc = CloseHandle( hevConKbdHandlerThreadDown ) ;
  1402.     hevConKbdHandlerThreadDown = (HANDLE) NULL ;
  1403.     return rc == TRUE ? 0 : GetLastError() ;
  1404. #else /* not NT */
  1405.     APIRET rc ;
  1406.     rc = DosCloseEventSem( hevConKbdHandlerThreadDown ) ;
  1407.     hevConKbdHandlerThreadDown = 0 ;
  1408.     return rc ;
  1409. #endif /* NT */
  1410. }
  1411.  
  1412. APIRET
  1413. CreateTermScrnUpdThreadDownSem( BOOL posted )
  1414. {
  1415.     if ( hevTermScrnUpdThreadDown )
  1416. #ifdef NT
  1417.         CloseHandle( hevTermScrnUpdThreadDown ) ;
  1418.     hevTermScrnUpdThreadDown = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1419.     return hevTermScrnUpdThreadDown == NULL ? GetLastError() : 0 ;
  1420. #else /* not NT */
  1421.         DosCloseEventSem( hevTermScrnUpdThreadDown ) ;
  1422.     return DosCreateEventSem( NULL, &hevTermScrnUpdThreadDown, 0, posted ) ;
  1423. #endif /* NT */
  1424. }
  1425.  
  1426. APIRET
  1427. PostTermScrnUpdThreadDownSem( void )
  1428. {
  1429. #ifdef NT
  1430.     BOOL rc = 0 ;
  1431.  
  1432.     rc = SetEvent( hevTermScrnUpdThreadDown ) ;
  1433.     return rc == TRUE ? 0 : GetLastError() ;
  1434. #else /* not NT */
  1435.     return DosPostEventSem( hevTermScrnUpdThreadDown ) ;
  1436. #endif /* NT */
  1437. }
  1438.  
  1439. APIRET
  1440. WaitTermScrnUpdThreadDownSem( ULONG timo )
  1441. {
  1442. #ifdef NT
  1443.     DWORD rc = 0 ;
  1444.  
  1445.     rc = WaitForSingleObjectEx( hevTermScrnUpdThreadDown, timo, TRUE ) ;
  1446.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1447. #else /* not NT */
  1448.     APIRET rc = 0 ;
  1449.  
  1450.     rc = DosWaitEventSem( hevTermScrnUpdThreadDown, timo ) ;
  1451.     return rc ;
  1452. #endif /* NT */
  1453. }
  1454.  
  1455. APIRET
  1456. WaitAndResetTermScrnUpdThreadDownSem( ULONG timo )
  1457. {
  1458. #ifdef NT
  1459.     DWORD rc = 0 ;
  1460.  
  1461.     rc = WaitForSingleObjectEx( hevTermScrnUpdThreadDown, timo, TRUE ) ;
  1462.     if ( rc == WAIT_OBJECT_0 )
  1463.         ResetEvent( hevTermScrnUpdThreadDown ) ;
  1464.     return rc == WAIT_OBJECT_0 ;
  1465. #else /* not NT */
  1466.     APIRET rc = 0 ;
  1467.     ULONG  semcount = 0 ;
  1468.  
  1469.     rc = DosWaitEventSem( hevTermScrnUpdThreadDown, timo ) ;
  1470.     if ( !rc )
  1471.         DosResetEventSem( hevTermScrnUpdThreadDown, &semcount ) ;
  1472.     return semcount ;
  1473. #endif /* NT */
  1474. }
  1475.  
  1476. APIRET
  1477. ResetTermScrnUpdThreadDownSem( void )
  1478. {
  1479. #ifdef NT
  1480.     BOOL rc = 0 ;
  1481.  
  1482.     rc = ResetEvent( hevTermScrnUpdThreadDown ) ;
  1483.     return rc ;
  1484. #else /* not NT */
  1485.     APIRET rc = 0 ;
  1486.     ULONG semcount = 0 ;
  1487.  
  1488.     rc = DosResetEventSem( hevTermScrnUpdThreadDown, &semcount ) ;
  1489.     return rc ;
  1490. #endif /* NT */
  1491. }
  1492.  
  1493. APIRET
  1494. CloseTermScrnUpdThreadDownSem( void )
  1495. {
  1496. #ifdef NT
  1497.     BOOL rc = 0 ;
  1498.     rc = CloseHandle( hevTermScrnUpdThreadDown ) ;
  1499.     hevTermScrnUpdThreadDown = (HANDLE) NULL ;
  1500.     return rc == TRUE ? 0 : GetLastError() ;
  1501. #else /* not NT */
  1502.     APIRET rc ;
  1503.     rc = DosCloseEventSem( hevTermScrnUpdThreadDown ) ;
  1504.     hevTermScrnUpdThreadDown = 0 ;
  1505.     return rc ;
  1506. #endif /* NT */
  1507. }
  1508.  
  1509. APIRET
  1510. CreateKbdThreadSem( BOOL posted )
  1511. {
  1512.     if ( hevKbdThread )
  1513. #ifdef NT
  1514.         CloseHandle( hevKbdThread ) ;
  1515.     hevKbdThread = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1516.     return hevKbdThread == NULL ? GetLastError() : 0 ;
  1517. #else /* not NT */
  1518.         DosCloseEventSem( hevKbdThread ) ;
  1519.     return DosCreateEventSem( NULL, &hevKbdThread, 0, posted ) ;
  1520. #endif /* NT */
  1521. }
  1522.  
  1523. APIRET
  1524. PostKbdThreadSem( void )
  1525. {
  1526. #ifdef NT
  1527.     BOOL rc = 0 ;
  1528.  
  1529.     rc = SetEvent( hevKbdThread ) ;
  1530.     return rc == TRUE ? 0 : GetLastError() ;
  1531. #else /* not NT */
  1532.     return DosPostEventSem( hevKbdThread ) ;
  1533. #endif /* NT */
  1534. }
  1535.  
  1536. APIRET
  1537. WaitKbdThreadSem( ULONG timo )
  1538. {
  1539. #ifdef NT
  1540.     DWORD rc = 0 ;
  1541.  
  1542.     rc = WaitForSingleObjectEx( hevKbdThread, timo, TRUE ) ;
  1543.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1544. #else /* not NT */
  1545.     APIRET rc = 0 ;
  1546.  
  1547.     rc = DosWaitEventSem( hevKbdThread, timo ) ;
  1548.     return rc ;
  1549. #endif /* NT */
  1550. }
  1551.  
  1552. APIRET
  1553. WaitAndResetKbdThreadSem( ULONG timo )
  1554. {
  1555. #ifdef NT
  1556.     DWORD rc = 0 ;
  1557.  
  1558.     rc = WaitForSingleObjectEx( hevKbdThread, timo, TRUE ) ;
  1559.     if ( rc == WAIT_OBJECT_0 )
  1560.         ResetEvent( hevKbdThread ) ;
  1561.     return rc == WAIT_OBJECT_0 ;
  1562. #else /* not NT */
  1563.     APIRET rc = 0 ;
  1564.     ULONG  semcount = 0;
  1565.  
  1566.     rc = DosWaitEventSem( hevKbdThread, timo ) ;
  1567.     if ( !rc )
  1568.         DosResetEventSem( hevKbdThread, &semcount ) ;
  1569.     return semcount ;
  1570. #endif /* NT */
  1571. }
  1572.  
  1573. APIRET
  1574. ResetKbdThreadSem( void )
  1575. {
  1576. #ifdef NT
  1577.     BOOL rc = 0 ;
  1578.  
  1579.     rc = ResetEvent( hevKbdThread ) ;
  1580.     return rc ;
  1581. #else /* not NT */
  1582.     APIRET rc = 0 ;
  1583.     ULONG semcount = 0 ;
  1584.  
  1585.     rc = DosResetEventSem( hevKbdThread, &semcount ) ;
  1586.     return semcount ;
  1587. #endif /* NT */
  1588. }
  1589.  
  1590. APIRET
  1591. CloseKbdThreadSem( void )
  1592. {
  1593. #ifdef NT
  1594.     BOOL rc = 0 ;
  1595.     rc = CloseHandle( hevKbdThread ) ;
  1596.     hevKbdThread = (HANDLE) NULL ;
  1597.     return rc == TRUE ? 0 : GetLastError() ;
  1598. #else /* not NT */
  1599.     APIRET rc ;
  1600.     rc = DosCloseEventSem( hevKbdThread ) ;
  1601.     hevKbdThread = 0 ;
  1602.     return rc ;
  1603. #endif /* NT */
  1604. }
  1605.  
  1606. APIRET
  1607. CreateKeyMapInitSem( BOOL posted )
  1608. {
  1609.     if ( hevKeyMapInit )
  1610. #ifdef NT
  1611.         CloseHandle( hevKeyMapInit ) ;
  1612.     hevKeyMapInit = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1613.     return hevKeyMapInit == NULL ? GetLastError() : 0 ;
  1614. #else /* not NT */
  1615.         DosCloseEventSem( hevKeyMapInit ) ;
  1616.     return DosCreateEventSem( NULL, &hevKeyMapInit, 0, posted ) ;
  1617. #endif /* NT */
  1618. }
  1619.  
  1620. APIRET
  1621. PostKeyMapInitSem( void )
  1622. {
  1623. #ifdef NT
  1624.     BOOL rc = 0 ;
  1625.  
  1626.     rc = SetEvent( hevKeyMapInit ) ;
  1627.     return rc == TRUE ? 0 : GetLastError() ;
  1628. #else /* not NT */
  1629.     return DosPostEventSem( hevKeyMapInit ) ;
  1630. #endif /* NT */
  1631. }
  1632.  
  1633. APIRET
  1634. WaitKeyMapInitSem( ULONG timo )
  1635. {
  1636. #ifdef NT
  1637.     DWORD rc = 0 ;
  1638.  
  1639.     rc = WaitForSingleObjectEx( hevKeyMapInit, timo, TRUE ) ;
  1640.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1641. #else /* not NT */
  1642.     APIRET rc = 0 ;
  1643.  
  1644.     rc = DosWaitEventSem( hevKeyMapInit, timo ) ;
  1645.     return rc ;
  1646. #endif /* NT */
  1647. }
  1648.  
  1649. APIRET
  1650. WaitAndResetKeyMapInitSem( ULONG timo )
  1651. {
  1652. #ifdef NT
  1653.     DWORD rc = 0 ;
  1654.  
  1655.     rc = WaitForSingleObjectEx( hevKeyMapInit, timo, TRUE ) ;
  1656.     if ( rc == WAIT_OBJECT_0 )
  1657.         ResetEvent( hevKeyMapInit ) ;
  1658.     return rc == WAIT_OBJECT_0 ;
  1659. #else /* not NT */
  1660.     APIRET rc = 0 ;
  1661.     ULONG  semcount = 0;
  1662.  
  1663.     rc = DosWaitEventSem( hevKeyMapInit, timo ) ;
  1664.     if ( !rc )
  1665.         DosResetEventSem( hevKeyMapInit, &semcount ) ;
  1666.     return semcount ;
  1667. #endif /* NT */
  1668. }
  1669.  
  1670. APIRET
  1671. ResetKeyMapInitSem( void )
  1672. {
  1673. #ifdef NT
  1674.     BOOL rc = 0 ;
  1675.  
  1676.     rc = ResetEvent( hevKeyMapInit ) ;
  1677.     return rc ;
  1678. #else /* not NT */
  1679.     APIRET rc = 0 ;
  1680.     ULONG semcount = 0 ;
  1681.  
  1682.     rc = DosResetEventSem( hevKeyMapInit, &semcount ) ;
  1683.     return semcount ;
  1684. #endif /* NT */
  1685. }
  1686.  
  1687. APIRET
  1688. CloseKeyMapInitSem( void )
  1689. {
  1690. #ifdef NT
  1691.     BOOL rc = 0 ;
  1692.     rc = CloseHandle( hevKeyMapInit ) ;
  1693.     hevKeyMapInit = (HANDLE) NULL ;
  1694.     return rc == TRUE ? 0 : GetLastError() ;
  1695. #else /* not NT */
  1696.     APIRET rc ;
  1697.     rc = DosCloseEventSem( hevKeyMapInit ) ;
  1698.     hevKeyMapInit = 0 ;
  1699.     return rc ;
  1700. #endif /* NT */
  1701. }
  1702.  
  1703. #ifdef NT
  1704. void CALLBACK
  1705. TimeProc(
  1706.     UINT IDEvent,
  1707.     UINT uReserved,
  1708.     DWORD dwUser,
  1709.     DWORD dwReserved1,
  1710.     DWORD dwReserved2 )
  1711. {
  1712.     if (IDEvent == htimVscrn[0]) {
  1713.         PostVscrnTimerSem(0);
  1714.         }
  1715.     if (IDEvent == htimVscrn[1]) {
  1716.         PostVscrnTimerSem(1);
  1717.         }
  1718.     if (IDEvent == htimVscrn[2]) {
  1719.         PostVscrnTimerSem(2);
  1720.         }
  1721.     else if (IDEvent == htimAlarm) {
  1722.         PostAlarmSem() ;
  1723.         }
  1724. }
  1725. #endif /* NT */
  1726.  
  1727. APIRET
  1728. StartVscrnTimer( ULONG interval )
  1729. {
  1730.     int i = 0 ;
  1731.     for ( i=0;i<VNUM;i++ )
  1732.     {
  1733. #ifdef NT
  1734.  
  1735.         if ( isWin95() )
  1736.         {
  1737.             htimVscrn[i] = ckTimerStart( (UINT) interval,
  1738.                                       (UINT) interval/20,
  1739.                                       &TimeProc,
  1740.                                       0, TIME_PERIODIC ) ;
  1741.         }
  1742.         else
  1743.         {
  1744.             htimVscrn[i] = timeSetEvent( (UINT) interval,
  1745.                                          (UINT) interval/20,
  1746.                                          &TimeProc,
  1747.                                          0, TIME_PERIODIC ) ;
  1748.         }
  1749.         if ( htimVscrn[i] == 0 )
  1750.             return -(i+1);
  1751. #else /* not NT */
  1752.         if ( DosStartTimer( interval,
  1753.                        (HSEM) hevVscrnTimer[i], &htimVscrn[i] ))
  1754.             return -(i+1);
  1755. #endif /* NT */
  1756.     }
  1757.     return 0;
  1758. }
  1759.  
  1760. APIRET
  1761. StopVscrnTimer( void )
  1762. {
  1763.     int i ;
  1764.     APIRET rc = 0 ;
  1765.     for ( i=0;i<VNUM;i++ )
  1766.     {
  1767. #ifdef NT
  1768.         if ( isWin95() )
  1769.         {
  1770.             rc = ckTimerKill( htimVscrn[i] ) ;
  1771.         }
  1772.         else
  1773.         {
  1774.             rc = timeKillEvent( htimVscrn[i] ) ;
  1775.         }
  1776. #else /* not NT */
  1777.         rc = DosStopTimer( htimVscrn[i] ) ;
  1778. #endif /* NT */
  1779.         htimVscrn[i] = 0 ;
  1780.     }
  1781.     return rc;
  1782. }
  1783.  
  1784. APIRET
  1785. StartAlarmTimer( ULONG interval )
  1786. {
  1787. #ifdef NT
  1788.    if ( isWin95() )
  1789.    {
  1790.       htimAlarm = ckTimerStart( (UINT) interval,(UINT) interval/20,
  1791.         &TimeProc, 0, TIME_ONESHOT ) ;
  1792.    }
  1793.    else
  1794.    {
  1795.       htimAlarm = timeSetEvent( (UINT) interval,(UINT) interval/20,
  1796.         &TimeProc, 0, TIME_ONESHOT ) ;
  1797.    }
  1798.     return htimAlarm == 0 ? 1 : 0 ;
  1799. #else /* not NT */
  1800.     ResetAlarmSem() ;
  1801.     return DosAsyncTimer( interval, (HSEM) hevAlarm, &htimAlarm ) ;
  1802. #endif /* NT */
  1803. }
  1804.  
  1805. APIRET
  1806. StopAlarmTimer( void )
  1807. {
  1808. #ifdef NT
  1809.     APIRET rc = 0 ;
  1810.     if ( isWin95() )
  1811.     {
  1812.         rc = ckTimerKill( htimAlarm ) ;
  1813.     }
  1814.     else
  1815.     {
  1816.         rc = timeKillEvent( htimAlarm ) ;
  1817.     }
  1818.     htimAlarm = 0 ;
  1819.     return rc ;
  1820. #else /* not NT */
  1821.     APIRET rc ;
  1822.     rc = DosStopTimer( htimAlarm ) ;
  1823.     htimAlarm = 0 ;
  1824.     return rc ;
  1825. #endif /* NT */
  1826. }
  1827.  
  1828. APIRET
  1829. CreateVscrnTimerSem( BOOL posted )
  1830. {
  1831.    int i, rc = 0 ;
  1832.    for ( i=0; i<VNUM ; i++ )
  1833.    {
  1834.     if ( hevVscrnTimer[i] )
  1835. #ifdef NT
  1836.         CloseHandle( hevVscrnTimer[i] ) ;
  1837.        hevVscrnTimer[i] = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1838.        if (hevVscrnTimer[i] == NULL)
  1839.            return GetLastError() ;
  1840. #else /* not NT */
  1841.        DosCloseEventSem( hevVscrnTimer[i] ) ;
  1842.        rc = DosCreateEventSem( NULL, &hevVscrnTimer[i],
  1843.                                DC_SEM_SHARED, posted ) ;
  1844.        if ( rc )
  1845.            return rc ;
  1846. #endif /* NT */
  1847.    }
  1848.    return 0;
  1849. }
  1850.  
  1851. APIRET
  1852. PostVscrnTimerSem( int vmode )
  1853. {
  1854. #ifdef NT
  1855.     BOOL rc = 0 ;
  1856.  
  1857.     rc = SetEvent( hevVscrnTimer[vmode] ) ;
  1858.     return rc == TRUE ? 0 : GetLastError() ;
  1859. #else /* not NT */
  1860.     return DosPostEventSem( hevVscrnTimer[vmode] ) ;
  1861. #endif /* NT */
  1862. }
  1863.  
  1864. APIRET
  1865. WaitVscrnTimerSem( int vmode, ULONG timo )
  1866. {
  1867. #ifdef NT
  1868.     DWORD rc = 0 ;
  1869.  
  1870.     rc = WaitForSingleObjectEx( hevVscrnTimer[vmode], timo, TRUE ) ;
  1871.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1872. #else /* not NT */
  1873.     APIRET rc = 0 ;
  1874.  
  1875.     rc = DosWaitEventSem( hevVscrnTimer[vmode], timo ) ;
  1876.     return rc ;
  1877. #endif /* NT */
  1878. }
  1879.  
  1880. APIRET
  1881. WaitAndResetVscrnTimerSem( int vmode, ULONG timo )
  1882. {
  1883. #ifdef NT
  1884.     DWORD rc = 0 ;
  1885.  
  1886.     rc = WaitForSingleObjectEx( hevVscrnTimer[vmode], timo, TRUE ) ;
  1887.     if ( rc == WAIT_OBJECT_0 )
  1888.         ResetEvent( hevVscrnTimer[vmode] ) ;
  1889.     return rc == WAIT_OBJECT_0 ;
  1890. #else /* not NT */
  1891.     APIRET rc = 0 ;
  1892.     ULONG  semcount = 0 ;
  1893.  
  1894.     rc = DosWaitEventSem( hevVscrnTimer[vmode], timo ) ;
  1895.     if ( !rc )
  1896.         DosResetEventSem( hevVscrnTimer[vmode], &semcount ) ;
  1897.     return semcount ;
  1898. #endif /* NT */
  1899. }
  1900.  
  1901. APIRET
  1902. ResetVscrnTimerSem( int vmode )
  1903. {
  1904. #ifdef NT
  1905.     BOOL rc = 0 ;
  1906.  
  1907.     rc = ResetEvent( hevVscrnTimer[vmode] ) ;
  1908.     return rc ;
  1909. #else /* not NT */
  1910.     APIRET rc = 0 ;
  1911.     ULONG semcount = 0 ;
  1912.  
  1913.     rc = DosResetEventSem( hevVscrnTimer[vmode], &semcount ) ;
  1914.     return semcount ;
  1915. #endif /* NT */
  1916. }
  1917.  
  1918. APIRET
  1919. CloseVscrnTimerSem( void )
  1920. {
  1921.    int i,rc=0 ;
  1922.  
  1923.    for ( i=0; i<VNUM ; i++ )
  1924.    {
  1925. #ifdef NT
  1926.     rc = CloseHandle( hevVscrnTimer[i] ) ;
  1927.     hevVscrnTimer[i] = (HANDLE) NULL ;
  1928.     if (!rc)
  1929.        return GetLastError() ;
  1930. #else /* not NT */
  1931.     rc = DosCloseEventSem( hevVscrnTimer[i] ) ;
  1932.     hevVscrnTimer[i] = 0 ;
  1933.     if (rc)
  1934.        return rc ;
  1935. #endif /* NT */
  1936.    }
  1937.    return 0;
  1938. }
  1939.  
  1940. APIRET
  1941. CreateVscrnDirtySem( BOOL posted )
  1942. {
  1943.    int i, rc = 0 ;
  1944.    for ( i=0 ; i<VNUM ; i++ )
  1945.    {
  1946.     if ( hevVscrnDirty[i] )
  1947. #ifdef NT
  1948.         CloseHandle( hevVscrnDirty[i] ) ;
  1949.     hevVscrnDirty[i] = CreateEvent( NULL, TRUE, posted, NULL ) ;
  1950.     if (hevVscrnDirty[i] == NULL)
  1951.        return GetLastError();
  1952. #else /* not NT */
  1953.         DosCloseEventSem( hevVscrnDirty[i] ) ;
  1954.     rc = DosCreateEventSem( NULL, &hevVscrnDirty[i], DC_SEM_SHARED, posted ) ;
  1955.       if ( rc )
  1956.          return rc ;
  1957. #endif /* NT */
  1958.    }
  1959.    return 0;
  1960. }
  1961.  
  1962. APIRET
  1963. PostVscrnDirtySem( int vmode )
  1964. {
  1965. #ifdef NT
  1966.     BOOL rc = 0 ;
  1967.  
  1968.     rc = SetEvent( hevVscrnDirty[vmode] ) ;
  1969. #ifdef COMMENT
  1970.     debug(F101,"PostVscrnDirtySem rc","",rc) ;
  1971. #endif
  1972.     return rc == TRUE ? 0 : GetLastError() ;
  1973. #else /* not NT */
  1974.     return DosPostEventSem( hevVscrnDirty[vmode] ) ;
  1975. #endif /* NT */
  1976. }
  1977.  
  1978. APIRET
  1979. WaitVscrnDirtySem( int vmode, ULONG timo )
  1980. {
  1981. #ifdef NT
  1982.     DWORD rc = 0 ;
  1983.  
  1984.     rc = WaitForSingleObjectEx( hevVscrnDirty[vmode], timo, TRUE ) ;
  1985.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  1986. #else /* not NT */
  1987.     APIRET rc = 0 ;
  1988.  
  1989.     rc = DosWaitEventSem( hevVscrnDirty[vmode], timo ) ;
  1990.     return rc ;
  1991. #endif /* NT */
  1992. }
  1993.  
  1994. APIRET
  1995. WaitAndResetVscrnDirtySem( int vmode, ULONG timo )
  1996. {
  1997. #ifdef NT
  1998.     DWORD rc = 0 ;
  1999.  
  2000.     rc = WaitForSingleObjectEx( hevVscrnDirty[vmode], timo, TRUE ) ;
  2001.     if ( rc == WAIT_OBJECT_0 )
  2002.         ResetEvent( hevVscrnDirty[vmode] ) ;
  2003.     return rc == WAIT_OBJECT_0 ;
  2004. #else /* not NT */
  2005.     APIRET rc = 0 ;
  2006.     ULONG  semcount = 0 ;
  2007.  
  2008.     rc = DosWaitEventSem( hevVscrnDirty[vmode], timo ) ;
  2009.     if ( !rc )
  2010.         DosResetEventSem( hevVscrnDirty[vmode], &semcount ) ;
  2011.     return semcount ;
  2012. #endif /* NT */
  2013. }
  2014.  
  2015. APIRET
  2016. ResetVscrnDirtySem( int vmode )
  2017. {
  2018. #ifdef NT
  2019.     BOOL rc = 0 ;
  2020.  
  2021.     rc = ResetEvent( hevVscrnDirty[vmode] ) ;
  2022. #ifdef COMMENT
  2023.     debug(F101,"ResetVscrnDirtySem rc","",rc) ;
  2024.     if ( !rc )
  2025.        debug(F101,"ResetVscrnDirtySem lasterror","",GetLastError()) ;
  2026. #endif /* COMMENT */
  2027.     return rc ;
  2028. #else /* not NT */
  2029.     APIRET rc = 0 ;
  2030.     ULONG semcount = 0 ;
  2031.  
  2032.     rc = DosResetEventSem( hevVscrnDirty[vmode], &semcount ) ;
  2033.     return semcount ;
  2034. #endif /* NT */
  2035. }
  2036.  
  2037. APIRET
  2038. CloseVscrnDirtySem( void )
  2039. {
  2040.    int i, rc = 0 ;
  2041.    for ( i=0 ; i<VNUM ; i++ )
  2042.    {
  2043. #ifdef NT
  2044.     rc = CloseHandle( hevVscrnDirty[i] ) ;
  2045.     hevVscrnDirty[i] = (HANDLE) NULL ;
  2046.     if (!rc)
  2047.        return GetLastError() ;
  2048. #else /* not NT */
  2049.     rc = DosCloseEventSem( hevVscrnDirty[i] ) ;
  2050.     hevVscrnDirty[i] = 0 ;
  2051.     if (rc)
  2052.        return rc ;
  2053. #endif /* NT */
  2054.    }
  2055.    return 0;
  2056. }
  2057.  
  2058. APIRET
  2059. CreateVscrnMuxWait( int vmode )
  2060. {
  2061. #ifdef NT
  2062.     if ( hevVscrnDirty[vmode] == NULL ||
  2063.          hevVscrnTimer[vmode] == NULL )
  2064.         return 1 ;
  2065.     hevVscrnUpdate[vmode][0] = hevVscrnDirty[vmode] ;
  2066.     hevVscrnUpdate[vmode][1] = hevVscrnTimer[vmode] ;
  2067.     return 0 ;
  2068. #else /* not NT */
  2069. #define VSCRN_DIRTY 1
  2070. #define VSCRN_TIMER 2
  2071.     static SEMRECORD upd_scr_rec[VNUM][2] ;
  2072.     APIRET rc ;
  2073.  
  2074.     upd_scr_rec[vmode][0].hsemCur = (HSEM) hevVscrnDirty[vmode] ;
  2075.     upd_scr_rec[vmode][0].ulUser  = VSCRN_DIRTY ;
  2076.     upd_scr_rec[vmode][1].hsemCur = (HSEM) hevVscrnTimer[vmode] ;
  2077.     upd_scr_rec[vmode][1].ulUser  = VSCRN_TIMER ;
  2078.     if ( hmuxVscrnUpdate[vmode] )
  2079.         DosCloseMuxWaitSem( hmuxVscrnUpdate[vmode] ) ;
  2080.     rc = DosCreateMuxWaitSem( NULL, &hmuxVscrnUpdate[vmode], 2, upd_scr_rec[vmode],
  2081.         DCMW_WAIT_ALL | DC_SEM_SHARED );
  2082.     return rc ;
  2083. #endif /* NT */
  2084. }
  2085.  
  2086. APIRET
  2087. WaitVscrnMuxWait( int vmode, ULONG timo )
  2088. {
  2089. #ifdef NT
  2090.     APIRET rc = 0 ;
  2091.     rc = WaitForMultipleObjectsEx( 2, hevVscrnUpdate[vmode], TRUE, timo, TRUE ) ;
  2092. #ifdef COMMENT
  2093.     debug(F101,"WaitVscrnMuxWait waitformultipleobjects rc","",rc);
  2094. #endif /* COMMENT */
  2095.     return ( rc == WAIT_OBJECT_0 || rc == WAIT_OBJECT_0 + 1 )? rc+1 : 0 ;
  2096. #else /* not NT */
  2097.     APIRET rc ;
  2098.     ULONG semid = 0;
  2099.     rc = DosWaitMuxWaitSem( hmuxVscrnUpdate[vmode], timo, &semid ) ;
  2100.     return semid ;
  2101. #endif /* NT */
  2102. }
  2103.  
  2104. APIRET
  2105. CloseVscrnMuxWait( int vmode )
  2106. {
  2107. #ifdef NT
  2108.     hevVscrnUpdate[vmode][0] = NULL ;
  2109.     hevVscrnUpdate[vmode][1] = NULL ;
  2110.     return 0 ;
  2111. #else /* not NT */
  2112.     APIRET rc ;
  2113.     rc = DosCloseMuxWaitSem( hmuxVscrnUpdate[vmode] ) ;
  2114.     hmuxVscrnUpdate[vmode] = 0 ;
  2115.     return rc ;
  2116. #endif /* NT */
  2117. }
  2118.  
  2119. /* Process and Thread management */
  2120.  
  2121. APIRET
  2122. ResetThreadPrty( void )
  2123. {
  2124. #ifdef NT
  2125.    SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_NORMAL ) ;
  2126. #else
  2127.     DosSetPriority( PRTYS_THREAD, XYP_REG, PRTYD_MINIMUM, 0 ) ;
  2128. #endif
  2129.    return 0;
  2130. }
  2131.  
  2132. APIRET
  2133. SetThreadPrty( int priority, int class )
  2134. {
  2135. #ifdef NT
  2136.     switch ( priority ) {
  2137.     case XYP_IDLE:
  2138.         class -= 3;
  2139.         break;
  2140.     case XYP_SRV:
  2141.         class += 3;
  2142.         break;
  2143.     case XYP_RTP:
  2144.         class += 6;
  2145.         break;
  2146.     }
  2147.     SetThreadPriority( GetCurrentThread(), class ) ;
  2148.     return 0;
  2149. #else /* not NT */
  2150.     DosSetPriority( PRTYS_THREAD, priority, PRTYD_MINIMUM, 0 ) ;
  2151.     return DosSetPriority( PRTYS_THREAD, priority, class, 0 ) ;
  2152. #endif /* NT */
  2153. }
  2154.  
  2155. APIRET
  2156. KillProcess( int pid )
  2157. {
  2158. #ifdef NT
  2159.         HANDLE process ;
  2160.     debug(F101,"KillProcess pid","",pid);
  2161.     process = OpenProcess( PROCESS_TERMINATE, FALSE, pid ) ;
  2162.         TerminateProcess( process, 1 ) ;
  2163.         CloseHandle( process ) ;
  2164.     return 0;
  2165. #else /* NT */
  2166.     debug(F100,"KillProcess","",0);
  2167.     return DosKillProcess(DKP_PROCESS, pid);
  2168. #endif /* NT */
  2169. }
  2170.  
  2171. #ifdef NT
  2172. APIRET
  2173. CreateSerialMutex( BOOL owned )
  2174. {
  2175.     if ( hmtxSerial )
  2176. #ifdef NT
  2177.         CloseHandle( hmtxSerial ) ;
  2178.     hmtxSerial = CreateMutex( NULL, owned, NULL ) ;
  2179.     return hmtxSerial == NULL ? GetLastError() : 0 ;
  2180. #else /* not NT */
  2181.         DosCloseMutexSem( hmtxSerial ) ;
  2182.     return DosCreateMutexSem( NULL, &hmtxSerial, 0, owned ) ;
  2183. #endif /* NT */
  2184. }
  2185.  
  2186. APIRET
  2187. RequestSerialMutex( ULONG timo )
  2188. {
  2189. #ifdef NT
  2190.     DWORD rc = 0 ;
  2191.  
  2192.     rc = WaitForSingleObjectEx( hmtxSerial, timo, TRUE ) ;
  2193.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  2194. #else /* not NT */
  2195.     return DosRequestMutexSem( hmtxSerial, timo ) ;
  2196. #endif /* NT */
  2197. }
  2198.  
  2199. APIRET
  2200. ReleaseSerialMutex( void )
  2201. {
  2202. #ifdef NT
  2203.     BOOL rc = 0 ;
  2204.  
  2205.     rc = ReleaseMutex( hmtxSerial ) ;
  2206.     return rc == TRUE ? 0 : GetLastError() ;
  2207. #else /* not NT */
  2208.     return DosReleaseMutexSem( hmtxSerial ) ;
  2209. #endif /* NT */
  2210. }
  2211.  
  2212. APIRET
  2213. CloseSerialMutex( void )
  2214. {
  2215. #ifdef NT
  2216.     BOOL rc = 0 ;
  2217.     rc = CloseHandle( hmtxSerial ) ;
  2218.     hmtxSerial = (HANDLE) NULL ;
  2219.     return rc == TRUE ? 0 : GetLastError() ;
  2220. #else /* not NT */
  2221.     APIRET rc ;
  2222.     rc = DosCloseMutexSem( hmtxSerial ) ;
  2223.     hmtxSerial = 0 ;
  2224.     return rc ;
  2225. #endif /* NT */
  2226. }
  2227. #endif /* NT */
  2228. APIRET
  2229. CreateThreadMgmtMutex( BOOL owned )
  2230. {
  2231.     if ( hmtxThreadMgmt )
  2232. #ifdef NT
  2233.         CloseHandle( hmtxThreadMgmt ) ;
  2234.     hmtxThreadMgmt = CreateMutex( NULL, owned, NULL ) ;
  2235.     return hmtxThreadMgmt == NULL ? GetLastError() : 0 ;
  2236. #else /* not NT */
  2237.         DosCloseMutexSem( hmtxThreadMgmt ) ;
  2238.     return DosCreateMutexSem( NULL, &hmtxThreadMgmt, 0, owned ) ;
  2239. #endif /* NT */
  2240. }
  2241.  
  2242. APIRET
  2243. RequestThreadMgmtMutex( ULONG timo )
  2244. {
  2245. #ifdef NT
  2246.     DWORD rc = 0 ;
  2247.  
  2248.     rc = WaitForSingleObjectEx( hmtxThreadMgmt, timo, TRUE ) ;
  2249.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  2250. #else /* not NT */
  2251.     return DosRequestMutexSem( hmtxThreadMgmt, timo ) ;
  2252. #endif /* NT */
  2253. }
  2254.  
  2255. APIRET
  2256. ReleaseThreadMgmtMutex( void )
  2257. {
  2258. #ifdef NT
  2259.     BOOL rc = 0 ;
  2260.  
  2261.     rc = ReleaseMutex( hmtxThreadMgmt ) ;
  2262.     return rc == TRUE ? 0 : GetLastError() ;
  2263. #else /* not NT */
  2264.     return DosReleaseMutexSem( hmtxThreadMgmt ) ;
  2265. #endif /* NT */
  2266. }
  2267.  
  2268. APIRET
  2269. CloseThreadMgmtMutex( void )
  2270. {
  2271. #ifdef NT
  2272.     BOOL rc = 0 ;
  2273.     rc = CloseHandle( hmtxThreadMgmt ) ;
  2274.     hmtxThreadMgmt = (HANDLE) NULL ;
  2275.     return rc == TRUE ? 0 : GetLastError() ;
  2276. #else /* not NT */
  2277.     APIRET rc ;
  2278.     rc = DosCloseMutexSem( hmtxThreadMgmt ) ;
  2279.     hmtxThreadMgmt = 0 ;
  2280.     return rc ;
  2281. #endif /* NT */
  2282. }
  2283.  
  2284. APIRET
  2285. CreateCtrlCSem( BOOL posted, ULONG * index )
  2286. {
  2287.     APIRET rc = 0 ;
  2288.     if ( CtrlCCount == MAXCTRLC ) {
  2289.         *index = -1 ;
  2290.         return -1;
  2291.     }
  2292.     CtrlCCount++ ;
  2293.     if ( hevCtrlC[CtrlCCount] )
  2294. #ifdef NT
  2295.         CloseHandle( hevCtrlC[CtrlCCount] ) ;
  2296.     hevCtrlC[CtrlCCount] = CreateEvent( NULL, TRUE, posted, NULL ) ;
  2297.     if ( hevCtrlC[CtrlCCount] == NULL )
  2298.     {
  2299.         CtrlCCount-- ;
  2300.         rc = GetLastError() ;
  2301.     }
  2302. #else /* not NT */
  2303.         DosCloseEventSem( hevCtrlC[CtrlCCount] ) ;
  2304.     rc = DosCreateEventSem( NULL, &hevCtrlC[CtrlCCount], DC_SEM_SHARED, posted ) ;
  2305.     if ( rc != 0 )
  2306.         CtrlCCount-- ;
  2307. #endif /* NT */
  2308.     *index = CtrlCCount ;
  2309.     return rc ;
  2310. }
  2311.  
  2312. APIRET
  2313. PostCtrlCSem(void)
  2314. {
  2315.     APIRET rc = 0 ;
  2316.     if ( CtrlCCount < 0 )
  2317.         return -1 ;
  2318. #ifdef NT
  2319.     rc = SetEvent( hevCtrlC[CtrlCCount] ) == TRUE ? 0 : GetLastError() ;
  2320. #else /* not NT */
  2321.     rc = DosPostEventSem( hevCtrlC[CtrlCCount] ) ;
  2322. #endif /* NT */
  2323.     return rc ;
  2324. }
  2325.  
  2326. APIRET
  2327. WaitCtrlCSem( ULONG index, ULONG timo )
  2328. {
  2329. #ifdef NT
  2330.     DWORD rc = 0 ;
  2331.  
  2332.     rc = WaitForSingleObjectEx( hevCtrlC[index], timo, TRUE ) ;
  2333.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  2334. #else /* not NT */
  2335.     APIRET rc = 0 ;
  2336.  
  2337.     rc = DosWaitEventSem( hevCtrlC[index], timo ) ;
  2338.     return rc ;
  2339. #endif /* NT */
  2340. }
  2341.  
  2342. APIRET
  2343. WaitAndResetCtrlCSem( ULONG index, ULONG timo )
  2344. {
  2345. #ifdef NT
  2346.     DWORD rc = 0 ;
  2347.  
  2348.     rc = WaitForSingleObjectEx( hevCtrlC[index], timo, TRUE ) ;
  2349.     if ( rc == WAIT_OBJECT_0 )
  2350.         ResetEvent( hevCtrlC[index] ) ;
  2351.     return rc == WAIT_OBJECT_0 ;
  2352. #else /* not NT */
  2353.     APIRET rc = 0 ;
  2354.     ULONG  semcount = 0 ;
  2355.  
  2356.     rc = DosWaitEventSem( hevCtrlC[index], timo ) ;
  2357.     if ( !rc )
  2358.         DosResetEventSem( hevCtrlC[index], &semcount ) ;
  2359.     return semcount ;
  2360. #endif /* NT */
  2361. }
  2362.  
  2363. APIRET
  2364. ResetCtrlCSem( ULONG index )
  2365. {
  2366. #ifdef NT
  2367.     BOOL rc = 0 ;
  2368.  
  2369.     rc = ResetEvent( hevCtrlC[index] ) ;
  2370.     return rc ;
  2371. #else /* not NT */
  2372.     APIRET rc = 0 ;
  2373.     ULONG semcount = 0 ;
  2374.  
  2375.     rc = DosResetEventSem( hevCtrlC[index], &semcount ) ;
  2376.     return semcount ;
  2377. #endif /* NT */
  2378. }
  2379.  
  2380. APIRET
  2381. CloseCtrlCSem( ULONG index )
  2382. {
  2383.     APIRET rc = 0 ;
  2384.     if ( index != CtrlCCount )
  2385.         return -1;
  2386. #ifdef NT
  2387.     rc = CloseHandle( hevCtrlC[index] ) == TRUE ? 0 : GetLastError() ;
  2388.     hevCtrlC[index] = (HANDLE) NULL ;
  2389. #else /* not NT */
  2390.     rc = DosCloseEventSem( hevCtrlC[index] ) ;
  2391.     hevCtrlC[index] = 0 ;
  2392. #endif /* NT */
  2393.     CtrlCCount-- ;
  2394.     return rc;
  2395. }
  2396.  
  2397. APIRET
  2398. CreateCtrlCMuxWait( ULONG ccindex,
  2399. #ifdef NT
  2400.                   HANDLE hevThread
  2401. #else /* NT */
  2402.                   HEV hevThread
  2403. #endif /* NT */
  2404.                   )
  2405. {
  2406. #ifdef NT
  2407.     if ( hevCtrlC[ccindex] == NULL || hevThread == NULL )
  2408.         return -1 ;
  2409.     hmuxCtrlC[ccindex][0] = hevCtrlC[ccindex] ;
  2410.     hmuxCtrlC[ccindex][1] = hevThread ;
  2411.     return 0 ;
  2412. #else /* not NT */
  2413. #define CTRL_C 1
  2414. #define THREAD 2
  2415.     SEMRECORD upd_scr_rec[2] ;
  2416.     APIRET rc ;
  2417.  
  2418.     upd_scr_rec[0].hsemCur = (HSEM) hevCtrlC[ccindex] ;
  2419.     upd_scr_rec[0].ulUser  = CTRL_C ;
  2420.     upd_scr_rec[1].hsemCur = (HSEM) hevThread ;
  2421.     upd_scr_rec[1].ulUser  = THREAD ;
  2422.     if ( hmuxCtrlC[ccindex] )
  2423.         DosCloseMuxWaitSem( hmuxCtrlC[ccindex] ) ;
  2424.     rc = DosCreateMuxWaitSem( NULL, &hmuxCtrlC[ccindex], 2, upd_scr_rec,
  2425.         DCMW_WAIT_ANY | DC_SEM_SHARED );
  2426.     return rc ;
  2427. #endif /* NT */
  2428. }
  2429.  
  2430. APIRET
  2431. WaitCtrlCMuxWait( ULONG ccindex, ULONG timo )
  2432. {
  2433. #ifdef NT
  2434.     APIRET rc = 0 ;
  2435.     rc = WaitForMultipleObjectsEx( 2, hmuxCtrlC[ccindex], FALSE, timo, TRUE ) ;
  2436.     return ( rc == WAIT_OBJECT_0 || rc == WAIT_OBJECT_0 + 1 )
  2437.         ? rc - WAIT_OBJECT_0 + 1 : 0 ;
  2438. #else /* not NT */
  2439.     APIRET rc ;
  2440.     ULONG semid = 0;
  2441.     do
  2442.     {
  2443.         rc = DosWaitMuxWaitSem( hmuxCtrlC[ccindex], timo, &semid ) ;
  2444.     }
  2445.     while ( rc == ERROR_INTERRUPT );
  2446.     return semid ;
  2447. #endif /* NT */
  2448. }
  2449.  
  2450. APIRET
  2451. CloseCtrlCMuxWait( ULONG ccindex )
  2452. {
  2453. #ifdef NT
  2454.     hmuxCtrlC[ccindex][0] = NULL ;
  2455.     hmuxCtrlC[ccindex][1] = NULL ;
  2456.     return 0 ;
  2457. #else /* not NT */
  2458.     APIRET rc ;
  2459.     rc = DosCloseMuxWaitSem( hmuxCtrlC[ccindex] ) ;
  2460.     hmuxCtrlC[ccindex] = 0 ;
  2461.     return rc ;
  2462. #endif /* NT */
  2463. }
  2464.  
  2465. APIRET
  2466. CreateAlarmSigSem( BOOL posted, ULONG * index )
  2467. {
  2468.     APIRET rc = 0 ;
  2469.     if ( AlarmSigCount == MAXALARMSIG ) {
  2470.         *index = -1 ;
  2471.         return -1;
  2472.     }
  2473.     AlarmSigCount++ ;
  2474.     if ( hevAlarmSig[AlarmSigCount] )
  2475. #ifdef NT
  2476.         CloseHandle( hevAlarmSig[AlarmSigCount] ) ;
  2477.     hevAlarmSig[AlarmSigCount] = CreateEvent( NULL, TRUE, posted, NULL ) ;
  2478.     if ( hevAlarmSig[AlarmSigCount] == NULL )
  2479.     {
  2480.         AlarmSigCount-- ;
  2481.         rc = GetLastError() ;
  2482.     }
  2483. #else /* not NT */
  2484.         DosCloseEventSem( hevAlarmSig[AlarmSigCount] ) ;
  2485.     rc = DosCreateEventSem( NULL, &hevAlarmSig[AlarmSigCount], DC_SEM_SHARED, posted ) ;
  2486.     if ( rc != 0 )
  2487.         AlarmSigCount-- ;
  2488. #endif /* NT */
  2489.     *index = AlarmSigCount ;
  2490.     debug(F101,"CreateAlarmSigSem AlarmSigCount","",AlarmSigCount) ;
  2491.     return rc ;
  2492. }
  2493.  
  2494. APIRET
  2495. PostAlarmSigSem(void)
  2496. {
  2497.     APIRET rc = 0 ;
  2498.     debug(F101,"PostAlarmSigSem AlarmSigCount","",AlarmSigCount) ;
  2499.     if ( AlarmSigCount < 0 )
  2500.         return -1 ;
  2501. #ifdef NT
  2502.     rc = SetEvent( hevAlarmSig[AlarmSigCount] ) == TRUE ? 0 : GetLastError() ;
  2503. #else /* not NT */
  2504.     rc = DosPostEventSem( hevAlarmSig[AlarmSigCount] ) ;
  2505. #endif /* NT */
  2506.     return rc ;
  2507. }
  2508.  
  2509. APIRET
  2510. WaitAlarmSigSem( ULONG index, ULONG timo )
  2511. {
  2512. #ifdef NT
  2513.     DWORD rc = 0 ;
  2514.  
  2515.     rc = WaitForSingleObjectEx( hevAlarmSig[index], timo, TRUE ) ;
  2516.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  2517. #else /* not NT */
  2518.     APIRET rc = 0 ;
  2519.  
  2520.     rc = DosWaitEventSem( hevAlarmSig[index], timo ) ;
  2521.     return rc ;
  2522. #endif /* NT */
  2523. }
  2524.  
  2525. APIRET
  2526. WaitAndResetAlarmSigSem( ULONG index, ULONG timo )
  2527. {
  2528. #ifdef NT
  2529.     DWORD rc = 0 ;
  2530.  
  2531.     rc = WaitForSingleObjectEx( hevAlarmSig[index], timo, TRUE ) ;
  2532.     if ( rc == WAIT_OBJECT_0 )
  2533.         ResetEvent( hevAlarmSig[index] ) ;
  2534.     return rc == WAIT_OBJECT_0 ;
  2535. #else /* not NT */
  2536.     APIRET rc = 0 ;
  2537.     ULONG  semcount = 0 ;
  2538.  
  2539.     rc = DosWaitEventSem( hevAlarmSig[index], timo ) ;
  2540.     if ( !rc )
  2541.         DosResetEventSem( hevAlarmSig[index], &semcount ) ;
  2542.     return semcount ;
  2543. #endif /* NT */
  2544. }
  2545.  
  2546. APIRET
  2547. ResetAlarmSigSem( ULONG index )
  2548. {
  2549. #ifdef NT
  2550.     BOOL rc = 0 ;
  2551.     debug(F101,"ResetAlarmSigSem index","",index) ;
  2552.     rc = ResetEvent( hevAlarmSig[index] ) ;
  2553.     return rc ;
  2554. #else /* not NT */
  2555.     APIRET rc = 0 ;
  2556.     ULONG semcount = 0 ;
  2557.  
  2558.     rc = DosResetEventSem( hevAlarmSig[index], &semcount ) ;
  2559.     return semcount ;
  2560. #endif /* NT */
  2561. }
  2562.  
  2563. APIRET
  2564. CloseAlarmSigSem( ULONG index )
  2565. {
  2566.     APIRET rc = 0 ;
  2567.     debug(F101,"CloseAlarmSigSem index","",index) ;
  2568.     if ( index != AlarmSigCount )
  2569.         return -1;
  2570. #ifdef NT
  2571.     rc = CloseHandle( hevAlarmSig[index] ) == TRUE ? 0 : GetLastError() ;
  2572.     hevAlarmSig[index] = (HANDLE) NULL ;
  2573. #else /* not NT */
  2574.     rc = DosCloseEventSem( hevAlarmSig[index] ) ;
  2575.     hevAlarmSig[index] = 0 ;
  2576. #endif /* NT */
  2577.     AlarmSigCount-- ;
  2578.     return rc;
  2579. }
  2580.  
  2581. APIRET
  2582. CreateAlarmSigMuxWait( ULONG alrmindex,
  2583. #ifdef NT
  2584.                   HANDLE hevThread
  2585. #else /* NT */
  2586.                   HEV hevThread
  2587. #endif /* NT */
  2588.                   )
  2589. {
  2590. #ifdef NT
  2591.     if ( hevAlarmSig[alrmindex] == NULL || hevThread == NULL )
  2592.         return -1 ;
  2593.     hmuxAlarmSig[alrmindex][0] = hevAlarmSig[alrmindex] ;
  2594.     hmuxAlarmSig[alrmindex][1] = hevThread ;
  2595.     return 0 ;
  2596. #else /* not NT */
  2597. #define ALRM 1
  2598. #define THREAD 2
  2599.     SEMRECORD upd_scr_rec[2] ;
  2600.     APIRET rc ;
  2601.  
  2602.     upd_scr_rec[0].hsemCur = (HSEM) hevAlarmSig[alrmindex] ;
  2603.     upd_scr_rec[0].ulUser  = ALRM ;
  2604.     upd_scr_rec[1].hsemCur = (HSEM) hevThread ;
  2605.     upd_scr_rec[1].ulUser  = THREAD ;
  2606.     if ( hmuxAlarmSig[alrmindex] )
  2607.         DosCloseMuxWaitSem( hmuxAlarmSig[alrmindex] ) ;
  2608.     rc = DosCreateMuxWaitSem( NULL, &hmuxAlarmSig[alrmindex], 2, upd_scr_rec,
  2609.         DCMW_WAIT_ANY | DC_SEM_SHARED );
  2610.     return rc ;
  2611. #endif /* NT */
  2612. }
  2613.  
  2614. APIRET
  2615. WaitAlarmSigMuxWait( ULONG alrmindex, ULONG timo )
  2616. {
  2617. #ifdef NT
  2618.     APIRET rc = 0 ;
  2619.     rc = WaitForMultipleObjectsEx( 2, hmuxAlarmSig[alrmindex], FALSE, timo, TRUE ) ;
  2620.     return ( rc == WAIT_OBJECT_0 || rc == WAIT_OBJECT_0 + 1 )
  2621.         ? rc - WAIT_OBJECT_0 + 1 : 0 ;
  2622. #else /* not NT */
  2623.     APIRET rc ;
  2624.     ULONG semid = 0;
  2625.     do
  2626.     {
  2627.         rc = DosWaitMuxWaitSem( hmuxAlarmSig[alrmindex], timo, &semid ) ;
  2628.     }
  2629.     while ( rc == ERROR_INTERRUPT );
  2630.     return semid ;
  2631. #endif /* NT */
  2632. }
  2633.  
  2634. APIRET
  2635. CloseAlarmSigMuxWait( ULONG alrmindex )
  2636. {
  2637. #ifdef NT
  2638.     hmuxAlarmSig[alrmindex][0] = NULL ;
  2639.     hmuxAlarmSig[alrmindex][1] = NULL ;
  2640.     return 0 ;
  2641. #else /* not NT */
  2642.     APIRET rc ;
  2643.     rc = DosCloseMuxWaitSem( hmuxAlarmSig[alrmindex] ) ;
  2644.     hmuxAlarmSig[alrmindex] = 0 ;
  2645.     return rc ;
  2646. #endif /* NT */
  2647. }
  2648.  
  2649. APIRET
  2650. CreateCtrlCAlarmSigMuxWait( ULONG ccindex, ULONG alrmindex,
  2651. #ifdef NT
  2652.                   HANDLE hevThread
  2653. #else /* NT */
  2654.                   HEV hevThread
  2655. #endif /* NT */
  2656.                   )
  2657. {
  2658. #ifdef NT
  2659.     if ( hevCtrlC[ccindex] == NULL ||
  2660.                  hevAlarmSig[alrmindex] == NULL ||
  2661.                  hevThread == NULL )
  2662.         return -1 ;
  2663.     hmuxCtrlCAlarmSig[0] = hevCtrlC[ccindex] ;
  2664.     hmuxCtrlCAlarmSig[1] = hevAlarmSig[alrmindex] ;
  2665.     hmuxCtrlCAlarmSig[2] = hevThread ;
  2666.     return 0 ;
  2667. #else /* not NT */
  2668.     SEMRECORD upd_scr_rec[3] ;
  2669.     APIRET rc ;
  2670.  
  2671.     upd_scr_rec[0].hsemCur = (HSEM) hevCtrlC[ccindex] ;
  2672.     upd_scr_rec[0].ulUser  = 1;
  2673.     upd_scr_rec[1].hsemCur = (HSEM) hevAlarmSig[alrmindex] ;
  2674.     upd_scr_rec[1].ulUser  = 1;
  2675.     upd_scr_rec[2].hsemCur = (HSEM) hevThread ;
  2676.     upd_scr_rec[2].ulUser  = 2 ;
  2677.     if ( hmuxCtrlCAlarmSig )
  2678.         DosCloseMuxWaitSem( hmuxCtrlCAlarmSig ) ;
  2679.     rc = DosCreateMuxWaitSem( NULL, &hmuxCtrlCAlarmSig, 3, upd_scr_rec,
  2680.         DCMW_WAIT_ANY | DC_SEM_SHARED );
  2681.     return rc ;
  2682. #endif /* NT */
  2683. }
  2684.  
  2685. APIRET
  2686. WaitCtrlCAlarmSigMuxWait( ULONG ccindex, ULONG alrmindex, ULONG timo )
  2687. {
  2688. #ifdef NT
  2689.     APIRET rc = 0 ;
  2690.     rc = WaitForMultipleObjectsEx( 3, hmuxCtrlCAlarmSig, FALSE, timo, TRUE ) ;
  2691.     return ( rc == WAIT_OBJECT_0 || rc == WAIT_OBJECT_0 + 1 || rc == WAIT_OBJECT_0 + 2 )
  2692.         ? rc - WAIT_OBJECT_0 + 1 : 0 ;
  2693. #else /* not NT */
  2694.     APIRET rc ;
  2695.     ULONG semid = 0;
  2696.     do
  2697.     {
  2698.         rc = DosWaitMuxWaitSem( hmuxCtrlCAlarmSig, timo, &semid ) ;
  2699.     }
  2700.     while ( rc == ERROR_INTERRUPT );
  2701.     return semid ;
  2702. #endif /* NT */
  2703. }
  2704.  
  2705. APIRET
  2706. CloseCtrlCAlarmSigMuxWait( ULONG ccindex, ULONG alrmindex )
  2707. {
  2708. #ifdef NT
  2709.     hmuxCtrlCAlarmSig[0] = NULL ;
  2710.     hmuxCtrlCAlarmSig[1] = NULL ;
  2711.     hmuxCtrlCAlarmSig[2] = NULL ;
  2712.    return 0 ;
  2713. #else /* not NT */
  2714.     APIRET rc ;
  2715.     rc = DosCloseMuxWaitSem( hmuxCtrlCAlarmSig ) ;
  2716.     hmuxCtrlCAlarmSig = 0 ;
  2717.     return rc ;
  2718. #endif /* NT */
  2719. }
  2720.  
  2721. APIRET
  2722. #ifdef NT
  2723. PostSem( HANDLE hev )
  2724. #else /* NT */
  2725. PostSem( HEV hev )
  2726. #endif /* NT */
  2727. {
  2728. #ifdef NT
  2729.     BOOL rc = 0 ;
  2730.  
  2731.     rc = SetEvent( hev ) ;
  2732.     return rc == TRUE ? 0 : GetLastError() ;
  2733. #else /* not NT */
  2734.     return DosPostEventSem( hev ) ;
  2735. #endif /* NT */
  2736. }
  2737.  
  2738. APIRET
  2739. #ifdef NT
  2740. WaitSem( HANDLE hev, ULONG timo )
  2741. #else /* NT */
  2742. WaitSem( HEV hev, ULONG timo )
  2743. #endif /* NT */
  2744. {
  2745. #ifdef NT
  2746.     DWORD rc = 0 ;
  2747.  
  2748.     rc = WaitForSingleObjectEx( hev, timo, TRUE ) ;
  2749.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  2750. #else /* not NT */
  2751.     APIRET rc = 0 ;
  2752.  
  2753.     rc = DosWaitEventSem( hev, timo ) ;
  2754.     return rc ;
  2755. #endif /* NT */
  2756. }
  2757.  
  2758. APIRET
  2759. #ifdef NT
  2760. WaitAndResetSem( HANDLE hev, ULONG timo )
  2761. #else /* NT */
  2762. WaitAndResetSem( HEV hev, ULONG timo )
  2763. #endif /* NT */
  2764. {
  2765. #ifdef NT
  2766.     DWORD rc = 0 ;
  2767.  
  2768.     rc = WaitForSingleObjectEx( hev, timo, TRUE ) ;
  2769.     if ( rc == WAIT_OBJECT_0 )
  2770.         ResetEvent( hev ) ;
  2771.     return rc == WAIT_OBJECT_0 ;
  2772. #else /* not NT */
  2773.     APIRET rc = 0 ;
  2774.     ULONG  semcount = 0 ;
  2775.  
  2776.     rc = DosWaitEventSem( hev, timo ) ;
  2777.     if ( !rc )
  2778.         DosResetEventSem( hev, &semcount ) ;
  2779.     return semcount ;
  2780. #endif /* NT */
  2781. }
  2782.  
  2783. APIRET
  2784. #ifdef NT
  2785. ResetSem( HANDLE hev )
  2786. #else /* NT */
  2787. ResetSem( HEV hev )
  2788. #endif /* NT */
  2789. {
  2790. #ifdef NT
  2791.     BOOL rc = 0 ;
  2792.  
  2793.     rc = ResetEvent( hev ) ;
  2794.     return rc ;
  2795. #else /* not NT */
  2796.     APIRET rc = 0 ;
  2797.     ULONG semcount = 0 ;
  2798.  
  2799.     rc = DosResetEventSem( hev, &semcount ) ;
  2800.     return semcount ;
  2801. #endif /* NT */
  2802. }
  2803.  
  2804. #ifdef CK_TAPI
  2805. APIRET
  2806. CreateTAPIConnectSem( BOOL posted )
  2807. {
  2808.     if ( hevTAPIConnect )
  2809. #ifdef NT
  2810.         CloseHandle( hevTAPIConnect ) ;
  2811.     hevTAPIConnect = CreateEvent( NULL, TRUE, posted, NULL ) ;
  2812.     return hevTAPIConnect == NULL ? GetLastError() : 0 ;
  2813. #else /* not NT */
  2814.         DosCloseEventSem( hevTAPIConnect ) ;
  2815.     return DosCreateEventSem( NULL, &hevTAPIConnect, 0, posted ) ;
  2816. #endif /* NT */
  2817. }
  2818.  
  2819. APIRET
  2820. PostTAPIConnectSem( void )
  2821. {
  2822. #ifdef NT
  2823.     BOOL rc = 0 ;
  2824.  
  2825.     rc = SetEvent( hevTAPIConnect ) ;
  2826.     return rc == TRUE ? 0 : GetLastError() ;
  2827. #else /* not NT */
  2828.     return DosPostEventSem( hevTAPIConnect ) ;
  2829. #endif /* NT */
  2830. }
  2831.  
  2832. APIRET
  2833. WaitTAPIConnectSem( ULONG timo )
  2834. {
  2835. #ifdef NT
  2836.     DWORD rc = 0 ;
  2837.  
  2838.     rc = WaitForSingleObjectEx( hevTAPIConnect, timo, TRUE ) ;
  2839.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  2840. #else /* not NT */
  2841.     APIRET rc = 0 ;
  2842.  
  2843.     rc = DosWaitEventSem( hevTAPIConnect, timo ) ;
  2844.     return rc ;
  2845. #endif /* NT */
  2846. }
  2847.  
  2848. APIRET
  2849. WaitAndResetTAPIConnectSem( ULONG timo )
  2850. {
  2851. #ifdef NT
  2852.     DWORD rc = 0 ;
  2853.  
  2854.     rc = WaitForSingleObjectEx( hevTAPIConnect, timo, TRUE ) ;
  2855.     if ( rc == WAIT_OBJECT_0 )
  2856.         ResetEvent( hevTAPIConnect ) ;
  2857.     return rc == WAIT_OBJECT_0 ;
  2858. #else /* not NT */
  2859.     APIRET rc = 0 ;
  2860.     ULONG  semcount = 0 ;
  2861.  
  2862.     rc = DosWaitEventSem( hevTAPIConnect, timo ) ;
  2863.     if ( !rc )
  2864.         DosResetEventSem( hevTAPIConnect, &semcount ) ;
  2865.     return semcount ;
  2866. #endif /* NT */
  2867. }
  2868.  
  2869. APIRET
  2870. ResetTAPIConnectSem( void )
  2871. {
  2872. #ifdef NT
  2873.     BOOL rc = 0 ;
  2874.  
  2875.     rc = ResetEvent( hevTAPIConnect ) ;
  2876.     return rc ;
  2877. #else /* not NT */
  2878.     APIRET rc = 0 ;
  2879.     ULONG semcount = 0 ;
  2880.  
  2881.     rc = DosResetEventSem( hevTAPIConnect, &semcount ) ;
  2882.     return rc ;
  2883. #endif /* NT */
  2884. }
  2885.  
  2886. APIRET
  2887. CloseTAPIConnectSem( void )
  2888. {
  2889. #ifdef NT
  2890.     BOOL rc = 0 ;
  2891.     rc = CloseHandle( hevTAPIConnect ) ;
  2892.     hevTAPIConnect = (HANDLE) NULL ;
  2893.     return rc == TRUE ? 0 : GetLastError() ;
  2894. #else /* not NT */
  2895.     APIRET rc ;
  2896.     rc = DosCloseEventSem( hevTAPIConnect ) ;
  2897.     hevTAPIConnect = 0 ;
  2898.     return rc ;
  2899. #endif /* NT */
  2900. }
  2901.  
  2902. APIRET
  2903. CreateTAPIAnswerSem( BOOL posted )
  2904. {
  2905.     if ( hevTAPIAnswer )
  2906. #ifdef NT
  2907.         CloseHandle( hevTAPIAnswer ) ;
  2908.     hevTAPIAnswer = CreateEvent( NULL, TRUE, posted, NULL ) ;
  2909.     return hevTAPIAnswer == NULL ? GetLastError() : 0 ;
  2910. #else /* not NT */
  2911.         DosCloseEventSem( hevTAPIAnswer ) ;
  2912.     return DosCreateEventSem( NULL, &hevTAPIAnswer, 0, posted ) ;
  2913. #endif /* NT */
  2914. }
  2915.  
  2916. APIRET
  2917. PostTAPIAnswerSem( void )
  2918. {
  2919. #ifdef NT
  2920.     BOOL rc = 0 ;
  2921.  
  2922.     rc = SetEvent( hevTAPIAnswer ) ;
  2923.     return rc == TRUE ? 0 : GetLastError() ;
  2924. #else /* not NT */
  2925.     return DosPostEventSem( hevTAPIAnswer ) ;
  2926. #endif /* NT */
  2927. }
  2928.  
  2929. APIRET
  2930. WaitTAPIAnswerSem( ULONG timo )
  2931. {
  2932. #ifdef NT
  2933.     DWORD rc = 0 ;
  2934.  
  2935.     rc = WaitForSingleObjectEx( hevTAPIAnswer, timo, TRUE ) ;
  2936.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  2937. #else /* not NT */
  2938.     APIRET rc = 0 ;
  2939.  
  2940.     rc = DosWaitEventSem( hevTAPIAnswer, timo ) ;
  2941.     return rc ;
  2942. #endif /* NT */
  2943. }
  2944.  
  2945. APIRET
  2946. WaitAndResetTAPIAnswerSem( ULONG timo )
  2947. {
  2948. #ifdef NT
  2949.     DWORD rc = 0 ;
  2950.  
  2951.     rc = WaitForSingleObjectEx( hevTAPIAnswer, timo, TRUE ) ;
  2952.     if ( rc == WAIT_OBJECT_0 )
  2953.         ResetEvent( hevTAPIAnswer ) ;
  2954.     return rc == WAIT_OBJECT_0 ;
  2955. #else /* not NT */
  2956.     APIRET rc = 0 ;
  2957.     ULONG  semcount = 0 ;
  2958.  
  2959.     rc = DosWaitEventSem( hevTAPIAnswer, timo ) ;
  2960.     if ( !rc )
  2961.         DosResetEventSem( hevTAPIAnswer, &semcount ) ;
  2962.     return semcount ;
  2963. #endif /* NT */
  2964. }
  2965.  
  2966. APIRET
  2967. ResetTAPIAnswerSem( void )
  2968. {
  2969. #ifdef NT
  2970.     BOOL rc = 0 ;
  2971.  
  2972.     rc = ResetEvent( hevTAPIAnswer ) ;
  2973.     return rc ;
  2974. #else /* not NT */
  2975.     APIRET rc = 0 ;
  2976.     ULONG semcount = 0 ;
  2977.  
  2978.     rc = DosResetEventSem( hevTAPIAnswer, &semcount ) ;
  2979.     return rc ;
  2980. #endif /* NT */
  2981. }
  2982.  
  2983. APIRET
  2984. CloseTAPIAnswerSem( void )
  2985. {
  2986. #ifdef NT
  2987.     BOOL rc = 0 ;
  2988.     rc = CloseHandle( hevTAPIAnswer ) ;
  2989.     hevTAPIAnswer = (HANDLE) NULL ;
  2990.     return rc == TRUE ? 0 : GetLastError() ;
  2991. #else /* not NT */
  2992.     APIRET rc ;
  2993.     rc = DosCloseEventSem( hevTAPIAnswer ) ;
  2994.     hevTAPIAnswer = 0 ;
  2995.     return rc ;
  2996. #endif /* NT */
  2997. }
  2998.  
  2999. APIRET
  3000. CreateTAPIInitSem( BOOL posted )
  3001. {
  3002.     if ( hevTAPIInit )
  3003. #ifdef NT
  3004.         CloseHandle( hevTAPIInit ) ;
  3005.     hevTAPIInit = CreateEvent( NULL, TRUE, posted, NULL ) ;
  3006.     return hevTAPIInit == NULL ? GetLastError() : 0 ;
  3007. #else /* not NT */
  3008.         DosCloseEventSem( hevTAPIInit ) ;
  3009.     return DosCreateEventSem( NULL, &hevTAPIInit, 0, posted ) ;
  3010. #endif /* NT */
  3011. }
  3012.  
  3013. APIRET
  3014. PostTAPIInitSem( void )
  3015. {
  3016. #ifdef NT
  3017.     BOOL rc = 0 ;
  3018.  
  3019.     rc = SetEvent( hevTAPIInit ) ;
  3020.     return rc == TRUE ? 0 : GetLastError() ;
  3021. #else /* not NT */
  3022.     return DosPostEventSem( hevTAPIInit ) ;
  3023. #endif /* NT */
  3024. }
  3025.  
  3026. APIRET
  3027. WaitTAPIInitSem( ULONG timo )
  3028. {
  3029. #ifdef NT
  3030.     DWORD rc = 0 ;
  3031.  
  3032.     rc = WaitForSingleObjectEx( hevTAPIInit, timo, TRUE ) ;
  3033.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3034. #else /* not NT */
  3035.     APIRET rc = 0 ;
  3036.  
  3037.     rc = DosWaitEventSem( hevTAPIInit, timo ) ;
  3038.     return rc ;
  3039. #endif /* NT */
  3040. }
  3041.  
  3042. APIRET
  3043. WaitAndResetTAPIInitSem( ULONG timo )
  3044. {
  3045. #ifdef NT
  3046.     DWORD rc = 0 ;
  3047.  
  3048.     rc = WaitForSingleObjectEx( hevTAPIInit, timo, TRUE ) ;
  3049.     if ( rc == WAIT_OBJECT_0 )
  3050.         ResetEvent( hevTAPIInit ) ;
  3051.     return rc == WAIT_OBJECT_0 ;
  3052. #else /* not NT */
  3053.     APIRET rc = 0 ;
  3054.     ULONG  semcount = 0 ;
  3055.  
  3056.     rc = DosWaitEventSem( hevTAPIInit, timo ) ;
  3057.     if ( !rc )
  3058.         DosResetEventSem( hevTAPIInit, &semcount ) ;
  3059.     return semcount ;
  3060. #endif /* NT */
  3061. }
  3062.  
  3063. APIRET
  3064. ResetTAPIInitSem( void )
  3065. {
  3066. #ifdef NT
  3067.     BOOL rc = 0 ;
  3068.  
  3069.     rc = ResetEvent( hevTAPIInit ) ;
  3070.     return rc ;
  3071. #else /* not NT */
  3072.     APIRET rc = 0 ;
  3073.     ULONG semcount = 0 ;
  3074.  
  3075.     rc = DosResetEventSem( hevTAPIInit, &semcount ) ;
  3076.     return rc ;
  3077. #endif /* NT */
  3078. }
  3079.  
  3080. APIRET
  3081. CloseTAPIInitSem( void )
  3082. {
  3083. #ifdef NT
  3084.     BOOL rc = 0 ;
  3085.     rc = CloseHandle( hevTAPIInit ) ;
  3086.     hevTAPIInit = (HANDLE) NULL ;
  3087.     return rc == TRUE ? 0 : GetLastError() ;
  3088. #else /* not NT */
  3089.     APIRET rc ;
  3090.     rc = DosCloseEventSem( hevTAPIInit ) ;
  3091.     hevTAPIInit = 0 ;
  3092.     return rc ;
  3093. #endif /* NT */
  3094. }
  3095. #endif /* CK_TAPI */
  3096.  
  3097. APIRET
  3098. CreateRichEditInitSem( BOOL posted )
  3099. {
  3100.     if ( hevRichEditInit )
  3101. #ifdef NT
  3102.         CloseHandle( hevRichEditInit ) ;
  3103.     hevRichEditInit = CreateEvent( NULL, TRUE, posted, NULL ) ;
  3104.     return hevRichEditInit == NULL ? GetLastError() : 0 ;
  3105. #else /* not NT */
  3106.         DosCloseEventSem( hevRichEditInit ) ;
  3107.     return DosCreateEventSem( NULL, &hevRichEditInit, 0, posted ) ;
  3108. #endif /* NT */
  3109. }
  3110.  
  3111. APIRET
  3112. PostRichEditInitSem( void )
  3113. {
  3114. #ifdef NT
  3115.     BOOL rc = 0 ;
  3116.  
  3117.     rc = SetEvent( hevRichEditInit ) ;
  3118.     return rc == TRUE ? 0 : GetLastError() ;
  3119. #else /* not NT */
  3120.     return DosPostEventSem( hevRichEditInit ) ;
  3121. #endif /* NT */
  3122. }
  3123.  
  3124. APIRET
  3125. WaitRichEditInitSem( ULONG timo )
  3126. {
  3127. #ifdef NT
  3128.     DWORD rc = 0 ;
  3129.  
  3130.     rc = WaitForSingleObjectEx( hevRichEditInit, timo, TRUE ) ;
  3131.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3132. #else /* not NT */
  3133.     APIRET rc = 0 ;
  3134.  
  3135.     rc = DosWaitEventSem( hevRichEditInit, timo ) ;
  3136.     return rc ;
  3137. #endif /* NT */
  3138. }
  3139.  
  3140. APIRET
  3141. WaitAndResetRichEditInitSem( ULONG timo )
  3142. {
  3143. #ifdef NT
  3144.     DWORD rc = 0 ;
  3145.  
  3146.     rc = WaitForSingleObjectEx( hevRichEditInit, timo, TRUE ) ;
  3147.     if ( rc == WAIT_OBJECT_0 )
  3148.         ResetEvent( hevRichEditInit ) ;
  3149.     return rc == WAIT_OBJECT_0 ;
  3150. #else /* not NT */
  3151.     APIRET rc = 0 ;
  3152.     ULONG  semcount = 0 ;
  3153.  
  3154.     rc = DosWaitEventSem( hevRichEditInit, timo ) ;
  3155.     if ( !rc )
  3156.         DosResetEventSem( hevRichEditInit, &semcount ) ;
  3157.     return semcount ;
  3158. #endif /* NT */
  3159. }
  3160.  
  3161. APIRET
  3162. ResetRichEditInitSem( void )
  3163. {
  3164. #ifdef NT
  3165.     BOOL rc = 0 ;
  3166.  
  3167.     rc = ResetEvent( hevRichEditInit ) ;
  3168.     return rc ;
  3169. #else /* not NT */
  3170.     APIRET rc = 0 ;
  3171.     ULONG semcount = 0 ;
  3172.  
  3173.     rc = DosResetEventSem( hevRichEditInit, &semcount ) ;
  3174.     return rc ;
  3175. #endif /* NT */
  3176. }
  3177.  
  3178. APIRET
  3179. CloseRichEditInitSem( void )
  3180. {
  3181. #ifdef NT
  3182.     BOOL rc = 0 ;
  3183.     rc = CloseHandle( hevRichEditInit ) ;
  3184.     hevRichEditInit = (HANDLE) NULL ;
  3185.     return rc == TRUE ? 0 : GetLastError() ;
  3186. #else /* not NT */
  3187.     APIRET rc ;
  3188.     rc = DosCloseEventSem( hevRichEditInit ) ;
  3189.     hevRichEditInit = 0 ;
  3190.     return rc ;
  3191. #endif /* NT */
  3192. }
  3193.  
  3194. APIRET
  3195. CreateRichEditCloseSem( BOOL posted )
  3196. {
  3197.     if ( hevRichEditClose )
  3198. #ifdef NT
  3199.         CloseHandle( hevRichEditClose ) ;
  3200.     hevRichEditClose = CreateEvent( NULL, TRUE, posted, NULL ) ;
  3201.     return hevRichEditClose == NULL ? GetLastError() : 0 ;
  3202. #else /* not NT */
  3203.         DosCloseEventSem( hevRichEditClose ) ;
  3204.     return DosCreateEventSem( NULL, &hevRichEditClose, 0, posted ) ;
  3205. #endif /* NT */
  3206. }
  3207.  
  3208. APIRET
  3209. PostRichEditCloseSem( void )
  3210. {
  3211. #ifdef NT
  3212.     BOOL rc = 0 ;
  3213.  
  3214.     rc = SetEvent( hevRichEditClose ) ;
  3215.     return rc == TRUE ? 0 : GetLastError() ;
  3216. #else /* not NT */
  3217.     return DosPostEventSem( hevRichEditClose ) ;
  3218. #endif /* NT */
  3219. }
  3220.  
  3221. APIRET
  3222. WaitRichEditCloseSem( ULONG timo )
  3223. {
  3224. #ifdef NT
  3225.     DWORD rc = 0 ;
  3226.  
  3227.     rc = WaitForSingleObjectEx( hevRichEditClose, timo, TRUE ) ;
  3228.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3229. #else /* not NT */
  3230.     APIRET rc = 0 ;
  3231.  
  3232.     rc = DosWaitEventSem( hevRichEditClose, timo ) ;
  3233.     return rc ;
  3234. #endif /* NT */
  3235. }
  3236.  
  3237. APIRET
  3238. WaitAndResetRichEditCloseSem( ULONG timo )
  3239. {
  3240. #ifdef NT
  3241.     DWORD rc = 0 ;
  3242.  
  3243.     rc = WaitForSingleObjectEx( hevRichEditClose, timo, TRUE ) ;
  3244.     if ( rc == WAIT_OBJECT_0 )
  3245.         ResetEvent( hevRichEditClose ) ;
  3246.     return rc == WAIT_OBJECT_0 ;
  3247. #else /* not NT */
  3248.     APIRET rc = 0 ;
  3249.     ULONG  semcount = 0 ;
  3250.  
  3251.     rc = DosWaitEventSem( hevRichEditClose, timo ) ;
  3252.     if ( !rc )
  3253.         DosResetEventSem( hevRichEditClose, &semcount ) ;
  3254.     return semcount ;
  3255. #endif /* NT */
  3256. }
  3257.  
  3258. APIRET
  3259. ResetRichEditCloseSem( void )
  3260. {
  3261. #ifdef NT
  3262.     BOOL rc = 0 ;
  3263.  
  3264.     rc = ResetEvent( hevRichEditClose ) ;
  3265.     return rc ;
  3266. #else /* not NT */
  3267.     APIRET rc = 0 ;
  3268.     ULONG semcount = 0 ;
  3269.  
  3270.     rc = DosResetEventSem( hevRichEditClose, &semcount ) ;
  3271.     return rc ;
  3272. #endif /* NT */
  3273. }
  3274.  
  3275. APIRET
  3276. CloseRichEditCloseSem( void )
  3277. {
  3278. #ifdef NT
  3279.     BOOL rc = 0 ;
  3280.     rc = CloseHandle( hevRichEditClose ) ;
  3281.     hevRichEditClose = (HANDLE) NULL ;
  3282.     return rc == TRUE ? 0 : GetLastError() ;
  3283. #else /* not NT */
  3284.     APIRET rc ;
  3285.     rc = DosCloseEventSem( hevRichEditClose ) ;
  3286.     hevRichEditClose = 0 ;
  3287.     return rc ;
  3288. #endif /* NT */
  3289. }
  3290.  
  3291. APIRET
  3292. CreateRichEditMutex( BOOL owned )
  3293. {
  3294.     if ( hmtxRichEdit )
  3295. #ifdef NT
  3296.         CloseHandle( hmtxRichEdit ) ;
  3297.     hmtxRichEdit = CreateMutex( NULL, owned, NULL ) ;
  3298.     return hmtxRichEdit == NULL ? GetLastError() : 0 ;
  3299. #else /* not NT */
  3300.         DosCloseMutexSem( hmtxRichEdit ) ;
  3301.     return DosCreateMutexSem( NULL, &hmtxRichEdit, 0, owned ) ;
  3302. #endif /* NT */
  3303. }
  3304.  
  3305. APIRET
  3306. RequestRichEditMutex( ULONG timo )
  3307. {
  3308. #ifdef NT
  3309.     DWORD rc = 0 ;
  3310.  
  3311.     rc = WaitForSingleObjectEx( hmtxRichEdit, timo, TRUE ) ;
  3312.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3313. #else /* not NT */
  3314.     return DosRequestMutexSem( hmtxRichEdit, timo ) ;
  3315. #endif /* NT */
  3316. }
  3317.  
  3318. APIRET
  3319. ReleaseRichEditMutex( void )
  3320. {
  3321. #ifdef NT
  3322.     BOOL rc = 0 ;
  3323.  
  3324.     rc = ReleaseMutex( hmtxRichEdit ) ;
  3325.     return rc == TRUE ? 0 : GetLastError() ;
  3326. #else /* not NT */
  3327.     return DosReleaseMutexSem( hmtxRichEdit ) ;
  3328. #endif /* NT */
  3329. }
  3330.  
  3331. APIRET
  3332. CloseRichEditMutex( void )
  3333. {
  3334. #ifdef NT
  3335.     BOOL rc = 0 ;
  3336.     rc = CloseHandle( hmtxRichEdit ) ;
  3337.     hmtxRichEdit = (HANDLE) NULL ;
  3338.     return rc == TRUE ? 0 : GetLastError() ;
  3339. #else /* not NT */
  3340.     APIRET rc ;
  3341.     rc = DosCloseMutexSem( hmtxRichEdit ) ;
  3342.     hmtxRichEdit = 0 ;
  3343.     return rc ;
  3344. #endif /* NT */
  3345. }
  3346.  
  3347. APIRET
  3348. CreateLocalEchoMutex( BOOL owned )
  3349. {
  3350.     if ( hmtxLocalEcho )
  3351. #ifdef NT
  3352.         CloseHandle( hmtxLocalEcho ) ;
  3353.     hmtxLocalEcho = CreateMutex( NULL, owned, NULL ) ;
  3354.     if (hmtxLocalEcho == NULL)
  3355.         return GetLastError();
  3356. #else /* not NT */
  3357.     DosCloseMutexSem( hmtxLocalEcho ) ;
  3358.     DosCreateMutexSem( NULL, &hmtxLocalEcho, 0, owned ) ;
  3359. #endif /* NT */
  3360.     return 0;
  3361. }
  3362.  
  3363. APIRET
  3364. RequestLocalEchoMutex( ULONG timo )
  3365. {
  3366. #ifdef NT
  3367.     DWORD rc = 0 ;
  3368.  
  3369.     rc = WaitForSingleObjectEx( hmtxLocalEcho, timo, TRUE ) ;
  3370.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3371. #else /* not NT */
  3372.     return DosRequestMutexSem( hmtxLocalEcho, timo ) ;
  3373. #endif /* NT */
  3374. }
  3375.  
  3376. APIRET
  3377. ReleaseLocalEchoMutex( void )
  3378. {
  3379. #ifdef NT
  3380.     BOOL rc = 0 ;
  3381.  
  3382.     rc = ReleaseMutex( hmtxLocalEcho ) ;
  3383.     return rc == TRUE ? 0 : GetLastError() ;
  3384. #else /* not NT */
  3385.     return DosReleaseMutexSem( hmtxLocalEcho ) ;
  3386. #endif /* NT */
  3387. }
  3388.  
  3389. APIRET
  3390. CloseLocalEchoMutex( void )
  3391. {
  3392. #ifdef NT
  3393.     BOOL rc = 0 ;
  3394.     rc = CloseHandle( hmtxLocalEcho ) ;
  3395.     hmtxLocalEcho = (HANDLE) NULL ;
  3396.     return rc == TRUE ? 0 : GetLastError() ;
  3397. #else /* not NT */
  3398.     APIRET rc ;
  3399.     rc = DosCloseMutexSem( hmtxLocalEcho ) ;
  3400.     hmtxLocalEcho = 0 ;
  3401.     return rc ;
  3402. #endif /* NT */
  3403. }
  3404.  
  3405.  
  3406. APIRET
  3407. CreateLocalEchoAvailSem( BOOL posted )
  3408. {
  3409.     if ( hevLocalEchoAvail )
  3410. #ifdef NT
  3411.         CloseHandle( hevLocalEchoAvail ) ;
  3412.     hevLocalEchoAvail = CreateEvent( NULL, TRUE, posted, NULL ) ;
  3413.     return hevLocalEchoAvail == NULL ? GetLastError() : 0 ;
  3414. #else /* not NT */
  3415.         DosCloseEventSem( hevLocalEchoAvail ) ;
  3416.     return DosCreateEventSem( NULL, &hevLocalEchoAvail, DC_SEM_SHARED, posted ) ;
  3417. #endif /* NT */
  3418. }
  3419.  
  3420. APIRET
  3421. PostLocalEchoAvailSem( void )
  3422. {
  3423. #ifdef NT
  3424.     BOOL rc = 0 ;
  3425.  
  3426.     rc = SetEvent( hevLocalEchoAvail ) ;
  3427.     return rc == TRUE ? 0 : GetLastError() ;
  3428. #else /* not NT */
  3429.     return DosPostEventSem( hevLocalEchoAvail ) ;
  3430. #endif /* NT */
  3431. }
  3432.  
  3433. APIRET
  3434. WaitLocalEchoAvailSem( ULONG timo )
  3435. {
  3436. #ifdef NT
  3437.     DWORD rc = 0 ;
  3438.  
  3439.     rc = WaitForSingleObjectEx( hevLocalEchoAvail, timo, TRUE ) ;
  3440.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3441. #else /* not NT */
  3442.     APIRET rc = 0 ;
  3443.  
  3444.     rc = DosWaitEventSem( hevLocalEchoAvail, timo ) ;
  3445.     return rc ;
  3446. #endif /* NT */
  3447. }
  3448.  
  3449. APIRET
  3450. WaitAndResetLocalEchoAvailSem( ULONG timo )
  3451. {
  3452. #ifdef NT
  3453.     DWORD rc = 0 ;
  3454.  
  3455.     rc = WaitForSingleObjectEx( hevLocalEchoAvail, timo, TRUE ) ;
  3456.     if ( rc == WAIT_OBJECT_0 )
  3457.         ResetEvent( hevLocalEchoAvail ) ;
  3458.     return rc == WAIT_OBJECT_0 ;
  3459. #else /* not NT */
  3460.     APIRET rc = 0 ;
  3461.     ULONG  semcount = 0 ;
  3462.  
  3463.     rc = DosWaitEventSem( hevLocalEchoAvail, timo ) ;
  3464.     if ( !rc )
  3465.         DosResetEventSem( hevLocalEchoAvail, &semcount ) ;
  3466.     return semcount ;
  3467. #endif /* NT */
  3468. }
  3469.  
  3470. APIRET
  3471. ResetLocalEchoAvailSem( void )
  3472. {
  3473. #ifdef NT
  3474.     BOOL rc = 0 ;
  3475.  
  3476.     rc = ResetEvent( hevLocalEchoAvail ) ;
  3477.     return rc ;
  3478. #else /* not NT */
  3479.     APIRET rc = 0 ;
  3480.     ULONG semcount = 0 ;
  3481.  
  3482.     rc = DosResetEventSem( hevLocalEchoAvail, &semcount ) ;
  3483.     return semcount ;
  3484. #endif /* NT */
  3485. }
  3486.  
  3487. APIRET
  3488. CloseLocalEchoAvailSem( void )
  3489. {
  3490. #ifdef NT
  3491.     BOOL rc = 0 ;
  3492.     rc = CloseHandle( hevLocalEchoAvail ) ;
  3493.     hevLocalEchoAvail = (HANDLE) NULL ;
  3494.     return rc == TRUE ? 0 : GetLastError() ;
  3495. #else /* not NT */
  3496.     APIRET rc ;
  3497.     rc = DosCloseEventSem( hevLocalEchoAvail ) ;
  3498.     hevLocalEchoAvail = 0 ;
  3499.     return rc ;
  3500. #endif /* NT */
  3501. }
  3502.  
  3503. #ifdef NETCMD
  3504. APIRET
  3505. CreateNetCmdMutex( BOOL owned )
  3506. {
  3507.     if ( hmtxNetCmd )
  3508. #ifdef NT
  3509.         CloseHandle( hmtxNetCmd ) ;
  3510.     hmtxNetCmd = CreateMutex( NULL, owned, NULL ) ;
  3511.     if (hmtxNetCmd == NULL)
  3512.         return GetLastError();
  3513. #else /* not NT */
  3514.     DosCloseMutexSem( hmtxNetCmd ) ;
  3515.     DosCreateMutexSem( NULL, &hmtxNetCmd, 0, owned ) ;
  3516. #endif /* NT */
  3517.     return 0;
  3518. }
  3519.  
  3520. APIRET
  3521. RequestNetCmdMutex( ULONG timo )
  3522. {
  3523. #ifdef NT
  3524.     DWORD rc = 0 ;
  3525.  
  3526.     rc = WaitForSingleObjectEx( hmtxNetCmd, timo, TRUE ) ;
  3527.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3528. #else /* not NT */
  3529.     return DosRequestMutexSem( hmtxNetCmd, timo ) ;
  3530. #endif /* NT */
  3531. }
  3532.  
  3533. APIRET
  3534. ReleaseNetCmdMutex( void )
  3535. {
  3536. #ifdef NT
  3537.     BOOL rc = 0 ;
  3538.  
  3539.     rc = ReleaseMutex( hmtxNetCmd ) ;
  3540.     return rc == TRUE ? 0 : GetLastError() ;
  3541. #else /* not NT */
  3542.     return DosReleaseMutexSem( hmtxNetCmd ) ;
  3543. #endif /* NT */
  3544. }
  3545.  
  3546. APIRET
  3547. CloseNetCmdMutex( void )
  3548. {
  3549. #ifdef NT
  3550.     BOOL rc = 0 ;
  3551.     rc = CloseHandle( hmtxNetCmd ) ;
  3552.     hmtxNetCmd = (HANDLE) NULL ;
  3553.     return rc == TRUE ? 0 : GetLastError() ;
  3554. #else /* not NT */
  3555.     APIRET rc ;
  3556.     rc = DosCloseMutexSem( hmtxNetCmd ) ;
  3557.     hmtxNetCmd = 0 ;
  3558.     return rc ;
  3559. #endif /* NT */
  3560. }
  3561.  
  3562.  
  3563. APIRET
  3564. CreateNetCmdAvailSem( BOOL posted )
  3565. {
  3566.     if ( hevNetCmdAvail )
  3567. #ifdef NT
  3568.         CloseHandle( hevNetCmdAvail ) ;
  3569.     hevNetCmdAvail = CreateEvent( NULL, TRUE, posted, NULL ) ;
  3570.     return hevNetCmdAvail == NULL ? GetLastError() : 0 ;
  3571. #else /* not NT */
  3572.         DosCloseEventSem( hevNetCmdAvail ) ;
  3573.     return DosCreateEventSem( NULL, &hevNetCmdAvail, DC_SEM_SHARED, posted ) ;
  3574. #endif /* NT */
  3575. }
  3576.  
  3577. APIRET
  3578. PostNetCmdAvailSem( void )
  3579. {
  3580. #ifdef NT
  3581.     BOOL rc = 0 ;
  3582.  
  3583.     rc = SetEvent( hevNetCmdAvail ) ;
  3584.     return rc == TRUE ? 0 : GetLastError() ;
  3585. #else /* not NT */
  3586.     return DosPostEventSem( hevNetCmdAvail ) ;
  3587. #endif /* NT */
  3588. }
  3589.  
  3590. APIRET
  3591. WaitNetCmdAvailSem( ULONG timo )
  3592. {
  3593. #ifdef NT
  3594.     DWORD rc = 0 ;
  3595.  
  3596.     rc = WaitForSingleObjectEx( hevNetCmdAvail, timo, TRUE ) ;
  3597.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3598. #else /* not NT */
  3599.     APIRET rc = 0 ;
  3600.  
  3601.     rc = DosWaitEventSem( hevNetCmdAvail, timo ) ;
  3602.     return rc ;
  3603. #endif /* NT */
  3604. }
  3605.  
  3606. APIRET
  3607. WaitAndResetNetCmdAvailSem( ULONG timo )
  3608. {
  3609. #ifdef NT
  3610.     DWORD rc = 0 ;
  3611.  
  3612.     rc = WaitForSingleObjectEx( hevNetCmdAvail, timo, TRUE ) ;
  3613.     if ( rc == WAIT_OBJECT_0 )
  3614.         ResetEvent( hevNetCmdAvail ) ;
  3615.     return rc == WAIT_OBJECT_0 ;
  3616. #else /* not NT */
  3617.     APIRET rc = 0 ;
  3618.     ULONG  semcount = 0 ;
  3619.  
  3620.     rc = DosWaitEventSem( hevNetCmdAvail, timo ) ;
  3621.     if ( !rc )
  3622.         DosResetEventSem( hevNetCmdAvail, &semcount ) ;
  3623.     return semcount ;
  3624. #endif /* NT */
  3625. }
  3626.  
  3627. APIRET
  3628. ResetNetCmdAvailSem( void )
  3629. {
  3630. #ifdef NT
  3631.     BOOL rc = 0 ;
  3632.  
  3633.     rc = ResetEvent( hevNetCmdAvail ) ;
  3634.     return rc ;
  3635. #else /* not NT */
  3636.     APIRET rc = 0 ;
  3637.     ULONG semcount = 0 ;
  3638.  
  3639.     rc = DosResetEventSem( hevNetCmdAvail, &semcount ) ;
  3640.     return semcount ;
  3641. #endif /* NT */
  3642. }
  3643.  
  3644. APIRET
  3645. CloseNetCmdAvailSem( void )
  3646. {
  3647. #ifdef NT
  3648.     BOOL rc = 0 ;
  3649.     rc = CloseHandle( hevNetCmdAvail ) ;
  3650.     hevNetCmdAvail = (HANDLE) NULL ;
  3651.     return rc == TRUE ? 0 : GetLastError() ;
  3652. #else /* not NT */
  3653.     APIRET rc ;
  3654.     rc = DosCloseEventSem( hevNetCmdAvail ) ;
  3655.     hevNetCmdAvail = 0 ;
  3656.     return rc ;
  3657. #endif /* NT */
  3658. }
  3659. #endif /* NETCMD */
  3660.  
  3661. APIRET
  3662. CreateTCPIPMutex( BOOL owned )
  3663. {
  3664.     if ( hmtxTCPIP )
  3665. #ifdef NT
  3666.         CloseHandle( hmtxTCPIP ) ;
  3667.     hmtxTCPIP = CreateMutex( NULL, owned, NULL ) ;
  3668.     if (hmtxTCPIP == NULL)
  3669.         return GetLastError();
  3670. #else /* not NT */
  3671.     DosCloseMutexSem( hmtxTCPIP ) ;
  3672.     DosCreateMutexSem( NULL, &hmtxTCPIP, 0, owned ) ;
  3673. #endif /* NT */
  3674.     return 0;
  3675. }
  3676.  
  3677. APIRET
  3678. RequestTCPIPMutex( ULONG timo )
  3679. {
  3680. #ifdef NT
  3681.     DWORD rc = 0 ;
  3682.  
  3683.     rc = WaitForSingleObjectEx( hmtxTCPIP, timo, TRUE ) ;
  3684.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3685. #else /* not NT */
  3686.     return DosRequestMutexSem( hmtxTCPIP, timo ) ;
  3687. #endif /* NT */
  3688. }
  3689.  
  3690. APIRET
  3691. ReleaseTCPIPMutex( void )
  3692. {
  3693. #ifdef NT
  3694.     BOOL rc = 0 ;
  3695.  
  3696.     rc = ReleaseMutex( hmtxTCPIP ) ;
  3697.     return rc == TRUE ? 0 : GetLastError() ;
  3698. #else /* not NT */
  3699.     return DosReleaseMutexSem( hmtxTCPIP ) ;
  3700. #endif /* NT */
  3701. }
  3702.  
  3703. APIRET
  3704. CloseTCPIPMutex( void )
  3705. {
  3706. #ifdef NT
  3707.     BOOL rc = 0 ;
  3708.     rc = CloseHandle( hmtxTCPIP ) ;
  3709.     hmtxTCPIP = (HANDLE) NULL ;
  3710.     return rc == TRUE ? 0 : GetLastError() ;
  3711. #else /* not NT */
  3712.     APIRET rc ;
  3713.     rc = DosCloseMutexSem( hmtxTCPIP ) ;
  3714.     hmtxTCPIP = 0 ;
  3715.     return rc ;
  3716. #endif /* NT */
  3717. }
  3718.  
  3719. APIRET
  3720. CreateCommMutex( BOOL owned )
  3721. {
  3722.     if ( hmtxComm )
  3723. #ifdef NT
  3724.         CloseHandle( hmtxComm ) ;
  3725.     hmtxComm = CreateMutex( NULL, owned, NULL ) ;
  3726.     if (hmtxComm == NULL)
  3727.         return GetLastError();
  3728. #else /* not NT */
  3729.     DosCloseMutexSem( hmtxComm ) ;
  3730.     DosCreateMutexSem( NULL, &hmtxComm, 0, owned ) ;
  3731. #endif /* NT */
  3732.     return 0;
  3733. }
  3734.  
  3735. APIRET
  3736. RequestCommMutex( ULONG timo )
  3737. {
  3738. #ifdef NT
  3739.     DWORD rc = 0 ;
  3740.  
  3741.     rc = WaitForSingleObjectEx( hmtxComm, timo, TRUE ) ;
  3742.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3743. #else /* not NT */
  3744.     return DosRequestMutexSem( hmtxComm, timo ) ;
  3745. #endif /* NT */
  3746. }
  3747.  
  3748. APIRET
  3749. ReleaseCommMutex( void )
  3750. {
  3751. #ifdef NT
  3752.     BOOL rc = 0 ;
  3753.  
  3754.     rc = ReleaseMutex( hmtxComm ) ;
  3755.     return rc == TRUE ? 0 : GetLastError() ;
  3756. #else /* not NT */
  3757.     return DosReleaseMutexSem( hmtxComm ) ;
  3758. #endif /* NT */
  3759. }
  3760.  
  3761. APIRET
  3762. CloseCommMutex( void )
  3763. {
  3764. #ifdef NT
  3765.     BOOL rc = 0 ;
  3766.     rc = CloseHandle( hmtxComm ) ;
  3767.     hmtxComm = (HANDLE) NULL ;
  3768.     return rc == TRUE ? 0 : GetLastError() ;
  3769. #else /* not NT */
  3770.     APIRET rc ;
  3771.     rc = DosCloseMutexSem( hmtxComm ) ;
  3772.     hmtxComm = 0 ;
  3773.     return rc ;
  3774. #endif /* NT */
  3775. }
  3776.  
  3777. #ifdef CK_SSL
  3778. APIRET
  3779. CreateSSLMutex( BOOL owned )
  3780. {
  3781.     if ( hmtxSSL )
  3782. #ifdef NT
  3783.         CloseHandle( hmtxSSL ) ;
  3784.     hmtxSSL = CreateMutex( NULL, owned, NULL ) ;
  3785.     if (hmtxSSL == NULL)
  3786.         return GetLastError();
  3787. #else /* not NT */
  3788.     DosCloseMutexSem( hmtxSSL ) ;
  3789.     DosCreateMutexSem( NULL, &hmtxSSL, 0, owned ) ;
  3790. #endif /* NT */
  3791.     return 0;
  3792. }
  3793.  
  3794. APIRET
  3795. RequestSSLMutex( ULONG timo )
  3796. {
  3797. #ifdef NT
  3798.     DWORD rc = 0 ;
  3799.  
  3800.     rc = WaitForSingleObjectEx( hmtxSSL, timo, TRUE ) ;
  3801.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3802. #else /* not NT */
  3803.     return DosRequestMutexSem( hmtxSSL, timo ) ;
  3804. #endif /* NT */
  3805. }
  3806.  
  3807. APIRET
  3808. ReleaseSSLMutex( void )
  3809. {
  3810. #ifdef NT
  3811.     BOOL rc = 0 ;
  3812.  
  3813.     rc = ReleaseMutex( hmtxSSL ) ;
  3814.     return rc == TRUE ? 0 : GetLastError() ;
  3815. #else /* not NT */
  3816.     return DosReleaseMutexSem( hmtxSSL ) ;
  3817. #endif /* NT */
  3818. }
  3819.  
  3820. APIRET
  3821. CloseSSLMutex( void )
  3822. {
  3823. #ifdef NT
  3824.     BOOL rc = 0 ;
  3825.     rc = CloseHandle( hmtxSSL ) ;
  3826.     hmtxSSL = (HANDLE) NULL ;
  3827.     return rc == TRUE ? 0 : GetLastError() ;
  3828. #else /* not NT */
  3829.     APIRET rc ;
  3830.     rc = DosCloseMutexSem( hmtxSSL ) ;
  3831.     hmtxSSL = 0 ;
  3832.     return rc ;
  3833. #endif /* NT */
  3834. }
  3835. #endif /* CK_SSL */
  3836.  
  3837.  
  3838. APIRET
  3839. CreateTerminalModeSem( BOOL posted )
  3840. {
  3841. #ifdef NT
  3842.     if ( hevTerminalMode )
  3843.         CloseHandle( hevTerminalMode ) ;
  3844.     hevTerminalMode = CreateEvent( NULL, TRUE, posted, NULL ) ;
  3845.     return hevTerminalMode == NULL ? GetLastError() : 0 ;
  3846. #else /* not NT */
  3847.     if ( hevTerminalMode )
  3848.         DosCloseEventSem( hevTerminalMode ) ;
  3849.     return DosCreateEventSem( NULL, &hevTerminalMode, DC_SEM_SHARED, posted ) ;
  3850. #endif /* NT */
  3851. }
  3852.  
  3853. APIRET
  3854. PostTerminalModeSem( void )
  3855. {
  3856. #ifdef NT
  3857.     BOOL rc = 0 ;
  3858.  
  3859.     rc = SetEvent( hevTerminalMode ) ;
  3860.     return rc == TRUE ? 0 : GetLastError() ;
  3861. #else /* not NT */
  3862.     return DosPostEventSem( hevTerminalMode ) ;
  3863. #endif /* NT */
  3864. }
  3865.  
  3866. APIRET
  3867. CreateCommandModeSem( BOOL posted )
  3868. {
  3869.     if ( hevCommandMode )
  3870. #ifdef NT
  3871.         CloseHandle( hevCommandMode ) ;
  3872.     hevCommandMode = CreateEvent( NULL, TRUE, posted, NULL ) ;
  3873.     return hevCommandMode == NULL ? GetLastError() : 0 ;
  3874. #else /* not NT */
  3875.         DosCloseEventSem( hevCommandMode ) ;
  3876.     return DosCreateEventSem( NULL, &hevCommandMode, DC_SEM_SHARED, posted ) ;
  3877. #endif /* NT */
  3878. }
  3879.  
  3880. APIRET
  3881. PostCommandModeSem( void )
  3882. {
  3883. #ifdef NT
  3884.     BOOL rc = 0 ;
  3885.  
  3886.     rc = SetEvent( hevCommandMode ) ;
  3887.     return rc == TRUE ? 0 : GetLastError() ;
  3888. #else /* not NT */
  3889.     return DosPostEventSem( hevCommandMode ) ;
  3890. #endif /* NT */
  3891. }
  3892.  
  3893. APIRET
  3894. WaitCommandModeSem( ULONG timo )
  3895. {
  3896. #ifdef NT
  3897.     DWORD rc = 0 ;
  3898.  
  3899.     rc = WaitForSingleObjectEx( hevCommandMode, timo, TRUE ) ;
  3900.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3901. #else /* not NT */
  3902.     APIRET rc = 0 ;
  3903.  
  3904.     rc = DosWaitEventSem( hevCommandMode, timo ) ;
  3905.     return rc ;
  3906. #endif /* NT */
  3907. }
  3908.  
  3909. APIRET
  3910. WaitAndResetCommandModeSem( ULONG timo )
  3911. {
  3912. #ifdef NT
  3913.     DWORD rc = 0 ;
  3914.  
  3915.     rc = WaitForSingleObjectEx( hevCommandMode, timo, TRUE ) ;
  3916.     if ( rc == WAIT_OBJECT_0 )
  3917.         ResetEvent( hevCommandMode ) ;
  3918.     return rc == WAIT_OBJECT_0 ;
  3919. #else /* not NT */
  3920.     APIRET rc = 0 ;
  3921.     ULONG  semcount = 0 ;
  3922.  
  3923.     rc = DosWaitEventSem( hevCommandMode, timo ) ;
  3924.     if ( !rc )
  3925.         DosResetEventSem( hevCommandMode, &semcount ) ;
  3926.     return semcount ;
  3927. #endif /* NT */
  3928. }
  3929.  
  3930. APIRET
  3931. ResetCommandModeSem( void )
  3932. {
  3933. #ifdef NT
  3934.     BOOL rc = 0 ;
  3935.  
  3936.     rc = ResetEvent( hevCommandMode ) ;
  3937.     return rc ;
  3938. #else /* not NT */
  3939.     APIRET rc = 0 ;
  3940.     ULONG semcount = 0 ;
  3941.  
  3942.     rc = DosResetEventSem( hevCommandMode, &semcount ) ;
  3943.     return semcount ;
  3944. #endif /* NT */
  3945. }
  3946.  
  3947. APIRET
  3948. CloseCommandModeSem( void )
  3949. {
  3950. #ifdef NT
  3951.     BOOL rc = 0 ;
  3952.     rc = CloseHandle( hevCommandMode ) ;
  3953.     hevCommandMode = (HANDLE) NULL ;
  3954.     return rc == TRUE ? 0 : GetLastError() ;
  3955. #else /* not NT */
  3956.     APIRET rc ;
  3957.     rc = DosCloseEventSem( hevCommandMode ) ;
  3958.     hevCommandMode = 0 ;
  3959.     return rc ;
  3960. #endif /* NT */
  3961. }
  3962.  
  3963.  
  3964. APIRET
  3965. WaitTerminalModeSem( ULONG timo )
  3966. {
  3967. #ifdef NT
  3968.     DWORD rc = 0 ;
  3969.  
  3970.     rc = WaitForSingleObjectEx( hevTerminalMode, timo, TRUE ) ;
  3971.     return rc == WAIT_OBJECT_0 ? 0 : rc ;
  3972. #else /* not NT */
  3973.     APIRET rc = 0 ;
  3974.  
  3975.     rc = DosWaitEventSem( hevTerminalMode, timo ) ;
  3976.     return rc ;
  3977. #endif /* NT */
  3978. }
  3979.  
  3980. APIRET
  3981. WaitAndResetTerminalModeSem( ULONG timo )
  3982. {
  3983. #ifdef NT
  3984.     DWORD rc = 0 ;
  3985.  
  3986.     rc = WaitForSingleObjectEx( hevTerminalMode, timo, TRUE ) ;
  3987.     if ( rc == WAIT_OBJECT_0 )
  3988.         ResetEvent( hevTerminalMode ) ;
  3989.     return rc == WAIT_OBJECT_0 ;
  3990. #else /* not NT */
  3991.     APIRET rc = 0 ;
  3992.     ULONG  semcount = 0 ;
  3993.  
  3994.     rc = DosWaitEventSem( hevTerminalMode, timo ) ;
  3995.     if ( !rc )
  3996.         DosResetEventSem( hevTerminalMode, &semcount ) ;
  3997.     return semcount ;
  3998. #endif /* NT */
  3999. }
  4000.  
  4001. APIRET
  4002. ResetTerminalModeSem( void )
  4003. {
  4004. #ifdef NT
  4005.     BOOL rc = 0 ;
  4006.  
  4007.     rc = ResetEvent( hevTerminalMode ) ;
  4008.     return rc ;
  4009. #else /* not NT */
  4010.     APIRET rc = 0 ;
  4011.     ULONG semcount = 0 ;
  4012.  
  4013.     rc = DosResetEventSem( hevTerminalMode, &semcount ) ;
  4014.     return semcount ;
  4015. #endif /* NT */
  4016. }
  4017.  
  4018. APIRET
  4019. CloseTerminalModeSem( void )
  4020. {
  4021. #ifdef NT
  4022.     BOOL rc = 0 ;
  4023.     rc = CloseHandle( hevTerminalMode ) ;
  4024.     hevTerminalMode = (HANDLE) NULL ;
  4025.     return rc == TRUE ? 0 : GetLastError() ;
  4026. #else /* not NT */
  4027.     APIRET rc ;
  4028.     rc = DosCloseEventSem( hevTerminalMode ) ;
  4029.     hevTerminalMode = 0 ;
  4030.     return rc ;
  4031. #endif /* NT */
  4032. }
  4033.  
  4034.