outputHandler::libssh Class Reference

#include <outputHandlerLibssh.h>

Inheritance diagram for outputHandler::libssh:

Collaboration diagram for outputHandler::libssh:

Classes
class	writerLibssh

Public Member Functions
	libssh ()
	~libssh () override=default
std::unique_ptr< writer >	newWriter (const std::string &path, bool mightAppend, size_t sourceSize, size_t readBlockSize, copyRequest::stateType &state, bool noWrite, std::unique_ptr< ioHandle::attrDataType > attrData, std::unique_ptr< acl::list > aclData) override
void	ensureParentDirs (const std::string &path, const std::string &srcPath, inputHandler::base *InputHandler) override
void	remove (const std::string &path, copyRequest::stateType &state) override
bool	renameSimple (const std::string &fromPath, const std::string &toPath) override
base::renameRetvalType	rename (const std::string &fromPath, const std::unique_ptr< const genericStat > &readInitialStat, const std::string &toPath, copyRequest::stateType &state) override
void	createSymlink (const std::vector< char > &target, const std::string &path, uid_t uid, gid_t gid) override
size_t	getMaxNameLength (const std::string &dirPath) override
Public Member Functions inherited from outputHandler::base
	~base () override=default
virtual std::unique_ptr< writer >	newTmpWriter (std::string &path, size_t sourceSize, bool noWrite, std::unique_ptr< ioHandle::attrDataType > attrData, std::unique_ptr< acl::list > aclData)
virtual void	doAttributePreservations (const std::string &, const genericStat &)
template<class C >
void	shortenNameToMax (const std::string &path, C &pathBuf, const std::string &suffix)
Public Member Functions inherited from pathHandler
virtual	~pathHandler ()=default
virtual std::string	getXattr (const std::string &, const std::string &)
Public Member Functions inherited from libsshCommon
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)

Static Private Attributes
static factoryTemplate< libssh >	factory

Additional Inherited Members
Public Types inherited from outputHandler::base
enum	renameRetvalType { renameRetvalType::ok, renameRetvalType::fileChanged, renameRetvalType::fileVanished, renameRetvalType::cantHappen }
Static Public Member Functions inherited from outputHandler::base
static base *	newHandler (const std::string &name)
template<class T >
static void	addAllowedNamesToOption (T &option)
Public Attributes inherited from libsshCommon
ssh_session	session
sftp_session	sftp
Protected Member Functions inherited from outputHandler::base
	base ()=default
Protected Member Functions inherited from libsshCommon
void	openSessions ()
void	closeSessions ()
Static Protected Member Functions inherited from outputHandler::base
static std::map< std::string, factoryClass * > &	getFactoryMap ()
Protected Attributes inherited from libsshCommon
sshOptions &	opt
bool	reconnecting

Detailed Description

Definition at line 10 of file outputHandlerLibssh.h.

Constructor & Destructor Documentation

libssh()

outputHandler::libssh::libssh

(

)

Definition at line 21 of file outputHandlerLibssh.cpp.

                  :
        libsshCommon(outputConfig) {
    }

~libssh()

outputHandler::libssh::~libssh ( )

overridedefault

Member Function Documentation

createSymlink()

void outputHandler::libssh::createSymlink ( const std::vector< char > &  target, const std::string &  path, uid_t  uid, gid_t  gid  )

overridevirtual

Reimplemented from outputHandler::base.

Definition at line 201 of file outputHandlerLibssh.cpp.

                                                     {
        {
            timerInst(sftp_symlink);
            auto retval = sftp_symlink(sftp, target.data(), path.c_str());
            if (retval != 0 && sftp_get_error(sftp) != SSH_FX_FILE_ALREADY_EXISTS) {
                throwcall::sftp::good0(retval, *this,  "can't create link at ", path);
            }
        }
        if (static_cast<std::make_signed<decltype(gid)>::type>(gid) != -1
                || static_cast<std::make_signed<decltype(uid)>::type>(uid) != -1) {
            timerInst(sftp_chown);
            throwcall::sftp::good0(sftp_chown(sftp, path.c_str(), uid, gid), *this,
                                   "can't set owner/group (", uid, ",", gid, ") on ", path);
        }
    }

References gid, throwcall::sftp::good0(), libsshCommon::sftp, timerInst, and uid.

Here is the call graph for this function:

ensureParentDirs()

void outputHandler::libssh::ensureParentDirs ( const std::string &  path, const std::string &  srcPath, inputHandler::base *  InputHandler  )

overridevirtual

Implements outputHandler::base.

