/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    psxsup.c

Abstract:

    PSX Support Routines

Author:

    Mark Lucovsky (markl) 27-Nov-1989

Revision History:

--*/

#include "psxsrv.h"
#include <ntlsa.h>
#include <ntsam.h>
#include <ntseapi.h>
#include "sesport.h"

#include "seposix.h"

#define UNICODE
#include <windows.h>
#include <lm.h>
#include <lmaccess.h>

#include <sys/stat.h>

//
// This number will never be returned in the PosixOffset field of
// a trusted domain query.
//
#define INVALID_POSIX_OFFSET 1

ULONG
PsxStatusToErrno(
    IN NTSTATUS Status
    )

/*++

Routine Description:

    This procedure converts an NT status code to an
    equivalent errno value.

    The conversion is a function of the status code class.

Arguments:

    Class - Supplies the status code class to use.

    Status - Supplies the status code to convert.

Return Value:

    Returns an equivalent error code to the supplied status code.

--*/

{
    ULONG Error;

    switch (Status) {

    case STATUS_INVALID_PARAMETER:
        Error = EINVAL;
        break;

    case STATUS_DIRECTORY_NOT_EMPTY:
        // Error = ENOTEMPTY;
        Error = EEXIST;
        break;

    case STATUS_OBJECT_PATH_INVALID:
    case STATUS_OBJECT_PATH_SYNTAX_BAD:
    case STATUS_NOT_A_DIRECTORY:
        Error = ENOTDIR;
        break;

    case STATUS_OBJECT_NAME_COLLISION:
        Error = EEXIST;
        break;

    case STATUS_OBJECT_PATH_NOT_FOUND:
    case STATUS_OBJECT_NAME_NOT_FOUND:
    case STATUS_DELETE_PENDING:
    case STATUS_NO_SUCH_FILE:
        Error = ENOENT;
        break;

    case STATUS_NO_MEMORY:
    case STATUS_INSUFFICIENT_RESOURCES:
        Error = ENOMEM;
        break;

    case STATUS_CANNOT_DELETE:
        Error = ETXTBUSY;
        break;

    case STATUS_DISK_FULL:
        Error = ENOSPC;
        break;

    case STATUS_MEDIA_WRITE_PROTECTED:
        Error = EROFS;
        break;

    case STATUS_OBJECT_NAME_INVALID:
        Error = ENAMETOOLONG;
        break;

    case STATUS_FILE_IS_A_DIRECTORY:
        Error = EISDIR;
        break;

    case STATUS_NOT_SAME_DEVICE:
        Error = EXDEV;
        break;

    case STATUS_INVALID_OWNER:
        Error = EPERM;
        break;

    case STATUS_INVALID_IMAGE_FORMAT:
    case STATUS_INVALID_IMAGE_LE_FORMAT:
    case STATUS_INVALID_IMAGE_NOT_MZ:
    case STATUS_INVALID_IMAGE_PROTECT:
    case STATUS_INVALID_IMAGE_WIN_16:
        Error = ENOEXEC;
        break;

    case STATUS_NOT_IMPLEMENTED:
        Error = ENOSYS;
        break;

    case STATUS_TOO_MANY_LINKS:
        Error = EMLINK;
        break;

    default:
        Error = EACCES;
    }

    return Error;
}

ULONG
PsxStatusToErrnoPath(
    IN PUNICODE_STRING Path
    )
