truncate_file.cpp

Go to the documentation of this file.

#include <chrono>
 
#include <Options.h>
#include <scoped.h>
#include <throwcall.h>
 
#include <fcntl.h>
#include <linux/fs.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#ifdef WithXattr
#include <xattr.h>
#endif
#ifdef WithXattrUgly
#include WithXattrUgly
#endif
#ifndef ENOATTR
#define ENOATTR ENODATA
#endif
#include <unistd.h>
#include <utime.h>
#ifdef withGpfs
#include <sys/vfs.h>
#include "gpfsCommon.h"
#endif
#include "escapism.h"
 
int main(int argc, const char *argv[]) {
    options::parser parser("truncate_file", "", {});
    options::positional<options::container<std::string>>files(10, "files",
            "files to be truncated");
    #if defined(WithXattr) || defined(WithXattrUgly)
    options::single<std::string> name('n', "name",
                                      "name of xattr to set", "user.truncated");
    options::single<std::string> sizeName('s', "size attr name",
                                          "name of xattr for old size", "user.origsize");
    options::single<std::string> ctimeName('c', "ctime attr name",
                                           "name of xattr for old ctime", "user.origctime");
    #endif
    options::single<bool> setImmutable('i', "immutable",
                                       "set files to immutable", false);
    options::single<bool> readPolicyOutput('p',"policyList",
                                           "read files from policy list");
    options::single<bool> verbose('v',"verbose",
                                           "print paths of traeded files");
    auto escaperOption = escapism::newEscaperOption("policyRunEscapeSchema",
                                                    "schema used for escaping file names in policy run file","C");
    parser.fParse(argc, argv);
 
    if (readPolicyOutput) {
        if (files.size() != 1) {
            std::cerr << "with --policyList exactly 1 arg is required\n";
            return 1;
        }
        auto escaper = escapism::newEscaper(*escaperOption);
        auto listName=files.front();
        files.clear();
        std::ifstream list(listName);
        std::string line;
        while (std::getline(list, line)) {
            auto separatorStart = line.find(" -- ");
            if (separatorStart == std::string::npos) {
                continue;
            }
            auto pathStart = separatorStart + 4; // length of " -- "
            std::string file;
            escaper->deEscape(line.substr(pathStart), file);
            files.push_back(file);
        }
    }
    
    for (auto file : files) {
        struct stat initialStat;
        throwcall::good0(stat(file.c_str(), &initialStat), "can't stat ", file);
        if (! S_ISREG(initialStat.st_mode)) {
            if (verbose) {
                std::cout << "ignoring non-file " << file << "\n";
            }
            continue;
        }
        if (verbose) {
            std::cout << "truncating " << file << "\n";
        }
        #if defined(WithXattr) || defined(WithXattrUgly)
        if (!name.empty()) {
            auto value = std::to_string(std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::system_clock::now().time_since_epoch()).count());
            throwcall::good0(setxattr(file.c_str(), name.c_str(), value.data(), value.size(), 0),
                             "can't set xattrs on ", file);
        }
        if (!sizeName.empty()) {
            auto value = std::to_string(initialStat.st_size);
            throwcall::good0(setxattr(file.c_str(), sizeName.c_str(), value.data(), value.size(), 0),
                             "can't set xattrs on ", file);
        }
        if (!ctimeName.empty()) {
            auto value = std::to_string(std::chrono::duration_cast<std::chrono::duration<double>>(
                                std::chrono::seconds(initialStat.st_ctim.tv_sec) +
                                std::chrono::nanoseconds(initialStat.st_ctim.tv_nsec)
                                ).count());
            throwcall::good0(setxattr(file.c_str(), ctimeName.c_str(), value.data(), value.size(), 0),
                             "can't set xattrs on ", file);
        }
        #endif
 
        throwcall::good0(truncate(file.c_str(), 0), "can't truncate ", file);
        struct timespec times[2];
        times[0].tv_sec =  initialStat.st_atim.tv_sec;
        times[0].tv_nsec = initialStat.st_atim.tv_nsec;
        times[1].tv_sec =  initialStat.st_mtim.tv_sec;
        times[1].tv_nsec = initialStat.st_mtim.tv_nsec;
 
        throwcall::good0(utimensat(AT_FDCWD, file.c_str(), times, 0), "can't reset time stamps of ", file);
 
        if (setImmutable) { // does not work on gpfs. GRRR
            scoped::Fd fd(file, throwcall::badval(open(file.c_str(), O_RDONLY),
                                                  -1, "can't open ", file));
            #ifdef withGpfs
            struct statfs statbuf;
            throwcall::good0(fstatfs(fd, &statbuf), "can't statfs for file", file);
            if (statbuf.f_type == GPFS_SUPER_MAGIC) {
                gpfs_fcntl_handler fcntl;
                auto& hint = fcntl.buffer.add<gpfsSetImmutable_t>(GPFS_FCNTL_SET_IMMUTABLE);
                hint.setImmutable = 1;
                hint.setIndefiniteRetention = 1;
                fcntl.call(fd, file);
            } else
            #endif
            {
                int flags;
                throwcall::good0(ioctl(fd, FS_IOC_GETFLAGS, &flags), "can't read flags on ", file);
                flags |= FS_IMMUTABLE_FL;
                throwcall::good0(ioctl(fd, FS_IOC_SETFLAGS, &flags), "can't set flags on ", file);
            }
        }
    }
 
    return 0;
}