davixCommon.cpp

Go to the documentation of this file.

#include "davixCommon.h"
#include <termios.h>
#include <throwcall.h>
 
decltype(errorReport::withTiming) errorReport::withTiming('\0', "davixTimed",
        "show davix cmd timing info");
 
 
 
 
 
davixCfgX509::davixCfgX509(const std::string& parPrefix):
    p12Path('\0', parPrefix + "X509credP12", "path to X509 cert in .p12 format"),
    privKeyPath('\0', parPrefix + "X509privKey", "path to X509 key in .pem format"),
    credentialPath('\0', parPrefix + "X509credPem", "path to X509 cert in .pem format"),
    proxy('\0', parPrefix + "X509Proxy", "path to proxy credential") {
    p12Path.fForbid({&privKeyPath, &credentialPath, &proxy});
    privKeyPath.fForbid({&p12Path, &proxy});
    credentialPath.fForbid({&p12Path, &proxy});
    proxy.fForbid({&privKeyPath, &credentialPath, &p12Path});
    privKeyPath.fRequire(&credentialPath);
    credentialPath.fRequire(&privKeyPath);
}
void davixCfgX509::applySingle(Davix::RequestParams& params, bool &accessConfigDone) {
    if (p12Path.fIsSet() || privKeyPath.fIsSet()) {
        std::string password;
        davixCommon::getPassword("X509 certificate password:", password);
        if (p12Path.fIsSet()) {
            errorReport report(__func__, "load X509 from p12 file", p12Path);
            if (credential.loadFromFileP12(p12Path, password, report)) {
                report.throwUp();
            }
 
        } else {
            errorReport report(__func__, "load X509 from pem files", privKeyPath);
            if (credential.loadFromFilePEM(privKeyPath, credentialPath, password, report)) {
                report.throwUp();
            }
        }
        params.setClientCertX509(credential);
        accessConfigDone = true;
    } else if (proxy.fIsSet()) {
        errorReport report(__func__, "load X509 from proxy file", proxy);
        if (credential.loadFromFilePEM(proxy, proxy, "", report)) {
            report.throwUp();
        }
        params.setClientCertX509(credential);
        accessConfigDone = true;
    }
}
 
 
 
 
 
 
davixConfigObject::davixConfigObject(const std::string& parPrefix):
    Protocol(parPrefix, "Protocol",
             "set the request protocol (ex : Webdav, Http, S3) ",
             &Davix::RequestParams::setProtocol, {
    {"Auto", Davix::RequestProtocol::Protocol::Auto},
    {"Http", Davix::RequestProtocol::Protocol::Http},
    {"Webdav", Davix::RequestProtocol::Protocol::Webdav},
    {"AwsS3", Davix::RequestProtocol::Protocol::AwsS3},
    #ifdef DAVIX_API_VERSION
    #if DAVIX_API_VERSION >= 20160621
    {"Azure", Davix::RequestProtocol::Protocol::Azure},
    {"Gcloud", Davix::RequestProtocol::Protocol::Gcloud},
    #endif
    #endif
}
        ),
        X509Cert(parPrefix),
        CertificateAuthorityPath(parPrefix, "CertificateAuthorityPath",
                                 "add to path list for CA directories",
                                 &Davix::RequestParams::addCertificateAuthorityPath),
        SSLCAcheck(parPrefix, "NoSSLCAcheck",
                   "disable the certificate authority validity check for the https request",
                   &Davix::RequestParams::setSSLCAcheck,
                   true),
        OperationRetry(parPrefix, "OperationRetry",
                       "set number of retries",
                       &Davix::RequestParams::setOperationRetry),
        OperationTimeout(parPrefix, "OperationTimeout",
                         "set the operation timeout",
                         &Davix::RequestParams::setOperationTimeout),
        ConnectionTimeout(parPrefix, "ConnectionTimeout",
                          "set the connection timeout",
                          &Davix::RequestParams::setConnectionTimeout),
    noAuth('\0',parPrefix + "NoAuth",parPrefix + " don't use authentification",false),
    accessConfigDone(false) {
}
 
void davixConfigObject::apply(Davix::RequestParams& params) {
    Protocol.applySingle(params);
    X509Cert.applySingle(params, accessConfigDone);
    CertificateAuthorityPath.applySingle(params);
    SSLCAcheck.applySingle(params);
    OperationRetry.applySingle(params);
    OperationTimeout.applySingle(params);
    ConnectionTimeout.applySingle(params);
}
bool davixConfigObject::accessConfigured() const {
    return accessConfigDone;
}
 