/*++

Routine Description:

    This procedure is called when an NtOpenFile returns
        STATUS_OBJECT_PATH_NOT_FOUND; this routine is to
        distinguish the following too cases:

                /file.c/foo, where file.c exists (ENOTDIR)
                /noent/foo, where noent doesn't exist (ENOENT)

        (NtOpenFile returns OBJECT_PATH_NOT_FOUND for both cases).

Arguments:

    Path - Supplies the path that was given to NtOpenFile.  The
        path string is destroyed by this function.

Return Value:

    Returns an equivalent error code to the supplied status code.

--*/
{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES Obj;
    HANDLE FileHandle;
    ULONG DesiredAccess;
    IO_STATUS_BLOCK Iosb;
    ULONG Options;
    PWCHAR pwc, pwcSav;
    ULONG MinLen;

    PSX_GET_SIZEOF(DOSDEVICE_X_W,MinLen);

    DesiredAccess = SYNCHRONIZE;
    Options = FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE;

    pwcSav = NULL;
        
    for (;;) {
        //
        // Remove a trailing component.
        //

        pwc = wcsrchr(Path->Buffer, L'\\');

        if (pwcSav)
            *pwcSav = L'\\';

        if (NULL == pwc) {
            break;
        }
        *pwc = UNICODE_NULL;
        pwcSav = pwc;

        Path->Length = wcslen(Path->Buffer) * sizeof(WCHAR);

        if (Path->Length <= MinLen) {
            *pwcSav = L'\\';
            break;
        }

        InitializeObjectAttributes(&Obj, Path, 0, NULL, NULL);

        Status = NtOpenFile(&FileHandle, DesiredAccess, &Obj,
            &Iosb, SHARE_ALL, Options);
        if (NT_SUCCESS(Status)) {
            NtClose(FileHandle);
        }

        if (STATUS_NOT_A_DIRECTORY == Status) {
            *pwcSav = L'\\';
            Path->Length = wcslen(Path->Buffer) * sizeof(WCHAR);
            return ENOTDIR;
        }
    }
    Path->Length = wcslen(Path->Buffer) * sizeof(WCHAR);
    return ENOENT;
}

ULONG
PsxDetermineFileClass(
    IN HANDLE FileHandle
    )

/*++

Routine Description:

    This function examines a file handle and returns its FileClass

Arguments:

    FileHandle - Supplies a handle to an open file whose class is to be
        determined.

Return Value:

    The file class of the specified file. Defined in <sys/stat.h>.

--*/

{
    NTSTATUS st;
    IO_STATUS_BLOCK Iosb;
    FILE_BASIC_INFORMATION BasicInfo;
    FILE_FS_DEVICE_INFORMATION DeviceInfo;

    //
    // Call NtQueryFile to get device type and attributes
    //

    st = NtQueryInformationFile(
            FileHandle,
            &Iosb,
            &BasicInfo,
            sizeof(BasicInfo),
            FileBasicInformation
            );
    if (!NT_SUCCESS(st)) {
        // XXX.mjb: Sometimes fails on HPFS
        KdPrint(("PSXS: PsxDetermineFileClass: NtQueryInfoFile: 0x%x\n", st));
        return S_IFREG;
    }

    st = NtQueryVolumeInformationFile(
            FileHandle,
            &Iosb,
            &DeviceInfo,
            sizeof(DeviceInfo),
            FileFsDeviceInformation
            );

    ASSERT(NT_SUCCESS(st));

    switch (DeviceInfo.DeviceType) {

    case FILE_DEVICE_DATALINK:
    case FILE_DEVICE_KEYBOARD:
    case FILE_DEVICE_MOUSE:
    case FILE_DEVICE_NETWORK:
    case FILE_DEVICE_NULL:
    case FILE_DEVICE_PHYSICAL_NETCARD:
    case FILE_DEVICE_PARALLEL_PORT:
    case FILE_DEVICE_PRINTER:
    case FILE_DEVICE_SOUND:
    case FILE_DEVICE_SCREEN:
    case FILE_DEVICE_SERIAL_PORT:
    case FILE_DEVICE_TRANSPORT:
        return S_IFCHR;

    case FILE_DEVICE_DFS:
    case FILE_DEVICE_DISK_FILE_SYSTEM:
    case FILE_DEVICE_NETWORK_FILE_SYSTEM:
        return S_IFBLK;

    case FILE_DEVICE_DISK:
    case FILE_DEVICE_VIRTUAL_DISK:
    case FILE_DEVICE_TAPE:
        break;

    default:
                break;
        // return 0;
    }

    //
    // The only thing left is RegularFile class. Now
    // determine if this is a directory, named pipe,
    // or regular file.
    //

    if (BasicInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        return S_IFDIR;
    }

    //
    // For now, anything marked as a system file is a named pipe.
    // In the future, this will involve checking to see if file
    // has the Object Bit and has the appropriate EA (named pipe
    // class id).
    //

    if (BasicInfo.FileAttributes & FILE_ATTRIBUTE_SYSTEM) {
        return S_IFIFO;
    }

    return S_IFREG;

}

