ftp.h

Go to the documentation of this file.

// Copyright (C) 2001 Dr. Eckhardt + Partner GmbH
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software 
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#ifndef CCXX_FTP_H_
#define CCXX_FTP_H_

#ifndef CCXX_CONFIG_H_
#include <cc++/config.h>
#endif

#ifndef CCXX_SOCKET_H_
#include <cc++/socket.h>
#endif

#include <string>
#include <set>
#include <iostream>
#include <utility>

#ifdef  CCXX_NAMESPACES
namespace ost {
using std::string;
using std::set;
#endif

class FTPSocket
{
protected:
      TCPStream* cs;

      friend class oftpstream;
      friend class iftpstream;
      static int debug;

public:

      void sendCommand(string cmd);
      int getResponse(string* resp = 0);

      FTPSocket();

      explicit FTPSocket(InetHostAddress host, timeout_t to = 0);

      FTPSocket(InetHostAddress host, string user, string passwd,
          timeout_t to = 0);

      ~FTPSocket();

      static void setDebug(int d = 1)  { debug = d; }

      static int  getDebug()           { return debug; }

      void setAscii();

      void setEbcdic();

      void setBinary();

      string command(string cmd);

      class DirEntry
      {
      protected:
          string line;
          string access;
          string user;
          string group;
          string name;
          unsigned int size;

      public:
          struct Compare
          {
            bool operator()(const DirEntry& d1, const DirEntry& d2) const
            { return d1.getName() < d2.getName(); }
          };

          bool parse(string li);

          string  getLine() const    { return line; }
          string  getAccess() const  { return access; }
          string  getUser() const    { return user; }
          string  getGroup() const   { return group; }
          string  getName() const    { return name; }
          unsigned int getSize() const    { return size; }

          bool isDir() const           { return access[0] == 'd'; }
          bool isLink() const          { return access[0] == 'l'; }
          bool canUserRead() const     { return access[1] == 'r'; }
          bool canUserWrite() const    { return access[2] == 'w'; }
          bool canGroupRead() const    { return access[4] == 'r'; }
          bool canGroupWrite() const   { return access[5] == 'w'; }
          bool canOtherRead() const    { return access[7] == 'r'; }
          bool canOtherWrite() const   { return access[8] == 'w'; }
      };

      typedef set<DirEntry, DirEntry::Compare> DirType;

      void open(InetHostAddress host, timeout_t to = 0);

      void open(InetHostAddress host, string user, string passwd,
                timeout_t to = 0);

      void login(string user, string passwd);

      void close(void);

      void quit(void);

      DirType       getDir(string dir = "", timeout_t to = 0);

      string    pwd(void);

      void           cwd(string dir);

      void           cdup(void);

      void put(string file, string rfilename, timeout_t to = 0);

      void put(string file, timeout_t to = 0)
        { put(file, file, to); }

      void get(string file, string lfilename, timeout_t to = 0);

      void get(string file, timeout_t to = 0)
        { get(file, file, to); }

      void remove(string file);

      void rename(string from, string to);

      void mkdir(string dir);

      void rmdir(string dir);
};

class oftpstream : public tcpstream
{
protected:
      FTPSocket& ftpref;

public:
      oftpstream(FTPSocket& f, string rfilename, int buffer = 512,
              timeout_t to = 0);

      ~oftpstream()
      { close(); }

      void close();
};

class iftpstream : public tcpstream
{
protected:
      FTPSocket& ftpref;

public:
      iftpstream(FTPSocket& f, string rfilename, int buffer = 512,
              timeout_t to = 0);

      ~iftpstream()
      { close(); }

      void close();
};

#ifdef  COMMON_STD_EXCEPTION

class FTPException : public SockException
{
public:
        FTPException(string str) : SockException(str) {};                   
};

class FTPResponse : public FTPException
{
protected:
      int code;
public:
      FTPResponse(int c, string r) : FTPException(r), code(c) {};

      int getCode() const  { return code; }
};
#endif

#ifdef  CCXX_NAMESPACES
};
#endif

#endif

---