libsshCommon.cpp

Go to the documentation of this file.

#include <OptionsChrono.h>
#include "libsshCommon.h"
#include "timer.h"
#include <forward_list>
#include "escapism.h"
#include "errMsgQueue.h"
 
static const std::string parPrefix("libssh");
 
genericSftpStat::genericSftpStat(const sftp_attributes_struct& attrs,
                                 const sftp_statvfs_struct& vfsStat) {
    device = vfsStat.f_fsid;
    size = attrs.size;
    sizeOnDisk = attrs.size;
    blksize = vfsStat.f_bsize;
    aTime = clock_type::time_point(std::chrono::seconds(attrs.atime)
                                   + std::chrono::nanoseconds(attrs.atime_nseconds));
    mTime = clock_type::time_point(std::chrono::seconds(attrs.mtime)
                                   + std::chrono::nanoseconds(attrs.mtime_nseconds));
    timeResolution = std::chrono::microseconds(1);
    mode = attrs.permissions;
    ownerUid = attrs.uid;
    ownerGid = attrs.gid;
}
 
libsshCommon::sshOptions::sshOptions(const std::string& optPrefix):
    host('\0', optPrefix + "_host",
         "host to connect to"),
    knownHostFile('\0', optPrefix + "_knownHosts",
                  "known hosts file to use"),
    configFile('\0', optPrefix + "_config",
               "path to ssh config file"),
    verbosity('\0', optPrefix + "_verbosity",
              "libssh verbosity", "SSH_LOG_NOLOG") {
    verbosity.fAddToRange("SSH_LOG_NOLOG");
    verbosity.fAddToRange("SSH_LOG_WARNING");
    verbosity.fAddToRange("SSH_LOG_PROTOCOL");
    verbosity.fAddToRange("SSH_LOG_PACKET");
    verbosity.fAddToRange("SSH_LOG_FUNCTIONS");
};
 
void libsshCommon::openSessions() {
    session = throwcall::badval(ssh_new(), nullptr, "create new ssh session");
    throwcall::good0(ssh_options_set(session, SSH_OPTIONS_HOST, opt.host.c_str()),
                     "can't set host");
    if (opt.knownHostFile.fIsSet()) {
        throwcall::ssh::good0(ssh_options_set(session, SSH_OPTIONS_KNOWNHOSTS,
                                              opt.knownHostFile.c_str()), *this,
                              "can't add global known hosts file");
    }
 
    throwcall::ssh::good0(ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY_STR,
                                          opt.verbosity.c_str()),
                          *this, "set verbosity");
    throwcall::good0(ssh_options_parse_config(session, opt.configFile.empty() ? nullptr : opt.configFile.c_str()),
                     "can't read ssh config file ", opt.configFile.empty() ? "(default)" : opt.configFile.c_str());
    throwcall::ssh::goodval(ssh_connect(session), SSH_OK, *this,
                            "can't connect to ", opt.host);
    #if LIBSSH_VERSION_MINOR > 7
    switch (ssh_session_is_known_server(session)) {
        case SSH_KNOWN_HOSTS_OK:
            break;
        case SSH_KNOWN_HOSTS_CHANGED:
            throw std::runtime_error("host " + opt.host + " key changed");
        case SSH_KNOWN_HOSTS_OTHER:
            throw std::runtime_error("host " + opt.host + " not found but other key exists");
        case SSH_KNOWN_HOSTS_NOT_FOUND:
            throw std::runtime_error("known hosts file not found");
        case SSH_KNOWN_HOSTS_UNKNOWN:
            throw std::runtime_error("host " + opt.host + " is unknown");
        case SSH_KNOWN_HOSTS_ERROR:
            throw std::runtime_error(std::string("host check error ") + ssh_get_error(session));
    }
    #else
    throwcall::ssh::goodval(ssh_is_server_known(session), SSH_SERVER_KNOWN_OK, *this,
                            "can't verify host ", opt.host);
    #endif
    if (ssh_userauth_gssapi(session) != SSH_AUTH_SUCCESS) {
        if (ssh_userauth_publickey_auto(session, nullptr, nullptr) != SSH_AUTH_SUCCESS) {
            if (ssh_userauth_agent(session, nullptr) != SSH_AUTH_SUCCESS) {
                throw std::runtime_error("can't authenticate at " + opt.host);
            }
        }
    }
    errMsg::emit(errMsg::level::debug, errMsg::location(),
                 "ssh", "connect", "sucessfully authenticated user");
    sftp = throwcall::ssh::badval(sftp_new(session), nullptr, *this,
                                  "create new sftp session");
    throwcall::sftp::good0(sftp_init(sftp), *this, "can't init sftp session");
}
void libsshCommon::closeSessions() {
    sftp_free(sftp);
    sftp = nullptr;
    ssh_disconnect(session);
    ssh_free(session);
    session = nullptr;
}
void libsshCommon::reconnectSessions() {
    if (reconnecting) {
        errMsg::emit(errMsg::level::debug, errMsg::location(),
                     "ssh", "reconnect", "error while reconnecting");
        return;
    }
    reconnecting = true;
    closeSessions();
    errMsg::emit(errMsg::level::debug, errMsg::location(),
                 "ssh", "reconnect", "trying reconnect");
    openSessions();
    reconnecting = false;
}
 
 
libsshCommon::libsshCommon(sshOptions& aOpt): opt(aOpt), reconnecting(false) {
    openSessions();
}
libsshCommon::~libsshCommon() {
    closeSessions();
}
 