VOID
EndImpersonation(
    VOID
    )
{
    HANDLE Handle;
    NTSTATUS Status;

    Handle = NULL;
    Status = NtSetInformationThread(NtCurrentThread(), ThreadImpersonationToken,
            (PVOID)&Handle, sizeof(HANDLE));
    ASSERT(NT_SUCCESS(Status));
}

//
// MakePosixId -- convert the given SID into a Posix Id.  This basically
//      means find the Posix Offset and add it to the last sub-authority
//      in the SID.  The Posix Id is returned.
//

uid_t
MakePosixId(PSID Sid)
{
    NTSTATUS Status;
    LSA_HANDLE
            PolicyHandle,
            TrustedDomainHandle;
    PTRUSTED_POSIX_OFFSET_INFO
            pPosixOff;
    OBJECT_ATTRIBUTES
            Obj;
    SECURITY_QUALITY_OF_SERVICE
            SecurityQoS;
    CHAR    buf[SECURITY_DESCRIPTOR_MIN_LENGTH];
    PSECURITY_DESCRIPTOR
            SecurityDescriptor = (PVOID)buf;
    PSID    DomainSid;
    ULONG   RelativeId, offset;
    UNICODE_STRING
            DCName,
            Domain_U;
    PPOLICY_ACCOUNT_DOMAIN_INFO
            AccountDomainInfo;
    PPOLICY_PRIMARY_DOMAIN_INFO
            PrimaryDomainInfo;
    UCHAR   SubAuthCount;
    LPBYTE  netbuf;
    ULONG   i;

    SubAuthCount = *RtlSubAuthorityCountSid(Sid);
    RelativeId = *RtlSubAuthoritySid(Sid, SubAuthCount - 1);

    //
    // Map S-1-5-5-X-Y to Id 0xFFF
    //

    if (3 == SubAuthCount &&
        5 == RtlIdentifierAuthoritySid(Sid)->Value[5] &&
        5 == *RtlSubAuthoritySid(Sid, 0)) {
        return 0xFFF;
    }

    //
    // First copy the given Sid to a Sid for that domain.
    //

    DomainSid = RtlAllocateHeap(PsxHeap, 0, RtlLengthSid(Sid));
    if (NULL == DomainSid) {
        KdPrint(("PSXSS: MakePosixId: no memory\n"));
        return 0;
    }

    Status = RtlCopySid(RtlLengthSid(Sid), DomainSid, Sid);
    ASSERT(NT_SUCCESS(Status));

    --*RtlSubAuthorityCountSid(DomainSid);

    //
    // See if the offset for the domain is already known.
    //

    if (INVALID_POSIX_OFFSET != (offset = GetOffsetBySid(DomainSid))) {
        // XXX.mjb: close handles, free memory.
        RtlFreeHeap(PsxHeap, 0, (PVOID)DomainSid);
        return (offset | RelativeId);
    }

    //
    // If the Domain part of the passed-in Sid is our account domain,
    // then the offset is known.
    //

    SecurityQoS.ImpersonationLevel = SecurityIdentification;
    SecurityQoS.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
    SecurityQoS.EffectiveOnly = TRUE;

    InitializeObjectAttributes(&Obj, NULL, 0, NULL, NULL);
    Obj.SecurityQualityOfService = &SecurityQoS;

    Status = LsaOpenPolicy(NULL, &Obj, GENERIC_EXECUTE, &PolicyHandle);
    if (!NT_SUCCESS(Status)) {
        KdPrint(("PSXSS: Can't open policy: 0x%x\n", Status));
        RtlFreeHeap(PsxHeap, 0, (PVOID)DomainSid);
        return 0;
    }

    Status = LsaQueryInformationPolicy(PolicyHandle,
            PolicyAccountDomainInformation, (PVOID *)&AccountDomainInfo);
    if (!NT_SUCCESS(Status)) {
        KdPrint(("PSXSS: Can't query info policy: 0x%x\n", Status));
        return 0;
    }
    ASSERT(NULL != AccountDomainInfo->DomainSid);

    if (RtlEqualSid(AccountDomainInfo->DomainSid, DomainSid)) {
        MapSidToOffset(DomainSid, SE_ACCOUNT_DOMAIN_POSIX_OFFSET);
        LsaFreeMemory(AccountDomainInfo);
        LsaClose(PolicyHandle);
        return RelativeId | SE_ACCOUNT_DOMAIN_POSIX_OFFSET;
    }
    LsaFreeMemory(AccountDomainInfo);

    Status = LsaQueryInformationPolicy(PolicyHandle,
            PolicyPrimaryDomainInformation, (PVOID *)&PrimaryDomainInfo);
    ASSERT(NT_SUCCESS(Status));

    if (NULL == PrimaryDomainInfo->Sid) {
        //
        // This machine does not have a primary domain, and the
        // sid we're mapping does not belong to the account domain
        // and is not a well-known sid.
        //
        RtlFreeHeap(PsxHeap, 0, (PVOID)DomainSid);
        LsaFreeMemory(PrimaryDomainInfo);
        LsaClose(PolicyHandle);
        return RelativeId;
    }

    if (NULL != PrimaryDomainInfo->Sid &&
        RtlEqualSid(PrimaryDomainInfo->Sid, DomainSid)) {
        MapSidToOffset(DomainSid, SE_PRIMARY_DOMAIN_POSIX_OFFSET);
        LsaFreeMemory(PrimaryDomainInfo);
        LsaClose(PolicyHandle);
        return RelativeId | SE_PRIMARY_DOMAIN_POSIX_OFFSET;
    }

    Status = NetGetAnyDCName(NULL,
            PrimaryDomainInfo->Name.Buffer,
            &netbuf);
    if (Status != ERROR_SUCCESS) {
        RtlFreeHeap(PsxHeap, 0, (PVOID)DomainSid);
        LsaFreeMemory(PrimaryDomainInfo);
        LsaClose(PolicyHandle);
        return RelativeId;
    }
    DCName.Buffer = (PVOID)netbuf;
    NetApiBufferSize(netbuf, (LPDWORD)&DCName.MaximumLength);
    DCName.Length = wcslen((PWCHAR)netbuf) * sizeof(WCHAR);

    LsaClose(PolicyHandle);

    Status = LsaOpenPolicy(&DCName, &Obj, GENERIC_EXECUTE, &PolicyHandle);
    if (!NT_SUCCESS(Status)) {
        KdPrint(("PSXSS: Can't open policy on DC %wZ: 0x%x\n", &DCName,
            Status));
        LsaFreeMemory(PrimaryDomainInfo);
        RtlFreeHeap(PsxHeap, 0, (PVOID)DomainSid);
        return RelativeId;
    }
            
    NetApiBufferFree(netbuf);
    LsaFreeMemory(PrimaryDomainInfo);

    Status = LsaOpenTrustedDomain(PolicyHandle, DomainSid, GENERIC_EXECUTE,
                &TrustedDomainHandle);
    if (!NT_SUCCESS(Status)) {
        KdPrint(("PSXSS: Can't open trusted domain\n"));
        RtlFreeHeap(PsxHeap, 0, (PVOID)DomainSid);
        return RelativeId;
    }

    Status = LsaQueryInfoTrustedDomain(TrustedDomainHandle,
                TrustedPosixOffsetInformation,
                (PVOID)&pPosixOff);
    if (!NT_SUCCESS(Status)) {
        KdPrint(("PSXSS: Can't query Posix offset info: 0x%x\n",
            Status));
        LsaClose(PolicyHandle);
        LsaClose(TrustedDomainHandle);
        RtlFreeHeap(PsxHeap, 0, (PVOID)DomainSid);
        return RelativeId;
    }

    offset = pPosixOff->Offset;

    LsaFreeMemory(pPosixOff);

    if (offset & 0xFFFF) {
        KdPrint(("PSXSS: bad PsxOffset 0x%x\n", offset));
        RtlFreeHeap(PsxHeap, 0, (PVOID)DomainSid);
        LsaClose(TrustedDomainHandle);
        LsaClose(PolicyHandle);
        offset = 0;
    }

    ASSERT(INVALID_POSIX_OFFSET != offset);

    MapSidToOffset(DomainSid, offset);

    //
    // Do not free DomainSid -- there is still a reference to it in
    // the Sid-Offset cache (put there by MapSidToOffset).
    //

    LsaClose(PolicyHandle);
    LsaClose(TrustedDomainHandle);

    return offset | RelativeId;
}

