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

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

Email服务器

开发平台：

Visual C++

MiscUtils.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 "SvrDefines.h"
  26. #include "ShBlocks.h"
  27. #include "StrUtils.h"
  28. #include "SList.h"
  29. #include "MD5.h"
  30. #include "Base64Enc.h"
  31. #include "BuffSock.h"
  32. #include "MailConfig.h"
  33. #include "UsrUtils.h"
  34. #include "SvrUtils.h"
  35. #include "MessQueue.h"
  36. #include "MailSvr.h"
  37. #include "MiscUtils.h"
  39. #define IPPROP_LINE_MAX             1024
  41. enum IPMapFileds {
  42. ipmFromIP = 0,
  43. ipmFromMask,
  44. ipmAllow,
  45. ipmPrecedence,
  47. ipmMax
  48. };
  50. struct FileScan {
  51. char szListFile[SYS_MAX_PATH];
  52. FILE *pListFile;
  53. };
  56. static int MscCopyFileLL(const char *pszCopyTo, const char *pszCopyFrom,
  57.  char const *pszMode);
  60. int MscUniqueFile(char const *pszDir, char *pszFilePath)
  61. {
  62. ///////////////////////////////////////////////////////////////////////////////
  63. //  Get thread ID and host name. We do not use atomic inc on ulUniqSeq, since
  64. //  collision is prevented by the thread ID
  65. ///////////////////////////////////////////////////////////////////////////////
  66. static unsigned long ulUniqSeq = 0;
  67. unsigned long ulThreadID = SysGetCurrentThreadId();
  68. SYS_INT64 iMsTime = SysMsTime();
  69. char szHostName[MAX_HOST_NAME] = "";
  71. gethostname(szHostName, sizeof(szHostName) - 1);
  73. sprintf(pszFilePath, "%s" SYS_SLASH_STR SYS_LLU_FMT ".%lu.%lx.%s",
  74. pszDir, iMsTime, ulThreadID, ulUniqSeq++, szHostName);
  76. return (0);
  78. }
  80. int MscRecvTextFile(const char *pszFileName, BSOCK_HANDLE hBSock, int iTimeout,
  81.     int (*pStopProc) (void *), void *pParam)
  82. {
  84. FILE *pFile = fopen(pszFileName, "wt");
  86. if (pFile == NULL) {
  87. ErrSetErrorCode(ERR_FILE_CREATE, pszFileName);
  88. return (ERR_FILE_CREATE);
  89. }
  91. char szBuffer[2048] = "";
  93. while (BSckGetString(hBSock, szBuffer, sizeof(szBuffer) - 1, iTimeout) != NULL) {
  94. if (strcmp(szBuffer, ".") == 0)
  95. break;
  97. if (szBuffer[0] == '.')
  98. fprintf(pFile, "%sn", szBuffer + 1);
  99. else
  100. fprintf(pFile, "%sn", szBuffer);
  102. if ((pStopProc != NULL) && pStopProc(pParam)) {
  103. fclose(pFile);
  104. return (ErrGetErrorCode());
  105. }
  106. }
  108. fclose(pFile);
  110. return (0);
  112. }
  114. int MscSendTextFile(const char *pszFileName, BSOCK_HANDLE hBSock, int iTimeout,
  115.     int (*pStopProc) (void *), void *pParam)
  116. {
  118. FILE *pFile = fopen(pszFileName, "rt");
  120. if (pFile == NULL) {
  121. ErrSetErrorCode(ERR_FILE_OPEN, pszFileName);
  122. return (ERR_FILE_OPEN);
  123. }
  125. char szBuffer[2048] = "";
  127. while (MscFGets(szBuffer, sizeof(szBuffer) - 1, pFile) != NULL) {
  128. if (szBuffer[0] == '.')
  129. for (int ii = strlen(szBuffer); ii >= 0; ii--)
  130. szBuffer[ii + 1] = szBuffer[ii];
  132. if (BSckSendString(hBSock, szBuffer, iTimeout) <= 0) {
  133. fclose(pFile);
  134. return (ErrGetErrorCode());
  135. }
  137. if ((pStopProc != NULL) && pStopProc(pParam)) {
  138. fclose(pFile);
  139. return (ErrGetErrorCode());
  140. }
  141. }
  143. fclose(pFile);
  145. return (BSckSendString(hBSock, ".", iTimeout));
  147. }
  149. char *MscTranslatePath(char *pszPath)
  150. {
  152. for (int ii = 0; pszPath[ii] != ''; ii++) {
  153. switch (pszPath[ii]) {
  154. case ('/'):
  155. case ('\'):
  156. pszPath[ii] = SYS_SLASH_CHAR;
  157. break;
  158. }
  159. }
  161. return (pszPath);
  163. }
  165. void *MscLoadFile(char const *pszFilePath, unsigned int &uFileSize)
  166. {
  168. FILE *pFile = fopen(pszFilePath, "rb");
  170. if (pFile == NULL) {
  171. ErrSetErrorCode(ERR_FILE_OPEN, pszFilePath);
  172. return (NULL);
  173. }
  175. fseek(pFile, 0, SEEK_END);
  177. uFileSize = (unsigned int) ftell(pFile);
  179. ///////////////////////////////////////////////////////////////////////////////
  180. //  Alloc one extra byte to enable placing a '' to terminate an eventual
  181. //  string representation and to avoid SysAlloc() to fail if uFileSize == 0
  182. ///////////////////////////////////////////////////////////////////////////////
  183. void *pFileData = SysAlloc(uFileSize + 1);
  185. if (pFileData == NULL) {
  186. fclose(pFile);
  187. return (NULL);
  188. }
  190. rewind(pFile);
  192. if (uFileSize != 0)
  193. fread(pFileData, uFileSize, 1, pFile);
  195. fclose(pFile);
  197. return (pFileData);
  199. }
  201. int MscLockFile(const char *pszFileName, int iMaxWait, int iWaitStep)
  202. {
  204. while ((iMaxWait > 0) && (SysLockFile(pszFileName) < 0)) {
  205. SysSleep(iWaitStep);
  207. iMaxWait -= iWaitStep;
  208. }
  210. return ((iMaxWait > 0) ? 0 : SysLockFile(pszFileName));
  212. }
  214. int MscGetTimeNbrString(char *pszTimeStr, int iStringSize, time_t tTime)
  215. {
  217. if (tTime == 0)
  218. time(&tTime);
  220. struct tm tmSession;
  222. SysLocalTime(&tTime, &tmSession);
  224. SysSNPrintf(pszTimeStr, iStringSize, "%04d-%02d-%02d %02d:%02d:%02d",
  225.     tmSession.tm_year + 1900,
  226.     tmSession.tm_mon + 1,
  227.     tmSession.tm_mday, tmSession.tm_hour, tmSession.tm_min, tmSession.tm_sec);
  229. return (0);
  231. }
  233. int MscGetTime(struct tm &tmLocal, int &iDiffHours, int &iDiffMins, time_t tCurr)
  234. {
  236. if (tCurr == 0)
  237. time(&tCurr);
  239. SysLocalTime(&tCurr, &tmLocal);
  241. struct tm tmTimeLOC = tmLocal;
  242. struct tm tmTimeGM;
  244. SysGMTime(&tCurr, &tmTimeGM);
  246. tmTimeLOC.tm_isdst = 0;
  247. tmTimeGM.tm_isdst = 0;
  249. time_t tLocal = mktime(&tmTimeLOC);
  250. time_t tGM = mktime(&tmTimeGM);
  252. int iSecsDiff = (int) difftime(tLocal, tGM);
  253. int iSignDiff = Sign(iSecsDiff);
  254. int iMinutes = Abs(iSecsDiff) / 60;
  256. iDiffMins = iMinutes % 60;
  257. iDiffHours = iSignDiff * (iMinutes / 60);
  259. return (0);
  261. }
  263. char *MscStrftime(struct tm const *ptmTime, char *pszDateStr, int iSize)
  264. {
  266. const char *pszWDays[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
  267. const char *pszMonths[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  268. "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  269. };
  271. SysSNPrintf(pszDateStr, iSize, "%s, %d %s %d %02d:%02d:%02d",
  272.     pszWDays[ptmTime->tm_wday], ptmTime->tm_mday,
  273.     pszMonths[ptmTime->tm_mon], ptmTime->tm_year + 1900,
  274.     ptmTime->tm_hour, ptmTime->tm_min, ptmTime->tm_sec);
  276. return (pszDateStr);
  278. }
  280. int MscGetTimeStr(char *pszTimeStr, int iStringSize, time_t tCurr)
  281. {
  283. int iDiffHours = 0;
  284. int iDiffMins = 0;
  285. struct tm tmTime;
  287. MscGetTime(tmTime, iDiffHours, iDiffMins, tCurr);
  289. char szDiffTime[128] = "";
  291. if (iDiffHours > 0)
  292. sprintf(szDiffTime, " +%02d%02d", iDiffHours, iDiffMins);
  293. else
  294. sprintf(szDiffTime, " -%02d%02d", -iDiffHours, iDiffMins);
  296. MscStrftime(&tmTime, pszTimeStr, iStringSize - strlen(szDiffTime) - 1);
  298. strcat(pszTimeStr, szDiffTime);
  300. return (0);
  302. }
  304. int MscGetDirectorySize(char const *pszPath, bool bRecurse, unsigned long &ulDirSize,
  305. unsigned long &ulNumFiles, int (*pFNValidate) (char const *))
  306. {
  308. char szFileName[SYS_MAX_PATH] = "";
  309. SYS_HANDLE hFind = SysFirstFile(pszPath, szFileName);
  311. if (hFind == SYS_INVALID_HANDLE)
  312. return (ErrGetErrorCode());
  314. ulDirSize = 0;
  316. do {
  317. if (SysIsDirectory(hFind)) {
  318. if (bRecurse && SYS_IS_VALID_FILENAME(szFileName)) {
  319. unsigned long ulSubDirSize = 0;
  320. unsigned long ulSubNumFiles = 0;
  321. char szSubPath[SYS_MAX_PATH] = "";
  323. StrSNCpy(szSubPath, pszPath);
  324. AppendSlash(szSubPath);
  325. StrSNCat(szSubPath, szFileName);
  327. if (MscGetDirectorySize(szSubPath, bRecurse, ulSubDirSize,
  328. ulSubNumFiles, pFNValidate) < 0) {
  329. ErrorPush();
  330. SysFindClose(hFind);
  331. return (ErrorPop());
  332. }
  334. ulNumFiles += ulSubNumFiles;
  335. ulDirSize += ulSubDirSize;
  336. }
  337. } else if ((pFNValidate == NULL) || pFNValidate(szFileName)) {
  338. ++ulNumFiles;
  340. ulDirSize += SysGetSize(hFind);
  341. }
  343. } while (SysNextFile(hFind, szFileName));
  345. SysFindClose(hFind);
  347. return (0);
  349. }
  351. FSCAN_HANDLE MscFirstFile(char const *pszPath, int iListDirs, char *pszFileName)
  352. {
  354. FileScan *pFS = (FileScan *) SysAlloc(sizeof(FileScan));
  356. if (pFS == NULL)
  357. return (INVALID_FSCAN_HANDLE);
  359. SysGetTmpFile(pFS->szListFile);
  361. if (MscGetFileList(pszPath, pFS->szListFile, iListDirs) < 0) {
  362. if (SysExistFile(pFS->szListFile))
  363. SysRemove(pFS->szListFile);
  364. SysFree(pFS);
  365. return (INVALID_FSCAN_HANDLE);
  366. }
  368. if ((pFS->pListFile = fopen(pFS->szListFile, "rb")) == NULL) {
  369. SysRemove(pFS->szListFile);
  370. SysFree(pFS);
  371. return (INVALID_FSCAN_HANDLE);
  372. }
  374. if (MscGetString(pFS->pListFile, pszFileName, SYS_MAX_PATH - 1) == NULL) {
  375. fclose(pFS->pListFile);
  376. SysRemove(pFS->szListFile);
  377. SysFree(pFS);
  378. return (INVALID_FSCAN_HANDLE);
  379. }
  381. return ((FSCAN_HANDLE) pFS);
  383. }
  385. int MscNextFile(FSCAN_HANDLE hFileScan, char *pszFileName)
  386. {
  388. FileScan *pFS = (FileScan *) hFileScan;
  390. if (MscGetString(pFS->pListFile, pszFileName, SYS_MAX_PATH - 1) == NULL)
  391. return (0);
  393. return (1);
  395. }
  397. void MscCloseFindFile(FSCAN_HANDLE hFileScan)
  398. {
  400. FileScan *pFS = (FileScan *) hFileScan;
  402. fclose(pFS->pListFile);
  404. SysRemove(pFS->szListFile);
  406. SysFree(pFS);
  408. }
  410. int MscGetFileList(char const *pszPath, const char *pszListFile, int iListDirs)
  411. {
  413. FILE *pListFile = fopen(pszListFile, "wb");
  415. if (pListFile == NULL) {
  416. ErrSetErrorCode(ERR_FILE_CREATE);
  417. return (ERR_FILE_CREATE);
  418. }
  420. char szFileName[SYS_MAX_PATH] = "";
  421. SYS_HANDLE hFind = SysFirstFile(pszPath, szFileName);
  423. if (hFind != SYS_INVALID_HANDLE) {
  424. do {
  425. if (iListDirs || !SysIsDirectory(hFind))
  426. fprintf(pListFile, "%srn", szFileName);
  428. } while (SysNextFile(hFind, szFileName));
  430. SysFindClose(hFind);
  431. }
  433. fclose(pListFile);
  435. return (0);
  437. }
  439. int MscCreateEmptyFile(const char *pszFileName)
  440. {
  442. FILE *pFile = fopen(pszFileName, "wb");
  444. if (pFile == NULL) {
  445. ErrSetErrorCode(ERR_FILE_CREATE);
  446. return (ERR_FILE_CREATE);
  447. }
  449. fclose(pFile);
  451. return (0);
  453. }
  455. int MscClearDirectory(const char *pszPath, int iRecurseSubs)
  456. {
  458. char szFileName[SYS_MAX_PATH] = "";
  459. SYS_HANDLE hFind = SysFirstFile(pszPath, szFileName);
  461. if (hFind == SYS_INVALID_HANDLE)
  462. return (0);
  464. char szTmpFileName[SYS_MAX_PATH] = "";
  466. SysGetTmpFile(szTmpFileName);
  468. FILE *pFile = fopen(szTmpFileName, "w+t");
  470. if (pFile == NULL) {
  471. SysFindClose(hFind);
  472. ErrSetErrorCode(ERR_FILE_CREATE);
  473. return (ERR_FILE_CREATE);
  474. }
  476. int iFileCount = 0;
  478. do {
  479. if (SysIsDirectory(hFind)) {
  480. if (iRecurseSubs && SYS_IS_VALID_FILENAME(szFileName)) {
  481. char szSubPath[SYS_MAX_PATH] = "";
  483. StrSNCpy(szSubPath, pszPath);
  484. AppendSlash(szSubPath);
  485. StrSNCat(szSubPath, szFileName);
  487. if (MscClearDirectory(szSubPath, iRecurseSubs) < 0) {
  488. fclose(pFile);
  489. SysRemove(szTmpFileName);
  490. return (ErrGetErrorCode());
  491. }
  493. if (SysRemoveDir(szSubPath) < 0) {
  494. fclose(pFile);
  495. SysRemove(szTmpFileName);
  496. return (ErrGetErrorCode());
  497. }
  498. }
  499. } else {
  500. fprintf(pFile, "%sn", szFileName);
  502. ++iFileCount;
  503. }
  505. } while (SysNextFile(hFind, szFileName));
  507. SysFindClose(hFind);
  509. if (iFileCount > 0) {
  510. fseek(pFile, 0, SEEK_SET);
  512. while (MscFGets(szFileName, sizeof(szFileName) - 1, pFile) != NULL) {
  513. char szFilePath[SYS_MAX_PATH] = "";
  515. StrSNCpy(szFilePath, pszPath);
  516. AppendSlash(szFilePath);
  517. StrSNCat(szFilePath, szFileName);
  519. if (SysRemove(szFilePath) < 0) {
  520. fclose(pFile);
  521. SysRemove(szTmpFileName);
  522. return (ErrGetErrorCode());
  523. }
  524. }
  525. }
  527. fclose(pFile);
  529. SysRemove(szTmpFileName);
  531. return (0);
  533. }
  535. static int MscCopyFileLL(const char *pszCopyTo, const char *pszCopyFrom,
  536.  char const *pszMode)
  537. {
  539. FILE *pFileIn = fopen(pszCopyFrom, "rb");
  541. if (pFileIn == NULL) {
  542. ErrSetErrorCode(ERR_FILE_OPEN);
  543. return (ERR_FILE_OPEN);
  544. }
  546. FILE *pFileOut = fopen(pszCopyTo, pszMode);
  548. if (pFileOut == NULL) {
  549. fclose(pFileIn);
  550. ErrSetErrorCode(ERR_FILE_CREATE);
  551. return (ERR_FILE_CREATE);
  552. }
  554. unsigned int uReaded;
  555. char szBuffer[2048];
  557. do {
  558. uReaded = fread(szBuffer, 1, sizeof(szBuffer), pFileIn);
  560. if (uReaded > 0) {
  561. if (fwrite(szBuffer, 1, uReaded, pFileOut) != uReaded) {
  562. fclose(pFileOut);
  563. fclose(pFileIn);
  564. SysRemove(pszCopyTo);
  566. ErrSetErrorCode(ERR_FILE_WRITE);
  567. return (ERR_FILE_WRITE);
  568. }
  569. }
  571. } while (uReaded == sizeof(szBuffer));
  573. fclose(pFileOut);
  574. fclose(pFileIn);
  576. return (0);
  578. }
  580. int MscCopyFile(const char *pszCopyTo, const char *pszCopyFrom)
  581. {
  583. return (MscCopyFileLL(pszCopyTo, pszCopyFrom, "wb"));
  585. }
  587. int MscAppendFile(const char *pszCopyTo, const char *pszCopyFrom)
  588. {
  590. return (MscCopyFileLL(pszCopyTo, pszCopyFrom, "a+b"));
  592. }
  594. int MscCopyFile(FILE * pFileOut, FILE * pFileIn, unsigned long ulBaseOffset,
  595. unsigned long ulCopySize)
  596. {
  597. ///////////////////////////////////////////////////////////////////////////////
  598. //  Setup copy size and seek start byte
  599. ///////////////////////////////////////////////////////////////////////////////
  600. if (ulBaseOffset == (unsigned long) -1)
  601. ulBaseOffset = (unsigned long) ftell(pFileIn);
  603. fseek(pFileIn, 0, SEEK_END);
  605. unsigned long ulFileSize = (unsigned long) ftell(pFileIn);
  607. if (ulCopySize == (unsigned long) -1)
  608. ulCopySize = ulFileSize - ulBaseOffset;
  609. else
  610. ulCopySize = Min(ulCopySize, ulFileSize - ulBaseOffset);
  612. fseek(pFileIn, ulBaseOffset, SEEK_SET);
  614. ///////////////////////////////////////////////////////////////////////////////
  615. //  Copy bytes
  616. ///////////////////////////////////////////////////////////////////////////////
  617. char szBuffer[2048];
  619. while (ulCopySize > 0) {
  620. unsigned int uToRead = (unsigned int) Min(ulCopySize, sizeof(szBuffer));
  621. unsigned int uReaded = fread(szBuffer, 1, uToRead, pFileIn);
  623. if (uReaded > 0) {
  624. if (fwrite(szBuffer, 1, uReaded, pFileOut) != uReaded) {
  625. ErrSetErrorCode(ERR_FILE_WRITE);
  626. return (ERR_FILE_WRITE);
  627. }
  629. ulCopySize -= uReaded;
  630. }
  632. if (uReaded != uToRead) {
  633. ErrSetErrorCode(ERR_FILE_READ);
  634. return (ERR_FILE_READ);
  635. }
  636. }
  638. return (0);
  640. }
  642. int MscMoveFile(char const *pszOldName, char const *pszNewName)
  643. {
  645. if (MscCopyFile(pszNewName, pszOldName) < 0)
  646. return (ErrGetErrorCode());
  648. return (SysRemove(pszOldName));
  650. }
  652. char *MscGetString(FILE * pFile, char *pszBuffer, int iMaxChars)
  653. {
  655. return ((fgets(pszBuffer, iMaxChars, pFile) != NULL) ? StrEOLTrim(pszBuffer) : NULL);
  657. }
  659. char *MscFGets(char *pszLine, int iLineSize, FILE * pFile)
  660. {
  662. if (fgets(pszLine, iLineSize, pFile) == NULL)
  663. return (NULL);
  665. int ii;
  667. for (ii = strlen(pszLine); (ii > 0) && ((pszLine[ii - 1] == 'r') ||
  668. (pszLine[ii - 1] == 'n')); ii--);
  669. pszLine[ii] = '';
  671. return (pszLine);
  673. }
  675. char *MscGetConfigLine(char *pszLine, int iLineSize, FILE * pFile, bool bSkipComments)
  676. {
  678. while (MscFGets(pszLine, iLineSize, pFile) != NULL) {
  680. if ((strlen(pszLine) > 0) && (!bSkipComments || (pszLine[0] != TAB_COMMENT_CHAR)))
  681. return (pszLine);
  683. }
  685. ErrSetErrorCode(ERR_FILE_EOF);
  686. return (NULL);
  688. }
  690. int MscGetPeerHost(SYS_SOCKET SockFD, char *pszFQDN)
  691. {
  693. SYS_INET_ADDR PeerInfo;
  695. if (SysGetPeerInfo(SockFD, PeerInfo) < 0)
  696. return (ErrGetErrorCode());
  698. return (SysGetHostByAddr(PeerInfo, pszFQDN));
  700. }
  702. int MscGetSockHost(SYS_SOCKET SockFD, char *pszFQDN)
  703. {
  705. SYS_INET_ADDR SockInfo;
  707. if (SysGetSockInfo(SockFD, SockInfo) < 0)
  708. return (ErrGetErrorCode());
  710. return (SysGetHostByAddr(SockInfo, pszFQDN));
  712. }
  714. int MscGetServerAddress(char const *pszServer, SYS_INET_ADDR & SvrAddr, int iPortNo)
  715. {
  717. char szServer[MAX_HOST_NAME] = "";
  719. ZeroData(SvrAddr);
  721. if (MscSplitAddressPort(pszServer, szServer, iPortNo, iPortNo) < 0)
  722. return (ErrGetErrorCode());
  724. NET_ADDRESS NetAddr;
  726. if ((SysInetAddr(szServer, NetAddr) < 0) && (SysGetHostByName(szServer, NetAddr) < 0))
  727. return (ErrGetErrorCode());
  729. SysSetupAddress(SvrAddr, AF_INET, NetAddr, iPortNo);
  731. return (0);
  733. }
  735. int MscSplitFQDN(const char *pszFQDN, char *pszHost, char *pszDomain)
  736. {
  738. const char *pszDot = strchr(pszFQDN, '.');
  740. if (pszDot == NULL) {
  741. if (pszHost != NULL)
  742. strcpy(pszHost, pszFQDN);
  744. if (pszDomain != NULL)
  745. SetEmptyString(pszDomain);
  746. } else {
  747. if (pszHost != NULL) {
  748. int iHostLength = (int) (pszDot - pszFQDN);
  750. strncpy(pszHost, pszFQDN, iHostLength);
  751. pszHost[iHostLength] = '';
  752. }
  754. if (pszDomain != NULL) {
  755. strcpy(pszDomain, pszDot + 1);
  757. int iDomainLength = strlen(pszDomain);
  759. if ((iDomainLength > 0) && (pszDomain[iDomainLength - 1] == '.'))
  760. pszDomain[iDomainLength - 1] = '';
  761. }
  762. }
  764. return (0);
  766. }
  768. char *MscLogFilePath(char const *pszLogFile, char *pszLogFilePath)
  769. {
  771. time_t tCurrent;
  773. time(&tCurrent);
  775. long lRotStep = (unsigned long) (3600L * iLogRotateHours);
  776. long lTimeZone = SysGetTimeZone();
  777. long lDayLight = SysGetDayLight();
  778. time_t tLogFileTime = (time_t) (NbrFloor((SYS_INT64) tCurrent - lTimeZone + lDayLight,
  779.  lRotStep) + lTimeZone - lDayLight);
  780. struct tm tmLocTime;
  781. char szLogsDir[SYS_MAX_PATH] = "";
  783. SysLocalTime(&tLogFileTime, &tmLocTime);
  785. SvrGetLogsDir(szLogsDir, sizeof(szLogsDir));
  786. AppendSlash(szLogsDir);
  788. sprintf(pszLogFilePath, "%s%s-%04d%02d%02d%02d%02d",
  789. szLogsDir, pszLogFile,
  790. tmLocTime.tm_year + 1900,
  791. tmLocTime.tm_mon + 1, tmLocTime.tm_mday, tmLocTime.tm_hour, tmLocTime.tm_min);
  793. return (pszLogFilePath);
  795. }
  797. int MscFileLog(char const *pszLogFile, char const *pszFormat, ...)
  798. {
  800. char szLogFilePath[SYS_MAX_PATH] = "";
  802. MscLogFilePath(pszLogFile, szLogFilePath);
  804. FILE *pLogFile = fopen(szLogFilePath, "a+t");
  806. if (pLogFile == NULL) {
  807. ErrSetErrorCode(ERR_FILE_OPEN);
  808. return (ERR_FILE_OPEN);
  809. }
  811. va_list Args;
  813. va_start(Args, pszFormat);
  815. vfprintf(pLogFile, pszFormat, Args);
  817. va_end(Args);
  819. fclose(pLogFile);
  821. return (0);
  823. }
  825. int MscSplitPath(char const *pszFilePath, char *pszDir, char *pszFName, char *pszExt)
  826. {
  828. char const *pszSlash = strrchr(pszFilePath, SYS_SLASH_CHAR);
  829. char const *pszFile = NULL;
  831. if (pszSlash != NULL) {
  832. pszFile = pszSlash + 1;
  834. if (pszDir != NULL) {
  835. int iDirLength = (int) (pszFile - pszFilePath);
  837. strncpy(pszDir, pszFilePath, iDirLength);
  838. pszDir[iDirLength] = '';
  839. }
  840. } else {
  841. pszFile = pszFilePath;
  843. if (pszDir != NULL)
  844. SetEmptyString(pszDir);
  845. }
  847. char const *pszDot = strrchr(pszFile, '.');
  849. if (pszDot != NULL) {
  850. if (pszFName != NULL) {
  851. int iNameLength = (int) (pszDot - pszFile);
  853. strncpy(pszFName, pszFile, iNameLength);
  854. pszFName[iNameLength] = '';
  855. }
  857. if (pszExt != NULL)
  858. strcpy(pszExt, pszDot);
  859. } else {
  860. if (pszFName != NULL)
  861. strcpy(pszFName, pszFile);
  863. if (pszExt != NULL)
  864. SetEmptyString(pszExt);
  865. }
  867. return (0);
  869. }
  871. int MscGetFileName(char const *pszFilePath, char *pszFileName)
  872. {
  874. char const *pszSlash = strrchr(pszFilePath, SYS_SLASH_CHAR);
  876. strcpy(pszFileName, (pszSlash != NULL) ? (pszSlash + 1) : pszFilePath);
  878. return (0);
  880. }
  882. int MscCreateClientSocket(char const *pszServer, int iPortNo, int iSockType,
  883.   SYS_SOCKET * pSockFD, SYS_INET_ADDR * pSvrAddr,
  884.   SYS_INET_ADDR * pSockAddr, int iTimeout)
  885. {
  886. ///////////////////////////////////////////////////////////////////////////////
  887. //  Get server address
  888. ///////////////////////////////////////////////////////////////////////////////
  889. SYS_INET_ADDR SvrAddr;
  891. if (MscGetServerAddress(pszServer, SvrAddr, iPortNo) < 0)
  892. return (ErrGetErrorCode());
  894. SYS_SOCKET SockFD = SysCreateSocket(AF_INET, iSockType, 0);
  896. if (SockFD == SYS_INVALID_SOCKET)
  897. return (ErrGetErrorCode());
  899. if (SysConnect(SockFD, &SvrAddr, sizeof(SvrAddr), iTimeout) < 0) {
  900. ErrorPush();
  901. SysCloseSocket(SockFD);
  902. return (ErrorPop());
  903. }
  905. SYS_INET_ADDR SockAddr;
  907. ZeroData(SockAddr);
  909. if (SysGetSockInfo(SockFD, SockAddr) < 0) {
  910. ErrorPush();
  911. SysCloseSocket(SockFD);
  912. return (ErrorPop());
  913. }
  915. *pSockFD = SockFD;
  917. if (pSvrAddr != NULL)
  918. *pSvrAddr = SvrAddr;
  920. if (pSockAddr != NULL)
  921. *pSockAddr = SockAddr;
  923. return (0);
  925. }
  927. int MscCreateServerSockets(int iNumAddr, SYS_INET_ADDR const *pSvrAddr, int iPortNo,
  928.    int iListenSize, SYS_SOCKET * pSockFDs, int &iNumSockFDs)
  929. {
  931. if (iNumAddr == 0) {
  932. SYS_SOCKET SvrSockFD = SysCreateSocket(AF_INET, SOCK_STREAM, 0);
  934. if (SvrSockFD == SYS_INVALID_SOCKET)
  935. return (ErrGetErrorCode());
  937. SYS_INET_ADDR InSvrAddr;
  939. SysSetupAddress(InSvrAddr, AF_INET, htonl(INADDR_ANY), iPortNo);
  941. if (SysBindSocket(SvrSockFD, (struct sockaddr *) &InSvrAddr, sizeof(InSvrAddr)) <
  942.     0) {
  943. ErrorPush();
  944. SysCloseSocket(SvrSockFD);
  945. return (ErrorPop());
  946. }
  948. SysListenSocket(SvrSockFD, iListenSize);
  950. *pSockFDs = SvrSockFD;
  951. iNumSockFDs = 1;
  952. } else {
  953. iNumSockFDs = 0;
  955. for (int ii = 0; ii < iNumAddr; ii++) {
  956. SYS_SOCKET SvrSockFD = SysCreateSocket(AF_INET, SOCK_STREAM, 0);
  958. if (SvrSockFD == SYS_INVALID_SOCKET) {
  959. ErrorPush();
  960. for (--iNumSockFDs; iNumSockFDs >= 0; iNumSockFDs--)
  961. SysCloseSocket(pSockFDs[iNumSockFDs]);
  962. return (ErrorPop());
  963. }
  965. SYS_INET_ADDR InSvrAddr = pSvrAddr[ii];
  967. if (SysGetAddrPort(InSvrAddr) == 0)
  968. SysSetAddrPort(InSvrAddr, iPortNo);
  970. if (SysBindSocket
  971.     (SvrSockFD, (struct sockaddr *) &InSvrAddr, sizeof(InSvrAddr)) < 0) {
  972. ErrorPush();
  973. SysCloseSocket(SvrSockFD);
  974. for (--iNumSockFDs; iNumSockFDs >= 0; iNumSockFDs--)
  975. SysCloseSocket(pSockFDs[iNumSockFDs]);
  976. return (ErrorPop());
  977. }
  979. SysListenSocket(SvrSockFD, iListenSize);
  981. pSockFDs[iNumSockFDs++] = SvrSockFD;
  982. }
  983. }
  985. return (0);
  987. }
  989. int MscGetMaxSockFD(SYS_SOCKET const *pSockFDs, int iNumSockFDs)
  990. {
  992. int iMaxFD = 0;
  994. for (int ii = 0; ii < iNumSockFDs; ii++)
  995. if (iMaxFD < (int) pSockFDs[ii])
  996. iMaxFD = (int) pSockFDs[ii];
  998. return (iMaxFD);
  1000. }
  1002. int MscAcceptServerConnection(SYS_SOCKET const *pSockFDs, int iNumSockFDs,
  1003.       SYS_SOCKET * pConnSockFD, int &iNumConnSockFD, int iTimeout)
  1004. {
  1006. int ii;
  1007. SYS_fd_set fdReadSet;
  1009. ZeroData(fdReadSet);
  1010. SYS_FD_ZERO(&fdReadSet);
  1012. for (ii = 0; ii < iNumSockFDs; ii++)
  1013. SYS_FD_SET(pSockFDs[ii], &fdReadSet);
  1015. int iSelectResult = SysSelect(MscGetMaxSockFD(pSockFDs, iNumSockFDs),
  1016.       &fdReadSet, NULL, NULL, iTimeout);
  1018. if (iSelectResult < 0)
  1019. return (ErrGetErrorCode());
  1021. iNumConnSockFD = 0;
  1023. for (ii = 0; ii < iNumSockFDs; ii++) {
  1024. if (SYS_FD_ISSET(pSockFDs[ii], &fdReadSet)) {
  1025. SYS_INET_ADDR ConnAddr;
  1026. int iConnAddrLength = sizeof(ConnAddr);
  1028. ZeroData(ConnAddr);
  1030. SYS_SOCKET ConnSockFD = SysAccept(pSockFDs[ii], &ConnAddr,
  1031.   &iConnAddrLength, iTimeout);
  1033. if (ConnSockFD != SYS_INVALID_SOCKET)
  1034. pConnSockFD[iNumConnSockFD++] = ConnSockFD;
  1035. }
  1036. }
  1038. return (0);
  1040. }
  1042. int MscLoadAddressFilter(char const *const *ppszFilter, int iNumTokens, AddressFilter & AF)
  1043. {
  1045. ZeroData(AF);
  1047. if (iNumTokens > 1) {
  1048. SysInetAddr(ppszFilter[0], *((NET_ADDRESS *) AF.Addr));
  1049. SysInetAddr(ppszFilter[1], *((NET_ADDRESS *) AF.Mask));
  1050. } else {
  1051. char const *pszMask;
  1053. if ((pszMask = strchr(ppszFilter[0], '/')) != NULL) {
  1054. int ii;
  1055. int iAddrLength = (int) (pszMask - ppszFilter[0]);
  1056. int iMaskBits = atoi(pszMask + 1);
  1057. char szFilter[128];
  1059. iAddrLength = Min(iAddrLength, sizeof(szFilter) - 1);
  1060. strncpy(szFilter, ppszFilter[0], iAddrLength);
  1061. szFilter[iAddrLength] = '';
  1063. SysInetAddr(szFilter, *((NET_ADDRESS *) AF.Addr));
  1065. iMaskBits = Min(iMaskBits, 8 * sizeof(NET_ADDRESS));
  1066. for (ii = 0; (ii + 8) <= iMaskBits; ii += 8)
  1067. AF.Mask[ii / 8] = 0xff;
  1068. if (ii < iMaskBits)
  1069. AF.Mask[ii / 8] =
  1070.     (SYS_UINT8) (((1 << (iMaskBits - ii)) - 1) << (8 - iMaskBits +
  1071.    ii));
  1072. } else {
  1073. SysInetAddr(ppszFilter[0], *((NET_ADDRESS *) AF.Addr));
  1075. for (int ii = 0; ii < sizeof(NET_ADDRESS); ii++)
  1076. AF.Mask[ii] = (AF.Addr[ii] != 0) ? 0xff : 0x00;
  1077. }
  1078. }
  1080. return (0);
  1082. }
  1084. bool MscAddressMatch(AddressFilter const &AF, NET_ADDRESS const &TestAddr)
  1085. {
  1087. SYS_UINT8 ByteAddr[sizeof(NET_ADDRESS)];
  1089. *((NET_ADDRESS *) ByteAddr) = TestAddr;
  1091. for (int ii = 0; ii < sizeof(NET_ADDRESS); ii++)
  1092. if ((ByteAddr[ii] & AF.Mask[ii]) != (AF.Addr[ii] & AF.Mask[ii]))
  1093. return (false);
  1095. return (true);
  1097. }
  1099. int MscCheckAllowedIP(char const *pszMapFile, const SYS_INET_ADDR & PeerInfo, bool bDefault)
  1100. {
  1102. FILE *pMapFile = fopen(pszMapFile, "rt");
  1104. if (pMapFile == NULL) {
  1105. ErrSetErrorCode(ERR_FILE_OPEN, pszMapFile);
  1106. return (ERR_FILE_OPEN);
  1107. }
  1109. NET_ADDRESS TestAddr;
  1111. SysGetAddrAddress(PeerInfo, TestAddr);
  1113. bool bAllow = bDefault;
  1114. int iPrecedence = -1;
  1115. char szMapLine[512] = "";
  1117. while (MscGetConfigLine(szMapLine, sizeof(szMapLine) - 1, pMapFile) != NULL) {
  1118. char **ppszStrings = StrGetTabLineStrings(szMapLine);
  1120. if (ppszStrings == NULL)
  1121. continue;
  1123. int iFieldsCount = StrStringsCount(ppszStrings);
  1124. AddressFilter AF;
  1126. if ((iFieldsCount >= ipmMax) &&
  1127.     (MscLoadAddressFilter(ppszStrings, iFieldsCount, AF) == 0) &&
  1128.     MscAddressMatch(AF, TestAddr)) {
  1129. int iCurrPrecedence = atoi(ppszStrings[ipmPrecedence]);
  1131. if (iCurrPrecedence >= iPrecedence) {
  1132. iPrecedence = iCurrPrecedence;
  1134. bAllow =
  1135.     (stricmp(ppszStrings[ipmAllow], "ALLOW") == 0) ? true : false;
  1136. }
  1137. }
  1139. StrFreeStrings(ppszStrings);
  1140. }
  1142. fclose(pMapFile);
  1144. if (!bAllow) {
  1145. ErrSetErrorCode(ERR_IP_NOT_ALLOWED);
  1146. return (ERR_IP_NOT_ALLOWED);
  1147. }
  1149. return (0);
  1151. }
  1153. char **MscGetIPProperties(char const *pszFileName, const SYS_INET_ADDR & PeerInfo)
  1154. {
  1156. ///////////////////////////////////////////////////////////////////////////////
  1157. //  Get peer IP addresses
  1158. ///////////////////////////////////////////////////////////////////////////////
  1159. NET_ADDRESS PeerAddr;
  1161. SysGetAddrAddress(PeerInfo, PeerAddr);
  1163. ///////////////////////////////////////////////////////////////////////////////
  1164. //  Open the IP properties database. Fail smoothly if the file does not exist
  1165. ///////////////////////////////////////////////////////////////////////////////
  1166. FILE *pFile = fopen(pszFileName, "rt");
  1168. if (pFile == NULL)
  1169. return (NULL);
  1171. char szLine[IPPROP_LINE_MAX] = "";
  1173. while (MscGetConfigLine(szLine, sizeof(szLine) - 1, pFile) != NULL) {
  1174. char **ppszTokens = StrGetTabLineStrings(szLine);
  1176. if (ppszTokens == NULL)
  1177. continue;
  1179. int iFieldsCount = StrStringsCount(ppszTokens);
  1180. AddressFilter AFPeer;
  1182. if ((iFieldsCount >= 1) && (MscLoadAddressFilter(&ppszTokens[0], 1, AFPeer) == 0)
  1183.     && MscAddressMatch(AFPeer, PeerAddr)) {
  1184. fclose(pFile);
  1185. return (ppszTokens);
  1186. }
  1188. StrFreeStrings(ppszTokens);
  1189. }
  1191. fclose(pFile);
  1193. return (NULL);
  1195. }
  1197. int MscMD5Authenticate(const char *pszPassword, const char *pszTimeStamp, const char *pszDigest)
  1198. {
  1200. char *pszHash = StrSprint("%s%s", pszTimeStamp, pszPassword);
  1202. if (pszHash == NULL)
  1203. return (ErrGetErrorCode());
  1205. char szMD5[128] = "";
  1207. do_md5_string(pszHash, strlen(pszHash), szMD5);
  1209. SysFree(pszHash);
  1211. if (stricmp(pszDigest, szMD5) != 0) {
  1212. ErrSetErrorCode(ERR_MD5_AUTH_FAILED);
  1213. return (ERR_MD5_AUTH_FAILED);
  1214. }
  1216. return (0);
  1218. }
  1220. char *MscExtractServerTimeStamp(char const *pszResponse, char *pszTimeStamp, int iMaxTimeStamp)
  1221. {
  1223. char const *pszStartTS = strchr(pszResponse, '<');
  1224. char const *pszEndTS = strchr(pszResponse, '>');
  1226. if ((pszStartTS == NULL) || (pszEndTS == NULL))
  1227. return (NULL);
  1229. int iLengthTS = (int) (pszEndTS - pszStartTS) + 1;
  1231. if (iLengthTS <= 0)
  1232. return (NULL);
  1234. iLengthTS = Min(iLengthTS, iMaxTimeStamp - 1);
  1236. strncpy(pszTimeStamp, pszStartTS, iLengthTS);
  1237. pszTimeStamp[iLengthTS] = '';
  1239. return (pszTimeStamp);
  1241. }
  1243. int MscBase64FileEncode(char const *pszBoundary, char const *pszFilePath, FILE * pFileOut)
  1244. {
  1246. FILE *pFileIn = fopen(pszFilePath, "rb");
  1248. if (pFileIn == NULL) {
  1249. ErrSetErrorCode(ERR_FILE_OPEN, pszFilePath);
  1250. return (ERR_FILE_OPEN);
  1251. }
  1253. char szFName[SYS_MAX_PATH] = "";
  1254. char szExt[SYS_MAX_PATH] = "";
  1256. MscSplitPath(pszFilePath, NULL, szFName, szExt);
  1258. fprintf(pFileOut, "rn--%srn"
  1259. "Content-Type: application/octet-stream;rn"
  1260. "tname="%s%s"rn"
  1261. "Content-Transfer-Encoding: base64rn"
  1262. "Content-Disposition: attachment;rn"
  1263. "tfilename="%s%s"rnrn", pszBoundary, szFName, szExt, szFName, szExt);
  1265. ///////////////////////////////////////////////////////////////////////////////
  1266. //  Note that sizeof(szFileBuffer) must be multiple of 3
  1267. ///////////////////////////////////////////////////////////////////////////////
  1268. unsigned int uReadSize;
  1269. char szFileBuffer[80 * 3] = "";
  1270. char szEncBuffer[512] = "";
  1272. do {
  1273. uReadSize = fread(szFileBuffer, 1, sizeof(szFileBuffer), pFileIn);
  1275. if (uReadSize > 0) {
  1276. unsigned int uOutLength = sizeof(szEncBuffer);
  1278. encode64(szFileBuffer, uReadSize, szEncBuffer, sizeof(szEncBuffer) - 1,
  1279.  &uOutLength);
  1281. unsigned int uWriteSize = 80;
  1282. char *pszWrite = szEncBuffer;
  1284. for (; uOutLength > 0; uOutLength -= uWriteSize, pszWrite += uWriteSize) {
  1285. uWriteSize = Min(uOutLength, uWriteSize);
  1287. if (!fwrite(pszWrite, uWriteSize, 1, pFileOut)) {
  1288. fclose(pFileIn);
  1290. ErrSetErrorCode(ERR_FILE_WRITE);
  1291. return (ERR_FILE_WRITE);
  1292. }
  1294. fputs("rn", pFileOut);
  1295. }
  1296. }
  1298. } while (uReadSize == sizeof(szFileBuffer));
  1300. fclose(pFileIn);
  1302. return (0);
  1304. }
  1306. int MscRootedName(char const *pszHostName)
  1307. {
  1309. char const *pszDot = strrchr(pszHostName, '.');
  1311. return ((pszDot == NULL) ? 0 : ((strlen(pszDot) == 0) ? 1 : 0));
  1313. }
  1315. int MscCramMD5(char const *pszSecret, char const *pszChallenge, char *pszDigest)
  1316. {
  1318. int iLenght = (int) strlen(pszSecret);
  1319. struct md5_ctx ctx;
  1320. unsigned char isecret[64];
  1321. unsigned char osecret[64];
  1322. unsigned char md5secret[16];
  1324. if (iLenght > 64) {
  1325. md5_init_ctx(&ctx);
  1326. md5_process_bytes(pszSecret, iLenght, &ctx);
  1327. md5_finish_ctx(&ctx, md5secret);
  1329. pszSecret = (char const *) md5secret;
  1330. iLenght = 16;
  1331. }
  1333. ZeroData(isecret);
  1334. memcpy(isecret, pszSecret, iLenght);
  1336. ZeroData(osecret);
  1337. memcpy(osecret, pszSecret, iLenght);
  1339. for (int ii = 0; ii < 64; ii++) {
  1340. isecret[ii] ^= 0x36;
  1341. osecret[ii] ^= 0x5c;
  1342. }
  1344. md5_init_ctx(&ctx);
  1345. md5_process_bytes(isecret, 64, &ctx);
  1346. md5_process_bytes((unsigned char *) pszChallenge, (int) strlen(pszChallenge), &ctx);
  1347. md5_finish_ctx(&ctx, md5secret);
  1349. md5_init_ctx(&ctx);
  1350. md5_process_bytes(osecret, 64, &ctx);
  1351. md5_process_bytes(md5secret, 16, &ctx);
  1352. md5_finish_ctx(&ctx, md5secret);
  1354. md5_hex(md5secret, pszDigest);
  1356. return (0);
  1358. }
  1360. SYS_UINT32 MscHashString(char const *pszBuffer, int iLength, SYS_UINT32 uHashInit)
  1361. {
  1363. SYS_UINT32 uHashVal = uHashInit;
  1365. while (iLength > 0) {
  1366. --iLength;
  1368. uHashVal += (uHashVal << 5);
  1369. uHashVal ^= (SYS_UINT32) * pszBuffer++;
  1370. }
  1372. return (uHashVal);
  1374. }
  1376. int MscSplitAddressPort(char const *pszConnSpec, char *pszAddress, int &iPortNo, int iDefPortNo)
  1377. {
  1379. char const *pszEnd = NULL, *pszPort;
  1381. iPortNo = iDefPortNo;
  1383. if (*pszConnSpec == '[') {
  1384. pszConnSpec++;
  1385. if ((pszEnd = strchr(pszConnSpec, ']')) == NULL) {
  1386. ErrSetErrorCode(ERR_BAD_SERVER_ADDR);
  1387. return (ERR_BAD_SERVER_ADDR);
  1388. }
  1389. if ((pszPort = strrchr(pszEnd + 1, '|')) == NULL)
  1390. pszPort = strrchr(pszEnd + 1, ':');
  1391. if (pszPort != NULL)
  1392. iPortNo = atoi(pszPort + 1);
  1393. } else {
  1394. if ((pszPort = strrchr(pszConnSpec, '|')) == NULL)
  1395. pszPort = strrchr(pszConnSpec, ':');
  1396. if ((pszEnd = pszPort) != NULL)
  1397. iPortNo = atoi(pszPort + 1);
  1398. }
  1400. if (pszEnd != NULL) {
  1401. int iAddrLen = Min((int) (pszEnd - pszConnSpec), MAX_HOST_NAME - 1);
  1403. strncpy(pszAddress, pszConnSpec, iAddrLen);
  1404. pszAddress[iAddrLen] = '';
  1405. } else
  1406. strncpy(pszAddress, pszConnSpec, MAX_HOST_NAME - 1);
  1408. return (0);
  1410. }
  1412. SYS_UINT16 MscReadUint16(void const *pData)
  1413. {
  1414. SYS_UINT16 uValue;
  1416. memcpy(&uValue, pData, sizeof(uValue));
  1418. return (uValue);
  1420. }
  1422. SYS_UINT32 MscReadUint32(void const *pData)
  1423. {
  1425. SYS_UINT32 uValue;
  1427. memcpy(&uValue, pData, sizeof(uValue));
  1429. return (uValue);
  1431. }
  1433. SYS_UINT64 MscReadUint64(void const *pData)
  1434. {
  1436. SYS_UINT64 uValue;
  1438. memcpy(&uValue, pData, sizeof(uValue));
  1440. return (uValue);
  1442. }
  1444. void *MscWriteUint16(void *pData, SYS_UINT16 uValue)
  1445. {
  1447. return (memcpy(pData, &uValue, sizeof(uValue)));
  1449. }
  1451. void *MscWriteUint32(void *pData, SYS_UINT32 uValue)
  1452. {
  1454. return (memcpy(pData, &uValue, sizeof(uValue)));
  1456. }
  1458. void *MscWriteUint64(void *pData, SYS_UINT64 uValue)
  1459. {
  1461. return (memcpy(pData, &uValue, sizeof(uValue)));
  1463. }
  1465. int MscCmdStringCheck(char const *pszString)
  1466. {
  1468. for (; *pszString != ''; pszString++)
  1469. if (((*pszString < ' ') || (*pszString > '~')) && (*pszString != 't')) {
  1470. ErrSetErrorCode(ERR_BAD_CMDSTR_CHARS);
  1471. return (ERR_BAD_CMDSTR_CHARS);
  1472. }
  1474. return (0);
  1476. }
  1478. int MscGetSectionSize(FileSection const *pFS, unsigned long *pulSize)
  1479. {
  1481. if (pFS->ulEndOffset == (unsigned long) -1) {
  1482. SYS_FILE_INFO FI;
  1484. if (SysGetFileInfo(pFS->szFilePath, FI) < 0)
  1485. return (ErrGetErrorCode());
  1487. *pulSize = FI.ulSize - pFS->ulStartOffset;
  1488. } else
  1489. *pulSize = pFS->ulEndOffset - pFS->ulStartOffset;
  1491. return (0);
  1493. }