fixGpfsAcls.cpp

Go to the documentation of this file.

 
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include <gpfs.h>
#include <string>
#include <forward_list>
#include <Options.h>
#include <throwcall.h>
#include <scoped.h>
 
 
class aclBuffer {
    gpfs_opaque_acl_t acls;
    char spaceForData[0x10000 - sizeof(gpfs_opaque_acl_t)];
    const std::string& path;
    bool isDir;
    bool initialized;
  public:
    aclBuffer(const std::string& aPath, bool aIsDir = false) : path(aPath), isDir(aIsDir), initialized(false) {
        acls.acl_buffer_len = sizeof(spaceForData);
        acls.acl_version = 0;
        acls.acl_type = GPFS_ACL_TYPE_ACCESS;
    };
    operator void* () {
        if (!initialized) {
            static const std::string pattern("/.aclgetXXXXXX");
            std::vector<char> tmpName;
            tmpName.reserve(path.size() + pattern.size());
            tmpName.insert(tmpName.end(), path.cbegin(), path.cend());
            tmpName.insert(tmpName.end(), pattern.cbegin(), pattern.cend());
            tmpName.push_back('\0');
            if (isDir) {
                throwcall::badval(mkdtemp(tmpName.data()), nullptr, "can't create tmp dir '", tmpName.data(), "'");
            } else {
                auto fd = throwcall::badval(mkstemp(tmpName.data()), -1, "can't create tmp file '", tmpName.data(), "'");
                throwcall::good0(close(fd), "can't close ", tmpName.data());
            }
            throwcall::good0(gpfs_getacl(tmpName.data(), 0, &acls), "can't get acl for '", tmpName.data(), "'");
            if (isDir) {
                throwcall::good0(rmdir(tmpName.data()), "can't remove '", tmpName.data(), "'");
            } else {
                throwcall::good0(unlink(tmpName.data()), "can't remove '", tmpName.data(), "'");
            }
            initialized = true;
        }
        return &acls;
    }
};
 
static unsigned long nDirs = 0;
static unsigned long nFiles = 0;
 
 
void handleDir(const std::string& path) {
    std::forward_list<std::string> subdirs;
    {
        scoped::Dir dir(path);
        aclBuffer fileAcls(path);
        while (auto entry = readdir(dir)) {
            if (entry->d_name[entry->d_name[0] != '.' ? 0 : entry->d_name[1] != '.' ? 1 : 2] == '\0') {
                continue; // skip . .. and empty strings
            }
            struct stat statbuf;
            throwcall::good0(fstatat(dirfd(dir), entry->d_name, &statbuf, AT_SYMLINK_NOFOLLOW), "can't stat '", entry->d_name, "' in '", path, "'");
            if (S_ISDIR(statbuf.st_mode)) {
                subdirs.emplace_front(path + "/" + entry->d_name);
            } else if (S_ISREG(statbuf.st_mode)) {
                std::string filePath(path);
                filePath += "/";
                filePath += entry->d_name;
                nFiles++;
                throwcall::good0(gpfs_putacl(filePath.c_str(), 0, fileAcls), "can't set acl for '", filePath, "'");
            } else {
                std::cerr << "ignoring '" << entry->d_name << "' in '" << path << "', it's neither dir nor file\n";
            }
        }
    }
    if (!subdirs.empty()) {
        aclBuffer dirAcls(path, true);
        for (const auto& subdir : subdirs) {
            nDirs++;
            throwcall::good0(gpfs_putacl(subdir.c_str(), 0, dirAcls), "can't set acl for '", subdir, "'");
        }
    }
    for (const auto& subdir : subdirs) {
        handleDir(subdir);
    }
}
 
 
int main(int argc, const char *argv[]) {
    options::parser parser(
        "set the ACLs of the files given on the command line\n"
        "\t to those they would inherit from theirparent directories.\n"
        "\tDirectories given on the command line are left unchanged,\n"
        "\t but all their content is recursively scanned and the ACLs\n"
        "\t of all their sub-directories and files are set\n"
        "\t as if freshly inherited.\n"
        , "", {});
    options::positional<options::container<std::string>>files(10, "files",
            "files to be fixed");
    parser.fParse(argc, argv);
    std::map<std::string, aclBuffer> fileAcls;
    for (const auto& file : files) {
        struct stat statbuf;
        throwcall::good0(lstat(file.c_str(), &statbuf), "can't stat ", file);
        if (S_ISDIR(statbuf.st_mode)) {
            handleDir(file);
        } else if (S_ISREG(statbuf.st_mode)) {
            auto lastSlash = file.find_last_of('/');
            auto dirPath = lastSlash == std::string::npos ? "." : file.substr(0, lastSlash);
            auto bla = fileAcls.emplace(dirPath, dirPath);
            nFiles++;
            throwcall::good0(gpfs_putacl(file.c_str(), 0, bla.first->second), "can't set acl for '", file, "'");
        } else {
            std::cerr << "ignoring '" << file << "', it's neither dir nor file\n";
        }
    }
    std::cout << "processed " << nFiles << " files in " << nDirs << " directories\n";
    return 0;
}