typedef struct _SID_AND_OFFSET {
    LIST_ENTRY Links;
    PSID Sid;
    ULONG Offset;
} SID_AND_OFFSET, *PSID_AND_OFFSET;

LIST_ENTRY SidList;
RTL_CRITICAL_SECTION SidListMutex;

//
// GetOffsetBySid -- search the SidList for the given Sid.  If we've
//      encountered this domain before, we'll know the Posix offset,
//      which is returned.  If not, INVALID_POSIX_OFFSET is returned.
//
ULONG
GetOffsetBySid(PSID Sid)
{
    PSID_AND_OFFSET pSO;
    ULONG Offset = INVALID_POSIX_OFFSET;

    RtlEnterCriticalSection(&SidListMutex);

    for (pSO = (PSID_AND_OFFSET)SidList.Flink;
         pSO != (PSID_AND_OFFSET)&SidList;
         pSO = (PSID_AND_OFFSET)pSO->Links.Flink) {
        if (RtlEqualSid(Sid, pSO->Sid)) {
            Offset = pSO->Offset;
            break;
        }
    }

    RtlLeaveCriticalSection(&SidListMutex);

    return Offset;
}

//
// GetSidByOffset -- search the SidList for the given offset.  Called in
//      the process of converting a uid or gid to a Sid, as in getpwuid().
//
PSID
GetSidByOffset(ULONG Offset)
{
    PSID_AND_OFFSET pSO;
    PSID Sid = NULL;

    RtlEnterCriticalSection(&SidListMutex);

    for (pSO = (PSID_AND_OFFSET)SidList.Flink;
         pSO != (PSID_AND_OFFSET)&SidList;
         pSO = (PSID_AND_OFFSET)pSO->Links.Flink) {
        if (Offset == pSO->Offset) {
            Sid = pSO->Sid;
            break;
        }
    }

    RtlLeaveCriticalSection(&SidListMutex);

    return Sid;
}

