checksumTestRequestProvider.cpp

Go to the documentation of this file.

#include "checksumTestRequestProvider.h"
#include "throwcall.h"
#include "escapism.h"
#include "ewmscp.h"
 
defineStatic(checksumTestRequestProvider::factory, "checksumTest");
defineStatic(checksumTestRequestProvider::escaperOption, *escapism::newEscaperOption("checksumTestEscapeSchema",
             "schema used for escaping file names in checksum file", "C"));
defineStatic(checksumTestRequestProvider::defaultSum, '\0', "defaultCheckSum",
             "check sum type in type-less check sum check files");
defineStatic(checksumTestRequestProvider::lengthMap, '\0', "checkSumGuessLengthMap",
             "map for guessing check sum types from their length",
{{8, "adler32"}, {32, "md5sum"}, {56, "sha224"}, {64, "sha265"}, {96, "sha384"}, {128, "sha512"}});
 
 
defineStatic(checksumTestRequestProvider::doCheck,
[](options::single<bool>&/*me*/) {
    requestProviderName = "checksumTest";
    printStatAnyway = true;
},
'c', "check", "just do checksum tests like md5sum -c");
 
 
 
namespace copyRequest {
    class checksumTest: public base {
      protected:
        static options::single<bool> exitOnMismatch;
        static unsigned int numberOfMismatches;
        static singleMap mapEntry;
      public:
        checksumTest(const std::string& aSource,
                     std::unique_ptr<const genericStat>& aStat,
                     inputHandler::base* aInputHandler):
            base(aInputHandler, aSource, "", aStat, mapEntry, false, copyRequest::clock_type::now()) {}
        void printResults(std::ostream& /*hashStream*/,
                          std::ostream& logStream) override {
            static auto escaper = escapism::newEscaper("C");
            bool matchesInAllSums = true;
            for (const auto& sum : checkSums) {
                if (!sum->getExpectedResult().empty()) {
                    matchesInAllSums &= sum->checkExpectation();
                    if (!quiet || sum->checkExpectation() == false) {
                        std::string name;
                        escaper->escape(source, name);
                        logStream << name << (sum->checkExpectation() ? ": OK\n" : ": FAILED\n");
                    }
                }
            }
            if (! matchesInAllSums) {
                numberOfMismatches++;
            }
        }
        static void printFinalLine(std::ostream& stream) {
            if (numberOfMismatches != 0) {
                stream << numberOfMismatches << " computed checksum" << (numberOfMismatches > 1 ? "s" : "")
                       << " did NOT match\n";
                if (exitOnMismatch) {
                        throw std::runtime_error("bad checksums found");
                }
            }
        }
        static void prepareStatPrint() {
            statPrinter = printFinalLine;
        }
    };
    defineStatic(checksumTest::mapEntry, "checksumtest", "mapentry");
    defineStatic(checksumTest::numberOfMismatches, 0);
    defineStatic(checksumTest::exitOnMismatch, '\0', "status", "for checksum test use exit state for result");
} // end namespace copyRequest
 
 
 
 
 
 
 
 
 
 
 
void checksumTestRequestProvider::processSource(const std::string& source) {
    static auto escaper = escapism::newEscaper(escaperOption);
    copyRequest::checksumTest::prepareStatPrint();
 
    std::ifstream srcList(source);
    while (srcList) {
        std::string sumType;
        std::string sumValue;
 
        srcList >> sumType;
        if (sumType.empty()) {
            continue;
        }
        if (sumType.back() == ':') { // we have our own "sumtype: sumvalue filename" line style
            sumType.pop_back();
            srcList >> sumValue;
        } else { // we have the default whateversum "sumvalue filename" line style
            if (sumType.front() == '\\') { // md5sum(1) uses this to indicate escaped file names
                sumValue = sumType.substr(1);
            } else {
                sumValue = sumType;
            }
            if (defaultSum.empty()) {
                auto item = lengthMap.find(sumValue.size());
                if (item == lengthMap.end()) {
                    throw std::runtime_error("can't guess checksum type from checksum length " + sumValue);
                }
                sumType = item->second;
            } else {
                sumType = defaultSum;
            }
        }
        std::string line;
        std::getline(srcList, line);
        if (line.empty()) {
            continue;
        }
 
        std::string src;
        escaper->deEscape(line.substr(line.find_first_not_of(" \t")), src);
        auto sourceStat = InputHandler->getStat(src, false); // never follow links
        if (!sourceStat) {
            if (ignoreMissing) {
                continue;
            } else {
                throw std::runtime_error("no such file or directory " + src);
            }
        }
        if (sourceStat->isDir()) { // directories are created on the fly, ignore here
            throw std::runtime_error(src + " is a directory");
        }
        auto request = new copyRequest::checksumTest(src, sourceStat, InputHandler);
        request->addExpectedChecksumResult(sumType, sumValue);
        requestSet.emplace(request);
    }
}
 
void checksumTestRequestProvider::prepareMappings(std::vector<std::string>& sources,
        std::string& destination) {
    if (!destination.empty()) { // last arg (destination) is also a source
        sources.push_back(destination);
        destination.clear();
    }
}