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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email服务器 > 查看源码
SysDepWin.cpp
资源名称：xmail-1.22.rar　[点击查看]
上传用户：woshihumen
上传日期：2013-07-18
资源大小：484k
文件大小：49k
源码类别：

Email服务器

开发平台：

Visual C++

SysDepWin.cpp：源码内容
  1. /*
  2.  *  XMail by Davide Libenzi ( Intranet and Internet mail server )
  3.  *  Copyright (C) 1999,..,2004  Davide Libenzi
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  *  Davide Libenzi <davidel@xmailserver.org>
  20.  *
  21.  */
  23. #include "SysInclude.h"
  24. #include "SysDep.h"
  25. #include "AppDefines.h"
  27. #define MAX_TLS_KEYS                    64
  28. #define UNUSED_TLS_KEY_PROC             ((void (*)(void *)) -1)
  30. #define SOCK_VERSION_REQUESTED          MAKEWORD(2, 0)
  31. #define SHUTDOWN_RECV_TIMEOUT           2
  33. ///////////////////////////////////////////////////////////////////////////////
  34. //  Under certain circumstances ( M$ Proxy installed ?! ) a waiting operation
  35. //  may be unlocked even if the IO terminal is not ready to perform following
  36. //  IO request ( an error code WSAEWOULDBLOCK is returned ). The only solution
  37. //  I see is to sleep a bit to prevent processor time wasting :(
  38. ///////////////////////////////////////////////////////////////////////////////
  39. #define BLOCKED_SNDRCV_MSSLEEP          200
  40. #define HANDLE_SOCKS_SUCKS()            do { Sleep(BLOCKED_SNDRCV_MSSLEEP); } while (0)
  42. #define SAIN_Addr(s)                    (s).sin_addr.S_un.S_addr
  44. #define MIN_TCP_SEND_SIZE               (1024 * 8)
  45. #define MAX_TCP_SEND_SIZE               (1024 * 128)
  46. #define K_IO_TIME_RATIO                 8
  48. #define MAX_STACK_SHIFT                 2048
  49. #define STACK_ALIGN_BYTES               sizeof(int)
  51. struct TlsKeyEntry {
  52. void (*pFreeProc) (void *);
  53. };
  55. struct TlsKeyData {
  56. void *pData;
  57. };
  59. struct FileFindData {
  60. char szFindPath[SYS_MAX_PATH];
  61. HANDLE hFind;
  62. WIN32_FIND_DATA WFD;
  63. };
  65. struct ThreadRunner {
  66. unsigned int (*pThreadProc) (void *);
  67. void *pThreadData;
  68. };
  70. static void SysInitTlsKeyEntries(void);
  71. static void SysInitTlsKeys(void);
  72. static void SysCleanupTlsKeys(void);
  73. static char const *SysGetLastError(void);
  74. static int SysSetServerName(void);
  75. static int SysBlockSocket(SYS_SOCKET SockFD, int OnOff);
  76. static int SysSetSocketsOptions(SYS_SOCKET SockFD);
  77. static int SysRecvLL(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize);
  78. static int SysSendLL(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize);
  79. static unsigned int SysThreadRunner(void *pRunData);
  80. static int SysThreadSetup(void);
  81. static int SysThreadCleanup(void);
  82. static BOOL WINAPI SysBreakHandlerRoutine(DWORD dwCtrlType);
  83. static void SysTimetToFileTime(time_t tTime, LPFILETIME pFT);
  84. static time_t SysFileTimeToTimet(LPFILETIME pFT);
  85. static unsigned int SysStkCall(unsigned int (*pProc) (void *), void *pData);
  87. static char szServerName[SYS_MAX_PATH];
  88. static CRITICAL_SECTION csTLS;
  89. static bool bSetupEntries = true;
  90. static TlsKeyEntry TlsKeyEntries[MAX_TLS_KEYS];
  91. static __declspec(thread)
  92. TlsKeyData TlsKeys[MAX_TLS_KEYS];
  93. static time_t tSysStart;
  94. static SYS_INT64 PCFreq;
  95. static SYS_INT64 PCSysStart;
  96. static unsigned int uSRandBase;
  97. static int iSndBufSize = -1, iRcvBufSize = -1;
  98. static CRITICAL_SECTION csLog;
  99. static void (*SysBreakHandler) (void) = NULL;
  100. static HANDLE hShutdownEvent = NULL;
  102. static void SysInitTlsKeyEntries(void)
  103. {
  105. if (bSetupEntries) {
  106. for (int ii = 0; ii < MAX_TLS_KEYS; ii++)
  107. TlsKeyEntries[ii].pFreeProc = UNUSED_TLS_KEY_PROC;
  109. bSetupEntries = false;
  110. }
  112. }
  114. static void SysInitTlsKeys(void)
  115. {
  117. for (int ii = 0; ii < MAX_TLS_KEYS; ii++)
  118. TlsKeys[ii].pData = NULL;
  120. }
  122. static void SysCleanupTlsKeys(void)
  123. {
  125. EnterCriticalSection(&csTLS);
  127. for (int ii = 0; ii < MAX_TLS_KEYS; ii++) {
  128. if ((TlsKeyEntries[ii].pFreeProc != UNUSED_TLS_KEY_PROC) &&
  129.     (TlsKeyEntries[ii].pFreeProc != NULL))
  130. TlsKeyEntries[ii].pFreeProc(TlsKeys[ii].pData);
  132. TlsKeys[ii].pData = NULL;
  133. }
  135. LeaveCriticalSection(&csTLS);
  137. }
  139. static char const *SysGetLastError(void)
  140. {
  142. char *pszMessage = NULL;
  143. DWORD dwError = GetLastError();
  144. DWORD dwRet =
  145.     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
  146.   FORMAT_MESSAGE_ARGUMENT_ARRAY,
  147.   NULL,
  148.   dwError,
  149.   LANG_NEUTRAL,
  150.   (LPTSTR) & pszMessage,
  151.   0,
  152.   NULL);
  154. static char szMessage[1024] = "";
  156. if (dwRet == 0)
  157. SysSNPrintf(szMessage, sizeof(szMessage) - 1, "(0x%lX) Unknown error",
  158.     (unsigned long) dwError);
  159. else
  160. SysSNPrintf(szMessage, sizeof(szMessage) - 1, "(0x%lX) %s",
  161.     (unsigned long) dwError, pszMessage);
  163. if (pszMessage != NULL)
  164. LocalFree((HLOCAL) pszMessage);
  166. return (szMessage);
  168. }
  170. static int SysSetServerName(void)
  171. {
  173. int iSize;
  174. char *pszSlash;
  175. char *pszDot;
  176. char szPath[SYS_MAX_PATH] = APP_NAME_STR;
  178. GetModuleFileName(NULL, szPath, CountOf(szPath));
  180. if ((pszSlash = strrchr(szPath, '\')) == NULL)
  181. pszSlash = szPath;
  182. else
  183. pszSlash++;
  185. if ((pszDot = strchr(pszSlash, '.')) == NULL)
  186. pszDot = pszSlash + strlen(pszSlash);
  188. iSize = Min(sizeof(szServerName) - 1, (int) (pszDot - pszSlash));
  189. Cpy2Sz(szServerName, pszSlash, iSize);
  191. return (0);
  193. }
  195. int SysInitLibrary(void)
  196. {
  197. ///////////////////////////////////////////////////////////////////////////////
  198. //  Setup timers
  199. ///////////////////////////////////////////////////////////////////////////////
  200. LARGE_INTEGER PerfCntFreq;
  201. LARGE_INTEGER PerfCntCurr;
  203. QueryPerformanceFrequency(&PerfCntFreq);
  204. QueryPerformanceCounter(&PerfCntCurr);
  206. PCFreq = *(SYS_INT64 *) & PerfCntFreq;
  207. PCFreq /= 1000;
  208. PCSysStart = *(SYS_INT64 *) & PerfCntCurr;
  210. _tzset();
  211. time(&tSysStart);
  212. uSRandBase = (unsigned int) tSysStart;
  214. ///////////////////////////////////////////////////////////////////////////////
  215. //  Set the server name
  216. ///////////////////////////////////////////////////////////////////////////////
  217. SysSetServerName();
  219. ///////////////////////////////////////////////////////////////////////////////
  220. //  Setup sockets
  221. ///////////////////////////////////////////////////////////////////////////////
  222. WSADATA WSD;
  224. ZeroData(WSD);
  226. if (WSAStartup(SOCK_VERSION_REQUESTED, &WSD)) {
  227. ErrSetErrorCode(ERR_NETWORK);
  228. return (ERR_NETWORK);
  229. }
  231. InitializeCriticalSection(&csTLS);
  232. SysInitTlsKeyEntries();
  234. InitializeCriticalSection(&csLog);
  236. if ((hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL)) == NULL) {
  237. DeleteCriticalSection(&csLog);
  238. DeleteCriticalSection(&csTLS);
  239. ErrSetErrorCode(ERR_CREATEEVENT);
  240. return (ERR_CREATEEVENT);
  241. }
  243. if (SysThreadSetup() < 0) {
  244. ErrorPush();
  245. CloseHandle(hShutdownEvent);
  246. DeleteCriticalSection(&csLog);
  247. DeleteCriticalSection(&csTLS);
  248. return (ErrorPop());
  249. }
  251. return (0);
  253. }
  255. void SysCleanupLibrary(void)
  256. {
  258. SysThreadCleanup();
  260. DeleteCriticalSection(&csLog);
  262. DeleteCriticalSection(&csTLS);
  264. CloseHandle(hShutdownEvent);
  266. WSACleanup();
  268. }
  270. int SysShutdownLibrary(int iMode)
  271. {
  273. SetEvent(hShutdownEvent);
  275. return (0);
  277. }
  279. int SysSetupSocketBuffers(int *piSndBufSize, int *piRcvBufSize)
  280. {
  282. if (piSndBufSize != NULL)
  283. iSndBufSize = *piSndBufSize;
  285. if (piRcvBufSize != NULL)
  286. iRcvBufSize = *piRcvBufSize;
  288. return (0);
  290. }
  292. SYS_SOCKET SysCreateSocket(int iAddressFamily, int iType, int iProtocol)
  293. {
  295. SOCKET SockFD = WSASocket(iAddressFamily, iType, iProtocol, NULL, 0,
  296.   WSA_FLAG_OVERLAPPED);
  298. if (SockFD == INVALID_SOCKET) {
  299. ErrSetErrorCode(ERR_SOCKET_CREATE);
  300. return (SYS_INVALID_SOCKET);
  301. }
  303. if (SysSetSocketsOptions((SYS_SOCKET) SockFD) < 0) {
  304. SysCloseSocket((SYS_SOCKET) SockFD);
  306. return (SYS_INVALID_SOCKET);
  307. }
  309. return ((SYS_SOCKET) SockFD);
  311. }
  313. static int SysBlockSocket(SYS_SOCKET SockFD, int OnOff)
  314. {
  316. u_long IoctlLong = (OnOff) ? 0 : 1;
  318. if (ioctlsocket(SockFD, FIONBIO, &IoctlLong) == SOCKET_ERROR) {
  319. ErrSetErrorCode(ERR_NETWORK);
  320. return (ERR_NETWORK);
  321. }
  323. return (0);
  325. }
  327. static int SysSetSocketsOptions(SYS_SOCKET SockFD)
  328. {
  329. ///////////////////////////////////////////////////////////////////////////////
  330. //  Set socket buffer sizes
  331. ///////////////////////////////////////////////////////////////////////////////
  332. if (iSndBufSize > 0) {
  333. int iSize = iSndBufSize;
  335. setsockopt((int) SockFD, SOL_SOCKET, SO_SNDBUF, (const char *) &iSize,
  336.    sizeof(iSize));
  337. }
  339. if (iRcvBufSize > 0) {
  340. int iSize = iRcvBufSize;
  342. setsockopt((int) SockFD, SOL_SOCKET, SO_RCVBUF, (const char *) &iSize,
  343.    sizeof(iSize));
  344. }
  346. int iActivate = 1;
  348. if (setsockopt(SockFD, SOL_SOCKET, SO_REUSEADDR, (const char *) &iActivate,
  349.        sizeof(iActivate)) != 0) {
  350. ErrSetErrorCode(ERR_SETSOCKOPT);
  351. return (ERR_SETSOCKOPT);
  352. }
  353. ///////////////////////////////////////////////////////////////////////////////
  354. //  Disable linger
  355. ///////////////////////////////////////////////////////////////////////////////
  356. struct linger Ling;
  358. ZeroData(Ling);
  359. Ling.l_onoff = 0;
  360. Ling.l_linger = 0;
  362. setsockopt(SockFD, SOL_SOCKET, SO_LINGER, (const char *) &Ling, sizeof(Ling));
  364. ///////////////////////////////////////////////////////////////////////////////
  365. //  Set KEEPALIVE if supported
  366. ///////////////////////////////////////////////////////////////////////////////
  367. setsockopt(SockFD, SOL_SOCKET, SO_KEEPALIVE, (const char *) &iActivate,
  368.    sizeof(iActivate));
  370. return (0);
  372. }
  374. void SysCloseSocket(SYS_SOCKET SockFD)
  375. {
  377. closesocket(SockFD);
  379. }
  381. int SysBindSocket(SYS_SOCKET SockFD, const struct sockaddr *SockName, int iNameLen)
  382. {
  384. if (bind(SockFD, SockName, iNameLen) == SOCKET_ERROR) {
  385. ErrSetErrorCode(ERR_SOCKET_BIND);
  386. return (ERR_SOCKET_BIND);
  387. }
  389. return (0);
  391. }
  393. void SysListenSocket(SYS_SOCKET SockFD, int iConnections)
  394. {
  396. listen(SockFD, iConnections);
  398. }
  400. static int SysRecvLL(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize)
  401. {
  403. DWORD dwRtxBytes = 0;
  404. DWORD dwRtxFlags = 0;
  405. WSABUF WSABuff;
  407. ZeroData(WSABuff);
  408. WSABuff.len = iBufferSize;
  409. WSABuff.buf = pszBuffer;
  411. return ((WSARecv(SockFD, &WSABuff, 1, &dwRtxBytes, &dwRtxFlags,
  412.  NULL, NULL) == 0) ? (int) dwRtxBytes : -WSAGetLastError());
  414. }
  416. static int SysSendLL(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize)
  417. {
  419. DWORD dwRtxBytes = 0;
  420. WSABUF WSABuff;
  422. ZeroData(WSABuff);
  423. WSABuff.len = iBufferSize;
  424. WSABuff.buf = (char *) pszBuffer;
  426. return ((WSASend(SockFD, &WSABuff, 1, &dwRtxBytes, 0,
  427.  NULL, NULL) == 0) ? (int) dwRtxBytes : -WSAGetLastError());
  429. }
  431. int SysRecvData(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize, int iTimeout)
  432. {
  434. HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  436. if (hReadEvent == NULL) {
  437. ErrSetErrorCode(ERR_CREATEEVENT);
  438. return (ERR_CREATEEVENT);
  439. }
  441. int iRecvBytes = 0;
  442. HANDLE hWaitEvents[2] = { hReadEvent, hShutdownEvent };
  444. for (;;) {
  445. WSAEventSelect(SockFD, (WSAEVENT) hReadEvent, FD_READ | FD_CLOSE);
  447. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hWaitEvents, FALSE,
  448.       (DWORD) (iTimeout * 1000), TRUE);
  450. WSAEventSelect(SockFD, (WSAEVENT) hReadEvent, 0);
  452. if (dwWaitResult == (WSA_WAIT_EVENT_0 + 1)) {
  453. CloseHandle(hReadEvent);
  454. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  455. return (ERR_SERVER_SHUTDOWN);
  456. } else if (dwWaitResult != WSA_WAIT_EVENT_0) {
  457. CloseHandle(hReadEvent);
  458. ErrSetErrorCode(ERR_TIMEOUT);
  459. return (ERR_TIMEOUT);
  460. }
  462. if ((iRecvBytes = SysRecvLL(SockFD, pszBuffer, iBufferSize)) >= 0)
  463. break;
  465. int iErrorCode = -iRecvBytes;
  467. if (iErrorCode != WSAEWOULDBLOCK) {
  468. CloseHandle(hReadEvent);
  469. ErrSetErrorCode(ERR_NETWORK);
  470. return (ERR_NETWORK);
  471. }
  472. ///////////////////////////////////////////////////////////////////////////////
  473. //  You should never get here if Win32 API worked fine
  474. ///////////////////////////////////////////////////////////////////////////////
  475. HANDLE_SOCKS_SUCKS();
  476. }
  478. CloseHandle(hReadEvent);
  480. return (iRecvBytes);
  482. }
  484. int SysRecv(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize, int iTimeout)
  485. {
  487. int iRtxBytes = 0;
  489. while (iRtxBytes < iBufferSize) {
  490. int iRtxCurrent = SysRecvData(SockFD, pszBuffer + iRtxBytes,
  491.       iBufferSize - iRtxBytes, iTimeout);
  493. if (iRtxCurrent <= 0)
  494. return (iRtxBytes);
  496. iRtxBytes += iRtxCurrent;
  497. }
  499. return (iRtxBytes);
  501. }
  503. int SysRecvDataFrom(SYS_SOCKET SockFD, struct sockaddr *pFrom, int iFromlen,
  504.     char *pszBuffer, int iBufferSize, int iTimeout)
  505. {
  507. HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  509. if (hReadEvent == NULL) {
  510. ErrSetErrorCode(ERR_CREATEEVENT);
  511. return (ERR_CREATEEVENT);
  512. }
  514. DWORD dwRtxBytes = 0;
  515. WSABUF WSABuff;
  516. HANDLE hWaitEvents[2] = { hReadEvent, hShutdownEvent };
  518. ZeroData(WSABuff);
  519. WSABuff.len = iBufferSize;
  520. WSABuff.buf = pszBuffer;
  522. for (;;) {
  523. WSAEventSelect(SockFD, (WSAEVENT) hReadEvent, FD_READ | FD_CLOSE);
  525. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hWaitEvents, FALSE,
  526.       (DWORD) (iTimeout * 1000), TRUE);
  528. WSAEventSelect(SockFD, (WSAEVENT) hReadEvent, 0);
  530. if (dwWaitResult == (WSA_WAIT_EVENT_0 + 1)) {
  531. CloseHandle(hReadEvent);
  532. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  533. return (ERR_SERVER_SHUTDOWN);
  534. } else if (dwWaitResult != WSA_WAIT_EVENT_0) {
  535. CloseHandle(hReadEvent);
  536. ErrSetErrorCode(ERR_TIMEOUT);
  537. return (ERR_TIMEOUT);
  538. }
  540. INT FromLen = (INT) iFromlen;
  541. DWORD dwRtxFlags = 0;
  543. if (WSARecvFrom(SockFD, &WSABuff, 1, &dwRtxBytes, &dwRtxFlags,
  544. pFrom, &FromLen, NULL, NULL) == 0)
  545. break;
  547. if (WSAGetLastError() != WSAEWOULDBLOCK) {
  548. CloseHandle(hReadEvent);
  549. ErrSetErrorCode(ERR_NETWORK);
  550. return (ERR_NETWORK);
  551. }
  552. ///////////////////////////////////////////////////////////////////////////////
  553. //  You should never get here if Win32 API worked fine
  554. ///////////////////////////////////////////////////////////////////////////////
  555. HANDLE_SOCKS_SUCKS();
  556. }
  558. CloseHandle(hReadEvent);
  560. return ((int) dwRtxBytes);
  562. }
  564. int SysSendData(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize, int iTimeout)
  565. {
  567. HANDLE hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  569. if (hWriteEvent == NULL) {
  570. ErrSetErrorCode(ERR_CREATEEVENT);
  571. return (ERR_CREATEEVENT);
  572. }
  574. int iSendBytes = 0;
  575. HANDLE hWaitEvents[2] = { hWriteEvent, hShutdownEvent };
  577. for (;;) {
  578. WSAEventSelect(SockFD, (WSAEVENT) hWriteEvent, FD_WRITE | FD_CLOSE);
  580. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hWaitEvents, FALSE,
  581.       (DWORD) (iTimeout * 1000), TRUE);
  583. WSAEventSelect(SockFD, (WSAEVENT) hWriteEvent, 0);
  585. if (dwWaitResult == (WSA_WAIT_EVENT_0 + 1)) {
  586. CloseHandle(hWriteEvent);
  587. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  588. return (ERR_SERVER_SHUTDOWN);
  589. } else if (dwWaitResult != WSA_WAIT_EVENT_0) {
  590. CloseHandle(hWriteEvent);
  591. ErrSetErrorCode(ERR_TIMEOUT);
  592. return (ERR_TIMEOUT);
  593. }
  595. if ((iSendBytes = SysSendLL(SockFD, pszBuffer, iBufferSize)) >= 0)
  596. break;
  598. int iErrorCode = -iSendBytes;
  600. if (iErrorCode != WSAEWOULDBLOCK) {
  601. CloseHandle(hWriteEvent);
  602. ErrSetErrorCode(ERR_NETWORK);
  603. return (ERR_NETWORK);
  604. }
  605. ///////////////////////////////////////////////////////////////////////////////
  606. //  You should never get here if Win32 API worked fine
  607. ///////////////////////////////////////////////////////////////////////////////
  608. HANDLE_SOCKS_SUCKS();
  609. }
  611. CloseHandle(hWriteEvent);
  613. return (iSendBytes);
  615. }
  617. int SysSend(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize, int iTimeout)
  618. {
  620. int iRtxBytes = 0;
  622. while (iRtxBytes < iBufferSize) {
  623. int iRtxCurrent = SysSendData(SockFD, pszBuffer + iRtxBytes,
  624.       iBufferSize - iRtxBytes, iTimeout);
  626. if (iRtxCurrent <= 0)
  627. return (iRtxBytes);
  629. iRtxBytes += iRtxCurrent;
  630. }
  632. return (iRtxBytes);
  634. }
  636. int SysSendDataTo(SYS_SOCKET SockFD, const struct sockaddr *pTo,
  637.   int iToLen, char const *pszBuffer, int iBufferSize, int iTimeout)
  638. {
  640. HANDLE hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  642. if (hWriteEvent == NULL) {
  643. ErrSetErrorCode(ERR_CREATEEVENT);
  644. return (ERR_CREATEEVENT);
  645. }
  647. DWORD dwRtxBytes = 0;
  648. WSABUF WSABuff;
  649. HANDLE hWaitEvents[2] = { hWriteEvent, hShutdownEvent };
  651. ZeroData(WSABuff);
  652. WSABuff.len = iBufferSize;
  653. WSABuff.buf = (char *) pszBuffer;
  655. for (;;) {
  656. WSAEventSelect(SockFD, (WSAEVENT) hWriteEvent, FD_WRITE | FD_CLOSE);
  658. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hWaitEvents, FALSE,
  659.       (DWORD) (iTimeout * 1000), TRUE);
  661. WSAEventSelect(SockFD, (WSAEVENT) hWriteEvent, 0);
  663. if (dwWaitResult == (WSA_WAIT_EVENT_0 + 1)) {
  664. CloseHandle(hWriteEvent);
  665. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  666. return (ERR_SERVER_SHUTDOWN);
  667. } else if (dwWaitResult != WSA_WAIT_EVENT_0) {
  668. CloseHandle(hWriteEvent);
  669. ErrSetErrorCode(ERR_TIMEOUT);
  670. return (ERR_TIMEOUT);
  671. }
  673. DWORD dwRtxFlags = 0;
  675. if (WSASendTo(SockFD, &WSABuff, 1, &dwRtxBytes, dwRtxFlags,
  676.       pTo, iToLen, NULL, NULL) == 0)
  677. break;
  679. if (WSAGetLastError() != WSAEWOULDBLOCK) {
  680. CloseHandle(hWriteEvent);
  681. ErrSetErrorCode(ERR_NETWORK);
  682. return (ERR_NETWORK);
  683. }
  684. ///////////////////////////////////////////////////////////////////////////////
  685. //  You should never get here if Win32 API worked fine
  686. ///////////////////////////////////////////////////////////////////////////////
  687. HANDLE_SOCKS_SUCKS();
  688. }
  690. CloseHandle(hWriteEvent);
  692. return ((int) dwRtxBytes);
  694. }
  696. int SysConnect(SYS_SOCKET SockFD, const SYS_INET_ADDR * pSockName, int iNameLen, int iTimeout)
  697. {
  699. HANDLE hConnectEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  701. if (hConnectEvent == NULL) {
  702. ErrSetErrorCode(ERR_CREATEEVENT);
  703. return (ERR_CREATEEVENT);
  704. }
  706. WSAEventSelect(SockFD, (WSAEVENT) hConnectEvent, FD_CONNECT);
  708. int iConnectResult = WSAConnect(SockFD, (const struct sockaddr *) &pSockName->Addr,
  709. iNameLen, NULL, NULL, NULL, NULL);
  710. int iConnectError = WSAGetLastError();
  712. if ((iConnectResult != 0) && (iConnectError == WSAEWOULDBLOCK)) {
  713. HANDLE hWaitEvents[2] = { hConnectEvent, hShutdownEvent };
  714. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hWaitEvents, FALSE,
  715.       (DWORD) (iTimeout * 1000), TRUE);
  717. if (dwWaitResult == WSA_WAIT_EVENT_0) {
  718. WSANETWORKEVENTS NetEvents;
  720. if ((WSAEnumNetworkEvents(SockFD, hConnectEvent, &NetEvents) != 0) ||
  721.     (NetEvents.iErrorCode[FD_CONNECT_BIT] != 0)) {
  722. ErrSetErrorCode(ERR_CONNECT);
  724. iConnectResult = ERR_CONNECT;
  725. } else
  726. iConnectResult = 0;
  727. } else if (dwWaitResult == (WSA_WAIT_EVENT_0 + 1)) {
  728. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  730. iConnectResult = ERR_SERVER_SHUTDOWN;
  731. } else {
  732. ErrSetErrorCode(ERR_TIMEOUT);
  734. iConnectResult = ERR_TIMEOUT;
  735. }
  736. }
  738. WSAEventSelect(SockFD, (WSAEVENT) hConnectEvent, 0);
  739. CloseHandle(hConnectEvent);
  741. return (iConnectResult);
  743. }
  745. SYS_SOCKET SysAccept(SYS_SOCKET SockFD, SYS_INET_ADDR * pSockName, int *iNameLen, int iTimeout)
  746. {
  748. HANDLE hAcceptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  750. if (hAcceptEvent == NULL) {
  751. ErrSetErrorCode(ERR_CREATEEVENT);
  752. return (SYS_INVALID_SOCKET);
  753. }
  755. WSAEventSelect(SockFD, (WSAEVENT) hAcceptEvent, FD_ACCEPT);
  757. SOCKET SockFDAccept =
  758.     WSAAccept(SockFD, (struct sockaddr *) &pSockName->Addr, iNameLen, NULL, 0);
  760. int iConnectError = WSAGetLastError();
  762. if ((SockFDAccept == INVALID_SOCKET) && (iConnectError == WSAEWOULDBLOCK)) {
  763. HANDLE hWaitEvents[2] = { hAcceptEvent, hShutdownEvent };
  764. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hWaitEvents, FALSE,
  765.       (DWORD) (iTimeout * 1000), TRUE);
  767. if (dwWaitResult == WSA_WAIT_EVENT_0)
  768. SockFDAccept =
  769.     WSAAccept(SockFD, (struct sockaddr *) &pSockName->Addr, iNameLen,
  770.       NULL, 0);
  771. else if (dwWaitResult == (WSA_WAIT_EVENT_0 + 1))
  772. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  773. else
  774. ErrSetErrorCode(ERR_TIMEOUT);
  775. }
  777. WSAEventSelect(SockFD, (WSAEVENT) hAcceptEvent, 0);
  778. CloseHandle(hAcceptEvent);
  780. if (SockFDAccept != INVALID_SOCKET) {
  781. if ((SysBlockSocket(SockFDAccept, 0) < 0) ||
  782.     (SysSetSocketsOptions(SockFDAccept) < 0)) {
  783. SysCloseSocket(SockFDAccept);
  784. return (SYS_INVALID_SOCKET);
  785. }
  786. }
  788. return (SockFDAccept);
  790. }
  792. int SysSelect(int iMaxFD, SYS_fd_set * pReadFDs, SYS_fd_set * pWriteFDs, SYS_fd_set * pExcptFDs,
  793.       int iTimeout)
  794. {
  796. struct timeval TV;
  798. ZeroData(TV);
  799. TV.tv_sec = iTimeout;
  800. TV.tv_usec = 0;
  802. int iSelectResult = select(iMaxFD + 1, pReadFDs, pWriteFDs, pExcptFDs, &TV);
  804. if (iSelectResult < 0) {
  805. ErrSetErrorCode(ERR_SELECT);
  806. return (ERR_SELECT);
  807. }
  809. if (iSelectResult == 0) {
  810. ErrSetErrorCode(ERR_TIMEOUT);
  811. return (ERR_TIMEOUT);
  812. }
  814. return (iSelectResult);
  816. }
  818. int SysSendFile(SYS_SOCKET SockFD, char const *pszFileName, unsigned long ulBaseOffset,
  819. unsigned long ulEndOffset, int iTimeout)
  820. {
  821. ///////////////////////////////////////////////////////////////////////////////
  822. //  Open the source file
  823. ///////////////////////////////////////////////////////////////////////////////
  824. HANDLE hFile = CreateFile(pszFileName, GENERIC_READ, FILE_SHARE_READ,
  825.   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  827. if (hFile == INVALID_HANDLE_VALUE) {
  828. ErrSetErrorCode(ERR_FILE_OPEN);
  829. return (ERR_FILE_OPEN);
  830. }
  831. ///////////////////////////////////////////////////////////////////////////////
  832. //  Create file mapping and the file
  833. ///////////////////////////////////////////////////////////////////////////////
  834. DWORD dwFileSizeHi = 0;
  835. DWORD dwFileSizeLo = GetFileSize(hFile, &dwFileSizeHi);
  836. HANDLE hFileMap = CreateFileMapping(hFile, NULL, PAGE_READONLY,
  837.     dwFileSizeHi, dwFileSizeLo, NULL);
  839. if (hFileMap == NULL) {
  840. CloseHandle(hFile);
  842. ErrSetErrorCode(ERR_CREATEFILEMAPPING);
  843. return (ERR_CREATEFILEMAPPING);
  844. }
  846. void *pAddress = MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 0);
  848. if (pAddress == NULL) {
  849. CloseHandle(hFileMap);
  850. CloseHandle(hFile);
  852. ErrSetErrorCode(ERR_MAPVIEWOFFILE);
  853. return (ERR_MAPVIEWOFFILE);
  854. }
  855. ///////////////////////////////////////////////////////////////////////////////
  856. //  Send the file
  857. ///////////////////////////////////////////////////////////////////////////////
  858. int iSndBuffSize = MIN_TCP_SEND_SIZE;
  859. SYS_UINT64 ullFileSize = (((SYS_UINT64) dwFileSizeHi) << 32) | (SYS_UINT64) dwFileSizeLo;
  860. SYS_UINT64 ullEndOffset = (ulEndOffset != (unsigned long) -1) ?
  861.     ((SYS_UINT64) ulEndOffset) : ullFileSize;
  862. SYS_UINT64 ullCurrOffset = (SYS_UINT64) ulBaseOffset;
  863. char *pszBuffer = (char *) pAddress + ulBaseOffset;
  864. time_t tStart;
  866. while (ullCurrOffset < ullEndOffset) {
  867. int iCurrSend = (int) Min(iSndBuffSize, ullEndOffset - ullCurrOffset);
  869. tStart = time(NULL);
  870. if ((iCurrSend = SysSendData(SockFD, pszBuffer, iCurrSend, iTimeout)) < 0) {
  871. ErrorPush();
  872. UnmapViewOfFile(pAddress);
  873. CloseHandle(hFileMap);
  874. CloseHandle(hFile);
  875. return (ErrorPop());
  876. }
  878. if ((((time(NULL) - tStart) * K_IO_TIME_RATIO) < iTimeout) &&
  879.     (iSndBuffSize < MAX_TCP_SEND_SIZE))
  880. iSndBuffSize = Min(iSndBuffSize * 2, MAX_TCP_SEND_SIZE);
  882. pszBuffer += iCurrSend;
  883. ullCurrOffset += (SYS_UINT64) iCurrSend;
  884. }
  886. UnmapViewOfFile(pAddress);
  887. CloseHandle(hFileMap);
  888. CloseHandle(hFile);
  890. return (0);
  892. }
  894. int SysSetupAddress(SYS_INET_ADDR & AddrInfo, int iFamily,
  895.     NET_ADDRESS const &NetAddr, int iPortNo)
  896. {
  898. ZeroData(AddrInfo);
  899. AddrInfo.Addr.sin_family = iFamily;
  900. SAIN_Addr(AddrInfo.Addr) = NetAddr;
  901. AddrInfo.Addr.sin_port = htons((short) iPortNo);
  903. return (0);
  905. }
  907. int SysGetAddrAddress(SYS_INET_ADDR const &AddrInfo, NET_ADDRESS & NetAddr)
  908. {
  910. NetAddr = SAIN_Addr(AddrInfo.Addr);
  912. return (0);
  914. }
  916. int SysGetAddrPort(SYS_INET_ADDR const &AddrInfo)
  917. {
  919. return (ntohs(AddrInfo.Addr.sin_port));
  921. }
  923. int SysSetAddrAddress(SYS_INET_ADDR & AddrInfo, NET_ADDRESS const &NetAddr)
  924. {
  926. SAIN_Addr(AddrInfo.Addr) = NetAddr;
  928. return (0);
  930. }
  932. int SysSetAddrPort(SYS_INET_ADDR & AddrInfo, int iPortNo)
  933. {
  935. AddrInfo.Addr.sin_port = htons((short) iPortNo);
  937. return (0);
  939. }
  941. int SysGetHostByName(char const *pszName, NET_ADDRESS & NetAddr)
  942. {
  944. struct hostent *pHostEnt = gethostbyname(pszName);
  946. if ((pHostEnt == NULL) || (pHostEnt->h_addr_list[0] == NULL)) {
  947. ErrSetErrorCode(ERR_BAD_SERVER_ADDR, pszName);
  948. return (ERR_BAD_SERVER_ADDR);
  949. }
  951. memcpy(&NetAddr, pHostEnt->h_addr_list[0], sizeof(NetAddr));
  953. return (0);
  955. }
  957. int SysGetHostByAddr(SYS_INET_ADDR const &AddrInfo, char *pszFQDN)
  958. {
  960. struct hostent *pHostEnt = gethostbyaddr((const char *) &SAIN_Addr(AddrInfo.Addr),
  961.  sizeof(SAIN_Addr(AddrInfo.Addr)), AF_INET);
  963. if (pHostEnt == NULL) {
  964. char szIP[128] = "???.???.???.???";
  966. ErrSetErrorCode(ERR_GET_SOCK_HOST, SysInetNToA(AddrInfo, szIP));
  967. return (ERR_GET_SOCK_HOST);
  968. }
  970. strcpy(pszFQDN, pHostEnt->h_name);
  972. return (0);
  974. }
  976. int SysGetPeerInfo(SYS_SOCKET SockFD, SYS_INET_ADDR & AddrInfo)
  977. {
  979. ZeroData(AddrInfo);
  981. socklen_t InfoSize = sizeof(AddrInfo.Addr);
  983. if (getpeername(SockFD, (struct sockaddr *) &AddrInfo.Addr, &InfoSize) == -1) {
  984. ErrSetErrorCode(ERR_GET_PEER_INFO);
  985. return (ERR_GET_PEER_INFO);
  986. }
  988. return (0);
  990. }
  992. int SysGetSockInfo(SYS_SOCKET SockFD, SYS_INET_ADDR & AddrInfo)
  993. {
  995. ZeroData(AddrInfo);
  997. socklen_t InfoSize = sizeof(AddrInfo.Addr);
  999. if (getsockname(SockFD, (struct sockaddr *) &AddrInfo.Addr, &InfoSize) == -1) {
  1000. ErrSetErrorCode(ERR_GET_SOCK_INFO);
  1001. return (ERR_GET_SOCK_INFO);
  1002. }
  1004. return (0);
  1006. }
  1008. char *SysInetNToA(SYS_INET_ADDR const &AddrInfo, char *pszIP)
  1009. {
  1011. union {
  1012. unsigned int a;
  1013. unsigned char b[4];
  1014. } UAddr;
  1016. memcpy(&UAddr, &AddrInfo.Addr.sin_addr, sizeof(UAddr));
  1018. sprintf(pszIP, "%u.%u.%u.%u",
  1019. (unsigned int) UAddr.b[0],
  1020. (unsigned int) UAddr.b[1], (unsigned int) UAddr.b[2], (unsigned int) UAddr.b[3]);
  1022. return (pszIP);
  1024. }
  1026. int SysInetAddr(char const *pszDotName, NET_ADDRESS & NetAddr)
  1027. {
  1029. if ((NetAddr = (NET_ADDRESS) inet_addr(pszDotName)) == SYS_INVALID_NET_ADDRESS) {
  1030. ErrSetErrorCode(ERR_BAD_SERVER_ADDR, pszDotName);
  1031. return (ERR_BAD_SERVER_ADDR);
  1032. }
  1034. return (0);
  1036. }
  1038. int SysSameAddress(NET_ADDRESS const &NetAddr1, NET_ADDRESS const &NetAddr2)
  1039. {
  1041. return (memcmp(&NetAddr1, &NetAddr2, sizeof(NET_ADDRESS)) == 0);
  1043. }
  1045. SYS_SEMAPHORE SysCreateSemaphore(int iInitCount, int iMaxCount)
  1046. {
  1048. HANDLE hSemaphore = CreateSemaphore(NULL, iInitCount, iMaxCount, NULL);
  1050. if (hSemaphore == NULL) {
  1051. ErrSetErrorCode(ERR_CREATESEMAPHORE);
  1052. return (SYS_INVALID_SEMAPHORE);
  1053. }
  1055. return ((SYS_SEMAPHORE) hSemaphore);
  1057. }
  1059. int SysCloseSemaphore(SYS_SEMAPHORE hSemaphore)
  1060. {
  1062. if (!CloseHandle((HANDLE) hSemaphore)) {
  1063. ErrSetErrorCode(ERR_CLOSEHANDLE);
  1064. return (ERR_CLOSEHANDLE);
  1065. }
  1067. return (0);
  1069. }
  1071. int SysWaitSemaphore(SYS_SEMAPHORE hSemaphore, int iTimeout)
  1072. {
  1074. if (WaitForSingleObject((HANDLE) hSemaphore, (DWORD) (iTimeout * 1000)) != WAIT_OBJECT_0) {
  1075. ErrSetErrorCode(ERR_TIMEOUT);
  1076. return (ERR_TIMEOUT);
  1077. }
  1079. return (0);
  1081. }
  1083. int SysReleaseSemaphore(SYS_SEMAPHORE hSemaphore, int iCount)
  1084. {
  1086. if (!ReleaseSemaphore((HANDLE) hSemaphore, (LONG) iCount, NULL)) {
  1087. ErrSetErrorCode(ERR_RELEASESEMAPHORE);
  1088. return (ERR_RELEASESEMAPHORE);
  1089. }
  1091. return (0);
  1093. }
  1095. int SysTryWaitSemaphore(SYS_SEMAPHORE hSemaphore)
  1096. {
  1098. if (WaitForSingleObject((HANDLE) hSemaphore, 0) != WAIT_OBJECT_0) {
  1099. ErrSetErrorCode(ERR_TIMEOUT);
  1100. return (ERR_TIMEOUT);
  1101. }
  1103. return (0);
  1105. }
  1107. SYS_MUTEX SysCreateMutex(void)
  1108. {
  1110. HANDLE hMutex = CreateMutex(NULL, FALSE, NULL);
  1112. if (hMutex == NULL) {
  1113. ErrSetErrorCode(ERR_CREATEMUTEX);
  1114. return (SYS_INVALID_MUTEX);
  1115. }
  1117. return ((SYS_MUTEX) hMutex);
  1119. }
  1121. int SysCloseMutex(SYS_MUTEX hMutex)
  1122. {
  1124. if (!CloseHandle((HANDLE) hMutex)) {
  1125. ErrSetErrorCode(ERR_CLOSEHANDLE);
  1126. return (ERR_CLOSEHANDLE);
  1127. }
  1129. return (0);
  1131. }
  1133. int SysLockMutex(SYS_MUTEX hMutex, int iTimeout)
  1134. {
  1136. if (WaitForSingleObject((HANDLE) hMutex, (DWORD) (iTimeout * 1000)) != WAIT_OBJECT_0) {
  1137. ErrSetErrorCode(ERR_TIMEOUT);
  1138. return (ERR_TIMEOUT);
  1139. }
  1141. return (0);
  1143. }
  1145. int SysUnlockMutex(SYS_MUTEX hMutex)
  1146. {
  1148. ReleaseMutex((HANDLE) hMutex);
  1150. return (0);
  1152. }
  1154. int SysTryLockMutex(SYS_MUTEX hMutex)
  1155. {
  1157. if (WaitForSingleObject((HANDLE) hMutex, 0) != WAIT_OBJECT_0) {
  1158. ErrSetErrorCode(ERR_TIMEOUT);
  1159. return (ERR_TIMEOUT);
  1160. }
  1162. return (0);
  1164. }
  1166. SYS_EVENT SysCreateEvent(int iManualReset)
  1167. {
  1169. HANDLE hEvent = CreateEvent(NULL, iManualReset, FALSE, NULL);
  1171. if (hEvent == NULL) {
  1172. ErrSetErrorCode(ERR_CREATEEVENT);
  1173. return (SYS_INVALID_EVENT);
  1174. }
  1176. return ((SYS_EVENT) hEvent);
  1178. }
  1180. int SysCloseEvent(SYS_EVENT hEvent)
  1181. {
  1183. if (!CloseHandle((HANDLE) hEvent)) {
  1184. ErrSetErrorCode(ERR_CLOSEHANDLE);
  1185. return (ERR_CLOSEHANDLE);
  1186. }
  1188. return (0);
  1190. }
  1192. int SysWaitEvent(SYS_EVENT hEvent, int iTimeout)
  1193. {
  1195. if (WaitForSingleObject((HANDLE) hEvent, (DWORD) (iTimeout * 1000)) != WAIT_OBJECT_0) {
  1196. ErrSetErrorCode(ERR_TIMEOUT);
  1197. return (ERR_TIMEOUT);
  1198. }
  1200. return (0);
  1202. }
  1204. int SysSetEvent(SYS_EVENT hEvent)
  1205. {
  1207. SetEvent((HANDLE) hEvent);
  1209. return (0);
  1211. }
  1213. int SysResetEvent(SYS_EVENT hEvent)
  1214. {
  1216. ResetEvent((HANDLE) hEvent);
  1218. return (0);
  1220. }
  1222. int SysTryWaitEvent(SYS_EVENT hEvent)
  1223. {
  1225. if (WaitForSingleObject((HANDLE) hEvent, 0) != WAIT_OBJECT_0) {
  1226. ErrSetErrorCode(ERR_TIMEOUT);
  1227. return (ERR_TIMEOUT);
  1228. }
  1230. return (0);
  1232. }
  1234. static unsigned int SysThreadRunner(void *pRunData)
  1235. {
  1237. ThreadRunner *pTR = (ThreadRunner *) pRunData;
  1239. if (SysThreadSetup() < 0) {
  1240. SysFree(pTR);
  1241. return (ErrGetErrorCode());
  1242. }
  1244. unsigned int uResultCode = SysStkCall(pTR->pThreadProc, pTR->pThreadData);
  1246. SysThreadCleanup();
  1248. SysFree(pTR);
  1250. return (uResultCode);
  1252. }
  1254. SYS_THREAD SysCreateThread(unsigned int (*pThreadProc) (void *), void *pThreadData)
  1255. {
  1256. ///////////////////////////////////////////////////////////////////////////////
  1257. //  Alloc thread runner data
  1258. ///////////////////////////////////////////////////////////////////////////////
  1259. ThreadRunner *pTR = (ThreadRunner *) SysAlloc(sizeof(ThreadRunner));
  1261. if (pTR == NULL)
  1262. return (SYS_INVALID_THREAD);
  1264. pTR->pThreadProc = pThreadProc;
  1265. pTR->pThreadData = pThreadData;
  1267. ///////////////////////////////////////////////////////////////////////////////
  1268. //  Create the thread
  1269. ///////////////////////////////////////////////////////////////////////////////
  1270. unsigned int uThreadId = 0;
  1271. unsigned long ulThread = _beginthreadex(NULL, 0,
  1272. (unsigned (__stdcall *) (void *)) SysThreadRunner,
  1273. pTR, 0, &uThreadId);
  1275. if (ulThread == 0) {
  1276. SysFree(pTR);
  1277. ErrSetErrorCode(ERR_BEGINTHREADEX);
  1278. return (SYS_INVALID_THREAD);
  1279. }
  1281. return ((SYS_THREAD) ulThread);
  1283. }
  1285. SYS_THREAD SysCreateServiceThread(unsigned int (*pThreadProc) (void *), SYS_SOCKET SockFD)
  1286. {
  1288. SYS_THREAD ThreadID = SysCreateThread(pThreadProc, (void *) (unsigned int) SockFD);
  1290. return (ThreadID);
  1292. }
  1294. static int SysThreadSetup(void)
  1295. {
  1297. SysInitTlsKeys();
  1299. return (0);
  1301. }
  1303. static int SysThreadCleanup(void)
  1304. {
  1306. SysCleanupTlsKeys();
  1308. return (0);
  1310. }
  1312. void SysCloseThread(SYS_THREAD ThreadID, int iForce)
  1313. {
  1315. if (iForce)
  1316. TerminateThread((HANDLE) ThreadID, (DWORD) - 1);
  1318. CloseHandle((HANDLE) ThreadID);
  1320. }
  1322. int SysSetThreadPriority(SYS_THREAD ThreadID, int iPriority)
  1323. {
  1325. BOOL bSetResult = FALSE;
  1327. switch (iPriority) {
  1328. case (SYS_PRIORITY_NORMAL):
  1329. bSetResult = SetThreadPriority((HANDLE) ThreadID, THREAD_PRIORITY_NORMAL);
  1330. break;
  1332. case (SYS_PRIORITY_LOWER):
  1333. bSetResult = SetThreadPriority((HANDLE) ThreadID, THREAD_PRIORITY_BELOW_NORMAL);
  1334. break;
  1336. case (SYS_PRIORITY_HIGHER):
  1337. bSetResult = SetThreadPriority((HANDLE) ThreadID, THREAD_PRIORITY_ABOVE_NORMAL);
  1338. break;
  1339. }
  1341. if (!bSetResult) {
  1342. ErrSetErrorCode(ERR_SET_THREAD_PRIORITY);
  1343. return (ERR_SET_THREAD_PRIORITY);
  1344. }
  1346. return (0);
  1348. }
  1350. int SysWaitThread(SYS_THREAD ThreadID, int iTimeout)
  1351. {
  1353. if (WaitForSingleObject((HANDLE) ThreadID, (DWORD) (iTimeout * 1000)) != WAIT_OBJECT_0) {
  1354. ErrSetErrorCode(ERR_TIMEOUT);
  1355. return (ERR_TIMEOUT);
  1356. }
  1358. return (0);
  1360. }
  1362. unsigned long SysGetCurrentThreadId(void)
  1363. {
  1365. return ((unsigned long) GetCurrentThreadId());
  1367. }
  1369. int SysExec(char const *pszCommand, char const *const *pszArgs, int iWaitTimeout,
  1370.     int iPriority, int *piExitStatus)
  1371. {
  1373. int ii;
  1374. int iCommandLength = strlen(pszCommand) + 4;
  1376. for (ii = 1; pszArgs[ii] != NULL; ii++)
  1377. iCommandLength += strlen(pszArgs[ii]) + 4;
  1379. char *pszCmdLine = (char *) SysAlloc(iCommandLength + 1);
  1381. if (pszCmdLine == NULL)
  1382. return (ErrGetErrorCode());
  1384. strcpy(pszCmdLine, pszCommand);
  1386. for (ii = 1; pszArgs[ii] != NULL; ii++)
  1387. sprintf(StrAppend(pszCmdLine), " "%s"", pszArgs[ii]);
  1389. PROCESS_INFORMATION PI;
  1390. STARTUPINFO SI;
  1392. ZeroData(PI);
  1393. ZeroData(SI);
  1394. SI.cb = sizeof(STARTUPINFO);
  1396. BOOL bProcessCreated = CreateProcess(NULL, pszCmdLine, NULL, NULL, FALSE,
  1397.      CREATE_NO_WINDOW | NORMAL_PRIORITY_CLASS, NULL, NULL,
  1398.      &SI, &PI);
  1400. SysFree(pszCmdLine);
  1402. if (!bProcessCreated) {
  1403. ErrSetErrorCode(ERR_PROCESS_EXECUTE);
  1404. return (ERR_PROCESS_EXECUTE);
  1405. }
  1407. SysSetThreadPriority((SYS_THREAD) PI.hThread, iPriority);
  1409. if (iWaitTimeout > 0) {
  1410. if (WaitForSingleObject(PI.hProcess, iWaitTimeout * 1000) != WAIT_OBJECT_0) {
  1411. CloseHandle(PI.hThread);
  1412. CloseHandle(PI.hProcess);
  1414. ErrSetErrorCode(ERR_TIMEOUT);
  1415. return (ERR_TIMEOUT);
  1416. }
  1418. if (piExitStatus != NULL) {
  1419. DWORD dwExitCode = 0;
  1421. if (!GetExitCodeProcess(PI.hProcess, &dwExitCode))
  1422. *piExitStatus = -1;
  1423. else
  1424. *piExitStatus = (int) dwExitCode;
  1425. }
  1426. } else if (piExitStatus != NULL)
  1427. *piExitStatus = -1;
  1429. CloseHandle(PI.hThread);
  1430. CloseHandle(PI.hProcess);
  1432. return (0);
  1434. }
  1436. static BOOL WINAPI SysBreakHandlerRoutine(DWORD dwCtrlType)
  1437. {
  1439. BOOL bReturnValue = FALSE;
  1441. switch (dwCtrlType) {
  1442. case (CTRL_C_EVENT):
  1443. case (CTRL_CLOSE_EVENT):
  1444. case (CTRL_SHUTDOWN_EVENT):
  1446. if (SysBreakHandler != NULL)
  1447. SysBreakHandler(), bReturnValue = TRUE;
  1449. break;
  1451. }
  1453. return (bReturnValue);
  1455. }
  1457. void SysSetBreakHandler(void (*BreakHandler) (void))
  1458. {
  1460. if (SysBreakHandler == NULL)
  1461. SetConsoleCtrlHandler(SysBreakHandlerRoutine,
  1462.       (BreakHandler != NULL) ? TRUE : FALSE);
  1464. SysBreakHandler = BreakHandler;
  1466. }
  1468. int SysCreateTlsKey(SYS_TLSKEY & TlsKey, void (*pFreeProc) (void *))
  1469. {
  1471. EnterCriticalSection(&csTLS);
  1473. for (int ii = 0; ii < MAX_TLS_KEYS; ii++) {
  1474. if (TlsKeyEntries[ii].pFreeProc == UNUSED_TLS_KEY_PROC) {
  1475. TlsKeyEntries[ii].pFreeProc = pFreeProc;
  1477. LeaveCriticalSection(&csTLS);
  1479. TlsKey = (SYS_TLSKEY) ii;
  1481. return (0);
  1482. }
  1483. }
  1485. LeaveCriticalSection(&csTLS);
  1487. ErrSetErrorCode(ERR_NOMORE_TLSKEYS);
  1489. return (ERR_NOMORE_TLSKEYS);
  1491. }
  1493. int SysDeleteTlsKey(SYS_TLSKEY & TlsKey)
  1494. {
  1496. int iKey = (int) TlsKey;
  1498. EnterCriticalSection(&csTLS);
  1500. if ((iKey < 0) || (iKey >= MAX_TLS_KEYS) ||
  1501.     (TlsKeyEntries[iKey].pFreeProc == UNUSED_TLS_KEY_PROC)) {
  1502. LeaveCriticalSection(&csTLS);
  1504. ErrSetErrorCode(ERR_INVALID_TLSKEY);
  1505. return (ERR_INVALID_TLSKEY);
  1506. }
  1508. TlsKeyEntries[iKey].pFreeProc = UNUSED_TLS_KEY_PROC;
  1510. LeaveCriticalSection(&csTLS);
  1512. TlsKey = (SYS_TLSKEY) - 1;
  1514. return (0);
  1516. }
  1518. int SysSetTlsKeyData(SYS_TLSKEY & TlsKey, void *pData)
  1519. {
  1521. int iKey = (int) TlsKey;
  1523. if ((iKey < 0) || (iKey >= MAX_TLS_KEYS) ||
  1524.     (TlsKeyEntries[iKey].pFreeProc == UNUSED_TLS_KEY_PROC)) {
  1525. ErrSetErrorCode(ERR_INVALID_TLSKEY);
  1526. return (ERR_INVALID_TLSKEY);
  1527. }
  1529. TlsKeys[iKey].pData = pData;
  1531. return (0);
  1533. }
  1535. void *SysGetTlsKeyData(SYS_TLSKEY & TlsKey)
  1536. {
  1538. int iKey = (int) TlsKey;
  1540. if ((iKey < 0) || (iKey >= MAX_TLS_KEYS) ||
  1541.     (TlsKeyEntries[iKey].pFreeProc == UNUSED_TLS_KEY_PROC)) {
  1542. ErrSetErrorCode(ERR_INVALID_TLSKEY);
  1543. return (NULL);
  1544. }
  1546. return (TlsKeys[iKey].pData);
  1548. }
  1550. void SysThreadOnce(SYS_THREAD_ONCE * pThrOnce, void (*pOnceProc) (void))
  1551. {
  1553. if (InterlockedExchange(&pThrOnce->lOnce, 1) == 0) {
  1554. pOnceProc();
  1556. pThrOnce->lDone++;
  1557. }
  1559. while (!pThrOnce->lDone)
  1560. Sleep(0);
  1562. }
  1564. void *SysAlloc(unsigned int uSize)
  1565. {
  1567. void *pData = malloc(uSize);
  1569. if (pData != NULL)
  1570. memset(pData, 0, uSize);
  1571. else
  1572. ErrSetErrorCode(ERR_MEMORY);
  1574. return (pData);
  1576. }
  1578. void SysFree(void *pData)
  1579. {
  1581. free(pData);
  1583. }
  1585. void *SysRealloc(void *pData, unsigned int uSize)
  1586. {
  1588. void *pNewData = realloc(pData, uSize);
  1590. if (pNewData == NULL)
  1591. ErrSetErrorCode(ERR_MEMORY);
  1593. return (pNewData);
  1595. }
  1597. int SysLockFile(const char *pszFileName, char const *pszLockExt)
  1598. {
  1600. char szLockFile[SYS_MAX_PATH] = "";
  1602. SysSNPrintf(szLockFile, sizeof(szLockFile) - 1, "%s%s", pszFileName, pszLockExt);
  1604. ///////////////////////////////////////////////////////////////////////////////
  1605. //  Try to create lock file
  1606. ///////////////////////////////////////////////////////////////////////////////
  1607. HANDLE hFile = CreateFile(szLockFile, GENERIC_READ | GENERIC_WRITE,
  1608.   0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
  1610. if (hFile == INVALID_HANDLE_VALUE) {
  1611. if (GetLastError() == ERROR_ALREADY_EXISTS) {
  1612. ErrSetErrorCode(ERR_LOCKED);
  1613. return (ERR_LOCKED);
  1614. }
  1616. ErrSetErrorCode(ERR_FILE_CREATE);
  1617. return (ERR_FILE_CREATE);
  1618. }
  1620. DWORD dwWritten = 0;
  1621. char szLock[128] = "";
  1623. sprintf(szLock, "%lu", (unsigned long) GetCurrentThreadId());
  1625. if (!WriteFile(hFile, szLock, strlen(szLock) + 1, &dwWritten, NULL)) {
  1626. CloseHandle(hFile);
  1628. ErrSetErrorCode(ERR_FILE_WRITE);
  1629. return (ERR_FILE_WRITE);
  1630. }
  1632. CloseHandle(hFile);
  1634. return (0);
  1636. }
  1638. int SysUnlockFile(const char *pszFileName, char const *pszLockExt)
  1639. {
  1641. char szLockFile[SYS_MAX_PATH] = "";
  1643. SysSNPrintf(szLockFile, sizeof(szLockFile) - 1, "%s%s", pszFileName, pszLockExt);
  1645. if (_unlink(szLockFile) != 0) {
  1646. ErrSetErrorCode(ERR_NOT_LOCKED);
  1647. return (ERR_NOT_LOCKED);
  1648. }
  1650. return (0);
  1652. }
  1654. SYS_HANDLE SysOpenModule(char const *pszFilePath)
  1655. {
  1657. HMODULE hModule = LoadLibrary(pszFilePath);
  1659. if (hModule == NULL) {
  1660. ErrSetErrorCode(ERR_LOADMODULE, pszFilePath);
  1661. return (SYS_INVALID_HANDLE);
  1662. }
  1664. return ((SYS_HANDLE) hModule);
  1666. }
  1668. int SysCloseModule(SYS_HANDLE hModule)
  1669. {
  1671. FreeLibrary((HMODULE) hModule);
  1673. return (0);
  1675. }
  1677. void *SysGetSymbol(SYS_HANDLE hModule, char const *pszSymbol)
  1678. {
  1680. void *pSymbol = (void *) GetProcAddress((HMODULE) hModule, pszSymbol);
  1682. if (pSymbol == NULL) {
  1683. ErrSetErrorCode(ERR_LOADMODULESYMBOL, pszSymbol);
  1684. return (NULL);
  1685. }
  1687. return (pSymbol);
  1689. }
  1691. int SysEventLogV(int iLogLevel, char const *pszFormat, va_list Args)
  1692. {
  1694. HANDLE hEventSource = RegisterEventSource(NULL, szServerName);
  1696. if (hEventSource == NULL) {
  1697. ErrSetErrorCode(ERR_REGISTER_EVENT_SOURCE);
  1698. return (ERR_REGISTER_EVENT_SOURCE);
  1699. }
  1701. char *pszStrings[2];
  1702. char szBuffer[2048] = "";
  1704. _vsnprintf(szBuffer, sizeof(szBuffer) - 1, pszFormat, Args);
  1705. pszStrings[0] = szBuffer;
  1707. ReportEvent(hEventSource,
  1708.     iLogLevel == LOG_LEV_ERROR ? EVENTLOG_ERROR_TYPE:
  1709.     iLogLevel == LOG_LEV_WARNING ? EVENTLOG_WARNING_TYPE:
  1710.     EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (const char **) pszStrings, NULL);
  1712. DeregisterEventSource(hEventSource);
  1714. return (0);
  1716. }
  1718. int SysEventLog(int iLogLevel, char const *pszFormat, ...)
  1719. {
  1721. va_list Args;
  1723. va_start(Args, pszFormat);
  1725. int iLogResult = SysEventLogV(iLogLevel, pszFormat, Args);
  1727. va_end(Args);
  1729. return (0);
  1731. }
  1733. int SysLogMessage(int iLogLevel, char const *pszFormat, ...)
  1734. {
  1736. extern bool bServerDebug;
  1738. EnterCriticalSection(&csLog);
  1740. va_list Args;
  1742. va_start(Args, pszFormat);
  1744. if (bServerDebug) {
  1745. ///////////////////////////////////////////////////////////////////////////////
  1746. //  Debug implementation
  1747. ///////////////////////////////////////////////////////////////////////////////
  1749. vprintf(pszFormat, Args);
  1751. } else {
  1752. switch (iLogLevel) {
  1753. case (LOG_LEV_WARNING):
  1754. case (LOG_LEV_ERROR):
  1756. SysEventLogV(iLogLevel, pszFormat, Args);
  1758. break;
  1759. }
  1760. }
  1762. va_end(Args);
  1764. LeaveCriticalSection(&csLog);
  1766. return (0);
  1768. }
  1770. void SysSleep(int iTimeout)
  1771. {
  1773. SysMsSleep(iTimeout * 1000);
  1775. }
  1777. void SysMsSleep(int iMsTimeout)
  1778. {
  1780. Sleep(iMsTimeout);
  1782. }
  1784. static void SysTimetToFileTime(time_t tTime, LPFILETIME pFT)
  1785. {
  1787. LONGLONG llTime = Int32x32To64(tTime, 10000000) + 116444736000000000;
  1789. pFT->dwLowDateTime = (DWORD) llTime;
  1790. pFT->dwHighDateTime = (DWORD) (llTime >> 32);
  1792. }
  1794. static time_t SysFileTimeToTimet(LPFILETIME pFT)
  1795. {
  1797. LONGLONG llTime = ((LONGLONG) pFT->dwLowDateTime) |
  1798.     (((LONGLONG) pFT->dwHighDateTime) << 32);
  1800. return ((time_t) ((llTime - 116444736000000000) / 10000000));
  1802. }
  1804. SYS_INT64 SysMsTime(void)
  1805. {
  1807. LARGE_INTEGER PerfCntCurr;
  1809. QueryPerformanceCounter(&PerfCntCurr);
  1811. SYS_INT64 MsTicks = *(SYS_INT64 *) & PerfCntCurr;
  1813. MsTicks -= PCSysStart;
  1814. MsTicks /= PCFreq;
  1815. MsTicks += (SYS_INT64) tSysStart *1000;
  1817. return (MsTicks);
  1819. }
  1821. int SysExistFile(const char *pszFilePath)
  1822. {
  1824. DWORD dwAttr = GetFileAttributes(pszFilePath);
  1826. if (dwAttr == (DWORD) - 1)
  1827. return (0);
  1829. return ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) ? 0 : 1);
  1831. }
  1833. int SysExistDir(const char *pszDirPath)
  1834. {
  1836. DWORD dwAttr = GetFileAttributes(pszDirPath);
  1838. if (dwAttr == (DWORD) - 1)
  1839. return (0);
  1841. return ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0);
  1843. }
  1845. SYS_HANDLE SysFirstFile(const char *pszPath, char *pszFileName)
  1846. {
  1848. char szMatch[SYS_MAX_PATH] = "";
  1850. strcpy(szMatch, pszPath);
  1851. AppendSlash(szMatch);
  1852. strcat(szMatch, "*");
  1854. WIN32_FIND_DATA WFD;
  1855. HANDLE hFind = FindFirstFile(szMatch, &WFD);
  1857. if (hFind == INVALID_HANDLE_VALUE)
  1858. return (SYS_INVALID_HANDLE);
  1860. FileFindData *pFFD = (FileFindData *) SysAlloc(sizeof(FileFindData));
  1862. if (pFFD == NULL) {
  1863. FindClose(hFind);
  1864. return (SYS_INVALID_HANDLE);
  1865. }
  1867. strcpy(pFFD->szFindPath, pszPath);
  1868. AppendSlash(pFFD->szFindPath);
  1870. pFFD->hFind = hFind;
  1871. pFFD->WFD = WFD;
  1873. strcpy(pszFileName, pFFD->WFD.cFileName);
  1875. return ((SYS_HANDLE) pFFD);
  1877. }
  1879. int SysIsDirectory(SYS_HANDLE hFind)
  1880. {
  1882. FileFindData *pFFD = (FileFindData *) hFind;
  1884. return ((pFFD->WFD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0);
  1886. }
  1888. unsigned long SysGetSize(SYS_HANDLE hFind)
  1889. {
  1891. FileFindData *pFFD = (FileFindData *) hFind;
  1893. return ((unsigned long) pFFD->WFD.nFileSizeLow);
  1895. }
  1897. int SysNextFile(SYS_HANDLE hFind, char *pszFileName)
  1898. {
  1900. FileFindData *pFFD = (FileFindData *) hFind;
  1902. if (!FindNextFile(pFFD->hFind, &pFFD->WFD))
  1903. return (0);
  1905. strcpy(pszFileName, pFFD->WFD.cFileName);
  1907. return (1);
  1909. }
  1911. void SysFindClose(SYS_HANDLE hFind)
  1912. {
  1914. FileFindData *pFFD = (FileFindData *) hFind;
  1916. FindClose(pFFD->hFind);
  1918. SysFree(pFFD);
  1920. }
  1922. int SysGetFileInfo(char const *pszFileName, SYS_FILE_INFO & FI)
  1923. {
  1925. WIN32_FIND_DATA WFD;
  1926. HANDLE hFind = FindFirstFile(pszFileName, &WFD);
  1928. if (hFind == INVALID_HANDLE_VALUE) {
  1929. ErrSetErrorCode(ERR_STAT);
  1930. return (ERR_STAT);
  1931. }
  1933. ZeroData(FI);
  1934. FI.iFileType = (WFD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? ftDirectory : ftNormal;
  1935. FI.ulSize = (unsigned long) WFD.nFileSizeLow;
  1936. FI.tMod = SysFileTimeToTimet(&WFD.ftLastWriteTime);
  1938. FindClose(hFind);
  1940. return (0);
  1942. }
  1944. int SysSetFileModTime(char const *pszFileName, time_t tMod)
  1945. {
  1947. HANDLE hFile = CreateFile(pszFileName, GENERIC_WRITE,
  1948.   FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
  1949.   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  1951. if (hFile == INVALID_HANDLE_VALUE) {
  1952. ErrSetErrorCode(ERR_SET_FILE_TIME);
  1953. return (ERR_SET_FILE_TIME);
  1954. }
  1956. FILETIME MFT;
  1958. SysTimetToFileTime(tMod, &MFT);
  1960. if (!SetFileTime(hFile, NULL, &MFT, &MFT)) {
  1961. CloseHandle(hFile);
  1962. ErrSetErrorCode(ERR_SET_FILE_TIME);
  1963. return (ERR_SET_FILE_TIME);
  1964. }
  1966. CloseHandle(hFile);
  1968. return (0);
  1970. }
  1972. char *SysStrDup(const char *pszString)
  1973. {
  1975. int iStrLength = strlen(pszString);
  1976. char *pszBuffer = (char *) SysAlloc(iStrLength + 1);
  1978. if (pszBuffer != NULL)
  1979. strcpy(pszBuffer, pszString);
  1981. return (pszBuffer);
  1983. }
  1985. char *SysGetEnv(const char *pszVarName)
  1986. {
  1988. char szRKeyPath[256] = "";
  1990. SysSNPrintf(szRKeyPath, sizeof(szRKeyPath) - 1, "SOFTWARE\%s\%s",
  1991.     APP_PRODUCER, szServerName);
  1993. HKEY hKey;
  1995. if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szRKeyPath, 0, KEY_QUERY_VALUE,
  1996.  &hKey) == ERROR_SUCCESS) {
  1997. char szKeyValue[2048] = "";
  1998. DWORD dwSize = sizeof(szKeyValue);
  1999. DWORD dwKeyType;
  2001. if (RegQueryValueEx(hKey, pszVarName, NULL, &dwKeyType, (u_char *) szKeyValue,
  2002.     &dwSize) == ERROR_SUCCESS) {
  2003. RegCloseKey(hKey);
  2005. return (SysStrDup(szKeyValue));
  2006. }
  2008. RegCloseKey(hKey);
  2009. }
  2011. const char *pszValue = getenv(pszVarName);
  2013. return ((pszValue != NULL) ? SysStrDup(pszValue) : NULL);
  2015. }
  2017. char *SysGetTmpFile(char *pszFileName)
  2018. {
  2020. char szTmpPath[SYS_MAX_PATH] = "";
  2022. GetTempPath(sizeof(szTmpPath) - 1, szTmpPath);
  2024. static unsigned int uFileSeqNr = 0;
  2025. SYS_LONGLONG llFileID =
  2026.     (((SYS_LONGLONG) GetCurrentThreadId()) << 32) | (SYS_LONGLONG)++ uFileSeqNr;
  2028. SysSNPrintf(pszFileName, SYS_MAX_PATH - 1, "%smsrv%I64x.tmp", szTmpPath, llFileID);
  2030. return (pszFileName);
  2032. }
  2034. int SysRemove(const char *pszFileName)
  2035. {
  2037. if (!DeleteFile(pszFileName)) {
  2038. ErrSetErrorCode(ERR_FILE_DELETE);
  2039. return (ERR_FILE_DELETE);
  2040. }
  2042. return (0);
  2044. }
  2046. int SysMakeDir(const char *pszPath)
  2047. {
  2049. if (!CreateDirectory(pszPath, NULL)) {
  2050. ErrSetErrorCode(ERR_DIR_CREATE);
  2051. return (ERR_DIR_CREATE);
  2052. }
  2054. return (0);
  2056. }
  2058. int SysRemoveDir(const char *pszPath)
  2059. {
  2061. if (!RemoveDirectory(pszPath)) {
  2062. ErrSetErrorCode(ERR_DIR_DELETE);
  2063. return (ERR_DIR_DELETE);
  2064. }
  2066. return (0);
  2068. }
  2070. int SysMoveFile(char const *pszOldName, char const *pszNewName)
  2071. {
  2073. if (!MoveFileEx(pszOldName, pszNewName,
  2074. MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED)) {
  2075. ErrSetErrorCode(ERR_FILE_MOVE);
  2076. return (ERR_FILE_MOVE);
  2077. }
  2079. return (0);
  2081. }
  2083. int SysVSNPrintf(char *pszBuffer, int iSize, char const *pszFormat, va_list Args)
  2084. {
  2086. return (_vsnprintf(pszBuffer, iSize, pszFormat, Args));
  2088. }
  2090. int SysFileSync(FILE * pFile)
  2091. {
  2093. if (fflush(pFile) || _commit(_fileno(pFile))) {
  2094. ErrSetErrorCode(ERR_FILE_WRITE);
  2095. return (ERR_FILE_WRITE);
  2096. }
  2098. return (0);
  2100. }
  2102. char *SysStrTok(char *pszData, char const *pszDelim, char **ppszSavePtr)
  2103. {
  2105. return (*ppszSavePtr = strtok(pszData, pszDelim));
  2107. }
  2109. char *SysCTime(time_t * pTimer, char *pszBuffer)
  2110. {
  2112. return (strcpy(pszBuffer, ctime(pTimer)));
  2114. }
  2116. struct tm *SysLocalTime(time_t * pTimer, struct tm *pTStruct)
  2117. {
  2119. *pTStruct = *localtime(pTimer);
  2121. return (pTStruct);
  2123. }
  2125. struct tm *SysGMTime(time_t * pTimer, struct tm *pTStruct)
  2126. {
  2128. *pTStruct = *gmtime(pTimer);
  2130. return (pTStruct);
  2132. }
  2134. char *SysAscTime(struct tm *pTStruct, char *pszBuffer, int iBufferSize)
  2135. {
  2137. strncpy(pszBuffer, asctime(pTStruct), iBufferSize);
  2138. pszBuffer[iBufferSize - 1] = '';
  2140. return (pszBuffer);
  2142. }
  2144. long SysGetTimeZone(void)
  2145. {
  2147. return ((long) _timezone);
  2149. }
  2151. long SysGetDayLight(void)
  2152. {
  2154. time_t tCurr = time(NULL);
  2155. struct tm tmCurr = *localtime(&tCurr);
  2157. return ((long) ((tmCurr.tm_isdst <= 0) ? 0 : 3600));
  2159. }
  2161. int SysGetDiskSpace(char const *pszPath, SYS_INT64 * pTotal, SYS_INT64 * pFree)
  2162. {
  2164. ULARGE_INTEGER BytesAvail;
  2165. ULARGE_INTEGER BytesOnDisk;
  2166. ULARGE_INTEGER BytesFree;
  2167. char szXPath[SYS_MAX_PATH] = "";
  2169. StrSNCpy(szXPath, pszPath);
  2170. AppendSlash(szXPath);
  2172. if (!GetDiskFreeSpaceEx(szXPath, &BytesAvail, &BytesOnDisk, &BytesFree)) {
  2173. ErrSetErrorCode(ERR_GET_DISK_SPACE_INFO);
  2174. return (ERR_GET_DISK_SPACE_INFO);
  2175. }
  2177. *pTotal = *(SYS_INT64 *) & BytesOnDisk;
  2179. *pFree = *(SYS_INT64 *) & BytesAvail;
  2181. return (0);
  2183. }
  2185. int SysMemoryInfo(SYS_INT64 * pRamTotal, SYS_INT64 * pRamFree,
  2186.   SYS_INT64 * pVirtTotal, SYS_INT64 * pVirtFree)
  2187. {
  2189. #if _WIN32_WINNT >= 0x0500
  2191. MEMORYSTATUSEX MSEX;
  2193. ZeroData(MSEX);
  2195. if (!GlobalMemoryStatusEx(&MSEX)) {
  2196. ErrSetErrorCode(ERR_GET_MEMORY_INFO);
  2197. return (ERR_GET_MEMORY_INFO);
  2198. }
  2200. *pRamTotal = (SYS_INT64) MSEX.ullTotalPhys;
  2202. *pRamFree = (SYS_INT64) MSEX.ullAvailPhys;
  2204. *pVirtTotal = (SYS_INT64) MSEX.ullTotalVirtual;
  2206. *pVirtFree = (SYS_INT64) MSEX.ullAvailVirtual;
  2208. #else // #if defined(_WIN32_WINNT 0x0500)
  2210. MEMORYSTATUS MS;
  2212. ZeroData(MS);
  2214. GlobalMemoryStatus(&MS);
  2216. *pRamTotal = (SYS_INT64) MS.dwTotalPhys;
  2218. *pRamFree = (SYS_INT64) MS.dwAvailPhys;
  2220. *pVirtTotal = (SYS_INT64) MS.dwTotalVirtual;
  2222. *pVirtFree = (SYS_INT64) MS.dwAvailVirtual;
  2224. #endif // #if defined(_WIN32_WINNT 0x0500)
  2226. return (0);
  2228. }
  2230. static unsigned int SysStkCall(unsigned int (*pProc) (void *), void *pData)
  2231. {
  2233. srand(GetCurrentThreadId() * (unsigned int) time(NULL) * uSRandBase);
  2235. unsigned int uResult;
  2236. unsigned int uStkDisp =
  2237.     (unsigned int) (rand() % MAX_STACK_SHIFT) & ~(STACK_ALIGN_BYTES - 1);
  2239. #if !defined(USE_ASM_STK_DISP)
  2241. void *pStkSpace = _alloca(uStkDisp);
  2243. uResult = pProc(pData);
  2245. #else
  2247. __asm {
  2248. sub esp, uStkDisp;
  2249. }
  2251. uResult = pProc(pData);
  2253. __asm {
  2254. add esp, uStkDisp;
  2255. }
  2257. #endif
  2259. return (uResult);
  2261. }