Definition at line 43 of file outputHandlerLibssh.cpp.

                                                                  {
        std::vector<std::remove_reference<decltype(path)>::type::value_type> disposable_buffer(path.c_str(), path.c_str() + path.size() + 1);
        std::string dir(dirname(disposable_buffer.data()));
        static timer::anchor a("sftp_stat");
        timer::instanceUnscoped i(a);
        auto stat = getUniquePtr(sftp_stat(sftp, dir.c_str()), sftp_attributes_free);
        i.stop();
        
        if (stat == nullptr) {
            if (sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE) {
                ensureParentDirs(dir, srcPath, InputHandler);
                {
                    timerInst(sftp_mkdir);
                    auto result = sftp_mkdir(sftp, dir.c_str(), 0777u);
 
                    if (result != 0 && sftp_get_error(sftp) == SSH_FX_FILE_ALREADY_EXISTS) {
                        return; // we lost a race with another copy process...
                    }
 
                    throwcall::sftp::good0(result, *this, "can't create directory ", dir);
                }
                if (gid != -1 || uid != -1) {
                    timerInst(sftp_chown);
                    throwcall::sftp::good0(sftp_chown(sftp, dir.c_str(), uid, gid), *this,
                                           "can't set owner/group (", uid, ",", gid, ") on ", dir);
                }
            }
        } else if (stat->type != SSH_FILEXFER_TYPE_DIRECTORY) {
            errMsg::emit(errMsg::level::info, errMsg::location(),
                         dir, "ensure parents",
                         "is not a directory (st_mode is ",
                         static_cast<int>(stat->type),
                         ", perm: ", std::hex, stat->permissions,
                         ") but should be");
        }
    }

References errMsg::emit(), libsshCommon::getUniquePtr(), gid, throwcall::sftp::good0(), errMsg::info, libsshCommon::sftp, timer::instanceUnscoped::stop(), timerInst, and uid.

Here is the call graph for this function:

getMaxNameLength()

size_t outputHandler::libssh::getMaxNameLength ( const std::string &  dirPath )

overridevirtual

Reimplemented from outputHandler::base.

Definition at line 398 of file outputHandlerLibssh.cpp.

                                                            {
        auto stat = getVfsStat(dirPath);
        if (stat.f_namemax > 0) {
            return stat.f_namemax;
        } else {
            return 255; // best guess if no sane value forem system
        }
    }

References libsshCommon::getVfsStat().

Here is the call graph for this function:

newWriter()

std::unique_ptr< base::writer > outputHandler::libssh::newWriter ( const std::string &  path, bool  mightAppend, size_t  sourceSize, size_t  readBlockSize, copyRequest::stateType &  state, bool  noWrite, std::unique_ptr< ioHandle::attrDataType >  attrData, std::unique_ptr< acl::list >  aclData  )

overridevirtual

Implements outputHandler::base.

Definition at line 27 of file outputHandlerLibssh.cpp.

                                            {
        return std::unique_ptr<base::writer>(new writerLibssh(path,
                                             *this,
                                             mightAppend,
                                             sourceSize, readBlockSize,
                                             state, noWrite, std::move(attrData),
                                             std::move(aclData)));
    }

remove()

void outputHandler::libssh::remove ( const std::string &  path, copyRequest::stateType &  state  )

overridevirtual

Implements outputHandler::base.

Definition at line 83 of file outputHandlerLibssh.cpp.

                                                                          {
        auto stat = getUniquePtr(sftp_lstat(sftp, path.c_str()), sftp_attributes_free);
        if (stat == nullptr && sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE) {
            state |= copyRequest::stateBitType::vanished;
            return;
        }
        if (stat->type == SSH_FILEXFER_TYPE_DIRECTORY) {
            auto retval = sftp_rmdir(sftp, path.c_str());
            if (retval) {
                switch (sftp_get_error(sftp)) {
                    case SSH_FX_NO_SUCH_FILE:
                        state |= copyRequest::stateBitType::vanished;
                        return;
                    case SSH_FX_FILE_ALREADY_EXISTS:
                        errMsg::emit(errMsg::level::info, errMsg::location(),
                                     path, "remove", "directory not empty but should be removed");
                        state |= copyRequest::stateBitType::failed;
                        return;
                }
                throwcall::sftp::good0(retval, *this, "can't remove directory ", path);
            } else {
                state |= copyRequest::stateBitType::done;
                return;
            }
        } else {
            auto retval = sftp_unlink(sftp, path.c_str());
 
            if (retval && sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE) {
                state |= copyRequest::stateBitType::vanished;
            } else {
                throwcall::sftp::good0(retval, *this, "can't unlink ", path);
            }
            state |= copyRequest::stateBitType::done;
        }
    }

References copyRequest::done, errMsg::emit(), copyRequest::failed, libsshCommon::getUniquePtr(), throwcall::sftp::good0(), errMsg::info, libsshCommon::sftp, and copyRequest::vanished.

