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

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

Email服务器

开发平台：

Visual C++

CTRLSvr.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 "SList.h"
  28. #include "BuffSock.h"
  29. #include "ResLocks.h"
  30. #include "MiscUtils.h"
  31. #include "MD5.h"
  32. #include "MailConfig.h"
  33. #include "SvrUtils.h"
  34. #include "UsrUtils.h"
  35. #include "StrUtils.h"
  36. #include "POP3Utils.h"
  37. #include "MessQueue.h"
  38. #include "SMAILUtils.h"
  39. #include "QueueUtils.h"
  40. #include "UsrMailList.h"
  41. #include "POP3GwLink.h"
  42. #include "MailDomains.h"
  43. #include "AliasDomain.h"
  44. #include "ExtAliases.h"
  45. #include "SMTPUtils.h"
  46. #include "MailConfig.h"
  47. #include "AppDefines.h"
  48. #include "MailSvr.h"
  49. #include "CTRLSvr.h"
  51. #define CTRL_ACCOUNTS_FILE      "ctrlaccounts.tab"
  52. #define CTRL_ACCOUNTS_LINE_MAX  512
  53. #define CTRLSRV_ACCEPT_TIMEOUT  4
  54. #define CTRL_LISTEN_SIZE        8
  55. #define CTRL_WAIT_SLEEP         2
  56. #define MAX_CLIENTS_WAIT        300
  57. #define STD_CTRL_TIMEOUT        45
  58. #define CTRL_IPMAP_FILE         "ctrl.ipmap.tab"
  59. #define CTRL_LOG_FILE           "ctrl"
  60. #define CTRL_MAX_LINE_SIZE      4096
  61. #define CTRL_QUIT_CMD_EXIT      1
  62. #define CTRL_LISTFOLLOW_RESULT  100
  63. #define CTRL_WAITDATA_RESULT    101
  64. #define CTRL_VAR_DROP_VALUE     ".|rm"
  65. #define CTRL_SERVER_NAME        "[" APP_NAME_VERSION_STR " CTRL Server]"
  67. enum CtrlAccountsFileds {
  68. accUsername = 0,
  69. accPassword,
  71. accMax
  72. };
  74. static CTRLConfig *CTRLGetConfigCopy(SHB_HANDLE hShbCTRL);
  75. static int CTRLLogEnabled(SHB_HANDLE hShbCTRL, CTRLConfig * pCTRLCfg = NULL);
  76. static int CTRLCheckPeerIP(SYS_SOCKET SockFD);
  77. static int CTRLLogSession(char const *pszUsername, char const *pszPassword,
  78.   SYS_INET_ADDR const &PeerInfo, int iStatus);
  79. static int CTRLThreadCountAdd(long lCount, SHB_HANDLE hShbCTRL, CTRLConfig * pCTRLCfg = NULL);
  80. static unsigned int CTRLClientThread(void *pThreadData);
  81. static int CTRLSendCmdResult(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock, int iErrorCode);
  82. static int CTRLSendCmdResult(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock, int iErrorCode,
  83.      char const *pszMessage);
  84. static int CTRLVSendCmdResult(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock, int iErrorCode,
  85.       char const *pszFormat, ...);
  86. static int CTRLSendCmdResult(BSOCK_HANDLE hBSock, int iErrorCode, char const *pszMessage,
  87.      int iTimeout);
  88. static char *CTRLGetAccountsFilePath(char *pszAccFilePath, int iMaxPath);
  89. static int CTRLAccountCheck(CTRLConfig * pCTRLCfg, char const *pszUsername,
  90.     char const *pszPassword, char const *pszTimeStamp);
  91. static int CTRLLogin(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  92.      char const *pszTimeStamp, SYS_INET_ADDR const &PeerInfo);
  93. static int CTRLHandleSession(SHB_HANDLE hShbCTRL, BSOCK_HANDLE hBSock,
  94.      SYS_INET_ADDR const &PeerInfo);
  95. static int CTRLProcessCommand(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock, char const *pszCommand);
  96. static int CTRLDo_useradd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  97.   char const *const *ppszTokens, int iTokensCount);
  98. static int CTRLDo_userdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  99.   char const *const *ppszTokens, int iTokensCount);
  100. static int CTRLDo_userpasswd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  101.      char const *const *ppszTokens, int iTokensCount);
  102. static int CTRLDo_aliasadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  103.    char const *const *ppszTokens, int iTokensCount);
  104. static int CTRLDo_aliasdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  105.    char const *const *ppszTokens, int iTokensCount);
  106. static int CTRLDo_aliaslist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  107.     char const *const *ppszTokens, int iTokensCount);
  108. static int CTRLDo_exaliasadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  109.      char const *const *ppszTokens, int iTokensCount);
  110. static int CTRLDo_exaliasdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  111.      char const *const *ppszTokens, int iTokensCount);
  112. static int CTRLDo_exaliaslist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  113.       char const *const *ppszTokens, int iTokensCount);
  114. static int CTRLDo_uservars(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  115.    char const *const *ppszTokens, int iTokensCount);
  116. static int CTRLDo_uservarsset(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  117.       char const *const *ppszTokens, int iTokensCount);
  118. static int CTRLDo_userlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  119.    char const *const *ppszTokens, int iTokensCount);
  120. static int CTRLDo_usergetmproc(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  121.        char const *const *ppszTokens, int iTokensCount);
  122. static int CTRLDo_usersetmproc(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  123.        char const *const *ppszTokens, int iTokensCount);
  124. static int CTRLDo_userauth(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  125.    char const *const *ppszTokens, int iTokensCount);
  126. static int CTRLDo_userstat(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  127.    char const *const *ppszTokens, int iTokensCount);
  128. static int CTRLDo_mluseradd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  129.     char const *const *ppszTokens, int iTokensCount);
  130. static int CTRLDo_mluserdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  131.     char const *const *ppszTokens, int iTokensCount);
  132. static int CTRLDo_mluserlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  133.      char const *const *ppszTokens, int iTokensCount);
  134. static int CTRLDo_domainadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  135.     char const *const *ppszTokens, int iTokensCount);
  136. static int CTRLDo_domaindel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  137.     char const *const *ppszTokens, int iTokensCount);
  138. static int CTRLDo_domainlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  139.      char const *const *ppszTokens, int iTokensCount);
  140. static int CTRLDo_custdomget(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  141.      char const *const *ppszTokens, int iTokensCount);
  142. static int CTRLDo_custdomset(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  143.      char const *const *ppszTokens, int iTokensCount);
  144. static int CTRLDo_custdomlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  145.       char const *const *ppszTokens, int iTokensCount);
  146. static int CTRLDo_noop(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  147.        char const *const *ppszTokens, int iTokensCount);
  148. static int CTRLDo_quit(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  149.        char const *const *ppszTokens, int iTokensCount);
  150. static int CTRLDo_poplnkadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  151.     char const *const *ppszTokens, int iTokensCount);
  152. static int CTRLDo_poplnkdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  153.     char const *const *ppszTokens, int iTokensCount);
  154. static int CTRLDo_poplnklist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  155.      char const *const *ppszTokens, int iTokensCount);
  156. static int CTRLDo_poplnkenable(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  157.        char const *const *ppszTokens, int iTokensCount);
  158. static int CTRLCheckRelativePath(char const *pszPath);
  159. static int CTRLDo_filelist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  160.    char const *const *ppszTokens, int iTokensCount);
  161. static int CTRLDo_cfgfileget(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  162.      char const *const *ppszTokens, int iTokensCount);
  163. static int CTRLDo_cfgfileset(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  164.      char const *const *ppszTokens, int iTokensCount);
  165. static int CTRLDo_frozlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  166.    char const *const *ppszTokens, int iTokensCount);
  167. static int CTRLDo_frozsubmit(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  168.      char const *const *ppszTokens, int iTokensCount);
  169. static int CTRLDo_frozdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  170.   char const *const *ppszTokens, int iTokensCount);
  171. static int CTRLDo_frozgetlog(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  172.      char const *const *ppszTokens, int iTokensCount);
  173. static int CTRLDo_frozgetmsg(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  174.      char const *const *ppszTokens, int iTokensCount);
  175. static int CTRLDo_etrn(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  176.        char const *const *ppszTokens, int iTokensCount);
  177. static int CTRLDo_aliasdomainadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  178.  char const *const *ppszTokens, int iTokensCount);
  179. static int CTRLDo_aliasdomaindel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  180.  char const *const *ppszTokens, int iTokensCount);
  181. static int CTRLDo_aliasdomainlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  182.   char const *const *ppszTokens, int iTokensCount);
  184. static CTRLConfig *CTRLGetConfigCopy(SHB_HANDLE hShbCTRL)
  185. {
  187. CTRLConfig *pCTRLCfg = (CTRLConfig *) ShbLock(hShbCTRL);
  189. if (pCTRLCfg == NULL)
  190. return (NULL);
  192. CTRLConfig *pCTRLCfgCopy = (CTRLConfig *) SysAlloc(sizeof(CTRLConfig));
  194. if (pCTRLCfgCopy != NULL)
  195. memcpy(pCTRLCfgCopy, pCTRLCfg, sizeof(CTRLConfig));
  197. ShbUnlock(hShbCTRL);
  199. return (pCTRLCfgCopy);
  201. }
  203. static int CTRLLogEnabled(SHB_HANDLE hShbCTRL, CTRLConfig * pCTRLCfg)
  204. {
  206. int iDoUnlock = 0;
  208. if (pCTRLCfg == NULL) {
  209. if ((pCTRLCfg = (CTRLConfig *) ShbLock(hShbCTRL)) == NULL)
  210. return (ErrGetErrorCode());
  212. ++iDoUnlock;
  213. }
  215. unsigned long ulFlags = pCTRLCfg->ulFlags;
  217. if (iDoUnlock)
  218. ShbUnlock(hShbCTRL);
  220. return ((ulFlags & CTRLF_LOG_ENABLED) ? 1 : 0);
  222. }
  224. static int CTRLCheckPeerIP(SYS_SOCKET SockFD)
  225. {
  227. char szIPMapFile[SYS_MAX_PATH] = "";
  229. CfgGetRootPath(szIPMapFile, sizeof(szIPMapFile));
  230. StrSNCat(szIPMapFile, CTRL_IPMAP_FILE);
  232. if (SysExistFile(szIPMapFile)) {
  233. SYS_INET_ADDR PeerInfo;
  235. if (SysGetPeerInfo(SockFD, PeerInfo) < 0)
  236. return (ErrGetErrorCode());
  238. if (MscCheckAllowedIP(szIPMapFile, PeerInfo, true) < 0)
  239. return (ErrGetErrorCode());
  240. }
  242. return (0);
  244. }
  246. static int CTRLLogSession(char const *pszUsername, char const *pszPassword,
  247.   SYS_INET_ADDR const &PeerInfo, int iStatus)
  248. {
  250. char szTime[256] = "";
  252. MscGetTimeNbrString(szTime, sizeof(szTime) - 1);
  254. RLCK_HANDLE hResLock = RLckLockEX(SVR_LOGS_DIR SYS_SLASH_STR CTRL_LOG_FILE);
  256. if (hResLock == INVALID_RLCK_HANDLE)
  257. return (ErrGetErrorCode());
  259. char szIP[128] = "???.???.???.???";
  261. MscFileLog(CTRL_LOG_FILE, ""%s""
  262.    "t"%s""
  263.    "t"%s""
  264.    "t"%s""
  265.    "t"%s""
  266.    "n", SysInetNToA(PeerInfo, szIP), pszUsername, pszPassword, szTime,
  267.    (iStatus == 0) ? "REQ" : ((iStatus > 0) ? "AUTH" : "FAIL"));
  269. RLckUnlockEX(hResLock);
  271. return (0);
  273. }
  275. static int CTRLThreadCountAdd(long lCount, SHB_HANDLE hShbCTRL, CTRLConfig * pCTRLCfg)
  276. {
  278. int iDoUnlock = 0;
  280. if (pCTRLCfg == NULL) {
  281. if ((pCTRLCfg = (CTRLConfig *) ShbLock(hShbCTRL)) == NULL)
  282. return (ErrGetErrorCode());
  284. ++iDoUnlock;
  285. }
  287. if ((pCTRLCfg->lThreadCount + lCount) > pCTRLCfg->lMaxThreads) {
  288. if (iDoUnlock)
  289. ShbUnlock(hShbCTRL);
  291. ErrSetErrorCode(ERR_SERVER_BUSY);
  292. return (ERR_SERVER_BUSY);
  293. }
  295. pCTRLCfg->lThreadCount += lCount;
  297. if (iDoUnlock)
  298. ShbUnlock(hShbCTRL);
  300. return (0);
  302. }
  304. unsigned int CTRLThreadProc(void *pThreadData)
  305. {
  307. CTRLConfig *pCTRLCfg = (CTRLConfig *) ShbLock(hShbCTRL);
  309. if (pCTRLCfg == NULL)
  310. return (ErrGetErrorCode());
  312. int iNumSockFDs = 0;
  313. SYS_SOCKET SockFDs[MAX_CTRL_ACCEPT_ADDRESSES];
  315. if (MscCreateServerSockets(pCTRLCfg->iNumAddr, pCTRLCfg->SvrAddr, pCTRLCfg->iPort,
  316.    CTRL_LISTEN_SIZE, SockFDs, iNumSockFDs) < 0) {
  317. ErrorPush();
  318. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  319. ShbUnlock(hShbCTRL);
  320. return (ErrorPop());
  321. }
  323. ShbUnlock(hShbCTRL);
  325. SysLogMessage(LOG_LEV_MESSAGE, "%s startedn", CTRL_SERVER_NAME);
  327. for (;;) {
  328. int iNumConnSockFD = 0;
  329. SYS_SOCKET ConnSockFD[MAX_CTRL_ACCEPT_ADDRESSES];
  331. if (MscAcceptServerConnection(SockFDs, iNumSockFDs, ConnSockFD,
  332.       iNumConnSockFD, CTRLSRV_ACCEPT_TIMEOUT) < 0) {
  333. unsigned long ulFlags = CTRLF_STOP_SERVER;
  335. pCTRLCfg = (CTRLConfig *) ShbLock(hShbCTRL);
  337. if (pCTRLCfg != NULL)
  338. ulFlags = pCTRLCfg->ulFlags;
  340. ShbUnlock(hShbCTRL);
  342. if (ulFlags & CTRLF_STOP_SERVER)
  343. break;
  344. else
  345. continue;
  346. }
  348. for (int ss = 0; ss < iNumConnSockFD; ss++) {
  349. SYS_THREAD hClientThread =
  350.     SysCreateServiceThread(CTRLClientThread, ConnSockFD[ss]);
  352. if (hClientThread != SYS_INVALID_THREAD)
  353. SysCloseThread(hClientThread, 0);
  354. else
  355. SysCloseSocket(ConnSockFD[ss]);
  357. }
  358. }
  360. for (int ss = 0; ss < iNumSockFDs; ss++)
  361. SysCloseSocket(SockFDs[ss]);
  363. ///////////////////////////////////////////////////////////////////////////////
  364. //  Wait for client completion
  365. ///////////////////////////////////////////////////////////////////////////////
  366. for (int iTotalWait = 0; (iTotalWait < MAX_CLIENTS_WAIT); iTotalWait += CTRL_WAIT_SLEEP) {
  367. pCTRLCfg = (CTRLConfig *) ShbLock(hShbCTRL);
  369. if (pCTRLCfg == NULL)
  370. break;
  372. long lThreadCount = pCTRLCfg->lThreadCount;
  374. ShbUnlock(hShbCTRL);
  376. if (lThreadCount == 0)
  377. break;
  379. SysSleep(CTRL_WAIT_SLEEP);
  380. }
  382. SysLogMessage(LOG_LEV_MESSAGE, "%s stoppedn", CTRL_SERVER_NAME);
  384. return (0);
  386. }
  388. static unsigned int CTRLClientThread(void *pThreadData)
  389. {
  391. SYS_SOCKET SockFD = (SYS_SOCKET) (unsigned long) pThreadData;
  393. ///////////////////////////////////////////////////////////////////////////////
  394. //  Link socket to the bufferer
  395. ///////////////////////////////////////////////////////////////////////////////
  396. BSOCK_HANDLE hBSock = BSckAttach(SockFD);
  398. if (hBSock == INVALID_BSOCK_HANDLE) {
  399. ErrorPush();
  400. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  401. SysCloseSocket(SockFD);
  402. return (ErrorPop());
  403. }
  404. ///////////////////////////////////////////////////////////////////////////////
  405. //  Check IP permission
  406. ///////////////////////////////////////////////////////////////////////////////
  407. if (CTRLCheckPeerIP(SockFD) < 0) {
  408. ErrorPush();
  410. CTRLSendCmdResult(hBSock, ErrorFetch(), ErrGetErrorString(), STD_CTRL_TIMEOUT);
  412. BSckDetach(hBSock, 1);
  413. return (ErrorPop());
  414. }
  415. ///////////////////////////////////////////////////////////////////////////////
  416. //  Increase threads count
  417. ///////////////////////////////////////////////////////////////////////////////
  418. if (CTRLThreadCountAdd(+1, hShbCTRL) < 0) {
  419. ErrorPush();
  421. CTRLSendCmdResult(hBSock, ErrorFetch(), ErrGetErrorString(), STD_CTRL_TIMEOUT);
  423. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString(ErrorFetch()));
  424. BSckDetach(hBSock, 1);
  425. return (ErrorPop());
  426. }
  427. ///////////////////////////////////////////////////////////////////////////////
  428. //  Get client socket information
  429. ///////////////////////////////////////////////////////////////////////////////
  430. SYS_INET_ADDR PeerInfo;
  432. if (SysGetPeerInfo(SockFD, PeerInfo) < 0) {
  433. ErrorPush();
  434. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  435. BSckDetach(hBSock, 1);
  436. CTRLThreadCountAdd(-1, hShbCTRL);
  437. return (ErrorPop());
  438. }
  440. char szIP[128] = "???.???.???.???";
  442. SysLogMessage(LOG_LEV_MESSAGE, "CTRL client connection from [%s]n",
  443.       SysInetNToA(PeerInfo, szIP));
  445. ///////////////////////////////////////////////////////////////////////////////
  446. //  Handle client session
  447. ///////////////////////////////////////////////////////////////////////////////
  448. CTRLHandleSession(hShbCTRL, hBSock, PeerInfo);
  450. SysLogMessage(LOG_LEV_MESSAGE, "CTRL client exit [%s]n", SysInetNToA(PeerInfo, szIP));
  452. ///////////////////////////////////////////////////////////////////////////////
  453. //  Unlink socket from the bufferer and close it
  454. ///////////////////////////////////////////////////////////////////////////////
  455. BSckDetach(hBSock, 1);
  457. ///////////////////////////////////////////////////////////////////////////////
  458. //  Decrease thread count
  459. ///////////////////////////////////////////////////////////////////////////////
  460. CTRLThreadCountAdd(-1, hShbCTRL);
  462. return (0);
  464. }
  466. static int CTRLSendCmdResult(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock, int iErrorCode)
  467. {
  469. return (CTRLSendCmdResult(pCTRLCfg, hBSock, iErrorCode,
  470.   (iErrorCode >= 0) ? "OK" : ErrGetErrorString(iErrorCode)));
  472. }
  474. static int CTRLSendCmdResult(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock, int iErrorCode,
  475.      char const *pszMessage)
  476. {
  478. return (CTRLSendCmdResult(hBSock, iErrorCode, pszMessage, pCTRLCfg->iTimeout));
  480. }
  482. static int CTRLVSendCmdResult(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock, int iErrorCode,
  483.       char const *pszFormat, ...)
  484. {
  486. char *pszMessage = NULL;
  488. STRSPRINTF(pszMessage, pszFormat, pszFormat);
  490. if (pszMessage == NULL)
  491. return (ErrGetErrorCode());
  493. int iSendResult = CTRLSendCmdResult(hBSock, iErrorCode, pszMessage, pCTRLCfg->iTimeout);
  495. SysFree(pszMessage);
  497. return (iSendResult);
  499. }
  501. static int CTRLSendCmdResult(BSOCK_HANDLE hBSock, int iErrorCode, char const *pszMessage,
  502.      int iTimeout)
  503. {
  505. int iSendResult;
  507. if (iErrorCode >= 0)
  508. iSendResult =
  509.     BSckVSendString(hBSock, iTimeout, "+%05d %s", iErrorCode, pszMessage);
  510. else
  511. iSendResult =
  512.     BSckVSendString(hBSock, iTimeout, "-%05d %s", -iErrorCode, pszMessage);
  514. return (iSendResult);
  516. }
  518. static char *CTRLGetAccountsFilePath(char *pszAccFilePath, int iMaxPath)
  519. {
  521. CfgGetRootPath(pszAccFilePath, iMaxPath);
  523. StrNCat(pszAccFilePath, CTRL_ACCOUNTS_FILE, iMaxPath);
  525. return (pszAccFilePath);
  527. }
  529. static int CTRLAccountCheck(CTRLConfig * pCTRLCfg, char const *pszUsername,
  530.     char const *pszPassword, char const *pszTimeStamp)
  531. {
  533. char szAccFilePath[SYS_MAX_PATH] = "";
  535. CTRLGetAccountsFilePath(szAccFilePath, sizeof(szAccFilePath));
  537. char szResLock[SYS_MAX_PATH] = "";
  538. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szAccFilePath, szResLock,
  539.   sizeof(szResLock)));
  541. if (hResLock == INVALID_RLCK_HANDLE)
  542. return (ErrGetErrorCode());
  544. FILE *pAccountsFile = fopen(szAccFilePath, "rt");
  546. if (pAccountsFile == NULL) {
  547. RLckUnlockSH(hResLock);
  549. ErrSetErrorCode(ERR_CTRL_ACCOUNTS_FILE_NOT_FOUND);
  550. return (ERR_CTRL_ACCOUNTS_FILE_NOT_FOUND);
  551. }
  553. char szAccountsLine[CTRL_ACCOUNTS_LINE_MAX] = "";
  555. while (MscFGets(szAccountsLine, sizeof(szAccountsLine) - 1, pAccountsFile) != NULL) {
  556. char **ppszStrings = StrGetTabLineStrings(szAccountsLine);
  558. if (ppszStrings == NULL)
  559. continue;
  561. int iFieldsCount = StrStringsCount(ppszStrings);
  563. if ((iFieldsCount >= accMax) &&
  564.     (stricmp(pszUsername, ppszStrings[accUsername]) == 0)) {
  566. char szClearPassword[256] = "";
  568. StrDeCrypt(ppszStrings[accPassword], szClearPassword);
  570. StrFreeStrings(ppszStrings);
  571. fclose(pAccountsFile);
  572. RLckUnlockSH(hResLock);
  574. ///////////////////////////////////////////////////////////////////////////////
  575. //  Check for MD5 authentication ( # as first char of password )
  576. ///////////////////////////////////////////////////////////////////////////////
  577. if (*pszPassword == '#') {
  578. if (MscMD5Authenticate
  579.     (szClearPassword, pszTimeStamp, pszPassword + 1) < 0) {
  580. ErrSetErrorCode(ERR_BAD_CTRL_LOGIN);
  581. return (ERR_BAD_CTRL_LOGIN);
  582. }
  583. } else if (strcmp(szClearPassword, pszPassword) != 0) {
  584. ErrSetErrorCode(ERR_BAD_CTRL_LOGIN);
  585. return (ERR_BAD_CTRL_LOGIN);
  586. }
  588. return (0);
  589. }
  591. StrFreeStrings(ppszStrings);
  592. }
  594. fclose(pAccountsFile);
  596. RLckUnlockSH(hResLock);
  598. ErrSetErrorCode(ERR_BAD_CTRL_LOGIN);
  599. return (ERR_BAD_CTRL_LOGIN);
  601. }
  603. static int CTRLLogin(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  604.      char const *pszTimeStamp, SYS_INET_ADDR const &PeerInfo)
  605. {
  607. char szLogin[256] = "";
  609. if ((BSckGetString(hBSock, szLogin, sizeof(szLogin) - 1, pCTRLCfg->iTimeout) == NULL) ||
  610.     (MscCmdStringCheck(szLogin) < 0))
  611. return (ErrGetErrorCode());
  613. char **ppszTokens = StrGetTabLineStrings(szLogin);
  615. if (ppszTokens == NULL) {
  616. ErrorPush();
  617. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  618. return (ErrorPop());
  619. }
  621. int iTokensCount = StrStringsCount(ppszTokens);
  623. if (iTokensCount != 2) {
  624. StrFreeStrings(ppszTokens);
  626. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_LOGIN);
  627. ErrSetErrorCode(ERR_BAD_CTRL_LOGIN);
  628. return (ERR_BAD_CTRL_LOGIN);
  629. }
  630. ///////////////////////////////////////////////////////////////////////////////
  631. //  Log CTRL login request
  632. ///////////////////////////////////////////////////////////////////////////////
  633. if (CTRLLogEnabled(SHB_INVALID_HANDLE, pCTRLCfg))
  634. CTRLLogSession(ppszTokens[0], ppszTokens[1], PeerInfo, 0);
  636. ///////////////////////////////////////////////////////////////////////////////
  637. //  Check user and password
  638. ///////////////////////////////////////////////////////////////////////////////
  639. if (CTRLAccountCheck(pCTRLCfg, ppszTokens[0], ppszTokens[1], pszTimeStamp) < 0) {
  640. ErrorPush();
  641. ///////////////////////////////////////////////////////////////////////////////
  642. //  Log CTRL login failure
  643. ///////////////////////////////////////////////////////////////////////////////
  644. if (CTRLLogEnabled(SHB_INVALID_HANDLE, pCTRLCfg))
  645. CTRLLogSession(ppszTokens[0], ppszTokens[1], PeerInfo, -1);
  647. StrFreeStrings(ppszTokens);
  649. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  650. return (ErrorPop());
  651. }
  652. ///////////////////////////////////////////////////////////////////////////////
  653. //  Log CTRL login authentication
  654. ///////////////////////////////////////////////////////////////////////////////
  655. if (CTRLLogEnabled(SHB_INVALID_HANDLE, pCTRLCfg))
  656. CTRLLogSession(ppszTokens[0], ppszTokens[1], PeerInfo, +1);
  658. StrFreeStrings(ppszTokens);
  660. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  662. return (0);
  664. }
  666. static int CTRLHandleSession(SHB_HANDLE hShbCTRL, BSOCK_HANDLE hBSock,
  667.      SYS_INET_ADDR const &PeerInfo)
  668. {
  670. CTRLConfig *pCTRLCfg = CTRLGetConfigCopy(hShbCTRL);
  672. if (pCTRLCfg == NULL)
  673. return (ErrGetErrorCode());
  675. int iSessionTimeout = pCTRLCfg->iSessionTimeout, iTimeout = pCTRLCfg->iTimeout;
  677. ///////////////////////////////////////////////////////////////////////////////
  678. //  Build TimeStamp string
  679. ///////////////////////////////////////////////////////////////////////////////
  680. SYS_INET_ADDR SockInfo;
  681. char szTimeStamp[256] = "";
  683. SysGetSockInfo(BSckGetAttachedSocket(hBSock), SockInfo);
  685. char szIP[128] = "???.???.???.???";
  687. sprintf(szTimeStamp, "<%lu.%lu@%s>",
  688. (unsigned long) time(NULL), SysGetCurrentThreadId(), SysInetNToA(SockInfo, szIP));
  690. ///////////////////////////////////////////////////////////////////////////////
  691. //  Welcome
  692. ///////////////////////////////////////////////////////////////////////////////
  693. char szTime[256] = "";
  695. MscGetTimeStr(szTime, sizeof(szTime) - 1);
  697. CTRLVSendCmdResult(pCTRLCfg, hBSock, 0, "%s %s CTRL Server; %s",
  698.    szTimeStamp, APP_NAME_VERSION_STR, szTime);
  700. ///////////////////////////////////////////////////////////////////////////////
  701. //  User login
  702. ///////////////////////////////////////////////////////////////////////////////
  703. if (CTRLLogin(pCTRLCfg, hBSock, szTimeStamp, PeerInfo) < 0) {
  704. ErrorPush();
  705. SysFree(pCTRLCfg);
  706. return (ErrorPop());
  707. }
  709. SysFree(pCTRLCfg);
  711. ///////////////////////////////////////////////////////////////////////////////
  712. //  Command loop
  713. ///////////////////////////////////////////////////////////////////////////////
  714. char szCommand[CTRL_MAX_LINE_SIZE] = "";
  716. while (!SvrInShutdown() &&
  717.        (BSckGetString(hBSock, szCommand, sizeof(szCommand) - 1, iSessionTimeout) != NULL)
  718.        && (MscCmdStringCheck(szCommand) == 0)) {
  719. ///////////////////////////////////////////////////////////////////////////////
  720. //  Check for exit flag
  721. ///////////////////////////////////////////////////////////////////////////////
  722. pCTRLCfg = CTRLGetConfigCopy(hShbCTRL);
  724. if ((pCTRLCfg == NULL) || (pCTRLCfg->ulFlags & CTRLF_STOP_SERVER)) {
  725. if (pCTRLCfg != NULL)
  726. SysFree(pCTRLCfg);
  727. break;
  728. }
  729. ///////////////////////////////////////////////////////////////////////////////
  730. //  Process client command
  731. ///////////////////////////////////////////////////////////////////////////////
  732. int iCmdResult = CTRLProcessCommand(pCTRLCfg, hBSock, szCommand);
  734. SysFree(pCTRLCfg);
  736. if (iCmdResult == CTRL_QUIT_CMD_EXIT)
  737. break;
  738. }
  740. return (0);
  742. }
  744. static int CTRLProcessCommand(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock, char const *pszCommand)
  745. {
  747. char **ppszTokens = StrGetTabLineStrings(pszCommand);
  749. if (ppszTokens == NULL) {
  750. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  751. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  752. return (ERR_BAD_CTRL_COMMAND);
  753. }
  755. int iTokensCount = StrStringsCount(ppszTokens);
  757. if (iTokensCount < 1) {
  758. StrFreeStrings(ppszTokens);
  760. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  761. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  762. return (ERR_BAD_CTRL_COMMAND);
  763. }
  765. int iCmdResult = -1;
  767. if (stricmp(ppszTokens[0], "useradd") == 0)
  768. iCmdResult = CTRLDo_useradd(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  769. else if (stricmp(ppszTokens[0], "userdel") == 0)
  770. iCmdResult = CTRLDo_userdel(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  771. else if (stricmp(ppszTokens[0], "userpasswd") == 0)
  772. iCmdResult = CTRLDo_userpasswd(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  773. else if (stricmp(ppszTokens[0], "uservars") == 0)
  774. iCmdResult = CTRLDo_uservars(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  775. else if (stricmp(ppszTokens[0], "uservarsset") == 0)
  776. iCmdResult = CTRLDo_uservarsset(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  777. else if (stricmp(ppszTokens[0], "userlist") == 0)
  778. iCmdResult = CTRLDo_userlist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  779. else if (stricmp(ppszTokens[0], "usergetmproc") == 0)
  780. iCmdResult = CTRLDo_usergetmproc(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  781. else if (stricmp(ppszTokens[0], "usersetmproc") == 0)
  782. iCmdResult = CTRLDo_usersetmproc(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  783. else if (stricmp(ppszTokens[0], "userauth") == 0)
  784. iCmdResult = CTRLDo_userauth(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  785. else if (stricmp(ppszTokens[0], "userstat") == 0)
  786. iCmdResult = CTRLDo_userstat(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  787. else if (stricmp(ppszTokens[0], "aliasadd") == 0)
  788. iCmdResult = CTRLDo_aliasadd(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  789. else if (stricmp(ppszTokens[0], "aliasdel") == 0)
  790. iCmdResult = CTRLDo_aliasdel(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  791. else if (stricmp(ppszTokens[0], "aliaslist") == 0)
  792. iCmdResult = CTRLDo_aliaslist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  793. else if (stricmp(ppszTokens[0], "exaliasadd") == 0)
  794. iCmdResult = CTRLDo_exaliasadd(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  795. else if (stricmp(ppszTokens[0], "exaliasdel") == 0)
  796. iCmdResult = CTRLDo_exaliasdel(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  797. else if (stricmp(ppszTokens[0], "exaliaslist") == 0)
  798. iCmdResult = CTRLDo_exaliaslist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  799. else if (stricmp(ppszTokens[0], "mluseradd") == 0)
  800. iCmdResult = CTRLDo_mluseradd(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  801. else if (stricmp(ppszTokens[0], "mluserdel") == 0)
  802. iCmdResult = CTRLDo_mluserdel(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  803. else if (stricmp(ppszTokens[0], "mluserlist") == 0)
  804. iCmdResult = CTRLDo_mluserlist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  805. else if (stricmp(ppszTokens[0], "domainadd") == 0)
  806. iCmdResult = CTRLDo_domainadd(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  807. else if (stricmp(ppszTokens[0], "domaindel") == 0)
  808. iCmdResult = CTRLDo_domaindel(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  809. else if (stricmp(ppszTokens[0], "domainlist") == 0)
  810. iCmdResult = CTRLDo_domainlist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  811. else if (stricmp(ppszTokens[0], "custdomget") == 0)
  812. iCmdResult = CTRLDo_custdomget(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  813. else if (stricmp(ppszTokens[0], "custdomset") == 0)
  814. iCmdResult = CTRLDo_custdomset(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  815. else if (stricmp(ppszTokens[0], "custdomlist") == 0)
  816. iCmdResult = CTRLDo_custdomlist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  817. else if (stricmp(ppszTokens[0], "poplnkadd") == 0)
  818. iCmdResult = CTRLDo_poplnkadd(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  819. else if (stricmp(ppszTokens[0], "poplnkdel") == 0)
  820. iCmdResult = CTRLDo_poplnkdel(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  821. else if (stricmp(ppszTokens[0], "poplnklist") == 0)
  822. iCmdResult = CTRLDo_poplnklist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  823. else if (stricmp(ppszTokens[0], "poplnkenable") == 0)
  824. iCmdResult = CTRLDo_poplnkenable(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  825. else if (stricmp(ppszTokens[0], "filelist") == 0)
  826. iCmdResult = CTRLDo_filelist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  827. else if (stricmp(ppszTokens[0], "cfgfileget") == 0)
  828. iCmdResult = CTRLDo_cfgfileget(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  829. else if (stricmp(ppszTokens[0], "cfgfileset") == 0)
  830. iCmdResult = CTRLDo_cfgfileset(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  831. else if (stricmp(ppszTokens[0], "frozlist") == 0)
  832. iCmdResult = CTRLDo_frozlist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  833. else if (stricmp(ppszTokens[0], "frozsubmit") == 0)
  834. iCmdResult = CTRLDo_frozsubmit(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  835. else if (stricmp(ppszTokens[0], "frozdel") == 0)
  836. iCmdResult = CTRLDo_frozdel(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  837. else if (stricmp(ppszTokens[0], "frozgetlog") == 0)
  838. iCmdResult = CTRLDo_frozgetlog(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  839. else if (stricmp(ppszTokens[0], "frozgetmsg") == 0)
  840. iCmdResult = CTRLDo_frozgetmsg(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  841. else if (stricmp(ppszTokens[0], "aliasdomainadd") == 0)
  842. iCmdResult = CTRLDo_aliasdomainadd(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  843. else if (stricmp(ppszTokens[0], "aliasdomaindel") == 0)
  844. iCmdResult = CTRLDo_aliasdomaindel(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  845. else if (stricmp(ppszTokens[0], "aliasdomainlist") == 0)
  846. iCmdResult = CTRLDo_aliasdomainlist(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  847. else if (stricmp(ppszTokens[0], "etrn") == 0)
  848. iCmdResult = CTRLDo_etrn(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  849. else if (stricmp(ppszTokens[0], "noop") == 0)
  850. iCmdResult = CTRLDo_noop(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  851. else if (stricmp(ppszTokens[0], "quit") == 0)
  852. iCmdResult = CTRLDo_quit(pCTRLCfg, hBSock, ppszTokens, iTokensCount);
  853. else {
  854. StrFreeStrings(ppszTokens);
  856. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  857. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  858. return (ERR_BAD_CTRL_COMMAND);
  859. }
  861. StrFreeStrings(ppszTokens);
  863. return (iCmdResult);
  865. }
  867. static int CTRLDo_useradd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  868.   char const *const *ppszTokens, int iTokensCount)
  869. {
  871. if (iTokensCount != 5) {
  872. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  873. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  874. return (ERR_BAD_CTRL_COMMAND);
  875. }
  877. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  878. ErrorPush();
  879. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  880. return (ErrorPop());
  881. }
  883. if ((USmtpCheckAddressPart(ppszTokens[1]) < 0) ||
  884.     (USmtpCheckAddressPart(ppszTokens[2]) < 0)) {
  885. ErrorPush();
  886. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  887. return (ErrorPop());
  888. }
  890. UserInfo *pUI = UsrCreateDefaultUser(ppszTokens[1], ppszTokens[2], ppszTokens[3],
  891.      (ppszTokens[4][0] == 'M') ? usrTypeML : usrTypeUser);
  893. if (pUI == NULL) {
  894. ErrorPush();
  895. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  896. return (ErrorPop());
  897. }
  899. if (UsrAddUser(pUI) < 0) {
  900. ErrorPush();
  901. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  902. UsrFreeUserInfo(pUI);
  903. return (ErrorPop());
  904. }
  906. UsrFreeUserInfo(pUI);
  908. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  910. return (0);
  912. }
  914. static int CTRLDo_userdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  915.   char const *const *ppszTokens, int iTokensCount)
  916. {
  918. if (iTokensCount != 3) {
  919. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  920. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  921. return (ERR_BAD_CTRL_COMMAND);
  922. }
  924. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  925. ErrorPush();
  926. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  927. return (ErrorPop());
  928. }
  930. if (UsrRemoveUser(ppszTokens[1], ppszTokens[2], 0) < 0) {
  931. ErrorPush();
  932. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  933. return (ErrorPop());
  934. }
  936. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  938. return (0);
  940. }
  942. static int CTRLDo_userpasswd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  943.      char const *const *ppszTokens, int iTokensCount)
  944. {
  946. if (iTokensCount != 4) {
  947. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  948. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  949. return (ERR_BAD_CTRL_COMMAND);
  950. }
  952. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  953. ErrorPush();
  954. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  955. return (ErrorPop());
  956. }
  957. ///////////////////////////////////////////////////////////////////////////////
  958. //  Check real user account existence
  959. ///////////////////////////////////////////////////////////////////////////////
  960. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  962. if (pUI == NULL) {
  963. ErrorPush();
  964. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  965. return (ErrorPop());
  966. }
  967. ///////////////////////////////////////////////////////////////////////////////
  968. //  Set account password and do modify
  969. ///////////////////////////////////////////////////////////////////////////////
  970. if (pUI->pszPassword != NULL)
  971. SysFree(pUI->pszPassword);
  973. pUI->pszPassword = SysStrDup(ppszTokens[3]);
  975. if (UsrModifyUser(pUI) < 0) {
  976. ErrorPush();
  977. UsrFreeUserInfo(pUI);
  978. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  979. return (ErrorPop());
  980. }
  982. UsrFreeUserInfo(pUI);
  984. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  986. return (0);
  988. }
  990. static int CTRLDo_aliasadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  991.    char const *const *ppszTokens, int iTokensCount)
  992. {
  994. if (iTokensCount != 4) {
  995. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  996. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  997. return (ERR_BAD_CTRL_COMMAND);
  998. }
  999. ///////////////////////////////////////////////////////////////////////////////
  1000. //  Check real user account existence
  1001. ///////////////////////////////////////////////////////////////////////////////
  1002. char szAccountName[MAX_ADDR_NAME] = "";
  1003. char szAccountDomain[MAX_ADDR_NAME] = "";
  1005. if (USmtpSplitEmailAddr(ppszTokens[3], szAccountName, szAccountDomain) < 0) {
  1006. StrSNCpy(szAccountName, ppszTokens[3]);
  1007. StrSNCpy(szAccountDomain, ppszTokens[1]);
  1008. }
  1010. UserInfo *pUI = UsrGetUserByName(szAccountDomain, szAccountName);
  1012. if (pUI == NULL) {
  1013. ErrorPush();
  1014. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1015. return (ErrorPop());
  1016. }
  1018. UsrFreeUserInfo(pUI);
  1020. ///////////////////////////////////////////////////////////////////////////////
  1021. //  Check if we're overlapping an existing users with the new alias
  1022. ///////////////////////////////////////////////////////////////////////////////
  1023. if ((pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2])) != NULL) {
  1024. UsrFreeUserInfo(pUI);
  1026. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_USER_EXIST);
  1028. ErrSetErrorCode(ERR_USER_EXIST);
  1029. return (ERR_USER_EXIST);
  1030. }
  1032. AliasInfo *pAI = UsrAllocAlias(ppszTokens[1], ppszTokens[2], ppszTokens[3]);
  1034. if (pAI == NULL) {
  1035. ErrorPush();
  1036. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1037. return (ErrorPop());
  1038. }
  1040. if (UsrAddAlias(pAI) < 0) {
  1041. ErrorPush();
  1042. UsrFreeAlias(pAI);
  1043. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1044. return (ErrorPop());
  1045. }
  1047. UsrFreeAlias(pAI);
  1049. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1051. return (0);
  1053. }
  1055. static int CTRLDo_aliasdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1056.    char const *const *ppszTokens, int iTokensCount)
  1057. {
  1059. if (iTokensCount != 3) {
  1060. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1061. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1062. return (ERR_BAD_CTRL_COMMAND);
  1063. }
  1065. if (UsrRemoveAlias(ppszTokens[1], ppszTokens[2]) < 0) {
  1066. ErrorPush();
  1067. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1068. return (ErrorPop());
  1069. }
  1071. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1073. return (0);
  1075. }
  1077. static int CTRLDo_aliaslist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1078.     char const *const *ppszTokens, int iTokensCount)
  1079. {
  1081. if (iTokensCount > 4) {
  1082. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1083. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1084. return (ERR_BAD_CTRL_COMMAND);
  1085. }
  1087. char const *pszDomain = (iTokensCount > 1) ? ppszTokens[1] : NULL;
  1088. char const *pszAlias = (iTokensCount > 2) ? ppszTokens[2] : NULL;
  1089. char const *pszName = (iTokensCount > 3) ? ppszTokens[3] : NULL;
  1091. ALSF_HANDLE hAliasDB = UsrAliasOpenDB();
  1093. if (hAliasDB == INVALID_ALSF_HANDLE) {
  1094. ErrorPush();
  1095. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1096. return (ErrorPop());
  1097. }
  1099. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  1101. AliasInfo *pAI = UsrAliasGetFirst(hAliasDB);
  1103. if (pAI != NULL) {
  1104. do {
  1105. if (((pszDomain == NULL) || StrIWildMatch(pAI->pszDomain, pszDomain)) &&
  1106.     ((pszAlias == NULL) || StrIWildMatch(pAI->pszAlias, pszAlias)) &&
  1107.     ((pszName == NULL) || StrIWildMatch(pAI->pszName, pszName))) {
  1108. char szAliasLine[1024] = "";
  1110. sprintf(szAliasLine,
  1111. ""%s"t"
  1112. ""%s"t"
  1113. ""%s"", pAI->pszDomain, pAI->pszAlias, pAI->pszName);
  1115. if (BSckSendString(hBSock, szAliasLine, pCTRLCfg->iTimeout) < 0) {
  1116. ErrorPush();
  1117. UsrFreeAlias(pAI);
  1118. UsrAliasCloseDB(hAliasDB);
  1119. return (ErrorPop());
  1120. }
  1121. }
  1123. UsrFreeAlias(pAI);
  1125. } while ((pAI = UsrAliasGetNext(hAliasDB)) != NULL);
  1126. }
  1128. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  1130. UsrAliasCloseDB(hAliasDB);
  1132. return (0);
  1134. }
  1136. static int CTRLDo_exaliasadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1137.      char const *const *ppszTokens, int iTokensCount)
  1138. {
  1140. if (iTokensCount != 3) {
  1141. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1142. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1143. return (ERR_BAD_CTRL_COMMAND);
  1144. }
  1146. ///////////////////////////////////////////////////////////////////////////////
  1147. //  Split local and remote accounts addresses
  1148. ///////////////////////////////////////////////////////////////////////////////
  1149. char szLocName[MAX_ADDR_NAME] = "";
  1150. char szLocDomain[MAX_ADDR_NAME] = "";
  1151. char szRmtName[MAX_ADDR_NAME] = "";
  1152. char szRmtDomain[MAX_ADDR_NAME] = "";
  1154. if ((USmtpSplitEmailAddr(ppszTokens[1], szLocName, szLocDomain) < 0) ||
  1155.     (USmtpSplitEmailAddr(ppszTokens[2], szRmtName, szRmtDomain) < 0)) {
  1156. ErrorPush();
  1157. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1158. return (ErrorPop());
  1159. }
  1161. ///////////////////////////////////////////////////////////////////////////////
  1162. //  Build the external alias structure
  1163. ///////////////////////////////////////////////////////////////////////////////
  1164. ExtAlias *pEA = ExAlAllocAlias();
  1166. if (pEA == NULL) {
  1167. ErrorPush();
  1168. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1169. return (ErrorPop());
  1170. }
  1172. pEA->pszRmtDomain = SysStrDup(szRmtDomain);
  1173. pEA->pszRmtName = SysStrDup(szRmtName);
  1174. pEA->pszDomain = SysStrDup(szLocDomain);
  1175. pEA->pszName = SysStrDup(szLocName);
  1177. if (ExAlAddAlias(pEA) < 0) {
  1178. ErrorPush();
  1179. ExAlFreeAlias(pEA);
  1180. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1181. return (ErrorPop());
  1182. }
  1183. ExAlFreeAlias(pEA);
  1185. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1187. return (0);
  1189. }
  1191. static int CTRLDo_exaliasdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1192.      char const *const *ppszTokens, int iTokensCount)
  1193. {
  1195. if (iTokensCount != 2) {
  1196. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1197. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1198. return (ERR_BAD_CTRL_COMMAND);
  1199. }
  1201. ///////////////////////////////////////////////////////////////////////////////
  1202. //  Split local and remote accounts addresses
  1203. ///////////////////////////////////////////////////////////////////////////////
  1204. char szRmtName[MAX_ADDR_NAME] = "";
  1205. char szRmtDomain[MAX_ADDR_NAME] = "";
  1207. if (USmtpSplitEmailAddr(ppszTokens[1], szRmtName, szRmtDomain) < 0) {
  1208. ErrorPush();
  1209. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1210. return (ErrorPop());
  1211. }
  1213. ///////////////////////////////////////////////////////////////////////////////
  1214. //  Build the external alias structure
  1215. ///////////////////////////////////////////////////////////////////////////////
  1216. ExtAlias *pEA = ExAlAllocAlias();
  1218. if (pEA == NULL) {
  1219. ErrorPush();
  1220. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1221. return (ErrorPop());
  1222. }
  1224. pEA->pszRmtDomain = SysStrDup(szRmtDomain);
  1225. pEA->pszRmtName = SysStrDup(szRmtName);
  1227. if (ExAlRemoveAlias(pEA) < 0) {
  1228. ErrorPush();
  1229. ExAlFreeAlias(pEA);
  1230. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1231. return (ErrorPop());
  1232. }
  1233. ExAlFreeAlias(pEA);
  1235. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1237. return (0);
  1239. }
  1241. static int CTRLDo_exaliaslist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1242.       char const *const *ppszTokens, int iTokensCount)
  1243. {
  1245. if (iTokensCount > 3) {
  1246. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1247. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1248. return (ERR_BAD_CTRL_COMMAND);
  1249. }
  1251. ///////////////////////////////////////////////////////////////////////////////
  1252. //  Split local and remote accounts addresses
  1253. ///////////////////////////////////////////////////////////////////////////////
  1254. char const *pszLocNameMatch = "*";
  1255. char const *pszLocDomainMatch = "*";
  1256. char const *pszRmtNameMatch = "*";
  1257. char const *pszRmtDomainMatch = "*";
  1258. char szLocName[MAX_ADDR_NAME] = "";
  1259. char szLocDomain[MAX_ADDR_NAME] = "";
  1260. char szRmtName[MAX_ADDR_NAME] = "";
  1261. char szRmtDomain[MAX_ADDR_NAME] = "";
  1263. if (iTokensCount > 1) {
  1264. if (USmtpSplitEmailAddr(ppszTokens[1], szLocName, szLocDomain) < 0) {
  1265. ErrorPush();
  1266. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1267. return (ErrorPop());
  1268. }
  1269. pszLocNameMatch = szLocName;
  1270. pszLocDomainMatch = szLocDomain;
  1272. if (iTokensCount > 2) {
  1273. if (USmtpSplitEmailAddr(ppszTokens[2], szRmtName, szRmtDomain) < 0) {
  1274. ErrorPush();
  1275. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1276. return (ErrorPop());
  1277. }
  1278. pszRmtNameMatch = szRmtName;
  1279. pszRmtDomainMatch = szRmtDomain;
  1280. }
  1281. }
  1283. EXAL_HANDLE hLinksDB = ExAlOpenDB();
  1285. if (hLinksDB == INVALID_EXAL_HANDLE) {
  1286. ErrorPush();
  1287. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1288. return (ErrorPop());
  1289. }
  1291. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  1293. ExtAlias *pEA;
  1295. for (pEA = ExAlGetFirstAlias(hLinksDB); pEA != NULL;
  1296.      pEA = ExAlGetNextAlias(hLinksDB)) {
  1297. if (StrIWildMatch(pEA->pszRmtDomain, pszRmtDomainMatch) &&
  1298.     StrIWildMatch(pEA->pszRmtName, pszRmtNameMatch) &&
  1299.     StrIWildMatch(pEA->pszDomain, pszLocDomainMatch) &&
  1300.     StrIWildMatch(pEA->pszName, pszLocNameMatch)) {
  1301. char szAliasLine[1024] = "";
  1303. sprintf(szAliasLine,
  1304. ""%s"t"
  1305. ""%s"t"
  1306. ""%s"t"
  1307. ""%s"", pEA->pszRmtDomain, pEA->pszRmtName,
  1308. pEA->pszDomain, pEA->pszName);
  1310. if (BSckSendString(hBSock, szAliasLine, pCTRLCfg->iTimeout) < 0) {
  1311. ErrorPush();
  1312. ExAlFreeAlias(pEA);
  1313. ExAlCloseDB(hLinksDB);
  1314. return (ErrorPop());
  1315. }
  1316. }
  1318. ExAlFreeAlias(pEA);
  1319. }
  1321. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  1323. ExAlCloseDB(hLinksDB);
  1325. return (0);
  1327. }
  1329. static int CTRLDo_uservars(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1330.    char const *const *ppszTokens, int iTokensCount)
  1331. {
  1333. if (iTokensCount != 3) {
  1334. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1335. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1336. return (ERR_BAD_CTRL_COMMAND);
  1337. }
  1339. char const *pszDomain = ppszTokens[1];
  1340. char const *pszName = ppszTokens[2];
  1342. if (MDomIsHandledDomain(pszDomain) < 0) {
  1343. ErrorPush();
  1344. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1345. return (ErrorPop());
  1346. }
  1348. UserInfo *pUI = UsrGetUserByName(pszDomain, pszName);
  1350. if (pUI == NULL) {
  1351. ErrorPush();
  1352. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1353. return (ErrorPop());
  1354. }
  1356. char **ppszVars = UsrGetProfileVars(pUI);
  1358. if (ppszVars == NULL) {
  1359. ErrorPush();
  1360. UsrFreeUserInfo(pUI);
  1361. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1362. return (ErrorPop());
  1363. }
  1365. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  1367. for (int ii = 0; ppszVars[ii] != NULL; ii++) {
  1368. char *pszVar = UsrGetUserInfoVar(pUI, ppszVars[ii]);
  1370. if (pszVar != NULL) {
  1371. if (BSckVSendString(hBSock, pCTRLCfg->iTimeout, ""%s"t"%s"",
  1372.     ppszVars[ii], pszVar) < 0) {
  1373. ErrorPush();
  1374. SysFree(pszVar);
  1375. StrFreeStrings(ppszVars);
  1376. UsrFreeUserInfo(pUI);
  1377. return (ErrorPop());
  1378. }
  1380. SysFree(pszVar);
  1381. }
  1382. }
  1384. StrFreeStrings(ppszVars);
  1386. UsrFreeUserInfo(pUI);
  1388. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  1390. return (0);
  1392. }
  1394. static int CTRLDo_uservarsset(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1395.       char const *const *ppszTokens, int iTokensCount)
  1396. {
  1398. if ((iTokensCount < 5) || (((iTokensCount - 3) % 2) != 0)) {
  1399. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1400. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1401. return (ERR_BAD_CTRL_COMMAND);
  1402. }
  1404. char const *pszDomain = ppszTokens[1];
  1405. char const *pszName = ppszTokens[2];
  1407. if (MDomIsHandledDomain(pszDomain) < 0) {
  1408. ErrorPush();
  1409. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1410. return (ErrorPop());
  1411. }
  1413. UserInfo *pUI = UsrGetUserByName(pszDomain, pszName);
  1415. if (pUI == NULL) {
  1416. ErrorPush();
  1417. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1418. return (ErrorPop());
  1419. }
  1421. for (int ii = 3; ii < (iTokensCount - 1); ii += 2) {
  1422. ///////////////////////////////////////////////////////////////////////////////
  1423. //  Check if the variable deletion is requested
  1424. ///////////////////////////////////////////////////////////////////////////////
  1425. if (strcmp(ppszTokens[ii + 1], CTRL_VAR_DROP_VALUE) == 0)
  1426. UsrDelUserInfoVar(pUI, ppszTokens[ii]);
  1427. else {
  1428. ///////////////////////////////////////////////////////////////////////////////
  1429. //  Set user variable
  1430. ///////////////////////////////////////////////////////////////////////////////
  1431. if (UsrSetUserInfoVar(pUI, ppszTokens[ii], ppszTokens[ii + 1]) < 0) {
  1432. ErrorPush();
  1433. UsrFreeUserInfo(pUI);
  1434. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1435. return (ErrorPop());
  1436. }
  1437. }
  1438. }
  1440. UsrFlushUserVars(pUI);
  1442. UsrFreeUserInfo(pUI);
  1444. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1446. return (0);
  1448. }
  1450. static int CTRLDo_userlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1451.    char const *const *ppszTokens, int iTokensCount)
  1452. {
  1454. if (iTokensCount > 3) {
  1455. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1456. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1457. return (ERR_BAD_CTRL_COMMAND);
  1458. }
  1460. char const *pszDomain = (iTokensCount > 1) ? ppszTokens[1] : NULL;
  1461. char const *pszName = (iTokensCount > 2) ? ppszTokens[2] : NULL;
  1463. USRF_HANDLE hUsersDB = UsrOpenDB();
  1465. if (hUsersDB == INVALID_USRF_HANDLE) {
  1466. ErrorPush();
  1467. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1468. return (ErrorPop());
  1469. }
  1471. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  1473. UserInfo *pUI = UsrGetFirstUser(hUsersDB);
  1475. if (pUI != NULL) {
  1476. do {
  1477. if (((pszDomain == NULL) || StrIWildMatch(pUI->pszDomain, pszDomain)) &&
  1478.     ((pszName == NULL) || StrIWildMatch(pUI->pszName, pszName))) {
  1479. char szUserLine[1024] = "";
  1481. sprintf(szUserLine,
  1482. ""%s"t"
  1483. ""%s"t"
  1484. ""%s"t"
  1485. ""%s"",
  1486. pUI->pszDomain, pUI->pszName, pUI->pszPassword,
  1487. pUI->pszType);
  1489. if (BSckSendString(hBSock, szUserLine, pCTRLCfg->iTimeout) < 0) {
  1490. ErrorPush();
  1491. UsrFreeUserInfo(pUI);
  1492. UsrCloseDB(hUsersDB);
  1493. return (ErrorPop());
  1494. }
  1495. }
  1497. UsrFreeUserInfo(pUI);
  1499. } while ((pUI = UsrGetNextUser(hUsersDB)) != NULL);
  1500. }
  1502. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  1504. UsrCloseDB(hUsersDB);
  1506. return (0);
  1508. }
  1510. static int CTRLDo_usergetmproc(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1511.        char const *const *ppszTokens, int iTokensCount)
  1512. {
  1514. if (iTokensCount != 3) {
  1515. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1516. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1517. return (ERR_BAD_CTRL_COMMAND);
  1518. }
  1520. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  1521. ErrorPush();
  1522. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1523. return (ErrorPop());
  1524. }
  1526. ///////////////////////////////////////////////////////////////////////////////
  1527. //  Check real user account existence
  1528. ///////////////////////////////////////////////////////////////////////////////
  1529. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  1531. if (pUI == NULL) {
  1532. ErrorPush();
  1533. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1534. return (ErrorPop());
  1535. }
  1536. ///////////////////////////////////////////////////////////////////////////////
  1537. //  Exist user custom message processing ?
  1538. ///////////////////////////////////////////////////////////////////////////////
  1539. char szMPFile[SYS_MAX_PATH] = "";
  1541. SysGetTmpFile(szMPFile);
  1543. if (UsrGetMailProcessFile(pUI, szMPFile) < 0) {
  1544. ErrorPush();
  1545. UsrFreeUserInfo(pUI);
  1546. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1547. return (ErrorPop());
  1548. }
  1550. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  1552. ///////////////////////////////////////////////////////////////////////////////
  1553. //  Send mailproc file
  1554. ///////////////////////////////////////////////////////////////////////////////
  1555. if (MscSendTextFile(szMPFile, hBSock, pCTRLCfg->iTimeout) < 0) {
  1556. ErrorPush();
  1557. SysRemove(szMPFile);
  1558. UsrFreeUserInfo(pUI);
  1559. return (ErrorPop());
  1560. }
  1562. SysRemove(szMPFile);
  1564. UsrFreeUserInfo(pUI);
  1566. return (0);
  1568. }
  1570. static int CTRLDo_usersetmproc(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1571.        char const *const *ppszTokens, int iTokensCount)
  1572. {
  1574. if (iTokensCount != 3) {
  1575. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1576. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1577. return (ERR_BAD_CTRL_COMMAND);
  1578. }
  1580. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  1581. ErrorPush();
  1582. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1583. return (ErrorPop());
  1584. }
  1586. ///////////////////////////////////////////////////////////////////////////////
  1587. //  Check real user account existence
  1588. ///////////////////////////////////////////////////////////////////////////////
  1589. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  1591. if (pUI == NULL) {
  1592. ErrorPush();
  1593. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1594. return (ErrorPop());
  1595. }
  1597. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_WAITDATA_RESULT);
  1599. ///////////////////////////////////////////////////////////////////////////////
  1600. //  Read user data in file
  1601. ///////////////////////////////////////////////////////////////////////////////
  1602. char szMPFile[SYS_MAX_PATH] = "";
  1604. SysGetTmpFile(szMPFile);
  1606. if (MscRecvTextFile(szMPFile, hBSock, pCTRLCfg->iTimeout) < 0) {
  1607. ErrorPush();
  1608. CheckRemoveFile(szMPFile);
  1609. UsrFreeUserInfo(pUI);
  1610. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1611. return (ErrorPop());
  1612. }
  1613. ///////////////////////////////////////////////////////////////////////////////
  1614. //  Get file info for size checking
  1615. ///////////////////////////////////////////////////////////////////////////////
  1616. SYS_FILE_INFO FI;
  1618. if (SysGetFileInfo(szMPFile, FI) < 0) {
  1619. ErrorPush();
  1620. CheckRemoveFile(szMPFile);
  1621. UsrFreeUserInfo(pUI);
  1622. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1623. return (ErrorPop());
  1624. }
  1625. ///////////////////////////////////////////////////////////////////////////////
  1626. //  Set mailproc file ( or delete it if size == 0 )
  1627. ///////////////////////////////////////////////////////////////////////////////
  1628. if (UsrSetMailProcessFile(pUI, (FI.ulSize != 0) ? szMPFile : NULL) < 0) {
  1629. ErrorPush();
  1630. SysRemove(szMPFile);
  1631. UsrFreeUserInfo(pUI);
  1632. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1633. return (ErrorPop());
  1634. }
  1636. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1638. SysRemove(szMPFile);
  1640. UsrFreeUserInfo(pUI);
  1642. return (0);
  1644. }
  1646. static int CTRLDo_userauth(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1647.    char const *const *ppszTokens, int iTokensCount)
  1648. {
  1650. if (iTokensCount != 4) {
  1651. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1652. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1653. return (ERR_BAD_CTRL_COMMAND);
  1654. }
  1655. ///////////////////////////////////////////////////////////////////////////////
  1656. //  Check real user account existence
  1657. ///////////////////////////////////////////////////////////////////////////////
  1658. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  1660. if (pUI == NULL) {
  1661. ErrorPush();
  1662. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1663. return (ErrorPop());
  1664. }
  1665. ///////////////////////////////////////////////////////////////////////////////
  1666. //  Check password
  1667. ///////////////////////////////////////////////////////////////////////////////
  1668. if (strcmp(pUI->pszPassword, ppszTokens[3]) != 0) {
  1669. UsrFreeUserInfo(pUI);
  1671. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_INVALID_PASSWORD);
  1672. ErrSetErrorCode(ERR_INVALID_PASSWORD);
  1673. return (ERR_INVALID_PASSWORD);
  1674. }
  1676. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1678. UsrFreeUserInfo(pUI);
  1680. return (0);
  1682. }
  1684. static int CTRLDo_userstat(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1685.    char const *const *ppszTokens, int iTokensCount)
  1686. {
  1688. if (iTokensCount != 3) {
  1689. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1690. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1691. return (ERR_BAD_CTRL_COMMAND);
  1692. }
  1693. ///////////////////////////////////////////////////////////////////////////////
  1694. //  Check real user account existence
  1695. ///////////////////////////////////////////////////////////////////////////////
  1696. char szRealAddress[MAX_ADDR_NAME] = "";
  1697. UserInfo *pUI = UsrGetUserByNameOrAlias(ppszTokens[1], ppszTokens[2],
  1698. szRealAddress);
  1700. if (pUI == NULL) {
  1701. ErrorPush();
  1702. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1703. return (ErrorPop());
  1704. }
  1705. ///////////////////////////////////////////////////////////////////////////////
  1706. //  Get mailbox infos
  1707. ///////////////////////////////////////////////////////////////////////////////
  1708. unsigned long ulMBSize = 0;
  1709. unsigned long ulNumMessages = 0;
  1711. if (UPopGetMailboxSize(pUI, ulMBSize, ulNumMessages) < 0) {
  1712. ErrorPush();
  1713. UsrFreeUserInfo(pUI);
  1714. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  1715. return (ErrorPop());
  1716. }
  1718. time_t LTime = time(NULL);
  1719. PopLastLoginInfo LoginInfo;
  1720. char szIPAddr[128] = "0.0.0.0";
  1721. char szLoginTime[128] = "";
  1723. if (UPopGetLastLoginInfo(pUI, &LoginInfo) == 0) {
  1724. SysInetNToA(LoginInfo.Address, szIPAddr);
  1725. LTime = LoginInfo.LTime;
  1726. }
  1727. MscGetTimeStr(szLoginTime, sizeof(szLoginTime) - 1, LTime);
  1729. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  1731. if ((BSckVSendString(hBSock, pCTRLCfg->iTimeout, ""RealAddress"t"%s"",
  1732.      szRealAddress) < 0) ||
  1733.     (BSckVSendString(hBSock, pCTRLCfg->iTimeout, ""MailboxSize"t"%lu"",
  1734.      ulMBSize) < 0) ||
  1735.     (BSckVSendString(hBSock, pCTRLCfg->iTimeout, ""MailboxMessages"t"%lu"",
  1736.      ulNumMessages) < 0) ||
  1737.     (BSckVSendString(hBSock, pCTRLCfg->iTimeout, ""LastLoginTimeDate"t"%s"",
  1738.      szLoginTime) < 0) ||
  1739.     (BSckVSendString(hBSock, pCTRLCfg->iTimeout, ""LastLoginIP"t"%s"",
  1740.      szIPAddr) < 0)) {
  1741. ErrorPush();
  1742. UsrFreeUserInfo(pUI);
  1743. return (ErrorPop());
  1744. }
  1746. UsrFreeUserInfo(pUI);
  1748. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  1750. return (0);
  1752. }
  1754. static int CTRLDo_mluseradd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1755.     char const *const *ppszTokens, int iTokensCount)
  1756. {
  1758. if (iTokensCount < 4) {
  1759. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1760. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1761. return (ERR_BAD_CTRL_COMMAND);
  1762. }
  1764. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  1765. ErrorPush();
  1766. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1767. return (ErrorPop());
  1768. }
  1770. if (USmtpCheckAddress(ppszTokens[3]) < 0) {
  1771. ErrorPush();
  1772. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1773. return (ErrorPop());
  1774. }
  1776. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  1778. if (pUI == NULL) {
  1779. ErrorPush();
  1780. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1781. return (ErrorPop());
  1782. }
  1784. if (UsrGetUserType(pUI) != usrTypeML) {
  1785. UsrFreeUserInfo(pUI);
  1787. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_USER_NOT_MAILINGLIST);
  1788. ErrSetErrorCode(ERR_USER_NOT_MAILINGLIST);
  1789. return (ERR_USER_NOT_MAILINGLIST);
  1790. }
  1792. char const *pszPerms = (iTokensCount > 4) ? ppszTokens[4] : DEFAULT_MLUSER_PERMS;
  1793. MLUserInfo *pMLUI = UsrMLAllocDefault(ppszTokens[3], pszPerms);
  1795. if (pMLUI == NULL) {
  1796. ErrorPush();
  1797. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1798. UsrFreeUserInfo(pUI);
  1799. return (ErrorPop());
  1800. }
  1802. if (UsrMLAddUser(pUI, pMLUI) < 0) {
  1803. ErrorPush();
  1804. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1805. UsrMLFreeUser(pMLUI);
  1806. UsrFreeUserInfo(pUI);
  1807. return (ErrorPop());
  1808. }
  1810. UsrMLFreeUser(pMLUI);
  1812. UsrFreeUserInfo(pUI);
  1814. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1816. return (0);
  1818. }
  1820. static int CTRLDo_mluserdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1821.     char const *const *ppszTokens, int iTokensCount)
  1822. {
  1824. if (iTokensCount != 4) {
  1825. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1826. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1827. return (ERR_BAD_CTRL_COMMAND);
  1828. }
  1830. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  1831. ErrorPush();
  1832. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1833. return (ErrorPop());
  1834. }
  1836. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  1838. if (pUI == NULL) {
  1839. ErrorPush();
  1840. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1841. return (ErrorPop());
  1842. }
  1844. if (UsrGetUserType(pUI) != usrTypeML) {
  1845. UsrFreeUserInfo(pUI);
  1847. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_USER_NOT_MAILINGLIST);
  1848. ErrSetErrorCode(ERR_USER_NOT_MAILINGLIST);
  1849. return (ERR_USER_NOT_MAILINGLIST);
  1850. }
  1852. if (UsrMLRemoveUser(pUI, ppszTokens[3]) < 0) {
  1853. ErrorPush();
  1854. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1855. UsrFreeUserInfo(pUI);
  1856. return (ErrorPop());
  1857. }
  1859. UsrFreeUserInfo(pUI);
  1861. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1863. return (0);
  1865. }
  1867. static int CTRLDo_mluserlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1868.      char const *const *ppszTokens, int iTokensCount)
  1869. {
  1871. if (iTokensCount != 3) {
  1872. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1873. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1874. return (ERR_BAD_CTRL_COMMAND);
  1875. }
  1877. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  1878. ErrorPush();
  1879. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1880. return (ErrorPop());
  1881. }
  1883. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  1885. if (pUI == NULL) {
  1886. ErrorPush();
  1887. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1888. return (ErrorPop());
  1889. }
  1891. if (UsrGetUserType(pUI) != usrTypeML) {
  1892. UsrFreeUserInfo(pUI);
  1894. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_USER_NOT_MAILINGLIST);
  1895. ErrSetErrorCode(ERR_USER_NOT_MAILINGLIST);
  1896. return (ERR_USER_NOT_MAILINGLIST);
  1897. }
  1899. USRML_HANDLE hUsersDB = UsrMLOpenDB(pUI);
  1901. if (hUsersDB == INVALID_USRML_HANDLE) {
  1902. ErrorPush();
  1903. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1904. UsrFreeUserInfo(pUI);
  1905. return (ErrorPop());
  1906. }
  1908. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  1910. ///////////////////////////////////////////////////////////////////////////////
  1911. //  Mailing list scan
  1912. ///////////////////////////////////////////////////////////////////////////////
  1913. MLUserInfo *pMLUI = UsrMLGetFirstUser(hUsersDB);
  1915. for (; pMLUI != NULL; pMLUI = UsrMLGetNextUser(hUsersDB)) {
  1916. char szUserLine[512] = "";
  1918. sprintf(szUserLine, ""%s"t"%s"", pMLUI->pszAddress, pMLUI->pszPerms);
  1920. if (BSckSendString(hBSock, szUserLine, pCTRLCfg->iTimeout) < 0) {
  1921. ErrorPush();
  1922. UsrMLFreeUser(pMLUI);
  1923. UsrFreeUserInfo(pUI);
  1924. UsrMLCloseDB(hUsersDB);
  1925. return (ErrorPop());
  1926. }
  1928. UsrMLFreeUser(pMLUI);
  1929. }
  1931. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  1933. UsrFreeUserInfo(pUI);
  1935. UsrMLCloseDB(hUsersDB);
  1937. return (0);
  1939. }
  1941. static int CTRLDo_domainadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1942.     char const *const *ppszTokens, int iTokensCount)
  1943. {
  1945. if (iTokensCount != 2) {
  1946. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1947. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1948. return (ERR_BAD_CTRL_COMMAND);
  1949. }
  1951. if (USmtpCheckAddressPart(ppszTokens[1]) < 0) {
  1952. ErrorPush();
  1953. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1954. return (ErrorPop());
  1955. }
  1957. char szDomain[MAX_HOST_NAME] = "";
  1959. StrSNCpy(szDomain, ppszTokens[1]);
  1960. StrLower(szDomain);
  1962. if (MDomAddDomain(szDomain) < 0) {
  1963. ErrorPush();
  1964. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1965. return (ErrorPop());
  1966. }
  1968. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1970. return (0);
  1972. }
  1974. static int CTRLDo_domaindel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  1975.     char const *const *ppszTokens, int iTokensCount)
  1976. {
  1978. if (iTokensCount != 2) {
  1979. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  1980. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  1981. return (ERR_BAD_CTRL_COMMAND);
  1982. }
  1984. char szDomain[MAX_HOST_NAME] = "";
  1986. StrSNCpy(szDomain, ppszTokens[1]);
  1987. StrLower(szDomain);
  1989. if (MDomRemoveDomain(szDomain) < 0) {
  1990. ErrorPush();
  1991. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  1992. return (ErrorPop());
  1993. }
  1995. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  1997. return (0);
  1999. }
  2001. static int CTRLDo_domainlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2002.      char const *const *ppszTokens, int iTokensCount)
  2003. {
  2005. DOMLS_HANDLE hDomainsDB = MDomOpenDB();
  2007. if (hDomainsDB == INVALID_DOMLS_HANDLE) {
  2008. ErrorPush();
  2009. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2010. return (ErrorPop());
  2011. }
  2013. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2015. char const *pszDomain = MDomGetFirstDomain(hDomainsDB);
  2017. if (pszDomain != NULL) {
  2018. do {
  2019. if ((iTokensCount < 2) || StrStringsRIWMatch(&ppszTokens[1], pszDomain)) {
  2020. char szDomainLine[512] = "";
  2022. sprintf(szDomainLine, ""%s"", pszDomain);
  2024. if (BSckSendString(hBSock, szDomainLine, pCTRLCfg->iTimeout) < 0) {
  2025. ErrorPush();
  2026. MDomCloseDB(hDomainsDB);
  2027. return (ErrorPop());
  2028. }
  2029. }
  2030. } while ((pszDomain = MDomGetNextDomain(hDomainsDB)) != NULL);
  2031. }
  2033. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  2035. MDomCloseDB(hDomainsDB);
  2037. return (0);
  2039. }
  2041. static int CTRLDo_custdomget(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2042.      char const *const *ppszTokens, int iTokensCount)
  2043. {
  2045. if (iTokensCount != 2) {
  2046. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2047. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2048. return (ERR_BAD_CTRL_COMMAND);
  2049. }
  2050. ///////////////////////////////////////////////////////////////////////////////
  2051. //  Try to get custom domain file ( if exist )
  2052. ///////////////////////////////////////////////////////////////////////////////
  2053. char szCustDomainFile[SYS_MAX_PATH] = "";
  2055. SysGetTmpFile(szCustDomainFile);
  2057. if (USmlGetCustomDomainFile(ppszTokens[1], szCustDomainFile) < 0) {
  2058. ErrorPush();
  2059. CheckRemoveFile(szCustDomainFile);
  2060. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2061. return (ErrorPop());
  2062. }
  2064. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2066. ///////////////////////////////////////////////////////////////////////////////
  2067. //  Send custom domain file
  2068. ///////////////////////////////////////////////////////////////////////////////
  2069. if (MscSendTextFile(szCustDomainFile, hBSock, pCTRLCfg->iTimeout) < 0) {
  2070. ErrorPush();
  2071. SysRemove(szCustDomainFile);
  2072. return (ErrorPop());
  2073. }
  2075. SysRemove(szCustDomainFile);
  2077. return (0);
  2079. }
  2081. static int CTRLDo_custdomset(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2082.      char const *const *ppszTokens, int iTokensCount)
  2083. {
  2085. if (iTokensCount != 2) {
  2086. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2087. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2088. return (ERR_BAD_CTRL_COMMAND);
  2089. }
  2091. if (USmtpCheckAddressPart(ppszTokens[1]) < 0) {
  2092. ErrorPush();
  2093. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2094. return (ErrorPop());
  2095. }
  2097. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_WAITDATA_RESULT);
  2099. ///////////////////////////////////////////////////////////////////////////////
  2100. //  Read user data in file
  2101. ///////////////////////////////////////////////////////////////////////////////
  2102. char szCustDomainFile[SYS_MAX_PATH] = "";
  2104. SysGetTmpFile(szCustDomainFile);
  2106. if (MscRecvTextFile(szCustDomainFile, hBSock, pCTRLCfg->iTimeout) < 0) {
  2107. ErrorPush();
  2108. CheckRemoveFile(szCustDomainFile);
  2109. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2110. return (ErrorPop());
  2111. }
  2112. ///////////////////////////////////////////////////////////////////////////////
  2113. //  Get file info for size checking
  2114. ///////////////////////////////////////////////////////////////////////////////
  2115. SYS_FILE_INFO FI;
  2117. if (SysGetFileInfo(szCustDomainFile, FI) < 0) {
  2118. ErrorPush();
  2119. CheckRemoveFile(szCustDomainFile);
  2120. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2121. return (ErrorPop());
  2122. }
  2123. ///////////////////////////////////////////////////////////////////////////////
  2124. //  Set custom domain file ( or delete it if size == 0 )
  2125. ///////////////////////////////////////////////////////////////////////////////
  2126. if (USmlSetCustomDomainFile(ppszTokens[1],
  2127.     (FI.ulSize != 0) ? szCustDomainFile : NULL) < 0) {
  2128. ErrorPush();
  2129. SysRemove(szCustDomainFile);
  2130. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2131. return (ErrorPop());
  2132. }
  2134. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2136. SysRemove(szCustDomainFile);
  2138. return (0);
  2140. }
  2142. static int CTRLDo_custdomlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2143.       char const *const *ppszTokens, int iTokensCount)
  2144. {
  2146. if (iTokensCount != 1) {
  2147. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2148. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2149. return (ERR_BAD_CTRL_COMMAND);
  2150. }
  2152. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2154. char szCustomPath[SYS_MAX_PATH] = "";
  2156. USmlGetDomainCustomDir(szCustomPath, sizeof(szCustomPath), 0);
  2158. char szCustFileName[SYS_MAX_PATH] = "";
  2159. FSCAN_HANDLE hFileScan = MscFirstFile(szCustomPath, 0, szCustFileName);
  2161. if (hFileScan != INVALID_FSCAN_HANDLE) {
  2162. do {
  2163. char szCustDomain[SYS_MAX_PATH] = "";
  2165. MscSplitPath(szCustFileName, NULL, szCustDomain, NULL);
  2167. if (BSckVSendString(hBSock, pCTRLCfg->iTimeout, ""%s"", szCustDomain) <
  2168.     0) {
  2169. ErrorPush();
  2170. MscCloseFindFile(hFileScan);
  2171. return (ErrorPop());
  2172. }
  2174. } while (MscNextFile(hFileScan, szCustFileName));
  2176. MscCloseFindFile(hFileScan);
  2177. }
  2179. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  2181. return (0);
  2183. }
  2185. static int CTRLDo_noop(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2186.        char const *const *ppszTokens, int iTokensCount)
  2187. {
  2189. if (iTokensCount != 1) {
  2190. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2191. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2192. return (ERR_BAD_CTRL_COMMAND);
  2193. }
  2195. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2197. return (0);
  2199. }
  2201. static int CTRLDo_quit(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2202.        char const *const *ppszTokens, int iTokensCount)
  2203. {
  2205. if (iTokensCount != 1) {
  2206. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2207. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2208. return (ERR_BAD_CTRL_COMMAND);
  2209. }
  2211. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2213. return (CTRL_QUIT_CMD_EXIT);
  2215. }
  2217. static int CTRLDo_poplnkadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2218.     char const *const *ppszTokens, int iTokensCount)
  2219. {
  2221. if (iTokensCount != 7) {
  2222. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2223. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2224. return (ERR_BAD_CTRL_COMMAND);
  2225. }
  2227. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  2228. ErrorPush();
  2229. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2230. return (ErrorPop());
  2231. }
  2233. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  2235. if (pUI == NULL) {
  2236. ErrorPush();
  2237. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2238. return (ErrorPop());
  2239. }
  2241. UsrFreeUserInfo(pUI);
  2243. POP3Link *pPopLnk = GwLkAllocLink(ppszTokens[1], ppszTokens[2],
  2244.   ppszTokens[3], ppszTokens[4], ppszTokens[5],
  2245.   ppszTokens[6]);
  2247. if (pPopLnk == NULL) {
  2248. ErrorPush();
  2249. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2250. return (ErrorPop());
  2251. }
  2253. if (GwLkAddLink(pPopLnk) < 0) {
  2254. ErrorPush();
  2255. GwLkFreePOP3Link(pPopLnk);
  2256. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2257. return (ErrorPop());
  2258. }
  2260. GwLkFreePOP3Link(pPopLnk);
  2262. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2264. return (0);
  2266. }
  2268. static int CTRLDo_poplnkdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2269.     char const *const *ppszTokens, int iTokensCount)
  2270. {
  2272. if (iTokensCount != 5) {
  2273. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2274. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2275. return (ERR_BAD_CTRL_COMMAND);
  2276. }
  2278. if (MDomIsHandledDomain(ppszTokens[1]) < 0) {
  2279. ErrorPush();
  2280. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2281. return (ErrorPop());
  2282. }
  2284. UserInfo *pUI = UsrGetUserByName(ppszTokens[1], ppszTokens[2]);
  2286. if (pUI == NULL) {
  2287. ErrorPush();
  2288. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2289. return (ErrorPop());
  2290. }
  2292. UsrFreeUserInfo(pUI);
  2294. POP3Link *pPopLnk = GwLkAllocLink(ppszTokens[1], ppszTokens[2],
  2295.   ppszTokens[3], ppszTokens[4], NULL, NULL);
  2297. if (pPopLnk == NULL) {
  2298. ErrorPush();
  2299. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2300. return (ErrorPop());
  2301. }
  2303. if (GwLkRemoveLink(pPopLnk) < 0) {
  2304. ErrorPush();
  2305. GwLkFreePOP3Link(pPopLnk);
  2306. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2307. return (ErrorPop());
  2308. }
  2310. GwLkFreePOP3Link(pPopLnk);
  2312. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2314. return (0);
  2316. }
  2318. static int CTRLDo_poplnklist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2319.      char const *const *ppszTokens, int iTokensCount)
  2320. {
  2322. if (iTokensCount > 3) {
  2323. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2324. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2325. return (ERR_BAD_CTRL_COMMAND);
  2326. }
  2328. char const *pszDomain = (iTokensCount > 1) ? ppszTokens[1] : NULL;
  2329. char const *pszName = (iTokensCount > 2) ? ppszTokens[2] : NULL;
  2331. GWLKF_HANDLE hLinksDB = GwLkOpenDB();
  2333. if (hLinksDB == INVALID_GWLKF_HANDLE) {
  2334. ErrorPush();
  2335. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2336. return (ErrorPop());
  2337. }
  2339. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2341. POP3Link *pPopLnk = GwLkGetFirstUser(hLinksDB);
  2343. if (pPopLnk != NULL) {
  2344. do {
  2345. if (((pszDomain == NULL) || (stricmp(pPopLnk->pszDomain, pszDomain) == 0))
  2346.     && ((pszName == NULL) || (stricmp(pPopLnk->pszName, pszName) == 0))) {
  2347. char const *pszEnable =
  2348.     (GwLkCheckEnabled(pPopLnk) == 0) ? "ON" : "OFF";
  2349. char szLinkLine[2048] = "";
  2351. sprintf(szLinkLine,
  2352. ""%s"t"
  2353. ""%s"t"
  2354. ""%s"t"
  2355. ""%s"t"
  2356. ""%s"t"
  2357. ""%s"t"
  2358. ""%s"",
  2359. pPopLnk->pszDomain, pPopLnk->pszName,
  2360. pPopLnk->pszRmtDomain, pPopLnk->pszRmtName,
  2361. pPopLnk->pszRmtPassword, pPopLnk->pszAuthType, pszEnable);
  2363. if (BSckSendString(hBSock, szLinkLine, pCTRLCfg->iTimeout) < 0) {
  2364. ErrorPush();
  2365. GwLkFreePOP3Link(pPopLnk);
  2366. GwLkCloseDB(hLinksDB);
  2367. return (ErrorPop());
  2368. }
  2369. }
  2371. GwLkFreePOP3Link(pPopLnk);
  2373. } while ((pPopLnk = GwLkGetNextUser(hLinksDB)) != NULL);
  2374. }
  2376. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  2378. GwLkCloseDB(hLinksDB);
  2380. return (0);
  2382. }
  2384. static int CTRLDo_poplnkenable(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2385.        char const *const *ppszTokens, int iTokensCount)
  2386. {
  2388. if (iTokensCount < 4) {
  2389. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2390. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2391. return (ERR_BAD_CTRL_COMMAND);
  2392. }
  2394. bool bEnable = (atoi(ppszTokens[1])) ? true : false;
  2395. char const *pszDomain = ppszTokens[2];
  2396. char const *pszName = ppszTokens[3];
  2397. char const *pszRmtDomain = (iTokensCount > 4) ? ppszTokens[4] : NULL;
  2398. char const *pszRmtName = (iTokensCount > 5) ? ppszTokens[5] : NULL;
  2400. if (GwLkEnable(pszDomain, pszName, pszRmtDomain, pszRmtName, bEnable) < 0) {
  2401. ErrorPush();
  2402. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2403. return (ErrorPop());
  2404. }
  2406. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2408. return (0);
  2410. }
  2412. static int CTRLCheckRelativePath(char const *pszPath)
  2413. {
  2415. ///////////////////////////////////////////////////////////////////////////////
  2416. //  Check 101 tricky path
  2417. ///////////////////////////////////////////////////////////////////////////////
  2418. if (strstr(pszPath, "..") != NULL) {
  2419. ErrSetErrorCode(ERR_BAD_RELATIVE_PATH);
  2420. return (ERR_BAD_RELATIVE_PATH);
  2421. }
  2423. return (0);
  2425. }
  2427. static int CTRLDo_filelist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2428.    char const *const *ppszTokens, int iTokensCount)
  2429. {
  2431. if (iTokensCount != 3) {
  2432. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2433. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2434. return (ERR_BAD_CTRL_COMMAND);
  2435. }
  2436. ///////////////////////////////////////////////////////////////////////////////
  2437. //  Check relative path syntax
  2438. ///////////////////////////////////////////////////////////////////////////////
  2439. if (CTRLCheckRelativePath(ppszTokens[1]) < 0) {
  2440. ErrorPush();
  2441. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2442. return (ErrorPop());
  2443. }
  2444. ///////////////////////////////////////////////////////////////////////////////
  2445. //  Setup listing file path
  2446. ///////////////////////////////////////////////////////////////////////////////
  2447. char szRelativePath[SYS_MAX_PATH] = "";
  2448. char szFullPath[SYS_MAX_PATH] = "";
  2450. StrSNCpy(szRelativePath, ppszTokens[1]);
  2451. MscTranslatePath(szRelativePath);
  2453. CfgGetFullPath(szRelativePath, szFullPath, sizeof(szFullPath));
  2454. DelFinalSlash(szFullPath);
  2456. ///////////////////////////////////////////////////////////////////////////////
  2457. //  Check directory existance
  2458. ///////////////////////////////////////////////////////////////////////////////
  2459. if (!SysExistDir(szFullPath)) {
  2460. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_LISTDIR_NOT_FOUND);
  2461. ErrSetErrorCode(ERR_LISTDIR_NOT_FOUND);
  2462. return (ERR_LISTDIR_NOT_FOUND);
  2463. }
  2464. ///////////////////////////////////////////////////////////////////////////////
  2465. //  Send command continue response
  2466. ///////////////////////////////////////////////////////////////////////////////
  2467. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2469. ///////////////////////////////////////////////////////////////////////////////
  2470. //  List files
  2471. ///////////////////////////////////////////////////////////////////////////////
  2472. char szFileName[SYS_MAX_PATH] = "";
  2473. FSCAN_HANDLE hFileScan = MscFirstFile(szFullPath, 0, szFileName);
  2475. if (hFileScan != INVALID_FSCAN_HANDLE) {
  2476. do {
  2477. if (!SYS_IS_VALID_FILENAME(szFileName) ||
  2478.     !StrWildMatch(szFileName, ppszTokens[2]))
  2479. continue;
  2481. SYS_FILE_INFO FI;
  2482. char szFilePath[SYS_MAX_PATH] = "";
  2484. SysSNPrintf(szFilePath, sizeof(szFilePath) - 1, "%s%s%s",
  2485.     szFullPath, SYS_SLASH_STR, szFileName);
  2487. if (SysGetFileInfo(szFilePath, FI) == 0) {
  2488. if (BSckVSendString(hBSock, pCTRLCfg->iTimeout, ""%s"t"%lu"",
  2489.     szFileName, FI.ulSize) < 0) {
  2490. ErrorPush();
  2491. MscCloseFindFile(hFileScan);
  2492. return (ErrorPop());
  2493. }
  2494. }
  2496. } while (MscNextFile(hFileScan, szFileName));
  2498. MscCloseFindFile(hFileScan);
  2499. }
  2501. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  2503. return (0);
  2505. }
  2507. static int CTRLDo_cfgfileget(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2508.      char const *const *ppszTokens, int iTokensCount)
  2509. {
  2511. if (iTokensCount != 2) {
  2512. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2513. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2514. return (ERR_BAD_CTRL_COMMAND);
  2515. }
  2516. ///////////////////////////////////////////////////////////////////////////////
  2517. //  Check relative path syntax
  2518. ///////////////////////////////////////////////////////////////////////////////
  2519. if (CTRLCheckRelativePath(ppszTokens[1]) < 0) {
  2520. ErrorPush();
  2521. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2522. return (ErrorPop());
  2523. }
  2524. ///////////////////////////////////////////////////////////////////////////////
  2525. //  Setup client target file path
  2526. ///////////////////////////////////////////////////////////////////////////////
  2527. char szRelativePath[SYS_MAX_PATH] = "";
  2528. char szFullPath[SYS_MAX_PATH] = "";
  2530. StrSNCpy(szRelativePath, ppszTokens[1]);
  2531. MscTranslatePath(szRelativePath);
  2533. CfgGetFullPath(szRelativePath, szFullPath, sizeof(szFullPath));
  2534. DelFinalSlash(szFullPath);
  2536. ///////////////////////////////////////////////////////////////////////////////
  2537. //  Share lock client target file
  2538. ///////////////////////////////////////////////////////////////////////////////
  2539. char szResLock[SYS_MAX_PATH] = "";
  2540. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szFullPath, szResLock,
  2541.   sizeof(szResLock)));
  2543. if (hResLock == INVALID_RLCK_HANDLE) {
  2544. ErrorPush();
  2545. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2546. return (ErrorPop());
  2547. }
  2549. ///////////////////////////////////////////////////////////////////////////////
  2550. //  Get a file snapshot
  2551. ///////////////////////////////////////////////////////////////////////////////
  2552. char szRequestedFile[SYS_MAX_PATH] = "";
  2554. SysGetTmpFile(szRequestedFile);
  2556. if (MscCopyFile(szRequestedFile, szFullPath) < 0) {
  2557. ErrorPush();
  2558. CheckRemoveFile(szRequestedFile);
  2559. RLckUnlockSH(hResLock);
  2560. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2561. return (ErrorPop());
  2562. }
  2564. RLckUnlockSH(hResLock);
  2566. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2568. ///////////////////////////////////////////////////////////////////////////////
  2569. //  Send client target file
  2570. ///////////////////////////////////////////////////////////////////////////////
  2571. if (MscSendTextFile(szRequestedFile, hBSock, pCTRLCfg->iTimeout) < 0) {
  2572. ErrorPush();
  2573. SysRemove(szRequestedFile);
  2574. return (ErrorPop());
  2575. }
  2577. SysRemove(szRequestedFile);
  2579. return (0);
  2581. }
  2583. static int CTRLDo_cfgfileset(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2584.      char const *const *ppszTokens, int iTokensCount)
  2585. {
  2587. if (iTokensCount != 2) {
  2588. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2589. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2590. return (ERR_BAD_CTRL_COMMAND);
  2591. }
  2592. ///////////////////////////////////////////////////////////////////////////////
  2593. //  Check relative path syntax
  2594. ///////////////////////////////////////////////////////////////////////////////
  2595. if (CTRLCheckRelativePath(ppszTokens[1]) < 0) {
  2596. ErrorPush();
  2597. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2598. return (ErrorPop());
  2599. }
  2600. ///////////////////////////////////////////////////////////////////////////////
  2601. //  Setup client target file path
  2602. ///////////////////////////////////////////////////////////////////////////////
  2603. char szRelativePath[SYS_MAX_PATH] = "";
  2604. char szFullPath[SYS_MAX_PATH] = "";
  2606. StrSNCpy(szRelativePath, ppszTokens[1]);
  2607. MscTranslatePath(szRelativePath);
  2609. CfgGetFullPath(szRelativePath, szFullPath, sizeof(szFullPath));
  2610. DelFinalSlash(szFullPath);
  2612. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_WAITDATA_RESULT);
  2614. ///////////////////////////////////////////////////////////////////////////////
  2615. //  Read user data in file
  2616. ///////////////////////////////////////////////////////////////////////////////
  2617. char szClientFile[SYS_MAX_PATH] = "";
  2619. SysGetTmpFile(szClientFile);
  2621. if (MscRecvTextFile(szClientFile, hBSock, pCTRLCfg->iTimeout) < 0) {
  2622. ErrorPush();
  2623. CheckRemoveFile(szClientFile);
  2624. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2625. return (ErrorPop());
  2626. }
  2627. ///////////////////////////////////////////////////////////////////////////////
  2628. //  Get file info for size checking
  2629. ///////////////////////////////////////////////////////////////////////////////
  2630. SYS_FILE_INFO FI;
  2632. if (SysGetFileInfo(szClientFile, FI) < 0) {
  2633. ErrorPush();
  2634. CheckRemoveFile(szClientFile);
  2635. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2636. return (ErrorPop());
  2637. }
  2638. ///////////////////////////////////////////////////////////////////////////////
  2639. //  Exclusive lock client target file
  2640. ///////////////////////////////////////////////////////////////////////////////
  2641. char szResLock[SYS_MAX_PATH] = "";
  2642. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szFullPath, szResLock,
  2643.   sizeof(szResLock)));
  2645. if (hResLock == INVALID_RLCK_HANDLE) {
  2646. ErrorPush();
  2647. SysRemove(szClientFile);
  2648. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2649. return (ErrorPop());
  2650. }
  2652. if (FI.ulSize != 0) {
  2653. if (MscCopyFile(szFullPath, szClientFile) < 0) {
  2654. ErrorPush();
  2655. RLckUnlockEX(hResLock);
  2656. SysRemove(szClientFile);
  2657. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2658. return (ErrorPop());
  2659. }
  2660. } else
  2661. SysRemove(szFullPath);
  2663. RLckUnlockEX(hResLock);
  2665. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2667. SysRemove(szClientFile);
  2669. return (0);
  2671. }
  2673. static int CTRLDo_frozlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2674.    char const *const *ppszTokens, int iTokensCount)
  2675. {
  2677. if (iTokensCount < 1) {
  2678. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2679. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2680. return (ERR_BAD_CTRL_COMMAND);
  2681. }
  2682. ///////////////////////////////////////////////////////////////////////////////
  2683. //  Build frozen list file
  2684. ///////////////////////////////////////////////////////////////////////////////
  2685. char szListFile[SYS_MAX_PATH] = "";
  2687. SysGetTmpFile(szListFile);
  2689. if (QueUtGetFrozenList(hSpoolQueue, szListFile) < 0) {
  2690. ErrorPush();
  2691. CheckRemoveFile(szListFile);
  2692. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2693. return (ErrorPop());
  2694. }
  2696. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2698. ///////////////////////////////////////////////////////////////////////////////
  2699. //  Send client target file
  2700. ///////////////////////////////////////////////////////////////////////////////
  2701. if (MscSendTextFile(szListFile, hBSock, pCTRLCfg->iTimeout) < 0) {
  2702. ErrorPush();
  2703. SysRemove(szListFile);
  2704. return (ErrorPop());
  2705. }
  2707. SysRemove(szListFile);
  2709. return (0);
  2711. }
  2713. static int CTRLDo_frozsubmit(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2714.      char const *const *ppszTokens, int iTokensCount)
  2715. {
  2717. if (iTokensCount < 4) {
  2718. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2719. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2720. return (ERR_BAD_CTRL_COMMAND);
  2721. }
  2722. ///////////////////////////////////////////////////////////////////////////////
  2723. //  Try to defroze frozen message
  2724. ///////////////////////////////////////////////////////////////////////////////
  2725. int iLevel1 = atoi(ppszTokens[1]);
  2726. int iLevel2 = atoi(ppszTokens[2]);
  2727. char szMessageFile[SYS_MAX_PATH] = "";
  2729. StrSNCpy(szMessageFile, ppszTokens[3]);
  2731. if (QueUtUnFreezeMessage(hSpoolQueue, iLevel1, iLevel2, szMessageFile) < 0) {
  2732. ErrorPush();
  2733. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2734. return (ErrorPop());
  2735. }
  2737. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2739. return (0);
  2741. }
  2743. static int CTRLDo_frozdel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2744.   char const *const *ppszTokens, int iTokensCount)
  2745. {
  2747. if (iTokensCount < 4) {
  2748. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2749. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2750. return (ERR_BAD_CTRL_COMMAND);
  2751. }
  2752. ///////////////////////////////////////////////////////////////////////////////
  2753. //  Try to delete frozen message
  2754. ///////////////////////////////////////////////////////////////////////////////
  2755. int iLevel1 = atoi(ppszTokens[1]);
  2756. int iLevel2 = atoi(ppszTokens[2]);
  2757. char szMessageFile[SYS_MAX_PATH] = "";
  2759. StrSNCpy(szMessageFile, ppszTokens[3]);
  2761. if (QueUtDeleteFrozenMessage(hSpoolQueue, iLevel1, iLevel2, szMessageFile) < 0) {
  2762. ErrorPush();
  2763. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2764. return (ErrorPop());
  2765. }
  2767. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2769. return (0);
  2771. }
  2773. static int CTRLDo_frozgetlog(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2774.      char const *const *ppszTokens, int iTokensCount)
  2775. {
  2777. if (iTokensCount < 4) {
  2778. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2779. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2780. return (ERR_BAD_CTRL_COMMAND);
  2781. }
  2782. ///////////////////////////////////////////////////////////////////////////////
  2783. //  Try to delete frozen message
  2784. ///////////////////////////////////////////////////////////////////////////////
  2785. int iLevel1 = atoi(ppszTokens[1]);
  2786. int iLevel2 = atoi(ppszTokens[2]);
  2787. char szMessageFile[SYS_MAX_PATH] = "";
  2789. StrSNCpy(szMessageFile, ppszTokens[3]);
  2791. ///////////////////////////////////////////////////////////////////////////////
  2792. //  Get log file snapshot
  2793. ///////////////////////////////////////////////////////////////////////////////
  2794. char szFileSS[SYS_MAX_PATH] = "";
  2796. SysGetTmpFile(szFileSS);
  2798. if (QueUtGetFrozenLogFile(hSpoolQueue, iLevel1, iLevel2, szMessageFile, szFileSS) < 0) {
  2799. ErrorPush();
  2800. CheckRemoveFile(szFileSS);
  2801. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2802. return (ErrorPop());
  2803. }
  2805. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2807. ///////////////////////////////////////////////////////////////////////////////
  2808. //  Send client target file
  2809. ///////////////////////////////////////////////////////////////////////////////
  2810. if (MscSendTextFile(szFileSS, hBSock, pCTRLCfg->iTimeout) < 0) {
  2811. ErrorPush();
  2812. SysRemove(szFileSS);
  2813. return (ErrorPop());
  2814. }
  2816. SysRemove(szFileSS);
  2818. return (0);
  2820. }
  2822. static int CTRLDo_frozgetmsg(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2823.      char const *const *ppszTokens, int iTokensCount)
  2824. {
  2826. if (iTokensCount < 4) {
  2827. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2828. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2829. return (ERR_BAD_CTRL_COMMAND);
  2830. }
  2831. ///////////////////////////////////////////////////////////////////////////////
  2832. //  Try to delete frozen message
  2833. ///////////////////////////////////////////////////////////////////////////////
  2834. int iLevel1 = atoi(ppszTokens[1]);
  2835. int iLevel2 = atoi(ppszTokens[2]);
  2836. char szMessageFile[SYS_MAX_PATH] = "";
  2838. StrSNCpy(szMessageFile, ppszTokens[3]);
  2840. ///////////////////////////////////////////////////////////////////////////////
  2841. //  Get log file snapshot
  2842. ///////////////////////////////////////////////////////////////////////////////
  2843. char szFileSS[SYS_MAX_PATH] = "";
  2845. SysGetTmpFile(szFileSS);
  2847. if (QueUtGetFrozenMsgFile(hSpoolQueue, iLevel1, iLevel2, szMessageFile, szFileSS) < 0) {
  2848. ErrorPush();
  2849. CheckRemoveFile(szFileSS);
  2850. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2851. return (ErrorPop());
  2852. }
  2854. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2856. ///////////////////////////////////////////////////////////////////////////////
  2857. //  Send client target file
  2858. ///////////////////////////////////////////////////////////////////////////////
  2859. if (MscSendTextFile(szFileSS, hBSock, pCTRLCfg->iTimeout) < 0) {
  2860. ErrorPush();
  2861. SysRemove(szFileSS);
  2862. return (ErrorPop());
  2863. }
  2865. SysRemove(szFileSS);
  2867. return (0);
  2869. }
  2871. static int CTRLDo_etrn(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2872.        char const *const *ppszTokens, int iTokensCount)
  2873. {
  2875. if (iTokensCount < 2) {
  2876. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2877. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2878. return (ERR_BAD_CTRL_COMMAND);
  2879. }
  2880. ///////////////////////////////////////////////////////////////////////////////
  2881. //  Do a matched flush of the rsnd arena
  2882. ///////////////////////////////////////////////////////////////////////////////
  2883. for (int ii = 1; ii < iTokensCount; ii++) {
  2884. if (QueFlushRsndArena(hSpoolQueue, ppszTokens[ii]) < 0) {
  2885. ErrorPush();
  2886. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2887. return (ErrorPop());
  2888. }
  2889. }
  2891. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2893. return (0);
  2895. }
  2897. static int CTRLDo_aliasdomainadd(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2898.  char const *const *ppszTokens, int iTokensCount)
  2899. {
  2901. if (iTokensCount != 3) {
  2902. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2903. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2904. return (ERR_BAD_CTRL_COMMAND);
  2905. }
  2906. ///////////////////////////////////////////////////////////////////////////////
  2907. //  Filter params
  2908. ///////////////////////////////////////////////////////////////////////////////
  2909. char szDomain[MAX_HOST_NAME] = "";
  2910. char szADomain[MAX_HOST_NAME] = "";
  2912. StrSNCpy(szDomain, ppszTokens[1]);
  2913. StrLower(szDomain);
  2915. StrSNCpy(szADomain, ppszTokens[2]);
  2916. StrLower(szADomain);
  2918. ///////////////////////////////////////////////////////////////////////////////
  2919. //  Target domain MUST exit ( alias of aliases are not permitted )
  2920. ///////////////////////////////////////////////////////////////////////////////
  2921. if (MDomLookupDomain(szDomain) < 0) {
  2922. ErrorPush();
  2923. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2924. return (ErrorPop());
  2925. }
  2926. ///////////////////////////////////////////////////////////////////////////////
  2927. //  Alias domain MUST NOT exit
  2928. ///////////////////////////////////////////////////////////////////////////////
  2929. if ((MDomLookupDomain(szADomain) == 0) ||
  2930.     ADomLookupDomain(szADomain, NULL, false)) {
  2931. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_ADOMAIN_EXIST);
  2933. ErrSetErrorCode(ERR_ADOMAIN_EXIST);
  2934. return (ERR_ADOMAIN_EXIST);
  2935. }
  2936. ///////////////////////////////////////////////////////////////////////////////
  2937. //  Add alias domain
  2938. ///////////////////////////////////////////////////////////////////////////////
  2939. if (ADomAddADomain(szADomain, szDomain) < 0) {
  2940. ErrorPush();
  2941. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2942. return (ErrorPop());
  2943. }
  2945. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2947. return (0);
  2949. }
  2951. static int CTRLDo_aliasdomaindel(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2952.  char const *const *ppszTokens, int iTokensCount)
  2953. {
  2955. if (iTokensCount != 2) {
  2956. CTRLSendCmdResult(pCTRLCfg, hBSock, ERR_BAD_CTRL_COMMAND);
  2957. ErrSetErrorCode(ERR_BAD_CTRL_COMMAND);
  2958. return (ERR_BAD_CTRL_COMMAND);
  2959. }
  2960. ///////////////////////////////////////////////////////////////////////////////
  2961. //  Filter params
  2962. ///////////////////////////////////////////////////////////////////////////////
  2963. char szADomain[MAX_HOST_NAME] = "";
  2965. StrSNCpy(szADomain, ppszTokens[1]);
  2966. StrLower(szADomain);
  2968. ///////////////////////////////////////////////////////////////////////////////
  2969. //  Remove alias domain
  2970. ///////////////////////////////////////////////////////////////////////////////
  2971. if (ADomRemoveADomain(szADomain) < 0) {
  2972. ErrorPush();
  2973. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrorFetch());
  2974. return (ErrorPop());
  2975. }
  2977. CTRLSendCmdResult(pCTRLCfg, hBSock, 0);
  2979. return (0);
  2981. }
  2983. static int CTRLDo_aliasdomainlist(CTRLConfig * pCTRLCfg, BSOCK_HANDLE hBSock,
  2984.   char const *const *ppszTokens, int iTokensCount)
  2985. {
  2987. ADOMAIN_HANDLE hADomainDB = ADomOpenDB();
  2989. if (hADomainDB == INVALID_ADOMAIN_HANDLE) {
  2990. ErrorPush();
  2991. CTRLSendCmdResult(pCTRLCfg, hBSock, ErrGetErrorCode());
  2992. return (ErrorPop());
  2993. }
  2995. CTRLSendCmdResult(pCTRLCfg, hBSock, CTRL_LISTFOLLOW_RESULT);
  2997. char const *const *ppszStrings = ADomGetFirstDomain(hADomainDB);
  2999. for (; ppszStrings != NULL; ppszStrings = ADomGetNextDomain(hADomainDB)) {
  3000. if ((iTokensCount < 2) ||
  3001.     ((iTokensCount == 2) && StrStringsRIWMatch(&ppszTokens[1], ppszStrings[adomDomain])) ||
  3002.     ((iTokensCount == 3) && StrStringsRIWMatch(&ppszTokens[1], ppszStrings[adomDomain]) &&
  3003.      StrStringsRIWMatch(&ppszTokens[2], ppszStrings[adomADomain]))) {
  3004. if (BSckVSendString
  3005.     (hBSock, pCTRLCfg->iTimeout, ""%s"t"%s"",
  3006.      ppszStrings[adomDomain], ppszStrings[adomADomain]) < 0) {
  3007. ErrorPush();
  3008. ADomCloseDB(hADomainDB);
  3009. return (ErrorPop());
  3010. }
  3011. }
  3012. }
  3014. ADomCloseDB(hADomainDB);
  3016. BSckSendString(hBSock, ".", pCTRLCfg->iTimeout);
  3018. return (0);
  3020. }