"""
Support routines for subprocess and multiprocess module.
Currently, this extension module is only required when using the
modules on Windows.
"""

import sys

if sys.platform != 'win32':
    raise ModuleNotFoundError("The '_winapi' module is only available on Windows", name="_winapi")

# Declare external Win32 functions

if sys.maxsize > 2 ** 31:
    from _pypy_winbase_cffi64 import ffi as _ffi
else:
    from _pypy_winbase_cffi import ffi as _ffi
_kernel32 = _ffi.dlopen('kernel32')

GetVersion = _kernel32.GetVersion
NULL = _ffi.NULL

def SetLastError(errno):
    return _kernel32.SetLastError(errno)

def GetLastError():
    return _kernel32.GetLastError()

def GetACP():
    return _kernel32.GetACP()

# Now the _subprocess module implementation
def raise_WinError(type=WindowsError):
    code, message = _ffi.getwinerror()
    excep = type(None, message, None ,code)
    raise excep

# In CPython PyErr_SetFromWindowsErr converts a windows error into a python object
# Not sure what we should do here.
def RaiseFromWindowsErr(err):
    if err == 0:
       err = _kernel32.GetLastError()

    if err == ERROR_CONNECTION_REFUSED:
        type = ConnectionRefusedError
    elif err == ERROR_CONNECTION_ABORTED:
        type = ConnectionAbortedError
    else:
        type = WindowsError

    raise_WinError(type)

def _int2handle(val):
    return _ffi.cast("HANDLE", val)

def _handle2int(handle):
    return int(_ffi.cast("intptr_t", handle))

def CreatePipe(attributes, size):
    handles = _ffi.new("HANDLE[2]")
    
    res = _kernel32.CreatePipe(handles, handles + 1, NULL, size)

    if not res:
        RaiseFromWindowsErr(GetLastError())

    return _handle2int(handles[0]), _handle2int(handles[1])

def CreateNamedPipe(*args):
    handle = _kernel32.CreateNamedPipeW(*args)
    if handle == INVALID_HANDLE_VALUE:
        RaiseFromWindowsErr(0)
    return _handle2int(handle)

def CreateFile(*args):
    handle = _kernel32.CreateFileW(*args)
    if handle == INVALID_HANDLE_VALUE:
        RaiseFromWindowsErr(0)
    return _handle2int(handle)

def SetNamedPipeHandleState(namedpipe, mode, max_collection_count, collect_data_timeout):
    d0 = _ffi.new('DWORD[1]', [mode])
    if max_collection_count is None:
        d1 = NULL
    else:
        d1 = _ffi.new('DWORD[1]', [max_collection_count])
    if collect_data_timeout is None:
        d2 = NULL
    else:
        d2 = _ffi.new('DWORD[1]', [collect_data_timeout])
    ret = _kernel32.SetNamedPipeHandleState(_int2handle(namedpipe), d0, d1, d2)
    if not ret:
        raise_WinError()

class Overlapped(object):
    def __init__(self, handle):
        self.overlapped = _ffi.new('OVERLAPPED[1]')
        self.handle = _handle2int(handle)
        self.readbuffer = None
        self.pending = 0
        self.completed = 0
        self.writebuffer = None
        self.overlapped[0].hEvent = \
                _kernel32.CreateEventW(NULL, True, False, NULL)
        if not self.overlapped[0].hEvent:
            raise_WinError(IOError)
    def __del__(self):
        # do this somehow else
        err = _kernel32.GetLastError()
        bytes = _ffi.new('DWORD[1]')
        if self.pending:
            result = _kernel32.CancelIoEx(_int2handle(self.handle), self.overlapped)
            if result: 
                _kernel32.GetOverlappedResult(_int2handle(self.handle), self.overlapped, bytes, True)
                # The operation is no longer pending, nothing to do
                
            #else:
                # We need to raise a warning here and not crash pypy
                #raise RuntimeError('deleting an overlapped struct with a pending operation not supported')
        CloseHandle(_int2handle(self.overlapped[0].hEvent))
        _kernel32.SetLastError(err)

    @property
    def event(self):
        return _handle2int(self.overlapped[0].hEvent)

    def GetOverlappedResult(self, wait):
        transferred = _ffi.new('DWORD[1]', [0])
        res = _kernel32.GetOverlappedResult(_int2handle(self.handle), self.overlapped, transferred, wait != 0)
        
        if res:
            err = ERROR_SUCCESS
        else:
            err = _kernel32.GetLastError()

        if err in (ERROR_SUCCESS, ERROR_MORE_DATA, ERROR_OPERATION_ABORTED):
            self.completed = 1
            self.pending = 0
        elif res != ERROR_IO_INCOMPLETE:
            self.pending = 0
            # print('GetOverlappedResult got err', err)
            raise_WinError(IOError)

        if self.completed and self.readbuffer:
            if transferred[0] != len(self.readbuffer):
                tempbuffer = _ffi.new("CHAR[]", transferred[0])
                _ffi.memmove(tempbuffer, self.readbuffer, transferred[0])
                self.readbuffer = tempbuffer
        return transferred[0], err

    def getbuffer(self):
        if not self.completed:
            raise ValueError("can't get read buffer before GetOverlappedResult() "
                        "signals the operation completed")
        if self.readbuffer:
            result = bytes(_ffi.buffer(self.readbuffer))
        else:
            result = None
        return result

    def cancel(self):
        ret = True
        if self.pending:
            ret = _kernel32.CancelIoEx(_int2handle(self.handle), self.overlapped)
        if not ret and _kernel32.GetLastError() != ERROR_NOT_FOUND:
            raise_WinError(IOError)
        self.pending = 0
        return None