davixCommon::davixCommon(davixConfigObject& configObj):
    posix(&context) {
    configObj.apply(params);
    if ((! configObj.accessConfigured()) && (! configObj.noAuth)) {
        params.setClientLoginPasswordCallback(loginCallback, this);
        loginCallbackInner(loginName, passWord, -1);
    }
}
 
int davixCommon::loginCallback(void* userdata,
                               const Davix::SessionInfo & /*info*/,
                               std::string & login,
                               std::string & password,
                               int count,
                               Davix::DavixError** /*err*/) {
    return static_cast<davixCommon*>(userdata)->loginCallbackInner(login, password, count);
}
 
void davixCommon::getPassword(const std::string& prompt, std::string & password) {
    std::cerr << prompt;
    std::cerr.flush();
    struct termios old_term, new_term;
    throwcall::good0(tcgetattr(0, &old_term), "tcgetattr on stdin");
    new_term = old_term;
    new_term.c_lflag &= ~ECHO;
    throwcall::good0(tcsetattr(0, TCSAFLUSH, &new_term), "tcsetattr on stdin");
    std::cin >> password;
    throwcall::good0(tcsetattr(0, TCSAFLUSH, &old_term), "tcsetattr on stdin");
    std::cerr << "\n";
}
 
int davixCommon::loginCallbackInner(std::string & login,
                                    std::string & password,
                                    int count) {
    if (count < 1) {
        if (passWord.empty() || loginName.empty()) {
            std::cerr << "Basic authentication - server is asking for username and password:\n";
        }
    } else {
        std::cerr << "Authentication failure, try again:\n";
        passWord.clear();
        loginName.clear();
    }
    if (loginName.empty()) {
        std::cerr << "Login: ";
        std::cerr.flush();
        std::cin >> login;
        if (login.empty()) {
            login = getenv("USER");
            std::cerr << "using '" << login << "' as login name\n";
        }
        loginName = login;
    } else {
        login = loginName;
    }
    if (passWord.empty()) {
        getPassword("Password:", password);
        passWord = password;
    } else {
        password = passWord;
    }
    return 0;
}
 
 
 
 
bool davixCommon::pathExists(const std::string& path) {
    errorReport report(__func__, "stat", path);
    Davix::StatInfo statBuf;
    if (posix.stat64(&params, path, &statBuf, report)) {
        if (report->getStatus() == Davix::StatusCode::FileNotFound) {
            return false;
        }
        report.throwUp();
    }
    return true;
};
std::unique_ptr<const genericStat> davixCommon::getStat(const std::string& path,
        bool /*followLink*/) {
    errorReport report(__func__, "stat", path);
    Davix::StatInfo statBuf;
    if (posix.stat64(&params, path, &statBuf, report)) {
        report.throwUp();
    }
    auto stat = new genericStat();
    auto prePathPart = path.find("//");
    if (prePathPart != std::remove_reference<decltype(path)>::type::npos) {
        prePathPart = path.find("/", prePathPart + 2);
    }
    stat->device = std::hash<std::string> {}(path.substr(0, prePathPart));
    stat->size = statBuf.size;
    stat->sizeOnDisk = statBuf.size;
    stat->blksize = 16 * 1024 * 1024;
    stat->aTime = genericStat::clock_type::time_point(std::chrono::seconds(statBuf.atime));
    stat->mTime = genericStat::clock_type::time_point(std::chrono::seconds(statBuf.mtime));
    stat->timeResolution = std::chrono::seconds(1);
    stat->mode = statBuf.mode;
    #ifdef DAVIX_API_VERSION
    #if DAVIX_API_VERSION >= 20160621
    stat->ownerUid = statBuf.owner;
    stat->ownerGid = statBuf.group;
    #endif
    #endif
    return std::unique_ptr<const genericStat>(stat);
};
 
davixIoCommon::davixIoCommon(const std::string& aPath, davixCommon& aHandler) :
    path(aPath),
    handler(aHandler) {
}
 
 
std::unique_ptr<const genericStat> davixIoCommon::getStat() {
    return handler.getStat(path, true);
}