Here is the call graph for this function:

rename()

base::renameRetvalType outputHandler::libssh::rename ( const std::string &  fromPath, const std::unique_ptr< const genericStat > &  readInitialStat, const std::string &  toPath, copyRequest::stateType &  state  )

overridevirtual

Bug:

what if at the end a directory is renamed?

Implements outputHandler::base.

Definition at line 140 of file outputHandlerLibssh.cpp.

                                                                       {
        auto fromPathStatBuf = getUniquePtr(sftp_stat(sftp, fromPath.c_str()),
                                            sftp_attributes_free);
        if (fromPathStatBuf == nullptr && sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE) {
            if (readInitialStat && readInitialStat->isDir()) { // no need to act, dirs are created on the fly
                state |= copyRequest::stateBitType::ignore;
                return base::renameRetvalType::ok;
            }
            return base::renameRetvalType::fileVanished;
        } else if (fromPathStatBuf == nullptr) { // curious error
            throwcall::sftp::badval(nullptr, nullptr, *this, "can't stat '", fromPath, "'");
            return base::renameRetvalType::cantHappen; // never reached
        }
        genericSftpStat fromPathStat(*fromPathStatBuf, getVfsStat(fromPath));
        if (!readInitialStat || (! readInitialStat->isDir() &&
                                 (fromPathStat.size != readInitialStat->size
                                  || !fromPathStat.isSameMtimeAs(*readInitialStat)))) {
            // the copy on fromPath is not up to date, create a new copy
            if (readInitialStat) {
                std::string initialTime;
                std::string finalTime;
                readInitialStat->getMtime(initialTime);
                fromPathStat.getMtime(finalTime);
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             fromPath, "move"
                             "file (", toPath, ") changed unexpectedly ("
                             , initialTime, " -> ", finalTime, ", "
                             , readInitialStat->size, " -> ", fromPathStat.size
                             , ", doing fresh copy");
            } else {
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             fromPath, "move",
                             "file (", toPath, ") has no initial stat, doing fresh copy");
            }
            return base::renameRetvalType::fileChanged;
        } else { // try to move the existing copy
            auto retval = sftp_rename(sftp, fromPath.c_str(), toPath.c_str());
 
            if (retval && (errno == ENOENT || errno == ENOTDIR)) {
                if (readInitialStat->isDir()) { // no need to act, dirs are created on the fly
                    state |= copyRequest::stateBitType::ignore;
                    return base::renameRetvalType::ok;
                }
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             fromPath, "move",
                             "vanished unexpectedly, doing fresh copy");
                // file was probably not copied yet, try to copy it from the move target
                return base::renameRetvalType::fileVanished;
            } else {
                throwcall::good0(retval, "can't rename '", fromPath, "' to '", toPath, "'");
                state |= copyRequest::stateBitType::done;
                return base::renameRetvalType::ok;
            }
        }
    }

References throwcall::sftp::badval(), outputHandler::base::cantHappen, copyRequest::done, errMsg::emit(), outputHandler::base::fileChanged, outputHandler::base::fileVanished, genericStat::getMtime(), libsshCommon::getUniquePtr(), libsshCommon::getVfsStat(), throwcall::good0(), copyRequest::ignore, errMsg::info, genericStat::isDir(), genericStat::isSameMtimeAs(), outputHandler::base::ok, libsshCommon::sftp, and genericStat::size.

Here is the call graph for this function:

renameSimple()

bool outputHandler::libssh::renameSimple ( const std::string &  fromPath, const std::string &  toPath  )

overridevirtual

Implements outputHandler::base.

Definition at line 119 of file outputHandlerLibssh.cpp.

                                                       {
        if (pathExists(toPath)) {
            auto retval = sftp_unlink(sftp, toPath.c_str());
            if (retval && sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE) {
                errMsg::emit(errMsg::level::notice, errMsg::location(),
                             toPath, "unlink in renameSimple",
                             "vanished");
            } else {
                throwcall::sftp::good0(retval, *this, "can't unlink in renameSimple ", toPath);
            }
        }
        auto retval = sftp_rename(sftp, fromPath.c_str(), toPath.c_str());
        if (retval && (sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE)) {
            return false;
        }
        throwcall::sftp::good0(retval, *this, "can't rename '", fromPath, "' to '", toPath, "'");
        return true;
    }

References errMsg::emit(), throwcall::sftp::good0(), errMsg::notice, libsshCommon::pathExists(), and libsshCommon::sftp.

Here is the call graph for this function:

Member Data Documentation

factory

factoryTemplate<libssh> outputHandler::libssh::factory

staticprivate

Definition at line 11 of file outputHandlerLibssh.h.

---

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

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