def ReadFile(handle, size, overlapped):
    nread = _ffi.new("DWORD*")
    use_overlapped = overlapped

    buf = _ffi.new("CHAR[]", size)
    if not buf:
        raise_WinError(IOError)
    err = 0
    if use_overlapped:
        overlapped = Overlapped(handle)
        overlapped.readbuffer = buf
        ret = _kernel32.ReadFile(_int2handle(handle), buf, size, nread,
                       overlapped.overlapped)
        if not ret:
            err = _kernel32.GetLastError()
            if err == ERROR_IO_PENDING:
                overlapped.pending = 1
            elif err != ERROR_MORE_DATA:
                raise_WinError(IOError)
        return overlapped, err
    else:
        ret = _kernel32.ReadFile(_int2handle(handle), buf, size, nread,
                       _ffi.NULL)
 
    if not ret:
        err = _kernel32.GetLastError()
        if err != ERROR_MORE_DATA:
            raise_WinError(IOError)
    return nread[0], err

def WriteFile(handle, buffer, overlapped=False):
    written = _ffi.new("DWORD*")
    use_overlapped = overlapped
    overlapped = None    
    err = 0
    if use_overlapped:
        overlapped = Overlapped(handle)
        if not overlapped:
            return _ffi.NULL
        overlapped.writebuffer = bytes(buffer)
        buf = overlapped.writebuffer
        ret = _kernel32.WriteFile(_int2handle(handle), buf , len(buf), written, overlapped.overlapped)
        if not ret:
            err = _kernel32.GetLastError()
            if err == ERROR_IO_PENDING:
                overlapped.pending = 1
            else:
                raise_WinError(IOError)
        return overlapped, err
    else:
        buf = _ffi.new("CHAR[]", bytes(buffer))
        ret = _kernel32.WriteFile(_int2handle(handle), buf , len(buf), written, _ffi.NULL)
        if not ret:
            raise_WinError(IOError)
        return written[0], err

 
def ConnectNamedPipe(handle, overlapped=False):
    handle = _int2handle(handle)
    if overlapped:
        ov = Overlapped(handle)
    else:
        ov = Overlapped(None)
    success = _kernel32.ConnectNamedPipe(handle, ov.overlapped)
    if overlapped:
        # Overlapped ConnectNamedPipe never returns a success code
        assert success == 0
        err = _kernel32.GetLastError()
        if err == ERROR_IO_PENDING:
            ov.pending = 1
        elif err == ERROR_PIPE_CONNECTED:
            _kernel32.SetEvent(ov.overlapped[0].hEvent)
        else:
            del ov
            RaiseFromWindowsErr(err)
        return ov
    elif not success:
        RaiseFromWindowsErr(0)

def GetCurrentProcess():
    return _handle2int(_kernel32.GetCurrentProcess())

def DuplicateHandle(source_process, source, target_process, access, inherit, options=0):
    # CPython: the first three arguments are expected to be integers
    target = _ffi.new("HANDLE[1]")

    res = _kernel32.DuplicateHandle(
        _int2handle(source_process),
        _int2handle(source),
        _int2handle(target_process),
        target, access, inherit, options)

    if not res:
        raise_WinError()
    
    return _handle2int(target[0])

