warsvrprotocolftpcmdall.h

ftpserver very good sample

/** 

    Default implementation of the FTP commands.
*/

#ifndef WAR_SVR_PROTOCOL_FTP_CMD_ALL_H
#define WAR_SVR_PROTOCOL_FTP_CMD_ALL_H

/* SYSTEM INCLUDES */


/* PROJECT INCLUDES */

#ifndef WAR_SVR_PROTOCOL_FTP_CMD_H
#   include "WarSvrProtocolFtp.h"
#endif

#ifndef WAR_SVR_PROTOCOL_FTP_H
#   include "WarSvrProtocolFtp.h"
#endif

#ifndef WAR_SVR_PATH_H
#   include "WarSvrPath.h"
#endif

/* LOCAL INCLUDES */


/* FORWARD REFERENCES */



#ifdef __cplusplus
extern "C" 
{
#endif
/****************** BEGIN OLD STYLE C spesific ********/


/****************** END OLD STYLE C spesific **********/
#ifdef __cplusplus 
}
#endif

/****************** BEGIN C++ spesific ****************/

#ifdef __cplusplus

#if 0 // Implementation template
class XX : public WarSvrProtocolFtpCmd
{
public:
    XX(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return false;}
    virtual bool IsArgumentRequiered() const {return false;}
    virtual bool IsArgumentAllowed() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~XX() {}

private:
};
#endif // 0

class FtpCmdAuthBase : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdAuthBase(war_ccstr_t commandName, 
        war_ccstr_t commandExplanation, /* Human help*/
        war_ccstr_t commandSyntax, /* Formal */
        war_ccstr_t commandReference, /* RFC */
        WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return true;}
    virtual bool IsArgumentRequiered() const {return true;}

protected:

    // Return true if login returned LF_OK
    bool Login(war_ccstr_t virtualHost, 
        war_ccstr_t userName, 
        war_ccstr_t userPasswd);

    ~FtpCmdAuthBase() {}

private:
};

class FtpCmdUser : public FtpCmdAuthBase
{
public:
    FtpCmdUser(WarSvrProtocolFtp& serverCompanion);

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdUser() {}

};

class FtpCmdPass : public FtpCmdAuthBase
{
public:
    FtpCmdPass(WarSvrProtocolFtp& serverCompanion);

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdPass() {}

private:
};

class FtpCmdPort : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdPort(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdPort() {}

private:
};

class FtpCmdPasv : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdPasv(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return false;}
    virtual bool IsArgumentAllowed() const {return false;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdPasv() {}

private:
};

class FtpCmdType : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdType(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return true;}
    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdType() {}

private:
};

