ftp.h

Go to the documentation of this file.

/*
 * ftp.h
 *
 * File Transfer Protocol Server/Client channel classes
 *  As per RFC 959 and RFC 1123
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-2002 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 25574 $
 * $Author: rjongbloed $
 * $Date: 2011-04-15 13:32:36 +1000 (Fri, 15 Apr 2011) $
 */

#ifndef PTLIB_FTP_H
#define PTLIB_FTP_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#if P_FTP

#include <ptclib/inetprot.h>
#include <ptlib/sockets.h>


class PURL;


class PFTP : public PInternetProtocol
{
  PCLASSINFO(PFTP, PInternetProtocol);
  public:
    enum Commands { 
      USER, PASS, ACCT, CWD, CDUP, SMNT, QUIT, REIN, PORT, PASV, TYPE,
      STRU, MODE, RETR, STOR, STOU, APPE, ALLO, REST, RNFR, RNTO, ABOR,
      DELE, RMD, MKD, PWD, LIST, NLST, SITE, SYST, STATcmd, HELP, NOOP,
      NumCommands
    };

    enum RepresentationType {
      ASCII,
      EBCDIC,
      Image
    };

    enum DataChannelType {
      NormalPort,
      Passive
    };

    enum NameTypes {
      ShortNames,
      DetailedNames
    };

    enum {
      DefaultPort = 21
    };

    PBoolean SendPORT(
      const PIPSocket::Address & addr, 
      WORD port                        
    );


  protected:
    PFTP();
};


class PFTPClient : public PFTP
{
  PCLASSINFO(PFTPClient, PFTP);
  public:
    PFTPClient();

    ~PFTPClient();


    virtual PBoolean Close();


    bool OpenHost(
      const PString & host,
      WORD port = DefaultPort
    );

    PBoolean LogIn(
      const PString & username,   
      const PString & password    
    );

    PString GetSystemType();

    PBoolean SetType(
      RepresentationType type   
    );

    PBoolean ChangeDirectory(
      const PString & dirPath     
    );

    PString GetCurrentDirectory();

    PStringArray GetDirectoryNames(
      NameTypes type = ShortNames,        
      DataChannelType channel = Passive   
    );
    PStringArray GetDirectoryNames(
      const PString & path,               
      NameTypes type = ShortNames,        
      DataChannelType channel = Passive   
    );

    PBoolean CreateDirectory(
      const PString & path                
    );

    PString GetFileStatus(
      const PString & path,                
      DataChannelType channel = Passive    
    );

    PTCPSocket * GetFile(
      const PString & filename,         
      DataChannelType channel = Passive 
    );

    PTCPSocket * PutFile(
      const PString & filename,         
      DataChannelType channel = Passive 
    );

    PTCPSocket * GetURL(
      const PURL & url,                 
      RepresentationType type,          
      DataChannelType channel = Passive 
    );


  protected:
    virtual PBoolean OnOpen();

    PTCPSocket * NormalClientTransfer(
      Commands cmd,
      const PString & args
    );
    PTCPSocket * PassiveClientTransfer(
      Commands cmd,
      const PString & args
    );

    WORD remotePort;
};


class PFTPServer : public PFTP
{
  PCLASSINFO(PFTPServer, PFTP);
  public:
    enum { MaxIllegalPasswords = 3 };

    PFTPServer();
    PFTPServer(
      const PString & readyString   
    );

    ~PFTPServer();


  // New functions for class
    virtual PString GetHelloString(const PString & user) const;

    virtual PString GetGoodbyeString(const PString & user) const;

    virtual PString GetSystemTypeString() const;

    PBoolean GetAllowThirdPartyPort() const { return thirdPartyPort; }

    void SetAllowThirdPartyPort(PBoolean state) { thirdPartyPort = state; }

    PBoolean ProcessCommand();

    virtual PBoolean DispatchCommand(
      PINDEX code,          
      const PString & args  
    );


    virtual PBoolean CheckLoginRequired(
      PINDEX cmd    
    );

    virtual PBoolean AuthoriseUser(
      const PString & user,     
      const PString & password, 
      PBoolean & replied            
    );

    virtual PBoolean OnUnknown(
      const PCaselessString & command  
    );

    virtual void OnError(
      PINDEX errorCode, 
      PINDEX cmdNum,    
      const char * msg  
    );

    virtual void OnSyntaxError(
      PINDEX cmdNum   
    );

    virtual void OnNotImplemented(
      PINDEX cmdNum   
    );

    virtual void OnCommandSuccessful(
      PINDEX cmdNum   
    );


    // the following commands must be implemented by all servers
    // and can be performed without logging in
    virtual PBoolean OnUSER(const PCaselessString & args);
    virtual PBoolean OnPASS(const PCaselessString & args);  // officially optional, but should be done
    virtual PBoolean OnQUIT(const PCaselessString & args);
    virtual PBoolean OnPORT(const PCaselessString & args);
    virtual PBoolean OnSTRU(const PCaselessString & args);
    virtual PBoolean OnMODE(const PCaselessString & args);
    virtual PBoolean OnTYPE(const PCaselessString & args);
    virtual PBoolean OnNOOP(const PCaselessString & args);
    virtual PBoolean OnSYST(const PCaselessString & args);
    virtual PBoolean OnSTAT(const PCaselessString & args);

    // the following commands must be implemented by all servers
    // and cannot be performed without logging in
    virtual PBoolean OnRETR(const PCaselessString & args);
    virtual PBoolean OnSTOR(const PCaselessString & args);
    virtual PBoolean OnACCT(const PCaselessString & args);
    virtual PBoolean OnAPPE(const PCaselessString & args);
    virtual PBoolean OnRNFR(const PCaselessString & args);
    virtual PBoolean OnRNTO(const PCaselessString & args);
    virtual PBoolean OnDELE(const PCaselessString & args);
    virtual PBoolean OnCWD(const PCaselessString & args);
    virtual PBoolean OnCDUP(const PCaselessString & args);
    virtual PBoolean OnRMD(const PCaselessString & args);
    virtual PBoolean OnMKD(const PCaselessString & args);
    virtual PBoolean OnPWD(const PCaselessString & args);
    virtual PBoolean OnLIST(const PCaselessString & args);
    virtual PBoolean OnNLST(const PCaselessString & args);
    virtual PBoolean OnPASV(const PCaselessString & args);

    // the following commands are optional and can be performed without
    // logging in
    virtual PBoolean OnHELP(const PCaselessString & args);
    virtual PBoolean OnSITE(const PCaselessString & args);
    virtual PBoolean OnABOR(const PCaselessString & args);

    // the following commands are optional and cannot be performed
    // without logging in
    virtual PBoolean OnSMNT(const PCaselessString & args);
    virtual PBoolean OnREIN(const PCaselessString & args);
    virtual PBoolean OnSTOU(const PCaselessString & args);
    virtual PBoolean OnALLO(const PCaselessString & args);
    virtual PBoolean OnREST(const PCaselessString & args);


    void SendToClient(
      const PFilePath & filename    
    );


  protected:
    PBoolean OnOpen();
    void Construct();

    PString readyString;
    PBoolean    thirdPartyPort;

    enum {
      NotConnected,
      NeedUser,
      NeedPassword,
      Connected,
      ClientConnect
    } state;

    PIPSocket::Address remoteHost;
    WORD remotePort;

    PTCPSocket * passiveSocket;

    char    type;
    char    structure;
    char    mode;
    PString userName;
    int     illegalPasswordCount;
};


#endif // P_FTP

#endif // PTLIB_FTP_H


// End of File ///////////////////////////////////////////////////////////////