inputHandlerLibssh.cpp

Go to the documentation of this file.

#include <iostream>
#include "inputHandlerLibssh.h"
#include "block.h"
#include "copyRequestTypes.h"
#include "ewmscp.h"
 
#include <fcntl.h>
#include <throwcall.h>
#include <errMsgQueue.h>
#include <unistd.h>
#include <string.h>
 
#include <memory>
 
namespace inputHandler {
    decltype(libssh::factory) libssh::factory("sftp");
 
    static libsshCommon::sshOptions inputConfig("sshIn");
 
    libssh::libssh():
        libsshCommon(inputConfig) {
    }
 
    std::unique_ptr<base::reader> libssh::newReader(const std::string& aPath,
            copyRequest::stateType &state,
            const genericStat& inititalStat) {
        return std::unique_ptr<base::reader>(new readerLibssh(aPath,
                                             *this,
                                             state,
                                             inititalStat));
    }
 
 
    bool libssh::readLinkTarget(const std::string& path,
                                std::vector<char>& target) {
        auto targetString = sftp_readlink(sftp, path.c_str());
        if (targetString == nullptr && sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE) {
            return false;
        }
        throwcall::sftp::badval(targetString, nullptr, *this, "could not read link ", path);
        auto linklength = strlen(targetString);
        if (linklength >= target.size()) {
            ssh_string_free_char(targetString);
            throw std::runtime_error("link size increased after stat for " + path);
        }
        for (auto c = targetString; *c; c++) {
            target.at(c - targetString) = *c;
        }
        ssh_string_free_char(targetString);
        target[linklength] = '\0';
 
        return true;
    }
 
 
 
    libssh::readerLibssh::readerLibssh(const std::string& aPath,
                                       libsshCommon& aHandler,
                                       copyRequest::stateType &state,
                                       const genericStat&inititalStat):
        libsshIoCommon(aPath, aHandler),
        reader(inititalStat) {
        file = sftp_open(handler.sftp, path.c_str(), O_RDONLY, 0);
        if (file == nullptr) {
            if (sftp_get_error(handler.sftp) == SSH_FX_NO_SUCH_FILE) {
                state |= copyRequest::stateBitType::vanished;
            }
        }
        throwcall::sftp::badval(file, nullptr, handler, "can't open ", path, " for reading");
        blockSize = readInitialStat.blksize;
    }
 
    libssh::readerLibssh::~readerLibssh() {
        if (file != nullptr) {
            if (isUnwinding()) {
                if (sftp_close(file) == SSH_ERROR) {
                    errMsg::emit(errMsg::level::debug, errMsg::location(),
                                 path, "close during unwind ",
                                 "sftp error ", sftp_get_error(handler.sftp),
                                 ", ssh error ", ssh_get_error(handler.session));
                }
                return;
            }
            throwcall::sftp::badval(sftp_close(file), SSH_ERROR, handler,
                                    "can't close ", path, " after reading");
        }
    }
 
 
 
 
    void libssh::readerLibssh::seek(size_t pos) {
        throwcall::sftp::good0(sftp_seek64(file, pos), handler,
                               "can't seek ", path, " to ", pos);
    }
 
    bool libssh::readerLibssh::readBlock(block& b) {
        b.clear(totalBytesRead);
        bool lastblock = false;
 
        auto bytesToRead = b.max_size();
 
        while (b.size() + blockSize <= bytesToRead) {
            readRateLimit.wait();
            auto bytes_read = sftp_read(file, b.bufferAt(b.size()), blockSize);
            if (bytes_read < 0) {
                throwcall::sftp::good0(1, handler, "read failed on ", path);
            }
            readRateLimit.update(bytes_read);
            if (bytes_read == 0) {
                lastblock = true;
                if (totalBytesRead < readInitialStat.size) {
                    throw delayAdvisingError(path + " has shrunk while reading, (" +
                                             std::to_string(readInitialStat.size) +
                                             " -> " +
                                             std::to_string(totalBytesRead) +
                                             ")");
                }
                break;
            }
            totalBytesRead += bytes_read;
            if (totalBytesRead > readInitialStat.size) {
                throw delayAdvisingError(path + " has grown while reading, (" +
                                         std::to_string(readInitialStat.size) +
                                         " -> " +
                                         std::to_string(totalBytesRead) +
                                         ")");
            }
 
            b.bump_size(bytes_read);
        }
 
 
        return lastblock;
    }
 
 
    void libssh::readerLibssh::checkUnchangedness() {
        auto stat = throwcall::sftp::badval(sftp_fstat(file), nullptr, handler,
                                            "can't stat", path);
        genericSftpStat readFinalStat(*stat, handler.getVfsStat(path));
        sftp_attributes_free(stat);
        if (readFinalStat.size != readInitialStat.size) {
            throw delayAdvisingError("file size has changed (" +
                                     std::to_string(readInitialStat.size) +
                                     " -> " +
                                     std::to_string(readFinalStat.size) +
                                     ") during reading on " + path);
        }
 
        if (!readFinalStat.isSameMtimeAs(readInitialStat)) {
            throw delayAdvisingError("file " + path + " was modified (" +
                                     std::to_string(std::chrono::duration_cast<std::chrono::duration<double>>(readFinalStat.getMtime() - readInitialStat.getMtime()).count()) +
                                     "s different mtime) during reading");
        }
    }
 
 
    libssh::SftpDirectory::SftpDirectory(libsshCommon& aHandler,
                                         const std::string& aPath):
        Directory(aPath),
        handler(aHandler) {
        dir = throwcall::sftp::badval(sftp_opendir(handler.sftp, path.c_str()),
                                      nullptr, handler,
                                      "can't open directory ", path);
    }
    libssh::SftpDirectory::~SftpDirectory() noexcept(false) {
        if (isUnwinding()) {
            if (sftp_closedir(dir) == SSH_ERROR) {
                errMsg::emit(errMsg::level::debug, errMsg::location(),
                             path, "close during unwind ",
                             "sftp error ", sftp_get_error(handler.sftp),
                             ", ssh error ", ssh_get_error(handler.session));
            }
        } else {
            throwcall::sftp::badval(sftp_closedir(dir), SSH_ERROR, handler,
                                    "can't close directory");
        }
    }
    std::unique_ptr<base::Directory::Entry> libssh::SftpDirectory::getNextEntry(bool /*ignoreMissing*/) {
        while (auto entry = sftp_readdir(handler.sftp, dir)) {
            if (entry->name[entry->name[0] != '.' ? 0 : entry->name[1] != '.' ? 1 : 2] == '\0') {
                sftp_attributes_free(entry);
                continue; // skip . .. and empty strings
            }
            auto genStat = std::unique_ptr<const genericStat>(new genericSftpStat(*entry,
                           handler.getVfsStat(path)));
            auto retval = new Entry(entry->name, genStat);
            sftp_attributes_free(entry);
            return std::unique_ptr<Entry>(retval);
        }
        return nullptr;
    }
    std::unique_ptr<base::Directory> libssh::getDirectory(const std::string& path) {
        return std::unique_ptr<Directory>(new SftpDirectory(*this, path));
    }
 
} //end namespace inputHandler