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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
ftpsrvr.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：16k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

ftpsrvr.cxx：源码内容
  1. /*
  2.  * ftpsrvr.cxx
  3.  *
  4.  * FTP server class.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: ftpsrvr.cxx,v $
  30.  * Revision 1.8  2000/06/21 01:10:18  robertj
  31.  * AIX port, thanks Wolfgang Platzer (wolfgang.platzer@infonova.at).
  32.  *
  33.  * Revision 1.7  2000/06/21 01:01:22  robertj
  34.  * AIX port, thanks Wolfgang Platzer (wolfgang.platzer@infonova.at).
  35.  *
  36.  * Revision 1.6  1999/02/16 06:04:41  robertj
  37.  * Fixed bug in FTP server for PASV mode, may return incorrect IP address.
  38.  *
  39.  * Revision 1.5  1998/11/30 04:50:48  robertj
  40.  * New directory structure
  41.  *
  42.  * Revision 1.4  1998/10/13 14:06:21  robertj
  43.  * Complete rewrite of memory leak detection code.
  44.  *
  45.  * Revision 1.3  1998/09/23 06:22:02  robertj
  46.  * Added open source copyright license.
  47.  *
  48.  * Revision 1.2  1996/10/26 01:39:49  robertj
  49.  * Added check for security breach using 3 way FTP transfer or use of privileged PORT.
  50.  *
  51.  * Revision 1.1  1996/09/14 13:02:35  robertj
  52.  * Initial revision
  53.  *
  54.  */
  56. #include <ptlib.h>
  57. #include <ptlib/sockets.h>
  58. #include <ptclib/ftp.h>
  60. #define new PNEW
  63. #define READY_STRING  "PWLib FTP Server v1.0 ready"
  64. #define GOOBYE_STRING "Goodbye"
  67. /////////////////////////////////////////////////////////
  68. //  FTPServer
  70. PFTPServer::PFTPServer()
  71.   : readyString(PIPSocket::GetHostName() & READY_STRING)
  72. {
  73.   Construct();
  74. }
  77. PFTPServer::PFTPServer(const PString & readyStr)
  78.   : readyString(readyStr)
  79. {
  80.   Construct();
  81. }
  84. void PFTPServer::Construct()
  85. {
  86.   thirdPartyPort = FALSE;
  87.   illegalPasswordCount = 0;
  88.   state     = NotConnected;
  89.   type      = 'A';
  90.   structure = 'F';
  91.   mode      = 'S';
  92.   passiveSocket = NULL;
  93. }
  96. PFTPServer::~PFTPServer()
  97. {
  98.   delete passiveSocket;
  99. }
  102. BOOL PFTPServer::OnOpen()
  103. {
  104.   // the default data port for a client is the same port
  105.   PIPSocket * socket = GetSocket();
  106.   if (socket == NULL)
  107.     return FALSE;
  109.   state = NeedUser;
  110.   if (!WriteResponse(220, readyString))
  111.     return FALSE;
  113.   socket->GetPeerAddress(remoteHost, remotePort);
  114.   return TRUE;
  115. }
  118. PString PFTPServer::GetHelloString(const PString & user) const
  119. {
  120.   return PString("User") & user & "logged in.";
  121. }
  124. PString PFTPServer::GetGoodbyeString(const PString &) const
  125. {
  126.   return PString(GOOBYE_STRING);
  127. }
  130. PString PFTPServer::GetSystemTypeString() const
  131. {
  132.   return PProcess::GetOSClass() + " " + PProcess::GetOSName() + " " + PProcess::GetOSVersion();
  133. }
  136. BOOL PFTPServer::AuthoriseUser(const PString &, const PString &, BOOL &)
  137. {
  138.   return TRUE;
  139. }
  142. BOOL PFTPServer::ProcessCommand()
  143. {
  144.   PString args;
  145.   PINDEX code;
  146.   if (!ReadCommand(code, args))
  147.     return FALSE;
  149.   if (code == P_MAX_INDEX)
  150.     return OnUnknown(args);
  152.   //  handle commands that require login
  153.   if (state == Connected || !CheckLoginRequired(code)) 
  154.     return DispatchCommand(code, args);
  155.   
  156.   // otherwise enforce login
  157.   WriteResponse(530, "Please login with USER and PASS.");
  158.   return TRUE;
  159. }
  162. BOOL PFTPServer::DispatchCommand(PINDEX code, const PString & args)
  163. {
  164.   switch (code) {
  166.     // mandatory commands
  167.     case USER:
  168.       return OnUSER(args);
  169.     case PASS:
  170.       return OnPASS(args);
  171.     case QUIT:
  172.       return OnQUIT(args);
  173.     case PORT:
  174.       return OnPORT(args);
  175.     case STRU:
  176.       return OnSTRU(args);
  177.     case MODE:
  178.       return OnMODE(args);
  179.     case NOOP:
  180.       return OnNOOP(args);
  181.     case TYPE:
  182.       return OnTYPE(args);
  183.     case RETR:
  184.       return OnRETR(args);
  185.     case STOR:
  186.       return OnSTOR(args);
  187.     case SYST:
  188.       return OnSYST(args);
  189.     case STATcmd:
  190.       return OnSTAT(args);
  191.     case ACCT:
  192.       return OnACCT(args);
  193.     case CWD:
  194.       return OnCWD(args);
  195.     case CDUP:
  196.       return OnCDUP(args);
  197.     case PASV:
  198.       return OnPASV(args);
  199.     case APPE:
  200.       return OnAPPE(args);
  201.     case RNFR:
  202.       return OnRNFR(args);
  203.     case RNTO:
  204.       return OnRNTO(args);
  205.     case DELE:
  206.       return OnDELE(args);
  207.     case RMD:
  208.       return OnRMD(args);
  209.     case MKD:
  210.       return OnMKD(args);
  211.     case PWD:
  212.       return OnPWD(args);
  213.     case LIST:
  214.       return OnLIST(args);
  215.     case NLST:
  216.       return OnNLST(args);
  218.     // optional commands
  219.     case HELP:
  220.       return OnHELP(args);
  221.     case SITE:
  222.       return OnSITE(args);
  223.     case ABOR:
  224.       return OnABOR(args);
  225.     case SMNT:
  226.       return OnSMNT(args);
  227.     case REIN:
  228.       return OnREIN(args);
  229.     case STOU:
  230.       return OnSTOU(args);
  231.     case ALLO:
  232.       return OnALLO(args);
  233.     case REST:
  234.       return OnREST(args);
  235.     default:
  236.       PAssertAlways("Registered FTP command not handled");
  237.       return FALSE;
  238.   }
  239.   return TRUE;
  240. }
  243. BOOL PFTPServer::CheckLoginRequired(PINDEX cmd)
  244. {
  245.   static const BYTE RequiresLogin[NumCommands] = {
  246.     1, // USER
  247.     1, // PASS
  248.     0, // ACCT
  249.     0, // CWD
  250.     0, // CDUP
  251.     0, // SMNT
  252.     1, // QUIT
  253.     0, // REIN
  254.     1, // PORT
  255.     0, // PASV
  256.     1, // TYPE
  257.     1, // STRU
  258.     1, // MODE
  259.     0, // RETR
  260.     0, // STOR
  261.     0, // STOU
  262.     0, // APPE
  263.     0, // ALLO
  264.     0, // REST
  265.     0, // RNFR
  266.     0, // RNTO
  267.     1, // ABOR
  268.     0, // DELE
  269.     0, // RMD
  270.     0, // MKD
  271.     0, // PWD
  272.     0, // LIST
  273.     0, // NLST
  274.     1, // SITE
  275.     1, // SYST
  276.     1, // STAT
  277.     1, // HELP
  278.     1, // NOOP
  279.   };
  280.   if (cmd < NumCommands)
  281.     return RequiresLogin[cmd] == 0;
  282.   else
  283.     return TRUE;
  284. }
  287. BOOL PFTPServer::OnUnknown(const PCaselessString & command)
  288. {
  289.   WriteResponse(500, """ + command + "" command unrecognised.");
  290.   return TRUE;
  291. }
  294. void PFTPServer::OnError(PINDEX errorCode, PINDEX cmdNum, const char * msg)
  295. {
  296.   if (cmdNum < commandNames.GetSize())
  297.     WriteResponse(errorCode, "Command "" + commandNames[cmdNum] + "":" + msg);
  298.   else
  299.     WriteResponse(errorCode, msg);
  300. }
  303. void PFTPServer::OnNotImplemented(PINDEX cmdNum)
  304. {
  305.   OnError(502, cmdNum, "not implemented");
  306. }
  309. void PFTPServer::OnSyntaxError(PINDEX cmdNum)
  310. {
  311.   OnError(501, cmdNum, "syntax error in parameters or arguments.");
  312. }
  315. void PFTPServer::OnCommandSuccessful(PINDEX cmdNum)
  316. {
  317.   if (cmdNum < commandNames.GetSize())
  318.     WriteResponse(200, """ + commandNames[cmdNum] + "" command successful.");
  319. }
  322. // mandatory commands that can be performed without loggin in
  324. BOOL PFTPServer::OnUSER(const PCaselessString & args)
  325. {
  326.   userName = args;
  327.   state    = NeedPassword;
  328.   WriteResponse(331, "Password required for " + args + ".");
  329.   return TRUE;
  330. }
  333. BOOL PFTPServer::OnPASS(const PCaselessString & args)
  334. {
  335.   BOOL replied = FALSE;
  336.   if (state != NeedPassword) 
  337.     WriteResponse(503, "Login with USER first.");
  338.   else if (!AuthoriseUser(userName, args, replied)) {
  339.     if (!replied)
  340.       WriteResponse(530, "Login incorrect.");
  341.     if (illegalPasswordCount++ == MaxIllegalPasswords)
  342.       return FALSE;
  343.   } else {
  344.     if (!replied)
  345.       WriteResponse(230, GetHelloString(userName));
  346.     illegalPasswordCount = 0;
  347.     state = Connected;
  348.   }
  349.   return TRUE;
  350. }
  353. BOOL PFTPServer::OnQUIT(const PCaselessString & userName)
  354. {
  355.   WriteResponse(221, GetGoodbyeString(userName));
  356.   return FALSE;
  357. }
  360. BOOL PFTPServer::OnPORT(const PCaselessString & args)
  361. {
  362.   PStringArray tokens = args.Tokenise(",");
  364.   long values[6];
  365.   PINDEX len = PMIN(args.GetSize(), 6);
  367.   PINDEX i;
  368.   for (i = 0; i < len; i++) {
  369.     values[i] = tokens[i].AsInteger();
  370.     if (values[i] < 0 || values[i] > 255)
  371.       break;
  372.   }
  373.   if (i < 6) 
  374.     OnSyntaxError(PORT);
  375.   else {
  376.     PIPSocket * socket = GetSocket();
  377.     if (socket == NULL)
  378.       OnError(590, PORT, "not available on non-TCP transport.");
  379.     else {
  380.       remoteHost = PIPSocket::Address((BYTE)values[0],
  381.                               (BYTE)values[1], (BYTE)values[2], (BYTE)values[3]);
  382.       remotePort = (WORD)(values[4]*256 + values[5]);
  383.       if (remotePort < 1024 && remotePort != socket->GetPort()-1)
  384.         OnError(590, PORT, "cannot access privileged port number.");
  385.       else {
  386.         PIPSocket::Address controlHost;
  387.         GetSocket()->GetPeerAddress(controlHost);
  388.         if (thirdPartyPort || remoteHost == controlHost)
  389.           OnCommandSuccessful(PORT);
  390.         else
  391.           OnError(591, PORT, "three way transfer not allowed.");
  392.       }
  393.     }
  394.   }
  395.   return TRUE;
  396. }
  399. BOOL PFTPServer::OnPASV(const PCaselessString &)
  400. {
  401.   if (passiveSocket != NULL)
  402.     delete passiveSocket;
  404.   passiveSocket = new PTCPSocket;
  405.   passiveSocket->Listen();
  407.   WORD portNo = passiveSocket->GetPort();
  408.   PIPSocket::Address ourAddr;
  409.   PIPSocket * socket = GetSocket();
  410.   if (socket != NULL)
  411.     socket->GetLocalAddress(ourAddr);
  412.   PString str(PString::Printf,
  413.               "Entering Passive Mode (%i,%i,%i,%i,%i,%i)",
  414.               ourAddr.Byte1(),
  415.               ourAddr.Byte2(),
  416.               ourAddr.Byte3(),
  417.               ourAddr.Byte4(),
  418.               portNo/256, portNo%256);
  420.   return WriteResponse(227, str);
  421. }
  424. BOOL PFTPServer::OnTYPE(const PCaselessString & args)
  425. {
  426.   if (args.IsEmpty())
  427.     OnSyntaxError(TYPE);
  428.   else {
  429.     switch (toupper(args[0])) {
  430.       case 'A':
  431.         type = 'A';
  432.         break;
  433.       case 'I':
  434.         type = 'I';
  435.         break;
  436.       case 'E':
  437.       case 'L':
  438.         WriteResponse(504, PString("TYPE not implemented for parameter ") + args);
  439.         return TRUE;
  441.       default:
  442.         OnSyntaxError(TYPE);
  443.         return TRUE;
  444.     }
  445.   }
  446.   OnCommandSuccessful(TYPE);
  447.   return TRUE;
  448. }
  451. BOOL PFTPServer::OnMODE(const PCaselessString & args)
  452. {
  453.   if (args.IsEmpty())
  454.     OnSyntaxError(MODE);
  455.   else {
  456.     switch (toupper(args[0])) {
  457.       case 'S':
  458.         structure = 'S';
  459.         break;
  460.       case 'B':
  461.       case 'C':
  462.         WriteResponse(504, PString("MODE not implemented for parameter ") + args);
  463.         return TRUE;
  464.       default:
  465.         OnSyntaxError(MODE);
  466.         return TRUE;
  467.     }
  468.   }
  469.   OnCommandSuccessful(MODE);
  470.   return TRUE;
  471. }
  474. BOOL PFTPServer::OnSTRU(const PCaselessString & args)
  475. {
  476.   if (args.IsEmpty())
  477.     OnSyntaxError(STRU);
  478.   else {
  479.     switch (toupper(args[0])) {
  480.       case 'F':
  481.         structure = 'F';
  482.         break;
  483.       case 'R':
  484.       case 'P':
  485.         WriteResponse(504, PString("STRU not implemented for parameter ") + args);
  486.         return TRUE;
  487.       default:
  488.         OnSyntaxError(STRU);
  489.         return TRUE;
  490.     }
  491.   }
  492.   OnCommandSuccessful(STRU);
  493.   return TRUE;
  494. }
  497. BOOL PFTPServer::OnNOOP(const PCaselessString &)
  498. {
  499.   OnCommandSuccessful(NOOP);
  500.   return TRUE;
  501. }
  504. // mandatory commands that cannot be performed without logging in
  506. BOOL PFTPServer::OnRETR(const PCaselessString &)
  507. {
  508.   OnNotImplemented(RETR);
  509.   return TRUE;
  510. }
  513. BOOL PFTPServer::OnSTOR(const PCaselessString &)
  514. {
  515.   OnNotImplemented(STOR);
  516.   return TRUE;
  517. }
  520. BOOL PFTPServer::OnACCT(const PCaselessString &)
  521. {
  522.   WriteResponse(532, "Need account for storing files");
  523.   return TRUE;
  524. }
  527. BOOL PFTPServer::OnCWD(const PCaselessString &)
  528. {
  529.   OnNotImplemented(CWD);
  530.   return TRUE;
  531. }
  534. BOOL PFTPServer::OnCDUP(const PCaselessString &)
  535. {
  536.   OnNotImplemented(CDUP);
  537.   return TRUE;
  538. }
  541. BOOL PFTPServer::OnSMNT(const PCaselessString &)
  542. {
  543.   OnNotImplemented(SMNT);
  544.   return TRUE;
  545. }
  548. BOOL PFTPServer::OnREIN(const PCaselessString &)
  549. {
  550.   OnNotImplemented(REIN);
  551.   return TRUE;
  552. }
  555. BOOL PFTPServer::OnSTOU(const PCaselessString &)
  556. {
  557.   OnNotImplemented(STOU);
  558.   return TRUE;
  559. }
  562. BOOL PFTPServer::OnAPPE(const PCaselessString &)
  563. {
  564.   OnNotImplemented(APPE);
  565.   return TRUE;
  566. }
  569. BOOL PFTPServer::OnALLO(const PCaselessString &)
  570. {
  571.   OnNotImplemented(ALLO);
  572.   return TRUE;
  573. }
  576. BOOL PFTPServer::OnREST(const PCaselessString &)
  577. {
  578.   OnNotImplemented(REST);
  579.   return TRUE;
  580. }
  583. BOOL PFTPServer::OnRNFR(const PCaselessString &)
  584. {
  585.   OnNotImplemented(RNFR);
  586.   return TRUE;
  587. }
  590. BOOL PFTPServer::OnRNTO(const PCaselessString &)
  591. {
  592.   OnNotImplemented(RNTO);
  593.   return TRUE;
  594. }
  597. BOOL PFTPServer::OnABOR(const PCaselessString &)
  598. {
  599.   OnNotImplemented(ABOR);
  600.   return TRUE;
  601. }
  604. BOOL PFTPServer::OnDELE(const PCaselessString &)
  605. {
  606.   OnNotImplemented(DELE);
  607.   return TRUE;
  608. }
  611. BOOL PFTPServer::OnRMD(const PCaselessString &)
  612. {
  613.   OnNotImplemented(RMD);
  614.   return TRUE;
  615. }
  618. BOOL PFTPServer::OnMKD(const PCaselessString &)
  619. {
  620.   OnNotImplemented(MKD);
  621.   return TRUE;
  622. }
  625. BOOL PFTPServer::OnPWD(const PCaselessString &)
  626. {
  627.   OnNotImplemented(PWD);
  628.   return TRUE;
  629. }
  632. BOOL PFTPServer::OnLIST(const PCaselessString &)
  633. {
  634.   OnNotImplemented(LIST);
  635.   return TRUE;
  636. }
  639. BOOL PFTPServer::OnNLST(const PCaselessString &)
  640. {
  641.   OnNotImplemented(NLST);
  642.   return TRUE;
  643. }
  646. BOOL PFTPServer::OnSITE(const PCaselessString &)
  647. {
  648.   OnNotImplemented(SITE);
  649.   return TRUE;
  650. }
  653. BOOL PFTPServer::OnSYST(const PCaselessString &)
  654. {
  655.   WriteResponse(215, GetSystemTypeString());
  656.   return TRUE;
  657. }
  660. BOOL PFTPServer::OnSTAT(const PCaselessString &)
  661. {
  662.   OnNotImplemented(STATcmd);
  663.   return TRUE;
  664. }
  667. BOOL PFTPServer::OnHELP(const PCaselessString &)
  668. {
  669.   OnNotImplemented(HELP);
  670.   return TRUE;
  671. }
  674. void PFTPServer::SendToClient(const PFilePath & filename)
  675. {
  676.   if (!PFile::Exists(filename)) 
  677.     WriteResponse(450, filename + ": file not found");
  678.   else {
  679.     PTCPSocket * dataSocket;
  680.     if (passiveSocket != NULL) {
  681.       dataSocket = new PTCPSocket(*passiveSocket);
  682.       delete passiveSocket;
  683.       passiveSocket = NULL;
  684.     } else
  685.       dataSocket = new PTCPSocket(remoteHost, remotePort);
  686.     if (!dataSocket->IsOpen())
  687.       WriteResponse(425, "Cannot open data connection");
  688.     else {
  689.       if (type == 'A') {
  690.         PTextFile file(filename, PFile::ReadOnly);
  691.         if (!file.IsOpen())
  692.           WriteResponse(450, filename + ": cannot open file");
  693.         else {
  694.           PString fileSize(PString::Unsigned, file.GetLength());
  695.           WriteResponse(150, PString("Opening ASCII data connection for " + filename.GetFileName() + "(" + fileSize + " bytes)"));
  696.           PString line;
  697.           BOOL ok = TRUE;
  698.           while (ok && file.ReadLine(line)) {
  699.             if (!dataSocket->Write((const char *)line, line.GetLength())) {
  700.               WriteResponse(426, "Connection closed - transfer aborted");
  701.               ok = FALSE;
  702.             }
  703.           }
  704.           file.Close();
  705.         }
  706.       } else {
  707.         PFile file(filename, PFile::ReadOnly);
  708.         if (!file.IsOpen())
  709.           WriteResponse(450, filename + ": cannot open file");
  710.         else {
  711.           PString fileSize(PString::Unsigned, file.GetLength());
  712.           WriteResponse(150, PString("Opening BINARY data connection for " + filename.GetFileName() + "(" + fileSize + " bytes)"));
  713.           BYTE buffer[2048];
  714.           BOOL ok = TRUE;
  715.           while (ok && file.Read(buffer, 2048)) {
  716.             if (!dataSocket->Write(buffer, file.GetLastReadCount())) {
  717.               WriteResponse(426, "Connection closed - transfer aborted");
  718.               ok = FALSE;
  719.             }
  720.           }
  721.           file.Close();
  722.         }
  723.       }
  724.       delete dataSocket;
  725.       WriteResponse(226, "Transfer complete");
  726.     }
  727.   }
  728. }
  731. // End of File ///////////////////////////////////////////////////////////////