libsshCommon Class Reference

#include <libsshCommon.h>

Inheritance diagram for libsshCommon:

Collaboration diagram for libsshCommon:

Classes
class	sshOptions

Public Member Functions
void	reconnectSessions ()
template<typename T >
std::unique_ptr< T, void(*)(T *)>	getUniquePtr (T *obj, void(*deleter)(T *))
	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)
Public Member Functions inherited from pathHandler
virtual	~pathHandler ()=default
virtual std::string	getXattr (const std::string &, const std::string &)

Public Attributes
ssh_session	session
sftp_session	sftp

Protected Member Functions
void	openSessions ()
void	closeSessions ()

Protected Attributes
sshOptions &	opt
bool	reconnecting

Detailed Description

Definition at line 25 of file libsshCommon.h.

Constructor & Destructor Documentation

libsshCommon()

libsshCommon::libsshCommon

(

sshOptions &

aOpt

)

Definition at line 113 of file libsshCommon.cpp.

                                          : opt(aOpt), reconnecting(false) {
    openSessions();
}

References openSessions().

Here is the call graph for this function:

~libsshCommon()

libsshCommon::~libsshCommon ( )

override

Definition at line 116 of file libsshCommon.cpp.

                            {
    closeSessions();
}

References closeSessions().

Here is the call graph for this function:

Member Function Documentation

closeSessions()

void libsshCommon::closeSessions ( )

protected

Definition at line 91 of file libsshCommon.cpp.

                                 {
    sftp_free(sftp);
    sftp = nullptr;
    ssh_disconnect(session);
    ssh_free(session);
    session = nullptr;
}

References session, and sftp.

Referenced by reconnectSessions(), and ~libsshCommon().

Here is the caller graph for this function:

getStat()

std::unique_ptr< const genericStat > libsshCommon::getStat ( const std::string &  path, bool  followLink  )

overridevirtual

Implements pathHandler.

Definition at line 130 of file libsshCommon.cpp.

                         {
    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);
};

References throwcall::sftp::badval(), getVfsStat(), sftp, and timerInst.

Here is the call graph for this function:

getUniquePtr()

template<typename T >

std::unique_ptr<T, void(*)(T*)> libsshCommon::getUniquePtr ( T *  obj, void(*)(T *)  deleter  )

inline

Definition at line 45 of file libsshCommon.h.

                                                                                               {
        return std::unique_ptr<T, void(*)(T*)>(obj, deleter);
    };

Referenced by outputHandler::libssh::ensureParentDirs(), pathExists(), outputHandler::libssh::remove(), and outputHandler::libssh::rename().

Here is the caller graph for this function:

getVfsStat()

const sftp_statvfs_struct & libsshCommon::getVfsStat

(

const std::string &

path

)

Definition at line 152 of file libsshCommon.cpp.

                                                                         {
    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);
}

References throwcall::sftp::badval(), errMsg::debug, errMsg::emit(), session, sftp, and timerInst.

Referenced by outputHandler::libssh::getMaxNameLength(), getStat(), libsshIoCommon::getStat(), and outputHandler::libssh::rename().

Here is the call graph for this function:

Here is the caller graph for this function:

openSessions()

void libsshCommon::openSessions ( )

protected

Definition at line 42 of file libsshCommon.cpp.

                                {
    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");
}

References throwcall::badval(), throwcall::ssh::badval(), libsshCommon::sshOptions::configFile, errMsg::debug, errMsg::emit(), options::base::fIsSet(), throwcall::good0(), throwcall::sftp::good0(), throwcall::ssh::good0(), throwcall::ssh::goodval(), libsshCommon::sshOptions::host, libsshCommon::sshOptions::knownHostFile, opt, session, sftp, and libsshCommon::sshOptions::verbosity.

Referenced by libsshCommon(), and reconnectSessions().

Here is the call graph for this function:

Here is the caller graph for this function:

pathExists()

bool libsshCommon::pathExists ( const std::string &  path )

overridevirtual

Implements pathHandler.

Definition at line 120 of file libsshCommon.cpp.

                                                   {
    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;
};

References throwcall::sftp::badval(), getUniquePtr(), and sftp.

Referenced by outputHandler::libssh::renameSimple().

Here is the call graph for this function:

Here is the caller graph for this function:

reconnectSessions()

void libsshCommon::reconnectSessions

(

)

Definition at line 98 of file libsshCommon.cpp.

                                     {
    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;
}

References closeSessions(), errMsg::debug, errMsg::emit(), openSessions(), and reconnecting.

Referenced by throwcall::sftp::badval(), throwcall::ssh::badval(), throwcall::sftp::good0(), throwcall::ssh::good0(), and throwcall::ssh::goodval().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

opt

sshOptions& libsshCommon::opt

protected

Definition at line 39 of file libsshCommon.h.

Referenced by openSessions().

reconnecting

bool libsshCommon::reconnecting

protected

Definition at line 42 of file libsshCommon.h.

Referenced by reconnectSessions().

session

ssh_session libsshCommon::session

Definition at line 27 of file libsshCommon.h.

Referenced by throwcall::sftp::badval(), throwcall::ssh::badval(), closeSessions(), getVfsStat(), throwcall::sftp::good0(), throwcall::ssh::good0(), throwcall::ssh::goodval(), and openSessions().

sftp

sftp_session libsshCommon::sftp

Definition at line 28 of file libsshCommon.h.

Referenced by throwcall::sftp::badval(), closeSessions(), outputHandler::libssh::createSymlink(), outputHandler::libssh::ensureParentDirs(), getStat(), getVfsStat(), throwcall::sftp::good0(), openSessions(), pathExists(), inputHandler::libssh::readerLibssh::readerLibssh(), inputHandler::libssh::readLinkTarget(), outputHandler::libssh::remove(), outputHandler::libssh::rename(), outputHandler::libssh::renameSimple(), inputHandler::libssh::SftpDirectory::SftpDirectory(), and outputHandler::libssh::writerLibssh::writerLibssh().

---

The documentation for this class was generated from the following files:

• src/libsshCommon.h (v0.19-24-g0617ca1 with changes)
• src/libsshCommon.cpp (v0.19-24-g0617ca1 with changes)