class FtpCmdTransfer 
: public WarSvrProtocolFtpCmd
{
public:
    FtpCmdTransfer(war_ccstr_t commandName, 
        war_ccstr_t commandExplanation, /* Human help*/
        war_ccstr_t commandSyntax, /* Formal */
        war_ccstr_t commandReference, /* RFC */
        WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

protected:
    virtual void SendFile(const war_ccstr_t filePath)
        throw(WarException);
    virtual void ReceiveFile(const war_ccstr_t filePath,
        bool withUniqueName = false,
        bool doAppend = false)
        throw(WarException);
    virtual void Connect()
        throw(WarException);
    virtual war_svrfile_ptr_t OpenFile(const WarSvrPath& svrFile, 
        war_uint32_t flags)
        throw(WarException);
};

class FtpCmdRetr : public FtpCmdTransfer
{
public:
    FtpCmdRetr(WarSvrProtocolFtp& serverCompanion);

    virtual LastCommandresultE ExecuteCommand();
    
protected:
    ~FtpCmdRetr() {}

private:
};

class FtpCmdList : public FtpCmdTransfer
{
public:
    FtpCmdList(WarSvrProtocolFtp& serverCompanion);
    FtpCmdList(war_ccstr_t commandName, 
        war_ccstr_t commandExplanation, /* Human help*/
        war_ccstr_t commandSyntax, /* Formal */
        war_ccstr_t commandReference, /* RFC */
        WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return false;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    bool mDoForceSimple;

    ~FtpCmdList() {}

private:
};

class FtpCmdNlst : public FtpCmdList
{
public:
    FtpCmdNlst(WarSvrProtocolFtp& serverCompanion);

protected:
    ~FtpCmdNlst() {}

private:
};

class FtpCmdCwd : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdCwd(WarSvrProtocolFtp& serverCompanion);
    FtpCmdCwd(war_ccstr_t commandName, 
        war_ccstr_t commandExplanation, /* Human help*/
        war_ccstr_t commandSyntax, /* Formal */
        war_ccstr_t commandReference, /* RFC */
        WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return false;}
    virtual bool IsArgumentAllowed() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    LastCommandresultE Cwd(war_ccstr_t newCwd);
    ~FtpCmdCwd() {}

private:
};

class FtpCmdPwd : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdPwd(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentAllowed() const {return false;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdPwd() {}

private:
};

class FtpCmdCdup : public FtpCmdCwd
{
public:
    FtpCmdCdup(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentAllowed() const {return false;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdCdup() {}

private:
};


class FtpCmdQuit : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdQuit(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return true;}
    virtual bool IsArgumentAllowed() const {return false;}
    virtual bool CanBeInTransfer() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdQuit() {}

private:
};

class FtpCmdStor : public FtpCmdTransfer
{
public:
    FtpCmdStor(WarSvrProtocolFtp& serverCompanion);

    virtual LastCommandresultE ExecuteCommand();
protected:
    ~FtpCmdStor() {}

private:
};

class FtpCmdStou : public FtpCmdTransfer
{
public:
    FtpCmdStou(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return false;}
    virtual bool IsArgumentAllowed() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdStou() {}

private:
};

class FtpCmdRest : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdRest(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

#if WAR_RFC2389
    virtual std::string GetFeatureString() const
    {
        return "REST STREAM";
    }
#endif

protected:
    ~FtpCmdRest() {}

private:
};

class FtpCmdSyst : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdSyst(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return true;}
    virtual bool IsArgumentAllowed() const {return false;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdSyst() {}

private:
};

class FtpCmdHelp : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdHelp(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return true;}
    virtual bool IsArgumentAllowed() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdHelp() {}

private:
};

class FtpCmdAcct : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdAcct(WarSvrProtocolFtp& serverCompanion)
        : WarSvrProtocolFtpCmd("ACCT", 
        "Account name", 
        "ACCT <SP> <account-information> <CRLF>",
        "RFC 959",
        serverCompanion)
    {}

    virtual bool IsImplemented() const {return false;}

protected:
    ~FtpCmdAcct() {}

private:
};

class FtpCmdSmnt : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdSmnt(WarSvrProtocolFtp& serverCompanion)
        : WarSvrProtocolFtpCmd("SMNT", 
        "Obsolete", 
        "SMNT <SP> <pathname> <CRLF>",
        "RFC 959",
        serverCompanion)
    {}

    virtual bool IsImplemented() const {return false;}

protected:
    ~FtpCmdSmnt() {}

private:
};

class FtpCmdRein : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdRein(WarSvrProtocolFtp& serverCompanion)
        : WarSvrProtocolFtpCmd("REIN", 
        "Reinitialize", 
        "REIN <CRLF>",
        "RFC 959",
        serverCompanion)
    {}

    virtual bool IsImplemented() const {return false;}

protected:
    ~FtpCmdRein() {}

private:
};

class FtpCmdStru : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdStru(WarSvrProtocolFtp& serverCompanion)
        : WarSvrProtocolFtpCmd("STRU", 
        "Structure", 
        "STRU <SP> <structure-code> <CRLF>",
        "RFC 959",
        serverCompanion)
    {}

    virtual bool IsImplemented() const {return false;}

protected:
    ~FtpCmdStru() {}