def _Z(input):
    if input is None:
        return _ffi.NULL
    if isinstance(input, str):
        return input
    raise TypeError("str or None expected, got %r" % (
        type(input).__name__,))

def CreateProcess(name, command_line, process_attr, thread_attr,
                  inherit, flags, env, start_dir, startup_info):
    si = _ffi.new("STARTUPINFO *")
    if startup_info is not None:
        si.dwFlags = startup_info.dwFlags
        si.wShowWindow = startup_info.wShowWindow
        # CPython: these three handles are expected to be
        # subprocess.Handle (int) objects
        if startup_info.hStdInput:
            si.hStdInput = _int2handle(startup_info.hStdInput)
        if startup_info.hStdOutput:
            si.hStdOutput = _int2handle(startup_info.hStdOutput)
        if startup_info.hStdError:
            si.hStdError = _int2handle(startup_info.hStdError)

    pi = _ffi.new("PROCESS_INFORMATION *")
    flags |= CREATE_UNICODE_ENVIRONMENT

    if env is not None:
        envbuf = ""
        for k, v in env.items():
            envbuf += "%s=%s\0" % (k, v)
        envbuf += '\0'
    else:
        envbuf = _ffi.NULL

    res = _kernel32.CreateProcessW(_Z(name), _Z(command_line), _ffi.NULL,
                                   _ffi.NULL, inherit, flags, envbuf,
                                   _Z(start_dir), si, pi)

    if not res:
        raise_WinError()

    return (_handle2int(pi.hProcess),
            _handle2int(pi.hThread),
            pi.dwProcessId,
            pi.dwThreadId)

def OpenProcess(desired_access, inherit_handle, process_id):
    handle = _kernel32.OpenProcess(desired_access, inherit_handle, process_id)
    if handle == _ffi.NULL:
        RaiseFromWindowsErr(0)
        handle = INVALID_HANDLE_VALUE

    return _handle2int(handle)

def PeekNamedPipe(handle, size=0):
    nread = _ffi.new("DWORD*")
    navail = _ffi.new("DWORD*")
    nleft = _ffi.new("DWORD*")

    if size < 0:
        raise ValueError("negative size")

    if size:
        buf = _ffi.new("CHAR[]", size)
        if not buf:
            return _ffi.NULL

        ret = _kernel32.PeekNamedPipe(_int2handle(handle), buf, size, nread,
                                      navail, nleft)
        if not ret:
            # In CPython SetExcFromWindowsErr is called here.
            # Not sure what that is doing currently.
            RaiseFromWindowsErr(0)


        return  buf, navail[0], nleft[0]
    else:
        ret = _kernel32.PeekNamedPipe(_int2handle(handle), _ffi.NULL, 0, _ffi.NULL, navail, nleft)
        if not ret:
            # In CPython SetExcFromWindowsErr is called here.
            # Not sure what that is doing currently.
            RaiseFromWindowsErr(0)
        return  navail[0], nleft[0]

def WaitForSingleObject(handleI, milliseconds):
    # CPython: the first argument is expected to be an integer.
    if handleI < 0:
        SetLastError(ERROR_INVALID_HANDLE)
        raise_WinError()
    handle = _int2handle(handleI)
    if milliseconds < 0:
        milliseconds = INFINITE
    res = _kernel32.WaitForSingleObject(handle, milliseconds)
    if res == WAIT_FAILED:
        raise_WinError()
    return int(res)


def WaitNamedPipe(namedpipe, milliseconds):
    namedpipe = _ffi.new("CHAR[]", namedpipe.encode("ascii", "ignore"))
    res = _kernel32.WaitNamedPipeA(namedpipe, milliseconds)

    if res < 0:
        raise RaiseFromWindowsErr(0)


def WaitForMultipleObjects(handle_sequence, waitflag, milliseconds):
    if len(handle_sequence) > MAXIMUM_WAIT_OBJECTS:
        return None
    handle_sequence = list(map(_int2handle, handle_sequence))
    handle_sequence = _ffi.new("HANDLE[]", handle_sequence)
    # CPython makes the wait interruptible by ctrl-c. We need to add this in at some point
    res = _kernel32.WaitForMultipleObjects(len(handle_sequence), handle_sequence, waitflag, milliseconds)

    if res == WAIT_FAILED:
        raise_WinError()
    return int(res)


def GetExitCodeProcess(handle):
    # CPython: the first argument is expected to be an integer.
    code = _ffi.new("DWORD[1]")

    res = _kernel32.GetExitCodeProcess(_int2handle(handle), code)

    if not res:
        raise_WinError()

    return code[0]