//
// MapSidToOffset -- add the given sid and offset to the cache.  If there's
//      an error, like no memory, it's simply dropped on the floor.
//
VOID
MapSidToOffset(PSID Sid, ULONG Offset)
{
    PSID_AND_OFFSET pSO;

    pSO = RtlAllocateHeap(PsxHeap, 0, sizeof(*pSO));
    if (NULL == pSO) {
        return;
    }

    pSO->Sid = Sid;
    pSO->Offset = Offset;

    RtlEnterCriticalSection(&SidListMutex);

    InsertHeadList(&SidList, &pSO->Links);

    RtlLeaveCriticalSection(&SidListMutex);
}

//
// InitSidList -- do initialization, including mapping special Sids to
//      their appropriate offsets.  No locking is done, assumed to be
//      called in a single-threaded way.
//
VOID
InitSidList(VOID)
{
    NTSTATUS Status;
    PSID Sid;
    SID_IDENTIFIER_AUTHORITY
    AuthSec = SECURITY_NT_AUTHORITY,
    Auth0 = SECURITY_NULL_SID_AUTHORITY,
    Auth1 = SECURITY_WORLD_SID_AUTHORITY,
    Auth2 = SECURITY_LOCAL_SID_AUTHORITY,
    Auth3 = SECURITY_CREATOR_SID_AUTHORITY,
    Auth4 = SECURITY_NON_UNIQUE_AUTHORITY,
    Auth5 = SECURITY_NT_AUTHORITY;

    RtlInitializeCriticalSection(&SidListMutex);
    InitializeListHead(&SidList);

    Status = RtlAllocateAndInitializeSid(&Auth0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, &Sid);
    ASSERT(NT_SUCCESS(Status));
    MapSidToOffset(Sid, SE_NULL_POSIX_ID);

    Status = RtlAllocateAndInitializeSid(&Auth1, 0,
        0, 0, 0, 0, 0, 0, 0, 0, &Sid);
    ASSERT(NT_SUCCESS(Status));
    MapSidToOffset(Sid, SE_WORLD_POSIX_ID);

    Status = RtlAllocateAndInitializeSid(&Auth2, 0,
        0, 0, 0, 0, 0, 0, 0, 0, &Sid);
    ASSERT(NT_SUCCESS(Status));
    MapSidToOffset(Sid, SE_LOCAL_POSIX_ID);

    Status = RtlAllocateAndInitializeSid(&Auth3, 0,
        0, 0, 0, 0, 0, 0, 0, 0, &Sid);
    ASSERT(NT_SUCCESS(Status));
    MapSidToOffset(Sid, SE_CREATOR_OWNER_POSIX_ID);

    Status = RtlAllocateAndInitializeSid(&Auth4, 0,
        0, 0, 0, 0, 0, 0, 0, 0, &Sid);
    ASSERT(NT_SUCCESS(Status));
    MapSidToOffset(Sid, SE_NON_UNIQUE_POSIX_ID);

    Status = RtlAllocateAndInitializeSid(&Auth5, 0,
        0, 0, 0, 0, 0, 0, 0, 0, &Sid);
    ASSERT(NT_SUCCESS(Status));
    MapSidToOffset(Sid, SE_AUTHORITY_POSIX_ID);

    //
    // "Builtin" domain has known offset.
    //

    Status = RtlAllocateAndInitializeSid(&AuthSec, 1,
        SECURITY_BUILTIN_DOMAIN_RID, 0, 0, 0, 0, 0, 0, 0, &Sid);
    ASSERT(NT_SUCCESS(Status));
    MapSidToOffset(Sid, SE_BUILT_IN_DOMAIN_POSIX_OFFSET);
}

