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

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

Email服务器

开发平台：

Visual C++

SysDepLinux.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. ///////////////////////////////////////////////////////////////////////////////
  46. //  Uncomment this if You want to use sendfile()
  47. ///////////////////////////////////////////////////////////////////////////////
  48. #define USE_SENDFILE
  50. struct SemData {
  51. pthread_mutex_t Mtx;
  52. pthread_cond_t WaitCond;
  53. int iSemCounter;
  54. int iMaxCount;
  55. };
  57. struct MutexData {
  58. pthread_mutex_t Mtx;
  59. pthread_cond_t WaitCond;
  60. int iLocked;
  61. };
  63. struct EventData {
  64. pthread_mutex_t Mtx;
  65. pthread_cond_t WaitCond;
  66. int iSignaled;
  67. int iManualReset;
  68. };
  70. struct WaitData {
  71. pthread_mutex_t Mtx;
  72. pthread_cond_t WaitCond;
  73. };
  75. struct ThrData {
  76. pthread_t ThreadId;
  77. unsigned int (*ThreadProc) (void *);
  78. void *pThreadData;
  79. pthread_mutex_t Mtx;
  80. pthread_cond_t ExitWaitCond;
  81. int iThreadEnded;
  82. int iExitCode;
  83. int iUseCount;
  84. };
  86. struct FileFindData {
  87. char szPath[SYS_MAX_PATH];
  88. DIR *pDIR;
  89. struct dirent DE;
  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);
  102. static int SysSafeMsSleep(int iMsTimeout);
  103. static int SysWaitPID(pid_t PID, int *piExitCode, int iTimeout);
  104. static void SysBreakHandlerRoutine(int iSignal);
  105. static int SysSetupWait(WaitData * pWD);
  106. static int SysWait(WaitData * pWD, int iMsTimeout);
  107. static void SysCleanupWait(WaitData * pWD);
  108. static unsigned int SysStkCall(unsigned int (*pProc) (void *), void *pData);
  110. static volatile int iShutDown = 0;
  111. static unsigned int uSRandBase;
  112. static pthread_mutex_t LogMutex = PTHREAD_MUTEX_INITIALIZER;
  113. static void (*SysBreakHandler) (void) = NULL;
  114. static int iSndBufSize = -1, iRcvBufSize = -1;
  116. static int SysSetSignal(int iSigNo, void (*pSigProc) (int))
  117. {
  119. signal(iSigNo, pSigProc);
  121. return (0);
  123. }
  125. static char const *SysGetLastError(void)
  126. {
  128. static char szMessage[1024] = "";
  130. snprintf(szMessage, sizeof(szMessage) - 1, "(0x%lX) %s", (unsigned long) errno,
  131.  strerror(errno));
  133. return (szMessage);
  135. }
  137. static void SysIgnoreProc(int iSignal)
  138. {
  140. SysSetSignal(iSignal, SysIgnoreProc);
  142. }
  144. int SysInitLibrary(void)
  145. {
  147. iShutDown = 0;
  148. tzset();
  149. uSRandBase = (unsigned int) time(NULL);
  151. if (SysThreadSetup(NULL) < 0)
  152. return (ErrGetErrorCode());
  154. return (0);
  156. }
  158. void SysCleanupLibrary(void)
  159. {
  161. SysThreadCleanup(NULL);
  163. }
  165. int SysShutdownLibrary(int iMode)
  166. {
  168. iShutDown++;
  170. kill(0, SIGQUIT);
  172. return (0);
  174. }
  176. int SysSetupSocketBuffers(int *piSndBufSize, int *piRcvBufSize)
  177. {
  179. if (piSndBufSize != NULL)
  180. iSndBufSize = *piSndBufSize;
  182. if (piRcvBufSize != NULL)
  183. iRcvBufSize = *piRcvBufSize;
  185. return (0);
  187. }
  189. SYS_SOCKET SysCreateSocket(int iAddressFamily, int iType, int iProtocol)
  190. {
  192. int SockFD = socket(AF_INET, iType, iProtocol);
  194. if (SockFD == -1) {
  195. ErrSetErrorCode(ERR_SOCKET_CREATE);
  196. return (SYS_INVALID_SOCKET);
  197. }
  199. if (SysSetSocketsOptions((SYS_SOCKET) SockFD) < 0) {
  200. SysCloseSocket((SYS_SOCKET) SockFD);
  202. return (SYS_INVALID_SOCKET);
  203. }
  205. return ((SYS_SOCKET) SockFD);
  207. }
  209. static int SysSetSockNoDelay(SYS_SOCKET SockFD, int iNoDelay)
  210. {
  212. long lSockFlags = fcntl((int) SockFD, F_GETFL, 0);
  214. if (lSockFlags == -1) {
  215. ErrSetErrorCode(ERR_NETWORK);
  216. return (ERR_NETWORK);
  217. }
  219. if (iNoDelay)
  220. lSockFlags |= O_NONBLOCK;
  221. else
  222. lSockFlags &= ~O_NONBLOCK;
  224. if (fcntl((int) SockFD, F_SETFL, lSockFlags) == -1) {
  225. ErrSetErrorCode(ERR_NETWORK);
  226. return (ERR_NETWORK);
  227. }
  229. return (0);
  231. }
  233. static int SysSetSocketsOptions(SYS_SOCKET SockFD)
  234. {
  235. ///////////////////////////////////////////////////////////////////////////////
  236. //  Set socket buffer sizes
  237. ///////////////////////////////////////////////////////////////////////////////
  238. if (iSndBufSize > 0) {
  239. int iSize = iSndBufSize;
  241. setsockopt((int) SockFD, SOL_SOCKET, SO_SNDBUF, (const char *) &iSize,
  242.    sizeof(iSize));
  243. }
  245. if (iRcvBufSize > 0) {
  246. int iSize = iRcvBufSize;
  248. setsockopt((int) SockFD, SOL_SOCKET, SO_RCVBUF, (const char *) &iSize,
  249.    sizeof(iSize));
  250. }
  252. int iActivate = 1;
  254. if (setsockopt(SockFD, SOL_SOCKET, SO_REUSEADDR, (const char *) &iActivate,
  255.        sizeof(iActivate)) != 0) {
  256. ErrSetErrorCode(ERR_SETSOCKOPT);
  257. return (ERR_SETSOCKOPT);
  258. }
  259. ///////////////////////////////////////////////////////////////////////////////
  260. //  Disable linger
  261. ///////////////////////////////////////////////////////////////////////////////
  262. struct linger Ling;
  264. ZeroData(Ling);
  265. Ling.l_onoff = 0;
  266. Ling.l_linger = 0;
  268. setsockopt(SockFD, SOL_SOCKET, SO_LINGER, (const char *) &Ling, sizeof(Ling));
  270. ///////////////////////////////////////////////////////////////////////////////
  271. //  Set KEEPALIVE if supported
  272. ///////////////////////////////////////////////////////////////////////////////
  273. setsockopt(SockFD, SOL_SOCKET, SO_KEEPALIVE, (const char *) &iActivate,
  274.    sizeof(iActivate));
  276. return (0);
  278. }
  280. void SysCloseSocket(SYS_SOCKET SockFD)
  281. {
  283. close(SockFD);
  285. }
  287. int SysBindSocket(SYS_SOCKET SockFD, const struct sockaddr *SockName, int iNameLen)
  288. {
  290. if (bind((int) SockFD, SockName, iNameLen) == -1) {
  291. ErrSetErrorCode(ERR_SOCKET_BIND);
  292. return (ERR_SOCKET_BIND);
  293. }
  295. return (0);
  297. }
  299. void SysListenSocket(SYS_SOCKET SockFD, int iConnections)
  300. {
  302. listen((int) SockFD, iConnections);
  304. }
  306. int SysRecvData(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize, int iTimeout)
  307. {
  309. struct pollfd pfds;
  311. ZeroData(pfds);
  312. pfds.fd = (int) SockFD;
  313. pfds.events = POLLIN;
  315. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  317. if (iPollResult == -1) {
  318. ErrSetErrorCode(ERR_NETWORK);
  319. return (ERR_NETWORK);
  320. }
  322. if (iPollResult == 0) {
  323. ErrSetErrorCode(ERR_TIMEOUT);
  324. return (ERR_TIMEOUT);
  325. }
  327. int iRecvBytes;
  329. while (((iRecvBytes = recv((int) SockFD, pszBuffer, iBufferSize, 0)) == -1) &&
  330.        SYS_INT_CALL());
  332. if (iRecvBytes == -1) {
  333. ErrSetErrorCode(ERR_NETWORK);
  334. return (ERR_NETWORK);
  335. }
  337. return (iRecvBytes);
  339. }
  341. int SysRecv(SYS_SOCKET SockFD, char *pszBuffer, int iBufferSize, int iTimeout)
  342. {
  344. int iRtxBytes = 0;
  346. while (iRtxBytes < iBufferSize) {
  347. int iRtxCurrent = SysRecvData(SockFD, pszBuffer + iRtxBytes,
  348.       iBufferSize - iRtxBytes, iTimeout);
  350. if (iRtxCurrent <= 0)
  351. return (iRtxBytes);
  353. iRtxBytes += iRtxCurrent;
  354. }
  356. return (iRtxBytes);
  358. }
  360. int SysRecvDataFrom(SYS_SOCKET SockFD, struct sockaddr *pFrom, int iFromlen,
  361.     char *pszBuffer, int iBufferSize, int iTimeout)
  362. {
  364. struct pollfd pfds;
  366. ZeroData(pfds);
  367. pfds.fd = (int) SockFD;
  368. pfds.events = POLLIN;
  370. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  372. if (iPollResult == -1) {
  373. ErrSetErrorCode(ERR_NETWORK);
  374. return (ERR_NETWORK);
  375. }
  377. if (iPollResult == 0) {
  378. ErrSetErrorCode(ERR_TIMEOUT);
  379. return (ERR_TIMEOUT);
  380. }
  382. socklen_t SockALen = (socklen_t) iFromlen;
  383. int iRecvBytes;
  385. while (((iRecvBytes = recvfrom((int) SockFD, pszBuffer, iBufferSize, 0,
  386.        pFrom, &SockALen)) == -1) && SYS_INT_CALL());
  388. if (iRecvBytes == -1) {
  389. ErrSetErrorCode(ERR_NETWORK);
  390. return (ERR_NETWORK);
  391. }
  393. return (iRecvBytes);
  395. }
  397. int SysSendData(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize, int iTimeout)
  398. {
  400. struct pollfd pfds;
  402. ZeroData(pfds);
  403. pfds.fd = (int) SockFD;
  404. pfds.events = POLLOUT;
  406. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  408. if (iPollResult == -1) {
  409. ErrSetErrorCode(ERR_NETWORK);
  410. return (ERR_NETWORK);
  411. }
  413. if (iPollResult == 0) {
  414. ErrSetErrorCode(ERR_TIMEOUT);
  415. return (ERR_TIMEOUT);
  416. }
  418. int iSendBytes;
  420. while (((iSendBytes = send((int) SockFD, pszBuffer, iBufferSize, 0)) == -1) &&
  421.        SYS_INT_CALL());
  423. if (iSendBytes == -1) {
  424. ErrSetErrorCode(ERR_NETWORK);
  425. return (ERR_NETWORK);
  426. }
  428. return (iSendBytes);
  430. }
  432. int SysSend(SYS_SOCKET SockFD, char const *pszBuffer, int iBufferSize, int iTimeout)
  433. {
  435. int iRtxBytes = 0;
  437. while (iRtxBytes < iBufferSize) {
  438. int iRtxCurrent = SysSendData(SockFD, pszBuffer + iRtxBytes,
  439.       iBufferSize - iRtxBytes, iTimeout);
  441. if (iRtxCurrent <= 0)
  442. return (iRtxBytes);
  444. iRtxBytes += iRtxCurrent;
  445. }
  447. return (iRtxBytes);
  449. }
  451. int SysSendDataTo(SYS_SOCKET SockFD, const struct sockaddr *pTo,
  452.   int iToLen, char const *pszBuffer, int iBufferSize, int iTimeout)
  453. {
  455. struct pollfd pfds;
  457. ZeroData(pfds);
  458. pfds.fd = (int) SockFD;
  459. pfds.events = POLLOUT;
  461. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  463. if (iPollResult == -1) {
  464. ErrSetErrorCode(ERR_NETWORK);
  465. return (ERR_NETWORK);
  466. }
  468. if (iPollResult == 0) {
  469. ErrSetErrorCode(ERR_TIMEOUT);
  470. return (ERR_TIMEOUT);
  471. }
  473. int iSendBytes;
  475. while (((iSendBytes = sendto((int) SockFD, pszBuffer, iBufferSize, 0, pTo, iToLen)) == -1)
  476.        && SYS_INT_CALL());
  478. if (iSendBytes == -1) {
  479. ErrSetErrorCode(ERR_NETWORK);
  480. return (ERR_NETWORK);
  481. }
  483. return (iSendBytes);
  485. }
  487. int SysConnect(SYS_SOCKET SockFD, const SYS_INET_ADDR * pSockName, int iNameLen, int iTimeout)
  488. {
  490. if (SysSetSockNoDelay(SockFD, 1) < 0)
  491. return (ErrGetErrorCode());
  493. if (connect((int) SockFD, (const struct sockaddr *) &pSockName->Addr, iNameLen) == 0) {
  494. SysSetSockNoDelay(SockFD, 0);
  495. return (0);
  496. }
  498. if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK)) {
  499. SysSetSockNoDelay(SockFD, 0);
  501. ErrSetErrorCode(ERR_NETWORK);
  502. return (ERR_NETWORK);
  503. }
  505. struct pollfd pfds;
  507. ZeroData(pfds);
  508. pfds.fd = (int) SockFD;
  509. pfds.events = POLLOUT;
  511. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  513. SysSetSockNoDelay(SockFD, 0);
  515. if (iPollResult == -1) {
  516. ErrSetErrorCode(ERR_NETWORK);
  517. return (ERR_NETWORK);
  518. }
  520. if (iPollResult == 0) {
  521. ErrSetErrorCode(ERR_TIMEOUT);
  522. return (ERR_TIMEOUT);
  523. }
  525. return (0);
  527. }
  529. SYS_SOCKET SysAccept(SYS_SOCKET SockFD, SYS_INET_ADDR * pSockName, int *iNameLen, int iTimeout)
  530. {
  532. struct pollfd pfds;
  534. ZeroData(pfds);
  535. pfds.fd = (int) SockFD;
  536. pfds.events = POLLIN;
  538. int iPollResult = poll(&pfds, 1, iTimeout * 1000);
  540. if (iPollResult == -1) {
  541. ErrSetErrorCode(ERR_NETWORK);
  542. return (SYS_INVALID_SOCKET);
  543. }
  545. if (iPollResult == 0) {
  546. ErrSetErrorCode(ERR_TIMEOUT);
  547. return (SYS_INVALID_SOCKET);
  548. }
  550. socklen_t SockALen = (socklen_t) * iNameLen;
  551. int iAcptSock = accept((int) SockFD,
  552.        (struct sockaddr *) &pSockName->Addr, &SockALen);
  554. if (iAcptSock == -1) {
  555. ErrSetErrorCode(ERR_NETWORK);
  556. return (SYS_INVALID_SOCKET);
  557. }
  559. if (SysSetSocketsOptions((SYS_SOCKET) iAcptSock) < 0) {
  560. SysCloseSocket((SYS_SOCKET) iAcptSock);
  562. return (SYS_INVALID_SOCKET);
  563. }
  565. *iNameLen = (int) SockALen;
  567. return ((SYS_SOCKET) iAcptSock);
  569. }
  571. int SysSelect(int iMaxFD, SYS_fd_set * pReadFDs, SYS_fd_set * pWriteFDs, SYS_fd_set * pExcptFDs,
  572.       int iTimeout)
  573. {
  575. struct timeval TV;
  577. ZeroData(TV);
  578. TV.tv_sec = iTimeout;
  579. TV.tv_usec = 0;
  581. int iSelectResult = select(iMaxFD + 1, pReadFDs, pWriteFDs, pExcptFDs, &TV);
  583. if (iSelectResult == -1) {
  584. ErrSetErrorCode(ERR_SELECT);
  585. return (ERR_SELECT);
  586. }
  588. if (iSelectResult == 0) {
  589. ErrSetErrorCode(ERR_TIMEOUT);
  590. return (ERR_TIMEOUT);
  591. }
  593. return (iSelectResult);
  595. }
  597. int SysSendFile(SYS_SOCKET SockFD, char const *pszFileName, unsigned long ulBaseOffset,
  598. unsigned long ulEndOffset, int iTimeout)
  599. {
  601. int iFileID = open(pszFileName, O_RDONLY);
  603. if (iFileID == -1) {
  604. ErrSetErrorCode(ERR_FILE_OPEN, pszFileName);
  605. return (ERR_FILE_OPEN);
  606. }
  608. unsigned long ulFileSize = (unsigned long) lseek(iFileID, 0, SEEK_END);
  610. lseek(iFileID, 0, SEEK_SET);
  612. #ifdef USE_SENDFILE
  613. ///////////////////////////////////////////////////////////////////////////////
  614. //  Set send timeout
  615. ///////////////////////////////////////////////////////////////////////////////
  616. socklen_t OptLenght = sizeof(struct timeval);
  617. struct timeval oldTV;
  618. struct timeval newTV;
  620. if (getsockopt((int) SockFD, SOL_SOCKET, SO_SNDTIMEO, &oldTV, &OptLenght)) {
  621. close(iFileID);
  622. ErrSetErrorCode(ERR_GETSOCKOPT);
  623. return (ERR_GETSOCKOPT);
  624. }
  626. newTV.tv_sec = iTimeout;
  627. newTV.tv_usec = 0;
  628. setsockopt((int) SockFD, SOL_SOCKET, SO_SNDTIMEO, &newTV, sizeof(newTV));
  630. ///////////////////////////////////////////////////////////////////////////////
  631. //  Send the file
  632. ///////////////////////////////////////////////////////////////////////////////
  633. unsigned long ulSndBuffSize = MIN_TCP_SEND_SIZE;
  634. unsigned long ulCurrOffset = ulBaseOffset;
  635. unsigned long ulSndEndOffset =
  636.     (ulEndOffset != (unsigned long) -1) ? ulEndOffset : ulFileSize;
  637. time_t tStart;
  639. while (ulCurrOffset < ulSndEndOffset) {
  640. unsigned long ulToSend = Min(ulSndBuffSize, ulSndEndOffset - ulCurrOffset);
  641. off_t ulStartOffset = (off_t) ulCurrOffset;
  643. tStart = time(NULL);
  644. unsigned long ulSendSize = (unsigned long) sendfile((int) SockFD, iFileID,
  645.     &ulStartOffset, ulToSend);
  647. if (ulSendSize != ulToSend) {
  648. setsockopt((int) SockFD, SOL_SOCKET, SO_SNDTIMEO, &oldTV, sizeof(oldTV));
  649. close(iFileID);
  650. ErrSetErrorCode(ERR_SENDFILE);
  651. return (ERR_SENDFILE);
  652. }
  654. if ((((time(NULL) - tStart) * K_IO_TIME_RATIO) < iTimeout) &&
  655.     (ulSndBuffSize < MAX_TCP_SEND_SIZE))
  656. ulSndBuffSize = Min(ulSndBuffSize * 2, MAX_TCP_SEND_SIZE);
  658. ulCurrOffset += ulToSend;
  659. }
  661. setsockopt((int) SockFD, SOL_SOCKET, SO_SNDTIMEO, &oldTV, sizeof(oldTV));
  663. #else // #ifdef USE_SENDFILE
  665. void *pMapAddress = (void *) mmap((char *) 0, (size_t) ulFileSize, PROT_READ,
  666.   MAP_SHARED, iFileID, 0);
  668. if (pMapAddress == (void *) -1) {
  669. close(iFileID);
  670. ErrSetErrorCode(ERR_MMAP);
  671. return (ERR_MMAP);
  672. }
  673. ///////////////////////////////////////////////////////////////////////////////
  674. //  Send the file
  675. ///////////////////////////////////////////////////////////////////////////////
  676. int iSndBuffSize = MIN_TCP_SEND_SIZE;
  677. unsigned long ulCurrOffset = ulBaseOffset;
  678. unsigned long ulSndEndOffset =
  679.     (ulEndOffset != (unsigned long) -1) ? ulEndOffset : ulFileSize;
  680. char *pszBuffer = (char *) pMapAddress + ulBaseOffset;
  681. time_t tStart;
  683. while (ulCurrOffset < ulSndEndOffset) {
  684. int iCurrSend = (int) Min(iSndBuffSize, ulSndEndOffset - ulCurrOffset);
  686. tStart = time(NULL);
  687. if ((iCurrSend = SysSendData(SockFD, pszBuffer, iCurrSend, iTimeout)) < 0) {
  688. ErrorPush();
  689. munmap((char *) pMapAddress, (size_t) ulFileSize);
  690. close(iFileID);
  691. return (ErrorPop());
  692. }
  694. if ((((time(NULL) - tStart) * K_IO_TIME_RATIO) < iTimeout) &&
  695.     (iSndBuffSize < MAX_TCP_SEND_SIZE))
  696. iSndBuffSize = Min(iSndBuffSize * 2, MAX_TCP_SEND_SIZE);
  698. pszBuffer += iCurrSend;
  699. ulCurrOffset += (unsigned long) iCurrSend;
  700. }
  702. munmap((char *) pMapAddress, (size_t) ulFileSize);
  704. #endif // #ifdef USE_SENDFILE
  706. close(iFileID);
  708. return (0);
  710. }
  712. int SysSetupAddress(SYS_INET_ADDR & AddrInfo, int iFamily,
  713.     NET_ADDRESS const &NetAddr, int iPortNo)
  714. {
  716. ZeroData(AddrInfo);
  717. AddrInfo.Addr.sin_family = iFamily;
  718. SAIN_Addr(AddrInfo.Addr) = NetAddr;
  719. AddrInfo.Addr.sin_port = htons((short) iPortNo);
  721. return (0);
  723. }
  725. int SysGetAddrAddress(SYS_INET_ADDR const &AddrInfo, NET_ADDRESS & NetAddr)
  726. {
  728. NetAddr = SAIN_Addr(AddrInfo.Addr);
  730. return (0);
  732. }
  734. int SysGetAddrPort(SYS_INET_ADDR const &AddrInfo)
  735. {
  737. return (ntohs(AddrInfo.Addr.sin_port));
  739. }
  741. int SysSetAddrAddress(SYS_INET_ADDR & AddrInfo, NET_ADDRESS const &NetAddr)
  742. {
  744. SAIN_Addr(AddrInfo.Addr) = NetAddr;
  746. return (0);
  748. }
  750. int SysSetAddrPort(SYS_INET_ADDR & AddrInfo, int iPortNo)
  751. {
  753. AddrInfo.Addr.sin_port = htons((short) iPortNo);
  755. return (0);
  757. }
  759. int SysGetHostByName(char const *pszName, NET_ADDRESS & NetAddr)
  760. {
  762. int iErrorNo = 0;
  763. struct hostent *pHostEnt;
  764. struct hostent HostEnt;
  765. char szBuffer[1024];
  767. if ((gethostbyname_r(pszName, &HostEnt, szBuffer, sizeof(szBuffer),
  768.      &pHostEnt, &iErrorNo) != 0) || (pHostEnt == NULL) ||
  769.     (pHostEnt->h_addr_list[0] == NULL)) {
  770. ErrSetErrorCode(ERR_BAD_SERVER_ADDR, pszName);
  771. return (ERR_BAD_SERVER_ADDR);
  772. }
  774. memcpy(&NetAddr, pHostEnt->h_addr_list[0], sizeof(NetAddr));
  776. return (0);
  778. }
  780. int SysGetHostByAddr(SYS_INET_ADDR const &AddrInfo, char *pszFQDN)
  781. {
  783. int iErrorNo = 0;
  784. struct hostent *pHostEnt;
  785. struct hostent HostEnt;
  786. char szBuffer[1024];
  788. if ((gethostbyaddr_r
  789.      ((const char *) &SAIN_Addr(AddrInfo.Addr), sizeof(SAIN_Addr(AddrInfo.Addr)), AF_INET,
  790.       &HostEnt, szBuffer, sizeof(szBuffer), &pHostEnt, &iErrorNo) != 0) ||
  791.     (pHostEnt == NULL) || (pHostEnt->h_name == NULL)) {
  792. char szIP[128] = "???.???.???.???";
  794. ErrSetErrorCode(ERR_GET_SOCK_HOST, SysInetNToA(AddrInfo, szIP));
  795. return (ERR_GET_SOCK_HOST);
  796. }
  798. strcpy(pszFQDN, pHostEnt->h_name);
  800. return (0);
  802. }
  804. int SysGetPeerInfo(SYS_SOCKET SockFD, SYS_INET_ADDR & AddrInfo)
  805. {
  807. ZeroData(AddrInfo);
  809. socklen_t InfoSize = sizeof(AddrInfo.Addr);
  811. if (getpeername(SockFD, (struct sockaddr *) &AddrInfo.Addr, &InfoSize) == -1) {
  812. ErrSetErrorCode(ERR_GET_PEER_INFO);
  813. return (ERR_GET_PEER_INFO);
  814. }
  816. return (0);
  818. }
  820. int SysGetSockInfo(SYS_SOCKET SockFD, SYS_INET_ADDR & AddrInfo)
  821. {
  823. ZeroData(AddrInfo);
  825. socklen_t InfoSize = sizeof(AddrInfo.Addr);
  827. if (getsockname(SockFD, (struct sockaddr *) &AddrInfo.Addr, &InfoSize) == -1) {
  828. ErrSetErrorCode(ERR_GET_SOCK_INFO);
  829. return (ERR_GET_SOCK_INFO);
  830. }
  832. return (0);
  834. }
  836. char *SysInetNToA(SYS_INET_ADDR const &AddrInfo, char *pszIP)
  837. {
  839. union {
  840. unsigned int a;
  841. unsigned char b[4];
  842. } UAddr;
  844. memcpy(&UAddr, &AddrInfo.Addr.sin_addr, sizeof(UAddr));
  846. sprintf(pszIP, "%u.%u.%u.%u",
  847. (unsigned int) UAddr.b[0],
  848. (unsigned int) UAddr.b[1], (unsigned int) UAddr.b[2], (unsigned int) UAddr.b[3]);
  850. return (pszIP);
  852. }
  854. int SysInetAddr(char const *pszDotName, NET_ADDRESS & NetAddr)
  855. {
  857. if ((NetAddr = (NET_ADDRESS) inet_addr(pszDotName)) == SYS_INVALID_NET_ADDRESS) {
  858. ErrSetErrorCode(ERR_BAD_SERVER_ADDR, pszDotName);
  859. return (ERR_BAD_SERVER_ADDR);
  860. }
  862. return (0);
  864. }
  866. int SysSameAddress(NET_ADDRESS const &NetAddr1, NET_ADDRESS const &NetAddr2)
  867. {
  869. return (memcmp(&NetAddr1, &NetAddr2, sizeof(NET_ADDRESS)) == 0);
  871. }
  873. SYS_SEMAPHORE SysCreateSemaphore(int iInitCount, int iMaxCount)
  874. {
  876. SemData *pSD = (SemData *) SysAlloc(sizeof(SemData));
  878. if (pSD == NULL)
  879. return (SYS_INVALID_SEMAPHORE);
  881. if (pthread_mutex_init(&pSD->Mtx, NULL) != 0) {
  882. SysFree(pSD);
  884. ErrSetErrorCode(ERR_MUTEXINIT, NULL);
  885. return (SYS_INVALID_SEMAPHORE);
  886. }
  888. if (pthread_cond_init(&pSD->WaitCond, NULL) != 0) {
  889. pthread_mutex_destroy(&pSD->Mtx);
  890. SysFree(pSD);
  892. ErrSetErrorCode(ERR_CONDINIT, NULL);
  893. return (SYS_INVALID_SEMAPHORE);
  894. }
  896. pSD->iSemCounter = iInitCount;
  898. pSD->iMaxCount = iMaxCount;
  900. return ((SYS_SEMAPHORE) pSD);
  902. }
  904. int SysCloseSemaphore(SYS_SEMAPHORE hSemaphore)
  905. {
  907. SemData *pSD = (SemData *) hSemaphore;
  909. pthread_cond_destroy(&pSD->WaitCond);
  911. pthread_mutex_destroy(&pSD->Mtx);
  913. SysFree(pSD);
  915. return (0);
  917. }
  919. int SysWaitSemaphore(SYS_SEMAPHORE hSemaphore, int iTimeout)
  920. {
  922. SemData *pSD = (SemData *) hSemaphore;
  924. pthread_mutex_lock(&pSD->Mtx);
  926. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  928. while (pSD->iSemCounter <= 0) {
  929. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pSD->Mtx);
  931. pthread_cond_wait(&pSD->WaitCond, &pSD->Mtx);
  933. pthread_cleanup_pop(0);
  934. }
  936. pSD->iSemCounter -= 1;
  938. } else {
  939. struct timeval tvNow;
  940. struct timespec tsTimeout;
  942. gettimeofday(&tvNow, NULL);
  944. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  945. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  947. int iRetCode = 0;
  949. while ((pSD->iSemCounter <= 0) && (iRetCode != ETIMEDOUT)) {
  950. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pSD->Mtx);
  952. iRetCode = pthread_cond_timedwait(&pSD->WaitCond, &pSD->Mtx, &tsTimeout);
  954. pthread_cleanup_pop(0);
  955. }
  957. if (iRetCode == ETIMEDOUT) {
  958. pthread_mutex_unlock(&pSD->Mtx);
  959. ErrSetErrorCode(ERR_TIMEOUT);
  960. return (ERR_TIMEOUT);
  961. }
  963. pSD->iSemCounter -= 1;
  965. }
  967. pthread_mutex_unlock(&pSD->Mtx);
  969. return (0);
  971. }
  973. int SysReleaseSemaphore(SYS_SEMAPHORE hSemaphore, int iCount)
  974. {
  976. SemData *pSD = (SemData *) hSemaphore;
  978. pthread_mutex_lock(&pSD->Mtx);
  980. pSD->iSemCounter += iCount;
  982. if (pSD->iSemCounter > 0) {
  983. if (pSD->iSemCounter > 1)
  984. pthread_cond_broadcast(&pSD->WaitCond);
  985. else
  986. pthread_cond_signal(&pSD->WaitCond);
  987. }
  989. pthread_mutex_unlock(&pSD->Mtx);
  991. return (0);
  993. }
  995. int SysTryWaitSemaphore(SYS_SEMAPHORE hSemaphore)
  996. {
  998. SemData *pSD = (SemData *) hSemaphore;
  1000. pthread_mutex_lock(&pSD->Mtx);
  1002. if (pSD->iSemCounter <= 0) {
  1003. pthread_mutex_unlock(&pSD->Mtx);
  1004. ErrSetErrorCode(ERR_TIMEOUT);
  1005. return (ERR_TIMEOUT);
  1006. }
  1008. pSD->iSemCounter -= 1;
  1010. pthread_mutex_unlock(&pSD->Mtx);
  1012. return (0);
  1014. }
  1016. SYS_MUTEX SysCreateMutex(void)
  1017. {
  1019. MutexData *pMD = (MutexData *) SysAlloc(sizeof(MutexData));
  1021. if (pMD == NULL)
  1022. return (SYS_INVALID_MUTEX);
  1024. if (pthread_mutex_init(&pMD->Mtx, NULL) != 0) {
  1025. SysFree(pMD);
  1026. ErrSetErrorCode(ERR_MUTEXINIT);
  1027. return (SYS_INVALID_MUTEX);
  1028. }
  1030. if (pthread_cond_init(&pMD->WaitCond, NULL) != 0) {
  1031. pthread_mutex_destroy(&pMD->Mtx);
  1032. SysFree(pMD);
  1033. ErrSetErrorCode(ERR_CONDINIT);
  1034. return (SYS_INVALID_MUTEX);
  1035. }
  1037. pMD->iLocked = 0;
  1039. return ((SYS_MUTEX) pMD);
  1041. }
  1043. int SysCloseMutex(SYS_MUTEX hMutex)
  1044. {
  1046. MutexData *pMD = (MutexData *) hMutex;
  1048. pthread_cond_destroy(&pMD->WaitCond);
  1050. pthread_mutex_destroy(&pMD->Mtx);
  1052. SysFree(pMD);
  1054. return (0);
  1056. }
  1058. int SysLockMutex(SYS_MUTEX hMutex, int iTimeout)
  1059. {
  1061. MutexData *pMD = (MutexData *) hMutex;
  1063. pthread_mutex_lock(&pMD->Mtx);
  1065. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1067. while (pMD->iLocked) {
  1068. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pMD->Mtx);
  1070. pthread_cond_wait(&pMD->WaitCond, &pMD->Mtx);
  1072. pthread_cleanup_pop(0);
  1073. }
  1075. pMD->iLocked = 1;
  1077. } else {
  1078. struct timeval tvNow;
  1079. struct timespec tsTimeout;
  1081. gettimeofday(&tvNow, NULL);
  1083. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1084. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1086. int iRetCode = 0;
  1088. while (pMD->iLocked && (iRetCode != ETIMEDOUT)) {
  1089. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pMD->Mtx);
  1091. iRetCode = pthread_cond_timedwait(&pMD->WaitCond, &pMD->Mtx, &tsTimeout);
  1093. pthread_cleanup_pop(0);
  1094. }
  1096. if (iRetCode == ETIMEDOUT) {
  1097. pthread_mutex_unlock(&pMD->Mtx);
  1098. ErrSetErrorCode(ERR_TIMEOUT);
  1099. return (ERR_TIMEOUT);
  1100. }
  1102. pMD->iLocked = 1;
  1104. }
  1106. pthread_mutex_unlock(&pMD->Mtx);
  1108. return (0);
  1110. }
  1112. int SysUnlockMutex(SYS_MUTEX hMutex)
  1113. {
  1115. MutexData *pMD = (MutexData *) hMutex;
  1117. pthread_mutex_lock(&pMD->Mtx);
  1119. pMD->iLocked = 0;
  1121. pthread_cond_signal(&pMD->WaitCond);
  1123. pthread_mutex_unlock(&pMD->Mtx);
  1125. return (0);
  1127. }
  1129. int SysTryLockMutex(SYS_MUTEX hMutex)
  1130. {
  1132. MutexData *pMD = (MutexData *) hMutex;
  1134. pthread_mutex_lock(&pMD->Mtx);
  1136. if (pMD->iLocked) {
  1137. pthread_mutex_unlock(&pMD->Mtx);
  1138. ErrSetErrorCode(ERR_TIMEOUT);
  1139. return (ERR_TIMEOUT);
  1140. }
  1142. pMD->iLocked = 1;
  1144. pthread_mutex_unlock(&pMD->Mtx);
  1146. return (0);
  1148. }
  1150. SYS_EVENT SysCreateEvent(int iManualReset)
  1151. {
  1153. EventData *pED = (EventData *) SysAlloc(sizeof(EventData));
  1155. if (pED == NULL)
  1156. return (SYS_INVALID_EVENT);
  1158. if (pthread_mutex_init(&pED->Mtx, NULL) != 0) {
  1159. SysFree(pED);
  1160. ErrSetErrorCode(ERR_MUTEXINIT);
  1161. return (SYS_INVALID_EVENT);
  1162. }
  1164. if (pthread_cond_init(&pED->WaitCond, NULL) != 0) {
  1165. pthread_mutex_destroy(&pED->Mtx);
  1166. SysFree(pED);
  1167. ErrSetErrorCode(ERR_CONDINIT);
  1168. return (SYS_INVALID_EVENT);
  1169. }
  1171. pED->iSignaled = 0;
  1172. pED->iManualReset = iManualReset;
  1174. return ((SYS_EVENT) pED);
  1176. }
  1178. int SysCloseEvent(SYS_EVENT hEvent)
  1179. {
  1181. EventData *pED = (EventData *) hEvent;
  1183. pthread_cond_destroy(&pED->WaitCond);
  1185. pthread_mutex_destroy(&pED->Mtx);
  1187. SysFree(pED);
  1189. return (0);
  1191. }
  1193. int SysWaitEvent(SYS_EVENT hEvent, int iTimeout)
  1194. {
  1196. EventData *pED = (EventData *) hEvent;
  1198. pthread_mutex_lock(&pED->Mtx);
  1200. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1202. while (!pED->iSignaled) {
  1203. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pED->Mtx);
  1205. pthread_cond_wait(&pED->WaitCond, &pED->Mtx);
  1207. pthread_cleanup_pop(0);
  1208. }
  1210. if (!pED->iManualReset)
  1211. pED->iSignaled = 0;
  1213. } else {
  1214. struct timeval tvNow;
  1215. struct timespec tsTimeout;
  1217. gettimeofday(&tvNow, NULL);
  1219. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1220. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1222. int iRetCode = 0;
  1224. while (!pED->iSignaled && (iRetCode != ETIMEDOUT)) {
  1225. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pED->Mtx);
  1227. iRetCode = pthread_cond_timedwait(&pED->WaitCond, &pED->Mtx, &tsTimeout);
  1229. pthread_cleanup_pop(0);
  1230. }
  1232. if (iRetCode == ETIMEDOUT) {
  1233. pthread_mutex_unlock(&pED->Mtx);
  1234. ErrSetErrorCode(ERR_TIMEOUT);
  1235. return (ERR_TIMEOUT);
  1236. }
  1238. if (!pED->iManualReset)
  1239. pED->iSignaled = 0;
  1241. }
  1243. pthread_mutex_unlock(&pED->Mtx);
  1245. return (0);
  1247. }
  1249. int SysSetEvent(SYS_EVENT hEvent)
  1250. {
  1252. EventData *pED = (EventData *) hEvent;
  1254. pthread_mutex_lock(&pED->Mtx);
  1256. pED->iSignaled = 1;
  1258. if (pED->iManualReset)
  1259. pthread_cond_broadcast(&pED->WaitCond);
  1260. else
  1261. pthread_cond_signal(&pED->WaitCond);
  1263. pthread_mutex_unlock(&pED->Mtx);
  1265. return (0);
  1267. }
  1269. int SysResetEvent(SYS_EVENT hEvent)
  1270. {
  1272. EventData *pED = (EventData *) hEvent;
  1274. pthread_mutex_lock(&pED->Mtx);
  1276. pED->iSignaled = 0;
  1278. pthread_mutex_unlock(&pED->Mtx);
  1280. return (0);
  1282. }
  1284. int SysTryWaitEvent(SYS_EVENT hEvent)
  1285. {
  1287. EventData *pED = (EventData *) hEvent;
  1289. pthread_mutex_lock(&pED->Mtx);
  1291. if (!pED->iSignaled) {
  1292. pthread_mutex_unlock(&pED->Mtx);
  1293. ErrSetErrorCode(ERR_TIMEOUT);
  1294. return (ERR_TIMEOUT);
  1295. }
  1297. if (!pED->iManualReset)
  1298. pED->iSignaled = 0;
  1300. pthread_mutex_unlock(&pED->Mtx);
  1302. return (0);
  1304. }
  1306. static int SysFreeThreadData(ThrData * pTD)
  1307. {
  1309. pthread_cond_destroy(&pTD->ExitWaitCond);
  1311. pthread_mutex_destroy(&pTD->Mtx);
  1313. SysFree(pTD);
  1315. return (0);
  1317. }
  1319. static void *SysThreadStartup(void *pThreadData)
  1320. {
  1322. ThrData *pTD = (ThrData *) pThreadData;
  1324. SysThreadSetup(pTD);
  1326. int iExitCode;
  1328. pthread_cleanup_push((void (*)(void *)) SysThreadCleanup, pTD);
  1330. pTD->iExitCode = iExitCode = SysStkCall(pTD->ThreadProc, pTD->pThreadData);
  1332. pthread_cleanup_pop(1);
  1334. return ((void *) iExitCode);
  1336. }
  1338. SYS_THREAD SysCreateThread(unsigned int (*pThreadProc) (void *), void *pThreadData)
  1339. {
  1341. ThrData *pTD = (ThrData *) SysAlloc(sizeof(ThrData));
  1343. if (pTD == NULL)
  1344. return (SYS_INVALID_THREAD);
  1346. pTD->ThreadProc = pThreadProc;
  1347. pTD->pThreadData = pThreadData;
  1348. pTD->iThreadEnded = 0;
  1349. pTD->iExitCode = -1;
  1350. pTD->iUseCount = 2;
  1352. if (pthread_mutex_init(&pTD->Mtx, NULL) != 0) {
  1353. SysFree(pTD);
  1355. ErrSetErrorCode(ERR_MUTEXINIT);
  1356. return (SYS_INVALID_THREAD);
  1357. }
  1359. if (pthread_cond_init(&pTD->ExitWaitCond, NULL) != 0) {
  1360. pthread_mutex_destroy(&pTD->Mtx);
  1361. SysFree(pTD);
  1363. ErrSetErrorCode(ERR_CONDINIT);
  1364. return (SYS_INVALID_THREAD);
  1365. }
  1367. pthread_attr_t ThrAttr;
  1369. pthread_attr_init(&ThrAttr);
  1371. pthread_attr_setscope(&ThrAttr, PTHREAD_SCOPE_SYSTEM);
  1373. if (pthread_create(&pTD->ThreadId, &ThrAttr, SysThreadStartup, pTD) != 0) {
  1374. pthread_attr_destroy(&ThrAttr);
  1375. pthread_cond_destroy(&pTD->ExitWaitCond);
  1376. pthread_mutex_destroy(&pTD->Mtx);
  1377. SysFree(pTD);
  1379. ErrSetErrorCode(ERR_THREADCREATE);
  1380. return (SYS_INVALID_THREAD);
  1381. }
  1383. pthread_attr_destroy(&ThrAttr);
  1385. return ((SYS_THREAD) pTD);
  1387. }
  1389. SYS_THREAD SysCreateServiceThread(unsigned int (*pThreadProc) (void *), SYS_SOCKET SockFD)
  1390. {
  1392. return (SysCreateThread(pThreadProc, (void *) SockFD));
  1394. }
  1396. static int SysThreadSetup(ThrData * pTD)
  1397. {
  1399. sigset_t SigMask;
  1401. sigemptyset(&SigMask);
  1402. sigaddset(&SigMask, SIGALRM);
  1403. sigaddset(&SigMask, SIGINT);
  1404. sigaddset(&SigMask, SIGHUP);
  1405. sigaddset(&SigMask, SIGSTOP);
  1406. sigaddset(&SigMask, SIGCHLD);
  1408. pthread_sigmask(SIG_BLOCK, &SigMask, NULL);
  1410. sigemptyset(&SigMask);
  1411. sigaddset(&SigMask, SIGQUIT);
  1413. pthread_sigmask(SIG_UNBLOCK, &SigMask, NULL);
  1415. SysSetSignal(SIGQUIT, SysIgnoreProc);
  1417. SysSetSignal(SIGPIPE, SysIgnoreProc);
  1419. SysSetSignal(SIGCHLD, SysIgnoreProc);
  1421. if (pTD != NULL) {
  1423. }
  1425. return (0);
  1427. }
  1429. static void SysThreadCleanup(ThrData * pTD)
  1430. {
  1432. if (pTD != NULL) {
  1433. pthread_mutex_lock(&pTD->Mtx);
  1435. pTD->iThreadEnded = 1;
  1437. pthread_cond_broadcast(&pTD->ExitWaitCond);
  1439. if (--pTD->iUseCount == 0) {
  1440. pthread_mutex_unlock(&pTD->Mtx);
  1442. SysFreeThreadData(pTD);
  1443. } else
  1444. pthread_mutex_unlock(&pTD->Mtx);
  1445. }
  1447. }
  1449. void SysCloseThread(SYS_THREAD ThreadID, int iForce)
  1450. {
  1452. ThrData *pTD = (ThrData *) ThreadID;
  1454. pthread_mutex_lock(&pTD->Mtx);
  1456. pthread_detach(pTD->ThreadId);
  1458. if (iForce && !pTD->iThreadEnded)
  1459. pthread_cancel(pTD->ThreadId);
  1461. if (--pTD->iUseCount == 0) {
  1462. pthread_mutex_unlock(&pTD->Mtx);
  1464. SysFreeThreadData(pTD);
  1465. } else
  1466. pthread_mutex_unlock(&pTD->Mtx);
  1468. }
  1470. int SysSetThreadPriority(SYS_THREAD ThreadID, int iPriority)
  1471. {
  1473. ThrData *pTD = (ThrData *) ThreadID;
  1474. int iPolicy;
  1475. struct sched_param SchParam;
  1477. if (pthread_getschedparam(pTD->ThreadId, &iPolicy, &SchParam) != 0) {
  1478. ErrSetErrorCode(ERR_SET_THREAD_PRIORITY);
  1479. return (ERR_SET_THREAD_PRIORITY);
  1480. }
  1482. int iMinPriority = sched_get_priority_min(iPolicy),
  1483.     iMaxPriority = sched_get_priority_max(iPolicy),
  1484.     iStdPriority = (iMinPriority + iMaxPriority) / 2;
  1486. switch (iPriority) {
  1487. case (SYS_PRIORITY_NORMAL):
  1488. SchParam.sched_priority = iStdPriority;
  1489. break;
  1491. case (SYS_PRIORITY_LOWER):
  1492. SchParam.sched_priority = iStdPriority - (iStdPriority - iMinPriority) / 3;
  1493. break;
  1495. case (SYS_PRIORITY_HIGHER):
  1496. SchParam.sched_priority = iStdPriority + (iStdPriority - iMinPriority) / 3;
  1497. break;
  1498. }
  1500. if (pthread_setschedparam(pTD->ThreadId, iPolicy, &SchParam) != 0) {
  1501. ErrSetErrorCode(ERR_SET_THREAD_PRIORITY);
  1502. return (ERR_SET_THREAD_PRIORITY);
  1503. }
  1505. return (0);
  1507. }
  1509. int SysWaitThread(SYS_THREAD ThreadID, int iTimeout)
  1510. {
  1512. ThrData *pTD = (ThrData *) ThreadID;
  1514. pthread_mutex_lock(&pTD->Mtx);
  1516. if (iTimeout == SYS_INFINITE_TIMEOUT) {
  1518. while (!pTD->iThreadEnded) {
  1519. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pTD->Mtx);
  1521. pthread_cond_wait(&pTD->ExitWaitCond, &pTD->Mtx);
  1523. pthread_cleanup_pop(0);
  1524. }
  1526. } else {
  1527. struct timeval tvNow;
  1528. struct timespec tsTimeout;
  1530. gettimeofday(&tvNow, NULL);
  1532. tsTimeout.tv_sec = tvNow.tv_sec + iTimeout;
  1533. tsTimeout.tv_nsec = tvNow.tv_usec * 1000;
  1535. int iRetCode = 0;
  1537. while (!pTD->iThreadEnded && (iRetCode != ETIMEDOUT)) {
  1538. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pTD->Mtx);
  1540. iRetCode =
  1541.     pthread_cond_timedwait(&pTD->ExitWaitCond, &pTD->Mtx, &tsTimeout);
  1543. pthread_cleanup_pop(0);
  1544. }
  1546. if (iRetCode == ETIMEDOUT) {
  1547. pthread_mutex_unlock(&pTD->Mtx);
  1549. ErrSetErrorCode(ERR_TIMEOUT);
  1550. return (ERR_TIMEOUT);
  1551. }
  1553. }
  1555. pthread_mutex_unlock(&pTD->Mtx);
  1557. return (0);
  1559. }
  1561. unsigned long SysGetCurrentThreadId(void)
  1562. {
  1564. return ((unsigned long) pthread_self());
  1566. }
  1568. static int SysSafeMsSleep(int iMsTimeout)
  1569. {
  1571. struct pollfd Dummy;
  1573. ZeroData(Dummy);
  1575. return ((poll(&Dummy, 0, iMsTimeout) == 0) ? 1 : 0);
  1577. }
  1579. static int SysWaitPID(pid_t PID, int *piExitCode, int iTimeout)
  1580. {
  1582. pid_t ExitPID;
  1583. int iExitStatus;
  1584. int iStatus;
  1586. iTimeout *= 1000;
  1587. do {
  1588. if ((ExitPID = (pid_t) waitpid(PID, &iStatus, WNOHANG)) == PID) {
  1589. if (!WIFEXITED(iStatus))
  1590. return (ERR_WAITPID);
  1592. iExitStatus = WEXITSTATUS(iStatus);
  1593. break;
  1594. }
  1596. SysSafeMsSleep(WAIT_PID_TIME_STEP);
  1597. iTimeout -= WAIT_PID_TIME_STEP;
  1599. } while (iTimeout > 0);
  1601. if (PID != ExitPID)
  1602. return (ERR_TIMEOUT);
  1604. if (piExitCode != NULL)
  1605. *piExitCode = iExitStatus;
  1607. return (0);
  1609. }
  1611. int SysExec(char const *pszCommand, char const *const *pszArgs, int iWaitTimeout,
  1612.     int iPriority, int *piExitStatus)
  1613. {
  1615. int iExitStatus;
  1616. pid_t ChildID;
  1617. pid_t ExitPID;
  1618. pid_t ProcessID;
  1619. int iPPipe[2];
  1620. int iCPipe[2];
  1622. if (pipe(iPPipe) == -1) {
  1623. ErrSetErrorCode(ERR_PIPE);
  1624. return (ERR_PIPE);
  1625. }
  1626. if (pipe(iCPipe) == -1) {
  1627. close(iPPipe[1]);
  1628. close(iPPipe[0]);
  1629. ErrSetErrorCode(ERR_PIPE);
  1630. return (ERR_PIPE);
  1631. }
  1633. ProcessID = fork();
  1634. if (ProcessID == 0) {
  1635. ChildID = fork();
  1636. if (ChildID == 0) {
  1637. close(iPPipe[1]);
  1638. close(iPPipe[0]);
  1640. ///////////////////////////////////////////////////////////////////////////////
  1641. //  Wait for the unlock from the parent
  1642. ///////////////////////////////////////////////////////////////////////////////
  1643. read(iCPipe[0], &ChildID, sizeof(ChildID));
  1645. close(iCPipe[1]);
  1646. close(iCPipe[0]);
  1648. ///////////////////////////////////////////////////////////////////////////////
  1649. //  Execute the command
  1650. ///////////////////////////////////////////////////////////////////////////////
  1651. execv(pszCommand, (char **) pszArgs);
  1653. ///////////////////////////////////////////////////////////////////////////////
  1654. //  We can only use async-signal safe functions, so we use write() directly
  1655. ///////////////////////////////////////////////////////////////////////////////
  1656. write(2, "execv error: cmd='", 18);
  1657. write(2, pszCommand, strlen(pszCommand));
  1658. write(2, "'n", 2);
  1660. _exit(WAIT_ERROR_EXIT_STATUS);
  1661. }
  1663. close(iCPipe[1]);
  1664. close(iCPipe[0]);
  1666. ///////////////////////////////////////////////////////////////////////////////
  1667. //  Tell the parent about the child-child PID
  1668. ///////////////////////////////////////////////////////////////////////////////
  1669. write(iPPipe[1], &ChildID, sizeof(ChildID));
  1671. close(iPPipe[1]);
  1672. close(iPPipe[0]);
  1674. if (ChildID == (pid_t) - 1)
  1675. _exit(WAIT_ERROR_EXIT_STATUS);
  1677. ///////////////////////////////////////////////////////////////////////////////
  1678. //  Wait for the child
  1679. ///////////////////////////////////////////////////////////////////////////////
  1680. iExitStatus = WAIT_TIMEO_EXIT_STATUS;
  1681. if (iWaitTimeout > 0)
  1682. SysWaitPID(ChildID, &iExitStatus, iWaitTimeout);
  1684. _exit(iExitStatus);
  1685. }
  1687. if ((ProcessID == (pid_t) - 1) ||
  1688.     (read(iPPipe[0], &ChildID, sizeof(ChildID)) != sizeof(ChildID))) {
  1689. close(iCPipe[1]);
  1690. close(iCPipe[0]);
  1691. close(iPPipe[1]);
  1692. close(iPPipe[0]);
  1693. ErrSetErrorCode(ERR_FORK);
  1694. return (ERR_FORK);
  1695. }
  1697. close(iPPipe[1]);
  1698. close(iPPipe[0]);
  1700. if (ChildID != (pid_t) - 1) {
  1701. ///////////////////////////////////////////////////////////////////////////////
  1702. //  Set process priority
  1703. ///////////////////////////////////////////////////////////////////////////////
  1704. switch (iPriority) {
  1705. case (SYS_PRIORITY_NORMAL):
  1706. setpriority(PRIO_PROCESS, ChildID, 0);
  1707. break;
  1709. case (SYS_PRIORITY_LOWER):
  1710. setpriority(PRIO_PROCESS, ChildID, SCHED_PRIORITY_INC);
  1711. break;
  1713. case (SYS_PRIORITY_HIGHER):
  1714. setpriority(PRIO_PROCESS, ChildID, -SCHED_PRIORITY_INC);
  1715. break;
  1716. }
  1718. ///////////////////////////////////////////////////////////////////////////////
  1719. //  Unlock the child
  1720. ///////////////////////////////////////////////////////////////////////////////
  1721. write(iCPipe[1], &ChildID, sizeof(ChildID));
  1722. }
  1724. close(iCPipe[1]);
  1725. close(iCPipe[0]);
  1727. ///////////////////////////////////////////////////////////////////////////////
  1728. //  Wait for completion (or timeout)
  1729. ///////////////////////////////////////////////////////////////////////////////
  1730. while (((ExitPID = (pid_t) waitpid(ProcessID, &iExitStatus, 0)) != ProcessID) &&
  1731.        (errno == EINTR));
  1733. if ((ExitPID == ProcessID) && WIFEXITED(iExitStatus))
  1734. iExitStatus = WEXITSTATUS(iExitStatus);
  1735. else
  1736. iExitStatus = WAIT_TIMEO_EXIT_STATUS;
  1738. if (iWaitTimeout > 0) {
  1739. if (iExitStatus == WAIT_TIMEO_EXIT_STATUS) {
  1740. ErrSetErrorCode(ERR_TIMEOUT);
  1741. return (ERR_TIMEOUT);
  1742. }
  1744. if (iExitStatus == WAIT_ERROR_EXIT_STATUS) {
  1745. ErrSetErrorCode(ERR_FORK);
  1746. return (ERR_FORK);
  1747. }
  1748. } else
  1749. iExitStatus = -1;
  1751. if (piExitStatus != NULL)
  1752. *piExitStatus = iExitStatus;
  1754. return (0);
  1756. }
  1758. static void SysBreakHandlerRoutine(int iSignal)
  1759. {
  1761. if (SysBreakHandler != NULL)
  1762. SysBreakHandler();
  1764. SysSetSignal(iSignal, SysBreakHandlerRoutine);
  1766. }
  1768. void SysSetBreakHandler(void (*BreakHandler) (void))
  1769. {
  1771. SysBreakHandler = BreakHandler;
  1773. ///////////////////////////////////////////////////////////////////////////////
  1774. //  Setup signal handlers and enable signals
  1775. ///////////////////////////////////////////////////////////////////////////////
  1776. SysSetSignal(SIGINT, SysBreakHandlerRoutine);
  1777. SysSetSignal(SIGHUP, SysBreakHandlerRoutine);
  1779. sigset_t SigMask;
  1781. sigemptyset(&SigMask);
  1782. sigaddset(&SigMask, SIGINT);
  1783. sigaddset(&SigMask, SIGHUP);
  1785. pthread_sigmask(SIG_UNBLOCK, &SigMask, NULL);
  1787. }
  1789. int SysCreateTlsKey(SYS_TLSKEY & TlsKey, void (*pFreeProc) (void *))
  1790. {
  1792. if (pthread_key_create(&TlsKey, pFreeProc) != 0) {
  1793. ErrSetErrorCode(ERR_NOMORE_TLSKEYS);
  1794. return (ERR_NOMORE_TLSKEYS);
  1795. }
  1797. return (0);
  1799. }
  1801. int SysDeleteTlsKey(SYS_TLSKEY & TlsKey)
  1802. {
  1804. pthread_key_delete(TlsKey);
  1806. return (0);
  1808. }
  1810. int SysSetTlsKeyData(SYS_TLSKEY & TlsKey, void *pData)
  1811. {
  1813. if (pthread_setspecific(TlsKey, pData) != 0) {
  1814. ErrSetErrorCode(ERR_INVALID_TLSKEY);
  1815. return (ERR_INVALID_TLSKEY);
  1816. }
  1818. return (0);
  1820. }
  1822. void *SysGetTlsKeyData(SYS_TLSKEY & TlsKey)
  1823. {
  1825. return (pthread_getspecific(TlsKey));
  1827. }
  1829. void SysThreadOnce(SYS_THREAD_ONCE * pThrOnce, void (*pOnceProc) (void))
  1830. {
  1832. pthread_once(pThrOnce, pOnceProc);
  1834. }
  1836. void *SysAlloc(unsigned int uSize)
  1837. {
  1839. void *pData = malloc(uSize);
  1841. if (pData != NULL)
  1842. memset(pData, 0, uSize);
  1843. else
  1844. ErrSetErrorCode(ERR_MEMORY);
  1846. return (pData);
  1848. }
  1850. void SysFree(void *pData)
  1851. {
  1853. free(pData);
  1855. }
  1857. void *SysRealloc(void *pData, unsigned int uSize)
  1858. {
  1860. void *pNewData = realloc(pData, uSize);
  1862. if (pNewData == NULL)
  1863. ErrSetErrorCode(ERR_MEMORY);
  1865. return (pNewData);
  1867. }
  1869. int SysLockFile(const char *pszFileName, char const *pszLockExt)
  1870. {
  1872. char szLockFile[SYS_MAX_PATH] = "";
  1874. snprintf(szLockFile, sizeof(szLockFile) - 1, "%s%s", pszFileName, pszLockExt);
  1876. int iFileID = open(szLockFile, O_CREAT | O_EXCL | O_RDWR, S_IREAD | S_IWRITE);
  1878. if (iFileID == -1) {
  1879. ErrSetErrorCode(ERR_LOCKED);
  1880. return (ERR_LOCKED);
  1881. }
  1883. char szLock[128] = "";
  1885. sprintf(szLock, "%lu", (unsigned long) SysGetCurrentThreadId());
  1887. write(iFileID, szLock, strlen(szLock) + 1);
  1889. close(iFileID);
  1891. return (0);
  1893. }
  1895. int SysUnlockFile(const char *pszFileName, char const *pszLockExt)
  1896. {
  1898. char szLockFile[SYS_MAX_PATH] = "";
  1900. snprintf(szLockFile, sizeof(szLockFile) - 1, "%s%s", pszFileName, pszLockExt);
  1902. if (unlink(szLockFile) != 0) {
  1903. ErrSetErrorCode(ERR_NOT_LOCKED);
  1904. return (ERR_NOT_LOCKED);
  1905. }
  1907. return (0);
  1909. }
  1911. SYS_HANDLE SysOpenModule(char const *pszFilePath)
  1912. {
  1914. void *pModule = dlopen(pszFilePath, RTLD_LAZY);
  1916. if (pModule == NULL) {
  1917. ErrSetErrorCode(ERR_LOADMODULE, pszFilePath);
  1918. return (SYS_INVALID_HANDLE);
  1919. }
  1921. return ((SYS_HANDLE) pModule);
  1923. }
  1925. int SysCloseModule(SYS_HANDLE hModule)
  1926. {
  1928. dlclose((void *) hModule);
  1930. return (0);
  1932. }
  1934. void *SysGetSymbol(SYS_HANDLE hModule, char const *pszSymbol)
  1935. {
  1937. void *pSymbol = dlsym((void *) hModule, pszSymbol);
  1939. if (pSymbol == NULL) {
  1940. ErrSetErrorCode(ERR_LOADMODULESYMBOL, pszSymbol);
  1941. return (NULL);
  1942. }
  1944. return (pSymbol);
  1946. }
  1948. int SysEventLogV(int iLogLevel, char const *pszFormat, va_list Args)
  1949. {
  1951. openlog(APP_NAME_STR, LOG_PID, LOG_DAEMON);
  1953. char szBuffer[2048] = "";
  1955. vsnprintf(szBuffer, sizeof(szBuffer) - 1, pszFormat, Args);
  1957. syslog(LOG_DAEMON | LOG_ERR, "%s", szBuffer);
  1959. closelog();
  1961. return (0);
  1963. }
  1965. int SysEventLog(int iLogLevel, char const *pszFormat, ...)
  1966. {
  1968. va_list Args;
  1970. va_start(Args, pszFormat);
  1972. int iLogResult = SysEventLogV(iLogLevel, pszFormat, Args);
  1974. va_end(Args);
  1976. return (0);
  1978. }
  1980. int SysLogMessage(int iLogLevel, char const *pszFormat, ...)
  1981. {
  1983. extern bool bServerDebug;
  1985. pthread_mutex_lock(&LogMutex);
  1987. va_list Args;
  1989. va_start(Args, pszFormat);
  1991. if (bServerDebug) {
  1992. ///////////////////////////////////////////////////////////////////////////////
  1993. //  Debug implementation
  1994. ///////////////////////////////////////////////////////////////////////////////
  1996. vprintf(pszFormat, Args);
  1998. } else {
  1999. switch (iLogLevel) {
  2000. case (LOG_LEV_WARNING):
  2001. case (LOG_LEV_ERROR):
  2003. SysEventLogV(iLogLevel, pszFormat, Args);
  2005. break;
  2006. }
  2007. }
  2009. va_end(Args);
  2011. pthread_mutex_unlock(&LogMutex);
  2013. return (0);
  2015. }
  2017. void SysSleep(int iTimeout)
  2018. {
  2020. SysMsSleep(iTimeout * 1000);
  2022. }
  2024. static int SysSetupWait(WaitData * pWD)
  2025. {
  2027. if (pthread_mutex_init(&pWD->Mtx, NULL) != 0) {
  2028. ErrSetErrorCode(ERR_MUTEXINIT);
  2029. return (ERR_MUTEXINIT);
  2030. }
  2032. if (pthread_cond_init(&pWD->WaitCond, NULL) != 0) {
  2033. pthread_mutex_destroy(&pWD->Mtx);
  2034. ErrSetErrorCode(ERR_CONDINIT);
  2035. return (ERR_CONDINIT);
  2036. }
  2038. return (0);
  2040. }
  2042. static int SysWait(WaitData * pWD, int iMsTimeout)
  2043. {
  2044. struct timespec TV;
  2045. struct timeval TmNow;
  2046. int iErrorCode;
  2048. gettimeofday(&TmNow, NULL);
  2050. TmNow.tv_sec += iMsTimeout / 1000;
  2051. TmNow.tv_usec += (iMsTimeout % 1000) * 1000;
  2052. TmNow.tv_sec += TmNow.tv_usec / 1000000;
  2053. TmNow.tv_usec %= 1000000;
  2055. TV.tv_sec = TmNow.tv_sec;
  2056. TV.tv_nsec = TmNow.tv_usec * 1000;
  2058. pthread_mutex_lock(&pWD->Mtx);
  2059. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock, &pWD->Mtx);
  2061. iErrorCode = pthread_cond_timedwait(&pWD->WaitCond, &pWD->Mtx, &TV);
  2063. pthread_cleanup_pop(1);
  2065. if (iErrorCode == ETIMEDOUT) {
  2066. ErrSetErrorCode(ERR_TIMEOUT);
  2067. return (ERR_TIMEOUT);
  2068. }
  2070. return (0);
  2072. }
  2074. static void SysCleanupWait(WaitData * pWD)
  2075. {
  2077. pthread_mutex_destroy(&pWD->Mtx);
  2078. pthread_cond_destroy(&pWD->WaitCond);
  2080. }
  2082. void SysMsSleep(int iMsTimeout)
  2083. {
  2085. WaitData WD;
  2087. if (SysSetupWait(&WD) == 0) {
  2088. SysWait(&WD, iMsTimeout);
  2089. SysCleanupWait(&WD);
  2090. }
  2092. }
  2094. SYS_INT64 SysMsTime(void)
  2095. {
  2097. struct timeval tv;
  2099. if (gettimeofday(&tv, NULL) != 0)
  2100. return (0);
  2102. return (1000 * (SYS_INT64) tv.tv_sec + (SYS_INT64) tv.tv_usec / 1000);
  2104. }
  2106. int SysExistFile(const char *pszFilePath)
  2107. {
  2109. struct stat FS;
  2111. if (stat(pszFilePath, &FS) != 0)
  2112. return (0);
  2114. return ((S_ISDIR(FS.st_mode)) ? 0 : 1);
  2116. }
  2118. int SysExistDir(const char *pszDirPath)
  2119. {
  2121. struct stat FS;
  2123. if (stat(pszDirPath, &FS) != 0)
  2124. return (0);
  2126. return ((S_ISDIR(FS.st_mode)) ? 1 : 0);
  2128. }
  2130. SYS_HANDLE SysFirstFile(const char *pszPath, char *pszFileName)
  2131. {
  2133. DIR *pDIR = opendir(pszPath);
  2135. if (pDIR == NULL) {
  2136. ErrSetErrorCode(ERR_OPENDIR);
  2137. return (SYS_INVALID_HANDLE);
  2138. }
  2140. struct dirent DE;
  2141. struct dirent *pDirEntry = NULL;
  2143. readdir_r(pDIR, &DE, &pDirEntry);
  2145. if (pDirEntry == NULL) {
  2146. closedir(pDIR);
  2147. return (SYS_INVALID_HANDLE);
  2148. }
  2150. FileFindData *pFFD = (FileFindData *) SysAlloc(sizeof(FileFindData));
  2152. if (pFFD == NULL) {
  2153. closedir(pDIR);
  2154. return (SYS_INVALID_HANDLE);
  2155. }
  2157. strcpy(pFFD->szPath, pszPath);
  2158. AppendSlash(pFFD->szPath);
  2159. pFFD->pDIR = pDIR;
  2160. pFFD->DE = *pDirEntry;
  2162. strcpy(pszFileName, pFFD->DE.d_name);
  2164. char szFilePath[SYS_MAX_PATH] = "";
  2166. snprintf(szFilePath, sizeof(szFilePath) - 1, "%s%s", pFFD->szPath, pFFD->DE.d_name);
  2168. if (stat(szFilePath, &pFFD->FS) != 0) {
  2169. SysFree(pFFD);
  2170. closedir(pDIR);
  2172. ErrSetErrorCode(ERR_STAT);
  2173. return (SYS_INVALID_HANDLE);
  2174. }
  2176. return ((SYS_HANDLE) pFFD);
  2178. }
  2180. int SysIsDirectory(SYS_HANDLE hFind)
  2181. {
  2183. FileFindData *pFFD = (FileFindData *) hFind;
  2185. return ((S_ISDIR(pFFD->FS.st_mode)) ? 1 : 0);
  2187. }
  2189. unsigned long SysGetSize(SYS_HANDLE hFind)
  2190. {
  2192. FileFindData *pFFD = (FileFindData *) hFind;
  2194. return ((unsigned long) pFFD->FS.st_size);
  2196. }
  2198. int SysNextFile(SYS_HANDLE hFind, char *pszFileName)
  2199. {
  2201. FileFindData *pFFD = (FileFindData *) hFind;
  2202. struct dirent *pDirEntry = NULL;
  2204. readdir_r(pFFD->pDIR, &pFFD->DE, &pDirEntry);
  2206. if (pDirEntry == NULL)
  2207. return (0);
  2209. strcpy(pszFileName, pFFD->DE.d_name);
  2211. char szFilePath[SYS_MAX_PATH] = "";
  2213. snprintf(szFilePath, sizeof(szFilePath) - 1, "%s%s", pFFD->szPath, pFFD->DE.d_name);
  2215. if (stat(szFilePath, &pFFD->FS) != 0) {
  2216. ErrSetErrorCode(ERR_STAT);
  2217. return (0);
  2218. }
  2220. return (1);
  2222. }
  2224. void SysFindClose(SYS_HANDLE hFind)
  2225. {
  2227. FileFindData *pFFD = (FileFindData *) hFind;
  2229. closedir(pFFD->pDIR);
  2231. SysFree(pFFD);
  2233. }
  2235. int SysGetFileInfo(char const *pszFileName, SYS_FILE_INFO & FI)
  2236. {
  2238. struct stat stat_buffer;
  2240. if (stat(pszFileName, &stat_buffer) != 0) {
  2241. ErrSetErrorCode(ERR_STAT);
  2242. return (ERR_STAT);
  2243. }
  2245. ZeroData(FI);
  2246. FI.iFileType = (S_ISREG(stat_buffer.st_mode)) ? ftNormal :
  2247.     ((S_ISDIR(stat_buffer.st_mode)) ? ftDirectory :
  2248.      ((S_ISLNK(stat_buffer.st_mode)) ? ftLink : ftOther));
  2249. FI.ulSize = (unsigned long) stat_buffer.st_size;
  2250. FI.tMod = stat_buffer.st_mtime;
  2252. return (0);
  2254. }
  2256. int SysSetFileModTime(char const *pszFileName, time_t tMod)
  2257. {
  2259. struct utimbuf TMB;
  2261. TMB.actime = tMod;
  2262. TMB.modtime = tMod;
  2264. if (utime(pszFileName, &TMB) != 0) {
  2265. ErrSetErrorCode(ERR_SET_FILE_TIME);
  2266. return (ERR_SET_FILE_TIME);
  2267. }
  2269. return (0);
  2271. }
  2273. char *SysStrDup(const char *pszString)
  2274. {
  2276. int iStrLength = strlen(pszString);
  2277. char *pszBuffer = (char *) SysAlloc(iStrLength + 1);
  2279. if (pszBuffer != NULL)
  2280. strcpy(pszBuffer, pszString);
  2282. return (pszBuffer);
  2284. }
  2286. char *SysGetEnv(const char *pszVarName)
  2287. {
  2289. const char *pszValue = getenv(pszVarName);
  2291. return ((pszValue != NULL) ? SysStrDup(pszValue) : NULL);
  2293. }
  2295. char *SysGetTmpFile(char *pszFileName)
  2296. {
  2298. static unsigned long ulFileSeqNr = 0;
  2299. unsigned long ulThreadID = SysGetCurrentThreadId();
  2301. sprintf(pszFileName, "/tmp/msrv%lx.%lx.tmp", ulThreadID, ulFileSeqNr++);
  2303. return (pszFileName);
  2305. }
  2307. int SysRemove(const char *pszFileName)
  2308. {
  2310. if (unlink(pszFileName) != 0) {
  2311. ErrSetErrorCode(ERR_FILE_DELETE);
  2312. return (ERR_FILE_DELETE);
  2313. }
  2315. return (0);
  2317. }
  2319. int SysMakeDir(const char *pszPath)
  2320. {
  2322. if (mkdir(pszPath, 0700) != 0) {
  2323. ErrSetErrorCode(ERR_DIR_CREATE);
  2324. return (ERR_DIR_CREATE);
  2325. }
  2327. return (0);
  2329. }
  2331. int SysRemoveDir(const char *pszPath)
  2332. {
  2334. if (rmdir(pszPath) != 0) {
  2335. ErrSetErrorCode(ERR_DIR_DELETE);
  2336. return (ERR_DIR_DELETE);
  2337. }
  2339. return (0);
  2341. }
  2343. int SysMoveFile(char const *pszOldName, char const *pszNewName)
  2344. {
  2346. if (rename(pszOldName, pszNewName) != 0) {
  2347. ErrSetErrorCode(ERR_FILE_MOVE);
  2348. return (ERR_FILE_MOVE);
  2349. }
  2351. return (0);
  2353. }
  2355. int SysVSNPrintf(char *pszBuffer, int iSize, char const *pszFormat, va_list Args)
  2356. {
  2358. int iPrintResult = vsnprintf(pszBuffer, iSize, pszFormat, Args);
  2360. return ((iPrintResult < iSize) ? iPrintResult : -1);
  2362. }
  2364. int SysFileSync(FILE * pFile)
  2365. {
  2367. if (fflush(pFile) || fsync(fileno(pFile))) {
  2368. ErrSetErrorCode(ERR_FILE_WRITE);
  2369. return (ERR_FILE_WRITE);
  2370. }
  2372. return (0);
  2374. }
  2376. char *SysStrTok(char *pszData, char const *pszDelim, char **ppszSavePtr)
  2377. {
  2379. return (strtok_r(pszData, pszDelim, ppszSavePtr));
  2381. }
  2383. char *SysCTime(time_t * pTimer, char *pszBuffer, int iBufferSize)
  2384. {
  2386. return (ctime_r(pTimer, pszBuffer));
  2388. }
  2390. struct tm *SysLocalTime(time_t * pTimer, struct tm *pTStruct)
  2391. {
  2393. return (localtime_r(pTimer, pTStruct));
  2395. }
  2397. struct tm *SysGMTime(time_t * pTimer, struct tm *pTStruct)
  2398. {
  2400. return (gmtime_r(pTimer, pTStruct));
  2402. }
  2404. char *SysAscTime(struct tm *pTStruct, char *pszBuffer, int iBufferSize)
  2405. {
  2407. return (asctime_r(pTStruct, pszBuffer));
  2409. }
  2411. long SysGetTimeZone(void)
  2412. {
  2414. return ((long) timezone);
  2416. }
  2418. long SysGetDayLight(void)
  2419. {
  2421. time_t tCurr = time(NULL);
  2422. struct tm tmCurr;
  2424. localtime_r(&tCurr, &tmCurr);
  2426. return ((long) ((tmCurr.tm_isdst <= 0) ? 0 : 3600));
  2428. }
  2430. int SysGetDiskSpace(char const *pszPath, SYS_INT64 * pTotal, SYS_INT64 * pFree)
  2431. {
  2433. struct statfs SFS;
  2435. if (statfs(pszPath, &SFS) != 0) {
  2436. ErrSetErrorCode(ERR_GET_DISK_SPACE_INFO);
  2437. return (ERR_GET_DISK_SPACE_INFO);
  2438. }
  2440. *pTotal = (SYS_INT64) SFS.f_bsize * (SYS_INT64) SFS.f_blocks;
  2442. *pFree = (SYS_INT64) SFS.f_bsize * (SYS_INT64) SFS.f_bavail;
  2444. return (0);
  2446. }
  2448. int SysMemoryInfo(SYS_INT64 * pRamTotal, SYS_INT64 * pRamFree,
  2449.   SYS_INT64 * pVirtTotal, SYS_INT64 * pVirtFree)
  2450. {
  2452. struct sysinfo SI;
  2454. if (sysinfo(&SI) < 0) {
  2455. ErrSetErrorCode(ERR_GET_MEMORY_INFO);
  2456. return (ERR_GET_MEMORY_INFO);
  2457. }
  2459. *pRamTotal = (SYS_INT64) SI.totalram;
  2461. *pRamFree = (SYS_INT64) SI.freeram;
  2463. *pVirtTotal = (SYS_INT64) SI.totalswap + (SYS_INT64) SI.totalram;
  2465. *pVirtFree = (SYS_INT64) SI.freeswap + (SYS_INT64) SI.freeram;
  2467. return (0);
  2469. }
  2471. static unsigned int SysStkCall(unsigned int (*pProc) (void *), void *pData)
  2472. {
  2474. srand(getpid() * (unsigned int) time(NULL) * uSRandBase);
  2476. unsigned int uResult;
  2477. unsigned int uStkDisp =
  2478.     (unsigned int) (rand() % MAX_STACK_SHIFT) & ~(STACK_ALIGN_BYTES - 1);
  2479. void *pStkSpace = alloca(uStkDisp);
  2481. uResult = pProc(pData);
  2483. return (uResult);
  2485. }