def TerminateProcess(handle, exitcode):
    # CPython: the first argument is expected to be an integer.
    # The second argument is silently wrapped in a UINT.
    res = _kernel32.TerminateProcess(_int2handle(handle),
                                     _ffi.cast("UINT", exitcode))

    if not res:
        raise_WinError()

def GetStdHandle(stdhandle):
    stdhandle = _ffi.cast("DWORD", stdhandle)
    res = _kernel32.GetStdHandle(stdhandle)

    if not res:
        return None
    else:
        return _handle2int(res)

def CloseHandle(handle):
    res = _kernel32.CloseHandle(_int2handle(handle))

    if not res:
        raise_WinError()

def GetFileType(handle):
    res = _kernel32.GetFileType(_int2handle(handle))

    if res == FILE_TYPE_UNKNOWN and GetLastError() != 0:
        raise_WinError()
    return res

def GetModuleFileName(module):
    buf = _ffi.new("wchar_t[]", _MAX_PATH)
    res = _kernel32.GetModuleFileNameW(_int2handle(module), buf, _MAX_PATH)

    if not res:
        raise_WinError()
    return _ffi.string(buf)

def ExitProcess(exitcode):
    _kernel32.ExitProcess(exitcode)

def CreateJunction(src_path, dst_path):
    import struct

    IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003
    FSCTL_SET_REPARSE_POINT    = 0x000900A4

    if src_path is None or dst_path is None or src_path[:4] == '\\??\\':
        SetLastError(ERROR_INVALID_PARAMETER)
        raise_WinError()

    # Get the full (absolute) path of the link target.
    buf_size = _kernel32.GetFullPathNameW(src_path, 0, _ffi.NULL, _ffi.NULL)
    if buf_size == 0:
        raise_WinError()
    full_buf = _ffi.new("wchar_t[]", buf_size)
    if _kernel32.GetFullPathNameW(src_path, buf_size, full_buf, _ffi.NULL) == 0:
        raise_WinError()
    full_path = _ffi.string(full_buf)

    # Build the reparse data buffer (UTF-16LE, NUL-terminated entries).
    sub_str   = '\\??\\'  + full_path
    sub_bytes = sub_str.encode('utf-16-le')
    prt_bytes = full_path.encode('utf-16-le')
    nul       = b'\x00\x00'
    path_buf  = sub_bytes + nul + prt_bytes + nul

    reparse_data_len = 8 + len(path_buf)   # 8 = MountPoint fixed header size
    header = struct.pack('<IHHHHHH',
        IO_REPARSE_TAG_MOUNT_POINT,
        reparse_data_len,
        0,                        # Reserved
        0,                        # SubstituteNameOffset
        len(sub_bytes),           # SubstituteNameLength
        len(sub_bytes) + 2,       # PrintNameOffset
        len(prt_bytes),           # PrintNameLength
    )
    rdb     = header + path_buf
    rdb_buf = _ffi.new("char[]", rdb)

    if not _kernel32.CreateDirectoryW(dst_path, _ffi.NULL):
        raise_WinError()

    junction = _kernel32.CreateFileW(
        dst_path,
        GENERIC_WRITE, 0, _ffi.NULL,
        OPEN_EXISTING,
        FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
        _ffi.NULL,
    )
    if junction == INVALID_HANDLE_VALUE:
        err = _kernel32.GetLastError()
        _kernel32.RemoveDirectoryW(dst_path)
        _kernel32.SetLastError(err)
        raise_WinError()

    try:
        returned = _ffi.new("DWORD[1]")
        ok = _kernel32.DeviceIoControl(
            junction,
            FSCTL_SET_REPARSE_POINT,
            rdb_buf, len(rdb),
            _ffi.NULL, 0,
            returned,
            _ffi.NULL,
        )
        if not ok:
            raise_WinError()
    finally:
        _kernel32.CloseHandle(junction)

ZERO_MEMORY = 0x00000008

def malloc(size):
    return _kernel32.HeapAlloc(_kernel32.GetProcessHeap(),ZERO_MEMORY,size)

def free(voidptr):
    _kernel32.HeapFree(_kernel32.GetProcessHeap(),0, voidptr)

def CreateFileMapping(*args):
    handle = _kernel32.CreateFileMappingW(*args)
    if handle == INVALID_HANDLE_VALUE:
        RaiseFromWindowsErr(0)
    return _handle2int(handle)