//
//  AccessMaskToMode -- convert a set of NT ACCESS_MASKS to the POSIX
//      mode_t.
//
mode_t
AccessMaskToMode(
    ACCESS_MASK UserAccess,
    ACCESS_MASK GroupAccess,
    ACCESS_MASK OtherAccess
    )
{
    mode_t Mode = 0;
    int i;
    PACCESS_MASK pAM;

    //
    // Make sure that if a GENERIC_ACCESS is set, we notice that
    // the mask implies FILE_GENERIC_ACCESS.
    //

    for (i = 0; i < 3; ++i) {
        switch (i) {
        case 0:
            pAM = &UserAccess;
            break;
        case 1:
            pAM = &GroupAccess;
            break;
        case 2:
            pAM = &OtherAccess;
            break;
        }
        if (*pAM & GENERIC_READ) {
            *pAM |= FILE_GENERIC_READ;
        }
        if (*pAM & GENERIC_WRITE) {
            *pAM |= FILE_GENERIC_WRITE;
        }
        if (*pAM & GENERIC_EXECUTE) {
            *pAM |= FILE_GENERIC_EXECUTE;
        }
        if (*pAM & GENERIC_ALL) {
            *pAM |= FILE_ALL_ACCESS;
        }
    }


    if (UserAccess & FILE_READ_DATA) {
        Mode |= S_IRUSR;
    }
    if ((UserAccess & FILE_WRITE_DATA) &&
        (UserAccess & FILE_APPEND_DATA)) {
        Mode |= S_IWUSR;
    }
    if (UserAccess & FILE_EXECUTE) {
        Mode |= S_IXUSR;
    }

    if (GroupAccess & FILE_READ_DATA) {
        Mode |= S_IRGRP;
    }
    if ((GroupAccess & FILE_WRITE_DATA) &&
        (GroupAccess & FILE_APPEND_DATA)) {
        Mode |= S_IWGRP;
    }
    if (GroupAccess & FILE_EXECUTE) {
        Mode |= S_IXGRP;
    }

    if (OtherAccess & FILE_READ_DATA) {
        Mode |= S_IROTH;
    }
    if ((OtherAccess & FILE_WRITE_DATA) &&
        (OtherAccess & FILE_APPEND_DATA)) {
        Mode |= S_IWOTH;
    }
    if (OtherAccess & FILE_EXECUTE) {
        Mode |= S_IXOTH;
    }
    return Mode;
}

