Wie kann ich mithilfe des Boost-Dateisystems den Eigentümer einer Datei oder eines Verzeichnisses ermitteln?[Duplikat]

Question

Auf diese Frage gibt es hier bereits eine Antwort:

Geschlossen vor 7 Jahren.

Mögliches Duplikat:
Ermitteln Sie mit Boost den Besitzer und die Gruppe der Datei

Ich möchte boost::filesystem verwenden, um festzustellen, welche Dateien und Verzeichnisse/Ordner einem bestimmten Benutzer gehören.

Ich muss dies sowohl auf Linux- (ext3) als auch auf Windows-Dateisystemen (NTFS) tun.

Wie kann ich mit boost::filesystem die Benutzerkennung für einen angegebenen Pfad abrufen?

Dank im Voraus.

Bearbeiten:Von der ausgewählten Antwort abgeleiteter Code:

#include <iostream>
#include <string>

#ifdef LINUX
#include <pwd.h>
#include <grp.h>
#include <sys/stat.h>
#else
#include <stdio.h>
#include <windows.h>
#include <tchar.h>
#include "accctrl.h"
#include "aclapi.h"
#pragma comment(lib, "advapi32.lib")
#endif

bool getOwner(const std::string &Filename, std::string &Owner)
{
#ifdef LINUX
    struct stat FileInfo;
    stat(Filename.c_str(), &FileInfo);
    struct passwd *UserDatabaseEntry  = getpwuid(FileInfo.st_uid);
    struct group  *GroupDatabaseEntry = getgrgid(FileInfo.st_gid);
    //
    if (UserDatabaseEntry != 0)
    {
        Owner = UserDatabaseEntry->pw_name;
        return true;
    }
    else
    {
        return false;
    }
#else
    DWORD dwRtnCode = 0;
    PSID pSidOwner = NULL;
    BOOL bRtnBool = TRUE;
    LPTSTR AcctName = NULL;
    LPTSTR DomainName = NULL;
    DWORD dwAcctName = 1, dwDomainName = 1;
    SID_NAME_USE eUse = SidTypeUnknown;
    HANDLE hFile;
    PSECURITY_DESCRIPTOR pSD = NULL;


    // Get the handle of the file object.
    hFile = CreateFile(
        TEXT(Filename.c_str()),
        GENERIC_READ,
        FILE_SHARE_READ,
        NULL,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL);

    // Check GetLastError for CreateFile error code.
    if (hFile == INVALID_HANDLE_VALUE)
    {
        DWORD dwErrorCode = 0;

        dwErrorCode = GetLastError();
        _tprintf(TEXT("CreateFile error = %d\n"), dwErrorCode);
        return false;
    }

    // Get the owner SID of the file.
    dwRtnCode = GetSecurityInfo(
        hFile,
        SE_FILE_OBJECT,
        OWNER_SECURITY_INFORMATION,
        &pSidOwner,
        NULL,
        NULL,
        NULL,
        &pSD);

    // Check GetLastError for GetSecurityInfo error condition.
    if (dwRtnCode != ERROR_SUCCESS) {
        DWORD dwErrorCode = 0;

        dwErrorCode = GetLastError();
        _tprintf(TEXT("GetSecurityInfo error = %d\n"), dwErrorCode);
        return false;
    }

    // First call to LookupAccountSid to get the buffer sizes.
    bRtnBool = LookupAccountSid(
        NULL,           // local computer
        pSidOwner,
        AcctName,
        (LPDWORD)&dwAcctName,
        DomainName,
        (LPDWORD)&dwDomainName,
        &eUse);

    // Reallocate memory for the buffers.
    AcctName = (LPTSTR)GlobalAlloc(
        GMEM_FIXED,
        dwAcctName);

    // Check GetLastError for GlobalAlloc error condition.
    if (AcctName == NULL) {
        DWORD dwErrorCode = 0;

        dwErrorCode = GetLastError();
        _tprintf(TEXT("GlobalAlloc error = %d\n"), dwErrorCode);
        return false;
    }

    DomainName = (LPTSTR)GlobalAlloc(
        GMEM_FIXED,
        dwDomainName);

    // Check GetLastError for GlobalAlloc error condition.
    if (DomainName == NULL) {
        DWORD dwErrorCode = 0;

        dwErrorCode = GetLastError();
        _tprintf(TEXT("GlobalAlloc error = %d\n"), dwErrorCode);
        return false;

    }

    // Second call to LookupAccountSid to get the account name.
    bRtnBool = LookupAccountSid(
        NULL,                   // name of local or remote computer
        pSidOwner,              // security identifier
        AcctName,               // account name buffer
        (LPDWORD)&dwAcctName,   // size of account name buffer 
        DomainName,             // domain name
        (LPDWORD)&dwDomainName, // size of domain name buffer
        &eUse);                 // SID type

    // Check GetLastError for LookupAccountSid error condition.
    if (bRtnBool == FALSE)
    {
        DWORD dwErrorCode = 0;

        dwErrorCode = GetLastError();

        if (dwErrorCode == ERROR_NONE_MAPPED)
        {
            _tprintf(TEXT("Account owner not found for specified SID.\n"));
        }
        else
        {
            _tprintf(TEXT("Error in LookupAccountSid.\n"));
        }
        return false;

    }
    else if (bRtnBool == TRUE)
    {

        // Print the account name.
        _tprintf(TEXT("Account owner = %s\n"), AcctName);
        Owner = AcctName;
        return true;
    }
#endif
    return false;
}

int main(int argc, char *argv[])
{
    std::string Filename = argv[0];
    if (argc > 1)
    {
        Filename = argv[1];
    }
    std::cout << "File " << Filename << " is owned by: ";
    //
    std::string Owner;
    bool OK = getOwner(Filename, Owner);
    if (OK)
    {
        std::cout << Owner << "." << std::endl;
    }
    else
    {
        std::cout << "Unknown." << std::endl;
    }
    return 0;
}

Answer 1

Ich fürchte, das, was Sie erreichen möchten, wird nicht von der Bibliothek boost::filesystem abgedeckt.Es ist möglich, es abzurufen Dateiberechtigungen, aber für den Besitz müssten Sie auf etwas anderes zurückgreifen oder Ihr eigenes schreiben.

Hier ist eine Erklärung, wie es geht Windows Und Linux.