def OpenFileMapping(*args):
    handle = _kernel32.OpenFileMappingW(*args)
    if not handle:
        RaiseFromWindowsErr(0)
    return _handle2int(handle)

def MapViewOfFile(handle, *args):
    address = _kernel32.MapViewOfFile(_int2handle(handle), *args)
    if not address:
        RaiseFromWindowsErr(0)
    return address
        
def VirtualQuerySize(address):
    mem_basic_info = _ffi.new("MEMORY_BASIC_INFORMATION[1]")
  
    size_of_buf = _kernel32.VirtualQuery(address, mem_basic_info, _ffi.sizeof(mem_basic_info))
    if size_of_buf == 0:
        RaiseFromWindowsErr(0)
    return mem_basic_info[0].RegionSize
    
# #define macros from WinBase.h and elsewhere
STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE = -11
STD_ERROR_HANDLE = -12
DUPLICATE_SAME_ACCESS = 2
DUPLICATE_CLOSE_SOURCE = 1
STARTF_USESTDHANDLES = 0x100
STARTF_USESHOWWINDOW = 0x001
SW_HIDE = 0
INFINITE = 0xffffffff
WAIT_OBJECT_0 = 0
WAIT_ABANDONED_0 = 0x80
WAIT_TIMEOUT = 0x102
WAIT_FAILED = 0xFFFFFFFF
DEBUG_PROCESS           = 0x00000001
DEBUG_ONLY_THIS_PROCESS = 0x00000002
CREATE_SUSPENDED        = 0x00000004
DETACHED_PROCESS        = 0x00000008
CREATE_NEW_CONSOLE         = 0x010
CREATE_NEW_PROCESS_GROUP   = 0x200
CREATE_UNICODE_ENVIRONMENT = 0x400
STILL_ACTIVE = 259
_MAX_PATH = 260
INFINITE = 0xFFFFFFFF

ERROR_SUCCESS           = 0
ERROR_INVALID_HANDLE    = 6
ERROR_NETNAME_DELETED   = 64
ERROR_BROKEN_PIPE       = 109
ERROR_SEM_TIMEOUT       = 121
ERROR_PIPE_BUSY         = 231
ERROR_NO_DATA           = 232 
ERROR_MORE_DATA         = 234
ERROR_PIPE_CONNECTED    = 535
ERROR_OPERATION_ABORTED = 995
ERROR_IO_INCOMPLETE     = 996
ERROR_IO_PENDING        = 997
ERROR_NOT_FOUND          = 1168
ERROR_CONNECTION_REFUSED = 1225
ERROR_CONNECTION_ABORTED = 1236
ERROR_ALREADY_EXISTS     = 0xB7
ERROR_INVALID_PARAMETER  = 87


PIPE_ACCESS_INBOUND = 0x00000001
PIPE_ACCESS_OUTBOUND = 0x00000002
PIPE_ACCESS_DUPLEX   = 0x00000003
PIPE_WAIT                  = 0x00000000
PIPE_NOWAIT                = 0x00000001
PIPE_READMODE_BYTE         = 0x00000000
PIPE_READMODE_MESSAGE      = 0x00000002
PIPE_TYPE_BYTE             = 0x00000000
PIPE_TYPE_MESSAGE          = 0x00000004
PIPE_ACCEPT_REMOTE_CLIENTS = 0x00000000
PIPE_REJECT_REMOTE_CLIENTS = 0x00000008

PIPE_UNLIMITED_INSTANCES = 255

GENERIC_READ   =  0x80000000
GENERIC_WRITE  =  0x40000000
GENERIC_EXECUTE=  0x20000000
GENERIC_ALL    =  0x10000000
INVALID_HANDLE_VALUE = _int2handle(-1)
FILE_FLAG_WRITE_THROUGH       =  0x80000000
FILE_FLAG_OVERLAPPED          =  0x40000000
FILE_FLAG_NO_BUFFERING        =  0x20000000
FILE_FLAG_RANDOM_ACCESS       =  0x10000000
FILE_FLAG_SEQUENTIAL_SCAN     =  0x08000000
FILE_FLAG_DELETE_ON_CLOSE     =  0x04000000
FILE_FLAG_BACKUP_SEMANTICS    =  0x02000000
FILE_FLAG_POSIX_SEMANTICS     =  0x01000000
FILE_FLAG_OPEN_REPARSE_POINT  =  0x00200000
FILE_FLAG_OPEN_NO_RECALL      =  0x00100000
FILE_FLAG_FIRST_PIPE_INSTANCE =  0x00080000