void
ModeToAccessMask(
    mode_t Mode,
    PACCESS_MASK pUserAccess,
    PACCESS_MASK pGroupAccess,
    PACCESS_MASK pOtherAccess
    )
{
    //
    // All ACL's have these standard permissions: 
    // READ_ATTR and READ_EA so anybody can access() any file.
    //

    *pUserAccess = SYNCHRONIZE |
            READ_CONTROL | FILE_READ_ATTRIBUTES | FILE_READ_EA;
    *pGroupAccess = *pOtherAccess = *pUserAccess;

    //
    // The owner always gets WRITE_DAC (for chmod), FILE_WRITE_ATTR
    // (for utimes), and WRITE_OWNER (for chgrp).
    //
    *pUserAccess |= (WRITE_DAC | WRITE_OWNER | FILE_WRITE_ATTRIBUTES);

    if (Mode & S_IRUSR) {
        *pUserAccess |= FILE_GENERIC_READ | FILE_LIST_DIRECTORY;
    }
    if (Mode & S_IWUSR) {
        *pUserAccess |= FILE_GENERIC_WRITE | FILE_DELETE_CHILD;
    }
    if (Mode & S_IXUSR) {
        *pUserAccess |= FILE_GENERIC_EXECUTE;
    }

    if (Mode & S_IRGRP) {
        *pGroupAccess |= FILE_GENERIC_READ | FILE_LIST_DIRECTORY;
    }
    if (Mode & S_IWGRP) {
        *pGroupAccess |= FILE_GENERIC_WRITE | FILE_DELETE_CHILD;
    }
    if (Mode & S_IXGRP) {
        *pGroupAccess |= FILE_GENERIC_EXECUTE;
    }

    if (Mode & S_IROTH) {
        *pOtherAccess |= FILE_GENERIC_READ | FILE_LIST_DIRECTORY;
    }
    if (Mode & S_IWOTH) {
        *pOtherAccess |= FILE_GENERIC_WRITE | FILE_DELETE_CHILD;
    }
    if (Mode & S_IXOTH) {
        *pOtherAccess |= FILE_GENERIC_EXECUTE;
    }
}