bool libsshCommon::pathExists(const std::string& path) {
    auto stat = getUniquePtr(sftp_lstat(sftp, path.c_str()), sftp_attributes_free);
    if (stat == nullptr) {
        if (sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE) {
            return false;
        }
        throwcall::sftp::badval(nullptr, nullptr, *this, "can't stat ", path);
    }
    return true;
};
std::unique_ptr<const genericStat> libsshCommon::getStat(const std::string& path,
        bool followLink) {
    sftp_attributes stat;
    if (followLink) {
        timerInst(sftp_stat);
        stat = sftp_stat(sftp, path.c_str());
    } else {
        timerInst(sftp_lstat);
        stat = sftp_lstat(sftp, path.c_str());
    }
    if (stat == nullptr) {
        if (sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE) {
            return nullptr;
        }
        return nullptr;
        throwcall::sftp::badval(nullptr, nullptr, *this, "can't stat ", path);
    }
    auto retval = new genericSftpStat(*stat, getVfsStat(path));
    sftp_attributes_free(stat);
    return std::unique_ptr<const genericStat>(retval);
};
 
const sftp_statvfs_struct& libsshCommon::getVfsStat(const std::string& path) {
    static std::map<std::string, sftp_statvfs_struct*> statMap;
    auto lastSlashAt = path.find_last_of('/');
    if (lastSlashAt ==  0) {
        lastSlashAt = std::string::npos;
    }
    auto dir = path.substr(0, lastSlashAt);
    auto item = statMap.find(dir);
    if (item == statMap.end()) {
        timerInst(sftp_statvfs);
        auto retval = sftp_statvfs(sftp, dir.c_str());
        if (retval == nullptr) {
            std::string msg(ssh_get_error(session));
            if (msg.find("Operation unsupported")) {
                static sftp_statvfs_struct fakeData;
                fakeData.f_bsize = 4096;
                errMsg::emit(errMsg::level::debug, errMsg::location(),
                             dir, "statvfs", "not supported, using fake data");
                auto result = statMap.emplace(dir, &fakeData);
                item = result.first;
            } else {
                throwcall::sftp::badval(retval, nullptr, *this,
                                        "can't stat fvs for path ", dir);
            }
        } else {
            auto result = statMap.emplace(dir, retval);
            item = result.first;
            errMsg::emit(errMsg::level::debug, errMsg::location(),
                         dir, "statvfs",
                         "bsize: ", retval->f_bsize,
                         " frsize:", retval->f_frsize,
                         " blocks:", retval->f_blocks,
                         " bfree:", retval->f_bfree,
                         " bavail:", retval->f_bavail,
                         " files:", retval->f_files,
                         " ffree:", retval->f_ffree,
                         " favail:", retval->f_favail,
                         " fsid:", retval->f_fsid,
                         " flag:", retval->f_flag,
                         " namemax:", retval->f_namemax);
        }
    }
    return *(item->second);
}
 
 
libsshIoCommon::libsshIoCommon(const std::string& aPath,
                               libsshCommon& aHandler):
    handler(aHandler),
    path(aPath) {
}
 
 
 
 
 
std::unique_ptr<const genericStat> libsshIoCommon::getStat() {
    timerInst(sftp_fstat);
    auto stat = throwcall::sftp::badval(sftp_fstat(file), nullptr, handler,
                                        "can't stat", path);
    auto retval = new genericSftpStat(*stat, handler.getVfsStat(path));
    sftp_attributes_free(stat);
    return std::unique_ptr<const genericStat>(retval);
}