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

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

Email服务器

开发平台：

Visual C++

SysDepBSD.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 SYS_INT_CALL()              (!iShutDown && (errno == EINTR))
  29. #define SHUTDOWN_RECV_TIMEOUT       2
  30. #define SAIN_Addr(s)                (s).sin_addr.s_addr
  32. #define SCHED_PRIORITY_INC          5
  34. #define MIN_TCP_SEND_SIZE           (1024 * 8)
  35. #define MAX_TCP_SEND_SIZE           (1024 * 128)
  36. #define K_IO_TIME_RATIO             8
  38. #define WAIT_PID_TIME_STEP          250
  39. #define WAIT_TIMEO_EXIT_STATUS      255
  40. #define WAIT_ERROR_EXIT_STATUS      254
  42. #define MAX_STACK_SHIFT             2048
  43. #define STACK_ALIGN_BYTES           sizeof(int)
  45. struct SemData {
  46. pthread_mutex_t Mtx;
  47. pthread_cond_t WaitCond;
  48. int iSemCounter;
  49. int iMaxCount;
  50. };
  52. struct MutexData {
  53. pthread_mutex_t Mtx;
  54. pthread_cond_t WaitCond;
  55. int iLocked;
  56. };
  58. struct EventData {
  59. pthread_mutex_t Mtx;
  60. pthread_cond_t WaitCond;
  61. int iSignaled;
  62. int iManualReset;
  63. };
  65. struct WaitData {
  66. pthread_mutex_t Mtx;
  67. pthread_cond_t WaitCond;
  68. };
  70. struct ThrData {
  71. pthread_t ThreadId;
  72. unsigned int (*ThreadProc) (void *);
  73. void *pThreadData;
  74. pthread_mutex_t Mtx;
  75. pthread_cond_t ExitWaitCond;
  76. int iThreadEnded;
  77. int iExitCode;
  78. int iUseCount;
  79. };
  81. union FilledDirent {
  82. struct dirent DE;
  83. char Pad[sizeof(struct dirent) + NAME_MAX];
  84. };
  86. struct FileFindData {
  87. char szPath[SYS_MAX_PATH];
  88. DIR *pDIR;
  89. FilledDirent FDE;
  90. struct stat FS;
  91. };
  93. static int SysSetSignal(int iSigNo, void (*pSigProc) (int));
  94. static char const *SysGetLastError(void);
  95. static void SysIgnoreProc(int iSignal);
  96. static int SysSetSockNoDelay(SYS_SOCKET SockFD, int iNoDelay);
  97. static int SysSetSocketsOptions(SYS_SOCKET SockFD);
  98. static int SysFreeThreadData(ThrData * pTD);
  99. static void *SysThreadStartup(void *pThreadData);
  100. static int SysThreadSetup(ThrData * pTD);
  101. static void SysThreadCleanup(ThrData * pTD);
  103. #if defined(__OPENBSD__) || defined(__NETBSD__)
  104. static int SysGetPriorityMin(int iPolicy);
  105. static int SysGetPriorityMax(int iPolicy);
  106. #endif // #if defined(__OPENBSD__) || defined(__NETBSD__)
  107. static int SysSafeMsSleep(int iMsTimeout);
  108. static int SysWaitPID(pid_t PID, int *piExitCode, int iTimeout);
  109. static void SysBreakHandlerRoutine(int iSignal);
  110. static int SysSetupWait(WaitData * pWD);
  111. static int SysWait(WaitData * pWD, int iMsTimeout);
  112. static void SysCleanupWait(WaitData * pWD);
  113. static unsigned int SysStkCall(unsigned int (*pProc) (void *), void *pData);
  115. static volatile int iShutDown = 0;
  116. static unsigned int uSRandBase;
  117. static pthread_mutex_t LogMutex = PTHREAD_MUTEX_INITIALIZER;
  118. static void (*SysBreakHandler) (void) = NULL;
  119. static int iSndBufSize = -1, iRcvBufSize = -1;
  121. static int SysSetSignal(int iSigNo, void (*pSigProc) (int))
  122. {
  124. signal(iSigNo, pSigProc);
  126. return (0);
  128. }
  130. static char const *SysGetLastError(void)
  131. {
  133. static char szMessage[1024] = "";
  135. snprintf(szMessage, sizeof(szMessage) - 1, "(0x%lX) %s", (unsigned long) errno,
  136.  strerror(errno));
  138. return (szMessage);
  140. }
  142. static void SysIgnoreProc(int iSignal)
  143. {
  145. SysSetSignal(iSignal, SysIgnoreProc);
  147. }
  149. int SysInitLibrary(void)
  150. {
  152. iShutDown = 0;
  153. tzset();
  154. uSRandBase = (unsigned int) time(NULL);
  156. if (SysThreadSetup(NULL) < 0)
  157. return (ErrGetErrorCode());
  159. return (0);
  161. }
  163. void SysCleanupLibrary(void)
  164. {
  166. SysThreadCleanup(NULL);
  168. }
  170. int SysShutdownLibrary(int iMode)
  171. {
  173. iShutDown++;
  175. kill(0, SIGQUIT);
  177. return (0);
  179. }
  181. int SysSetupSocketBuffers(int *piSndBufSize, int *piRcvBufSize)
  182. {
  184. if (piSndBufSize != NULL)
  185. iSndBufSize = *piSndBufSize;
  187. if (piRcvBufSize != NULL)
  188. iRcvBufSize = *piRcvBufSize;
  190. return (0);
  192. }
  194. SYS_SOCKET SysCreateSocket(int iAddressFamily, int iType, int iProtocol)
  195. {
  197. int SockFD = socket(AF_INET, iType, iProtocol);
  199. if (SockFD == -1) {
  200. ErrSetErrorCode(ERR_SOCKET_CREATE);
  201. return (SYS_INVALID_SOCKET);
  202. }
  204. if (SysSetSocketsOptions((SYS_SOCKET) SockFD) < 0) {
  205. SysCloseSocket((SYS_SOCKET) SockFD);
  207. return (SYS_INVALID_SOCKET);
  208. }
  210. return ((SYS_SOCKET) SockFD);
  212. }
  214. static int SysSetSockNoDelay(SYS_SOCKET SockFD, int iNoDelay)
  215. {
  217. long lSockFlags = fcntl((int) SockFD, F_GETFL, 0);
  219. if (lSockFlags == -1) {
  220. ErrSetErrorCode(ERR_NETWORK);
  221. return (ERR_NETWORK);
  222. }
  224. if (iNoDelay)
  225. lSockFlags |= O_NONBLOCK;
  226. else
  227. lSockFlags &= ~O_NONBLOCK;
  229. if (fcntl((int) SockFD, F_SETFL, lSockFlags) == -1) {
  230. ErrSetErrorCode(ERR_NETWORK);
  231. return (ERR_NETWORK);
  232. }
  234. return (0);
  236. }
  238. static int SysSetSocketsOptions(SYS_SOCKET SockFD)
  239. {
  240. ///////////////////////////////////////////////////////////////////////////////
  241. //  Set socket buffer sizes
  242. ///////////////////////////////////////////////////////////////////////////////
  243. if (iSndBufSize > 0) {
  244. int iSize = iSndBufSize;
  246. setsockopt((int) SockFD, SOL_SOCKET, SO_SNDBUF, (const char *) &iSize,
  247.    sizeof(iSize));
  248. }
  250. if (iRcvBufSize > 0) {
  251. int iSize = iRcvBufSize;
  253. setsockopt((int) SockFD, SOL_SOCKET, SO_RCVBUF, (const char *) &iSize,
  254.    sizeof(iSize));
  255. }
  257. int iActivate = 1;
  259. if (setsockopt(SockFD, SOL_SOCKET, SO_REUSEADDR, (const char *) &iActivate,
  260.        sizeof(iActivate)) != 0) {
  261. ErrSetErrorCode(ERR_SETSOCKOPT);
  262. return (ERR_SETSOCKOPT);
  263. }
  264. ///////////////////////////////////////////////////////////////////////////////
  265. //  Disable linger
  266. ///////////////////////////////////////////////////////////////////////////////
  267. struct linger Ling;
  269. ZeroData(Ling);
  270. Ling.l_onoff = 0;
  271. Ling.l_linger = 0;
  273. setsockopt(SockFD, SOL_SOCKET, SO_LINGER, (const char *) &Ling, sizeof(Ling));
  275. ///////////////////////////////////////////////////////////////////////////////
  276. //  Set KEEPALIVE if supported
  277. ///////////////////////////////////////////////////////////////////////////////
  278. setsockopt(SockFD, SOL_SOCKET, SO_KEEPALIVE, (const char *) &iActivate,
  279.    sizeof(iActivate));
  281. return (0);
  283. }
  285. void SysCloseSocket(SYS_SOCKET SockFD)
  286. {
  288. close(SockFD);
  290. }
  292. int SysBindSocket(SYS_SOCKET SockFD, const struct sockaddr *SockName, int iNameLen)
  293. {
  295. if (bind((int) SockFD, SockName, iNameLen) == -1) {
  296. ErrSetErrorCode(ERR_SOCKET_BIND);
  297. return (ERR_SOCKET_BIND);
  298. }
  300. return (0);
  302. }
  304. void SysListenSocket(SYS_SOCKET SockFD, int iConnections)
  305. {
  307. listen((int) SockFD, iConnections);
  309. }
  311. int SysRecvData(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize, int iTimeout)
  312. {
  314. struct pollfd pfds;
  316. ZeroData(pfds);
  317. pfds.fd = (int) SockFD;
  318. pfds.events = POLLIN;
  320. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  322. if (iPollResult == -1) {
  323. ErrSetErrorCode(ERR_NETWORK);
  324. return (ERR_NETWORK);
  325. }
  327. if (iPollResult == 0) {
  328. ErrSetErrorCode(ERR_TIMEOUT);
  329. return (ERR_TIMEOUT);
  330. }
  332. int iRecvBytes;
  334. while (((iRecvBytes = recv((int) SockFD, pszBuffer, iBufferSize, 0)) == -1) &&
  335.        SYS_INT_CALL());
  337. if (iRecvBytes == -1) {
  338. ErrSetErrorCode(ERR_NETWORK);
  339. return (ERR_NETWORK);
  340. }
  342. return (iRecvBytes);
  344. }
  346. int SysRecv(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize, int iTimeout)
  347. {
  349. int iRtxBytes = 0;
  351. while (iRtxBytes < iBufferSize) {
  352. int iRtxCurrent = SysRecvData(SockFD, pszBuffer + iRtxBytes,
  353.       iBufferSize - iRtxBytes, iTimeout);
  355. if (iRtxCurrent <= 0)
  356. return (iRtxBytes);
  358. iRtxBytes += iRtxCurrent;
  359. }
  361. return (iRtxBytes);
  363. }
  365. int SysRecvDataFrom(SYS_SOCKET SockFD, struct sockaddr *pFrom, int iFromlen,
  366.     char *pszBuffer, int iBufferSize, int iTimeout)
  367. {
  369. struct pollfd pfds;
  371. ZeroData(pfds);
  372. pfds.fd = (int) SockFD;
  373. pfds.events = POLLIN;
  375. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  377. if (iPollResult == -1) {
  378. ErrSetErrorCode(ERR_NETWORK);
  379. return (ERR_NETWORK);
  380. }
  382. if (iPollResult == 0) {
  383. ErrSetErrorCode(ERR_TIMEOUT);
  384. return (ERR_TIMEOUT);
  385. }
  387. socklen_t SockALen = (socklen_t) iFromlen;
  388. int iRecvBytes;
  390. while (((iRecvBytes = recvfrom((int) SockFD, pszBuffer, iBufferSize, 0,
  391.        pFrom, &SockALen)) == -1) && SYS_INT_CALL());
  393. if (iRecvBytes == -1) {
  394. ErrSetErrorCode(ERR_NETWORK);
  395. return (ERR_NETWORK);
  396. }
  398. return (iRecvBytes);
  400. }
  402. int SysSendData(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize, int iTimeout)
  403. {
  405. struct pollfd pfds;
  407. ZeroData(pfds);
  408. pfds.fd = (int) SockFD;
  409. pfds.events = POLLOUT;
  411. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  413. if (iPollResult == -1) {
  414. ErrSetErrorCode(ERR_NETWORK);
  415. return (ERR_NETWORK);
  416. }
  418. if (iPollResult == 0) {
  419. ErrSetErrorCode(ERR_TIMEOUT);
  420. return (ERR_TIMEOUT);
  421. }
  423. int iSendBytes;
  425. while (((iSendBytes = send((int) SockFD, pszBuffer, iBufferSize, 0)) == -1) &&
  426.        SYS_INT_CALL());
  428. if (iSendBytes == -1) {
  429. ErrSetErrorCode(ERR_NETWORK);
  430. return (ERR_NETWORK);
  431. }
  433. return (iSendBytes);
  435. }
  437. int SysSend(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize, int iTimeout)
  438. {
  440. int iRtxBytes = 0;
  442. while (iRtxBytes < iBufferSize) {
  443. int iRtxCurrent = SysSendData(SockFD, pszBuffer + iRtxBytes,
  444.       iBufferSize - iRtxBytes, iTimeout);
  446. if (iRtxCurrent <= 0)
  447. return (iRtxBytes);
  449. iRtxBytes += iRtxCurrent;
  450. }
  452. return (iRtxBytes);
  454. }
  456. int SysSendDataTo(SYS_SOCKET SockFD, const struct sockaddr *pTo,
  457.   int iToLen, char const *pszBuffer, int iBufferSize, int iTimeout)
  458. {
  460. struct pollfd pfds;
  462. ZeroData(pfds);
  463. pfds.fd = (int) SockFD;
  464. pfds.events = POLLOUT;
  466. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  468. if (iPollResult == -1) {
  469. ErrSetErrorCode(ERR_NETWORK);
  470. return (ERR_NETWORK);
  471. }
  473. if (iPollResult == 0) {
  474. ErrSetErrorCode(ERR_TIMEOUT);
  475. return (ERR_TIMEOUT);
  476. }
  478. int iSendBytes;
  480. while (((iSendBytes = sendto((int) SockFD, pszBuffer, iBufferSize, 0, pTo, iToLen)) == -1)
  481.        && SYS_INT_CALL());
  483. if (iSendBytes == -1) {
  484. ErrSetErrorCode(ERR_NETWORK);
  485. return (ERR_NETWORK);
  486. }
  488. return (iSendBytes);
  490. }
  492. int SysConnect(SYS_SOCKET SockFD, const SYS_INET_ADDR * pSockName, int iNameLen, int iTimeout)
  493. {
  495. if (SysSetSockNoDelay(SockFD, 1) < 0)
  496. return (ErrGetErrorCode());
  498. if (connect((int) SockFD, (const struct sockaddr *) &pSockName->Addr, iNameLen) == 0) {
  499. SysSetSockNoDelay(SockFD, 0);
  500. return (0);
  501. }
  503. if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK)) {
  504. SysSetSockNoDelay(SockFD, 0);
  506. ErrSetErrorCode(ERR_NETWORK);
  507. return (ERR_NETWORK);
  508. }
  510. struct pollfd pfds;
  512. ZeroData(pfds);
  513. pfds.fd = (int) SockFD;
  514. pfds.events = POLLOUT;
  516. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  518. SysSetSockNoDelay(SockFD, 0);
  520. if (iPollResult == -1) {
  521. ErrSetErrorCode(ERR_NETWORK);
  522. return (ERR_NETWORK);
  523. }
  525. if (iPollResult == 0) {
  526. ErrSetErrorCode(ERR_TIMEOUT);
  527. return (ERR_TIMEOUT);
  528. }
  530. return (0);
  532. }
  534. SYS_SOCKET SysAccept(SYS_SOCKET SockFD, SYS_INET_ADDR * pSockName, int *iNameLen, int iTimeout)
  535. {
  537. struct pollfd pfds;
  539. ZeroData(pfds);
  540. pfds.fd = (int) SockFD;
  541. pfds.events = POLLIN;
  543. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  545. if (iPollResult == -1) {
  546. ErrSetErrorCode(ERR_NETWORK);
  547. return (SYS_INVALID_SOCKET);
  548. }
  550. if (iPollResult == 0) {
  551. ErrSetErrorCode(ERR_TIMEOUT);
  552. return (SYS_INVALID_SOCKET);
  553. }
  555. socklen_t SockALen = (socklen_t) * iNameLen;
  556. int iAcptSock = accept((int) SockFD,
  557.        (struct sockaddr *) &pSockName->Addr, &SockALen);
  559. if (iAcptSock == -1) {
  560. ErrSetErrorCode(ERR_NETWORK);
  561. return (SYS_INVALID_SOCKET);
  562. }
  564. if (SysSetSocketsOptions((SYS_SOCKET) iAcptSock) < 0) {
  565. SysCloseSocket((SYS_SOCKET) iAcptSock);
  567. return (SYS_INVALID_SOCKET);
  568. }
  570. *iNameLen = (int) SockALen;
  572. return ((SYS_SOCKET) iAcptSock);
  574. }
  576. int SysSelect(int iMaxFD, SYS_fd_set * pReadFDs, SYS_fd_set * pWriteFDs, SYS_fd_set * pExcptFDs,
  577.       int iTimeout)
  578. {
  580. struct timeval TV;
  582. ZeroData(TV);
  583. TV.tv_sec = iTimeout;
  584. TV.tv_usec = 0;
  586. int iSelectResult = select(iMaxFD + 1, pReadFDs, pWriteFDs, pExcptFDs, &TV);
  588. if (iSelectResult == -1) {
  589. ErrSetErrorCode(ERR_SELECT);
  590. return (ERR_SELECT);
  591. }
  593. if (iSelectResult == 0) {
  594. ErrSetErrorCode(ERR_TIMEOUT);
  595. return (ERR_TIMEOUT);
  596. }
  598. return (iSelectResult);
  600. }
  602. int SysSendFile(SYS_SOCKET SockFD, char const *pszFileName, unsigned long ulBaseOffset,
  603. unsigned long ulEndOffset, int iTimeout)
  604. {
  606. int iFileID = open(pszFileName, O_RDONLY);
  608. if (iFileID == -1) {
  609. ErrSetErrorCode(ERR_FILE_OPEN, pszFileName);
  610. return (ERR_FILE_OPEN);
  611. }
  613. unsigned long ulFileSize = (unsigned long) lseek(iFileID, 0, SEEK_END);
  615. lseek(iFileID, 0, SEEK_SET);
  617. void *pMapAddress = (void *) mmap((char *) 0, (size_t) ulFileSize, PROT_READ,
  618.   MAP_SHARED, iFileID, 0);
  620. if (pMapAddress == (void *) -1) {
  621. close(iFileID);
  622. ErrSetErrorCode(ERR_MMAP);
  623. return (ERR_MMAP);
  624. }
  625. ///////////////////////////////////////////////////////////////////////////////
  626. //  Send the file
  627. ///////////////////////////////////////////////////////////////////////////////
  628. int iSndBuffSize = MIN_TCP_SEND_SIZE;
  629. unsigned long ulCurrOffset = ulBaseOffset;
  630. unsigned long ulSndEndOffset =
  631. (ulEndOffset != (unsigned long) -1) ? ulEndOffset : ulFileSize;
  632. char *pszBuffer = (char *) pMapAddress + ulBaseOffset;
  633. time_t tStart;
  635. while (ulCurrOffset < ulSndEndOffset) {
  636. int iCurrSend = (int) Min(iSndBuffSize, ulSndEndOffset - ulCurrOffset);
  638. tStart = time(NULL);
  639. if ((iCurrSend = SysSendData(SockFD, pszBuffer, iCurrSend, iTimeout)) < 0) {
  640. ErrorPush();
  641. munmap((char *) pMapAddress, (size_t) ulFileSize);
  642. close(iFileID);
  643. return (ErrorPop());
  644. }
  646. if ((((time(NULL) - tStart) * K_IO_TIME_RATIO) < iTimeout) &&
  647.     (iSndBuffSize < MAX_TCP_SEND_SIZE))
  648. iSndBuffSize = Min(iSndBuffSize * 2, MAX_TCP_SEND_SIZE);
  650. pszBuffer += iCurrSend;
  651. ulCurrOffset += (unsigned long) iCurrSend;
  652. }
  654. munmap((char *) pMapAddress, (size_t) ulFileSize);
  656. close(iFileID);
  658. return (0);
  660. }
  662. int SysSetupAddress(SYS_INET_ADDR & AddrInfo, int iFamily,
  663.     NET_ADDRESS const &NetAddr, int iPortNo)
  664. {
  666. ZeroData(AddrInfo);
  667. AddrInfo.Addr.sin_family = iFamily;
  668. SAIN_Addr(AddrInfo.Addr) = NetAddr;
  669. AddrInfo.Addr.sin_port = htons((short) iPortNo);
  671. return (0);
  673. }
  675. int SysGetAddrAddress(SYS_INET_ADDR const &AddrInfo, NET_ADDRESS & NetAddr)
  676. {
  678. NetAddr = SAIN_Addr(AddrInfo.Addr);
  680. return (0);
  682. }
  684. int SysGetAddrPort(SYS_INET_ADDR const &AddrInfo)
  685. {
  687. return (ntohs(AddrInfo.Addr.sin_port));
  689. }
  691. int SysSetAddrAddress(SYS_INET_ADDR & AddrInfo, NET_ADDRESS const &NetAddr)
  692. {
  694. SAIN_Addr(AddrInfo.Addr) = NetAddr;
  696. return (0);
  698. }
  700. int SysSetAddrPort(SYS_INET_ADDR & AddrInfo, int iPortNo)
  701. {
  703. AddrInfo.Addr.sin_port = htons((short) iPortNo);
  705. return (0);
  707. }
  709. int SysGetHostByName(char const *pszName, NET_ADDRESS & NetAddr)
  710. {
  712. struct hostent *pHostEnt = gethostbyname(pszName);
  714. if ((pHostEnt == NULL) || (pHostEnt->h_addr_list[0] == NULL)) {
  715. ErrSetErrorCode(ERR_BAD_SERVER_ADDR, pszName);
  716. return (ERR_BAD_SERVER_ADDR);
  717. }
  719. memcpy(&NetAddr, pHostEnt->h_addr_list[0], sizeof(NetAddr));
  721. return (0);
  723. }
  725. int SysGetHostByAddr(SYS_INET_ADDR const &AddrInfo, char *pszFQDN)
  726. {
  728. struct hostent *pHostEnt = gethostbyaddr((char *) &SAIN_Addr(AddrInfo.Addr),
  729.  sizeof(SAIN_Addr(AddrInfo.Addr)), AF_INET);
  731. if ((pHostEnt == NULL) || (pHostEnt->h_name == NULL)) {
  732. char szIP[128] = "???.???.???.???";
  734. ErrSetErrorCode(ERR_GET_SOCK_HOST, SysInetNToA(AddrInfo, szIP));
  735. return (ERR_GET_SOCK_HOST);
  736. }
  738. strcpy(pszFQDN, pHostEnt->h_name);
  740. return (0);
  742. }
  744. int SysGetPeerInfo(SYS_SOCKET SockFD, SYS_INET_ADDR & AddrInfo)
  745. {
  747. ZeroData(AddrInfo);
  749. socklen_t InfoSize = sizeof(AddrInfo.Addr);
  751. if (getpeername(SockFD, (struct sockaddr *) &AddrInfo.Addr, &InfoSize) == -1) {
  752. ErrSetErrorCode(ERR_GET_PEER_INFO);
  753. return (ERR_GET_PEER_INFO);
  754. }
  756. return (0);
  758. }
  760. int SysGetSockInfo(SYS_SOCKET SockFD, SYS_INET_ADDR & AddrInfo)
  761. {
  763. ZeroData(AddrInfo);
  765. socklen_t InfoSize = sizeof(AddrInfo.Addr);
  767. if (getsockname(SockFD, (struct sockaddr *) &AddrInfo.Addr, &InfoSize) == -1) {
  768. ErrSetErrorCode(ERR_GET_SOCK_INFO);
  769. return (ERR_GET_SOCK_INFO);
  770. }
  772. return (0);
  774. }
  776. char *SysInetNToA(SYS_INET_ADDR const &AddrInfo, char *pszIP)
  777. {
  779. union {
  780. unsigned int a;
  781. unsigned char b[4];
  782. } UAddr;
  784. memcpy(&UAddr, &AddrInfo.Addr.sin_addr, sizeof(UAddr));
  786. sprintf(pszIP, "%u.%u.%u.%u",
  787. (unsigned int) UAddr.b[0],
  788. (unsigned int) UAddr.b[1], (unsigned int) UAddr.b[2], (unsigned int) UAddr.b[3]);
  790. return (pszIP);
  792. }
  794. int SysInetAddr(char const *pszDotName, NET_ADDRESS & NetAddr)
  795. {
  797. if ((NetAddr = (NET_ADDRESS) inet_addr(pszDotName)) == SYS_INVALID_NET_ADDRESS) {
  798. ErrSetErrorCode(ERR_BAD_SERVER_ADDR, pszDotName);
  799. return (ERR_BAD_SERVER_ADDR);
  800. }
  802. return (0);
  804. }
  806. int SysSameAddress(NET_ADDRESS const &NetAddr1, NET_ADDRESS const &NetAddr2)
  807. {
  809. return (memcmp(&NetAddr1, &NetAddr2, sizeof(NET_ADDRESS)) == 0);
  811. }
  813. SYS_SEMAPHORE SysCreateSemaphore(int iInitCount, int iMaxCount)
  814. {
  816. SemData *pSD = (SemData *) SysAlloc(sizeof(SemData));
  818. if (pSD == NULL)
  819. return (SYS_INVALID_SEMAPHORE);
  821. if (pthread_mutex_init(&pSD->Mtx, NULL) != 0) {
  822. SysFree(pSD);
  824. ErrSetErrorCode(ERR_MUTEXINIT, NULL);
  825. return (SYS_INVALID_SEMAPHORE);
  826. }
  828. if (pthread_cond_init(&pSD->WaitCond, NULL) != 0) {
  829. pthread_mutex_destroy(&pSD->Mtx);
  830. SysFree(pSD);
  832. ErrSetErrorCode(ERR_CONDINIT, NULL);
  833. return (SYS_INVALID_SEMAPHORE);
  834. }
  836. pSD->iSemCounter = iInitCount;
  838. pSD->iMaxCount = iMaxCount;
  840. return ((SYS_SEMAPHORE) pSD);
  842. }
  844. int SysCloseSemaphore(SYS_SEMAPHORE hSemaphore)
  845. {
  847. SemData *pSD = (SemData *) hSemaphore;
  849. pthread_cond_destroy(&pSD->WaitCond);
  851. pthread_mutex_destroy(&pSD->Mtx);
  853. SysFree(pSD);
  855. return (0);
  857. }
  859. int SysWaitSemaphore(SYS_SEMAPHORE hSemaphore, int iTimeout)
  860. {
  862. SemData *pSD = (SemData *) hSemaphore;
  864. pthread_mutex_lock(&pSD->Mtx);
  866. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  868. while (pSD->iSemCounter <= 0) {
  869. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pSD->Mtx);
  871. pthread_cond_wait(&pSD->WaitCond, &pSD->Mtx);
  873. pthread_cleanup_pop(0);
  874. }
  876. pSD->iSemCounter -= 1;
  878. } else {
  879. struct timeval tvNow;
  880. struct timespec tsTimeout;
  882. gettimeofday(&tvNow, NULL);
  884. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  885. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  887. int iRetCode = 0;
  889. while ((pSD->iSemCounter <= 0) && (iRetCode != ETIMEDOUT)) {
  890. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pSD->Mtx);
  892. iRetCode = pthread_cond_timedwait(&pSD->WaitCond, &pSD->Mtx, &tsTimeout);
  894. pthread_cleanup_pop(0);
  895. }
  897. if (iRetCode == ETIMEDOUT) {
  898. pthread_mutex_unlock(&pSD->Mtx);
  899. ErrSetErrorCode(ERR_TIMEOUT);
  900. return (ERR_TIMEOUT);
  901. }
  903. pSD->iSemCounter -= 1;
  905. }
  907. pthread_mutex_unlock(&pSD->Mtx);
  909. return (0);
  911. }
  913. int SysReleaseSemaphore(SYS_SEMAPHORE hSemaphore, int iCount)
  914. {
  916. SemData *pSD = (SemData *) hSemaphore;
  918. pthread_mutex_lock(&pSD->Mtx);
  920. pSD->iSemCounter += iCount;
  922. if (pSD->iSemCounter > 0) {
  923. if (pSD->iSemCounter > 1)
  924. pthread_cond_broadcast(&pSD->WaitCond);
  925. else
  926. pthread_cond_signal(&pSD->WaitCond);
  927. }
  929. pthread_mutex_unlock(&pSD->Mtx);
  931. return (0);
  933. }
  935. int SysTryWaitSemaphore(SYS_SEMAPHORE hSemaphore)
  936. {
  938. SemData *pSD = (SemData *) hSemaphore;
  940. pthread_mutex_lock(&pSD->Mtx);
  942. if (pSD->iSemCounter <= 0) {
  943. pthread_mutex_unlock(&pSD->Mtx);
  944. ErrSetErrorCode(ERR_TIMEOUT);
  945. return (ERR_TIMEOUT);
  946. }
  948. pSD->iSemCounter -= 1;
  950. pthread_mutex_unlock(&pSD->Mtx);
  952. return (0);
  954. }
  956. SYS_MUTEX SysCreateMutex(void)
  957. {
  959. MutexData *pMD = (MutexData *) SysAlloc(sizeof(MutexData));
  961. if (pMD == NULL)
  962. return (SYS_INVALID_MUTEX);
  964. if (pthread_mutex_init(&pMD->Mtx, NULL) != 0) {
  965. SysFree(pMD);
  966. ErrSetErrorCode(ERR_MUTEXINIT);
  967. return (SYS_INVALID_MUTEX);
  968. }
  970. if (pthread_cond_init(&pMD->WaitCond, NULL) != 0) {
  971. pthread_mutex_destroy(&pMD->Mtx);
  972. SysFree(pMD);
  973. ErrSetErrorCode(ERR_CONDINIT);
  974. return (SYS_INVALID_MUTEX);
  975. }
  977. pMD->iLocked = 0;
  979. return ((SYS_MUTEX) pMD);
  981. }
  983. int SysCloseMutex(SYS_MUTEX hMutex)
  984. {
  986. MutexData *pMD = (MutexData *) hMutex;
  988. pthread_cond_destroy(&pMD->WaitCond);
  990. pthread_mutex_destroy(&pMD->Mtx);
  992. SysFree(pMD);
  994. return (0);
  996. }
  998. int SysLockMutex(SYS_MUTEX hMutex, int iTimeout)
  999. {
  1001. MutexData *pMD = (MutexData *) hMutex;
  1003. pthread_mutex_lock(&pMD->Mtx);
  1005. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1007. while (pMD->iLocked) {
  1008. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pMD->Mtx);
  1010. pthread_cond_wait(&pMD->WaitCond, &pMD->Mtx);
  1012. pthread_cleanup_pop(0);
  1013. }
  1015. pMD->iLocked = 1;
  1017. } else {
  1018. struct timeval tvNow;
  1019. struct timespec tsTimeout;
  1021. gettimeofday(&tvNow, NULL);
  1023. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1024. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1026. int iRetCode = 0;
  1028. while (pMD->iLocked && (iRetCode != ETIMEDOUT)) {
  1029. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pMD->Mtx);
  1031. iRetCode = pthread_cond_timedwait(&pMD->WaitCond, &pMD->Mtx, &tsTimeout);
  1033. pthread_cleanup_pop(0);
  1034. }
  1036. if (iRetCode == ETIMEDOUT) {
  1037. pthread_mutex_unlock(&pMD->Mtx);
  1038. ErrSetErrorCode(ERR_TIMEOUT);
  1039. return (ERR_TIMEOUT);
  1040. }
  1042. pMD->iLocked = 1;
  1044. }
  1046. pthread_mutex_unlock(&pMD->Mtx);
  1048. return (0);
  1050. }
  1052. int SysUnlockMutex(SYS_MUTEX hMutex)
  1053. {
  1055. MutexData *pMD = (MutexData *) hMutex;
  1057. pthread_mutex_lock(&pMD->Mtx);
  1059. pMD->iLocked = 0;
  1061. pthread_cond_signal(&pMD->WaitCond);
  1063. pthread_mutex_unlock(&pMD->Mtx);
  1065. return (0);
  1067. }
  1069. int SysTryLockMutex(SYS_MUTEX hMutex)
  1070. {
  1072. MutexData *pMD = (MutexData *) hMutex;
  1074. pthread_mutex_lock(&pMD->Mtx);
  1076. if (pMD->iLocked) {
  1077. pthread_mutex_unlock(&pMD->Mtx);
  1078. ErrSetErrorCode(ERR_TIMEOUT);
  1079. return (ERR_TIMEOUT);
  1080. }
  1082. pMD->iLocked = 1;
  1084. pthread_mutex_unlock(&pMD->Mtx);
  1086. return (0);
  1088. }
  1090. SYS_EVENT SysCreateEvent(int iManualReset)
  1091. {
  1093. EventData *pED = (EventData *) SysAlloc(sizeof(EventData));
  1095. if (pED == NULL)
  1096. return (SYS_INVALID_EVENT);
  1098. if (pthread_mutex_init(&pED->Mtx, NULL) != 0) {
  1099. SysFree(pED);
  1100. ErrSetErrorCode(ERR_MUTEXINIT);
  1101. return (SYS_INVALID_EVENT);
  1102. }
  1104. if (pthread_cond_init(&pED->WaitCond, NULL) != 0) {
  1105. pthread_mutex_destroy(&pED->Mtx);
  1106. SysFree(pED);
  1107. ErrSetErrorCode(ERR_CONDINIT);
  1108. return (SYS_INVALID_EVENT);
  1109. }
  1111. pED->iSignaled = 0;
  1112. pED->iManualReset = iManualReset;
  1114. return ((SYS_EVENT) pED);
  1116. }
  1118. int SysCloseEvent(SYS_EVENT hEvent)
  1119. {
  1121. EventData *pED = (EventData *) hEvent;
  1123. pthread_cond_destroy(&pED->WaitCond);
  1125. pthread_mutex_destroy(&pED->Mtx);
  1127. SysFree(pED);
  1129. return (0);
  1131. }
  1133. int SysWaitEvent(SYS_EVENT hEvent, int iTimeout)
  1134. {
  1136. EventData *pED = (EventData *) hEvent;
  1138. pthread_mutex_lock(&pED->Mtx);
  1140. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1142. while (!pED->iSignaled) {
  1143. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pED->Mtx);
  1145. pthread_cond_wait(&pED->WaitCond, &pED->Mtx);
  1147. pthread_cleanup_pop(0);
  1148. }
  1150. if (!pED->iManualReset)
  1151. pED->iSignaled = 0;
  1153. } else {
  1154. struct timeval tvNow;
  1155. struct timespec tsTimeout;
  1157. gettimeofday(&tvNow, NULL);
  1159. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1160. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1162. int iRetCode = 0;
  1164. while (!pED->iSignaled && (iRetCode != ETIMEDOUT)) {
  1165. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pED->Mtx);
  1167. iRetCode = pthread_cond_timedwait(&pED->WaitCond, &pED->Mtx, &tsTimeout);
  1169. pthread_cleanup_pop(0);
  1170. }
  1172. if (iRetCode == ETIMEDOUT) {
  1173. pthread_mutex_unlock(&pED->Mtx);
  1174. ErrSetErrorCode(ERR_TIMEOUT);
  1175. return (ERR_TIMEOUT);
  1176. }
  1178. if (!pED->iManualReset)
  1179. pED->iSignaled = 0;
  1181. }
  1183. pthread_mutex_unlock(&pED->Mtx);
  1185. return (0);
  1187. }
  1189. int SysSetEvent(SYS_EVENT hEvent)
  1190. {
  1192. EventData *pED = (EventData *) hEvent;
  1194. pthread_mutex_lock(&pED->Mtx);
  1196. pED->iSignaled = 1;
  1198. if (pED->iManualReset)
  1199. pthread_cond_broadcast(&pED->WaitCond);
  1200. else
  1201. pthread_cond_signal(&pED->WaitCond);
  1203. pthread_mutex_unlock(&pED->Mtx);
  1205. return (0);
  1207. }
  1209. int SysResetEvent(SYS_EVENT hEvent)
  1210. {
  1212. EventData *pED = (EventData *) hEvent;
  1214. pthread_mutex_lock(&pED->Mtx);
  1216. pED->iSignaled = 0;
  1218. pthread_mutex_unlock(&pED->Mtx);
  1220. return (0);
  1222. }
  1224. int SysTryWaitEvent(SYS_EVENT hEvent)
  1225. {
  1227. EventData *pED = (EventData *) hEvent;
  1229. pthread_mutex_lock(&pED->Mtx);
  1231. if (!pED->iSignaled) {
  1232. pthread_mutex_unlock(&pED->Mtx);
  1233. ErrSetErrorCode(ERR_TIMEOUT);
  1234. return (ERR_TIMEOUT);
  1235. }
  1237. if (!pED->iManualReset)
  1238. pED->iSignaled = 0;
  1240. pthread_mutex_unlock(&pED->Mtx);
  1242. return (0);
  1244. }
  1246. static int SysFreeThreadData(ThrData * pTD)
  1247. {
  1249. pthread_cond_destroy(&pTD->ExitWaitCond);
  1251. pthread_mutex_destroy(&pTD->Mtx);
  1253. SysFree(pTD);
  1255. return (0);
  1257. }
  1259. static void *SysThreadStartup(void *pThreadData)
  1260. {
  1262. ThrData *pTD = (ThrData *) pThreadData;
  1264. SysThreadSetup(pTD);
  1266. int iExitCode;
  1268. pthread_cleanup_push((void (*)(void *)) SysThreadCleanup, pTD);
  1270. pTD->iExitCode = iExitCode = SysStkCall(pTD->ThreadProc, pTD->pThreadData);
  1272. pthread_cleanup_pop(1);
  1274. return ((void *) iExitCode);
  1276. }
  1278. SYS_THREAD SysCreateThread(unsigned int (*pThreadProc) (void *), void *pThreadData)
  1279. {
  1281. ThrData *pTD = (ThrData *) SysAlloc(sizeof(ThrData));
  1283. if (pTD == NULL)
  1284. return (SYS_INVALID_THREAD);
  1286. pTD->ThreadProc = pThreadProc;
  1287. pTD->pThreadData = pThreadData;
  1288. pTD->iThreadEnded = 0;
  1289. pTD->iExitCode = -1;
  1290. pTD->iUseCount = 2;
  1292. if (pthread_mutex_init(&pTD->Mtx, NULL) != 0) {
  1293. SysFree(pTD);
  1295. ErrSetErrorCode(ERR_MUTEXINIT);
  1296. return (SYS_INVALID_THREAD);
  1297. }
  1299. if (pthread_cond_init(&pTD->ExitWaitCond, NULL) != 0) {
  1300. pthread_mutex_destroy(&pTD->Mtx);
  1301. SysFree(pTD);
  1303. ErrSetErrorCode(ERR_CONDINIT);
  1304. return (SYS_INVALID_THREAD);
  1305. }
  1307. pthread_attr_t ThrAttr;
  1309. pthread_attr_init(&ThrAttr);
  1311. pthread_attr_setscope(&ThrAttr, PTHREAD_SCOPE_SYSTEM);
  1313. if (pthread_create(&pTD->ThreadId, &ThrAttr, SysThreadStartup, pTD) != 0) {
  1314. pthread_attr_destroy(&ThrAttr);
  1315. pthread_cond_destroy(&pTD->ExitWaitCond);
  1316. pthread_mutex_destroy(&pTD->Mtx);
  1317. SysFree(pTD);
  1319. ErrSetErrorCode(ERR_THREADCREATE);
  1320. return (SYS_INVALID_THREAD);
  1321. }
  1323. pthread_attr_destroy(&ThrAttr);
  1325. return ((SYS_THREAD) pTD);
  1327. }
  1329. SYS_THREAD SysCreateServiceThread(unsigned int (*pThreadProc) (void *), SYS_SOCKET SockFD)
  1330. {
  1332. return (SysCreateThread(pThreadProc, (void *) SockFD));
  1334. }
  1336. static int SysThreadSetup(ThrData * pTD)
  1337. {
  1339. sigset_t SigMask;
  1341. sigemptyset(&SigMask);
  1342. sigaddset(&SigMask, SIGALRM);
  1343. sigaddset(&SigMask, SIGINT);
  1344. sigaddset(&SigMask, SIGHUP);
  1345. sigaddset(&SigMask, SIGSTOP);
  1346. sigaddset(&SigMask, SIGCHLD);
  1348. pthread_sigmask(SIG_BLOCK, &SigMask, NULL);
  1350. sigemptyset(&SigMask);
  1351. sigaddset(&SigMask, SIGQUIT);
  1353. pthread_sigmask(SIG_UNBLOCK, &SigMask, NULL);
  1355. SysSetSignal(SIGQUIT, SysIgnoreProc);
  1357. SysSetSignal(SIGPIPE, SysIgnoreProc);
  1359. SysSetSignal(SIGCHLD, SysIgnoreProc);
  1361. if (pTD != NULL) {
  1363. }
  1365. return (0);
  1367. }
  1369. static void SysThreadCleanup(ThrData * pTD)
  1370. {
  1372. if (pTD != NULL) {
  1373. pthread_mutex_lock(&pTD->Mtx);
  1375. pTD->iThreadEnded = 1;
  1377. pthread_cond_broadcast(&pTD->ExitWaitCond);
  1379. if (--pTD->iUseCount == 0) {
  1380. pthread_mutex_unlock(&pTD->Mtx);
  1382. SysFreeThreadData(pTD);
  1383. } else
  1384. pthread_mutex_unlock(&pTD->Mtx);
  1385. }
  1387. }
  1389. void SysCloseThread(SYS_THREAD ThreadID, int iForce)
  1390. {
  1392. ThrData *pTD = (ThrData *) ThreadID;
  1394. pthread_mutex_lock(&pTD->Mtx);
  1396. pthread_detach(pTD->ThreadId);
  1398. if (iForce && !pTD->iThreadEnded)
  1399. pthread_cancel(pTD->ThreadId);
  1401. if (--pTD->iUseCount == 0) {
  1402. pthread_mutex_unlock(&pTD->Mtx);
  1404. SysFreeThreadData(pTD);
  1405. } else
  1406. pthread_mutex_unlock(&pTD->Mtx);
  1408. }
  1410. #if defined(__OPENBSD__) || defined(__NETBSD__)
  1412. static int SysGetPriorityMin(int iPolicy)
  1413. {
  1415. int iPriority = 0;
  1417. switch (iPolicy) {
  1418. case SCHED_FIFO:
  1419. iPriority = 0;
  1420. break;
  1421. case SCHED_OTHER:
  1422. iPriority = -20;
  1423. break;
  1424. case SCHED_RR:
  1425. iPriority = 0;
  1426. break;
  1427. }
  1429. return (iPriority);
  1431. }
  1433. static int SysGetPriorityMax(int iPolicy)
  1434. {
  1436. int iPriority = 0;
  1438. switch (iPolicy) {
  1439. case SCHED_FIFO:
  1440. iPriority = 31;
  1441. break;
  1442. case SCHED_OTHER:
  1443. iPriority = +20;
  1444. break;
  1445. case SCHED_RR:
  1446. iPriority = 31;
  1447. break;
  1448. }
  1450. return (iPriority);
  1452. }
  1454. #endif // #if defined(__OPENBSD__) || defined(__NETBSD__)
  1456. int SysSetThreadPriority(SYS_THREAD ThreadID, int iPriority)
  1457. {
  1459. ThrData *pTD = (ThrData *) ThreadID;
  1460. int iPolicy;
  1461. struct sched_param SchParam;
  1463. if (pthread_getschedparam(pTD->ThreadId, &iPolicy, &SchParam) != 0) {
  1464. ErrSetErrorCode(ERR_SET_THREAD_PRIORITY);
  1465. return (ERR_SET_THREAD_PRIORITY);
  1466. }
  1467. #if defined(__FREEBSD__) || defined (__DARWIN__)
  1468. int iMinPriority = sched_get_priority_min(iPolicy);
  1469. int iMaxPriority = sched_get_priority_max(iPolicy);
  1470. #else // #if defined(__FREEBSD__)
  1471. int iMinPriority = SysGetPriorityMin(iPolicy);
  1472. int iMaxPriority = SysGetPriorityMax(iPolicy);
  1473. #endif // #if defined(__FREEBSD__)
  1475. int iStdPriority = (iMinPriority + iMaxPriority) / 2;
  1477. switch (iPriority) {
  1478. case (SYS_PRIORITY_NORMAL):
  1479. SchParam.sched_priority = iStdPriority;
  1480. break;
  1482. case (SYS_PRIORITY_LOWER):
  1483. SchParam.sched_priority = iStdPriority - (iStdPriority - iMinPriority) / 3;
  1484. break;
  1486. case (SYS_PRIORITY_HIGHER):
  1487. SchParam.sched_priority = iStdPriority + (iStdPriority - iMinPriority) / 3;
  1488. break;
  1489. }
  1491. if (pthread_setschedparam(pTD->ThreadId, iPolicy, &SchParam) != 0) {
  1492. ErrSetErrorCode(ERR_SET_THREAD_PRIORITY);
  1493. return (ERR_SET_THREAD_PRIORITY);
  1494. }
  1496. return (0);
  1498. }
  1500. int SysWaitThread(SYS_THREAD ThreadID, int iTimeout)
  1501. {
  1503. ThrData *pTD = (ThrData *) ThreadID;
  1505. pthread_mutex_lock(&pTD->Mtx);
  1507. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1509. while (!pTD->iThreadEnded) {
  1510. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pTD->Mtx);
  1512. pthread_cond_wait(&pTD->ExitWaitCond, &pTD->Mtx);
  1514. pthread_cleanup_pop(0);
  1515. }
  1517. } else {
  1518. struct timeval tvNow;
  1519. struct timespec tsTimeout;
  1521. gettimeofday(&tvNow, NULL);
  1523. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1524. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1526. int iRetCode = 0;
  1528. while (!pTD->iThreadEnded && (iRetCode != ETIMEDOUT)) {
  1529. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pTD->Mtx);
  1531. iRetCode =
  1532. pthread_cond_timedwait(&pTD->ExitWaitCond, &pTD->Mtx, &tsTimeout);
  1534. pthread_cleanup_pop(0);
  1535. }
  1537. if (iRetCode == ETIMEDOUT) {
  1538. pthread_mutex_unlock(&pTD->Mtx);
  1540. ErrSetErrorCode(ERR_TIMEOUT);
  1541. return (ERR_TIMEOUT);
  1542. }
  1544. }
  1546. pthread_mutex_unlock(&pTD->Mtx);
  1548. return (0);
  1550. }
  1552. unsigned long SysGetCurrentThreadId(void)
  1553. {
  1555. return ((unsigned long) pthread_self());
  1557. }
  1559. static int SysSafeMsSleep(int iMsTimeout)
  1560. {
  1562. struct pollfd Dummy;
  1564. ZeroData(Dummy);
  1566. return ((poll(&Dummy, 0, iMsTimeout) == 0) ? 1 : 0);
  1568. }
  1570. static int SysWaitPID(pid_t PID, int *piExitCode, int iTimeout)
  1571. {
  1573. pid_t ExitPID;
  1574. int iExitStatus;
  1575. int iStatus;
  1577. iTimeout *= 1000;
  1578. do {
  1579. if ((ExitPID = (pid_t) waitpid(PID, &iStatus, WNOHANG)) == PID) {
  1580. if (!WIFEXITED(iStatus))
  1581. return (ERR_WAITPID);
  1583. iExitStatus = WEXITSTATUS(iStatus);
  1584. break;
  1585. }
  1587. SysSafeMsSleep(WAIT_PID_TIME_STEP);
  1588. iTimeout -= WAIT_PID_TIME_STEP;
  1590. } while (iTimeout > 0);
  1592. if (PID != ExitPID)
  1593. return (ERR_TIMEOUT);
  1595. if (piExitCode != NULL)
  1596. *piExitCode = iExitStatus;
  1598. return (0);
  1600. }
  1602. int SysExec(char const *pszCommand, char const *const *pszArgs, int iWaitTimeout,
  1603.     int iPriority, int *piExitStatus)
  1604. {
  1606. int iExitStatus;
  1607. pid_t ChildID;
  1608. pid_t ExitPID;
  1609. pid_t ProcessID;
  1610. int iPPipe[2];
  1611. int iCPipe[2];
  1613. if (pipe(iPPipe) == -1) {
  1614. ErrSetErrorCode(ERR_PIPE);
  1615. return (ERR_PIPE);
  1616. }
  1617. if (pipe(iCPipe) == -1) {
  1618. close(iPPipe[1]);
  1619. close(iPPipe[0]);
  1620. ErrSetErrorCode(ERR_PIPE);
  1621. return (ERR_PIPE);
  1622. }
  1624. ProcessID = fork();
  1625. if (ProcessID == 0) {
  1626. ChildID = fork();
  1627. if (ChildID == 0) {
  1628. close(iPPipe[1]);
  1629. close(iPPipe[0]);
  1631. ///////////////////////////////////////////////////////////////////////////////
  1632. //  Wait for the unlock from the parent
  1633. ///////////////////////////////////////////////////////////////////////////////
  1634. read(iCPipe[0], &ChildID, sizeof(ChildID));
  1636. close(iCPipe[1]);
  1637. close(iCPipe[0]);
  1639. ///////////////////////////////////////////////////////////////////////////////
  1640. //  Execute the command
  1641. ///////////////////////////////////////////////////////////////////////////////
  1642. execv(pszCommand, (char **) pszArgs);
  1644. ///////////////////////////////////////////////////////////////////////////////
  1645. //  We can only use async-signal safe functions, so we use write() directly
  1646. ///////////////////////////////////////////////////////////////////////////////
  1647. write(2, "execv error: cmd='", 18);
  1648. write(2, pszCommand, strlen(pszCommand));
  1649. write(2, "'n", 2);
  1651. _exit(WAIT_ERROR_EXIT_STATUS);
  1652. }
  1654. close(iCPipe[1]);
  1655. close(iCPipe[0]);
  1657. ///////////////////////////////////////////////////////////////////////////////
  1658. //  Tell the parent about the child-child PID
  1659. ///////////////////////////////////////////////////////////////////////////////
  1660. write(iPPipe[1], &ChildID, sizeof(ChildID));
  1662. close(iPPipe[1]);
  1663. close(iPPipe[0]);
  1665. if (ChildID == (pid_t) - 1)
  1666. _exit(WAIT_ERROR_EXIT_STATUS);
  1668. ///////////////////////////////////////////////////////////////////////////////
  1669. //  Wait for the child
  1670. ///////////////////////////////////////////////////////////////////////////////
  1671. iExitStatus = WAIT_TIMEO_EXIT_STATUS;
  1672. if (iWaitTimeout > 0)
  1673. SysWaitPID(ChildID, &iExitStatus, iWaitTimeout);
  1675. _exit(iExitStatus);
  1676. }
  1678. if ((ProcessID == (pid_t) - 1) ||
  1679.     (read(iPPipe[0], &ChildID, sizeof(ChildID)) != sizeof(ChildID))) {
  1680. close(iCPipe[1]);
  1681. close(iCPipe[0]);
  1682. close(iPPipe[1]);
  1683. close(iPPipe[0]);
  1684. ErrSetErrorCode(ERR_FORK);
  1685. return (ERR_FORK);
  1686. }
  1688. close(iPPipe[1]);
  1689. close(iPPipe[0]);
  1691. if (ChildID != (pid_t) - 1) {
  1692. ///////////////////////////////////////////////////////////////////////////////
  1693. //  Set process priority
  1694. ///////////////////////////////////////////////////////////////////////////////
  1695. switch (iPriority) {
  1696. case (SYS_PRIORITY_NORMAL):
  1697. setpriority(PRIO_PROCESS, ChildID, 0);
  1698. break;
  1700. case (SYS_PRIORITY_LOWER):
  1701. setpriority(PRIO_PROCESS, ChildID, SCHED_PRIORITY_INC);
  1702. break;
  1704. case (SYS_PRIORITY_HIGHER):
  1705. setpriority(PRIO_PROCESS, ChildID, -SCHED_PRIORITY_INC);
  1706. break;
  1707. }
  1709. ///////////////////////////////////////////////////////////////////////////////
  1710. //  Unlock the child
  1711. ///////////////////////////////////////////////////////////////////////////////
  1712. write(iCPipe[1], &ChildID, sizeof(ChildID));
  1713. }
  1715. close(iCPipe[1]);
  1716. close(iCPipe[0]);
  1718. ///////////////////////////////////////////////////////////////////////////////
  1719. //  Wait for completion (or timeout)
  1720. ///////////////////////////////////////////////////////////////////////////////
  1721. while (((ExitPID = (pid_t) waitpid(ProcessID, &iExitStatus, 0)) != ProcessID) &&
  1722.        (errno == EINTR));
  1724. if ((ExitPID == ProcessID) && WIFEXITED(iExitStatus))
  1725. iExitStatus = WEXITSTATUS(iExitStatus);
  1726. else
  1727. iExitStatus = WAIT_TIMEO_EXIT_STATUS;
  1729. if (iWaitTimeout > 0) {
  1730. if (iExitStatus == WAIT_TIMEO_EXIT_STATUS) {
  1731. ErrSetErrorCode(ERR_TIMEOUT);
  1732. return (ERR_TIMEOUT);
  1733. }
  1735. if (iExitStatus == WAIT_ERROR_EXIT_STATUS) {
  1736. ErrSetErrorCode(ERR_FORK);
  1737. return (ERR_FORK);
  1738. }
  1739. } else
  1740. iExitStatus = -1;
  1742. if (piExitStatus != NULL)
  1743. *piExitStatus = iExitStatus;
  1745. return (0);
  1747. }
  1749. static void SysBreakHandlerRoutine(int iSignal)
  1750. {
  1752. if (SysBreakHandler != NULL)
  1753. SysBreakHandler();
  1755. SysSetSignal(iSignal, SysBreakHandlerRoutine);
  1757. }
  1759. void SysSetBreakHandler(void (*BreakHandler) (void))
  1760. {
  1762. SysBreakHandler = BreakHandler;
  1764. ///////////////////////////////////////////////////////////////////////////////
  1765. //  Setup signal handlers and enable signals
  1766. ///////////////////////////////////////////////////////////////////////////////
  1767. SysSetSignal(SIGINT, SysBreakHandlerRoutine);
  1768. SysSetSignal(SIGHUP, SysBreakHandlerRoutine);
  1770. sigset_t SigMask;
  1772. sigemptyset(&SigMask);
  1773. sigaddset(&SigMask, SIGINT);
  1774. sigaddset(&SigMask, SIGHUP);
  1776. pthread_sigmask(SIG_UNBLOCK, &SigMask, NULL);
  1778. }
  1780. int SysCreateTlsKey(SYS_TLSKEY & TlsKey, void (*pFreeProc) (void *))
  1781. {
  1783. if (pthread_key_create(&TlsKey, pFreeProc) != 0) {
  1784. ErrSetErrorCode(ERR_NOMORE_TLSKEYS);
  1785. return (ERR_NOMORE_TLSKEYS);
  1786. }
  1788. return (0);
  1790. }
  1792. int SysDeleteTlsKey(SYS_TLSKEY & TlsKey)
  1793. {
  1795. pthread_key_delete(TlsKey);
  1797. return (0);
  1799. }
  1801. int SysSetTlsKeyData(SYS_TLSKEY & TlsKey, void *pData)
  1802. {
  1804. if (pthread_setspecific(TlsKey, pData) != 0) {
  1805. ErrSetErrorCode(ERR_INVALID_TLSKEY);
  1806. return (ERR_INVALID_TLSKEY);
  1807. }
  1809. return (0);
  1811. }
  1813. void *SysGetTlsKeyData(SYS_TLSKEY & TlsKey)
  1814. {
  1816. return (pthread_getspecific(TlsKey));
  1818. }
  1820. void SysThreadOnce(SYS_THREAD_ONCE * pThrOnce, void (*pOnceProc) (void))
  1821. {
  1823. pthread_once(pThrOnce, pOnceProc);
  1825. }
  1827. void *SysAlloc(unsigned int uSize)
  1828. {
  1830. void *pData = malloc(uSize);
  1832. if (pData != NULL)
  1833. memset(pData, 0, uSize);
  1834. else
  1835. ErrSetErrorCode(ERR_MEMORY);
  1837. return (pData);
  1839. }
  1841. void SysFree(void *pData)
  1842. {
  1844. free(pData);
  1846. }
  1848. void *SysRealloc(void *pData, unsigned int uSize)
  1849. {
  1851. void *pNewData = realloc(pData, uSize);
  1853. if (pNewData == NULL)
  1854. ErrSetErrorCode(ERR_MEMORY);
  1856. return (pNewData);
  1858. }
  1860. int SysLockFile(const char *pszFileName, char const *pszLockExt)
  1861. {
  1863. char szLockFile[SYS_MAX_PATH] = "";
  1865. snprintf(szLockFile, sizeof(szLockFile) - 1, "%s%s", pszFileName, pszLockExt);
  1867. int iFileID = open(szLockFile, O_CREAT | O_EXCL | O_RDWR, S_IREAD | S_IWRITE);
  1869. if (iFileID == -1) {
  1870. ErrSetErrorCode(ERR_LOCKED);
  1871. return (ERR_LOCKED);
  1872. }
  1874. char szLock[128] = "";
  1876. sprintf(szLock, "%lu", (unsigned long) SysGetCurrentThreadId());
  1878. write(iFileID, szLock, strlen(szLock) + 1);
  1880. close(iFileID);
  1882. return (0);
  1884. }
  1886. int SysUnlockFile(const char *pszFileName, char const *pszLockExt)
  1887. {
  1889. char szLockFile[SYS_MAX_PATH] = "";
  1891. snprintf(szLockFile, sizeof(szLockFile) - 1, "%s%s", pszFileName, pszLockExt);
  1893. if (unlink(szLockFile) != 0) {
  1894. ErrSetErrorCode(ERR_NOT_LOCKED);
  1895. return (ERR_NOT_LOCKED);
  1896. }
  1898. return (0);
  1900. }
  1902. SYS_HANDLE SysOpenModule(char const *pszFilePath)
  1903. {
  1905. void *pModule = dlopen(pszFilePath, RTLD_LAZY);
  1907. if (pModule == NULL) {
  1908. ErrSetErrorCode(ERR_LOADMODULE, pszFilePath);
  1909. return (SYS_INVALID_HANDLE);
  1910. }
  1912. return ((SYS_HANDLE) pModule);
  1914. }
  1916. int SysCloseModule(SYS_HANDLE hModule)
  1917. {
  1919. dlclose((void *) hModule);
  1921. return (0);
  1923. }
  1925. void *SysGetSymbol(SYS_HANDLE hModule, char const *pszSymbol)
  1926. {
  1928. void *pSymbol = dlsym((void *) hModule, pszSymbol);
  1930. if (pSymbol == NULL) {
  1931. ErrSetErrorCode(ERR_LOADMODULESYMBOL, pszSymbol);
  1932. return (NULL);
  1933. }
  1935. return (pSymbol);
  1937. }
  1939. int SysEventLogV(int iLogLevel, char const *pszFormat, va_list Args)
  1940. {
  1942. openlog(APP_NAME_STR, LOG_PID, LOG_DAEMON);
  1944. char szBuffer[2048] = "";
  1946. vsnprintf(szBuffer, sizeof(szBuffer) - 1, pszFormat, Args);
  1948. syslog(LOG_DAEMON | LOG_ERR, "%s", szBuffer);
  1950. closelog();
  1952. return (0);
  1954. }
  1956. int SysEventLog(int iLogLevel, char const *pszFormat, ...)
  1957. {
  1959. va_list Args;
  1961. va_start(Args, pszFormat);
  1963. int iLogResult = SysEventLogV(iLogLevel, pszFormat, Args);
  1965. va_end(Args);
  1967. return (0);
  1969. }
  1971. int SysLogMessage(int iLogLevel, char const *pszFormat, ...)
  1972. {
  1974. extern bool bServerDebug;
  1976. pthread_mutex_lock(&LogMutex);
  1978. va_list Args;
  1980. va_start(Args, pszFormat);
  1982. if (bServerDebug) {
  1983. ///////////////////////////////////////////////////////////////////////////////
  1984. //  Debug implementation
  1985. ///////////////////////////////////////////////////////////////////////////////
  1987. vprintf(pszFormat, Args);
  1989. } else {
  1990. switch (iLogLevel) {
  1991. case (LOG_LEV_WARNING):
  1992. case (LOG_LEV_ERROR):
  1994. SysEventLogV(iLogLevel, pszFormat, Args);
  1996. break;
  1997. }
  1998. }
  2000. va_end(Args);
  2002. pthread_mutex_unlock(&LogMutex);
  2004. return (0);
  2006. }
  2008. void SysSleep(int iTimeout)
  2009. {
  2011. SysMsSleep(iTimeout * 1000);
  2013. }
  2015. static int SysSetupWait(WaitData * pWD)
  2016. {
  2018. if (pthread_mutex_init(&pWD->Mtx, NULL) != 0) {
  2019. ErrSetErrorCode(ERR_MUTEXINIT);
  2020. return (ERR_MUTEXINIT);
  2021. }
  2023. if (pthread_cond_init(&pWD->WaitCond, NULL) != 0) {
  2024. pthread_mutex_destroy(&pWD->Mtx);
  2025. ErrSetErrorCode(ERR_CONDINIT);
  2026. return (ERR_CONDINIT);
  2027. }
  2029. return (0);
  2031. }
  2033. static int SysWait(WaitData * pWD, int iMsTimeout)
  2034. {
  2035. struct timespec TV;
  2036. struct timeval TmNow;
  2037. int iErrorCode;
  2039. gettimeofday(&TmNow, NULL);
  2041. TmNow.tv_sec += iMsTimeout / 1000;
  2042. TmNow.tv_usec += (iMsTimeout % 1000) * 1000;
  2043. TmNow.tv_sec += TmNow.tv_usec / 1000000;
  2044. TmNow.tv_usec %= 1000000;
  2046. TV.tv_sec = TmNow.tv_sec;
  2047. TV.tv_nsec = TmNow.tv_usec * 1000;
  2049. pthread_mutex_lock(&pWD->Mtx);
  2050. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pWD->Mtx);
  2052. iErrorCode = pthread_cond_timedwait(&pWD->WaitCond, &pWD->Mtx, &TV);
  2054. pthread_cleanup_pop(1);
  2056. if (iErrorCode == ETIMEDOUT) {
  2057. ErrSetErrorCode(ERR_TIMEOUT);
  2058. return (ERR_TIMEOUT);
  2059. }
  2061. return (0);
  2063. }
  2065. static void SysCleanupWait(WaitData * pWD)
  2066. {
  2068. pthread_mutex_destroy(&pWD->Mtx);
  2069. pthread_cond_destroy(&pWD->WaitCond);
  2071. }
  2073. void SysMsSleep(int iMsTimeout)
  2074. {
  2076. WaitData WD;
  2078. if (SysSetupWait(&WD) == 0) {
  2079. SysWait(&WD, iMsTimeout);
  2080. SysCleanupWait(&WD);
  2081. }
  2083. }
  2085. SYS_INT64 SysMsTime(void)
  2086. {
  2088. struct timeval tv;
  2090. if (gettimeofday(&tv, NULL) != 0)
  2091. return (0);
  2093. return (1000 * (SYS_INT64) tv.tv_sec + (SYS_INT64) tv.tv_usec / 1000);
  2095. }
  2097. int SysExistFile(const char *pszFilePath)
  2098. {
  2100. struct stat FS;
  2102. if (stat(pszFilePath, &FS) != 0)
  2103. return (0);
  2105. return ((S_ISDIR(FS.st_mode)) ? 0 : 1);
  2107. }
  2109. int SysExistDir(const char *pszDirPath)
  2110. {
  2112. struct stat FS;
  2114. if (stat(pszDirPath, &FS) != 0)
  2115. return (0);
  2117. return ((S_ISDIR(FS.st_mode)) ? 1 : 0);
  2119. }
  2121. SYS_HANDLE SysFirstFile(const char *pszPath, char *pszFileName)
  2122. {
  2124. DIR *pDIR = opendir(pszPath);
  2126. if (pDIR == NULL) {
  2127. ErrSetErrorCode(ERR_OPENDIR);
  2128. return (SYS_INVALID_HANDLE);
  2129. }
  2131. FilledDirent FDE;
  2132. struct dirent *pDirEntry = NULL;
  2134. readdir_r(pDIR, &FDE.DE, &pDirEntry);
  2136. if (pDirEntry == NULL) {
  2137. closedir(pDIR);
  2138. return (SYS_INVALID_HANDLE);
  2139. }
  2141. FileFindData *pFFD = (FileFindData *) SysAlloc(sizeof(FileFindData));
  2143. if (pFFD == NULL) {
  2144. closedir(pDIR);
  2145. return (SYS_INVALID_HANDLE);
  2146. }
  2148. strcpy(pFFD->szPath, pszPath);
  2149. AppendSlash(pFFD->szPath);
  2150. pFFD->pDIR = pDIR;
  2151. pFFD->FDE = FDE;
  2153. strcpy(pszFileName, pFFD->FDE.DE.d_name);
  2155. char szFilePath[SYS_MAX_PATH] = "";
  2157. snprintf(szFilePath, sizeof(szFilePath) - 1, "%s%s", pFFD->szPath, pFFD->FDE.DE.d_name);
  2159. if (stat(szFilePath, &pFFD->FS) != 0) {
  2160. SysFree(pFFD);
  2161. closedir(pDIR);
  2163. ErrSetErrorCode(ERR_STAT);
  2164. return (SYS_INVALID_HANDLE);
  2165. }
  2167. return ((SYS_HANDLE) pFFD);
  2169. }
  2171. int SysIsDirectory(SYS_HANDLE hFind)
  2172. {
  2174. FileFindData *pFFD = (FileFindData *) hFind;
  2176. return ((S_ISDIR(pFFD->FS.st_mode)) ? 1 : 0);
  2178. }
  2180. unsigned long SysGetSize(SYS_HANDLE hFind)
  2181. {
  2183. FileFindData *pFFD = (FileFindData *) hFind;
  2185. return ((unsigned long) pFFD->FS.st_size);
  2187. }
  2189. int SysNextFile(SYS_HANDLE hFind, char *pszFileName)
  2190. {
  2192. FileFindData *pFFD = (FileFindData *) hFind;
  2193. struct dirent *pDirEntry = NULL;
  2195. readdir_r(pFFD->pDIR, &pFFD->FDE.DE, &pDirEntry);
  2197. if (pDirEntry == NULL)
  2198. return (0);
  2200. strcpy(pszFileName, pFFD->FDE.DE.d_name);
  2202. char szFilePath[SYS_MAX_PATH] = "";
  2204. snprintf(szFilePath, sizeof(szFilePath) - 1, "%s%s", pFFD->szPath, pFFD->FDE.DE.d_name);
  2206. if (stat(szFilePath, &pFFD->FS) != 0) {
  2207. ErrSetErrorCode(ERR_STAT);
  2208. return (0);
  2209. }
  2211. return (1);
  2213. }
  2215. void SysFindClose(SYS_HANDLE hFind)
  2216. {
  2218. FileFindData *pFFD = (FileFindData *) hFind;
  2220. closedir(pFFD->pDIR);
  2222. SysFree(pFFD);
  2224. }
  2226. int SysGetFileInfo(char const *pszFileName, SYS_FILE_INFO & FI)
  2227. {
  2229. struct stat stat_buffer;
  2231. if (stat(pszFileName, &stat_buffer) != 0) {
  2232. ErrSetErrorCode(ERR_STAT);
  2233. return (ERR_STAT);
  2234. }
  2236. ZeroData(FI);
  2237. FI.iFileType = (S_ISREG(stat_buffer.st_mode)) ? ftNormal :
  2238. ((S_ISDIR(stat_buffer.st_mode)) ? ftDirectory :
  2239.  ((S_ISLNK(stat_buffer.st_mode)) ? ftLink : ftOther));
  2240. FI.ulSize = (unsigned long) stat_buffer.st_size;
  2241. FI.tMod = stat_buffer.st_mtime;
  2243. return (0);
  2245. }
  2247. int SysSetFileModTime(char const *pszFileName, time_t tMod)
  2248. {
  2250. struct utimbuf TMB;
  2252. TMB.actime = tMod;
  2253. TMB.modtime = tMod;
  2255. if (utime(pszFileName, &TMB) != 0) {
  2256. ErrSetErrorCode(ERR_SET_FILE_TIME);
  2257. return (ERR_SET_FILE_TIME);
  2258. }
  2260. return (0);
  2262. }
  2264. char *SysStrDup(const char *pszString)
  2265. {
  2267. int iStrLength = strlen(pszString);
  2268. char *pszBuffer = (char *) SysAlloc(iStrLength + 1);
  2270. if (pszBuffer != NULL)
  2271. strcpy(pszBuffer, pszString);
  2273. return (pszBuffer);
  2275. }
  2277. char *SysGetEnv(const char *pszVarName)
  2278. {
  2280. const char *pszValue = getenv(pszVarName);
  2282. return ((pszValue != NULL) ? SysStrDup(pszValue) : NULL);
  2284. }
  2286. char *SysGetTmpFile(char *pszFileName)
  2287. {
  2289. static unsigned long ulFileSeqNr = 0;
  2290. unsigned long ulThreadID = SysGetCurrentThreadId();
  2292. sprintf(pszFileName, "/tmp/msrv%lx.%lx.tmp", ulThreadID, ulFileSeqNr++);
  2294. return (pszFileName);
  2296. }
  2298. int SysRemove(const char *pszFileName)
  2299. {
  2301. if (unlink(pszFileName) != 0) {
  2302. ErrSetErrorCode(ERR_FILE_DELETE);
  2303. return (ERR_FILE_DELETE);
  2304. }
  2306. return (0);
  2308. }
  2310. int SysMakeDir(const char *pszPath)
  2311. {
  2313. if (mkdir(pszPath, 0700) != 0) {
  2314. ErrSetErrorCode(ERR_DIR_CREATE);
  2315. return (ERR_DIR_CREATE);
  2316. }
  2318. return (0);
  2320. }
  2322. int SysRemoveDir(const char *pszPath)
  2323. {
  2325. if (rmdir(pszPath) != 0) {
  2326. ErrSetErrorCode(ERR_DIR_DELETE);
  2327. return (ERR_DIR_DELETE);
  2328. }
  2330. return (0);
  2332. }
  2334. int SysMoveFile(char const *pszOldName, char const *pszNewName)
  2335. {
  2337. if (rename(pszOldName, pszNewName) != 0) {
  2338. ErrSetErrorCode(ERR_FILE_MOVE);
  2339. return (ERR_FILE_MOVE);
  2340. }
  2342. return (0);
  2344. }
  2346. int SysVSNPrintf(char *pszBuffer, int iSize, char const *pszFormat, va_list Args)
  2347. {
  2349. int iPrintResult = vsnprintf(pszBuffer, iSize, pszFormat, Args);
  2351. return ((iPrintResult < iSize) ? iPrintResult : -1);
  2353. }
  2355. int SysFileSync(FILE * pFile)
  2356. {
  2358. if (fflush(pFile) || fsync(fileno(pFile))) {
  2359. ErrSetErrorCode(ERR_FILE_WRITE);
  2360. return (ERR_FILE_WRITE);
  2361. }
  2363. return (0);
  2365. }
  2367. char *SysStrTok(char *pszData, char const *pszDelim, char **ppszSavePtr)
  2368. {
  2370. return (strtok_r(pszData, pszDelim, ppszSavePtr));
  2372. }
  2374. char *SysCTime(time_t * pTimer, char *pszBuffer, int iBufferSize)
  2375. {
  2377. return (ctime_r(pTimer, pszBuffer));
  2379. }
  2381. struct tm *SysLocalTime(time_t * pTimer, struct tm *pTStruct)
  2382. {
  2384. return (localtime_r(pTimer, pTStruct));
  2386. }
  2388. struct tm *SysGMTime(time_t * pTimer, struct tm *pTStruct)
  2389. {
  2391. return (gmtime_r(pTimer, pTStruct));
  2393. }
  2395. char *SysAscTime(struct tm *pTStruct, char *pszBuffer, int iBufferSize)
  2396. {
  2398. return (asctime_r(pTStruct, pszBuffer));
  2400. }
  2402. long SysGetTimeZone(void)
  2403. {
  2405. time_t tCurr = time(NULL);
  2406. struct tm tmCurr;
  2408. localtime_r(&tCurr, &tmCurr);
  2410. return ((long) -tmCurr.tm_gmtoff);
  2412. }
  2414. long SysGetDayLight(void)
  2415. {
  2417. time_t tCurr = time(NULL);
  2418. struct tm tmCurr;
  2420. localtime_r(&tCurr, &tmCurr);
  2422. return ((long) ((tmCurr.tm_isdst <= 0) ? 0 : 3600));
  2424. }
  2426. int SysGetDiskSpace(char const *pszPath, SYS_INT64 * pTotal, SYS_INT64 * pFree)
  2427. {
  2429. struct statfs SFS;
  2431. if (statfs(pszPath, &SFS) != 0) {
  2432. ErrSetErrorCode(ERR_GET_DISK_SPACE_INFO);
  2433. return (ERR_GET_DISK_SPACE_INFO);
  2434. }
  2436. *pTotal = (SYS_INT64) SFS.f_bsize * (SYS_INT64) SFS.f_blocks;
  2438. *pFree = (SYS_INT64) SFS.f_bsize * (SYS_INT64) SFS.f_bavail;
  2440. return (0);
  2442. }
  2444. int SysMemoryInfo(SYS_INT64 * pRamTotal, SYS_INT64 * pRamFree,
  2445.   SYS_INT64 * pVirtTotal, SYS_INT64 * pVirtFree)
  2446. {
  2448. #if defined(__FREEBSD__)
  2449. int iValue;
  2450. size_t DataLen;
  2452. DataLen = sizeof(iValue);
  2453. if (sysctlbyname("vm.stats.vm.v_page_size", &iValue, &DataLen, NULL, 0) != 0) {
  2454. ErrSetErrorCode(ERR_GET_MEMORY_INFO);
  2455. return (ERR_GET_MEMORY_INFO);
  2456. }
  2458. SYS_INT64 PageSize = (SYS_INT64) iValue;
  2460. DataLen = sizeof(iValue);
  2461. if (sysctlbyname("vm.stats.vm.v_page_count", &iValue, &DataLen, NULL, 0) != 0) {
  2462. ErrSetErrorCode(ERR_GET_MEMORY_INFO);
  2463. return (ERR_GET_MEMORY_INFO);
  2464. }
  2466. *pVirtTotal = *pRamTotal = (SYS_INT64) iValue *PageSize;
  2468. DataLen = sizeof(iValue);
  2469. if (sysctlbyname("vm.stats.vm.v_free_count", &iValue, &DataLen, NULL, 0) != 0) {
  2470. ErrSetErrorCode(ERR_GET_MEMORY_INFO);
  2471. return (ERR_GET_MEMORY_INFO);
  2472. }
  2474. *pVirtFree = *pRamFree = (SYS_INT64) iValue *PageSize;
  2476. ///////////////////////////////////////////////////////////////////////////////
  2477. //  Get swap infos through the kvm interface
  2478. ///////////////////////////////////////////////////////////////////////////////
  2479. char szErrBuffer[_POSIX2_LINE_MAX] = "";
  2480. kvm_t *pKD = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, szErrBuffer);
  2482. if (pKD == NULL) {
  2483. ErrSetErrorCode(ERR_GET_MEMORY_INFO);
  2484. return (ERR_GET_MEMORY_INFO);
  2485. }
  2487. struct kvm_swap KSwap[8];
  2488. int iSwaps = kvm_getswapinfo(pKD, KSwap, CountOf(KSwap), SWIF_DEV_PREFIX);
  2490. for (int ii; ii < iSwaps; ii++) {
  2491. *pVirtFree += (SYS_INT64) (KSwap[ii].ksw_total - KSwap[ii].ksw_used) * PageSize;
  2493. *pVirtTotal += (SYS_INT64) KSwap[ii].ksw_total * PageSize;
  2494. }
  2496. kvm_close(pKD);
  2498. return (0);
  2499. #else // #if defined(__FREEBSD__)
  2500. int iResult = 0, iHwPhisMem, iHwPageSize;
  2501. size_t DataLen;
  2502. struct vmtotal VmMeter;
  2503. static int iHwPhisMem_mib[] = { CTL_HW, HW_PHYSMEM };
  2504. static int iHwPageSize_mib[] = { CTL_HW, HW_PAGESIZE };
  2505. static int VmMeter_mib[] = { CTL_VM, VM_METER };
  2507. DataLen = sizeof(iHwPhisMem);
  2508. if (iResult >= 0)
  2509. iResult = sysctl(iHwPhisMem_mib, 2, &iHwPhisMem, &DataLen, NULL, 0);
  2511. DataLen = sizeof(iHwPageSize);
  2512. if (iResult >= 0)
  2513. iResult = sysctl(iHwPageSize_mib, 2, &iHwPageSize, &DataLen, NULL, 0);
  2515. DataLen = sizeof(vmtotal);
  2516. if (iResult >= 0)
  2517. iResult = sysctl(VmMeter_mib, 2, &VmMeter, &DataLen, NULL, 0);
  2519. if (iResult < 0) {
  2520. ErrSetErrorCode(ERR_GET_MEMORY_INFO);
  2521. return (ERR_GET_MEMORY_INFO);
  2522. }
  2524. *pRamTotal = iHwPhisMem;
  2525. *pRamFree = (SYS_INT64) iHwPageSize *(SYS_INT64) VmMeter.t_free;
  2526. *pVirtTotal = (SYS_INT64) iHwPageSize *(SYS_INT64) VmMeter.t_vm;
  2527. *pVirtFree = *pVirtTotal - (SYS_INT64) iHwPageSize *(SYS_INT64) VmMeter.t_avm;
  2529. return (0);
  2530. #endif // #if defined(__FREEBSD__)
  2532. }
  2534. static unsigned int SysStkCall(unsigned int (*pProc) (void *), void *pData)
  2535. {
  2537. srand(getpid() * (unsigned int) time(NULL) * uSRandBase);
  2539. unsigned int uResult;
  2540. unsigned int uStkDisp =
  2541. (unsigned int) (rand() % MAX_STACK_SHIFT) & ~(STACK_ALIGN_BYTES - 1);
  2542. void *pStkSpace = alloca(uStkDisp);
  2544. uResult = pProc(pData);
  2546. return (uResult);
  2548. }