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

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

Email服务器

开发平台：

Visual C++

UsrUtils.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 "ResLocks.h"
  28. #include "StrUtils.h"
  29. #include "SList.h"
  30. #include "BuffSock.h"
  31. #include "MailConfig.h"
  32. #include "UsrUtils.h"
  33. #include "SvrUtils.h"
  34. #include "MessQueue.h"
  35. #include "SMAILUtils.h"
  36. #include "QueueUtils.h"
  37. #include "MailSvr.h"
  38. #include "MiscUtils.h"
  39. #include "MailDomains.h"
  40. #include "POP3GwLink.h"
  41. #include "ExtAliases.h"
  42. #include "Maildir.h"
  43. #include "TabIndex.h"
  44. #include "SMTPUtils.h"
  45. #include "AliasDomain.h"
  46. #include "UsrAuth.h"
  48. #define SVR_TABLE_FILE              "mailusers.tab"
  49. #define SVR_ALIAS_FILE              "aliases.tab"
  50. #define WILD_ALIASES_HASH           0
  51. #define USR_TABLE_LINE_MAX          2048
  52. #define USR_ALIAS_LINE_MAX          512
  53. #define USER_PROFILE_FILE           "user.tab"
  54. #define DEFAULT_USER_PROFILE_FILE   "userdef.tab"
  55. #define MAILBOX_DIRECTORY           "mailbox"
  57. #define POP3_LOCKS_DIR              "pop3locks"
  58. #define MLUSERS_TABLE_FILE          "mlusers.tab"
  59. #define MAILPROCESS_FILE            "mailproc.tab"
  61. enum UsrFileds {
  62. usrDomain = 0,
  63. usrName,
  64. usrPassword,
  65. usrID,
  66. usrPath,
  67. usrType,
  69. usrMax
  70. };
  72. struct UserInfoVar {
  73. LISTLINK LL;
  74. char *pszName;
  75. char *pszValue;
  76. };
  78. enum AliasFileds {
  79. alsDomain = 0,
  80. alsAlias,
  81. alsName,
  83. alsMax
  84. };
  86. struct UsersDBScanData {
  87. char szTmpDBFile[SYS_MAX_PATH];
  88. FILE *pDBFile;
  89. };
  91. struct AliasDBScanData {
  92. char szTmpDBFile[SYS_MAX_PATH];
  93. FILE *pDBFile;
  94. };
  96. static int UsrCalcAliasHash(char const *const *ppszTabTokens, int const *piFieldsIdx,
  97.     SYS_UINT32 * puHashVal, bool bCaseSens);
  98. static int UsrRebuildUsersIndexes(char const *pszUsrFilePath);
  99. static int UsrRebuildAliasesIndexes(char const *pszAlsFilePath);
  100. static char *UsrGetTableFilePath(char *pszUsrFilePath, int iMaxPath);
  101. static char *UsrGetAliasFilePath(char *pszAlsFilePath, int iMaxPath);
  102. static UserInfo *UsrGetUserFromStrings(char **ppszStrings);
  103. static UserInfoVar *UsrAllocVar(const char *pszName, const char *pszValue);
  104. static void UsrFreeVar(UserInfoVar * pUIV);
  105. static void UsrFreeInfoList(HSLIST & InfoList);
  106. static UserInfoVar *UsrGetUserVar(HSLIST & InfoList, const char *pszName);
  107. static int UsrWriteInfoList(HSLIST & InfoList, FILE * pProfileFile);
  108. static int UsrLoadUserInfo(HSLIST & InfoList, unsigned int uUserID, const char *pszFilePath);
  109. static int UsrGetDefaultInfoFile(char const *pszDomain, char *pszInfoFile, int iMaxPath);
  110. static int UsrLoadUserDefaultInfo(HSLIST & InfoList, char const *pszDomain = NULL);
  111. static int UsrAliasLookupNameLK(const char *pszAlsFilePath, const char *pszDomain,
  112. const char *pszAlias, char *pszName = NULL, bool bWildMatch =
  113. true);
  114. static int UsrWriteAlias(FILE * pAlsFile, AliasInfo * pAI);
  115. static bool UsrIsWildAlias(char const *pszAlias);
  116. static int UsrRemoveUserAlias(char const *pszDomain, char const *pszName);
  117. static UserInfo *UsrGetUserByNameLK(const char *pszUsrFilePath, const char *pszDomain,
  118.     const char *pszName);
  119. static UserInfo *UsrGetUserByNameOrAliasNDA(const char *pszDomain, const char *pszName,
  120.     char *pszRealAddr);
  121. static int UsrDropUserEnv(UserInfo * pUI);
  122. static int UsrWriteUser(UserInfo * pUI, FILE * pUsrFile);
  123. static char const *UsrGetMailboxDir(void);
  124. static int UsrCreateMailbox(char const *pszUsrUserPath);
  125. static int UsrPrepareUserEnv(UserInfo * pUI);
  126. static char *UsrGetPop3LocksPath(UserInfo * pUI, char *pszPop3LockPath, int iMaxPath);
  128. static int iIdxUser_Domain_Name[] = {
  129. usrDomain,
  130. usrName,
  132. INDEX_SEQUENCE_TERMINATOR
  133. };
  135. static int iIdxAlias_Domain_Alias[] = {
  136. alsDomain,
  137. alsAlias,
  139. INDEX_SEQUENCE_TERMINATOR
  140. };
  142. static int UsrCalcAliasHash(char const *const *ppszTabTokens, int const *piFieldsIdx,
  143.     SYS_UINT32 * puHashVal, bool bCaseSens)
  144. {
  145. ///////////////////////////////////////////////////////////////////////////////
  146. //  This will group wild alias ( * ? )
  147. ///////////////////////////////////////////////////////////////////////////////
  148. int iFieldsCount = StrStringsCount(ppszTabTokens);
  150. if ((iFieldsCount > alsAlias) &&
  151.     (UsrIsWildAlias(ppszTabTokens[alsAlias]) || UsrIsWildAlias(ppszTabTokens[alsDomain])))
  152. {
  153. *puHashVal = WILD_ALIASES_HASH;
  155. return (0);
  156. }
  158. return (TbixCalculateHash(ppszTabTokens, piFieldsIdx, puHashVal, bCaseSens));
  160. }
  162. int UsrCheckUsersIndexes(void)
  163. {
  165. char szUsrFilePath[SYS_MAX_PATH] = "";
  167. UsrGetTableFilePath(szUsrFilePath, sizeof(szUsrFilePath));
  169. ///////////////////////////////////////////////////////////////////////////////
  170. //  Align Domain-Name index
  171. ///////////////////////////////////////////////////////////////////////////////
  172. if (TbixCheckIndex(szUsrFilePath, iIdxUser_Domain_Name, false) < 0)
  173. return (ErrGetErrorCode());
  175. return (0);
  177. }
  179. int UsrCheckAliasesIndexes(void)
  180. {
  182. char szAlsFilePath[SYS_MAX_PATH] = "";
  184. UsrGetAliasFilePath(szAlsFilePath, sizeof(szAlsFilePath));
  186. ///////////////////////////////////////////////////////////////////////////////
  187. //  Align Domain-Alias index
  188. ///////////////////////////////////////////////////////////////////////////////
  189. if (TbixCheckIndex(szAlsFilePath, iIdxAlias_Domain_Alias, false, UsrCalcAliasHash) < 0)
  190. return (ErrGetErrorCode());
  192. return (0);
  194. }
  196. static int UsrRebuildUsersIndexes(char const *pszUsrFilePath)
  197. {
  198. ///////////////////////////////////////////////////////////////////////////////
  199. //  Rebuild Domain-Name index
  200. ///////////////////////////////////////////////////////////////////////////////
  201. if (TbixCreateIndex(pszUsrFilePath, iIdxUser_Domain_Name, false) < 0)
  202. return (ErrGetErrorCode());
  204. return (0);
  206. }
  208. static int UsrRebuildAliasesIndexes(char const *pszAlsFilePath)
  209. {
  210. ///////////////////////////////////////////////////////////////////////////////
  211. //  Rebuild Domain-Alias index
  212. ///////////////////////////////////////////////////////////////////////////////
  213. if (TbixCreateIndex(pszAlsFilePath, iIdxAlias_Domain_Alias, false, UsrCalcAliasHash) < 0)
  214. return (ErrGetErrorCode());
  216. return (0);
  218. }
  220. static char *UsrGetTableFilePath(char *pszUsrFilePath, int iMaxPath)
  221. {
  223. CfgGetRootPath(pszUsrFilePath, iMaxPath);
  225. StrNCat(pszUsrFilePath, SVR_TABLE_FILE, iMaxPath);
  227. return (pszUsrFilePath);
  229. }
  231. static char *UsrGetAliasFilePath(char *pszAlsFilePath, int iMaxPath)
  232. {
  234. CfgGetRootPath(pszAlsFilePath, iMaxPath);
  236. StrNCat(pszAlsFilePath, SVR_ALIAS_FILE, iMaxPath);
  238. return (pszAlsFilePath);
  240. }
  242. char *UsrGetMLTableFilePath(UserInfo * pUI, char *pszMLTablePath, int iMaxPath)
  243. {
  245. UsrGetUserPath(pUI, pszMLTablePath, iMaxPath, 1);
  247. StrNCat(pszMLTablePath, MLUSERS_TABLE_FILE, iMaxPath);
  249. return (pszMLTablePath);
  251. }
  253. UserType UsrGetUserType(UserInfo * pUI)
  254. {
  256. if (pUI->pszType == NULL)
  257. return (usrTypeError);
  259. switch (ToUpper(pUI->pszType[0])) {
  260. case ('U'):
  261. return (usrTypeUser);
  263. case ('M'):
  264. return (usrTypeML);
  265. }
  267. return (usrTypeError);
  269. }
  271. UserInfo *UsrCreateDefaultUser(char const *pszDomain, char const *pszName,
  272.        char const *pszPassword, UserType TypeUser)
  273. {
  275. UserInfo *pUI = (UserInfo *) SysAlloc(sizeof(UserInfo));
  277. if (pUI == NULL)
  278. return (NULL);
  280. pUI->pszDomain = SysStrDup(pszDomain);
  281. pUI->uUserID = 0;
  282. pUI->pszName = SysStrDup(pszName);
  283. pUI->pszPassword = SysStrDup(pszPassword);
  284. pUI->pszPath = SysStrDup(pszName);
  285. pUI->pszType = SysStrDup((TypeUser == usrTypeUser) ? "U" : "M");
  287. ///////////////////////////////////////////////////////////////////////////////
  288. //  Load user profile
  289. ///////////////////////////////////////////////////////////////////////////////
  290. ListInit(pUI->InfoList);
  292. UsrLoadUserDefaultInfo(pUI->InfoList, pszDomain);
  294. return (pUI);
  296. }
  298. static UserInfo *UsrGetUserFromStrings(char **ppszStrings)
  299. {
  301. int iFieldsCount = StrStringsCount(ppszStrings);
  303. if (iFieldsCount < usrMax)
  304. return (NULL);
  306. char szPassword[512] = "";
  308. if (StrDeCrypt(ppszStrings[usrPassword], szPassword) == NULL)
  309. return (NULL);
  311. UserInfo *pUI = (UserInfo *) SysAlloc(sizeof(UserInfo));
  313. if (pUI == NULL)
  314. return (NULL);
  316. pUI->pszDomain = SysStrDup(ppszStrings[usrDomain]);
  317. pUI->uUserID = (unsigned int) atol(ppszStrings[usrID]);
  318. pUI->pszName = SysStrDup(ppszStrings[usrName]);
  319. pUI->pszPassword = SysStrDup(szPassword);
  320. pUI->pszPath = SysStrDup(ppszStrings[usrPath]);
  321. pUI->pszType = SysStrDup(ppszStrings[usrType]);
  323. ///////////////////////////////////////////////////////////////////////////////
  324. //  Load user profile
  325. ///////////////////////////////////////////////////////////////////////////////
  326. ListInit(pUI->InfoList);
  328. char szUsrFilePath[SYS_MAX_PATH] = "";
  330. UsrGetUserPath(pUI, szUsrFilePath, sizeof(szUsrFilePath), 1);
  332. StrNCat(szUsrFilePath, USER_PROFILE_FILE, sizeof(szUsrFilePath));
  334. UsrLoadUserInfo(pUI->InfoList, pUI->uUserID, szUsrFilePath);
  336. return (pUI);
  338. }
  340. void UsrFreeUserInfo(UserInfo * pUI)
  341. {
  343. UsrFreeInfoList(pUI->InfoList);
  345. if (pUI->pszDomain != NULL)
  346. SysFree(pUI->pszDomain);
  348. if (pUI->pszPassword != NULL)
  349. SysFree(pUI->pszPassword);
  351. if (pUI->pszName != NULL)
  352. SysFree(pUI->pszName);
  354. if (pUI->pszPath != NULL)
  355. SysFree(pUI->pszPath);
  357. if (pUI->pszType != NULL)
  358. SysFree(pUI->pszType);
  360. SysFree(pUI);
  362. }
  364. char *UsrGetUserInfoVar(UserInfo * pUI, const char *pszName, const char *pszDefault)
  365. {
  367. UserInfoVar *pUIV = UsrGetUserVar(pUI->InfoList, pszName);
  369. if (pUIV != NULL)
  370. return (SysStrDup(pUIV->pszValue));
  372. return ((pszDefault != NULL) ? SysStrDup(pszDefault) : NULL);
  374. }
  376. int UsrGetUserInfoVarInt(UserInfo * pUI, const char *pszName, int iDefault)
  377. {
  379. UserInfoVar *pUIV = UsrGetUserVar(pUI->InfoList, pszName);
  381. return ((pUIV != NULL) ? atoi(pUIV->pszValue) : iDefault);
  383. }
  385. int UsrDelUserInfoVar(UserInfo * pUI, const char *pszName)
  386. {
  388. UserInfoVar *pUIV = UsrGetUserVar(pUI->InfoList, pszName);
  390. if (pUIV == NULL) {
  391. ErrSetErrorCode(ERR_USER_VAR_NOT_FOUND);
  392. return (ERR_USER_VAR_NOT_FOUND);
  393. }
  395. ListRemovePtr(pUI->InfoList, (PLISTLINK) pUIV);
  397. UsrFreeVar(pUIV);
  399. return (0);
  401. }
  403. int UsrSetUserInfoVar(UserInfo * pUI, const char *pszName, const char *pszValue)
  404. {
  406. UserInfoVar *pUIV = UsrGetUserVar(pUI->InfoList, pszName);
  408. if (pUIV != NULL) {
  409. SysFree(pUIV->pszValue);
  411. pUIV->pszValue = SysStrDup(pszValue);
  412. } else {
  413. UserInfoVar *pUIV = UsrAllocVar(pszName, pszValue);
  415. if (pUIV == NULL)
  416. return (ErrGetErrorCode());
  418. ListAddTail(pUI->InfoList, (PLISTLINK) pUIV);
  419. }
  421. return (0);
  423. }
  425. char **UsrGetProfileVars(UserInfo * pUI)
  426. {
  428. int iVarsCount = ListGetCount(pUI->InfoList);
  429. char **ppszVars = (char **) SysAlloc((iVarsCount + 1) * sizeof(char *));
  431. if (ppszVars == NULL)
  432. return (NULL);
  434. int iCurrVar = 0;
  435. UserInfoVar *pUIV = (UserInfoVar *) ListFirst(pUI->InfoList);
  437. for (; pUIV != INVALID_SLIST_PTR; pUIV = (UserInfoVar *)
  438.      ListNext(pUI->InfoList, (PLISTLINK) pUIV))
  439. ppszVars[iCurrVar++] = SysStrDup(pUIV->pszName);
  441. ppszVars[iCurrVar] = NULL;
  443. return (ppszVars);
  445. }
  447. static UserInfoVar *UsrAllocVar(const char *pszName, const char *pszValue)
  448. {
  450. UserInfoVar *pUIV = (UserInfoVar *) SysAlloc(sizeof(UserInfoVar));
  452. if (pUIV == NULL)
  453. return (NULL);
  455. ListLinkInit(pUIV);
  456. pUIV->pszName = SysStrDup(pszName);
  457. pUIV->pszValue = SysStrDup(pszValue);
  459. return (pUIV);
  461. }
  463. static void UsrFreeVar(UserInfoVar * pUIV)
  464. {
  466. SysFree(pUIV->pszName);
  467. SysFree(pUIV->pszValue);
  469. SysFree(pUIV);
  471. }
  473. static void UsrFreeInfoList(HSLIST & InfoList)
  474. {
  476. UserInfoVar *pUIV;
  478. while ((pUIV = (UserInfoVar *) ListRemove(InfoList)) != INVALID_SLIST_PTR)
  479. UsrFreeVar(pUIV);
  481. }
  483. static UserInfoVar *UsrGetUserVar(HSLIST & InfoList, const char *pszName)
  484. {
  486. UserInfoVar *pUIV = (UserInfoVar *) ListFirst(InfoList);
  488. for (; pUIV != INVALID_SLIST_PTR; pUIV = (UserInfoVar *)
  489.      ListNext(InfoList, (PLISTLINK) pUIV))
  490. if (strcmp(pUIV->pszName, pszName) == 0)
  491. return (pUIV);
  493. return (NULL);
  495. }
  497. static int UsrWriteInfoList(HSLIST & InfoList, FILE * pProfileFile)
  498. {
  500. UserInfoVar *pUIV = (UserInfoVar *) ListFirst(InfoList);
  502. for (; pUIV != INVALID_SLIST_PTR; pUIV = (UserInfoVar *)
  503.      ListNext(InfoList, (PLISTLINK) pUIV)) {
  504. ///////////////////////////////////////////////////////////////////////////////
  505. //  Write variabile name
  506. ///////////////////////////////////////////////////////////////////////////////
  507. char *pszQuoted = StrQuote(pUIV->pszName, '"');
  509. if (pszQuoted == NULL)
  510. return (ErrGetErrorCode());
  512. fprintf(pProfileFile, "%st", pszQuoted);
  514. SysFree(pszQuoted);
  516. ///////////////////////////////////////////////////////////////////////////////
  517. //  Write variabile value
  518. ///////////////////////////////////////////////////////////////////////////////
  519. pszQuoted = StrQuote(pUIV->pszValue, '"');
  521. if (pszQuoted == NULL)
  522. return (ErrGetErrorCode());
  524. fprintf(pProfileFile, "%sn", pszQuoted);
  526. SysFree(pszQuoted);
  527. }
  529. return (0);
  531. }
  533. static int UsrLoadUserInfo(HSLIST & InfoList, unsigned int uUserID, const char *pszFilePath)
  534. {
  536. char szResLock[SYS_MAX_PATH] = "";
  537. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(pszFilePath, szResLock,
  538.   sizeof(szResLock)));
  540. if (hResLock == INVALID_RLCK_HANDLE)
  541. return (ErrGetErrorCode());
  543. FILE *pProfileFile = fopen(pszFilePath, "rt");
  545. if (pProfileFile == NULL) {
  546. RLckUnlockSH(hResLock);
  547. ErrSetErrorCode(ERR_NO_USER_PRFILE);
  548. return (ERR_NO_USER_PRFILE);
  549. }
  551. char szProfileLine[USR_TABLE_LINE_MAX] = "";
  553. while (MscFGets(szProfileLine, sizeof(szProfileLine) - 1, pProfileFile) != NULL) {
  554. if (szProfileLine[0] == TAB_COMMENT_CHAR)
  555. continue;
  557. char **ppszStrings = StrGetTabLineStrings(szProfileLine);
  559. if (ppszStrings == NULL)
  560. continue;
  562. int iFieldsCount = StrStringsCount(ppszStrings);
  564. if (iFieldsCount == 2) {
  565. UserInfoVar *pUIV = UsrAllocVar(ppszStrings[0], ppszStrings[1]);
  567. if (pUIV != NULL)
  568. ListAddTail(InfoList, (PLISTLINK) pUIV);
  569. }
  571. StrFreeStrings(ppszStrings);
  572. }
  574. fclose(pProfileFile);
  576. RLckUnlockSH(hResLock);
  578. return (0);
  580. }
  582. static int UsrGetDefaultInfoFile(char const *pszDomain, char *pszInfoFile, int iMaxPath)
  583. {
  585. if (pszDomain != NULL) {
  586. ///////////////////////////////////////////////////////////////////////////////
  587. //  Try to lookup domain specific configuration
  588. ///////////////////////////////////////////////////////////////////////////////
  589. MDomGetDomainPath(pszDomain, pszInfoFile, iMaxPath, 1);
  591. StrNCat(pszInfoFile, DEFAULT_USER_PROFILE_FILE, iMaxPath);
  593. if (SysExistFile(pszInfoFile))
  594. return (0);
  596. }
  597. ///////////////////////////////////////////////////////////////////////////////
  598. //  Try to lookup global configuration
  599. ///////////////////////////////////////////////////////////////////////////////
  600. CfgGetRootPath(pszInfoFile, iMaxPath);
  602. StrNCat(pszInfoFile, DEFAULT_USER_PROFILE_FILE, iMaxPath);
  604. if (!SysExistFile(pszInfoFile)) {
  605. ErrSetErrorCode(ERR_NO_USER_DEFAULT_PRFILE);
  606. return (ERR_NO_USER_DEFAULT_PRFILE);
  607. }
  609. return (0);
  611. }
  613. static int UsrLoadUserDefaultInfo(HSLIST & InfoList, char const *pszDomain)
  614. {
  616. char szUserDefFilePath[SYS_MAX_PATH] = "";
  618. if (UsrGetDefaultInfoFile(pszDomain, szUserDefFilePath, sizeof(szUserDefFilePath)) < 0)
  619. return (ErrGetErrorCode());
  621. char szResLock[SYS_MAX_PATH] = "";
  622. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szUserDefFilePath, szResLock,
  623.   sizeof(szResLock)));
  625. if (hResLock == INVALID_RLCK_HANDLE)
  626. return (ErrGetErrorCode());
  628. FILE *pProfileFile = fopen(szUserDefFilePath, "rt");
  630. if (pProfileFile == NULL) {
  631. ErrSetErrorCode(ERR_NO_USER_DEFAULT_PRFILE);
  632. RLckUnlockSH(hResLock);
  633. return (ERR_NO_USER_DEFAULT_PRFILE);
  634. }
  636. char szProfileLine[USR_TABLE_LINE_MAX] = "";
  638. while (MscFGets(szProfileLine, sizeof(szProfileLine) - 1, pProfileFile) != NULL) {
  639. if (szProfileLine[0] == TAB_COMMENT_CHAR)
  640. continue;
  642. char **ppszStrings = StrGetTabLineStrings(szProfileLine);
  644. if (ppszStrings == NULL)
  645. continue;
  647. int iFieldsCount = StrStringsCount(ppszStrings);
  649. if (iFieldsCount == 2) {
  650. UserInfoVar *pUIV = UsrAllocVar(ppszStrings[0], ppszStrings[1]);
  652. if (pUIV != NULL)
  653. ListAddTail(InfoList, (PLISTLINK) pUIV);
  654. }
  656. StrFreeStrings(ppszStrings);
  657. }
  659. fclose(pProfileFile);
  661. RLckUnlockSH(hResLock);
  663. return (0);
  665. }
  667. static int UsrAliasLookupNameLK(const char *pszAlsFilePath, const char *pszDomain,
  668. const char *pszAlias, char *pszName, bool bWildMatch)
  669. {
  670. ///////////////////////////////////////////////////////////////////////////////
  671. //  Lookup record using the specified index ( lookup precise aliases )
  672. ///////////////////////////////////////////////////////////////////////////////
  673. char **ppszTabTokens = TbixLookup(pszAlsFilePath, iIdxAlias_Domain_Alias, false,
  674.   pszDomain,
  675.   pszAlias,
  676.   NULL);
  678. if (ppszTabTokens != NULL) {
  679. if (pszName != NULL)
  680. strcpy(pszName, ppszTabTokens[alsName]);
  682. StrFreeStrings(ppszTabTokens);
  684. return (1);
  685. }
  686. ///////////////////////////////////////////////////////////////////////////////
  687. //  We can stop here if wild alias matching is not required
  688. ///////////////////////////////////////////////////////////////////////////////
  689. if (!bWildMatch)
  690. return (0);
  692. ///////////////////////////////////////////////////////////////////////////////
  693. //  Lookup record using the specified index ( lookup wild aliases grouped
  694. //  under WILD_ALIASES_HASH hash key )
  695. ///////////////////////////////////////////////////////////////////////////////
  696. INDEX_HANDLE hIndexLookup = TbixOpenHandle(pszAlsFilePath, iIdxAlias_Domain_Alias,
  697.    WILD_ALIASES_HASH);
  699. if (hIndexLookup != INVALID_INDEX_HANDLE) {
  700. int iNumRecords = TbixLookedUpRecords(hIndexLookup);
  701. int iMaxLength = -1;
  703. for (int ii = 0; ii < iNumRecords; ii++) {
  704. char **ppszTabTokens = TbixGetRecord(hIndexLookup, ii);
  706. if (ppszTabTokens == NULL)
  707. continue;
  709. int iFieldsCount = StrStringsCount(ppszTabTokens);
  711. if ((iFieldsCount >= alsMax) &&
  712.     StrIWildMatch(pszDomain, ppszTabTokens[alsDomain]) &&
  713.     StrIWildMatch(pszAlias, ppszTabTokens[alsAlias])) {
  714. int iLength = strlen(ppszTabTokens[alsDomain]) +
  715.     strlen(ppszTabTokens[alsAlias]);
  717. if (iLength > iMaxLength) {
  718. iMaxLength = iLength;
  720. if (pszName != NULL)
  721. strcpy(pszName, ppszTabTokens[alsName]);
  722. }
  723. }
  725. StrFreeStrings(ppszTabTokens);
  726. }
  728. TbixCloseHandle(hIndexLookup);
  730. if (iMaxLength > 0)
  731. return (1);
  732. }
  734. return (0);
  736. }
  738. int UsrAliasLookupName(const char *pszDomain, const char *pszAlias,
  739.        char *pszName, bool bWildMatch)
  740. {
  742. char szAlsFilePath[SYS_MAX_PATH] = "";
  744. UsrGetAliasFilePath(szAlsFilePath, sizeof(szAlsFilePath));
  746. char szResLock[SYS_MAX_PATH] = "";
  747. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szAlsFilePath, szResLock,
  748.   sizeof(szResLock)));
  750. if (hResLock == INVALID_RLCK_HANDLE)
  751. return (0);
  753. int iLookupResult = UsrAliasLookupNameLK(szAlsFilePath, pszDomain,
  754.  pszAlias, pszName, bWildMatch);
  756. RLckUnlockSH(hResLock);
  758. return (iLookupResult);
  760. }
  762. static int UsrWriteAlias(FILE * pAlsFile, AliasInfo * pAI)
  763. {
  765. ///////////////////////////////////////////////////////////////////////////////
  766. //  Domain
  767. ///////////////////////////////////////////////////////////////////////////////
  768. char *pszQuoted = StrQuote(pAI->pszDomain, '"');
  770. if (pszQuoted == NULL)
  771. return (ErrGetErrorCode());
  773. fprintf(pAlsFile, "%st", pszQuoted);
  775. SysFree(pszQuoted);
  777. ///////////////////////////////////////////////////////////////////////////////
  778. //  Alias
  779. ///////////////////////////////////////////////////////////////////////////////
  780. pszQuoted = StrQuote(pAI->pszAlias, '"');
  782. if (pszQuoted == NULL)
  783. return (ErrGetErrorCode());
  785. fprintf(pAlsFile, "%st", pszQuoted);
  787. SysFree(pszQuoted);
  789. ///////////////////////////////////////////////////////////////////////////////
  790. //  Account name
  791. ///////////////////////////////////////////////////////////////////////////////
  792. pszQuoted = StrQuote(pAI->pszName, '"');
  794. if (pszQuoted == NULL)
  795. return (ErrGetErrorCode());
  797. fprintf(pAlsFile, "%sn", pszQuoted);
  799. SysFree(pszQuoted);
  801. return (0);
  803. }
  805. AliasInfo *UsrAllocAlias(const char *pszDomain, const char *pszAlias, const char *pszName)
  806. {
  808. AliasInfo *pAI = (AliasInfo *) SysAlloc(sizeof(AliasInfo));
  810. if (pAI == NULL)
  811. return (NULL);
  813. pAI->pszDomain = (pszDomain != NULL) ? SysStrDup(pszDomain) : NULL;
  814. pAI->pszAlias = (pszAlias != NULL) ? SysStrDup(pszAlias) : NULL;
  815. pAI->pszName = (pszName != NULL) ? SysStrDup(pszName) : NULL;
  817. return (pAI);
  819. }
  821. void UsrFreeAlias(AliasInfo * pAI)
  822. {
  824. SysFreeCheck(pAI->pszDomain);
  825. SysFreeCheck(pAI->pszAlias);
  826. SysFreeCheck(pAI->pszName);
  828. SysFree(pAI);
  830. }
  832. static bool UsrIsWildAlias(char const *pszAlias)
  833. {
  835. return ((strchr(pszAlias, '*') != NULL) || (strchr(pszAlias, '?') != NULL));
  837. }
  839. int UsrAddAlias(AliasInfo * pAI)
  840. {
  842. char szAlsFilePath[SYS_MAX_PATH] = "";
  844. UsrGetAliasFilePath(szAlsFilePath, sizeof(szAlsFilePath));
  846. char szResLock[SYS_MAX_PATH] = "";
  847. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szAlsFilePath, szResLock,
  848.   sizeof(szResLock)));
  850. if (hResLock == INVALID_RLCK_HANDLE)
  851. return (ErrGetErrorCode());
  853. FILE *pAlsFile = fopen(szAlsFilePath, "r+t");
  855. if (pAlsFile == NULL) {
  856. ErrSetErrorCode(ERR_ALIAS_FILE_NOT_FOUND);
  857. RLckUnlockEX(hResLock);
  858. return (ERR_ALIAS_FILE_NOT_FOUND);
  859. }
  861. char szAlsLine[USR_ALIAS_LINE_MAX] = "";
  863. while (MscFGets(szAlsLine, sizeof(szAlsLine) - 1, pAlsFile) != NULL) {
  864. char **ppszStrings = StrGetTabLineStrings(szAlsLine);
  866. if (ppszStrings == NULL)
  867. continue;
  869. int iFieldsCount = StrStringsCount(ppszStrings);
  871. if ((iFieldsCount >= alsMax) &&
  872.     (stricmp(pAI->pszDomain, ppszStrings[alsDomain]) == 0) &&
  873.     (stricmp(pAI->pszAlias, ppszStrings[alsAlias]) == 0)) {
  874. StrFreeStrings(ppszStrings);
  875. fclose(pAlsFile);
  876. RLckUnlockEX(hResLock);
  878. ErrSetErrorCode(ERR_ALIAS_EXIST);
  879. return (ERR_ALIAS_EXIST);
  880. }
  882. StrFreeStrings(ppszStrings);
  883. }
  885. fseek(pAlsFile, 0, SEEK_END);
  887. if (UsrWriteAlias(pAlsFile, pAI) < 0) {
  888. fclose(pAlsFile);
  889. RLckUnlockEX(hResLock);
  891. ErrSetErrorCode(ERR_WRITE_ALIAS_FILE);
  892. return (ERR_WRITE_ALIAS_FILE);
  893. }
  895. fclose(pAlsFile);
  897. ///////////////////////////////////////////////////////////////////////////////
  898. //  Rebuild indexes
  899. ///////////////////////////////////////////////////////////////////////////////
  900. if (UsrRebuildAliasesIndexes(szAlsFilePath) < 0) {
  901. ErrorPush();
  902. RLckUnlockEX(hResLock);
  903. return (ErrorPop());
  904. }
  906. RLckUnlockEX(hResLock);
  908. return (0);
  910. }
  912. int UsrRemoveAlias(const char *pszDomain, const char *pszAlias)
  913. {
  915. char szAlsFilePath[SYS_MAX_PATH] = "";
  917. UsrGetAliasFilePath(szAlsFilePath, sizeof(szAlsFilePath));
  919. char szTmpFile[SYS_MAX_PATH] = "";
  921. SysGetTmpFile(szTmpFile);
  923. char szResLock[SYS_MAX_PATH] = "";
  924. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szAlsFilePath, szResLock,
  925.   sizeof(szResLock)));
  927. if (hResLock == INVALID_RLCK_HANDLE) {
  928. ErrorPush();
  929. CheckRemoveFile(szTmpFile);
  930. return (ErrorPop());
  931. }
  933. FILE *pAlsFile = fopen(szAlsFilePath, "rt");
  935. if (pAlsFile == NULL) {
  936. RLckUnlockEX(hResLock);
  937. CheckRemoveFile(szTmpFile);
  939. ErrSetErrorCode(ERR_ALIAS_FILE_NOT_FOUND);
  940. return (ERR_ALIAS_FILE_NOT_FOUND);
  941. }
  943. FILE *pTmpFile = fopen(szTmpFile, "wt");
  945. if (pTmpFile == NULL) {
  946. fclose(pAlsFile);
  947. RLckUnlockEX(hResLock);
  948. CheckRemoveFile(szTmpFile);
  950. ErrSetErrorCode(ERR_FILE_CREATE);
  951. return (ERR_FILE_CREATE);
  952. }
  954. int iAliasFound = 0;
  955. char szAlsLine[USR_ALIAS_LINE_MAX] = "";
  957. while (MscFGets(szAlsLine, sizeof(szAlsLine) - 1, pAlsFile) != NULL) {
  958. char **ppszStrings = StrGetTabLineStrings(szAlsLine);
  960. if (ppszStrings == NULL)
  961. continue;
  963. int iFieldsCount = StrStringsCount(ppszStrings);
  965. if ((iFieldsCount >= alsMax) && (stricmp(pszDomain, ppszStrings[alsDomain]) == 0)
  966.     && (stricmp(pszAlias, ppszStrings[alsAlias]) == 0)) {
  968. ++iAliasFound;
  970. } else
  971. fprintf(pTmpFile, "%sn", szAlsLine);
  973. StrFreeStrings(ppszStrings);
  974. }
  976. fclose(pAlsFile);
  977. fclose(pTmpFile);
  979. if (iAliasFound == 0) {
  980. SysRemove(szTmpFile);
  981. RLckUnlockEX(hResLock);
  983. ErrSetErrorCode(ERR_ALIAS_NOT_FOUND);
  984. return (ERR_ALIAS_NOT_FOUND);
  985. }
  987. char szTmpAlsFilePath[SYS_MAX_PATH] = "";
  989. sprintf(szTmpAlsFilePath, "%s.tmp", szAlsFilePath);
  991. if (MscMoveFile(szAlsFilePath, szTmpAlsFilePath) < 0) {
  992. RLckUnlockEX(hResLock);
  993. return (ErrGetErrorCode());
  994. }
  996. if (MscMoveFile(szTmpFile, szAlsFilePath) < 0) {
  997. MscMoveFile(szTmpAlsFilePath, szAlsFilePath);
  998. RLckUnlockEX(hResLock);
  999. return (ErrGetErrorCode());
  1000. }
  1002. SysRemove(szTmpAlsFilePath);
  1004. ///////////////////////////////////////////////////////////////////////////////
  1005. //  Rebuild indexes
  1006. ///////////////////////////////////////////////////////////////////////////////
  1007. if (UsrRebuildAliasesIndexes(szAlsFilePath) < 0) {
  1008. ErrorPush();
  1009. RLckUnlockEX(hResLock);
  1010. return (ErrorPop());
  1011. }
  1013. RLckUnlockEX(hResLock);
  1015. return (0);
  1017. }
  1019. int UsrRemoveDomainAliases(const char *pszDomain)
  1020. {
  1022. char szAlsFilePath[SYS_MAX_PATH] = "";
  1024. UsrGetAliasFilePath(szAlsFilePath, sizeof(szAlsFilePath));
  1026. char szTmpFile[SYS_MAX_PATH] = "";
  1028. SysGetTmpFile(szTmpFile);
  1030. char szResLock[SYS_MAX_PATH] = "";
  1031. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szAlsFilePath, szResLock,
  1032.   sizeof(szResLock)));
  1034. if (hResLock == INVALID_RLCK_HANDLE) {
  1035. ErrorPush();
  1036. CheckRemoveFile(szTmpFile);
  1037. return (ErrorPop());
  1038. }
  1040. FILE *pAlsFile = fopen(szAlsFilePath, "rt");
  1042. if (pAlsFile == NULL) {
  1043. RLckUnlockEX(hResLock);
  1044. CheckRemoveFile(szTmpFile);
  1046. ErrSetErrorCode(ERR_ALIAS_FILE_NOT_FOUND);
  1047. return (ERR_ALIAS_FILE_NOT_FOUND);
  1048. }
  1050. FILE *pTmpFile = fopen(szTmpFile, "wt");
  1052. if (pTmpFile == NULL) {
  1053. fclose(pAlsFile);
  1054. RLckUnlockEX(hResLock);
  1055. CheckRemoveFile(szTmpFile);
  1057. ErrSetErrorCode(ERR_FILE_CREATE);
  1058. return (ERR_FILE_CREATE);
  1059. }
  1061. int iAliasFound = 0;
  1062. char szAlsLine[USR_ALIAS_LINE_MAX] = "";
  1064. while (MscFGets(szAlsLine, sizeof(szAlsLine) - 1, pAlsFile) != NULL) {
  1065. char **ppszStrings = StrGetTabLineStrings(szAlsLine);
  1067. if (ppszStrings == NULL)
  1068. continue;
  1070. int iFieldsCount = StrStringsCount(ppszStrings);
  1072. if ((iFieldsCount >= alsMax) && (stricmp(pszDomain, ppszStrings[alsDomain]) == 0)) {
  1074. ++iAliasFound;
  1076. } else
  1077. fprintf(pTmpFile, "%sn", szAlsLine);
  1079. StrFreeStrings(ppszStrings);
  1080. }
  1082. fclose(pAlsFile);
  1083. fclose(pTmpFile);
  1085. if (iAliasFound == 0) {
  1086. SysRemove(szTmpFile);
  1087. RLckUnlockEX(hResLock);
  1088. return (0);
  1089. }
  1091. char szTmpAlsFilePath[SYS_MAX_PATH] = "";
  1093. sprintf(szTmpAlsFilePath, "%s.tmp", szAlsFilePath);
  1095. if (MscMoveFile(szAlsFilePath, szTmpAlsFilePath) < 0) {
  1096. ErrorPush();
  1097. SysRemove(szTmpFile);
  1098. RLckUnlockEX(hResLock);
  1099. return (ErrorPop());
  1100. }
  1102. if (MscMoveFile(szTmpFile, szAlsFilePath) < 0) {
  1103. ErrorPush();
  1104. MscMoveFile(szTmpAlsFilePath, szAlsFilePath);
  1105. SysRemove(szTmpFile);
  1106. RLckUnlockEX(hResLock);
  1107. return (ErrorPop());
  1108. }
  1110. SysRemove(szTmpAlsFilePath);
  1112. ///////////////////////////////////////////////////////////////////////////////
  1113. //  Rebuild indexes
  1114. ///////////////////////////////////////////////////////////////////////////////
  1115. if (UsrRebuildAliasesIndexes(szAlsFilePath) < 0) {
  1116. ErrorPush();
  1117. RLckUnlockEX(hResLock);
  1118. return (ErrorPop());
  1119. }
  1121. RLckUnlockEX(hResLock);
  1123. return (0);
  1125. }
  1127. static int UsrRemoveUserAlias(char const *pszDomain, char const *pszName)
  1128. {
  1130. char szAlsFilePath[SYS_MAX_PATH] = "";
  1132. UsrGetAliasFilePath(szAlsFilePath, sizeof(szAlsFilePath));
  1134. char szTmpFile[SYS_MAX_PATH] = "";
  1136. SysGetTmpFile(szTmpFile);
  1138. char szResLock[SYS_MAX_PATH] = "";
  1139. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szAlsFilePath, szResLock,
  1140.   sizeof(szResLock)));
  1142. if (hResLock == INVALID_RLCK_HANDLE)
  1143. return (ErrGetErrorCode());
  1145. FILE *pAlsFile = fopen(szAlsFilePath, "rt");
  1147. if (pAlsFile == NULL) {
  1148. RLckUnlockEX(hResLock);
  1150. ErrSetErrorCode(ERR_ALIAS_FILE_NOT_FOUND);
  1151. return (ERR_ALIAS_FILE_NOT_FOUND);
  1152. }
  1154. FILE *pTmpFile = fopen(szTmpFile, "wt");
  1156. if (pTmpFile == NULL) {
  1157. fclose(pAlsFile);
  1158. RLckUnlockEX(hResLock);
  1160. ErrSetErrorCode(ERR_FILE_CREATE);
  1161. return (ERR_FILE_CREATE);
  1162. }
  1164. char szUserAddress[MAX_ADDR_NAME] = "";
  1166. sprintf(szUserAddress, "%s@%s", pszName, pszDomain);
  1168. int iAliasFound = 0;
  1169. char szAlsLine[USR_ALIAS_LINE_MAX] = "";
  1171. while (MscFGets(szAlsLine, sizeof(szAlsLine) - 1, pAlsFile) != NULL) {
  1172. char **ppszStrings = StrGetTabLineStrings(szAlsLine);
  1174. if (ppszStrings == NULL)
  1175. continue;
  1177. int iFieldsCount = StrStringsCount(ppszStrings);
  1179. if ((iFieldsCount >= alsMax) &&
  1180.     (((stricmp(pszName, ppszStrings[alsName]) == 0) &&
  1181.       (stricmp(pszDomain, ppszStrings[alsDomain]) == 0)) ||
  1182.      (stricmp(szUserAddress, ppszStrings[alsName]) == 0))) {
  1184. ++iAliasFound;
  1186. } else
  1187. fprintf(pTmpFile, "%sn", szAlsLine);
  1189. StrFreeStrings(ppszStrings);
  1190. }
  1192. fclose(pAlsFile);
  1193. fclose(pTmpFile);
  1195. if (iAliasFound == 0) {
  1196. SysRemove(szTmpFile);
  1197. RLckUnlockEX(hResLock);
  1198. return (0);
  1199. }
  1201. char szTmpAlsFilePath[SYS_MAX_PATH] = "";
  1203. sprintf(szTmpAlsFilePath, "%s.tmp", szAlsFilePath);
  1205. if (MscMoveFile(szAlsFilePath, szTmpAlsFilePath) < 0) {
  1206. RLckUnlockEX(hResLock);
  1207. return (ErrGetErrorCode());
  1208. }
  1210. if (MscMoveFile(szTmpFile, szAlsFilePath) < 0) {
  1211. MscMoveFile(szTmpAlsFilePath, szAlsFilePath);
  1212. RLckUnlockEX(hResLock);
  1213. return (ErrGetErrorCode());
  1214. }
  1216. SysRemove(szTmpAlsFilePath);
  1218. ///////////////////////////////////////////////////////////////////////////////
  1219. //  Rebuild indexes
  1220. ///////////////////////////////////////////////////////////////////////////////
  1221. if (UsrRebuildAliasesIndexes(szAlsFilePath) < 0) {
  1222. ErrorPush();
  1223. RLckUnlockEX(hResLock);
  1224. return (ErrorPop());
  1225. }
  1227. RLckUnlockEX(hResLock);
  1229. return (0);
  1231. }
  1233. static UserInfo *UsrGetUserByNameLK(const char *pszUsrFilePath, const char *pszDomain,
  1234.     const char *pszName)
  1235. {
  1236. ///////////////////////////////////////////////////////////////////////////////
  1237. //  Lookup record using the specified index
  1238. ///////////////////////////////////////////////////////////////////////////////
  1239. char **ppszTabTokens = TbixLookup(pszUsrFilePath, iIdxUser_Domain_Name, false,
  1240.   pszDomain,
  1241.   pszName,
  1242.   NULL);
  1244. if (ppszTabTokens == NULL) {
  1245. ErrSetErrorCode(ERR_USER_NOT_FOUND);
  1247. return (NULL);
  1248. }
  1250. UserInfo *pUI = UsrGetUserFromStrings(ppszTabTokens);
  1252. StrFreeStrings(ppszTabTokens);
  1254. return (pUI);
  1256. }
  1258. UserInfo *UsrLookupUser(const char *pszDomain, const char *pszName)
  1259. {
  1261. char szUsrFilePath[SYS_MAX_PATH] = "";
  1263. UsrGetTableFilePath(szUsrFilePath, sizeof(szUsrFilePath));
  1265. char szResLock[SYS_MAX_PATH] = "";
  1266. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szUsrFilePath, szResLock,
  1267.   sizeof(szResLock)));
  1269. if (hResLock == INVALID_RLCK_HANDLE)
  1270. return (NULL);
  1272. UserInfo *pUI = UsrGetUserByNameLK(szUsrFilePath, pszDomain, pszName);
  1274. RLckUnlockSH(hResLock);
  1276. return (pUI);
  1278. }
  1280. UserInfo *UsrGetUserByName(const char *pszDomain, const char *pszName)
  1281. {
  1282. ///////////////////////////////////////////////////////////////////////////////
  1283. //  Check for alias domain
  1284. ///////////////////////////////////////////////////////////////////////////////
  1285. UserInfo *pUI = UsrLookupUser(pszDomain, pszName);
  1286. char szADomain[MAX_HOST_NAME] = "";
  1288. ///////////////////////////////////////////////////////////////////////////////
  1289. //  Check for alias domain if first lookup failed
  1290. ///////////////////////////////////////////////////////////////////////////////
  1291. if ((pUI == NULL) && ADomLookupDomain(pszDomain, szADomain, true))
  1292. pUI = UsrLookupUser(szADomain, pszName);
  1294. return (pUI);
  1296. }
  1298. static UserInfo *UsrGetUserByNameOrAliasNDA(const char *pszDomain, const char *pszName,
  1299.     char *pszRealAddr)
  1300. {
  1302. char const *pszAliasedUser = NULL;
  1303. char const *pszAliasedDomain = NULL;
  1304. char szAliasedAccount[MAX_ADDR_NAME] = "";
  1305. char szAliasedName[MAX_ADDR_NAME] = "";
  1306. char szAliasedDomain[MAX_ADDR_NAME] = "";
  1308. if (UsrAliasLookupName(pszDomain, pszName, szAliasedAccount)) {
  1309. if (USmtpSplitEmailAddr(szAliasedAccount, szAliasedName, szAliasedDomain) < 0) {
  1310. pszAliasedUser = szAliasedAccount;
  1311. pszAliasedDomain = pszDomain;
  1312. } else {
  1313. pszAliasedUser = szAliasedName;
  1314. pszAliasedDomain = szAliasedDomain;
  1315. }
  1316. }
  1318. char szUsrFilePath[SYS_MAX_PATH] = "";
  1320. UsrGetTableFilePath(szUsrFilePath, sizeof(szUsrFilePath));
  1322. char szResLock[SYS_MAX_PATH] = "";
  1323. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szUsrFilePath, szResLock,
  1324.   sizeof(szResLock)));
  1326. if (hResLock == INVALID_RLCK_HANDLE)
  1327. return (NULL);
  1329. UserInfo *pUI = UsrGetUserByNameLK(szUsrFilePath, pszDomain, pszName);
  1331. if ((pUI == NULL) && (pszAliasedUser != NULL))
  1332. pUI = UsrGetUserByNameLK(szUsrFilePath, pszAliasedDomain, pszAliasedUser);
  1334. if ((pUI != NULL) && (pszRealAddr != NULL))
  1335. UsrGetAddress(pUI, pszRealAddr);
  1337. RLckUnlockSH(hResLock);
  1339. return (pUI);
  1341. }
  1343. UserInfo *UsrGetUserByNameOrAlias(const char *pszDomain, const char *pszName, char *pszRealAddr)
  1344. {
  1346. UserInfo *pUI = UsrGetUserByNameOrAliasNDA(pszDomain, pszName, pszRealAddr);
  1347. char szADomain[MAX_HOST_NAME] = "";
  1349. ///////////////////////////////////////////////////////////////////////////////
  1350. //  Check for alias domain if first lookup failed
  1351. ///////////////////////////////////////////////////////////////////////////////
  1352. if ((pUI == NULL) && ADomLookupDomain(pszDomain, szADomain, true))
  1353. pUI = UsrGetUserByNameOrAliasNDA(szADomain, pszName, pszRealAddr);
  1355. return (pUI);
  1357. }
  1359. int UsrRemoveUser(const char *pszDomain, const char *pszName, unsigned int uUserID)
  1360. {
  1362. char szUsrFilePath[SYS_MAX_PATH] = "";
  1364. UsrGetTableFilePath(szUsrFilePath, sizeof(szUsrFilePath));
  1366. char szTmpFile[SYS_MAX_PATH] = "";
  1368. SysGetTmpFile(szTmpFile);
  1370. char szResLock[SYS_MAX_PATH] = "";
  1371. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szUsrFilePath, szResLock,
  1372.   sizeof(szResLock)));
  1374. if (hResLock == INVALID_RLCK_HANDLE) {
  1375. ErrorPush();
  1376. CheckRemoveFile(szTmpFile);
  1377. return (ErrorPop());
  1378. }
  1380. FILE *pUsrFile = fopen(szUsrFilePath, "rt");
  1382. if (pUsrFile == NULL) {
  1383. RLckUnlockEX(hResLock);
  1384. CheckRemoveFile(szTmpFile);
  1386. ErrSetErrorCode(ERR_USERS_FILE_NOT_FOUND);
  1387. return (ERR_USERS_FILE_NOT_FOUND);
  1388. }
  1390. FILE *pTmpFile = fopen(szTmpFile, "wt");
  1392. if (pTmpFile == NULL) {
  1393. fclose(pUsrFile);
  1394. RLckUnlockEX(hResLock);
  1395. CheckRemoveFile(szTmpFile);
  1397. ErrSetErrorCode(ERR_FILE_CREATE);
  1398. return (ERR_FILE_CREATE);
  1399. }
  1401. UserInfo *pUI = NULL;
  1402. char szUsrLine[USR_TABLE_LINE_MAX] = "";
  1404. while (MscFGets(szUsrLine, sizeof(szUsrLine) - 1, pUsrFile) != NULL) {
  1405. char **ppszStrings = StrGetTabLineStrings(szUsrLine);
  1407. if (ppszStrings == NULL)
  1408. continue;
  1410. int iFieldsCount = StrStringsCount(ppszStrings);
  1412. if ((iFieldsCount >= usrMax) && (stricmp(pszDomain, ppszStrings[usrDomain]) == 0)
  1413.     && (((uUserID != 0) && (uUserID == (unsigned int) atol(ppszStrings[usrID])))
  1414. || ((pszName != NULL) &&
  1415.     (stricmp(pszName, ppszStrings[usrName]) == 0)))) {
  1416. if (pUI != NULL)
  1417. UsrFreeUserInfo(pUI);
  1419. pUI = UsrGetUserFromStrings(ppszStrings);
  1420. } else
  1421. fprintf(pTmpFile, "%sn", szUsrLine);
  1423. StrFreeStrings(ppszStrings);
  1424. }
  1426. fclose(pUsrFile);
  1427. fclose(pTmpFile);
  1429. if (pUI == NULL) {
  1430. SysRemove(szTmpFile);
  1431. RLckUnlockEX(hResLock);
  1433. ErrSetErrorCode(ERR_USER_NOT_FOUND);
  1434. return (ERR_USER_NOT_FOUND);
  1435. }
  1437. char szTmpUsrFilePath[SYS_MAX_PATH] = "";
  1439. sprintf(szTmpUsrFilePath, "%s.tmp", szUsrFilePath);
  1441. if (MscMoveFile(szUsrFilePath, szTmpUsrFilePath) < 0) {
  1442. ErrorPush();
  1443. UsrFreeUserInfo(pUI);
  1444. RLckUnlockEX(hResLock);
  1445. return (ErrorPop());
  1446. }
  1448. if (MscMoveFile(szTmpFile, szUsrFilePath) < 0) {
  1449. ErrorPush();
  1450. MscMoveFile(szTmpUsrFilePath, szUsrFilePath);
  1451. UsrFreeUserInfo(pUI);
  1452. RLckUnlockEX(hResLock);
  1453. return (ErrorPop());
  1454. }
  1456. SysRemove(szTmpUsrFilePath);
  1458. ///////////////////////////////////////////////////////////////////////////////
  1459. //  Rebuild indexes
  1460. ///////////////////////////////////////////////////////////////////////////////
  1461. if (UsrRebuildUsersIndexes(szUsrFilePath) < 0) {
  1462. ErrorPush();
  1463. UsrFreeUserInfo(pUI);
  1464. RLckUnlockEX(hResLock);
  1465. return (ErrorPop());
  1466. }
  1468. RLckUnlockEX(hResLock);
  1470. GwLkRemoveUserLinks(pUI->pszDomain, pUI->pszName);
  1472. ExAlRemoveUserAliases(pUI->pszDomain, pUI->pszName);
  1474. UsrRemoveUserAlias(pUI->pszDomain, pUI->pszName);
  1476. ///////////////////////////////////////////////////////////////////////////////
  1477. //  Try ( if defined ) to remove external auth user
  1478. ///////////////////////////////////////////////////////////////////////////////
  1479. UAthDelUser(AUTH_SERVICE_POP3, pUI);
  1481. UsrDropUserEnv(pUI);
  1483. UsrFreeUserInfo(pUI);
  1485. return (0);
  1487. }
  1489. int UsrModifyUser(UserInfo * pUI)
  1490. {
  1492. char szUsrFilePath[SYS_MAX_PATH] = "";
  1494. UsrGetTableFilePath(szUsrFilePath, sizeof(szUsrFilePath));
  1496. char szTmpFile[SYS_MAX_PATH] = "";
  1498. SysGetTmpFile(szTmpFile);
  1500. char szResLock[SYS_MAX_PATH] = "";
  1501. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szUsrFilePath, szResLock,
  1502.   sizeof(szResLock)));
  1504. if (hResLock == INVALID_RLCK_HANDLE) {
  1505. ErrorPush();
  1506. CheckRemoveFile(szTmpFile);
  1507. return (ErrorPop());
  1508. }
  1510. FILE *pUsrFile = fopen(szUsrFilePath, "rt");
  1512. if (pUsrFile == NULL) {
  1513. RLckUnlockEX(hResLock);
  1514. CheckRemoveFile(szTmpFile);
  1516. ErrSetErrorCode(ERR_USERS_FILE_NOT_FOUND);
  1517. return (ERR_USERS_FILE_NOT_FOUND);
  1518. }
  1520. FILE *pTmpFile = fopen(szTmpFile, "wt");
  1522. if (pTmpFile == NULL) {
  1523. fclose(pUsrFile);
  1524. RLckUnlockEX(hResLock);
  1525. CheckRemoveFile(szTmpFile);
  1527. ErrSetErrorCode(ERR_FILE_CREATE);
  1528. return (ERR_FILE_CREATE);
  1529. }
  1531. UserInfo *pFoundUI = NULL;
  1532. char szUsrLine[USR_TABLE_LINE_MAX] = "";
  1534. while (MscFGets(szUsrLine, sizeof(szUsrLine) - 1, pUsrFile) != NULL) {
  1535. char **ppszStrings = StrGetTabLineStrings(szUsrLine);
  1537. if (ppszStrings == NULL)
  1538. continue;
  1540. int iFieldsCount = StrStringsCount(ppszStrings);
  1542. if ((iFieldsCount >= usrMax) && (pFoundUI == NULL) &&
  1543.     (pUI->uUserID == (unsigned int) atol(ppszStrings[usrID])) &&
  1544.     (stricmp(pUI->pszDomain, ppszStrings[usrDomain]) == 0) &&
  1545.     (stricmp(pUI->pszName, ppszStrings[usrName]) == 0)) {
  1546. if ((UsrWriteUser(pUI, pTmpFile) < 0) ||
  1547.     ((pFoundUI = UsrGetUserFromStrings(ppszStrings)) == NULL)) {
  1548. ErrorPush();
  1549. fclose(pUsrFile);
  1550. fclose(pTmpFile);
  1551. SysRemove(szTmpFile);
  1552. RLckUnlockEX(hResLock);
  1553. return (ErrorPop());
  1554. }
  1555. } else
  1556. fprintf(pTmpFile, "%sn", szUsrLine);
  1558. StrFreeStrings(ppszStrings);
  1559. }
  1561. fclose(pUsrFile);
  1562. fclose(pTmpFile);
  1564. if (pFoundUI == NULL) {
  1565. SysRemove(szTmpFile);
  1566. RLckUnlockEX(hResLock);
  1568. ErrSetErrorCode(ERR_USER_NOT_FOUND);
  1569. return (ERR_USER_NOT_FOUND);
  1570. }
  1571. ///////////////////////////////////////////////////////////////////////////////
  1572. //
  1573. //  Adjust for fields changes
  1574. //
  1575. ///////////////////////////////////////////////////////////////////////////////
  1577. ///////////////////////////////////////////////////////////////////////////////
  1578. //  Try ( if defined ) to modify external auth user
  1579. ///////////////////////////////////////////////////////////////////////////////
  1580. UAthModifyUser(AUTH_SERVICE_POP3, pUI);
  1582. UsrFreeUserInfo(pFoundUI);
  1584. char szTmpUsrFilePath[SYS_MAX_PATH] = "";
  1586. sprintf(szTmpUsrFilePath, "%s.tmp", szUsrFilePath);
  1588. if (MscMoveFile(szUsrFilePath, szTmpUsrFilePath) < 0) {
  1589. ErrorPush();
  1590. SysRemove(szTmpFile);
  1591. RLckUnlockEX(hResLock);
  1592. return (ErrorPop());
  1593. }
  1595. if (MscMoveFile(szTmpFile, szUsrFilePath) < 0) {
  1596. ErrorPush();
  1597. MscMoveFile(szTmpUsrFilePath, szUsrFilePath);
  1598. SysRemove(szTmpFile);
  1599. RLckUnlockEX(hResLock);
  1600. return (ErrorPop());
  1601. }
  1603. SysRemove(szTmpUsrFilePath);
  1605. ///////////////////////////////////////////////////////////////////////////////
  1606. //  Rebuild indexes
  1607. ///////////////////////////////////////////////////////////////////////////////
  1608. if (UsrRebuildUsersIndexes(szUsrFilePath) < 0) {
  1609. ErrorPush();
  1610. RLckUnlockEX(hResLock);
  1611. return (ErrorPop());
  1612. }
  1614. RLckUnlockEX(hResLock);
  1616. return (0);
  1618. }
  1620. int UsrRemoveDomainUsers(const char *pszDomain)
  1621. {
  1623. char szUsrFilePath[SYS_MAX_PATH] = "";
  1625. UsrGetTableFilePath(szUsrFilePath, sizeof(szUsrFilePath));
  1627. char szTmpFile[SYS_MAX_PATH] = "";
  1629. SysGetTmpFile(szTmpFile);
  1631. char szResLock[SYS_MAX_PATH] = "";
  1632. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szUsrFilePath, szResLock,
  1633.   sizeof(szResLock)));
  1635. if (hResLock == INVALID_RLCK_HANDLE) {
  1636. ErrorPush();
  1637. CheckRemoveFile(szTmpFile);
  1638. return (ErrorPop());
  1639. }
  1641. FILE *pUsrFile = fopen(szUsrFilePath, "rt");
  1643. if (pUsrFile == NULL) {
  1644. RLckUnlockEX(hResLock);
  1645. CheckRemoveFile(szTmpFile);
  1647. ErrSetErrorCode(ERR_USERS_FILE_NOT_FOUND);
  1648. return (ERR_USERS_FILE_NOT_FOUND);
  1649. }
  1651. FILE *pTmpFile = fopen(szTmpFile, "wt");
  1653. if (pTmpFile == NULL) {
  1654. fclose(pUsrFile);
  1655. RLckUnlockEX(hResLock);
  1656. CheckRemoveFile(szTmpFile);
  1658. ErrSetErrorCode(ERR_FILE_CREATE);
  1659. return (ERR_FILE_CREATE);
  1660. }
  1662. int iUsersFound = 0;
  1663. char szUsrLine[USR_TABLE_LINE_MAX] = "";
  1665. while (MscFGets(szUsrLine, sizeof(szUsrLine) - 1, pUsrFile) != NULL) {
  1666. char **ppszStrings = StrGetTabLineStrings(szUsrLine);
  1668. if (ppszStrings == NULL)
  1669. continue;
  1671. int iFieldsCount = StrStringsCount(ppszStrings);
  1673. if ((iFieldsCount >= usrMax) && (stricmp(pszDomain, ppszStrings[usrDomain]) == 0)) {
  1675. ++iUsersFound;
  1677. } else
  1678. fprintf(pTmpFile, "%sn", szUsrLine);
  1680. StrFreeStrings(ppszStrings);
  1681. }
  1683. fclose(pUsrFile);
  1684. fclose(pTmpFile);
  1686. if (iUsersFound == 0) {
  1687. SysRemove(szTmpFile);
  1688. RLckUnlockEX(hResLock);
  1689. return (0);
  1690. }
  1692. char szTmpUsrFilePath[SYS_MAX_PATH] = "";
  1694. sprintf(szTmpUsrFilePath, "%s.tmp", szUsrFilePath);
  1696. if (MscMoveFile(szUsrFilePath, szTmpUsrFilePath) < 0) {
  1697. ErrorPush();
  1698. SysRemove(szTmpFile);
  1699. RLckUnlockEX(hResLock);
  1700. return (ErrorPop());
  1701. }
  1703. if (MscMoveFile(szTmpFile, szUsrFilePath) < 0) {
  1704. ErrorPush();
  1705. MscMoveFile(szTmpUsrFilePath, szUsrFilePath);
  1706. SysRemove(szTmpFile);
  1707. RLckUnlockEX(hResLock);
  1708. return (ErrorPop());
  1709. }
  1711. SysRemove(szTmpUsrFilePath);
  1713. ///////////////////////////////////////////////////////////////////////////////
  1714. //  Rebuild indexes
  1715. ///////////////////////////////////////////////////////////////////////////////
  1716. if (UsrRebuildUsersIndexes(szUsrFilePath) < 0) {
  1717. ErrorPush();
  1718. RLckUnlockEX(hResLock);
  1719. return (ErrorPop());
  1720. }
  1722. RLckUnlockEX(hResLock);
  1724. return (0);
  1726. }
  1728. static int UsrDropUserEnv(UserInfo * pUI)
  1729. {
  1730. ///////////////////////////////////////////////////////////////////////////////
  1731. //  User directory cleaning
  1732. ///////////////////////////////////////////////////////////////////////////////
  1733. char szUsrUserPath[SYS_MAX_PATH] = "";
  1735. UsrGetUserPath(pUI, szUsrUserPath, sizeof(szUsrUserPath), 0);
  1737. if (MscClearDirectory(szUsrUserPath) < 0)
  1738. return (ErrGetErrorCode());
  1740. ///////////////////////////////////////////////////////////////////////////////
  1741. //  User directory removing
  1742. ///////////////////////////////////////////////////////////////////////////////
  1743. if (SysRemoveDir(szUsrUserPath) < 0)
  1744. return (ErrGetErrorCode());
  1746. return (0);
  1748. }
  1750. static int UsrWriteUser(UserInfo * pUI, FILE * pUsrFile)
  1751. {
  1753. ///////////////////////////////////////////////////////////////////////////////
  1754. //  Domain
  1755. ///////////////////////////////////////////////////////////////////////////////
  1756. char *pszQuoted = StrQuote(pUI->pszDomain, '"');
  1758. if (pszQuoted == NULL)
  1759. return (ErrGetErrorCode());
  1761. fprintf(pUsrFile, "%st", pszQuoted);
  1763. SysFree(pszQuoted);
  1765. ///////////////////////////////////////////////////////////////////////////////
  1766. //  Name
  1767. ///////////////////////////////////////////////////////////////////////////////
  1768. pszQuoted = StrQuote(pUI->pszName, '"');
  1770. if (pszQuoted == NULL)
  1771. return (ErrGetErrorCode());
  1773. fprintf(pUsrFile, "%st", pszQuoted);
  1775. SysFree(pszQuoted);
  1777. ///////////////////////////////////////////////////////////////////////////////
  1778. //  Password
  1779. ///////////////////////////////////////////////////////////////////////////////
  1780. char szPassword[512] = "";
  1782. StrCrypt(pUI->pszPassword, szPassword);
  1784. pszQuoted = StrQuote(szPassword, '"');
  1786. if (pszQuoted == NULL)
  1787. return (ErrGetErrorCode());
  1789. fprintf(pUsrFile, "%st", pszQuoted);
  1791. SysFree(pszQuoted);
  1793. ///////////////////////////////////////////////////////////////////////////////
  1794. //  UserID
  1795. ///////////////////////////////////////////////////////////////////////////////
  1796. fprintf(pUsrFile, "%ut", pUI->uUserID);
  1798. ///////////////////////////////////////////////////////////////////////////////
  1799. //  Directory
  1800. ///////////////////////////////////////////////////////////////////////////////
  1801. pszQuoted = StrQuote(pUI->pszPath, '"');
  1803. if (pszQuoted == NULL)
  1804. return (ErrGetErrorCode());
  1806. fprintf(pUsrFile, "%st", pszQuoted);
  1808. SysFree(pszQuoted);
  1810. ///////////////////////////////////////////////////////////////////////////////
  1811. //  User type
  1812. ///////////////////////////////////////////////////////////////////////////////
  1813. pszQuoted = StrQuote(pUI->pszType, '"');
  1815. if (pszQuoted == NULL)
  1816. return (ErrGetErrorCode());
  1818. fprintf(pUsrFile, "%sn", pszQuoted);
  1820. SysFree(pszQuoted);
  1822. return (0);
  1824. }
  1826. int UsrAddUser(UserInfo * pUI)
  1827. {
  1828. ///////////////////////////////////////////////////////////////////////////////
  1829. //  Search for overlapping alias ( wildcard alias not checked here )
  1830. ///////////////////////////////////////////////////////////////////////////////
  1831. if (UsrAliasLookupName(pUI->pszDomain, pUI->pszName, NULL, false)) {
  1832. ErrSetErrorCode(ERR_ALIAS_EXIST);
  1833. return (ERR_ALIAS_EXIST);
  1834. }
  1836. char szUsrFilePath[SYS_MAX_PATH] = "";
  1838. UsrGetTableFilePath(szUsrFilePath, sizeof(szUsrFilePath));
  1840. char szResLock[SYS_MAX_PATH] = "";
  1841. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szUsrFilePath, szResLock,
  1842.   sizeof(szResLock)));
  1844. if (hResLock == INVALID_RLCK_HANDLE)
  1845. return (ErrGetErrorCode());
  1847. FILE *pUsrFile = fopen(szUsrFilePath, "r+t");
  1849. if (pUsrFile == NULL) {
  1850. RLckUnlockEX(hResLock);
  1852. ErrSetErrorCode(ERR_USERS_FILE_NOT_FOUND);
  1853. return (ERR_USERS_FILE_NOT_FOUND);
  1854. }
  1856. unsigned int uMaxUserID = 0;
  1857. char szUsrLine[USR_TABLE_LINE_MAX] = "";
  1859. while (MscFGets(szUsrLine, sizeof(szUsrLine) - 1, pUsrFile) != NULL) {
  1860. char **ppszStrings = StrGetTabLineStrings(szUsrLine);
  1862. if (ppszStrings == NULL)
  1863. continue;
  1865. int iFieldsCount = StrStringsCount(ppszStrings);
  1867. if (iFieldsCount >= usrMax) {
  1868. if ((stricmp(pUI->pszDomain, ppszStrings[usrDomain]) == 0) &&
  1869.     (stricmp(pUI->pszName, ppszStrings[usrName]) == 0)) {
  1870. StrFreeStrings(ppszStrings);
  1871. fclose(pUsrFile);
  1872. RLckUnlockEX(hResLock);
  1874. ErrSetErrorCode(ERR_USER_EXIST);
  1875. return (ERR_USER_EXIST);
  1876. }
  1878. unsigned int uUserID = (unsigned int) atol(ppszStrings[usrID]);
  1880. if (uUserID > uMaxUserID)
  1881. uMaxUserID = uUserID;
  1882. }
  1884. StrFreeStrings(ppszStrings);
  1885. }
  1887. pUI->uUserID = uMaxUserID + 1;
  1889. if (UsrPrepareUserEnv(pUI) < 0) {
  1890. fclose(pUsrFile);
  1891. RLckUnlockEX(hResLock);
  1892. return (ErrGetErrorCode());
  1893. }
  1895. fseek(pUsrFile, 0, SEEK_END);
  1897. if (UsrWriteUser(pUI, pUsrFile) < 0) {
  1898. fclose(pUsrFile);
  1899. RLckUnlockEX(hResLock);
  1901. ErrSetErrorCode(ERR_WRITE_USERS_FILE);
  1902. return (ERR_WRITE_USERS_FILE);
  1903. }
  1905. fclose(pUsrFile);
  1907. ///////////////////////////////////////////////////////////////////////////////
  1908. //  Rebuild indexes
  1909. ///////////////////////////////////////////////////////////////////////////////
  1910. if (UsrRebuildUsersIndexes(szUsrFilePath) < 0) {
  1911. ErrorPush();
  1912. RLckUnlockEX(hResLock);
  1913. return (ErrorPop());
  1914. }
  1916. RLckUnlockEX(hResLock);
  1918. ///////////////////////////////////////////////////////////////////////////////
  1919. //  Try ( if defined ) to add external auth user
  1920. ///////////////////////////////////////////////////////////////////////////////
  1921. UAthAddUser(AUTH_SERVICE_POP3, pUI);
  1923. return (0);
  1925. }
  1927. static char const *UsrGetMailboxDir(void)
  1928. {
  1930. return ((iMailboxType == XMAIL_MAILBOX) ? MAILBOX_DIRECTORY : MAILDIR_DIRECTORY);
  1932. }
  1934. static int UsrCreateMailbox(char const *pszUsrUserPath)
  1935. {
  1937. if (iMailboxType == XMAIL_MAILBOX) {
  1938. ///////////////////////////////////////////////////////////////////////////////
  1939. //  Create mailbox directory
  1940. ///////////////////////////////////////////////////////////////////////////////
  1941. char szUsrMailboxPath[SYS_MAX_PATH] = "";
  1943. StrSNCpy(szUsrMailboxPath, pszUsrUserPath);
  1945. AppendSlash(szUsrMailboxPath);
  1946. StrSNCat(szUsrMailboxPath, MAILBOX_DIRECTORY);
  1948. if (SysMakeDir(szUsrMailboxPath) < 0)
  1949. return (ErrGetErrorCode());
  1951. return (0);
  1952. }
  1954. return (MdirCreateStructure(pszUsrUserPath));
  1956. }
  1958. static int UsrPrepareUserEnv(UserInfo * pUI)
  1959. {
  1961. char szUsrUserPath[SYS_MAX_PATH] = "";
  1963. UsrGetUserPath(pUI, szUsrUserPath, sizeof(szUsrUserPath), 0);
  1965. ///////////////////////////////////////////////////////////////////////////////
  1966. //  Create main directory
  1967. ///////////////////////////////////////////////////////////////////////////////
  1968. if (SysMakeDir(szUsrUserPath) < 0)
  1969. return (ErrGetErrorCode());
  1971. if (UsrGetUserType(pUI) == usrTypeUser) {
  1972. ///////////////////////////////////////////////////////////////////////////////
  1973. //  Create mailbox directory
  1974. ///////////////////////////////////////////////////////////////////////////////
  1975. if (UsrCreateMailbox(szUsrUserPath) < 0) {
  1976. ErrorPush();
  1977. MscClearDirectory(szUsrUserPath);
  1978. SysRemoveDir(szUsrUserPath);
  1979. return (ErrorPop());
  1980. }
  1981. } else {
  1982. ///////////////////////////////////////////////////////////////////////////////
  1983. //  Create mailing list users file
  1984. ///////////////////////////////////////////////////////////////////////////////
  1985. char szMLUsersFilePath[SYS_MAX_PATH] = "";
  1987. StrSNCpy(szMLUsersFilePath, szUsrUserPath);
  1989. AppendSlash(szMLUsersFilePath);
  1990. StrSNCat(szMLUsersFilePath, MLUSERS_TABLE_FILE);
  1992. if (MscCreateEmptyFile(szMLUsersFilePath) < 0) {
  1993. ErrorPush();
  1994. MscClearDirectory(szUsrUserPath);
  1995. SysRemoveDir(szUsrUserPath);
  1996. return (ErrorPop());
  1997. }
  1998. }
  2000. ///////////////////////////////////////////////////////////////////////////////
  2001. //  Create profile file
  2002. ///////////////////////////////////////////////////////////////////////////////
  2003. char szUsrProfileFilePath[SYS_MAX_PATH] = "";
  2005. StrSNCpy(szUsrProfileFilePath, szUsrUserPath);
  2007. AppendSlash(szUsrProfileFilePath);
  2008. StrSNCat(szUsrProfileFilePath, USER_PROFILE_FILE);
  2010. FILE *pProfileFile = fopen(szUsrProfileFilePath, "wt");
  2012. if (pProfileFile == NULL) {
  2013. MscClearDirectory(szUsrUserPath);
  2014. SysRemoveDir(szUsrUserPath);
  2016. ErrSetErrorCode(ERR_FILE_CREATE);
  2017. return (ERR_FILE_CREATE);
  2018. }
  2020. UsrWriteInfoList(pUI->InfoList, pProfileFile);
  2022. fclose(pProfileFile);
  2024. return (0);
  2026. }
  2028. int UsrFlushUserVars(UserInfo * pUI)
  2029. {
  2031. char szUsrUserPath[SYS_MAX_PATH] = "";
  2033. UsrGetUserPath(pUI, szUsrUserPath, sizeof(szUsrUserPath), 0);
  2035. ///////////////////////////////////////////////////////////////////////////////
  2036. //  Build profile file path
  2037. ///////////////////////////////////////////////////////////////////////////////
  2038. char szUsrProfileFilePath[SYS_MAX_PATH] = "";
  2040. StrSNCpy(szUsrProfileFilePath, szUsrUserPath);
  2042. AppendSlash(szUsrProfileFilePath);
  2043. StrSNCat(szUsrProfileFilePath, USER_PROFILE_FILE);
  2045. char szResLock[SYS_MAX_PATH] = "";
  2046. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szUsrProfileFilePath, szResLock,
  2047.   sizeof(szResLock)));
  2049. if (hResLock == INVALID_RLCK_HANDLE)
  2050. return (ErrGetErrorCode());
  2052. FILE *pProfileFile = fopen(szUsrProfileFilePath, "wt");
  2054. if (pProfileFile == NULL) {
  2055. RLckUnlockEX(hResLock);
  2057. ErrSetErrorCode(ERR_FILE_CREATE);
  2058. return (ERR_FILE_CREATE);
  2059. }
  2061. UsrWriteInfoList(pUI->InfoList, pProfileFile);
  2063. fclose(pProfileFile);
  2065. RLckUnlockEX(hResLock);
  2067. return (0);
  2069. }
  2071. int UsrGetDBFileSnapShot(const char *pszFileName)
  2072. {
  2074. char szUsrFilePath[SYS_MAX_PATH] = "";
  2076. UsrGetTableFilePath(szUsrFilePath, sizeof(szUsrFilePath));
  2078. char szResLock[SYS_MAX_PATH] = "";
  2079. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szUsrFilePath, szResLock,
  2080.   sizeof(szResLock)));
  2082. if (hResLock == INVALID_RLCK_HANDLE)
  2083. return (ErrGetErrorCode());
  2085. if (MscCopyFile(pszFileName, szUsrFilePath) < 0) {
  2086. RLckUnlockSH(hResLock);
  2087. return (ErrGetErrorCode());
  2088. }
  2090. RLckUnlockSH(hResLock);
  2092. return (0);
  2094. }
  2096. USRF_HANDLE UsrOpenDB(void)
  2097. {
  2099. UsersDBScanData *pUDBSD = (UsersDBScanData *) SysAlloc(sizeof(UsersDBScanData));
  2101. if (pUDBSD == NULL)
  2102. return (INVALID_USRF_HANDLE);
  2104. SysGetTmpFile(pUDBSD->szTmpDBFile);
  2106. if (UsrGetDBFileSnapShot(pUDBSD->szTmpDBFile) < 0) {
  2107. SysFree(pUDBSD);
  2108. return (INVALID_USRF_HANDLE);
  2109. }
  2111. if ((pUDBSD->pDBFile = fopen(pUDBSD->szTmpDBFile, "rt")) == NULL) {
  2112. SysRemove(pUDBSD->szTmpDBFile);
  2113. SysFree(pUDBSD);
  2114. return (INVALID_USRF_HANDLE);
  2115. }
  2117. return ((USRF_HANDLE) pUDBSD);
  2119. }
  2121. void UsrCloseDB(USRF_HANDLE hUsersDB)
  2122. {
  2124. UsersDBScanData *pUDBSD = (UsersDBScanData *) hUsersDB;
  2126. fclose(pUDBSD->pDBFile);
  2128. SysRemove(pUDBSD->szTmpDBFile);
  2130. SysFree(pUDBSD);
  2132. }
  2134. UserInfo *UsrGetFirstUser(USRF_HANDLE hUsersDB)
  2135. {
  2137. UsersDBScanData *pUDBSD = (UsersDBScanData *) hUsersDB;
  2139. rewind(pUDBSD->pDBFile);
  2141. UserInfo *pUI = NULL;
  2142. char szUsrLine[USR_TABLE_LINE_MAX] = "";
  2144. while ((pUI == NULL) &&
  2145.        (MscFGets(szUsrLine, sizeof(szUsrLine) - 1, pUDBSD->pDBFile) != NULL)) {
  2146. char **ppszStrings = StrGetTabLineStrings(szUsrLine);
  2148. if (ppszStrings == NULL)
  2149. continue;
  2151. int iFieldsCount = StrStringsCount(ppszStrings);
  2153. if (iFieldsCount >= usrMax)
  2154. pUI = UsrGetUserFromStrings(ppszStrings);
  2156. StrFreeStrings(ppszStrings);
  2157. }
  2159. return (pUI);
  2161. }
  2163. UserInfo *UsrGetNextUser(USRF_HANDLE hUsersDB)
  2164. {
  2166. UsersDBScanData *pUDBSD = (UsersDBScanData *) hUsersDB;
  2168. UserInfo *pUI = NULL;
  2169. char szUsrLine[USR_TABLE_LINE_MAX] = "";
  2171. while ((pUI == NULL) &&
  2172.        (MscFGets(szUsrLine, sizeof(szUsrLine) - 1, pUDBSD->pDBFile) != NULL)) {
  2173. char **ppszStrings = StrGetTabLineStrings(szUsrLine);
  2175. if (ppszStrings == NULL)
  2176. continue;
  2178. int iFieldsCount = StrStringsCount(ppszStrings);
  2180. if (iFieldsCount >= usrMax)
  2181. pUI = UsrGetUserFromStrings(ppszStrings);
  2183. StrFreeStrings(ppszStrings);
  2184. }
  2186. return (pUI);
  2188. }
  2190. static char *UsrGetPop3LocksPath(UserInfo * pUI, char *pszPop3LockPath, int iMaxPath)
  2191. {
  2193. CfgGetRootPath(pszPop3LockPath, iMaxPath);
  2195. StrNCat(pszPop3LockPath, POP3_LOCKS_DIR, iMaxPath);
  2196. AppendSlash(pszPop3LockPath);
  2198. char szUserAddress[MAX_ADDR_NAME] = "";
  2200. UsrGetAddress(pUI, szUserAddress);
  2202. StrNCat(pszPop3LockPath, szUserAddress, iMaxPath);
  2204. return (pszPop3LockPath);
  2206. }
  2208. int UsrPOP3Lock(UserInfo * pUI)
  2209. {
  2211. char szLockPath[SYS_MAX_PATH] = "";
  2213. UsrGetPop3LocksPath(pUI, szLockPath, sizeof(szLockPath));
  2215. if (SysLockFile(szLockPath) < 0)
  2216. return (ErrGetErrorCode());
  2218. return (0);
  2220. }
  2222. void UsrPOP3Unlock(UserInfo * pUI)
  2223. {
  2225. char szLockPath[SYS_MAX_PATH] = "";
  2227. UsrGetPop3LocksPath(pUI, szLockPath, sizeof(szLockPath));
  2229. SysUnlockFile(szLockPath);
  2231. }
  2233. int UsrClearPop3LocksDir(void)
  2234. {
  2236. char szLocksDir[SYS_MAX_PATH] = "";
  2238. CfgGetRootPath(szLocksDir, sizeof(szLocksDir));
  2240. StrNCat(szLocksDir, POP3_LOCKS_DIR, sizeof(szLocksDir));
  2242. return (MscClearDirectory(szLocksDir));
  2244. }
  2246. char *UsrGetUserPath(UserInfo * pUI, char *pszUserPath, int iMaxPath, int iFinalSlash)
  2247. {
  2249. MDomGetDomainPath(pUI->pszDomain, pszUserPath, iMaxPath, 1);
  2251. StrNCat(pszUserPath, pUI->pszPath, iMaxPath);
  2253. if (iFinalSlash)
  2254. AppendSlash(pszUserPath);
  2256. return (pszUserPath);
  2258. }
  2260. char *UsrGetMailboxPath(UserInfo * pUI, char *pszMBPath, int iMaxPath, int iFinalSlash)
  2261. {
  2263. UsrGetUserPath(pUI, pszMBPath, iMaxPath, 1);
  2265. StrNCat(pszMBPath, UsrGetMailboxDir(), iMaxPath);
  2266. if (iFinalSlash)
  2267. AppendSlash(pszMBPath);
  2269. return (pszMBPath);
  2271. }
  2273. int UsrMoveToMailBox(UserInfo * pUI, char const *pszFileName, char const *pszMessageID)
  2274. {
  2276. if (iMailboxType == XMAIL_MAILBOX) {
  2277. ///////////////////////////////////////////////////////////////////////////////
  2278. //  Setup full mailbox file path
  2279. ///////////////////////////////////////////////////////////////////////////////
  2280. char szMBPath[SYS_MAX_PATH] = "";
  2281. char szMBFile[SYS_MAX_PATH] = "";
  2283. UsrGetMailboxPath(pUI, szMBPath, sizeof(szMBPath), 0);
  2285. sprintf(szMBFile, "%s" SYS_SLASH_STR "%s", szMBPath, pszMessageID);
  2287. char szResLock[SYS_MAX_PATH] = "";
  2288. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szMBPath, szResLock,
  2289.   sizeof(szResLock)));
  2291. if (hResLock == INVALID_RLCK_HANDLE)
  2292. return (ErrGetErrorCode());
  2294. if (MscMoveFile(pszFileName, szMBFile) < 0) {
  2295. ErrorPush();
  2296. RLckUnlockEX(hResLock);
  2297. return (ErrorPop());
  2298. }
  2300. RLckUnlockEX(hResLock);
  2301. } else {
  2302. ///////////////////////////////////////////////////////////////////////////////
  2303. //  Get user Maildir path
  2304. ///////////////////////////////////////////////////////////////////////////////
  2305. char szMBPath[SYS_MAX_PATH] = "";
  2307. UsrGetMailboxPath(pUI, szMBPath, sizeof(szMBPath), 0);
  2309. char szResLock[SYS_MAX_PATH] = "";
  2310. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szMBPath, szResLock,
  2311.   sizeof(szResLock)));
  2313. if (hResLock == INVALID_RLCK_HANDLE)
  2314. return (ErrGetErrorCode());
  2316. if (MdirMoveMessage(szMBPath, pszFileName, pszMessageID) < 0) {
  2317. ErrorPush();
  2318. RLckUnlockEX(hResLock);
  2319. return (ErrorPop());
  2320. }
  2322. RLckUnlockEX(hResLock);
  2323. }
  2325. return (0);
  2327. }
  2329. int UsrGetMailProcessFile(UserInfo * pUI, char const *pszMPPath)
  2330. {
  2332. int iAppendFiles = 0;
  2333. char szMPFilePath[SYS_MAX_PATH] = "";
  2335. if (MDomGetDomainPath(pUI->pszDomain, szMPFilePath, sizeof(szMPFilePath) - 1,
  2336.       1) == NULL)
  2337. return (ErrGetErrorCode());
  2338. StrNCat(szMPFilePath, MAILPROCESS_FILE, sizeof(szMPFilePath) - 1);
  2340. if (SysExistFile(szMPFilePath)) {
  2341. char szResLock[SYS_MAX_PATH] = "";
  2342. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szMPFilePath, szResLock,
  2343.   sizeof(szResLock)));
  2345. if (hResLock == INVALID_RLCK_HANDLE)
  2346. return (ErrGetErrorCode());
  2348. if (MscAppendFile(pszMPPath, szMPFilePath) < 0) {
  2349. ErrorPush();
  2350. CheckRemoveFile(pszMPPath);
  2351. RLckUnlockSH(hResLock);
  2352. return (ErrorPop());
  2353. }
  2355. RLckUnlockSH(hResLock);
  2356. iAppendFiles++;
  2357. }
  2359. if (UsrGetUserPath(pUI, szMPFilePath, sizeof(szMPFilePath), 1) == NULL)
  2360. return (ErrGetErrorCode());
  2361. StrNCat(szMPFilePath, MAILPROCESS_FILE, sizeof(szMPFilePath));
  2363. if (SysExistFile(szMPFilePath)) {
  2364. char szResLock[SYS_MAX_PATH] = "";
  2365. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szMPFilePath, szResLock,
  2366.   sizeof(szResLock)));
  2368. if (hResLock == INVALID_RLCK_HANDLE)
  2369. return (ErrGetErrorCode());
  2371. if (MscAppendFile(pszMPPath, szMPFilePath) < 0) {
  2372. ErrorPush();
  2373. CheckRemoveFile(pszMPPath);
  2374. RLckUnlockSH(hResLock);
  2375. return (ErrorPop());
  2376. }
  2378. RLckUnlockSH(hResLock);
  2379. iAppendFiles++;
  2380. }
  2382. if (!iAppendFiles) {
  2383. ErrSetErrorCode(ERR_NO_MAILPROC_FILE);
  2384. return (ERR_NO_MAILPROC_FILE);
  2385. }
  2387. return (0);
  2389. }
  2391. int UsrSetMailProcessFile(UserInfo * pUI, char const *pszMPPath)
  2392. {
  2394. char szMPFilePath[SYS_MAX_PATH] = "";
  2396. if (UsrGetUserPath(pUI, szMPFilePath, sizeof(szMPFilePath), 1) == NULL)
  2397. return (ErrGetErrorCode());
  2399. StrNCat(szMPFilePath, MAILPROCESS_FILE, sizeof(szMPFilePath));
  2401. char szResLock[SYS_MAX_PATH] = "";
  2402. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szMPFilePath, szResLock,
  2403.   sizeof(szResLock)));
  2405. if (hResLock == INVALID_RLCK_HANDLE)
  2406. return (ErrGetErrorCode());
  2408. if (pszMPPath != NULL) {
  2409. if (MscCopyFile(szMPFilePath, pszMPPath) < 0) {
  2410. ErrorPush();
  2411. RLckUnlockEX(hResLock);
  2412. return (ErrorPop());
  2413. }
  2414. } else
  2415. SysRemove(szMPFilePath);
  2417. RLckUnlockEX(hResLock);
  2419. return (0);
  2421. }
  2423. char *UsrGetAddress(UserInfo * pUI, char *pszAddress)
  2424. {
  2426. sprintf(pszAddress, "%s@%s", pUI->pszName, pUI->pszDomain);
  2428. return (pszAddress);
  2430. }
  2432. int UsrGetAliasDBFileSnapShot(char const *pszFileName)
  2433. {
  2435. char szAlsFilePath[SYS_MAX_PATH] = "";
  2437. UsrGetAliasFilePath(szAlsFilePath, sizeof(szAlsFilePath));
  2439. char szResLock[SYS_MAX_PATH] = "";
  2440. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szAlsFilePath, szResLock,
  2441.   sizeof(szResLock)));
  2443. if (hResLock == INVALID_RLCK_HANDLE)
  2444. return (ErrGetErrorCode());
  2446. if (MscCopyFile(pszFileName, szAlsFilePath) < 0) {
  2447. RLckUnlockSH(hResLock);
  2448. return (ErrGetErrorCode());
  2449. }
  2451. RLckUnlockSH(hResLock);
  2453. return (0);
  2455. }
  2457. ALSF_HANDLE UsrAliasOpenDB(void)
  2458. {
  2460. AliasDBScanData *pADBSD = (AliasDBScanData *) SysAlloc(sizeof(AliasDBScanData));
  2462. if (pADBSD == NULL)
  2463. return (INVALID_ALSF_HANDLE);
  2465. SysGetTmpFile(pADBSD->szTmpDBFile);
  2467. if (UsrGetAliasDBFileSnapShot(pADBSD->szTmpDBFile) < 0) {
  2468. SysFree(pADBSD);
  2469. return (INVALID_ALSF_HANDLE);
  2470. }
  2472. if ((pADBSD->pDBFile = fopen(pADBSD->szTmpDBFile, "rt")) == NULL) {
  2473. SysRemove(pADBSD->szTmpDBFile);
  2474. SysFree(pADBSD);
  2475. return (INVALID_ALSF_HANDLE);
  2476. }
  2478. return ((ALSF_HANDLE) pADBSD);
  2480. }
  2482. void UsrAliasCloseDB(ALSF_HANDLE hAliasDB)
  2483. {
  2485. AliasDBScanData *pADBSD = (AliasDBScanData *) hAliasDB;
  2487. fclose(pADBSD->pDBFile);
  2489. SysRemove(pADBSD->szTmpDBFile);
  2491. SysFree(pADBSD);
  2493. }
  2495. AliasInfo *UsrAliasGetFirst(ALSF_HANDLE hAliasDB)
  2496. {
  2498. AliasDBScanData *pADBSD = (AliasDBScanData *) hAliasDB;
  2500. rewind(pADBSD->pDBFile);
  2502. AliasInfo *pAI = NULL;
  2503. char szUsrLine[USR_ALIAS_LINE_MAX] = "";
  2505. while ((pAI == NULL) &&
  2506.        (MscFGets(szUsrLine, sizeof(szUsrLine) - 1, pADBSD->pDBFile) != NULL)) {
  2507. char **ppszStrings = StrGetTabLineStrings(szUsrLine);
  2509. if (ppszStrings == NULL)
  2510. continue;
  2512. int iFieldsCount = StrStringsCount(ppszStrings);
  2514. if (iFieldsCount >= alsMax)
  2515. pAI =
  2516.     UsrAllocAlias(ppszStrings[alsDomain], ppszStrings[alsAlias],
  2517.   ppszStrings[alsName]);
  2519. StrFreeStrings(ppszStrings);
  2520. }
  2522. return (pAI);
  2524. }
  2526. AliasInfo *UsrAliasGetNext(ALSF_HANDLE hAliasDB)
  2527. {
  2529. AliasDBScanData *pADBSD = (AliasDBScanData *) hAliasDB;
  2531. AliasInfo *pAI = NULL;
  2532. char szUsrLine[USR_ALIAS_LINE_MAX] = "";
  2534. while ((pAI == NULL) &&
  2535.        (MscFGets(szUsrLine, sizeof(szUsrLine) - 1, pADBSD->pDBFile) != NULL)) {
  2536. char **ppszStrings = StrGetTabLineStrings(szUsrLine);
  2538. if (ppszStrings == NULL)
  2539. continue;
  2541. int iFieldsCount = StrStringsCount(ppszStrings);
  2543. if (iFieldsCount >= alsMax)
  2544. pAI =
  2545.     UsrAllocAlias(ppszStrings[alsDomain], ppszStrings[alsAlias],
  2546.   ppszStrings[alsName]);
  2548. StrFreeStrings(ppszStrings);
  2549. }
  2551. return (pAI);
  2553. }