NMPWAIT_WAIT_FOREVER          =  0xffffffff
NMPWAIT_NOWAIT                =  0x00000001
NMPWAIT_USE_DEFAULT_WAIT      =  0x00000000

FILE_READ_DATA = 1
FILE_WRITE_DATA = 2
FILE_APPEND_DATA = 4
FILE_READ_EA = 8
FILE_WRITE_EA = 16
FILE_EXECUTE = 32
FILE_READ_ATTRIBUTES = 128 
FILE_WRITE_ATTRIBUTES = 256
READ_CONTROL = 0x00020000
SYNCHRONIZE = 0x00100000
STANDARD_RIGHTS_EXECUTE = READ_CONTROL
STANDARD_RIGHTS_READ = READ_CONTROL
STANDARD_RIGHTS_WRITE = READ_CONTROL

FILE_GENERIC_EXECUTE = FILE_EXECUTE | FILE_READ_ATTRIBUTES | STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE
FILE_GENERIC_READ = FILE_READ_ATTRIBUTES | FILE_READ_DATA | FILE_READ_EA | STANDARD_RIGHTS_READ | SYNCHRONIZE
FILE_GENERIC_WRITE = FILE_APPEND_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_DATA | FILE_WRITE_EA | STANDARD_RIGHTS_WRITE | SYNCHRONIZE

PROCESS_DUP_HANDLE = 0x0040

CREATE_NEW        = 1
CREATE_ALWAYS     = 2
OPEN_EXISTING     = 3
OPEN_ALWAYS       = 4
TRUNCATE_EXISTING = 5

MAXIMUM_WAIT_OBJECTS = 64

BELOW_NORMAL_PRIORITY_CLASS = 0x00004000
ABOVE_NORMAL_PRIORITY_CLASS = 0x00008000
NORMAL_PRIORITY_CLASS       = 0x00000020
IDLE_PRIORITY_CLASS         = 0x00000040
HIGH_PRIORITY_CLASS         = 0x00000080
REALTIME_PRIORITY_CLASS     = 0x00000100
BELOW_NORMAL_PRIORITY_CLASS = 0x00004000
CREATE_BREAKAWAY_FROM_JOB   = 0x01000000
CREATE_DEFAULT_ERROR_MODE   = 0x04000000
CREATE_NO_WINDOW            = 0x08000000

FILE_TYPE_CHAR = 2
FILE_TYPE_DISK = 1
FILE_TYPE_PIPE = 3
FILE_TYPE_REMOTE = 32768
FILE_TYPE_UNKNOWN = 0

# Used in CreateFileMapping
PAGE_EXECUTE_READ = 0x20
PAGE_EXECUTE_READWRITE = 0x40
PAGE_EXECUTE_WRITECOPY = 0x80
PAGE_READONLY = 0x02
PAGE_READWRITE = 0x04
PAGE_WRITECOPY = 0x08
SEC_COMMIT = 0x8000000
SEC_IMAGE = 0x1000000
SEC_IMAGE_NO_EXECUTE = 0x11000000
SEC_LARGE_PAGES = 0x80000000
SEC_NOCACHE = 0x10000000
SEC_RESERVE = 0x4000000
SEC_WRITECOMBINE = 0x40000000

# Used in MapViewOfFile
STANDARD_RIGHTS_REQUIRED     = 0x000F0000
SECTION_QUERY                = 0x0001
SECTION_MAP_WRITE            = 0x0002
SECTION_MAP_READ             = 0x0004
SECTION_MAP_EXECUTE          = 0x0008
SECTION_EXTEND_SIZE          = 0x0010
SECTION_MAP_EXECUTE_EXPLICIT = 0x0020 
SECTION_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED|SECTION_QUERY|
                            SECTION_MAP_WRITE |
                            SECTION_MAP_READ |
                            SECTION_MAP_EXECUTE |
                            SECTION_EXTEND_SIZE)


FILE_MAP_WRITE           = SECTION_MAP_WRITE
FILE_MAP_READ            = SECTION_MAP_READ
FILE_MAP_ALL_ACCESS      = SECTION_ALL_ACCESS
FILE_MAP_EXECUTE         = SECTION_MAP_EXECUTE_EXPLICIT
FILE_MAP_COPY            = 0x00000001
FILE_MAP_RESERVE         = 0x80000000
FILE_MAP_TARGETS_INVALID = 0x40000000
FILE_MAP_LARGE_PAGES     = 0x20000000