private:
};

class FtpCmdMode : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdMode(WarSvrProtocolFtp& serverCompanion)
        : WarSvrProtocolFtpCmd("MODE", 
        "Mode", 
        "MODE <SP> <mode-code> <CRLF>",
        "RFC 959",
        serverCompanion)
    {}

    virtual bool IsImplemented() const {return false;}

protected:
    ~FtpCmdMode() {}

private:
};


class FtpCmdAppe : public FtpCmdTransfer
{
public:
    FtpCmdAppe(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdAppe() {}

private:
};

class FtpCmdAllo : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdAllo(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdAllo() {}

private:
};

class FtpCmdRnfr : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdRnfr(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

    const WarSvrPath& GetRnfrPath() const
    {
        return mPath;
    }

protected:
    ~FtpCmdRnfr() {}

private:
    WarSvrPath mPath;
};

class FtpCmdRnto : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdRnto(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdRnto() {}

private:
};

class FtpCmdAbor : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdAbor(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentAllowed() const {return false;}
    virtual bool CanBeInTransfer() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdAbor() {}

private:
};

class FtpCmdDele : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdDele(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdDele() {}

private:
};

class FtpCmdRmd : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdRmd(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdRmd() {}

private:
};

class FtpCmdMkd : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdMkd(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdMkd() {}

private:
};

class FtpCmdStat : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdStat(WarSvrProtocolFtp& serverCompanion);

    virtual bool IsArgumentAllowed() const {return true;}
    virtual bool CanBeInTransfer() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdStat() {}

private:
};

class FtpCmdNoop : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdNoop(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return true;}
    virtual bool IsArgumentAllowed() const {return false;}

    virtual LastCommandresultE ExecuteCommand();
    virtual void OnResetTimer() {} // No default reset

protected:
    ~FtpCmdNoop() {}

private:
};

class FtpCmdSite : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdSite(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return true;}
    virtual bool IsArgumentRequiered() const {return true;}
    
    virtual LastCommandresultE ExecuteCommand();

    void InnstallCommand(war_ftpcmd_ptr_t& command,
        bool doReplace = true)
    {
        mCommands.InnstallCommand(command, doReplace);
    }

    void InstallAlias(war_ccstr_t strAlias, 
        war_ccstr_t strCommand)
    {
        mCommands.InstallAlias(strAlias, strCommand);
    }

protected:
    ~FtpCmdSite() {}

private:
    WarSvrProtocolFtpCommands mCommands;
};


// Feature Negotiation Mechanism
#if WAR_RFC2389

class FtpCmdFeat : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdFeat(WarSvrProtocolFtp& serverCompanion);

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdFeat() {}

private:
};

class FtpCmdOpts : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdOpts(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

protected:
    ~FtpCmdOpts() {}

private:
};

class FtpCmdMdtm : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdMdtm(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return false;}
    virtual bool IsArgumentRequiered() const {return true;}

    virtual LastCommandresultE ExecuteCommand();

#if WAR_RFC2389
    virtual std::string GetFeatureString() const
    {
        return "MDTM";
    }
#endif

protected:
    ~FtpCmdMdtm() {}

private:
};

class FtpCmdSize : public WarSvrProtocolFtpCmd
{
public:
    FtpCmdSize(WarSvrProtocolFtp& serverCompanion);

    virtual bool CanBePrelogin() const {return false;}
    virtual bool IsArgumentRequiered() const {return false;}
    virtual bool IsArgumentAllowed() const {return true;}

    virtual LastCommandresultE ExecuteCommand();


#if WAR_RFC2389
    virtual std::string GetFeatureString() const
    {
        return "SIZE";
    }
#endif

protected:
    ~FtpCmdSize() {}

private:
};



#endif // WAR_RFC2389

#endif /* __cplusplus */

/****************** END C++ spesific ******************/

#endif  /* WAR_SVR_PROTOCOL_FTP_CMD_ALL_H_ */