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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
FTPDaemonCore.cpp
资源名称：warftpd.zip　[点击查看]
上传用户：surprise9
上传日期：2007-01-04
资源大小：426k
文件大小：56k
源码类别：

Ftp客户端

开发平台：

Visual C++

FTPDaemonCore.cpp：源码内容
  1. // This is part of the WAR SOFTWARE SERIES initiated by Jarle Aase
  2. // Copyright 1996 by Jarle Aase. All rights reserved.
  3. // See the "War Software Series Licende Agreement" for details concerning 
  4. // use and distribution.
  5. // ---
  6. // This source code, executables and programs containing source code or
  7. // binaries or proprietetary technology from the War Software Series are
  8. // NOT alloed used, viewed or tested by any governmental agencies in
  9. // any countries. This includes the government, departments, police, 
  10. // military etc.
  11. // ---
  12. // This file is intended for use with Tab space = 2
  13. // Created and maintained in MSVC Developer Studio
  14. // ---
  15. // NAME : FTPDaemonCore.cpp
  16. // PURPOSE : Basic FTP Daemon classes
  17. // PROGRAM : 
  18. // DATE : Sept. 27 1996
  19. // AUTHOR : Jarle Aase
  20. // ---
  21. // REVISION HISTORY
  22. // 
  24. #include "stdafx.h"
  25. #define FTP_NAMES
  26. #include "ftp.h"
  27. #include "FTPDaemonCore.h"
  28. #include "Unix.h"
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  37. ////////////////////////////////////////////////////////////////////
  38. // FTPD Command parser
  40. enum // Token ID's
  41. {
  42. TOK_USER = TOK_START_TAB,     TOK_PASS, TOK_ACCT, TOK_REIN, TOK_XCUP,
  43. TOK_PORT, TOK_PASV, TOK_TYPE, TOK_STRU, TOK_MODE, TOK_RETR, TOK_STOR, 
  44. TOK_APPE, TOK_MLFL, TOK_MAIL, TOK_MSND, TOK_MSOM, TOK_MSAM, TOK_MRSQ, 
  45. TOK_MRCP, TOK_ALLO, TOK_REST, TOK_RNFR, TOK_RNTO, TOK_ABOR, TOK_DELE, 
  46. TOK_CWD,  TOK_LIST, TOK_NLST, TOK_SITE, TOK_STAT, TOK_XCWD, TOK_XMKD,
  47. TOK_HELP, TOK_NOOP, TOK_MKD,  TOK_RMD,  TOK_PWD,  TOK_CDUP, TOK_STOU, 
  48. TOK_SMNT, TOK_SYST, TOK_SIZE, TOK_MDTM, TOK_XRMD, TOK_XPWD, TOK_QUIT,
  50. // SITE
  51. TOK_CHMOD, TOK_CHOWN, TOK_CHGRP, TOK_CHCMT, TOK_FSYSSTAT,
  52. };
  54. // Command tokens
  55. static STokenTab BaseTokens[] =
  56. {
  57. {TOK_QUIT, "QUIT" },
  58. {TOK_USER, "USER" },
  59. {TOK_PASS, "PASS" },
  60. {TOK_ACCT, "ACCT" },
  61. {TOK_REIN, "REIN" },
  62. {TOK_QUIT, "QUIT" },
  63. {TOK_PORT, "PORT" },
  64. {TOK_PASV, "PASV" },
  65. {TOK_TYPE, "TYPE" },
  66. {TOK_STRU, "STRU" },
  67. {TOK_MODE, "MODE" },
  68. {TOK_RETR, "RETR" },
  69. {TOK_STOR, "STOR" },
  70. {TOK_APPE, "APPE" },
  71. {TOK_MLFL, "MLFL" },
  72. {TOK_MAIL, "MAIL" },
  73. {TOK_MSND, "MSND" },
  74. {TOK_MSOM, "MSOM" },
  75. {TOK_MSAM, "MSAM" },
  76. {TOK_MRSQ, "MRSQ" },
  77. {TOK_MRCP, "MRCP" },
  78. {TOK_ALLO, "ALLO" },
  79. {TOK_REST, "REST" },
  80. {TOK_RNFR, "RNFR" },
  81. {TOK_RNTO, "RNTO" },
  82. {TOK_ABOR, "ABOR" },
  83. {TOK_DELE, "DELE" },
  84. {TOK_CWD,  "CWD" },
  85. {TOK_XCWD, "XCWD" },
  86. {TOK_LIST, "LIST" },
  87. {TOK_NLST, "NLST" },
  88. {TOK_SITE, "SITE" },
  89. {TOK_STAT, "STAT" },
  90. {TOK_HELP, "HELP" },
  91. {TOK_NOOP, "NOOP" },
  92. {TOK_MKD,  "MKD" },
  93. {TOK_RMD,  "RMD" },
  94. {TOK_PWD,  "PWD" },
  95. {TOK_XMKD, "XMKD" },
  96. {TOK_XRMD, "XRMD" },
  97. {TOK_XPWD, "XPWD" },
  98. {TOK_CDUP, "CDUP" },
  99. {TOK_XCUP, "XCUP" },
  100. {TOK_STOU, "STOU" },
  101. {TOK_SMNT, "SMNT" },
  102. {TOK_SYST, "SYST" },
  103. {TOK_SIZE, "SIZE" },
  104. {TOK_MDTM, "MDTM" },
  106. // SITE
  107. {TOK_CHMOD,"CHMOD"},
  108. {TOK_CHOWN,"CHOWN"},
  109. {TOK_CHGRP,"CHGRP"},
  110. {TOK_CHCMT,"CHCMT"},
  111. {TOK_FSYSSTAT,"FSYSSTAT"},
  112. {TOK_INVALID, "" }
  113. };
  116. enum // Commands recognized on this level
  117. {
  118. CMD_USER = CMD_START_TREE,    CMD_PASS, CMD_ACCT, CMD_REIN, CMD_QUIT, 
  119. CMD_PORT, CMD_PASV, CMD_TYPE, CMD_STRU, CMD_MODE, CMD_RETR, CMD_STOR, 
  120. CMD_APPE, CMD_MLFL, CMD_MAIL, CMD_MSND, CMD_MSOM, CMD_MSAM, CMD_MRSQ, 
  121. CMD_MRCP, CMD_ALLO, CMD_REST, CMD_RNFR, CMD_RNTO, CMD_ABOR, CMD_DELE, 
  122. CMD_CWD,  CMD_LIST, CMD_NLST, CMD_SITE, CMD_STAT,  
  123. CMD_HELP, CMD_NOOP, CMD_MKD,  CMD_RMD,  CMD_PWD,  CMD_CDUP, CMD_STOU, 
  124. CMD_SMNT, CMD_SYST, CMD_SIZE, CMD_MDTM,
  126. // SITE
  127. CMD_CHMOD, CMD_CHGRP, CMD_CHOWN, CMD_CHCMT, CMD_FSYSSTAT,
  128. };
  130. static SCommandTree SiteCmds[] =
  131. {
  132. {TOK_CHMOD, CMD_CHMOD, PROCESS,  CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "SITE CHMOD <sp> mode <sp> file ..." },
  133. {TOK_CHOWN, CMD_CHOWN, PROCESS,  CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "SITE CHOWN <sp> user <sp> file..." },
  134. {TOK_CHGRP, CMD_CHGRP, PROCESS,  CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "SITE CHGRP <sp> class <sp> file..." },
  135. {TOK_CHCMT, CMD_CHCMT, PROCESS,  CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "SITE CHCMT <sp> "comment" <sp> file..."},
  136. {TOK_FSYSSTAT, CMD_FSYSSTAT, PROCESS, CMDF_NOPARAM,  NULL, ' ', LEX_WANT_CMD, "SITE FSYSSTAT"},
  137. {TOK_INVALID, CMD_INVALID, 0,  0,  NULL, 0,   0,             NULL}
  138. };
  140. // Command tree
  141. static SCommandTree BaseCmds[] =
  142. {
  143. {TOK_USER, CMD_USER, PRELOGIN, CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "USER <sp> username"},
  144. {TOK_PASS, CMD_PASS, GOTNAME,  CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "PASS <sp> password" },
  145. {TOK_QUIT, CMD_QUIT, PRELOGIN, 0,  NULL, ' ', LEX_WANT_CMD, "QUIT (end session)" },
  146. {TOK_ACCT, CMD_ACCT, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "ACCT (specify account)" },
  147. {TOK_REIN, CMD_REIN, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "REIN (reinitialize server state)" },
  148. {TOK_PORT, CMD_PORT, PRELOGIN, CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "PORT <sp> b0, b1, b2, b3, b4" },
  149. {TOK_PASV, CMD_PASV, PRELOGIN, CMDF_NOPARAM,         NULL, ' ', LEX_WANT_CMD, "PASV (set server in passive mode)" },
  150. {TOK_TYPE, CMD_TYPE, PRELOGIN, CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "TYPE <sp> [ A | E | I | L ]" },
  151. {TOK_STRU, CMD_STRU, PROCESS,  CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "STRU (specify file structure)" },
  152. {TOK_MODE, CMD_MODE, PRELOGIN, CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "MODE (specify transfer mode)" },
  153. {TOK_RETR, CMD_RETR, PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "RETR <sp> file-name" },
  154. {TOK_STOR, CMD_STOR, PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "STOR <sp> file-name" },
  155. {TOK_APPE, CMD_APPE, PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "APPE <sp> file-name" },
  156. {TOK_MLFL, CMD_MLFL, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "MLFL (mail file)" },
  157. {TOK_MAIL, CMD_MAIL, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "MAIL (mail to user)" },
  158. {TOK_MSND, CMD_MSND, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "MSND (mail send to terminal)" },
  159. {TOK_MSOM, CMD_MSOM, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "MSOM (mail send to terminal or mailbox)" },
  160. {TOK_MSAM, CMD_MSAM, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "MSAM (mail send to terminal and mailbox)" },
  161. {TOK_MRSQ, CMD_MRSQ, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "MRSQ (mail recipient scheme question)" },
  162. {TOK_MRCP, CMD_MRCP, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "MRCP (mail recipient)" },
  163. {TOK_ALLO, CMD_ALLO, PROCESS,  CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "ALLO <sp> bytes" },
  164. {TOK_REST, CMD_REST, PRELOGIN, CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "REST <sp> byte offset" },
  165. {TOK_RNFR, CMD_RNFR, PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "RNFR <sp> file-name" },
  166. {TOK_RNTO, CMD_RNTO, PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "RNTO <sp> file-name" },
  167. {TOK_ABOR, CMD_ABOR, PROCESS,  0,                    NULL, ' ', LEX_WANT_CMD, "(abort operation)" },
  168. {TOK_DELE, CMD_DELE, PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "DELE <sp> file-name" },
  169. {TOK_CWD,  CMD_CWD,  PROCESS,  CMDF_PARSE_CMD_LINE,                    NULL, ' ', LEX_WANT_CMD, "CWD [ <sp> directory-name ]" },
  170. {TOK_XCWD, CMD_CWD,  PROCESS,  CMDF_PARSE_CMD_LINE,                    NULL, ' ', LEX_WANT_CMD, "XCWD [ <sp> directory-name ]" },
  171. {TOK_LIST, CMD_LIST, PROCESS,  CMDF_PARSE_CMD_LINE,                    NULL, ' ', LEX_WANT_CMD, "LIST [ <sp> path-name ]" },
  172. {TOK_NLST, CMD_NLST, PROCESS,  CMDF_PARSE_CMD_LINE,                    NULL, ' ', LEX_WANT_CMD, "NLST [ <sp> path-name ]" },
  173. {TOK_SITE, CMD_SITE, PRELOGIN, CMDF_PARAMETER,       SiteCmds, ' ', LEX_WANT_CMD, "SITE site-cmd [ <sp> arguments ]" },
  174. {TOK_STAT, CMD_STAT, PROCESS,  0,                    NULL, ' ', LEX_WANT_CMD, "STAT [ <sp> path-name ]" },
  175. {TOK_HELP, CMD_HELP, PRELOGIN, 0,                    NULL, ' ', LEX_WANT_CMD, "HELP [ <sp> <string> ]" },
  176. {TOK_NOOP, CMD_NOOP, PRELOGIN, CMDF_NOPARAM,         NULL, ' ', LEX_WANT_CMD, "NOOP (no operation)" },
  177. {TOK_MKD,  CMD_MKD,  PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "MKD <sp> path-name" },
  178. {TOK_XMKD, CMD_MKD,  PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "XMKD <sp> path-name" },
  179. {TOK_RMD,  CMD_RMD,  PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "RMD <sp> path-name" },
  180. {TOK_XRMD, CMD_RMD,  PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "XRMD <sp> path-name" },
  181. {TOK_PWD,  CMD_PWD,  PROCESS,  CMDF_NOPARAM,         NULL, ' ', LEX_WANT_CMD, "PWD (return current directory)" },
  182. {TOK_XPWD, CMD_PWD,  PROCESS,  CMDF_NOPARAM,         NULL, ' ', LEX_WANT_CMD, "XPWD (return current directory)" },
  183. {TOK_CDUP, CMD_CDUP, PROCESS,  0,                    NULL, ' ', LEX_WANT_CMD, "CDUP (change to parent directory)" },
  184. {TOK_XCUP, CMD_CDUP, PROCESS,  0,                    NULL, ' ', LEX_WANT_CMD, "CDUP (change to parent directory)" },
  185. {TOK_STOU, CMD_STOU, PROCESS,  CMDF_PARAMETER,       NULL, ' ', LEX_WANT_CMD, "STOU <sp> file-name" },
  186. {TOK_SMNT, CMD_SMNT, PROCESS,  CMDF_NOT_IMPLEMENTED, NULL, ' ', LEX_WANT_CMD, "SMNT (structure mount)" },
  187. {TOK_SYST, CMD_SYST, PRELOGIN, CMDF_NOPARAM,        NULL, ' ', LEX_WANT_CMD, "SYST (get type of operating system)" },
  188. {TOK_SIZE, CMD_SIZE, PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "SIZE <sp> path-name" },
  189. {TOK_MDTM, CMD_MDTM, PROCESS,  CMDF_PARAMETER|CMDF_PARSE_CMD_LINE,       NULL, ' ', LEX_WANT_CMD, "MDTM <sp> path-name" },
  190. {TOK_INVALID, CMD_INVALID, 0,  0,                    NULL, 0,   0,             NULL}
  191. };
  193. CFTPDParser::CFTPDParser()
  194. {
  195. m_Commands = (SCommandTree *) BaseCmds;
  196. m_Tokens = (STokenTab *) BaseTokens;
  197. }
  200. // The FTP protocol command interface is fairly simple.
  201. // We don't call the regular CCmdParser::ParseCmd() but do the parsing
  202. // ourself.
  203. int CFTPDParser::ParseCmd(LPCSTR CmdLine, CCmdArgs& Args, int Level, BOOL& DoParseCmdLine)
  204. {
  205. int TokenID;
  206. LPCSTR LexCmdLine = CmdLine;
  207. SCommandTreeDef *CmdPtr = m_Commands;
  209. again:
  210. TokenID = yyLex(&LexCmdLine, m_Tokens, ' ', LEX_WANT_CMD, Args);
  211. if (TokenID < TOK_START_TAB)
  212. return CMD_PARSE_ERROR; // Error
  214. // Find the command ID
  215. while(CmdPtr && (CmdPtr->TokenID != TokenID) && (CmdPtr->TokenID != TOK_INVALID))
  216. ++CmdPtr;
  218. if (!CmdPtr)
  219. return CMD_UNKNOWN_COMMAND;
  221. if (CmdPtr->NextLevel)
  222. {
  223. ASSERT(CmdPtr->CommandID == CMD_SITE);
  224. CmdPtr = CmdPtr->NextLevel;
  225. goto again;
  226. }
  228. // Try to get parameter
  229. TokenID = yyLex(&LexCmdLine, m_Tokens, 0, LEX_WANT_STRING, Args);
  231. // Check for login level and availibility
  232. if (CmdPtr->AccessLevel > Level)
  233. return CMD_BAD_LEVEL;
  235. // Check for required parameter
  236. if ((CmdPtr->Flags & CMDF_PARAMETER)
  237. && (TokenID == TOK_END_OF_TOKENS))
  238. return CMD_MISSING_PARAMETER;
  240. // Check for no parameter
  241. if ((CmdPtr->Flags & CMDF_NOPARAM)
  242. && (TokenID != TOK_END_OF_TOKENS))
  243. return CMD_UNKNOWN_PARAMETER;
  245. // Is the command implemented?
  246. if (CmdPtr->Flags & CMDF_NOT_IMPLEMENTED)
  247. return CMD_NOT_IMPLEMENTED;
  249. DoParseCmdLine = (CmdPtr->Flags & CMDF_PARSE_CMD_LINE) != 0;
  251. return CmdPtr->CommandID;
  252. }
  255. ////////////////////////////////////////////////////////////////////
  256. // CFTPDaemonCore
  258. CFtpDaemonCore *CFtpDaemonCore::m_pCFtpDaemonCore = NULL;
  260. CFtpDaemonCore::CFtpDaemonCore()
  261. {
  262. m_pCFtpDaemonCore = this;
  263. }
  265. CFtpDaemonCore::~CFtpDaemonCore()
  266. {
  267. m_Options.SaveAll();
  268. CUserFsys::CloseFileSystem();
  269. m_pCFtpDaemonCore = NULL;
  270. }
  272. // Initialize and go online
  273. BOOL CFtpDaemonCore::Create(LPCSTR IniFile, CLog *Log)
  274. {
  275. m_Log = Log;
  276. m_Options.Create(NULL,IniFile,"FTPD", COPTION_FTPD_CORE);
  277. m_Options.LoadAll();
  279. // Start the file system
  280. if (!CUserFsys::FsysIsStarted())
  281. {
  282. if (!CUserFsys::StartFileSystem(NULL))
  283. return FALSE;
  284. }
  286. CDaemonBase::GetSvr()->RefreshStats();
  288. if (!m_Listen.Initialize(m_Options.m_Port, "FTP", m_Options.m_IPname))
  289. {
  290. return FALSE;
  291. }
  293. return TRUE;
  294. }
  296. void CFtpDaemonCore::LogMsg(int flag, LPCSTR Format, ...)
  297. {
  298. CString cBuf;
  299. if (!ShouldLog(m_Log, flag))
  300. return;
  302. ASSERT(AfxIsValidString(Format, FALSE));
  303. ASSERT(m_Log != NULL);
  304. ASSERT(AfxIsValidAddress(m_Log,sizeof(CLog)));
  306. cBuf.Format("FTPD: %s", Format);
  308. va_list argList;
  309. va_start(argList, Format);
  310. m_Log->LogMsgV(flag, cBuf, argList);
  311. va_end(argList);
  312. }
  314. /////////////////////////////////////////////////////////////////////////////////
  315. // FTP server listen socket
  317. void CFTPDCoreListenSock::OnAccept( int nErrorCode )
  318. {
  319. try
  320. {
  321. _OnAccept(nErrorCode);
  322. }
  323. catch(CSocketException *pExc)
  324. {
  325. LogMsg(LOGF_DEBUG,"CFTPDCoreListenSock::OnAccept(%d) - Caught exception '%s' from module %s",
  326. nErrorCode, pExc->m_ErrorText, pExc->m_ErrorText);
  328. if (!OnHandleWinsockErr(pExc->m_ErrorNum))
  329. delete this;
  331. delete pExc;
  332. }
  333. catch(...)
  334. {
  335. LogMsg(LOGF_ERROR,"CFTPDCoreListenSock::OnAccept(%d) - Caught unknown exception", nErrorCode);
  336. }
  337. }
  339. void CFTPDCoreListenSock::_OnAccept( int nErrorCode )
  340. {
  341. int err;
  342. CSock::OnAccept(nErrorCode);
  343. if (nErrorCode)
  344. return;
  347. CFTPDCoreCtrlSock *NewSocket = new CFTPDCoreCtrlSock;
  349. // EXT module
  350. if (err = PrcExt(CAPIHandler::OnPreFTPDAccept,0,(WPARAM)&NewSocket,(LPARAM)this))
  351. {
  352. if (err == CFuncList::AbortError)
  353. delete NewSocket;
  355. return;
  356. }
  358. try
  359. {
  360. if (!DoAccept(NewSocket))
  361. {
  362. delete NewSocket;
  363. return;
  364. }
  365. }
  366. catch(CSocketException *pExc)
  367. {
  368. if (pExc->m_pSock == NewSocket)
  369. {
  370. LogMsg(LOGF_DEBUG,"CFTPDCoreListenSock::_OnAccept(%d) - Caught exception '%s' from module %s. Connecting socket is being killed.",
  371. nErrorCode, pExc->m_ErrorText, pExc->m_ErrorText);
  372. delete NewSocket;
  373. delete pExc;
  374. return;
  375. }
  377. // Can't handle this here...
  378. throw pExc;
  379. }
  380. catch(...)
  381. {
  382. LogMsg(LOGF_ERROR,"CFTPDCoreListenSock::_OnAccept(%d) - Caught unknown exception", nErrorCode);
  383. return;
  384. }
  386. // EXT module
  387. if (err = PrcExt(CAPIHandler::OnPostFTPDAccept,0,(WPARAM)&NewSocket,(LPARAM)this))
  388. {
  389. if (err == CFuncList::AbortError)
  390. delete NewSocket;
  392. return;
  393. }
  395. // Intitialize connection
  396. NewSocket->EnableMacros();
  397. NewSocket->SendCtrlMsg(220,"[$systemname] ([$programname] [$programversion]) ready [%c][+sysmsg0.txt]");
  398. }
  400. BOOL CFTPDCoreListenSock::Initialize(int PortNumber, LPCSTR ServiceName, LPCSTR ListenIP)
  401. {
  402. if (!PortNumber)
  403. PortNumber = 21; // FTP
  405. if (!ServiceName)
  406. ServiceName = "FTP";
  408. m_Type = LT_FTP;
  410. BOOL IsOnline = CDaemonServiceSocket::Initialize(PortNumber,ServiceName, ListenIP);
  411. CDaemonStatusSvr::SetOnline(IsOnline);
  413. return IsOnline;
  414. }
  416. /////////////////////////////////////////////////////////////////////////////////
  417. // FTP server Control Socket
  418. // This is the FTP server module
  420. IMPLEMENT_DYNAMIC(CFTPDCoreCtrlSock, CTextSock);
  422. CFTPDCoreCtrlSock::CFTPDCoreCtrlSock()
  423. {
  424. SOCKADDR_IN *s_in = (SOCKADDR_IN *)&m_Sockaddr;
  425. m_ArgSave.Empty();
  426. m_Fsys = NULL;
  427. m_DataSock = NULL;
  429. // Set RFC 959 default values.
  430. m_FTPmode = MODE_S;
  431. m_FTPtype = TYPE_A;
  432. m_FTPstru = STRU_F;
  433. m_FTPform = FORM_N;
  435. memset(&m_Sockaddr, 0, sizeof(struct sockaddr));
  437. // Increase login counter
  438. CDaemonStatusSvr::IncUserCnt(TRUE);
  440. PrcExt(CAPIHandler::OnFTPDCoreCtrlSock,0,0,(LPARAM)this);
  441. }
  443. CFTPDCoreCtrlSock::~CFTPDCoreCtrlSock()
  444. {
  445. LogMsg(LOGF_DEBUG,"~CFTPDCoreCtrlSock() - %s.", m_DataSock ? "deleting data socket" : "no datasocket");
  446. if (m_DataSock)
  447. delete m_DataSock;
  449. //Log out from file system
  450. if (m_Fsys)
  451. m_Fsys->Logout();
  453. // Decrease login counter
  454. CDaemonStatusSvr::IncUserCnt(FALSE);
  455. }
  457. void CFTPDCoreCtrlSock::IncXferCnt(BOOL Add)
  458. {
  459. CDaemonStatusSvr::IncXferCnt(Add);
  460. }
  463. void CFTPDCoreCtrlSock::OnClose( int nErrorCode )
  464. {
  465. m_SuspendOnClose = TRUE; // Turn it on - just in case...
  466. try
  467. {
  468. CTextSock::OnClose(nErrorCode);
  469. CSocketException::Throw(this, "CFTPDCoreCtrlSock::OnClose()", nErrorCode, NULL);
  470. }
  471. catch(CSocketException *pExc)
  472. {
  473. LogMsg(LOGF_DEBUG,"CFTPDCoreCtrlSock::OnClose(%d) - Caught exception '%s' from module %s",
  474. nErrorCode, pExc->m_ErrorText, pExc->m_ErrorText);
  476. if (!OnHandleWinsockErr(pExc->m_ErrorNum))
  477. delete this;
  479. delete pExc;
  480. }
  481. catch(...)
  482. {
  483. LogMsg(LOGF_ERROR,"CFTPDCoreListenSock::OnClose(%d) - Caught unknown exception", nErrorCode);
  484. return;
  485. }
  486. }
  488. void CFTPDCoreCtrlSock::OnReceive( int nErrorCode )
  489. {
  490. try
  491. {
  492. CTextSock::OnReceive(nErrorCode);
  493. }
  494. catch(CSocketException *pExc)
  495. {
  496. LogMsg(LOGF_DEBUG,"CFTPDCoreCtrlSock::OnReceive(%d) - Caught exception '%s' from module %s",
  497. nErrorCode, pExc->m_ErrorText, pExc->m_ErrorText);
  499. if (!OnHandleWinsockErr(pExc->m_ErrorNum))
  500. delete this;
  502. delete pExc;
  503. }
  504. catch(...)
  505. {
  506. LogMsg(LOGF_ERROR,"CFTPDCoreListenSock::OnReceive(%d) - Caught unknown exception", nErrorCode);
  507. return;
  508. }
  509. }
  511. void CFTPDCoreCtrlSock::OnSend( int nErrorCode )
  512. {
  513. try
  514. {
  515. CTextSock::OnSend(nErrorCode);
  516. }
  517. catch(CSocketException *pExc)
  518. {
  519. LogMsg(LOGF_DEBUG,"CFTPDCoreCtrlSock::OnSend(%d) - Caught exception '%s' from module %s",
  520. nErrorCode, pExc->m_ErrorText, pExc->m_ErrorText);
  522. if (!OnHandleWinsockErr(pExc->m_ErrorNum))
  523. delete this;
  525. delete pExc;
  526. }
  527. catch(...)
  528. {
  529. LogMsg(LOGF_ERROR,"CFTPDCoreListenSock::OnSend(%d) - Caught unknown exception", nErrorCode);
  530. return;
  531. }
  532. }
  534. void CFTPDCoreCtrlSock::OnConnect( int nErrorCode )
  535. {
  536. try
  537. {
  538. _OnConnect(nErrorCode);
  539. }
  540. catch(CSocketException *pExc)
  541. {
  542. LogMsg(LOGF_DEBUG,"CFTPDCoreCtrlSock::OnConnect(%d) - Caught exception '%s' from module %s",
  543. nErrorCode, pExc->m_ErrorText, pExc->m_ErrorText);
  545. if (!OnHandleWinsockErr(pExc->m_ErrorNum))
  546. delete this;
  548. delete pExc;
  549. return;
  550. }
  551. catch(...)
  552. {
  553. LogMsg(LOGF_ERROR,"CFTPDCoreListenSock::OnConnect(%d) - Caught unknown exception", nErrorCode);
  554. return;
  555. }
  557. SetIdleTime(1000 * 60 * 3); // 3 minuts idle time on login
  558. m_Timer.Reset();
  559. }
  561. void CFTPDCoreCtrlSock::_OnConnect( int nErrorCode )
  562. {
  563. CTextSock::OnConnect(nErrorCode);
  565. // Initialize the sockaddr
  566. ASSERT(CFtpDaemonCore::m_pCFtpDaemonCore != NULL);
  567. SOCKADDR_IN *s_in = (SOCKADDR_IN *)&m_Sockaddr;
  568. int Len = sizeof(struct sockaddr);
  569. GetPeerName(&m_Sockaddr,&Len);
  570. s_in->sin_family = AF_INET;
  571. s_in->sin_port = htons(CFtpDaemonCore::m_pCFtpDaemonCore->m_Options.m_Port);
  572. }
  574. void CFTPDCoreCtrlSock::Virgin()
  575. {
  576. CTextSock::Virgin();
  577. }
  579. BOOL CFTPDCoreCtrlSock::ProcessTelnetNegotiation(int ch1, int ch2)
  580. {
  581. return CTextSock::ProcessTelnetNegotiation(ch1, ch2);
  582. }
  584. void CFTPDCoreCtrlSock::InsertPendingText()
  585. {
  586. CTextSock::InsertPendingText();
  587. }
  589. enum // Macro Table 
  590. {
  591. MT_DIRMSG, MT_DISKFREE, MT_USERTYPE, MT_CMAX, MT_CAMAX
  592. };
  594. MACROTABLE BaseMacros[] = 
  595. {
  596. {"diskfree", MT_DISKFREE,"Free disk space in the current directory."},
  597. {"dirmsg", MT_DIRMSG, "Directory change message"},
  598. {"usertype",        MT_USERTYPE,"User type. Anonymous, user or administrator"},
  599. {"maxusers", MT_CMAX, "Max number of users online."},
  600. {"maxanons", MT_CAMAX, "Max number of anonymous users online."},
  601. {"", 0, ""}
  602. };
  604. BOOL CFTPDCoreCtrlSock::ExpandMacro(LPSTR *To, LPCSTR MacroName, int AvailBytes)
  605. {
  606.  if (CTextSock::ExpandMacro(To, MacroName, AvailBytes))
  607. return TRUE;
  609. CString Macro("");
  611. if (*MacroName == '$')
  612. {
  613. for(MACROTABLE *pMT = BaseMacros; *pMT->Name; pMT++)
  614. {
  615. if (!stricmp(pMT->Name, MacroName + 1))
  616. {
  617. switch(pMT->Symb)
  618. {
  619. case MT_USERTYPE:
  620. if (m_IsLoggedInAnonymously)
  621. Macro = "anonymous";
  622. else if (CUsr::IsAdmin(m_User))
  623. Macro = "supervisor";
  624. else
  625. Macro = "user";
  626. break;
  627. case MT_DIRMSG:
  628. {
  629. /*
  630. CString Path;
  631. Path.Format("%s\.message.txt", m_CWD);
  632. CFsys::GetFsys()->DosPath(Path.GetBuffer(1));
  633. Path.ReleaseBuffer();
  634. FILE *fp = fopen(Path,"r");
  635. if (fp)
  636. {
  637. char buf[1024];
  638. while(fgets(buf, sizeof(buf), fp))
  639. Macro += buf;
  640. fclose(fp);
  641. }
  642. */
  643. }
  644. break;
  645. case MT_DISKFREE:
  646. {
  647. /*
  648. CString Path(m_CWD);
  649. CFsys::GetFsys()->DosPath(Path.GetBuffer(1));
  650. Path.ReleaseBuffer();
  651. __int64 MySize = GetFreeDiskSpace(Path);
  652. char buf[128];
  653. sprintf(buf, "%I64d", MySize);
  654. Macro = buf;
  655. */
  656. }
  657. break;
  658. case MT_CAMAX: 
  659. Macro = COptions::GetOption(
  660. COPTION_FTPD_CORE,
  661. FTPDCORE_OPTIONS__MAX_ANON_CONNECTOIONS);
  662. break;
  663. case MT_CMAX:
  664. Macro = COptions::GetOption(
  665. COPTION_FTPD_CORE,
  666. FTPDCORE_OPTIONS__MAX_CONNECTIONS);
  667. break;
  668. default:
  669. Macro.Format("(Macro '%s' is not yet available)", MacroName);
  670. break;
  671. }
  672. break;
  673. }
  674. }
  675. }
  676. else
  677. {
  678. // File name
  679. FILE *fp;
  680. CString Fname;
  681. if (*MacroName == '+')
  682. {
  683. Fname = MacroName + 1;
  684. Macro = "rn";
  685. }
  686. else
  687. Fname = MacroName;
  689. CString Upath;
  692. /*if (strpbrk(Fname,"/\:"))
  693. {
  694. CFsys::GetFsys()->UnixPath(Upath.GetBuffer(1));
  695. Upath.ReleaseBuffer();
  696. CFsys::GetFsys()->MkPath(m_RootDir, m_CWD, Fname, Upath.GetBuffer(MAX_PATH));
  697. if (!CFsys::GetFsys()->CheckPermission(m_User, m_RootDir, Upath, FALSE, NODE_READ))
  698. {
  699. denied:
  700. LogMsg(LOGF_SECURITY,"CFTPDCoreCtrlSock::ExpandMacro(%s) - Permission denied to file!", MacroName);
  701. Macro.Format("(Permission denied to file '%s')", Fname);
  702. goto done;
  703. }
  704. CFsys::GetFsys()->DosPath(Upath.GetBuffer(1));
  705. }
  706. else*/ if (!strnicmp("sysmsg", Fname, 6))
  707. {
  708. Upath = Fname;
  709. }
  710. /*else
  711. goto denied;*/
  713. if (Upath && *Upath)
  714. {
  715. if ((fp = fopen(Upath,"r")) != NULL)
  716. {
  717. {
  718. char buf[512];
  719. while(fgets(buf, sizeof(buf), fp))
  720. Macro += buf;
  721. }
  722. fclose(fp);
  723. int OfsSave = m_InsertOffset;
  724. m_InsertOffset += (*To - &m_OutBuf[CBufferSock::m_BufferUsed]);
  725. SendCtrlMsg(m_LastRcode, Macro, TRUE, FALSE);
  726. *To = &m_OutBuf[CBufferSock::m_BufferUsed];
  727. m_InsertOffset = OfsSave;
  728. return TRUE;
  729. }
  730. else
  731. {
  732. LogMsg(LOGF_DEBUG,"CFTPDCoreCtrlSock::ExpandMacro(%s) - Unable to open file.", MacroName);
  733. return TRUE;
  734. }
  735. }
  736. }
  738. //done:
  739. int Len = Macro.GetLength();
  741. if (Len && (Len < AvailBytes))
  742. {
  743. memcpy(*To, Macro, Len);
  744. *To = *To + Len;
  745. return TRUE;
  746. }
  748. return FALSE;
  749. }
  751. // Return TRUE if the socket still exist
  752. BOOL CFTPDCoreCtrlSock::OnCommand(LPCSTR Text)
  753. {
  754. BOOL DoParseCmdLine = FALSE;
  755. if (!CTextSock::OnCommand(Text))
  756. return FALSE;
  758. m_LastCommandText = Text;
  760. // EXT module
  761. if (PrcSockExt(CSock::iOnCommand,0,(WPARAM)0,(LPARAM)&Text))
  762. return TRUE;
  764. m_Args.PrepereNew();
  765. m_UnixArgs.PrepereNew();
  767. int CmdID = m_Parser.ParseCmd(Text,m_Args, m_State, DoParseCmdLine);
  769. if (DoParseCmdLine)
  770. {
  771. m_Fsys->PrepereCommandLine(CmdID);
  772. return TRUE;
  773. }
  774. else
  775. return OnCommand(CmdID);
  776. }
  778. BOOL CFTPDCoreCtrlSock::OnCommand(int CmdID)
  779. {
  780. BOOL Rval = TRUE;
  781. switch(CmdID)
  782. {
  783. case CMD_USER:
  784. m_Restart = 0; m_ArgSave.Empty();
  785. if (m_User = CUsr::Login(LT_FTP,m_Args[1], NULL, this))
  786. goto logged_in;
  788. m_State = GOTNAME;
  789. m_ArgSave = m_Args[1];
  790. break;
  792. case CMD_PASS:
  793. m_Restart = 0;
  794. logged_in:
  795. if (m_User = CUsr::Login(LT_FTP, m_ArgSave, m_Args[1], this))
  796. {
  797. if (!OnLogin(m_Args))
  798. return FALSE;
  799. SendMsg(230,"User %s logged in. Access restrictions apply.", m_LoginName);
  800. m_State = PROCESS;
  801. }
  802. else
  803. m_State = PRELOGIN; // Try again...
  805. m_ArgSave.Empty();
  806. break;
  808. case CMD_ACCT:
  809. m_Restart = 0; m_ArgSave.Empty();
  810. if (!OnAcct(m_Args))
  811. return FALSE;
  812. break;
  814. case CMD_QUIT:
  815. m_Restart = 0; m_ArgSave.Empty();
  816. if (!OnQuit(m_Args))
  817. return FALSE;
  818. break;
  820. case CMD_REIN:
  821. m_Restart = 0; m_ArgSave.Empty();
  822. if (!OnRein(m_Args))
  823. return FALSE;
  824. break;
  826. case CMD_PORT:
  827. m_ArgSave.Empty();
  828. if (!OnPort(m_Args))
  829. return FALSE;
  830. break;
  832. case CMD_PASV:
  833. m_ArgSave.Empty();
  834. if (!OnPasv(m_Args))
  835. return FALSE;
  836. break;
  838. case CMD_TYPE:
  839. m_ArgSave.Empty();
  840. if (!OnType(m_Args))
  841. return FALSE;
  842. break;
  844. case CMD_STRU:
  845. m_ArgSave.Empty();
  846. if (!OnStru(m_Args))
  847. return FALSE;
  848. break;
  850. case CMD_MODE:
  851. m_ArgSave.Empty();
  852. if (!OnMode(m_Args))
  853. return FALSE;
  854. break;
  856. case CMD_RETR:
  857. m_ArgSave.Empty();
  858. if (!OnRetr(m_Args))
  859. return FALSE;
  860. m_Restart = 0;
  861. break;
  863. case CMD_STOR:
  864. m_ArgSave.Empty();
  865. if (!OnStor(m_Args))
  866. return FALSE;
  867. m_Restart = 0;
  868. break;
  870. case CMD_APPE:
  871. m_ArgSave.Empty();
  872. if (!OnAppe(m_Args))
  873. return FALSE;
  874. m_Restart = 0;
  875. break;
  877. case CMD_ALLO:
  878. m_ArgSave.Empty();
  879. if (!OnAllo(m_Args))
  880. return FALSE;
  881. break;
  883. case CMD_REST:
  884. m_Restart = 0; m_ArgSave.Empty();
  885. if (!OnRest(m_Args))
  886. return FALSE;
  887. break;
  889. case CMD_RNFR:
  890. m_Restart = 0;
  891. m_ArgSave = m_Args[1];
  892. if (!OnRnFr(m_Args))
  893. return FALSE;
  894. break;
  896. case CMD_RNTO:
  897. m_Restart = 0;
  898. if (!OnRnTo(m_Args))
  899. return FALSE;
  900. m_ArgSave.Empty();
  901. break;
  903. case CMD_ABOR:
  904. m_Restart = 0; m_ArgSave.Empty();
  905. if (!OnAbor(m_Args))
  906. return FALSE;
  907. break;
  909. case CMD_DELE:
  910. m_Restart = 0; m_ArgSave.Empty();
  911. if (!OnDele(m_Args))
  912. return FALSE;
  913. break;
  915. case CMD_CWD:
  916. m_Restart = 0; m_ArgSave.Empty();
  917. if (!OnCwd(m_Args))
  918. return FALSE;
  919. break;
  921. case CMD_LIST:
  922. m_Restart = 0; m_ArgSave.Empty();
  923. if (!OnList(m_Args))
  924. return FALSE;
  925. break;
  927. case CMD_NLST:
  928. m_Restart = 0; m_ArgSave.Empty();
  929. if (!OnNlst(m_Args))
  930. return FALSE;
  931. break;
  933. case CMD_SITE:
  934. m_Restart = 0; m_ArgSave.Empty();
  935. if (!OnSite(m_Args))
  936. return FALSE;
  937. break;
  939. case CMD_STAT:
  940. m_Restart = 0; m_ArgSave.Empty();
  941. if (!OnStat(m_Args))
  942. return FALSE;
  943. break;
  945. case CMD_HELP:
  946. m_Restart = 0; m_ArgSave.Empty();
  947. if (!OnHelp(m_Args))
  948. return FALSE;
  949. break;
  951. case CMD_NOOP:
  952. m_Restart = 0; m_ArgSave.Empty();
  953. if (!OnNoop(m_Args))
  954. return FALSE;
  955. break;
  957. case CMD_MKD:
  958. m_Restart = 0; m_ArgSave.Empty();
  959. if (!OnMkd(m_Args))
  960. return FALSE;
  961. break;
  963. case CMD_RMD:
  964. m_Restart = 0; m_ArgSave.Empty();
  965. if (!OnRmd(m_Args))
  966. return FALSE;
  968. case CMD_PWD:
  969. m_Restart = 0; m_ArgSave.Empty();
  970. if (!OnPwd(m_Args))
  971. return FALSE;
  972. break;
  974. case CMD_CDUP:
  975. m_Restart = 0; m_ArgSave.Empty();
  976. if (!OnCdUp(m_Args))
  977. return FALSE;
  978. break;
  980. case CMD_STOU:
  981. m_Restart = 0; m_ArgSave.Empty();
  982. if (!OnStou(m_Args))
  983. return FALSE;
  984. break;
  986. case CMD_SMNT:
  987. m_Restart = 0; m_ArgSave.Empty();
  988. if (!OnSmnt(m_Args))
  989. return FALSE;
  990. break;
  992. case CMD_SYST:
  993. m_Restart = 0; m_ArgSave.Empty();
  994. if (!OnSyst(m_Args))
  995. return FALSE;
  996. break;
  998. case CMD_SIZE:
  999. m_ArgSave.Empty();
  1000. if (!OnSize(m_Args))
  1001. return FALSE;
  1002. break;
  1004. case CMD_MDTM:
  1005. m_ArgSave.Empty();
  1006. if (!OnMdtm(m_Args))
  1007. return FALSE;
  1008. break;
  1010. // SITE commands
  1011. case CMD_CHMOD:
  1012. m_Restart = 0; m_ArgSave.Empty();
  1013. if (!OnSiteChmod(m_Args))
  1014. return FALSE;
  1015. break;
  1017. case CMD_FSYSSTAT:
  1018. m_Restart = 0; m_ArgSave.Empty();
  1019. if (!OnSiteFsysstat(m_Args))
  1020. return FALSE;
  1021. break;
  1023. // Command errors
  1024. case CMD_MISSING_PARAMETER:
  1025. SendMsg(501,"Missing parameter in command %s", m_LastCommandText);
  1026. break;
  1027. case CMD_UNKNOWN_COMMAND:
  1028. SendMsg(500, "%s: unrecognized command.", m_LastCommandText);
  1029. break;
  1030. case CMD_NOT_IMPLEMENTED:
  1031. SendMsg(502, "%s: command not implemented.", m_LastCommandText);
  1032. break;
  1033. case CMD_BAD_LEVEL:
  1034. m_Restart = 0; m_ArgSave.Empty();
  1035. SendMsg(530, "Please login with USER and PASS.");
  1036. break;
  1037. case CMD_PARSE_ERROR:
  1038. case CMD_UNKNOWN_PARAMETER:
  1039. SendMsg(500,"'%s': command not understood.", m_LastCommandText);
  1040. break;
  1041. default:
  1042. SendMsg(502,"%s: Command not implemented.", m_Args[0]);
  1043. break;
  1044. }
  1046. m_PrevCmdID = CmdID;
  1047. return Rval;
  1048. }
  1050. /////////////////////////////////////////////////////////////////////////////////
  1051. // FTP server implementation functions
  1053. BOOL CFTPDCoreCtrlSock::OnQuit(CCmdArgs& Args)
  1054. {
  1055. SendCtrlMsg(221, "Goodbye.");
  1056. LogMsg(LOGF_INOUT,"User from %s logging off.", m_PeerName);
  1057. CSocketException::Throw(this, "CFTPDCoreCtrlSock::OnQuit()", 0, "User logged out");
  1058. return FALSE; // Socket is deleted
  1059. }
  1061. BOOL CFTPDCoreCtrlSock::OnLogin(CCmdArgs& Args)
  1062. {
  1064. // Set idle time
  1065. SetIdleTime(CUsr::GetRecursiveParam(m_User, "IdleTime", 3 * 60) * 1000);
  1066. SetLogonTime(CUsr::GetRecursiveParam(m_User, "LoginTime", 0) * 60000);
  1068. NotifyLogin(ENL_UPDATE, "");
  1070. m_Fsys = new CFTPDFsys((LPVOID *)&m_Fsys);
  1072. if (!m_Fsys->Create(this))
  1073. {
  1074. delete m_Fsys;
  1075. m_Fsys = NULL;
  1076. SendMsg(421, "Internal error - unable to initialize your file system. Goodbye");
  1077. LogMsg(LOGF_ERROR,"Unable to initialize the users file system.");
  1078. CSocketException::Throw(this, "CFTPDCoreCtrlSock::OnLogin()", 0, "Unable to initialize file system");
  1079. }
  1081. return TRUE;
  1082. }
  1084. BOOL CFTPDCoreCtrlSock::OnAcct(CCmdArgs& Args)
  1085. {
  1086. SendMsg(200,"ACCT Command ok.");
  1087. return TRUE;
  1088. }
  1090. BOOL CFTPDCoreCtrlSock::OnRein(CCmdArgs& Args)
  1091. {
  1092. SendMsg(502,"%s: Command not implemented.", m_Args[0]);
  1093. return TRUE;
  1094. }
  1096. BOOL CFTPDCoreCtrlSock::OnPort(CCmdArgs& Args)
  1097. {
  1098. SOCKADDR_IN *s_in = (SOCKADDR_IN *)&m_Sockaddr;
  1099. SOCKADDR_IN sin;
  1100. int i1, i2, i3, i4, i5, i6;
  1103. if (sscanf(m_Args[1],"%d,%d,%d,%d,%d,%d", &i1, &i2, &i3, &i4, &i5, &i6) != 6)
  1104. {
  1105. SendMsg(501,"'%s': Must be 6 digits.", Args.Arg(1));
  1106. return TRUE;
  1107. }
  1109. sin.sin_addr.S_un.S_un_b.s_b1 = (unsigned char)i1;
  1110. sin.sin_addr.S_un.S_un_b.s_b2 = (unsigned char)i2;
  1111. sin.sin_addr.S_un.S_un_b.s_b3 = (unsigned char)i3;
  1112. sin.sin_addr.S_un.S_un_b.s_b4 = (unsigned char)i4;
  1113. sin.sin_port = htons((i5 << 8) | i6);
  1115. if ((ntohs(sin.sin_port) > 1023) && (s_in->sin_addr.s_addr > 0)) 
  1116. {
  1117. SendMsg(200, "PORT command successful.");
  1118. s_in->sin_addr.S_un.S_addr = sin.sin_addr.S_un.S_addr;
  1119. s_in->sin_port = sin.sin_port;
  1120. }
  1121. else 
  1122. {
  1123. LogMsg(LOGF_SECURITY, "CFTPDCoreCtrlSock::OnPort(%s): refused PORT %lX,%d", 
  1124. Args.Arg(1), sin.sin_addr.s_addr, ntohs(sin.sin_port));
  1125. SendMsg(500, "Illegal PORT Command");
  1126. }
  1128. LogMsg(LOGF_DEBUG,"OnPort(%s): PORT %lX,%d.", Args.Arg(1), sin.sin_addr.s_addr, ntohs(sin.sin_port));
  1130. return TRUE;
  1131. }
  1133. BOOL CFTPDCoreCtrlSock::OnPasv(CCmdArgs& Args)
  1134. {
  1135. return m_DataSock->Create(this, &m_DataSock, m_FTPmode, m_FTPstru, m_FTPform, 
  1136. m_FTPtype, &m_Sockaddr, TRUE);
  1137. }
  1139. BOOL CFTPDCoreCtrlSock::OnType(CCmdArgs& Args)
  1140. {
  1141. // Parse the type.
  1142. int cmd_form, cmd_type, cmd_bytesz, TokenID;
  1143. LPCSTR LexCmdLine = Args.Arg(1);
  1145. TokenID = m_Parser.yyLex(&LexCmdLine, m_Parser.m_Tokens, ' ', LEX_WANT_CHAR, Args);
  1146. if (TokenID != TOK_CHAR)
  1147. {
  1148. unknown_type:
  1149. SendMsg(501,"'%s %s': unknown type.", Args.Arg(0), Args.Arg(1));
  1150. return TRUE;
  1151. }
  1153. ASSERT(Args.m_argc == 3);
  1154. switch(toupper(*Args.Arg(2)))
  1155. {
  1156. case 'A':
  1157. cmd_type = TYPE_A;
  1158. cmd_form = FORM_N;
  1159. // Check for form parameter
  1160. check_form:
  1161. TokenID = m_Parser.yyLex(&LexCmdLine, m_Parser.m_Tokens, ' ', LEX_WANT_CHAR, Args);
  1162. if (TokenID == TOK_CHAR)
  1163. {
  1164. ASSERT(Args.m_argc == 4);
  1165. switch(toupper(*Args.Arg(3)))
  1166. {
  1167. case 'N': cmd_form = FORM_N; break;
  1168. case 'T': cmd_form = FORM_T; break;
  1169. case 'C': cmd_form = FORM_C; break;
  1170. default:
  1171. SendMsg(501,"'%s %s': unknown form (%s).", Args.Arg(0), Args.Arg(1), Args.Arg(3));
  1172. return TRUE;
  1173. }
  1174. }
  1175. // Validiate...
  1176. if (cmd_form == FORM_N) 
  1177. {
  1178. SendMsg(200, "Type set to A.");
  1179. m_FTPtype = cmd_type;
  1180. m_FTPform = cmd_form;
  1181. } 
  1182. else
  1183. SendMsg(504, "Form must be N.");
  1184. break;
  1186. case 'E':
  1187. SendMsg(504, "Type E not implemented.");
  1188. goto check_form;
  1190. case 'I':
  1191. SendMsg(200, "Type set to I.");
  1192. m_FTPtype = TYPE_I;
  1193. break;
  1195. case 'L':
  1196. cmd_bytesz = 8;
  1197. cmd_type = TYPE_L;
  1199. // Check for bytesize parameter
  1200. TokenID = m_Parser.yyLex(&LexCmdLine, m_Parser.m_Tokens, ' ', LEX_WANT_INT, Args);
  1201. if (TokenID == TOK_CHAR)
  1202. {
  1203. ASSERT(Args.m_argc == 4);
  1204. cmd_bytesz = atoi(Args.Arg(3));
  1205. }
  1206. else if (atoi(Args.Arg(2) + 1))
  1207. {
  1208. // This is for a bug in the BBN ftp 
  1209. cmd_bytesz = atoi(Args.Arg(2) + 1);
  1210. }
  1212. if (cmd_bytesz == 8)
  1213. {
  1214. SendMsg(200, "Type set to L (byte size 8).");
  1215. m_FTPtype = cmd_type;
  1216. } 
  1217. else
  1218. SendMsg(504, "Byte size must be 8.");
  1219. break;
  1221. default:
  1222. goto unknown_type;
  1223. }
  1225. return TRUE;
  1226. }
  1228. BOOL CFTPDCoreCtrlSock::OnStru(CCmdArgs& Args)
  1229. {
  1230. int TokenID;
  1231. LPCSTR LexCmdLine = Args.Arg(1);
  1233. TokenID = m_Parser.yyLex(&LexCmdLine, m_Parser.m_Tokens, ' ', LEX_WANT_CHAR, Args);
  1234. if (TokenID != TOK_CHAR)
  1235. {
  1236. SendMsg(501,"'%s %s': unknown struct.", Args.Arg(0), Args.Arg(1));
  1237. return TRUE;
  1238. }
  1240. ASSERT(Args.m_argc == 3);
  1241. switch(toupper(*Args.Arg(2)))
  1242. {
  1243. case 'F':
  1244. m_FTPstru = STRU_F;
  1245. SendMsg(200, "STRU F ok.");
  1246. break;
  1248. default:
  1249. SendMsg(504, "Unimplemented STRU type.");
  1250. return TRUE;
  1251. }
  1252. return TRUE;
  1253. }
  1255. BOOL CFTPDCoreCtrlSock::OnMode(CCmdArgs& Args)
  1256. {
  1257. int TokenID;
  1258. LPCSTR LexCmdLine = Args.Arg(1);
  1260. TokenID = m_Parser.yyLex(&LexCmdLine, m_Parser.m_Tokens, ' ', LEX_WANT_CHAR, Args);
  1261. if (TokenID != TOK_CHAR)
  1262. {
  1263. SendMsg(501,"'%s %s': unknown mode.", Args.Arg(0), Args.Arg(1));
  1264. return TRUE;
  1265. }
  1267. ASSERT(Args.m_argc == 3);
  1268. switch(toupper(*Args.Arg(2)))
  1269. {
  1270. case 'S':
  1271. m_FTPmode = MODE_S;
  1272. SendMsg(200, "MODE S ok.");
  1273. break;
  1275. default:
  1276. SendMsg(504, "Unimplemented MODE type.");
  1277. return TRUE;
  1278. }
  1279. return TRUE;
  1280. }
  1282. BOOL CFTPDCoreCtrlSock::OnRetr(CCmdArgs& Args)
  1283. {
  1284. return DoRetr(Args, 0);
  1285. }
  1287. BOOL CFTPDCoreCtrlSock::OnStor(CCmdArgs& Args)
  1288. {
  1289. return DoStor(Args, 0);
  1290. }
  1292. BOOL CFTPDCoreCtrlSock::OnAppe(CCmdArgs& Args)
  1293. {
  1294. return DoStor(Args, XMITF_APPE);
  1295. }
  1297. BOOL CFTPDCoreCtrlSock::OnAllo(CCmdArgs& Args)
  1298. {
  1299. SendMsg(502,"%s: Command not implemented.", Args.Arg(0));
  1300. return TRUE;
  1301. }
  1303. BOOL CFTPDCoreCtrlSock::OnRest(CCmdArgs& Args)
  1304. {
  1305. m_Restart = atoi(Args.Arg(1));
  1307. SendMsg(350, "Restarting at byte offset %u. Send STORE or RETRIEVE to initiate transfer.", 
  1308. m_Restart);
  1309. return TRUE;
  1310. }
  1312. BOOL CFTPDCoreCtrlSock::OnRnFr(CCmdArgs& Args)
  1313. {
  1315. if (m_UnixArgs.m_argc != 2)
  1316. {
  1317. LogMsg(LOGF_DEBUG,"OnRnFr() - Ambigous RNFR command: %s", Args[1]);
  1318. SendMsg(550,"Ambigous RNFR command: %s", Args[1]);
  1319. return TRUE;
  1320. }
  1322. m_ArgSave = m_UnixArgs[1];
  1323. SendMsg(350, "RNFR Ok. Ready for destination name.");
  1324. return TRUE;
  1325. }
  1327. BOOL CFTPDCoreCtrlSock::OnRnTo(CCmdArgs& Args)
  1328. {
  1329. CString cFnameBuf;
  1330. if (m_PrevCmdID != CMD_RNFR)
  1331. {
  1332. SendMsg(503,"Bad sequence of commands.");
  1333. return TRUE;
  1334. }
  1336. if (m_UnixArgs.m_argc != 2)
  1337. {
  1338. LogMsg(LOGF_DEBUG,"OnRnTo() - Ambigous RNFR command: %s", m_UnixArgs[1]);
  1339. SendMsg(550,"Ambigous RNFR command: %s", m_UnixArgs[1]);
  1340. return TRUE;
  1341. }
  1343. ASSERT(AfxIsValidString(m_ArgSave));
  1345. if (!m_Fsys->MoveFile(m_ArgSave, m_UnixArgs[1]))
  1346. {
  1347. LogMsg(LOGF_DEBUG,"OnRnTo() - RenamePath(%s,%s) failed before callback.", m_ArgSave, cFnameBuf);
  1348. SendMsg(550,"Permission denied.");
  1349. return TRUE;
  1350. }
  1352. return TRUE;
  1353. }
  1355. BOOL CFTPDCoreCtrlSock::OnAbor(CCmdArgs& Args)
  1356. {
  1357. if (m_DataSock)
  1358. {
  1359. ASSERT(AfxIsValidAddress(m_DataSock,sizeof(CFTPDataSock)));
  1360. m_DataSock->m_HaveToldUserThatTransfereIsComplete = TRUE;
  1361. delete m_DataSock;
  1362. }
  1363. SendMsg(225, "ABOR command successful.");
  1364. return TRUE;
  1365. }
  1367. BOOL CFTPDCoreCtrlSock::OnDele(CCmdArgs& Args)
  1368. {
  1369. return DoDele(Args);
  1370. }
  1372. BOOL CFTPDCoreCtrlSock::OnCwd(CCmdArgs& Args)
  1373. {
  1374. // Expand the command line to allow "CD war*"
  1377. if (m_UnixArgs.m_argc > 2)
  1378. {
  1379. // The pattern matching routines returned more than one path...
  1380. SendMsg(550,"Ambigous CWD command.");
  1381. }
  1382. else if (!DoChdir((m_UnixArgs.m_argc == 2) ? m_UnixArgs.Arg(1) : NULL))
  1383. {
  1384. // Failed
  1385. SendMsg(550,"Permission denied.");
  1386. }
  1388. return TRUE;
  1389. }
  1391. BOOL CFTPDCoreCtrlSock::OnList(CCmdArgs& Args)
  1392. {
  1393. return ProcessList("-lAf", Args);
  1394. }
  1396. BOOL CFTPDCoreCtrlSock::OnNlst(CCmdArgs& Args)
  1397. {
  1398. return ProcessList("", Args);
  1399. }
  1401. BOOL CFTPDCoreCtrlSock::OnSite(CCmdArgs& Args)
  1402. {
  1403. // EXT module
  1404. if (PrcSockExt(CSock::iOnSITECmd,0,(WPARAM)0,(LPARAM)&Args))
  1405. return TRUE;
  1407. SendMsg(502,"%s: Command not implemented.", Args.Arg(0));
  1408. return TRUE;
  1409. }
  1411. BOOL CFTPDCoreCtrlSock::OnStat(CCmdArgs& Args)
  1412. {
  1413. if (Args.m_argc == 2)
  1414. {
  1415. // STAT path command
  1416. SendMsg(504,"STAT <path> command not implemented.");
  1417. return TRUE;
  1418. }
  1419. else
  1420. {
  1421. CWarString cBuf;
  1422. ASSERT(Args.m_argc == 1);
  1423. // Stat command without 
  1424. SendCtrlMsg(211,"[$systemname] FTP server status:", TRUE, FALSE);
  1425. SendMsg(0,"n     Version [$programname] [$programversion]");
  1427. if (!isdigit(m_DNSName[0]))
  1428. cBuf.Format("%s (%s)", m_DNSName, m_PeerName);
  1429. else
  1430. cBuf.Format("%s", m_DNSName);
  1431. SendMsg(0,"     Connected to %s", cBuf);
  1433. if (m_State >= PROCESS)
  1434. {
  1435. if (m_IsLoggedInAnonymously)
  1436. SendMsg(0, "     Logged in anonymously");
  1437. else
  1438. SendMsg(0, "     Logged in as %s", m_LoginName);
  1439. }
  1440. else if (m_State == GOTNAME)
  1441. SendMsg(0, "     Waiting for password");
  1442. else if (m_State == PRELOGIN)
  1443. SendMsg(0, "     Waiting for user name");
  1444. else
  1445. SendMsg(0, "     Unknown internal state %d", m_Type);
  1446.     
  1447. cBuf.Format("     TYPE: %s", SafeStringIndex(typenames, m_FTPtype, 5));
  1448. if ((m_FTPtype == TYPE_A) || (m_FTPtype == TYPE_E))
  1449. cBuf.FormatCat(", FORM: %s", SafeStringIndex(formnames, m_FTPform, 4));
  1450.     if (m_FTPtype == TYPE_L)
  1451.         cBuf.FormatCat(" %d", 8);
  1452.     cBuf.FormatCat("; STRUcture: %s; transfer MODE: %s", 
  1453. SafeStringIndex(strunames, m_FTPstru, 4), SafeStringIndex(modenames,m_FTPmode, 4));
  1454. SendMsg(0, "%s", cBuf);
  1456.     if (m_DataSock)
  1457.         SendMsg(0, "     Data connection ready/open"); 
  1458. else
  1459.         SendMsg(0, "     No data connection");
  1460.     SendMsg(211, "End of status");
  1461. }
  1462. return TRUE;
  1463. }
  1465. BOOL CFTPDCoreCtrlSock::OnHelp(CCmdArgs& Args)
  1466. {
  1467. CString cBuf = "";
  1468. STokenTabDef *Token;
  1469. SCommandTreeDef *Cmd;
  1470. int Index = 0;
  1472. if (Args.m_argc == 2)
  1473. {
  1474. LPCSTR CmdName = Args.Arg(1);
  1475. // Help on a command
  1476. for(Token = BaseTokens; Token->TokenID != TOK_INVALID; Token++)
  1477. {
  1478. // Lookup cmd
  1479. if (!stricmp(CmdName,Token->Token))
  1480. {
  1481. for(Cmd = BaseCmds; Cmd->CommandID != CMD_INVALID; Cmd++)
  1482. {
  1483. if (Cmd->TokenID == Token->TokenID)
  1484. {
  1485. SendMsg(214,"Syntax: %s", Cmd->CommandSyntax);
  1486. break;
  1487. }
  1488. }
  1489. break;
  1490. }
  1491. }
  1492. if (!Cmd || !Token)
  1493. SendMsg(502,"Unknown command %s", CmdName);
  1494. }
  1495. else
  1496. {
  1497. // Just list all commands
  1498. SendCtrlMsg(214, "The following commands are recognized. (* =>'s unimplemented)", TRUE);
  1499. SendCtrlMsg(0,"n", TRUE, FALSE);
  1500. for(Token = BaseTokens; Token->TokenID != TOK_INVALID; Token++)
  1501. {
  1502. // Lookup cmd
  1503. for(Cmd = BaseCmds; Cmd->CommandID != CMD_INVALID; Cmd++)
  1504. {
  1505. if (Cmd->TokenID == Token->TokenID)
  1506. {
  1507. cBuf += "   ";
  1508. cBuf += Token->Token;
  1509. cBuf += (Cmd->Flags & CMDF_NOT_IMPLEMENTED) ? '*' : ' ';
  1511. if (strlen(Token->Token) == 3)
  1512. cBuf += ' ';
  1514. if (!(++Index % 8))
  1515. {
  1516. cBuf += 'n';
  1517. SendCtrlMsg(0, cBuf, TRUE);
  1518. cBuf = "";
  1519. }
  1520. break;
  1521. }
  1522. }
  1523. }
  1524. if (cBuf.GetLength())
  1525. {
  1526. cBuf += 'n';
  1527. SendCtrlMsg(0, cBuf, TRUE);
  1528. }
  1529. SendMsg(214, "Direct comments to [$email]");
  1530. }
  1531. return TRUE;
  1532. }
  1534. BOOL CFTPDCoreCtrlSock::OnNoop(CCmdArgs& Args)
  1535. {
  1536. SendMsg(200, "NOOP command successful.");
  1537. return TRUE;
  1538. }
  1540. BOOL CFTPDCoreCtrlSock::OnMkd(CCmdArgs& Args)
  1541. {
  1542. return DoMkDir(Args);
  1543. }
  1545. BOOL CFTPDCoreCtrlSock::OnRmd(CCmdArgs& Args)
  1546. {
  1547. return DoDele(Args);
  1548. }
  1550. BOOL CFTPDCoreCtrlSock::OnPwd(CCmdArgs& Args)
  1551. {
  1552. SendMsg(257, ""%s" is current directory.", m_Fsys->m_CWD);
  1553. return TRUE;
  1554. }
  1556. BOOL CFTPDCoreCtrlSock::OnCdUp(CCmdArgs& Args)
  1557. {
  1558. m_UnixArgs.AddArg("CD");
  1559. m_UnixArgs.AddArg("..");
  1560. OnCwd(Args);
  1561. return TRUE;
  1562. }
  1564. BOOL CFTPDCoreCtrlSock::OnStou(CCmdArgs& Args)
  1565. {
  1566. return DoStor(Args, XMITF_UNIQUE);
  1567. }
  1569. BOOL CFTPDCoreCtrlSock::OnSmnt(CCmdArgs& Args)
  1570. {
  1571. SendMsg(502,"%s: Command not implemented.", Args.Arg(0));
  1572. return TRUE;
  1573. }
  1575. BOOL CFTPDCoreCtrlSock::OnSyst(CCmdArgs& Args)
  1576. {
  1577. SendMsg(215, "UNIX Type: L8 Server: "War FTPD light 2.01a" OS: "%s"", OsName());
  1578. return TRUE;
  1579. }
  1581. BOOL CFTPDCoreCtrlSock::OnSize(CCmdArgs& Args)
  1582. {
  1584. CString cBuf, cFnameBuf;
  1586. switch(m_FTPtype)
  1587. {
  1588. case TYPE_L:
  1589.     case TYPE_I:
  1590. case TYPE_A:
  1591. {
  1592. if (m_UnixArgs.m_argc != 2)
  1593. {
  1594. LogMsg(LOGF_DEBUG,"OnSize() - Ambigous SIZE command: %s", Args.Arg(1));
  1595. SendMsg(550,"Ambigous SIZE command: %s", Args.Arg(1));
  1596. return TRUE;
  1597. }
  1599. if (!m_Fsys->Size(m_UnixArgs[1]))
  1600. {
  1601. LogMsg(LOGF_DEBUG,"OnSize() - FindFirstFile(%s) failed before callback.", m_UnixArgs[1]);
  1602. SendMsg(451,"Server error.");
  1603. }
  1604. }
  1605. break;
  1606. default:
  1607. SendMsg(504, "SIZE not implemented for Type %c.", "?AEIL"[max((unsigned)m_FTPtype, 5)]);
  1608. }
  1609. return TRUE;
  1610. }
  1612. /*
  1613.  * MDTM is not in RFC959, but Postel has blessed it and
  1614.  * it will be in the updated RFC.
  1615.  *
  1616.  * Return modification time of file as an ISO 3307
  1617.  * style time. E.g. YYYYMMDDHHMMSS or YYYYMMDDHHMMSS.xxx
  1618.  * where xxx is the fractional second (of any precision,
  1619.  * not necessarily 3 digits)
  1620.  */
  1622. BOOL CFTPDCoreCtrlSock::OnMdtm(CCmdArgs& Args)
  1623. {
  1624. if (m_UnixArgs.m_argc != 2)
  1625. {
  1626. LogMsg(LOGF_DEBUG,"OnMdtm() - Ambigous SIZE command: %s", Args.Arg(1));
  1627. SendMsg(550,"Ambigous SIZE command: %s", Args.Arg(1));
  1628. return TRUE;
  1629. }
  1631. if (!m_Fsys->Mdtm(m_UnixArgs[1]))
  1632. {
  1633. LogMsg(LOGF_DEBUG,"Mdtm(%s) - failed before callback.", m_UnixArgs[1]);
  1634. SendMsg(451,"Server error.");
  1635. return TRUE;
  1636. }
  1638. return TRUE;
  1639. }
  1644. ///////////////////////////////////////////////////////////////////////////////
  1645. // Support functions
  1648. // Process LIST and NLST commands.
  1649. BOOL CFTPDCoreCtrlSock::ProcessList(LPCSTR LineArguments, CCmdArgs& Args)
  1650. {
  1651. CString cBuf;
  1652. static LPSTR Cmd = "/bin/ls";
  1654. m_UnixArgs.Replace(0,Cmd);
  1655. if (LineArguments && *LineArguments)
  1656. m_UnixArgs.Insert(1,LineArguments);
  1658. m_Fsys->m_FsysPath3 = LineArguments ? LineArguments : "";
  1660. return m_Fsys->List();
  1661. }
  1663. BOOL CFTPDCoreCtrlSock::CallbackProcessList(int nErrorCode)
  1664. {
  1665. if (nErrorCode)
  1666. {
  1667. SendMsg(550, "Failed to execute %s, error code %d.", m_UnixArgs.Arg(0), nErrorCode);
  1668. LogMsg(LOGF_WARNINGS,"ProcessList() - Failed to execute %s, error code %d.", m_UnixArgs.Arg(0), nErrorCode);
  1669. return TRUE;
  1670. }
  1672. if (!m_DataSock->Create(this, &m_DataSock, m_FTPmode, m_FTPstru, m_FTPform, m_FTPtype, &m_Sockaddr, FALSE))
  1673. {
  1674. ASSERT(AfxIsValidAddress(m_DataSock, sizeof(CFTPDataSock)));
  1675. LogMsg(LOGF_WARNINGS,"ProcessList() - Failed to create data socket.");
  1676. return TRUE;
  1677. }
  1679. CString cBuf;
  1680. cBuf.Format("%s%s%s", m_UnixArgs.Arg(0), m_Fsys->m_FsysPath3.IsEmpty() ? "" : " ", m_Fsys->m_FsysPath3);
  1682. try
  1683. {
  1684. if (!m_DataSock->SendFile(m_Fsys->m_FsysPath2, cBuf, TRUE, m_Restart, 0))
  1685. {
  1686. // SendFile() has already told the user the reason for this and destroyed the socket...
  1687. LogMsg(LOGF_DEBUG,"ProcessList() - SendFile() failed.");
  1688. return TRUE;
  1689. }
  1690. }
  1691. catch(CSocketException *pExc)
  1692. {
  1693. LogMsg(LOGF_DEBUG,"CFTPDCoreCtrlSock::CallbackProcessList(%d) - Caught exception '%s' from module %s",
  1694. nErrorCode, pExc->m_ErrorText, pExc->m_ErrorText);
  1696. if (pExc->m_pSock == (CSock *)m_DataSock)
  1697. {
  1698. delete m_DataSock;
  1699. m_DataSock = NULL;
  1700. delete pExc;
  1701. return FALSE;
  1702. }
  1704. throw pExc; // We can't handle this...
  1705. }
  1707. return TRUE;
  1708. }
  1710. // Change directory. Does not inform user about errors.
  1711. BOOL CFTPDCoreCtrlSock::DoChdir(LPCSTR Path)
  1712. {
  1713. return m_Fsys->ChDir(Path);
  1714. }
  1716. // Send a file to the remote host
  1717. BOOL CFTPDCoreCtrlSock::DoRetr(CCmdArgs& Args, DWORD Flags)
  1718. {
  1720. CString cBuf, cFnameBuf;
  1722. if (m_UnixArgs.m_argc > 2)
  1723. {
  1724. LogMsg(LOGF_DEBUG,"DoRetr() - Ambigous RETR command: %s", Args.Arg(1));
  1725. SendMsg(550,"Ambigous RETR command: %s", Args.Arg(1));
  1726. return TRUE;
  1727. }
  1729. if (!m_DataSock->Create(this, &m_DataSock, m_FTPmode, m_FTPstru, m_FTPform, m_FTPtype, &m_Sockaddr, FALSE))
  1730. {
  1731. ASSERT(AfxIsValidAddress(m_DataSock, sizeof(CFTPDataSock)));
  1732. LogMsg(LOGF_WARNINGS,"DoRetr() - Failed to create data socket.");
  1733. return TRUE;
  1734. }
  1736. m_DataSock->m_pFile = new CWarFile(m_Fsys);
  1738. ASSERT((Flags & XMITF_APPE) == 0);
  1740. if (!m_DataSock->SendFile(m_UnixArgs.Arg(1), cBuf, Flags & XMITF_TEMP, m_Restart, 0))
  1741. {
  1742. // SendFile() has already told the user the reason for this and destroyed the socket...
  1743. LogMsg(LOGF_DEBUG,"DoRetr() - SendFile() failed.");
  1744. return TRUE;
  1745. }
  1747. return TRUE;
  1748. }
  1750. // Receive a file from the remote host
  1751. BOOL CFTPDCoreCtrlSock::DoStor(CCmdArgs& Args, DWORD Flags)
  1752. {
  1754. CString cBuf, cFnameBuf;
  1755. DWORD FTPflags = 0;
  1757. if (m_UnixArgs.m_argc > 2)
  1758. {
  1759. LogMsg(LOGF_DEBUG,"DoStor() - Ambigous STOR command: %s", Args.Arg(1));
  1760. SendMsg(550,"Ambigous RETR command: %s", Args.Arg(1));
  1761. return TRUE;
  1762. }
  1764. // Handle unique
  1765. if (Flags & XMITF_UNIQUE)
  1766. {
  1767. FTPflags |= CWarFile::UNIQUE_NAME;
  1768. }
  1770. // Handle for APPEND mode
  1771. if (Flags & XMITF_APPE)
  1772. {
  1773. if (m_Restart)
  1774. {
  1775. LogMsg(LOGF_DEBUG,"DoStor() - Can't combine APPE and REST");
  1776. SendMsg(550,"Can't combine APPE and REST");
  1777. return TRUE;
  1778. }
  1779. m_Restart = FLEN_MAX;
  1780. }
  1782. if (!m_DataSock->Create(
  1783. this, &m_DataSock, m_FTPmode, m_FTPstru, m_FTPform, m_FTPtype, &m_Sockaddr, FALSE, FTPflags))
  1784. {
  1785. ASSERT(AfxIsValidAddress(m_DataSock, sizeof(CFTPDataSock)));
  1786. LogMsg(LOGF_WARNINGS,"DoRetr() - Failed to create data socket.");
  1787. return TRUE;
  1788. }
  1790. m_DataSock->m_pFile = new CWarFile(m_Fsys);
  1792. if (!m_DataSock->ReceiveFile(m_UnixArgs.Arg(1), cBuf, 0, m_Restart, 0))
  1793. {
  1794. // ReceiveFile() has already told the user the reason for this and destroyed the socket...
  1795. LogMsg(LOGF_DEBUG,"DoStor() - ReceiveFile() failed.");
  1796. return TRUE;
  1797. }
  1799. return TRUE;
  1800. }
  1803. BOOL CFTPDCoreCtrlSock::MkUniquePath(CString& cFnameBuf)
  1804. {
  1805. ASSERT(AfxIsValidString(cFnameBuf));
  1806. CString cBuf = cFnameBuf;
  1807. HANDLE h;
  1808. int cnt = 0;
  1810. while((h = CreateFile(
  1811. cBuf,
  1812. GENERIC_WRITE,
  1813. 0,
  1814. NULL,
  1815. CREATE_NEW,
  1816. FILE_FLAG_DELETE_ON_CLOSE,
  1817. NULL)) == INVALID_HANDLE_VALUE)
  1818. {
  1819. int err;
  1820. if ((err = GetLastError()) != ERROR_FILE_EXISTS)
  1821. {
  1822. LogMsg(LOGF_DEBUG,"MkUniquePath(%s) - Got unexpected error: %s.", 
  1823. cFnameBuf, GetLastErrorText(err));
  1824. return FALSE;
  1825. }
  1827. if (++cnt > 20)
  1828. {
  1829. LogMsg(LOGF_DEBUG,"MkUniquePath(%s) - Failed. Tried %d names.", 
  1830. cFnameBuf, cnt - 1);
  1831. return FALSE;
  1832. }
  1834. cBuf.Format("%s%d", cFnameBuf, cnt);
  1835. }
  1837. ASSERT(h != INVALID_HANDLE_VALUE);
  1838. CloseHandle(h);
  1839. LogMsg(LOGF_DEBUG,"MkUniquePath(%s) - Found unique filename: %s.", 
  1840. cFnameBuf, cBuf);
  1841. cFnameBuf = cBuf;
  1843. return TRUE;
  1844. }
  1847. BOOL CFTPDCoreCtrlSock::DoDele(CCmdArgs& Args)
  1848. {
  1849. if (m_UnixArgs.m_argc != 2)
  1850. {
  1851. LogMsg(LOGF_DEBUG,"DoDele() - Ambigous %s command: %s", Args[0], m_UnixArgs[1]);
  1852. SendMsg(550,"Ambigous %s command: %s", Args[0], m_UnixArgs[1]);
  1853. return TRUE;
  1854. }
  1856. if (!m_Fsys->DeleteGeneric(m_UnixArgs[1]))
  1857. {
  1858. LogMsg(LOGF_DEBUG,"DoDele() - Failed to delete before callback: %s", Args[1]);
  1859. SendMsg(550,"Server error. Failed to delete.");
  1860. return TRUE;
  1861. }
  1862. return TRUE;
  1863. }
  1865. BOOL CFTPDCoreCtrlSock::DoMkDir(CCmdArgs& Args)
  1866. {
  1867. if (!m_Fsys->CreateDirectory(Args[1]))
  1868. {
  1869. LogMsg(LOGF_DEBUG,"DoMkDir() - Failed to create directory before callback: %s", Args.Arg(1));
  1870. SendMsg(550,"Server error. Failed to cerate directory.");
  1871. }
  1873. return TRUE;
  1874. }
  1876. BOOL CFTPDCoreCtrlSock::OnSiteChmod(CCmdArgs &Args)
  1877. {
  1878. CCmdArgs MyArgs("chmod", Args[2], m_Parser);
  1880. if (!m_Fsys->ChMod(MyArgs))
  1881. {
  1882. SendMsg(451, "chmod failed.");
  1883. LogMsg(LOGF_WARNINGS,"chmod failed before callback");
  1884. }
  1885. return TRUE;
  1886. }
  1888. BOOL CFTPDCoreCtrlSock::OnSiteFsysstat(CCmdArgs &Args)
  1889. {
  1890. CCmdArgs MyArgs("chmod", Args[2], m_Parser);
  1892. if (!m_Fsys->FsysStat())
  1893. {
  1894. SendMsg(451, "Site Fsysstat failed.");
  1895. LogMsg(LOGF_WARNINGS,"OnSiteFsysstat failed before callback");
  1896. }
  1897. return TRUE;
  1898. }
  1900. //////////////////////////////////////////////////////////////////////////////////////////
  1901. // CFTPDFsys
  1903. CFTPDFsys::CFTPDFsys(LPVOID *pRef)
  1904. :CUserFsys(pRef)
  1905. {
  1906. ;
  1907. }
  1909. BOOL CFTPDFsys::SetOnHold()
  1910. {
  1911. m_AsyncSelectMaskSaved = m_pSock->m_AsyncSelectMask;
  1912. m_StateSaved = m_pSock->m_State;
  1914. // Prevent socket read/write events
  1915. m_pSock->m_AsyncSelectMask &= ~(FD_READ | FD_WRITE);
  1916. m_pSock->AsyncSelect(m_pSock->m_AsyncSelectMask);
  1918. // Set block state
  1919. m_pSock->m_State = HOLD;
  1920. return TRUE;
  1921. }
  1923. void CFTPDFsys::ReleaseHold()
  1924. {
  1925. m_pSock->m_State = m_StateSaved;
  1926. m_pSock->m_AsyncSelectMask = m_AsyncSelectMaskSaved;
  1927. m_pSock->AsyncSelect(m_pSock->m_AsyncSelectMask);
  1928. }
  1930. void CFTPDFsys::CheckForZombie()
  1931. {
  1932. CUserFsys::CheckForZombie();
  1933. }
  1936. BOOL CFTPDFsys::Create(CFTPDCoreCtrlSock *pSock)
  1937. {
  1938. ASSERT(m_pRef != NULL);
  1939. m_pSock = pSock;
  1940. m_IsAdmin = CUsr::IsAdmin(m_pSock->m_User);
  1941. USER Class = CUsr::GetUserClass(m_pSock->m_User);
  1942. CString Roots, Home;
  1943. CString AssignToName;
  1944. CString UmaskStr;
  1945. USER AssignTo = INVALID_USER_VALUE;
  1946. DWORD Umask = 0;
  1948. CUsr::GetRecursiveParam(m_pSock->m_User, "root", "", Roots);
  1949. CUsr::GetRecursiveParam(m_pSock->m_User, "home", "", Home);
  1950. CUsr::GetRecursiveParam(m_pSock->m_User, "AssignFilesTo", "", AssignToName);
  1951. CUsr::GetRecursiveParam(m_pSock->m_User, "Umask", "", UmaskStr);
  1952. sscanf(UmaskStr, "%o", &Umask);
  1954. if (!AssignToName.IsEmpty())
  1955. AssignTo = CUsr::FindUser(UT_USER, (LPCSTR)AssignToName);
  1957. return CUserFsys::Create(Roots, Home, m_pSock->m_User, Class, pSock->m_SocketName, Umask, AssignTo);
  1958. }
  1960. // Called after the file system is initialized
  1961. // for the user
  1962. BOOL CFTPDFsys::OnCreate(int nErrorCode)
  1963. {
  1964. CUserFsys::OnCreate(nErrorCode);
  1966. if (nErrorCode)
  1967. {
  1968. m_pSock->SendMsg(421, "Internal error - unable to initialize your file system. Goodbye");
  1969. m_pSock->LogMsg(LOGF_ERROR,"Unable to initialize the users file system.");
  1970. delete m_pSock;
  1971. return FALSE;
  1972. }
  1973. m_pSock->m_State = PROCESS;
  1974. return TRUE;
  1975. }
  1978. /////////////////////////////////////////////////////////////////////////////////////
  1979. // High level calls for CFTPDFsys
  1981. BOOL CFTPDFsys::PrepereCommandLine(int CmdIDtoRemember)
  1982. {
  1983. m_FsysPath1.Empty();
  1985. m_lParam = (LPARAM)CmdIDtoRemember;
  1987. for(int Index = 0; Index < m_pSock->m_Args.m_argc; Index++)
  1988. {
  1989. if (!m_FsysPath1.IsEmpty())
  1990. m_FsysPath1 += 'n';
  1991. m_FsysPath1 += m_pSock->m_Args[Index];
  1992. }
  1993. return ProcessRequest(FSM_PRPCMDLINE, (WPARAM)this, 0);
  1994. }
  1996. BOOL CFTPDFsys::OnPrpCmdLine(int nErrorCode)
  1997. {
  1998. LPSTR p = m_FsysPath1.GetBuffer(1);
  1999. for(p = strtok(p, "n"); p; p = strtok(NULL, "n"))
  2000. {
  2001. m_pSock->m_UnixArgs.AddArg(p);
  2002. }
  2004. return m_pSock->OnCommand((int)m_lParam);
  2005. }
  2007. BOOL CFTPDFsys::List()
  2008. {
  2009. m_FsysPath1.Empty();
  2011. for(int Index = 0; Index < m_pSock->m_UnixArgs.m_argc; Index++)
  2012. {
  2013. if (!m_FsysPath1.IsEmpty())
  2014. m_FsysPath1 += 'n';
  2015. m_FsysPath1 += m_pSock->m_UnixArgs.Arg(Index);
  2016. }
  2017. return ProcessRequest(FSM_LIST, (WPARAM)this, 0);
  2018. }
  2020. BOOL CFTPDFsys::OnList(int nErrorCode)
  2021. {
  2022. return m_pSock->CallbackProcessList(nErrorCode);
  2023. }
  2025. CString CFTPDFsys::GetFullPath(LPCSTR Path, DWORD AccessFlags)
  2026. {
  2027. ASSERT(FALSE);
  2028. return "/";
  2029. }
  2031. BOOL CFTPDFsys::RenamePath(LPCSTR OldName, LPCSTR NewName)
  2032. {
  2033. return TRUE;
  2034. }
  2036. BOOL CFTPDFsys::CheckPermission(LPCSTR Path, BOOL IsDir, int PermsWanted)
  2037. {
  2038. return TRUE;
  2039. }
  2042. BOOL CFTPDFsys::ChDir(LPCSTR Path)
  2043. {
  2044. m_CallbackID = CB_CHDIR;
  2045. return CUserFsys::ChDir(Path);
  2046. }
  2048. BOOL CFTPDFsys::Mdtm(LPCSTR Path)
  2049. {
  2050. m_CallbackID = CB_MDTM;
  2051. return CUserFsys::Stat(Path);
  2052. }
  2054. BOOL CFTPDFsys::Size(LPCSTR Path)
  2055. {
  2056. m_CallbackID = CB_SIZE;
  2057. return CUserFsys::Stat(Path);
  2058. }
  2060. BOOL CFTPDFsys::OnChdir(int nErrorCode)
  2061. {
  2062. switch(m_CallbackID)
  2063. {
  2064. case CB_CHDIR:
  2065. return CallbackChDir(nErrorCode);
  2066. }
  2068. return CUserFsys::OnChdir(nErrorCode);
  2069. }
  2071. BOOL CFTPDFsys::CallbackChDir(int nErrorCode)
  2072. {
  2073. if (nErrorCode)
  2074. {
  2075. m_pSock->SendMsg(550, "Permission denied.");
  2076. }
  2077. else
  2078. {
  2079. m_pSock->SendMsg(250, ""%s" is current directory.", m_CWD);
  2080. }
  2081. return nErrorCode == 0;
  2082. }
  2084. BOOL CFTPDFsys::OnChmod(int nErrorCode)
  2085. {
  2086. if (nErrorCode && m_Output.IsEmpty())
  2087. {
  2088. m_pSock->SendMsg(551, "chmod failed.");
  2089. m_pSock->LogMsg(LOGF_WARNINGS,"chmod failed after callback, error %d", nErrorCode);
  2090. }
  2091. else
  2092. {
  2093. m_pSock->SuspendMacros();
  2094. m_pSock->SendMsg(200, "chmod: %s", m_Output);
  2095. m_pSock->EnableMacros();
  2096. }
  2097. return TRUE;
  2098. }
  2100. BOOL CFTPDFsys::OnFsysStat(int nErrorCode)
  2101. {
  2102. if (nErrorCode && m_Output.IsEmpty())
  2103. {
  2104. m_pSock->SendMsg(551, "SITE FSYSSTAT failed.");
  2105. m_pSock->LogMsg(LOGF_WARNINGS,"OnFsysStat failed after callback, error %d", nErrorCode);
  2106. }
  2107. else
  2108. {
  2109. m_pSock->SuspendMacros();
  2110. m_pSock->SendMsg(200, "%s", m_Output);
  2111. m_pSock->EnableMacros();
  2112. }
  2113. return TRUE;
  2114. }
  2116. BOOL CFTPDFsys::OnCreateDirectory(int nErrorCode)
  2117. {
  2118. if (nErrorCode && m_Output.IsEmpty())
  2119. {
  2120. m_pSock->SendMsg(551, "Permission denied.");
  2121. m_pSock->LogMsg(LOGF_WARNINGS,"OnCreateDirectory failed after callback, error %d", nErrorCode);
  2122. }
  2123. else
  2124. {
  2125. m_pSock->SendMsg(257, "Directory created");
  2126. }
  2127. return TRUE;
  2128. }
  2130. BOOL CFTPDFsys::OnDeleteDirectory(int nErrorCode)
  2131. {
  2132. return OnDelete(nErrorCode);
  2133. }
  2135. BOOL CFTPDFsys::OnDeleteFile(int nErrorCode)
  2136. {
  2137. return OnDelete(nErrorCode);
  2138. }
  2140. BOOL CFTPDFsys::OnDeleteGeneric(int nErrorCode)
  2141. {
  2142. return OnDelete(nErrorCode);
  2143. }
  2145. BOOL CFTPDFsys::OnDelete(int nErrorCode)
  2146. {
  2147. if (nErrorCode && m_Output.IsEmpty())
  2148. {
  2149. m_pSock->SendMsg(551, "Permission denied.");
  2150. m_pSock->LogMsg(LOGF_WARNINGS,"OnDelete failed after callback, error %d", nErrorCode);
  2151. }
  2152. else
  2153. {
  2154. m_pSock->SendMsg(250, "%s is deleted", m_FsysPath1);
  2155. }
  2156. return TRUE;
  2157. }
  2159. BOOL CFTPDFsys::OnMoveFile(int nErrorCode)
  2160. {
  2161. if (nErrorCode && m_Output.IsEmpty())
  2162. {
  2163. m_pSock->SendMsg(551, "Permission denied.");
  2164. m_pSock->LogMsg(LOGF_WARNINGS,"OnDelete failed after callback, error %d", nErrorCode);
  2165. }
  2166. else
  2167. {
  2168. m_pSock->LogMsg(LOGF_FILEACC,"Renamed/moved %s to %s",m_FsysPath1, m_FsysPath2);
  2169. m_pSock->SendMsg(250,"RNTO command successful.");
  2170. }
  2171. return TRUE;
  2172. }
  2174. BOOL CFTPDFsys::OnStat(int nErrorCode)
  2175. {
  2176. switch(m_CallbackID)
  2177. {
  2178. case CB_SIZE:
  2179. return OnStatSize(nErrorCode);
  2180. case CB_MDTM:
  2181. return OnStatMDTM(nErrorCode);
  2182. }
  2183. return FALSE;
  2184. }
  2187. BOOL CFTPDFsys::OnStatSize(int nErrorCode)
  2188. {
  2189. char buf[32];
  2190. if (nErrorCode)
  2191. {
  2192. m_pSock->SendMsg(551, "Permission denied.");
  2193. m_pSock->LogMsg(LOGF_WARNINGS,"OnStatSize failed after callback, error %d", nErrorCode);
  2194. return TRUE;
  2195. }
  2197. if (m_FilePerms & NODE_DIR)
  2198. {
  2199. m_pSock->LogMsg(LOGF_DEBUG,"OnStatSize() - Not a plain file.");
  2200. m_pSock->SendMsg(550, "%s: not a plain file.", m_FsysPath1);
  2201. return TRUE;
  2202. }
  2204. sprintf(buf,"%I64d", m_FileLen);
  2205. m_pSock->SendMsg(213, "%s", buf);
  2207. return TRUE;
  2208. }
  2210. BOOL CFTPDFsys::OnStatMDTM(int nErrorCode)
  2211. {
  2212. if (nErrorCode)
  2213. {
  2214. m_pSock->SendMsg(551, "Permission denied.");
  2215. m_pSock->LogMsg(LOGF_WARNINGS,"OnStatMDTM failed after callback, error %d", nErrorCode);
  2216. return TRUE;
  2217. }
  2219. if (m_FilePerms & NODE_DIR)
  2220. {
  2221. m_pSock->LogMsg(LOGF_DEBUG,"OnMdtm() - Not a plain file.");
  2222. m_pSock->SendMsg(550, "%s: not a plain file.", m_FsysPath1);
  2223. return TRUE;
  2224. }
  2226. FILETIME lt;
  2227. SYSTEMTIME st;
  2228. FileTimeToLocalFileTime(&m_FileTime,&lt);
  2229. FileTimeToSystemTime(&lt,&st);
  2230. m_pSock->SendMsg(213, "%04d%02d%02d%02d%02d%02d.%d",
  2231. st.wYear,
  2232. st.wMonth,
  2233. st.wDay,
  2234. st.wHour,
  2235. st.wMinute,
  2236. st.wSecond,
  2237. st.wMilliseconds);
  2239. return TRUE;
  2240. }