libsshCommon.h

Go to the documentation of this file.

#ifndef __libsshCommon_h__
#define __libsshCommon_h__
 
#include <iostream>
 
#include "ioHandle.h"
#include "pathHandler.h"
#include "Options.h"
#include <libssh/libssh.h>
#include <libssh/sftp.h>
#include <throwcall.h>
#include <mutex>
 
#include "errMsgQueue.h"
 
class genericSftpStat: public genericStat {
  public:
    genericSftpStat(const sftp_attributes_struct& attrs,
                    const sftp_statvfs_struct& vfsStat);
};
 
 
 
 
class libsshCommon: virtual public pathHandler {
  public:
    ssh_session session;
    sftp_session sftp;
 
    class sshOptions {
      public:
        sshOptions(const std::string& optPrefix);
        options::single<std::string> host;
        options::single<std::string> knownHostFile;
        options::single<std::string> configFile;
        options::single<std::string> verbosity;
    };
  protected:
    sshOptions& opt;
    void openSessions();
    void closeSessions();
    bool reconnecting;
  public:
    void reconnectSessions();
    template<typename T> std::unique_ptr<T, void(*)(T*)>getUniquePtr(T* obj, void(*deleter)(T*)) {
        return std::unique_ptr<T, void(*)(T*)>(obj, deleter);
    };
    libsshCommon(sshOptions& aOpt);
    ~libsshCommon() override;
    bool pathExists(const std::string& path) override;
    std::unique_ptr<const genericStat> getStat(const std::string& path,
            bool followLink) override;
    const sftp_statvfs_struct& getVfsStat(const std::string& path);
};
 
class libsshIoCommon: virtual public ioHandle {
  protected:
    libsshCommon& handler;
    const std::string path;
    sftp_file file;
  public:
    libsshIoCommon(const std::string& aPath,
                   libsshCommon& aHandler);
    std::unique_ptr<const genericStat> getStat() override;
};
 
 
namespace throwcall {
    namespace sftp {
        template <typename T, typename ... Args> inline void good0(T call,
                libsshCommon& handler,
                const Args& ... args) {
            if (__builtin_expect(call, 0)) {
                handler.reconnectSessions();
                std::ostringstream msg;
                conCatString(msg, "sftp error ", sftp_get_error(handler.sftp),
                             ", ssh error ", ssh_get_error(handler.session),
                             " ", args...);
                throw std::runtime_error(msg.str());
            }
        };
        template <typename T, typename t, typename ... Args> inline T badval(T call, t badvalue,
                libsshCommon& handler,
                const Args& ... args) {
            if (__builtin_expect(call == badvalue, false)) {
                std::ostringstream msg;
                conCatString(msg, "sftp error ", sftp_get_error(handler.sftp),
                             ", ssh error ", ssh_get_error(handler.session),
                             "  ", args...);
                handler.reconnectSessions();
                throw std::runtime_error(msg.str());
            }
            return call;
        };
    } // end namespace sftp
    namespace ssh {
        template <typename T, typename ... Args> inline void good0(T call,
                libsshCommon& handler,
                const Args& ... args) {
            if (__builtin_expect(call != 0, false)) {
                std::ostringstream msg;
                conCatString(msg, "ssh error ", ssh_get_error(handler.session), "  ", args...);
                handler.reconnectSessions();
                throw std::runtime_error(msg.str());
            }
        };
 
        template <typename T, typename t, typename ... Args> inline T goodval(T call, t goodvalue,
                libsshCommon& handler,
                const Args& ... args) {
            if (__builtin_expect(call != goodvalue, false)) {
                std::ostringstream msg;
                conCatString(msg, "ssh error ", ssh_get_error(handler.session), "  ", args...);
                handler.reconnectSessions();
                throw std::runtime_error(msg.str());
            }
            return call;
        };
 
        template <typename T, typename t, typename ... Args> inline T badval(T call, t badvalue,
                libsshCommon& handler,
                const Args& ... args) {
            if (__builtin_expect(call == badvalue, false)) {
                std::ostringstream msg;
                conCatString(msg, "ssh error ", ssh_get_error(handler.session), "  ", args...);
                handler.reconnectSessions();
                throw std::runtime_error(msg.str());
            }
            return call;
        };
    } // end namespace ssh
} // end namespace throwcall
 
 
#endif