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

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

Email服务器

开发平台：

Visual C++

SysDepSolaris.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 MAX_THREAD_CONCURRENCY      512
  31. #define SHUTDOWN_RECV_TIMEOUT       2
  32. #define SAIN_Addr(s)                (s).sin_addr.s_addr
  34. #define SCHED_PRIORITY_INC          5
  36. #define MIN_TCP_SEND_SIZE           (1024 * 8)
  37. #define MAX_TCP_SEND_SIZE           (1024 * 128)
  38. #define K_IO_TIME_RATIO             8
  40. #define MAX_SWAP_NAME_SIZE          256
  42. #define WAIT_PID_TIME_STEP          250
  43. #define WAIT_TIMEO_EXIT_STATUS      255
  44. #define WAIT_ERROR_EXIT_STATUS      254
  46. #define MAX_STACK_SHIFT             2048
  47. #define STACK_ALIGN_BYTES           sizeof(int)
  49. struct SemData {
  50. pthread_mutex_t Mtx;
  51. pthread_cond_t WaitCond;
  52. int iSemCounter;
  53. int iMaxCount;
  54. };
  56. struct MutexData {
  57. pthread_mutex_t Mtx;
  58. pthread_cond_t WaitCond;
  59. int iLocked;
  60. };
  62. struct EventData {
  63. pthread_mutex_t Mtx;
  64. pthread_cond_t WaitCond;
  65. int iSignaled;
  66. int iManualReset;
  67. };
  69. struct WaitData {
  70. pthread_mutex_t Mtx;
  71. pthread_cond_t WaitCond;
  72. };
  74. struct ThrData {
  75. pthread_t ThreadId;
  76. unsigned int (*ThreadProc) (void *);
  77. void *pThreadData;
  78. pthread_mutex_t Mtx;
  79. pthread_cond_t ExitWaitCond;
  80. int iThreadEnded;
  81. int iExitCode;
  82. int iUseCount;
  83. };
  85. union FilledDirent {
  86. struct dirent DE;
  87. char Pad[sizeof(struct dirent) + NAME_MAX];
  88. };
  90. struct FileFindData {
  91. char szPath[SYS_MAX_PATH];
  92. DIR *pDIR;
  93. FilledDirent FDE;
  94. struct stat FS;
  95. };
  97. static int SysSetSignal(int iSigNo, void (*pSigProc) (int));
  98. static char const *SysGetLastError(void);
  99. static void SysIgnoreProc(int iSignal);
  100. static int SysSetSockNoDelay(SYS_SOCKET SockFD, int iNoDelay);
  101. static int SysSetSocketsOptions(SYS_SOCKET SockFD);
  102. static int SysFreeThreadData(ThrData * pTD);
  103. static void *SysThreadStartup(void *pThreadData);
  104. static int SysThreadSetup(ThrData * pTD);
  105. static void SysThreadCleanup(ThrData * pTD);
  106. static int SysSafeMsSleep(int iMsTimeout);
  107. static int SysWaitPID(pid_t PID, int *piExitCode, int iTimeout);
  108. static void SysBreakHandlerRoutine(int iSignal);
  109. static int SysSetupWait(WaitData * pWD);
  110. static int SysWait(WaitData * pWD, int iMsTimeout);
  111. static void SysCleanupWait(WaitData * pWD);
  112. static int SysGetSwapInfo(SYS_INT64 * pSwapTotal, SYS_INT64 * pSwapFree);
  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. thr_setconcurrency(MAX_THREAD_CONCURRENCY);
  158. if (SysThreadSetup(NULL) < 0)
  159. return (ErrGetErrorCode());
  161. return (0);
  163. }
  165. void SysCleanupLibrary(void)
  166. {
  168. SysThreadCleanup(NULL);
  170. }
  172. int SysShutdownLibrary(int iMode)
  173. {
  175. iShutDown++;
  177. kill(0, SIGQUIT);
  179. return (0);
  181. }
  183. int SysSetupSocketBuffers(int *piSndBufSize, int *piRcvBufSize)
  184. {
  186. if (piSndBufSize != NULL)
  187. iSndBufSize = *piSndBufSize;
  189. if (piRcvBufSize != NULL)
  190. iRcvBufSize = *piRcvBufSize;
  192. return (0);
  194. }
  196. SYS_SOCKET SysCreateSocket(int iAddressFamily, int iType, int iProtocol)
  197. {
  199. int SockFD = socket(AF_INET, iType, iProtocol);
  201. if (SockFD == -1) {
  202. ErrSetErrorCode(ERR_SOCKET_CREATE);
  203. return (SYS_INVALID_SOCKET);
  204. }
  206. if (SysSetSocketsOptions((SYS_SOCKET) SockFD) < 0) {
  207. SysCloseSocket((SYS_SOCKET) SockFD);
  209. return (SYS_INVALID_SOCKET);
  210. }
  212. return ((SYS_SOCKET) SockFD);
  214. }
  216. static int SysSetSockNoDelay(SYS_SOCKET SockFD, int iNoDelay)
  217. {
  219. long lSockFlags = fcntl((int) SockFD, F_GETFL, 0);
  221. if (lSockFlags == -1) {
  222. ErrSetErrorCode(ERR_NETWORK);
  223. return (ERR_NETWORK);
  224. }
  226. if (iNoDelay)
  227. lSockFlags |= O_NONBLOCK;
  228. else
  229. lSockFlags &= ~O_NONBLOCK;
  231. if (fcntl((int) SockFD, F_SETFL, lSockFlags) == -1) {
  232. ErrSetErrorCode(ERR_NETWORK);
  233. return (ERR_NETWORK);
  234. }
  236. return (0);
  238. }
  240. static int SysSetSocketsOptions(SYS_SOCKET SockFD)
  241. {
  242. ///////////////////////////////////////////////////////////////////////////////
  243. //  Set socket buffer sizes
  244. ///////////////////////////////////////////////////////////////////////////////
  245. if (iSndBufSize > 0) {
  246. int iSize = iSndBufSize;
  248. setsockopt((int) SockFD, SOL_SOCKET, SO_SNDBUF, (const char *) &iSize,
  249.    sizeof(iSize));
  250. }
  252. if (iRcvBufSize > 0) {
  253. int iSize = iRcvBufSize;
  255. setsockopt((int) SockFD, SOL_SOCKET, SO_RCVBUF, (const char *) &iSize,
  256.    sizeof(iSize));
  257. }
  259. int iActivate = 1;
  261. if (setsockopt(SockFD, SOL_SOCKET, SO_REUSEADDR, (const char *) &iActivate,
  262.        sizeof(iActivate)) != 0) {
  263. ErrSetErrorCode(ERR_SETSOCKOPT);
  264. return (ERR_SETSOCKOPT);
  265. }
  266. ///////////////////////////////////////////////////////////////////////////////
  267. //  Disable linger
  268. ///////////////////////////////////////////////////////////////////////////////
  269. struct linger Ling;
  271. ZeroData(Ling);
  272. Ling.l_onoff = 0;
  273. Ling.l_linger = 0;
  275. setsockopt(SockFD, SOL_SOCKET, SO_LINGER, (const char *) &Ling, sizeof(Ling));
  277. ///////////////////////////////////////////////////////////////////////////////
  278. //  Set KEEPALIVE if supported
  279. ///////////////////////////////////////////////////////////////////////////////
  280. setsockopt(SockFD, SOL_SOCKET, SO_KEEPALIVE, (const char *) &iActivate,
  281.    sizeof(iActivate));
  283. return (0);
  285. }
  287. void SysCloseSocket(SYS_SOCKET SockFD)
  288. {
  290. close(SockFD);
  292. }
  294. int SysBindSocket(SYS_SOCKET SockFD, const struct sockaddr *SockName, int iNameLen)
  295. {
  297. if (bind((int) SockFD, SockName, iNameLen) == -1) {
  298. ErrSetErrorCode(ERR_SOCKET_BIND);
  299. return (ERR_SOCKET_BIND);
  300. }
  302. return (0);
  304. }
  306. void SysListenSocket(SYS_SOCKET SockFD, int iConnections)
  307. {
  309. listen((int) SockFD, iConnections);
  311. }
  313. int SysRecvData(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize, int iTimeout)
  314. {
  316. struct pollfd pfds;
  318. ZeroData(pfds);
  319. pfds.fd = (int) SockFD;
  320. pfds.events = POLLIN;
  322. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  324. if (iPollResult == -1) {
  325. ErrSetErrorCode(ERR_NETWORK);
  326. return (ERR_NETWORK);
  327. }
  329. if (iPollResult == 0) {
  330. ErrSetErrorCode(ERR_TIMEOUT);
  331. return (ERR_TIMEOUT);
  332. }
  334. int iRecvBytes;
  336. while (((iRecvBytes = recv((int) SockFD, pszBuffer, iBufferSize, 0)) == -1) &&
  337.        SYS_INT_CALL());
  339. if (iRecvBytes == -1) {
  340. ErrSetErrorCode(ERR_NETWORK);
  341. return (ERR_NETWORK);
  342. }
  344. return (iRecvBytes);
  346. }
  348. int SysRecv(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize, int iTimeout)
  349. {
  351. int iRtxBytes = 0;
  353. while (iRtxBytes < iBufferSize) {
  354. int iRtxCurrent = SysRecvData(SockFD, pszBuffer + iRtxBytes,
  355.       iBufferSize - iRtxBytes, iTimeout);
  357. if (iRtxCurrent <= 0)
  358. return (iRtxBytes);
  360. iRtxBytes += iRtxCurrent;
  361. }
  363. return (iRtxBytes);
  365. }
  367. int SysRecvDataFrom(SYS_SOCKET SockFD, struct sockaddr *pFrom, int iFromlen,
  368.     char *pszBuffer, int iBufferSize, int iTimeout)
  369. {
  371. struct pollfd pfds;
  373. ZeroData(pfds);
  374. pfds.fd = (int) SockFD;
  375. pfds.events = POLLIN;
  377. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  379. if (iPollResult == -1) {
  380. ErrSetErrorCode(ERR_NETWORK);
  381. return (ERR_NETWORK);
  382. }
  384. if (iPollResult == 0) {
  385. ErrSetErrorCode(ERR_TIMEOUT);
  386. return (ERR_TIMEOUT);
  387. }
  389. socklen_t SockALen = (socklen_t) iFromlen;
  390. int iRecvBytes;
  392. while (((iRecvBytes = recvfrom((int) SockFD, pszBuffer, iBufferSize, 0,
  393.        pFrom, &SockALen)) == -1) && SYS_INT_CALL());
  395. if (iRecvBytes == -1) {
  396. ErrSetErrorCode(ERR_NETWORK);
  397. return (ERR_NETWORK);
  398. }
  400. return (iRecvBytes);
  402. }
  404. int SysSendData(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize, int iTimeout)
  405. {
  407. struct pollfd pfds;
  409. ZeroData(pfds);
  410. pfds.fd = (int) SockFD;
  411. pfds.events = POLLOUT;
  413. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  415. if (iPollResult == -1) {
  416. ErrSetErrorCode(ERR_NETWORK);
  417. return (ERR_NETWORK);
  418. }
  420. if (iPollResult == 0) {
  421. ErrSetErrorCode(ERR_TIMEOUT);
  422. return (ERR_TIMEOUT);
  423. }
  425. int iSendBytes;
  427. while (((iSendBytes = send((int) SockFD, pszBuffer, iBufferSize, 0)) == -1) &&
  428.        SYS_INT_CALL());
  430. if (iSendBytes == -1) {
  431. ErrSetErrorCode(ERR_NETWORK);
  432. return (ERR_NETWORK);
  433. }
  435. return (iSendBytes);
  437. }
  439. int SysSend(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize, int iTimeout)
  440. {
  442. int iRtxBytes = 0;
  444. while (iRtxBytes < iBufferSize) {
  445. int iRtxCurrent = SysSendData(SockFD, pszBuffer + iRtxBytes,
  446.       iBufferSize - iRtxBytes, iTimeout);
  448. if (iRtxCurrent <= 0)
  449. return (iRtxBytes);
  451. iRtxBytes += iRtxCurrent;
  452. }
  454. return (iRtxBytes);
  456. }
  458. int SysSendDataTo(SYS_SOCKET SockFD, const struct sockaddr *pTo,
  459.   int iToLen, char const *pszBuffer, int iBufferSize, int iTimeout)
  460. {
  462. struct pollfd pfds;
  464. ZeroData(pfds);
  465. pfds.fd = (int) SockFD;
  466. pfds.events = POLLOUT;
  468. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  470. if (iPollResult == -1) {
  471. ErrSetErrorCode(ERR_NETWORK);
  472. return (ERR_NETWORK);
  473. }
  475. if (iPollResult == 0) {
  476. ErrSetErrorCode(ERR_TIMEOUT);
  477. return (ERR_TIMEOUT);
  478. }
  480. int iSendBytes;
  482. while (((iSendBytes = sendto((int) SockFD, pszBuffer, iBufferSize, 0, pTo, iToLen)) == -1)
  483.        && SYS_INT_CALL());
  485. if (iSendBytes == -1) {
  486. ErrSetErrorCode(ERR_NETWORK);
  487. return (ERR_NETWORK);
  488. }
  490. return (iSendBytes);
  492. }
  494. int SysConnect(SYS_SOCKET SockFD, const SYS_INET_ADDR * pSockName, int iNameLen, int iTimeout)
  495. {
  497. if (SysSetSockNoDelay(SockFD, 1) < 0)
  498. return (ErrGetErrorCode());
  500. if (connect((int) SockFD, (const struct sockaddr *) &pSockName->Addr, iNameLen) == 0) {
  501. SysSetSockNoDelay(SockFD, 0);
  502. return (0);
  503. }
  505. if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK)) {
  506. SysSetSockNoDelay(SockFD, 0);
  508. ErrSetErrorCode(ERR_NETWORK);
  509. return (ERR_NETWORK);
  510. }
  512. struct pollfd pfds;
  514. ZeroData(pfds);
  515. pfds.fd = (int) SockFD;
  516. pfds.events = POLLOUT;
  518. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  520. SysSetSockNoDelay(SockFD, 0);
  522. if (iPollResult == -1) {
  523. ErrSetErrorCode(ERR_NETWORK);
  524. return (ERR_NETWORK);
  525. }
  527. if (iPollResult == 0) {
  528. ErrSetErrorCode(ERR_TIMEOUT);
  529. return (ERR_TIMEOUT);
  530. }
  532. return (0);
  534. }
  536. SYS_SOCKET SysAccept(SYS_SOCKET SockFD, SYS_INET_ADDR * pSockName, int *iNameLen, int iTimeout)
  537. {
  539. struct pollfd pfds;
  541. ZeroData(pfds);
  542. pfds.fd = (int) SockFD;
  543. pfds.events = POLLIN;
  545. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  547. if (iPollResult == -1) {
  548. ErrSetErrorCode(ERR_NETWORK);
  549. return (SYS_INVALID_SOCKET);
  550. }
  552. if (iPollResult == 0) {
  553. ErrSetErrorCode(ERR_TIMEOUT);
  554. return (SYS_INVALID_SOCKET);
  555. }
  557. socklen_t SockALen = (socklen_t) * iNameLen;
  558. int iAcptSock = accept((int) SockFD,
  559.        (struct sockaddr *) &pSockName->Addr, &SockALen);
  561. if (iAcptSock == -1) {
  562. ErrSetErrorCode(ERR_NETWORK);
  563. return (SYS_INVALID_SOCKET);
  564. }
  566. if (SysSetSocketsOptions((SYS_SOCKET) iAcptSock) < 0) {
  567. SysCloseSocket((SYS_SOCKET) iAcptSock);
  569. return (SYS_INVALID_SOCKET);
  570. }
  572. *iNameLen = (int) SockALen;
  574. return ((SYS_SOCKET) iAcptSock);
  576. }
  578. int SysSelect(int iMaxFD, SYS_fd_set * pReadFDs, SYS_fd_set * pWriteFDs, SYS_fd_set * pExcptFDs,
  579.       int iTimeout)
  580. {
  582. struct timeval TV;
  584. ZeroData(TV);
  585. TV.tv_sec = iTimeout;
  586. TV.tv_usec = 0;
  588. int iSelectResult = select(iMaxFD + 1, pReadFDs, pWriteFDs, pExcptFDs, &TV);
  590. if (iSelectResult == -1) {
  591. ErrSetErrorCode(ERR_SELECT);
  592. return (ERR_SELECT);
  593. }
  595. if (iSelectResult == 0) {
  596. ErrSetErrorCode(ERR_TIMEOUT);
  597. return (ERR_TIMEOUT);
  598. }
  600. return (iSelectResult);
  602. }
  604. int SysSendFile(SYS_SOCKET SockFD, char const *pszFileName, unsigned long ulBaseOffset,
  605. unsigned long ulEndOffset, int iTimeout)
  606. {
  608. int iFileID = open(pszFileName, O_RDONLY);
  610. if (iFileID == -1) {
  611. ErrSetErrorCode(ERR_FILE_OPEN, pszFileName);
  612. return (ERR_FILE_OPEN);
  613. }
  615. unsigned long ulFileSize = (unsigned long) lseek(iFileID, 0, SEEK_END);
  617. lseek(iFileID, 0, SEEK_SET);
  619. void *pMapAddress = (void *) mmap((char *) 0, (size_t) ulFileSize, PROT_READ,
  620.   MAP_SHARED, iFileID, 0);
  622. if (pMapAddress == (void *) -1) {
  623. close(iFileID);
  624. ErrSetErrorCode(ERR_MMAP);
  625. return (ERR_MMAP);
  626. }
  627. ///////////////////////////////////////////////////////////////////////////////
  628. //  Send the file
  629. ///////////////////////////////////////////////////////////////////////////////
  630. int iSndBuffSize = MIN_TCP_SEND_SIZE;
  631. unsigned long ulCurrOffset = ulBaseOffset;
  632. unsigned long ulSndEndOffset =
  633. (ulEndOffset != (unsigned long) -1) ? ulEndOffset : ulFileSize;
  634. char *pszBuffer = (char *) pMapAddress + ulBaseOffset;
  635. time_t tStart;
  637. while (ulCurrOffset < ulSndEndOffset) {
  638. int iCurrSend = (int) Min(iSndBuffSize, ulSndEndOffset - ulCurrOffset);
  640. tStart = time(NULL);
  641. if ((iCurrSend = SysSendData(SockFD, pszBuffer, iCurrSend, iTimeout)) < 0) {
  642. ErrorPush();
  643. munmap((char *) pMapAddress, (size_t) ulFileSize);
  644. close(iFileID);
  645. return (ErrorPop());
  646. }
  648. if ((((time(NULL) - tStart) * K_IO_TIME_RATIO) < iTimeout) &&
  649.     (iSndBuffSize < MAX_TCP_SEND_SIZE))
  650. iSndBuffSize = Min(iSndBuffSize * 2, MAX_TCP_SEND_SIZE);
  652. pszBuffer += iCurrSend;
  653. ulCurrOffset += (unsigned long) iCurrSend;
  654. }
  656. munmap((char *) pMapAddress, (size_t) ulFileSize);
  658. close(iFileID);
  660. return (0);
  662. }
  664. int SysSetupAddress(SYS_INET_ADDR & AddrInfo, int iFamily,
  665.     NET_ADDRESS const &NetAddr, int iPortNo)
  666. {
  668. ZeroData(AddrInfo);
  669. AddrInfo.Addr.sin_family = iFamily;
  670. SAIN_Addr(AddrInfo.Addr) = NetAddr;
  671. AddrInfo.Addr.sin_port = htons((short) iPortNo);
  673. return (0);
  675. }
  677. int SysGetAddrAddress(SYS_INET_ADDR const &AddrInfo, NET_ADDRESS & NetAddr)
  678. {
  680. NetAddr = SAIN_Addr(AddrInfo.Addr);
  682. return (0);
  684. }
  686. int SysGetAddrPort(SYS_INET_ADDR const &AddrInfo)
  687. {
  689. return (ntohs(AddrInfo.Addr.sin_port));
  691. }
  693. int SysSetAddrAddress(SYS_INET_ADDR & AddrInfo, NET_ADDRESS const &NetAddr)
  694. {
  696. SAIN_Addr(AddrInfo.Addr) = NetAddr;
  698. return (0);
  700. }
  702. int SysSetAddrPort(SYS_INET_ADDR & AddrInfo, int iPortNo)
  703. {
  705. AddrInfo.Addr.sin_port = htons((short) iPortNo);
  707. return (0);
  709. }
  711. int SysGetHostByName(char const *pszName, NET_ADDRESS & NetAddr)
  712. {
  714. int iErrorNo = 0;
  715. struct hostent HostEnt;
  716. char szBuffer[1024];
  717. struct hostent *pHostEnt =
  718. gethostbyname_r(pszName, &HostEnt, szBuffer, sizeof(szBuffer), &iErrorNo);
  720. if ((pHostEnt == NULL) || (pHostEnt->h_addr_list[0] == NULL)) {
  721. ErrSetErrorCode(ERR_BAD_SERVER_ADDR, pszName);
  722. return (ERR_BAD_SERVER_ADDR);
  723. }
  725. memcpy(&NetAddr, pHostEnt->h_addr_list[0], sizeof(NetAddr));
  727. return (0);
  729. }
  731. int SysGetHostByAddr(SYS_INET_ADDR const &AddrInfo, char *pszFQDN)
  732. {
  734. int iErrorNo = 0;
  735. struct hostent HostEnt;
  736. char szBuffer[1024];
  737. struct hostent *pHostEnt = gethostbyaddr_r((const char *) &SAIN_Addr(AddrInfo.Addr),
  738.    sizeof(SAIN_Addr(AddrInfo.Addr)), AF_INET,
  739.    &HostEnt, szBuffer, sizeof(szBuffer),
  740.    &iErrorNo);
  742. if ((pHostEnt == NULL) || (pHostEnt->h_name == NULL)) {
  743. char szIP[128] = "???.???.???.???";
  745. ErrSetErrorCode(ERR_GET_SOCK_HOST, SysInetNToA(AddrInfo, szIP));
  746. return (ERR_GET_SOCK_HOST);
  747. }
  749. strcpy(pszFQDN, pHostEnt->h_name);
  751. return (0);
  753. }
  755. int SysGetPeerInfo(SYS_SOCKET SockFD, SYS_INET_ADDR & AddrInfo)
  756. {
  758. ZeroData(AddrInfo);
  760. socklen_t InfoSize = sizeof(AddrInfo.Addr);
  762. if (getpeername(SockFD, (struct sockaddr *) &AddrInfo.Addr, &InfoSize) == -1) {
  763. ErrSetErrorCode(ERR_GET_PEER_INFO);
  764. return (ERR_GET_PEER_INFO);
  765. }
  767. return (0);
  769. }
  771. int SysGetSockInfo(SYS_SOCKET SockFD, SYS_INET_ADDR & AddrInfo)
  772. {
  774. ZeroData(AddrInfo);
  776. socklen_t InfoSize = sizeof(AddrInfo.Addr);
  778. if (getsockname(SockFD, (struct sockaddr *) &AddrInfo.Addr, &InfoSize) == -1) {
  779. ErrSetErrorCode(ERR_GET_SOCK_INFO);
  780. return (ERR_GET_SOCK_INFO);
  781. }
  783. return (0);
  785. }
  787. char *SysInetNToA(SYS_INET_ADDR const &AddrInfo, char *pszIP)
  788. {
  790. union {
  791. unsigned int a;
  792. unsigned char b[4];
  793. } UAddr;
  795. memcpy(&UAddr, &AddrInfo.Addr.sin_addr, sizeof(UAddr));
  797. sprintf(pszIP, "%u.%u.%u.%u",
  798. (unsigned int) UAddr.b[0],
  799. (unsigned int) UAddr.b[1], (unsigned int) UAddr.b[2], (unsigned int) UAddr.b[3]);
  801. return (pszIP);
  803. }
  805. int SysInetAddr(char const *pszDotName, NET_ADDRESS & NetAddr)
  806. {
  808. if ((NetAddr = (NET_ADDRESS) inet_addr(pszDotName)) == SYS_INVALID_NET_ADDRESS) {
  809. ErrSetErrorCode(ERR_BAD_SERVER_ADDR, pszDotName);
  810. return (ERR_BAD_SERVER_ADDR);
  811. }
  813. return (0);
  815. }
  817. int SysSameAddress(NET_ADDRESS const &NetAddr1, NET_ADDRESS const &NetAddr2)
  818. {
  820. return (memcmp(&NetAddr1, &NetAddr2, sizeof(NET_ADDRESS)) == 0);
  822. }
  824. SYS_SEMAPHORE SysCreateSemaphore(int iInitCount, int iMaxCount)
  825. {
  827. SemData *pSD = (SemData *) SysAlloc(sizeof(SemData));
  829. if (pSD == NULL)
  830. return (SYS_INVALID_SEMAPHORE);
  832. if (pthread_mutex_init(&pSD->Mtx, NULL) != 0) {
  833. SysFree(pSD);
  835. ErrSetErrorCode(ERR_MUTEXINIT, NULL);
  836. return (SYS_INVALID_SEMAPHORE);
  837. }
  839. if (pthread_cond_init(&pSD->WaitCond, NULL) != 0) {
  840. pthread_mutex_destroy(&pSD->Mtx);
  841. SysFree(pSD);
  843. ErrSetErrorCode(ERR_CONDINIT, NULL);
  844. return (SYS_INVALID_SEMAPHORE);
  845. }
  847. pSD->iSemCounter = iInitCount;
  849. pSD->iMaxCount = iMaxCount;
  851. return ((SYS_SEMAPHORE) pSD);
  853. }
  855. int SysCloseSemaphore(SYS_SEMAPHORE hSemaphore)
  856. {
  858. SemData *pSD = (SemData *) hSemaphore;
  860. pthread_cond_destroy(&pSD->WaitCond);
  862. pthread_mutex_destroy(&pSD->Mtx);
  864. SysFree(pSD);
  866. return (0);
  868. }
  870. int SysWaitSemaphore(SYS_SEMAPHORE hSemaphore, int iTimeout)
  871. {
  873. SemData *pSD = (SemData *) hSemaphore;
  875. pthread_mutex_lock(&pSD->Mtx);
  877. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  879. while (pSD->iSemCounter <= 0) {
  880. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pSD->Mtx);
  882. pthread_cond_wait(&pSD->WaitCond, &pSD->Mtx);
  884. pthread_cleanup_pop(0);
  885. }
  887. pSD->iSemCounter -= 1;
  889. } else {
  890. struct timeval tvNow;
  891. struct timespec tsTimeout;
  893. gettimeofday(&tvNow, NULL);
  895. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  896. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  898. int iRetCode = 0;
  900. while ((pSD->iSemCounter <= 0) && (iRetCode != ETIMEDOUT)) {
  901. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pSD->Mtx);
  903. iRetCode = pthread_cond_timedwait(&pSD->WaitCond, &pSD->Mtx, &tsTimeout);
  905. pthread_cleanup_pop(0);
  906. }
  908. if (iRetCode == ETIMEDOUT) {
  909. pthread_mutex_unlock(&pSD->Mtx);
  910. ErrSetErrorCode(ERR_TIMEOUT);
  911. return (ERR_TIMEOUT);
  912. }
  914. pSD->iSemCounter -= 1;
  916. }
  918. pthread_mutex_unlock(&pSD->Mtx);
  920. return (0);
  922. }
  924. int SysReleaseSemaphore(SYS_SEMAPHORE hSemaphore, int iCount)
  925. {
  927. SemData *pSD = (SemData *) hSemaphore;
  929. pthread_mutex_lock(&pSD->Mtx);
  931. pSD->iSemCounter += iCount;
  933. if (pSD->iSemCounter > 0) {
  934. if (pSD->iSemCounter > 1)
  935. pthread_cond_broadcast(&pSD->WaitCond);
  936. else
  937. pthread_cond_signal(&pSD->WaitCond);
  938. }
  940. pthread_mutex_unlock(&pSD->Mtx);
  942. return (0);
  944. }
  946. int SysTryWaitSemaphore(SYS_SEMAPHORE hSemaphore)
  947. {
  949. SemData *pSD = (SemData *) hSemaphore;
  951. pthread_mutex_lock(&pSD->Mtx);
  953. if (pSD->iSemCounter <= 0) {
  954. pthread_mutex_unlock(&pSD->Mtx);
  955. ErrSetErrorCode(ERR_TIMEOUT);
  956. return (ERR_TIMEOUT);
  957. }
  959. pSD->iSemCounter -= 1;
  961. pthread_mutex_unlock(&pSD->Mtx);
  963. return (0);
  965. }
  967. SYS_MUTEX SysCreateMutex(void)
  968. {
  970. MutexData *pMD = (MutexData *) SysAlloc(sizeof(MutexData));
  972. if (pMD == NULL)
  973. return (SYS_INVALID_MUTEX);
  975. if (pthread_mutex_init(&pMD->Mtx, NULL) != 0) {
  976. SysFree(pMD);
  977. ErrSetErrorCode(ERR_MUTEXINIT);
  978. return (SYS_INVALID_MUTEX);
  979. }
  981. if (pthread_cond_init(&pMD->WaitCond, NULL) != 0) {
  982. pthread_mutex_destroy(&pMD->Mtx);
  983. SysFree(pMD);
  984. ErrSetErrorCode(ERR_CONDINIT);
  985. return (SYS_INVALID_MUTEX);
  986. }
  988. pMD->iLocked = 0;
  990. return ((SYS_MUTEX) pMD);
  992. }
  994. int SysCloseMutex(SYS_MUTEX hMutex)
  995. {
  997. MutexData *pMD = (MutexData *) hMutex;
  999. pthread_cond_destroy(&pMD->WaitCond);
  1001. pthread_mutex_destroy(&pMD->Mtx);
  1003. SysFree(pMD);
  1005. return (0);
  1007. }
  1009. int SysLockMutex(SYS_MUTEX hMutex, int iTimeout)
  1010. {
  1012. MutexData *pMD = (MutexData *) hMutex;
  1014. pthread_mutex_lock(&pMD->Mtx);
  1016. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1018. while (pMD->iLocked) {
  1019. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pMD->Mtx);
  1021. pthread_cond_wait(&pMD->WaitCond, &pMD->Mtx);
  1023. pthread_cleanup_pop(0);
  1024. }
  1026. pMD->iLocked = 1;
  1028. } else {
  1029. struct timeval tvNow;
  1030. struct timespec tsTimeout;
  1032. gettimeofday(&tvNow, NULL);
  1034. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1035. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1037. int iRetCode = 0;
  1039. while (pMD->iLocked && (iRetCode != ETIMEDOUT)) {
  1040. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pMD->Mtx);
  1042. iRetCode = pthread_cond_timedwait(&pMD->WaitCond, &pMD->Mtx, &tsTimeout);
  1044. pthread_cleanup_pop(0);
  1045. }
  1047. if (iRetCode == ETIMEDOUT) {
  1048. pthread_mutex_unlock(&pMD->Mtx);
  1049. ErrSetErrorCode(ERR_TIMEOUT);
  1050. return (ERR_TIMEOUT);
  1051. }
  1053. pMD->iLocked = 1;
  1055. }
  1057. pthread_mutex_unlock(&pMD->Mtx);
  1059. return (0);
  1061. }
  1063. int SysUnlockMutex(SYS_MUTEX hMutex)
  1064. {
  1066. MutexData *pMD = (MutexData *) hMutex;
  1068. pthread_mutex_lock(&pMD->Mtx);
  1070. pMD->iLocked = 0;
  1072. pthread_cond_signal(&pMD->WaitCond);
  1074. pthread_mutex_unlock(&pMD->Mtx);
  1076. return (0);
  1078. }
  1080. int SysTryLockMutex(SYS_MUTEX hMutex)
  1081. {
  1083. MutexData *pMD = (MutexData *) hMutex;
  1085. pthread_mutex_lock(&pMD->Mtx);
  1087. if (pMD->iLocked) {
  1088. pthread_mutex_unlock(&pMD->Mtx);
  1089. ErrSetErrorCode(ERR_TIMEOUT);
  1090. return (-1);
  1091. }
  1093. pMD->iLocked = 1;
  1095. pthread_mutex_unlock(&pMD->Mtx);
  1097. return (0);
  1099. }
  1101. SYS_EVENT SysCreateEvent(int iManualReset)
  1102. {
  1104. EventData *pED = (EventData *) SysAlloc(sizeof(EventData));
  1106. if (pED == NULL)
  1107. return (SYS_INVALID_EVENT);
  1109. if (pthread_mutex_init(&pED->Mtx, NULL) != 0) {
  1110. SysFree(pED);
  1111. ErrSetErrorCode(ERR_MUTEXINIT);
  1112. return (SYS_INVALID_EVENT);
  1113. }
  1115. if (pthread_cond_init(&pED->WaitCond, NULL) != 0) {
  1116. pthread_mutex_destroy(&pED->Mtx);
  1117. SysFree(pED);
  1118. ErrSetErrorCode(ERR_CONDINIT);
  1119. return (SYS_INVALID_EVENT);
  1120. }
  1122. pED->iSignaled = 0;
  1123. pED->iManualReset = iManualReset;
  1125. return ((SYS_EVENT) pED);
  1127. }
  1129. int SysCloseEvent(SYS_EVENT hEvent)
  1130. {
  1132. EventData *pED = (EventData *) hEvent;
  1134. pthread_cond_destroy(&pED->WaitCond);
  1136. pthread_mutex_destroy(&pED->Mtx);
  1138. SysFree(pED);
  1140. return (0);
  1142. }
  1144. int SysWaitEvent(SYS_EVENT hEvent, int iTimeout)
  1145. {
  1147. EventData *pED = (EventData *) hEvent;
  1149. pthread_mutex_lock(&pED->Mtx);
  1151. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1153. while (!pED->iSignaled) {
  1154. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pED->Mtx);
  1156. pthread_cond_wait(&pED->WaitCond, &pED->Mtx);
  1158. pthread_cleanup_pop(0);
  1159. }
  1161. if (!pED->iManualReset)
  1162. pED->iSignaled = 0;
  1164. } else {
  1165. struct timeval tvNow;
  1166. struct timespec tsTimeout;
  1168. gettimeofday(&tvNow, NULL);
  1170. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1171. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1173. int iRetCode = 0;
  1175. while (!pED->iSignaled && (iRetCode != ETIMEDOUT)) {
  1176. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pED->Mtx);
  1178. iRetCode = pthread_cond_timedwait(&pED->WaitCond, &pED->Mtx, &tsTimeout);
  1180. pthread_cleanup_pop(0);
  1181. }
  1183. if (iRetCode == ETIMEDOUT) {
  1184. pthread_mutex_unlock(&pED->Mtx);
  1185. ErrSetErrorCode(ERR_TIMEOUT);
  1186. return (ERR_TIMEOUT);
  1187. }
  1189. if (!pED->iManualReset)
  1190. pED->iSignaled = 0;
  1192. }
  1194. pthread_mutex_unlock(&pED->Mtx);
  1196. return (0);
  1198. }
  1200. int SysSetEvent(SYS_EVENT hEvent)
  1201. {
  1203. EventData *pED = (EventData *) hEvent;
  1205. pthread_mutex_lock(&pED->Mtx);
  1207. pED->iSignaled = 1;
  1209. if (pED->iManualReset)
  1210. pthread_cond_broadcast(&pED->WaitCond);
  1211. else
  1212. pthread_cond_signal(&pED->WaitCond);
  1214. pthread_mutex_unlock(&pED->Mtx);
  1216. return (0);
  1218. }
  1220. int SysResetEvent(SYS_EVENT hEvent)
  1221. {
  1223. EventData *pED = (EventData *) hEvent;
  1225. pthread_mutex_lock(&pED->Mtx);
  1227. pED->iSignaled = 0;
  1229. pthread_mutex_unlock(&pED->Mtx);
  1231. return (0);
  1233. }
  1235. int SysTryWaitEvent(SYS_EVENT hEvent)
  1236. {
  1238. EventData *pED = (EventData *) hEvent;
  1240. pthread_mutex_lock(&pED->Mtx);
  1242. if (!pED->iSignaled) {
  1243. pthread_mutex_unlock(&pED->Mtx);
  1244. ErrSetErrorCode(ERR_TIMEOUT);
  1245. return (ERR_TIMEOUT);
  1246. }
  1248. if (!pED->iManualReset)
  1249. pED->iSignaled = 0;
  1251. pthread_mutex_unlock(&pED->Mtx);
  1253. return (0);
  1255. }
  1257. static int SysFreeThreadData(ThrData * pTD)
  1258. {
  1260. pthread_cond_destroy(&pTD->ExitWaitCond);
  1262. pthread_mutex_destroy(&pTD->Mtx);
  1264. SysFree(pTD);
  1266. return (0);
  1268. }
  1270. static void *SysThreadStartup(void *pThreadData)
  1271. {
  1273. ThrData *pTD = (ThrData *) pThreadData;
  1275. SysThreadSetup(pTD);
  1277. int iExitCode;
  1279. pthread_cleanup_push((void (*)(void *)) SysThreadCleanup, pTD);
  1281. pTD->iExitCode = iExitCode = SysStkCall(pTD->ThreadProc, pTD->pThreadData);
  1283. pthread_cleanup_pop(1);
  1285. return ((void *) iExitCode);
  1287. }
  1289. SYS_THREAD SysCreateThread(unsigned int (*pThreadProc) (void *), void *pThreadData)
  1290. {
  1292. ThrData *pTD = (ThrData *) SysAlloc(sizeof(ThrData));
  1294. if (pTD == NULL)
  1295. return (SYS_INVALID_THREAD);
  1297. pTD->ThreadProc = pThreadProc;
  1298. pTD->pThreadData = pThreadData;
  1299. pTD->iThreadEnded = 0;
  1300. pTD->iExitCode = -1;
  1301. pTD->iUseCount = 2;
  1303. if (pthread_mutex_init(&pTD->Mtx, NULL) != 0) {
  1304. SysFree(pTD);
  1306. ErrSetErrorCode(ERR_MUTEXINIT);
  1307. return (SYS_INVALID_THREAD);
  1308. }
  1310. if (pthread_cond_init(&pTD->ExitWaitCond, NULL) != 0) {
  1311. pthread_mutex_destroy(&pTD->Mtx);
  1312. SysFree(pTD);
  1314. ErrSetErrorCode(ERR_CONDINIT);
  1315. return (SYS_INVALID_THREAD);
  1316. }
  1318. pthread_attr_t ThrAttr;
  1320. pthread_attr_init(&ThrAttr);
  1322. pthread_attr_setscope(&ThrAttr, PTHREAD_SCOPE_SYSTEM);
  1324. if (pthread_create(&pTD->ThreadId, &ThrAttr, SysThreadStartup, pTD) != 0) {
  1325. pthread_attr_destroy(&ThrAttr);
  1326. pthread_cond_destroy(&pTD->ExitWaitCond);
  1327. pthread_mutex_destroy(&pTD->Mtx);
  1328. SysFree(pTD);
  1330. ErrSetErrorCode(ERR_THREADCREATE);
  1331. return (SYS_INVALID_THREAD);
  1332. }
  1334. pthread_attr_destroy(&ThrAttr);
  1336. return ((SYS_THREAD) pTD);
  1338. }
  1340. SYS_THREAD SysCreateServiceThread(unsigned int (*pThreadProc) (void *), SYS_SOCKET SockFD)
  1341. {
  1343. return (SysCreateThread(pThreadProc, (void *) SockFD));
  1345. }
  1347. static int SysThreadSetup(ThrData * pTD)
  1348. {
  1350. sigset_t SigMask;
  1352. sigemptyset(&SigMask);
  1353. sigaddset(&SigMask, SIGALRM);
  1354. sigaddset(&SigMask, SIGINT);
  1355. sigaddset(&SigMask, SIGHUP);
  1356. sigaddset(&SigMask, SIGSTOP);
  1357. sigaddset(&SigMask, SIGCHLD);
  1359. pthread_sigmask(SIG_BLOCK, &SigMask, NULL);
  1361. sigemptyset(&SigMask);
  1362. sigaddset(&SigMask, SIGQUIT);
  1364. pthread_sigmask(SIG_UNBLOCK, &SigMask, NULL);
  1366. SysSetSignal(SIGQUIT, SysIgnoreProc);
  1368. SysSetSignal(SIGPIPE, SysIgnoreProc);
  1370. SysSetSignal(SIGCHLD, SysIgnoreProc);
  1372. if (pTD != NULL) {
  1374. }
  1376. return (0);
  1378. }
  1380. static void SysThreadCleanup(ThrData * pTD)
  1381. {
  1383. if (pTD != NULL) {
  1384. pthread_mutex_lock(&pTD->Mtx);
  1386. pTD->iThreadEnded = 1;
  1388. pthread_cond_broadcast(&pTD->ExitWaitCond);
  1390. if (--pTD->iUseCount == 0) {
  1391. pthread_mutex_unlock(&pTD->Mtx);
  1393. SysFreeThreadData(pTD);
  1394. } else
  1395. pthread_mutex_unlock(&pTD->Mtx);
  1396. }
  1398. }
  1400. void SysCloseThread(SYS_THREAD ThreadID, int iForce)
  1401. {
  1403. ThrData *pTD = (ThrData *) ThreadID;
  1405. pthread_mutex_lock(&pTD->Mtx);
  1407. pthread_detach(pTD->ThreadId);
  1409. if (iForce && !pTD->iThreadEnded)
  1410. pthread_cancel(pTD->ThreadId);
  1412. if (--pTD->iUseCount == 0) {
  1413. pthread_mutex_unlock(&pTD->Mtx);
  1415. SysFreeThreadData(pTD);
  1416. } else
  1417. pthread_mutex_unlock(&pTD->Mtx);
  1419. }
  1421. int SysSetThreadPriority(SYS_THREAD ThreadID, int iPriority)
  1422. {
  1424. ThrData *pTD = (ThrData *) ThreadID;
  1425. int iPolicy;
  1426. struct sched_param SchParam;
  1428. if (pthread_getschedparam(pTD->ThreadId, &iPolicy, &SchParam) != 0) {
  1429. ErrSetErrorCode(ERR_SET_THREAD_PRIORITY);
  1430. return (ERR_SET_THREAD_PRIORITY);
  1431. }
  1433. int iMinPriority = sched_get_priority_min(iPolicy),
  1434. iMaxPriority = sched_get_priority_max(iPolicy),
  1435. iStdPriority = (iMinPriority + iMaxPriority) / 2;
  1437. switch (iPriority) {
  1438. case (SYS_PRIORITY_NORMAL):
  1439. SchParam.sched_priority = iStdPriority;
  1440. break;
  1442. case (SYS_PRIORITY_LOWER):
  1443. SchParam.sched_priority = iStdPriority - (iStdPriority - iMinPriority) / 3;
  1444. break;
  1446. case (SYS_PRIORITY_HIGHER):
  1447. SchParam.sched_priority = iStdPriority + (iStdPriority - iMinPriority) / 3;
  1448. break;
  1449. }
  1451. if (pthread_setschedparam(pTD->ThreadId, iPolicy, &SchParam) != 0) {
  1452. ErrSetErrorCode(ERR_SET_THREAD_PRIORITY);
  1453. return (ERR_SET_THREAD_PRIORITY);
  1454. }
  1456. return (0);
  1458. }
  1460. int SysWaitThread(SYS_THREAD ThreadID, int iTimeout)
  1461. {
  1463. ThrData *pTD = (ThrData *) ThreadID;
  1465. pthread_mutex_lock(&pTD->Mtx);
  1467. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1469. while (!pTD->iThreadEnded) {
  1470. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pTD->Mtx);
  1472. pthread_cond_wait(&pTD->ExitWaitCond, &pTD->Mtx);
  1474. pthread_cleanup_pop(0);
  1475. }
  1477. } else {
  1478. struct timeval tvNow;
  1479. struct timespec tsTimeout;
  1481. gettimeofday(&tvNow, NULL);
  1483. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1484. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1486. int iRetCode = 0;
  1488. while (!pTD->iThreadEnded && (iRetCode != ETIMEDOUT)) {
  1489. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pTD->Mtx);
  1491. iRetCode =
  1492. pthread_cond_timedwait(&pTD->ExitWaitCond, &pTD->Mtx, &tsTimeout);
  1494. pthread_cleanup_pop(0);
  1495. }
  1497. if (iRetCode == ETIMEDOUT) {
  1498. pthread_mutex_unlock(&pTD->Mtx);
  1500. ErrSetErrorCode(ERR_TIMEOUT);
  1501. return (ERR_TIMEOUT);
  1502. }
  1504. }
  1506. pthread_mutex_unlock(&pTD->Mtx);
  1508. return (0);
  1510. }
  1512. unsigned long SysGetCurrentThreadId(void)
  1513. {
  1515. return ((unsigned long) pthread_self());
  1517. }
  1519. static int SysSafeMsSleep(int iMsTimeout)
  1520. {
  1522. struct pollfd Dummy;
  1524. ZeroData(Dummy);
  1526. return ((poll(&Dummy, 0, iMsTimeout) == 0) ? 1 : 0);
  1528. }
  1530. static int SysWaitPID(pid_t PID, int *piExitCode, int iTimeout)
  1531. {
  1533. pid_t ExitPID;
  1534. int iExitStatus;
  1535. int iStatus;
  1537. iTimeout *= 1000;
  1538. do {
  1539. if ((ExitPID = (pid_t) waitpid(PID, &iStatus, WNOHANG)) == PID) {
  1540. if (!WIFEXITED(iStatus))
  1541. return (ERR_WAITPID);
  1543. iExitStatus = WEXITSTATUS(iStatus);
  1544. break;
  1545. }
  1547. SysSafeMsSleep(WAIT_PID_TIME_STEP);
  1548. iTimeout -= WAIT_PID_TIME_STEP;
  1550. } while (iTimeout > 0);
  1552. if (PID != ExitPID)
  1553. return (ERR_TIMEOUT);
  1555. if (piExitCode != NULL)
  1556. *piExitCode = iExitStatus;
  1558. return (0);
  1560. }
  1562. int SysExec(char const *pszCommand, char const *const *pszArgs, int iWaitTimeout,
  1563.     int iPriority, int *piExitStatus)
  1564. {
  1566. int iExitStatus;
  1567. pid_t ChildID;
  1568. pid_t ExitPID;
  1569. pid_t ProcessID;
  1570. int iPPipe[2];
  1571. int iCPipe[2];
  1573. if (pipe(iPPipe) == -1) {
  1574. ErrSetErrorCode(ERR_PIPE);
  1575. return (ERR_PIPE);
  1576. }
  1577. if (pipe(iCPipe) == -1) {
  1578. close(iPPipe[1]);
  1579. close(iPPipe[0]);
  1580. ErrSetErrorCode(ERR_PIPE);
  1581. return (ERR_PIPE);
  1582. }
  1584. ProcessID = fork();
  1585. if (ProcessID == 0) {
  1586. ChildID = fork();
  1587. if (ChildID == 0) {
  1588. close(iPPipe[1]);
  1589. close(iPPipe[0]);
  1591. ///////////////////////////////////////////////////////////////////////////////
  1592. //  Wait for the unlock from the parent
  1593. ///////////////////////////////////////////////////////////////////////////////
  1594. read(iCPipe[0], &ChildID, sizeof(ChildID));
  1596. close(iCPipe[1]);
  1597. close(iCPipe[0]);
  1599. ///////////////////////////////////////////////////////////////////////////////
  1600. //  Execute the command
  1601. ///////////////////////////////////////////////////////////////////////////////
  1602. execv(pszCommand, (char **) pszArgs);
  1604. ///////////////////////////////////////////////////////////////////////////////
  1605. //  We can only use async-signal safe functions, so we use write() directly
  1606. ///////////////////////////////////////////////////////////////////////////////
  1607. write(2, "execv error: cmd='", 18);
  1608. write(2, pszCommand, strlen(pszCommand));
  1609. write(2, "'n", 2);
  1611. _exit(WAIT_ERROR_EXIT_STATUS);
  1612. }
  1614. close(iCPipe[1]);
  1615. close(iCPipe[0]);
  1617. ///////////////////////////////////////////////////////////////////////////////
  1618. //  Tell the parent about the child-child PID
  1619. ///////////////////////////////////////////////////////////////////////////////
  1620. write(iPPipe[1], &ChildID, sizeof(ChildID));
  1622. close(iPPipe[1]);
  1623. close(iPPipe[0]);
  1625. if (ChildID == (pid_t) - 1)
  1626. _exit(WAIT_ERROR_EXIT_STATUS);
  1628. ///////////////////////////////////////////////////////////////////////////////
  1629. //  Wait for the child
  1630. ///////////////////////////////////////////////////////////////////////////////
  1631. iExitStatus = WAIT_TIMEO_EXIT_STATUS;
  1632. if (iWaitTimeout > 0)
  1633. SysWaitPID(ChildID, &iExitStatus, iWaitTimeout);
  1635. _exit(iExitStatus);
  1636. }
  1638. if ((ProcessID == (pid_t) - 1) ||
  1639.     (read(iPPipe[0], &ChildID, sizeof(ChildID)) != sizeof(ChildID))) {
  1640. close(iCPipe[1]);
  1641. close(iCPipe[0]);
  1642. close(iPPipe[1]);
  1643. close(iPPipe[0]);
  1644. ErrSetErrorCode(ERR_FORK);
  1645. return (ERR_FORK);
  1646. }
  1648. close(iPPipe[1]);
  1649. close(iPPipe[0]);
  1651. if (ChildID != (pid_t) - 1) {
  1652. ///////////////////////////////////////////////////////////////////////////////
  1653. //  Set process priority
  1654. ///////////////////////////////////////////////////////////////////////////////
  1655. switch (iPriority) {
  1656. case (SYS_PRIORITY_NORMAL):
  1657. setpriority(PRIO_PROCESS, ChildID, 0);
  1658. break;
  1660. case (SYS_PRIORITY_LOWER):
  1661. setpriority(PRIO_PROCESS, ChildID, SCHED_PRIORITY_INC);
  1662. break;
  1664. case (SYS_PRIORITY_HIGHER):
  1665. setpriority(PRIO_PROCESS, ChildID, -SCHED_PRIORITY_INC);
  1666. break;
  1667. }
  1669. ///////////////////////////////////////////////////////////////////////////////
  1670. //  Unlock the child
  1671. ///////////////////////////////////////////////////////////////////////////////
  1672. write(iCPipe[1], &ChildID, sizeof(ChildID));
  1673. }
  1675. close(iCPipe[1]);
  1676. close(iCPipe[0]);
  1678. ///////////////////////////////////////////////////////////////////////////////
  1679. //  Wait for completion (or timeout)
  1680. ///////////////////////////////////////////////////////////////////////////////
  1681. while (((ExitPID = (pid_t) waitpid(ProcessID, &iExitStatus, 0)) != ProcessID) &&
  1682.        (errno == EINTR));
  1684. if ((ExitPID == ProcessID) && WIFEXITED(iExitStatus))
  1685. iExitStatus = WEXITSTATUS(iExitStatus);
  1686. else
  1687. iExitStatus = WAIT_TIMEO_EXIT_STATUS;
  1689. if (iWaitTimeout > 0) {
  1690. if (iExitStatus == WAIT_TIMEO_EXIT_STATUS) {
  1691. ErrSetErrorCode(ERR_TIMEOUT);
  1692. return (ERR_TIMEOUT);
  1693. }
  1695. if (iExitStatus == WAIT_ERROR_EXIT_STATUS) {
  1696. ErrSetErrorCode(ERR_FORK);
  1697. return (ERR_FORK);
  1698. }
  1699. } else
  1700. iExitStatus = -1;
  1702. if (piExitStatus != NULL)
  1703. *piExitStatus = iExitStatus;
  1705. return (0);
  1707. }
  1709. static void SysBreakHandlerRoutine(int iSignal)
  1710. {
  1712. if (SysBreakHandler != NULL)
  1713. SysBreakHandler();
  1715. SysSetSignal(iSignal, SysBreakHandlerRoutine);
  1717. }
  1719. void SysSetBreakHandler(void (*BreakHandler) (void))
  1720. {
  1722. SysBreakHandler = BreakHandler;
  1724. ///////////////////////////////////////////////////////////////////////////////
  1725. //  Setup signal handlers and enable signals
  1726. ///////////////////////////////////////////////////////////////////////////////
  1727. SysSetSignal(SIGINT, SysBreakHandlerRoutine);
  1728. SysSetSignal(SIGHUP, SysBreakHandlerRoutine);
  1730. sigset_t SigMask;
  1732. sigemptyset(&SigMask);
  1733. sigaddset(&SigMask, SIGINT);
  1734. sigaddset(&SigMask, SIGHUP);
  1736. pthread_sigmask(SIG_UNBLOCK, &SigMask, NULL);
  1738. }
  1740. int SysCreateTlsKey(SYS_TLSKEY & TlsKey, void (*pFreeProc) (void *))
  1741. {
  1743. if (pthread_key_create(&TlsKey, pFreeProc) != 0) {
  1744. ErrSetErrorCode(ERR_NOMORE_TLSKEYS);
  1745. return (ERR_NOMORE_TLSKEYS);
  1746. }
  1748. return (0);
  1750. }
  1752. int SysDeleteTlsKey(SYS_TLSKEY & TlsKey)
  1753. {
  1755. pthread_key_delete(TlsKey);
  1757. return (0);
  1759. }
  1761. int SysSetTlsKeyData(SYS_TLSKEY & TlsKey, void *pData)
  1762. {
  1764. if (pthread_setspecific(TlsKey, pData) != 0) {
  1765. ErrSetErrorCode(ERR_INVALID_TLSKEY);
  1766. return (ERR_INVALID_TLSKEY);
  1767. }
  1769. return (0);
  1771. }
  1773. void *SysGetTlsKeyData(SYS_TLSKEY & TlsKey)
  1774. {
  1776. return (pthread_getspecific(TlsKey));
  1778. }
  1780. void SysThreadOnce(SYS_THREAD_ONCE * pThrOnce, void (*pOnceProc) (void))
  1781. {
  1783. pthread_once(pThrOnce, pOnceProc);
  1785. }
  1787. void *SysAlloc(unsigned int uSize)
  1788. {
  1790. void *pData = malloc(uSize);
  1792. if (pData != NULL)
  1793. memset(pData, 0, uSize);
  1794. else
  1795. ErrSetErrorCode(ERR_MEMORY);
  1797. return (pData);
  1799. }
  1801. void SysFree(void *pData)
  1802. {
  1804. free(pData);
  1806. }
  1808. void *SysRealloc(void *pData, unsigned int uSize)
  1809. {
  1811. void *pNewData = realloc(pData, uSize);
  1813. if (pNewData == NULL)
  1814. ErrSetErrorCode(ERR_MEMORY);
  1816. return (pNewData);
  1818. }
  1820. int SysLockFile(const char *pszFileName, char const *pszLockExt)
  1821. {
  1823. char szLockFile[SYS_MAX_PATH] = "";
  1825. snprintf(szLockFile, sizeof(szLockFile) - 1, "%s%s", pszFileName, pszLockExt);
  1827. int iFileID = open(szLockFile, O_CREAT | O_EXCL | O_RDWR, S_IREAD | S_IWRITE);
  1829. if (iFileID == -1) {
  1830. ErrSetErrorCode(ERR_LOCKED);
  1831. return (ERR_LOCKED);
  1832. }
  1834. char szLock[128] = "";
  1836. sprintf(szLock, "%lu", (unsigned long) SysGetCurrentThreadId());
  1838. write(iFileID, szLock, strlen(szLock) + 1);
  1840. close(iFileID);
  1842. return (0);
  1844. }
  1846. int SysUnlockFile(const char *pszFileName, char const *pszLockExt)
  1847. {
  1849. char szLockFile[SYS_MAX_PATH] = "";
  1851. snprintf(szLockFile, sizeof(szLockFile) - 1, "%s%s", pszFileName, pszLockExt);
  1853. if (unlink(szLockFile) != 0) {
  1854. ErrSetErrorCode(ERR_NOT_LOCKED);
  1855. return (ERR_NOT_LOCKED);
  1856. }
  1858. return (0);
  1860. }
  1862. SYS_HANDLE SysOpenModule(char const *pszFilePath)
  1863. {
  1865. void *pModule = dlopen(pszFilePath, RTLD_LAZY);
  1867. if (pModule == NULL) {
  1868. ErrSetErrorCode(ERR_LOADMODULE, pszFilePath);
  1869. return (SYS_INVALID_HANDLE);
  1870. }
  1872. return ((SYS_HANDLE) pModule);
  1874. }
  1876. int SysCloseModule(SYS_HANDLE hModule)
  1877. {
  1879. dlclose((void *) hModule);
  1881. return (0);
  1883. }
  1885. void *SysGetSymbol(SYS_HANDLE hModule, char const *pszSymbol)
  1886. {
  1888. void *pSymbol = dlsym((void *) hModule, pszSymbol);
  1890. if (pSymbol == NULL) {
  1891. ErrSetErrorCode(ERR_LOADMODULESYMBOL, pszSymbol);
  1892. return (NULL);
  1893. }
  1895. return (pSymbol);
  1897. }
  1899. int SysEventLogV(int iLogLevel, char const *pszFormat, va_list Args)
  1900. {
  1902. openlog(APP_NAME_STR, LOG_PID, LOG_DAEMON);
  1904. char szBuffer[2048] = "";
  1906. vsnprintf(szBuffer, sizeof(szBuffer) - 1, pszFormat, Args);
  1908. syslog(LOG_DAEMON | LOG_ERR, "%s", szBuffer);
  1910. closelog();
  1912. return (0);
  1914. }
  1916. int SysEventLog(int iLogLevel, char const *pszFormat, ...)
  1917. {
  1919. va_list Args;
  1921. va_start(Args, pszFormat);
  1923. int iLogResult = SysEventLogV(iLogLevel, pszFormat, Args);
  1925. va_end(Args);
  1927. return (0);
  1929. }
  1931. int SysLogMessage(int iLogLevel, char const *pszFormat, ...)
  1932. {
  1934. extern bool bServerDebug;
  1936. pthread_mutex_lock(&LogMutex);
  1938. va_list Args;
  1940. va_start(Args, pszFormat);
  1942. if (bServerDebug) {
  1943. ///////////////////////////////////////////////////////////////////////////////
  1944. //  Debug implementation
  1945. ///////////////////////////////////////////////////////////////////////////////
  1947. vprintf(pszFormat, Args);
  1949. } else {
  1950. switch (iLogLevel) {
  1951. case (LOG_LEV_WARNING):
  1952. case (LOG_LEV_ERROR):
  1954. SysEventLogV(iLogLevel, pszFormat, Args);
  1956. break;
  1957. }
  1958. }
  1960. va_end(Args);
  1962. pthread_mutex_unlock(&LogMutex);
  1964. return (0);
  1966. }
  1968. void SysSleep(int iTimeout)
  1969. {
  1971. SysMsSleep(iTimeout * 1000);
  1973. }
  1975. static int SysSetupWait(WaitData * pWD)
  1976. {
  1978. if (pthread_mutex_init(&pWD->Mtx, NULL) != 0) {
  1979. ErrSetErrorCode(ERR_MUTEXINIT);
  1980. return (ERR_MUTEXINIT);
  1981. }
  1983. if (pthread_cond_init(&pWD->WaitCond, NULL) != 0) {
  1984. pthread_mutex_destroy(&pWD->Mtx);
  1985. ErrSetErrorCode(ERR_CONDINIT);
  1986. return (ERR_CONDINIT);
  1987. }
  1989. return (0);
  1991. }
  1993. static int SysWait(WaitData * pWD, int iMsTimeout)
  1994. {
  1995. struct timespec TV;
  1996. struct timeval TmNow;
  1997. int iErrorCode;
  1999. gettimeofday(&TmNow, NULL);
  2001. TmNow.tv_sec += iMsTimeout / 1000;
  2002. TmNow.tv_usec += (iMsTimeout % 1000) * 1000;
  2003. TmNow.tv_sec += TmNow.tv_usec / 1000000;
  2004. TmNow.tv_usec %= 1000000;
  2006. TV.tv_sec = TmNow.tv_sec;
  2007. TV.tv_nsec = TmNow.tv_usec * 1000;
  2009. pthread_mutex_lock(&pWD->Mtx);
  2010. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pWD->Mtx);
  2012. iErrorCode = pthread_cond_timedwait(&pWD->WaitCond, &pWD->Mtx, &TV);
  2014. pthread_cleanup_pop(1);
  2016. if (iErrorCode == ETIMEDOUT) {
  2017. ErrSetErrorCode(ERR_TIMEOUT);
  2018. return (ERR_TIMEOUT);
  2019. }
  2021. return (0);
  2023. }
  2025. static void SysCleanupWait(WaitData * pWD)
  2026. {
  2028. pthread_mutex_destroy(&pWD->Mtx);
  2029. pthread_cond_destroy(&pWD->WaitCond);
  2031. }
  2033. void SysMsSleep(int iMsTimeout)
  2034. {
  2036. WaitData WD;
  2038. if (SysSetupWait(&WD) == 0) {
  2039. SysWait(&WD, iMsTimeout);
  2040. SysCleanupWait(&WD);
  2041. }
  2043. }
  2045. SYS_INT64 SysMsTime(void)
  2046. {
  2048. struct timeval tv;
  2050. if (gettimeofday(&tv, NULL) != 0)
  2051. return (0);
  2053. return (1000 * (SYS_INT64) tv.tv_sec + (SYS_INT64) tv.tv_usec / 1000);
  2055. }
  2057. int SysExistFile(const char *pszFilePath)
  2058. {
  2060. struct stat FS;
  2062. if (stat(pszFilePath, &FS) != 0)
  2063. return (0);
  2065. return ((S_ISDIR(FS.st_mode)) ? 0 : 1);
  2067. }
  2069. int SysExistDir(const char *pszDirPath)
  2070. {
  2072. struct stat FS;
  2074. if (stat(pszDirPath, &FS) != 0)
  2075. return (0);
  2077. return ((S_ISDIR(FS.st_mode)) ? 1 : 0);
  2079. }
  2081. SYS_HANDLE SysFirstFile(const char *pszPath, char *pszFileName)
  2082. {
  2084. DIR *pDIR = opendir(pszPath);
  2086. if (pDIR == NULL) {
  2087. ErrSetErrorCode(ERR_OPENDIR);
  2088. return (SYS_INVALID_HANDLE);
  2089. }
  2091. FilledDirent FDE;
  2092. struct dirent *pDirEntry = NULL;
  2094. #if (_POSIX_C_SOURCE - 0 >= 199506L) || defined(_POSIX_PTHREAD_SEMANTICS)
  2096. readdir_r(pDIR, &FDE.DE, &pDirEntry);
  2098. #else // #if (_POSIX_C_SOURCE - 0 >= 199506L) || ...
  2100. pDirEntry = readdir_r(pDIR, &FDE.DE);
  2102. #endif // #if (_POSIX_C_SOURCE - 0 >= 199506L) || ...
  2104. if (pDirEntry == NULL) {
  2105. closedir(pDIR);
  2106. return (SYS_INVALID_HANDLE);
  2107. }
  2109. FileFindData *pFFD = (FileFindData *) SysAlloc(sizeof(FileFindData));
  2111. if (pFFD == NULL) {
  2112. closedir(pDIR);
  2113. return (SYS_INVALID_HANDLE);
  2114. }
  2116. strcpy(pFFD->szPath, pszPath);
  2117. AppendSlash(pFFD->szPath);
  2118. pFFD->pDIR = pDIR;
  2119. pFFD->FDE = FDE;
  2121. strcpy(pszFileName, pFFD->FDE.DE.d_name);
  2123. char szFilePath[SYS_MAX_PATH] = "";
  2125. snprintf(szFilePath, sizeof(szFilePath) - 1, "%s%s", pFFD->szPath, pFFD->FDE.DE.d_name);
  2127. if (stat(szFilePath, &pFFD->FS) != 0) {
  2128. SysFree(pFFD);
  2129. closedir(pDIR);
  2131. ErrSetErrorCode(ERR_STAT);
  2132. return (SYS_INVALID_HANDLE);
  2133. }
  2135. return ((SYS_HANDLE) pFFD);
  2137. }
  2139. int SysIsDirectory(SYS_HANDLE hFind)
  2140. {
  2142. FileFindData *pFFD = (FileFindData *) hFind;
  2144. return ((S_ISDIR(pFFD->FS.st_mode)) ? 1 : 0);
  2146. }
  2148. unsigned long SysGetSize(SYS_HANDLE hFind)
  2149. {
  2151. FileFindData *pFFD = (FileFindData *) hFind;
  2153. return ((unsigned long) pFFD->FS.st_size);
  2155. }
  2157. int SysNextFile(SYS_HANDLE hFind, char *pszFileName)
  2158. {
  2160. FileFindData *pFFD = (FileFindData *) hFind;
  2161. struct dirent *pDirEntry = NULL;
  2163. #if (_POSIX_C_SOURCE - 0 >= 199506L) || defined(_POSIX_PTHREAD_SEMANTICS)
  2165. readdir_r(pFFD->pDIR, &pFFD->FDE.DE, &pDirEntry);
  2167. #else // #if (_POSIX_C_SOURCE - 0 >= 199506L) || ...
  2169. pDirEntry = readdir_r(pFFD->pDIR, &pFFD->FDE.DE);
  2171. #endif // #if (_POSIX_C_SOURCE - 0 >= 199506L) || ...
  2173. if (pDirEntry == NULL)
  2174. return (0);
  2176. strcpy(pszFileName, pFFD->FDE.DE.d_name);
  2178. char szFilePath[SYS_MAX_PATH] = "";
  2180. snprintf(szFilePath, sizeof(szFilePath) - 1, "%s%s", pFFD->szPath, pFFD->FDE.DE.d_name);
  2182. if (stat(szFilePath, &pFFD->FS) != 0) {
  2183. ErrSetErrorCode(ERR_STAT);
  2184. return (0);
  2185. }
  2187. return (1);
  2189. }
  2191. void SysFindClose(SYS_HANDLE hFind)
  2192. {
  2194. FileFindData *pFFD = (FileFindData *) hFind;
  2196. closedir(pFFD->pDIR);
  2198. SysFree(pFFD);
  2200. }
  2202. int SysGetFileInfo(char const *pszFileName, SYS_FILE_INFO & FI)
  2203. {
  2205. struct stat stat_buffer;
  2207. if (stat(pszFileName, &stat_buffer) != 0) {
  2208. ErrSetErrorCode(ERR_STAT);
  2209. return (ERR_STAT);
  2210. }
  2212. ZeroData(FI);
  2213. FI.iFileType = (S_ISREG(stat_buffer.st_mode)) ? ftNormal :
  2214. ((S_ISDIR(stat_buffer.st_mode)) ? ftDirectory :
  2215.  ((S_ISLNK(stat_buffer.st_mode)) ? ftLink : ftOther));
  2216. FI.ulSize = (unsigned long) stat_buffer.st_size;
  2217. FI.tMod = stat_buffer.st_mtime;
  2219. return (0);
  2221. }
  2223. int SysSetFileModTime(char const *pszFileName, time_t tMod)
  2224. {
  2226. struct utimbuf TMB;
  2228. TMB.actime = tMod;
  2229. TMB.modtime = tMod;
  2231. if (utime(pszFileName, &TMB) != 0) {
  2232. ErrSetErrorCode(ERR_SET_FILE_TIME);
  2233. return (ERR_SET_FILE_TIME);
  2234. }
  2236. return (0);
  2238. }
  2240. char *SysStrDup(const char *pszString)
  2241. {
  2243. int iStrLength = strlen(pszString);
  2244. char *pszBuffer = (char *) SysAlloc(iStrLength + 1);
  2246. if (pszBuffer != NULL)
  2247. strcpy(pszBuffer, pszString);
  2249. return (pszBuffer);
  2251. }
  2253. char *SysGetEnv(const char *pszVarName)
  2254. {
  2256. const char *pszValue = getenv(pszVarName);
  2258. return ((pszValue != NULL) ? SysStrDup(pszValue) : NULL);
  2260. }
  2262. char *SysGetTmpFile(char *pszFileName)
  2263. {
  2265. static unsigned long ulFileSeqNr = 0;
  2266. unsigned long ulThreadID = SysGetCurrentThreadId();
  2268. sprintf(pszFileName, "/tmp/msrv%lx.%lx.tmp", ulThreadID, ulFileSeqNr++);
  2270. return (pszFileName);
  2272. }
  2274. int SysRemove(const char *pszFileName)
  2275. {
  2277. if (unlink(pszFileName) != 0) {
  2278. ErrSetErrorCode(ERR_FILE_DELETE);
  2279. return (ERR_FILE_DELETE);
  2280. }
  2282. return (0);
  2284. }
  2286. int SysMakeDir(const char *pszPath)
  2287. {
  2289. if (mkdir(pszPath, 0700) != 0) {
  2290. ErrSetErrorCode(ERR_DIR_CREATE);
  2291. return (ERR_DIR_CREATE);
  2292. }
  2294. return (0);
  2296. }
  2298. int SysRemoveDir(const char *pszPath)
  2299. {
  2301. if (rmdir(pszPath) != 0) {
  2302. ErrSetErrorCode(ERR_DIR_DELETE);
  2303. return (ERR_DIR_DELETE);
  2304. }
  2306. return (0);
  2308. }
  2310. int SysMoveFile(char const *pszOldName, char const *pszNewName)
  2311. {
  2313. if (rename(pszOldName, pszNewName) != 0) {
  2314. ErrSetErrorCode(ERR_FILE_MOVE);
  2315. return (ERR_FILE_MOVE);
  2316. }
  2318. return (0);
  2320. }
  2322. int SysVSNPrintf(char *pszBuffer, int iSize, char const *pszFormat, va_list Args)
  2323. {
  2325. int iPrintResult = vsnprintf(pszBuffer, iSize, pszFormat, Args);
  2327. return ((iPrintResult < iSize) ? iPrintResult : -1);
  2329. }
  2331. int SysFileSync(FILE * pFile)
  2332. {
  2334. if (fflush(pFile) || fsync(fileno(pFile))) {
  2335. ErrSetErrorCode(ERR_FILE_WRITE);
  2336. return (ERR_FILE_WRITE);
  2337. }
  2339. return (0);
  2341. }
  2343. char *SysStrTok(char *pszData, char const *pszDelim, char **ppszSavePtr)
  2344. {
  2346. return (strtok_r(pszData, pszDelim, ppszSavePtr));
  2348. }
  2350. char *SysCTime(time_t * pTimer, char *pszBuffer, int iBufferSize)
  2351. {
  2353. #if (_POSIX_C_SOURCE - 0 >= 199506L) || defined(_POSIX_PTHREAD_SEMANTICS)
  2355. return (ctime_r(pTimer, pszBuffer));
  2357. #else // #if (_POSIX_C_SOURCE - 0 >= 199506L) ||
  2359. return (ctime_r(pTimer, pszBuffer, iBufferSize));
  2361. #endif // #if (_POSIX_C_SOURCE - 0 >= 199506L) ||
  2362. }
  2364. struct tm *SysLocalTime(time_t * pTimer, struct tm *pTStruct)
  2365. {
  2367. return (localtime_r(pTimer, pTStruct));
  2369. }
  2371. struct tm *SysGMTime(time_t * pTimer, struct tm *pTStruct)
  2372. {
  2374. return (gmtime_r(pTimer, pTStruct));
  2376. }
  2378. char *SysAscTime(struct tm *pTStruct, char *pszBuffer, int iBufferSize)
  2379. {
  2381. #if (_POSIX_C_SOURCE - 0 >= 199506L) || defined(_POSIX_PTHREAD_SEMANTICS)
  2383. return (asctime_r(pTStruct, pszBuffer));
  2385. #else // #if (_POSIX_C_SOURCE - 0 >= 199506L) ||
  2387. return (asctime_r(pTStruct, pszBuffer, iBufferSize));
  2389. #endif // #if (_POSIX_C_SOURCE - 0 >= 199506L) ||
  2390. }
  2392. long SysGetTimeZone(void)
  2393. {
  2395. return ((long) timezone);
  2397. }
  2399. long SysGetDayLight(void)
  2400. {
  2402. time_t tCurr = time(NULL);
  2403. struct tm tmCurr;
  2405. localtime_r(&tCurr, &tmCurr);
  2407. return ((long) ((tmCurr.tm_isdst <= 0) ? 0 : 3600));
  2409. }
  2411. int SysGetDiskSpace(char const *pszPath, SYS_INT64 * pTotal, SYS_INT64 * pFree)
  2412. {
  2414. struct statvfs SFS;
  2416. if (statvfs(pszPath, &SFS) != 0) {
  2417. ErrSetErrorCode(ERR_GET_DISK_SPACE_INFO);
  2418. return (ERR_GET_DISK_SPACE_INFO);
  2419. }
  2421. *pTotal = (SYS_INT64) SFS.f_bsize * (SYS_INT64) SFS.f_blocks;
  2423. *pFree = (SYS_INT64) SFS.f_bsize * (SYS_INT64) SFS.f_bavail;
  2425. return (0);
  2427. }
  2429. int SysMemoryInfo(SYS_INT64 * pRamTotal, SYS_INT64 * pRamFree,
  2430.   SYS_INT64 * pVirtTotal, SYS_INT64 * pVirtFree)
  2431. {
  2433. SYS_INT64 SwapTotal;
  2434. SYS_INT64 SwapFree;
  2436. if (SysGetSwapInfo(&SwapTotal, &SwapFree) < 0) {
  2437. ErrSetErrorCode(ERR_GET_MEMORY_INFO);
  2438. return (ERR_GET_MEMORY_INFO);
  2439. }
  2441. SYS_INT64 PageSize = (SYS_INT64) sysconf(_SC_PAGESIZE);
  2443. *pRamTotal = (SYS_INT64) sysconf(_SC_PHYS_PAGES) * PageSize;
  2445. *pRamFree = (SYS_INT64) sysconf(_SC_AVPHYS_PAGES) * PageSize;
  2447. *pVirtTotal = SwapTotal + *pRamTotal;
  2449. *pVirtFree = SwapFree + *pRamFree;
  2451. return (0);
  2453. }
  2455. static int SysGetSwapInfo(SYS_INT64 * pSwapTotal, SYS_INT64 * pSwapFree)
  2456. {
  2458. *pSwapTotal = *pSwapFree = 0;
  2460. int iNumSwaps = swapctl(SC_GETNSWP, 0);
  2462. if (iNumSwaps == -1)
  2463. return (-1);
  2465. if (iNumSwaps == 0)
  2466. return (0);
  2468. swaptbl_t *pSwTab = (swaptbl_t *) malloc(iNumSwaps * sizeof(swapent_t) +
  2469.  sizeof(struct swaptable));
  2471. if (pSwTab == (void *) 0)
  2472. return (-1);
  2474. memset(pSwTab, 0, iNumSwaps * sizeof(swapent_t) + sizeof(struct swaptable));
  2476. char *pszNameTab = (char *) malloc(iNumSwaps * MAX_SWAP_NAME_SIZE);
  2478. if (pszNameTab == (void *) 0) {
  2479. free(pSwTab);
  2480. return (-1);
  2481. }
  2483. memset(pszNameTab, 0, iNumSwaps * MAX_SWAP_NAME_SIZE);
  2485. int ii;
  2487. for (ii = 0; ii < iNumSwaps; ii++)
  2488. pSwTab->swt_ent[ii].ste_path = pszNameTab + (ii * MAX_SWAP_NAME_SIZE);
  2490. pSwTab->swt_n = iNumSwaps;
  2492. if ((iNumSwaps = swapctl(SC_LIST, pSwTab)) < 0) {
  2493. free(pszNameTab);
  2494. free(pSwTab);
  2495. return (-1);
  2496. }
  2498. SYS_INT64 PageSize = (SYS_INT64) sysconf(_SC_PAGESIZE);
  2500. for (ii = 0; ii < iNumSwaps; ii++) {
  2501. *pSwapTotal += (SYS_INT64) pSwTab->swt_ent[ii].ste_pages * PageSize;
  2503. *pSwapFree += (SYS_INT64) pSwTab->swt_ent[ii].ste_free * PageSize;
  2504. }
  2506. free(pszNameTab);
  2507. free(pSwTab);
  2509. return (0);
  2511. }
  2513. static unsigned int SysStkCall(unsigned int (*pProc) (void *), void *pData)
  2514. {
  2516. srand(getpid() * (unsigned int) time(NULL) * uSRandBase);
  2518. unsigned int uResult;
  2519. unsigned int uStkDisp =
  2520. (unsigned int) (rand() % MAX_STACK_SHIFT) & ~(STACK_ALIGN_BYTES - 1);
  2521. void *pStkSpace = alloca(uStkDisp);
  2523. uResult = pProc(pData);
  2525. return (uResult);
  2527. }