winbase.odl

来自「The code for this article was written fo」· ODL 代码 · 共 2,193 行 · 第 1/4 页

        DWORD dwPositionType,
        LPDWORD lpdwPartition,
        LPDWORD lpdwOffsetLow,
        LPDWORD lpdwOffsetHigh
        );

    DWORD WINAPI PrepareTape(
        HANDLE hDevice,
        DWORD dwOperation,
        BOOL bImmediate
        );

    DWORD WINAPI EraseTape(
        HANDLE hDevice,
        DWORD dwEraseType,
        BOOL bImmediate
        );

    DWORD WINAPI CreateTapePartition(
        HANDLE hDevice,
        DWORD dwPartitionMethod,
        DWORD dwCount,
        DWORD dwSize
        );

    DWORD WINAPI WriteTapemark(
        HANDLE hDevice,
        DWORD dwTapemarkType,
        DWORD dwTapemarkCount,
        BOOL bImmediate
        );

    DWORD WINAPI GetTapeStatus(
        HANDLE hDevice
        );

    DWORD WINAPI GetTapeParameters(
        HANDLE hDevice,
        DWORD dwOperation,
        LPDWORD lpdwSize,
        LPVOID lpTapeInformation
        );

    //const int GET_TAPE_MEDIA_INFORMATION = 0;
    //const int GET_TAPE_DRIVE_INFORMATION = 1;

    DWORD WINAPI SetTapeParameters(
        HANDLE hDevice,
        DWORD dwOperation,
        LPVOID lpTapeInformation
        );

    //const int SET_TAPE_MEDIA_INFORMATION = 0;
    //const int SET_TAPE_DRIVE_INFORMATION = 1;

    BOOL WINAPI BackupRead(
        HANDLE hFile,
        LPBYTE lpBuffer,
        DWORD nNumberOfBytesToRead,
        LPDWORD lpNumberOfBytesRead,
        BOOL bAbort,
        BOOL bProcessSecurity,
        LPVOID *lpContext
        );

    BOOL WINAPI BackupSeek(
        HANDLE hFile,
        DWORD  dwLowBytesToSeek,
        DWORD  dwHighBytesToSeek,
        LPDWORD lpdwLowByteSeeked,
        LPDWORD lpdwHighByteSeeked,
        LPVOID *lpContext
        );

    BOOL WINAPI BackupWrite(
        HANDLE hFile,
        LPBYTE lpBuffer,
        DWORD nNumberOfBytesToWrite,
        LPDWORD lpNumberOfBytesWritten,
        BOOL bAbort,
        BOOL bProcessSecurity,
        LPVOID *lpContext
        );

    typedef struct _WIN32_STREAM_ID {
            DWORD          dwStreamId ;
            DWORD          dwStreamAttributes ;
            LARGE_INTEGER  Size ;
            DWORD          dwStreamNameSize ;
            WCHAR          cStreamName[ ANYSIZE_ARRAY ] ;
    } WIN32_STREAM_ID, *LPWIN32_STREAM_ID ;

    //  Stream Ids

    const DWORD BACKUP_INVALID         = 0x00000000;
    const DWORD BACKUP_DATA            = 0x00000001;
    const DWORD BACKUP_EA_DATA         = 0x00000002;
    const DWORD BACKUP_SECURITY_DATA   = 0x00000003;
    const DWORD BACKUP_ALTERNATE_DATA  = 0x00000004;
    const DWORD BACKUP_LINK            = 0x00000005;
    const DWORD BACKUP_PROPERTY_DATA   = 0x00000006;

    //  Stream Attributes

    const DWORD STREAM_NORMAL_ATTRIBUTE    = 0x00000000;
    const DWORD STREAM_MODIFIED_WHEN_READ  = 0x00000001;
    const DWORD STREAM_CONTAINS_SECURITY   = 0x00000002;
    const DWORD STREAM_CONTAINS_PROPERTIES = 0x00000004;

    */

    /* Time not implemented
    VOID WINAPI GetSystemTime(
        LPSYSTEMTIME lpSystemTime
        );

    BOOL WINAPI SetSystemTime(
        CONST SYSTEMTIME *lpSystemTime
        );

    VOID WINAPI GetLocalTime(
        LPSYSTEMTIME lpSystemTime
        );

    BOOL WINAPI SetLocalTime(
        CONST SYSTEMTIME *lpSystemTime
        );

    typedef struct _TIME_ZONE_INFORMATION {
        LONG Bias;
        WCHAR StandardName[ 32 ];
        SYSTEMTIME StandardDate;
        LONG StandardBias;
        WCHAR DaylightName[ 32 ];
        SYSTEMTIME DaylightDate;
        LONG DaylightBias;
    } TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;

    BOOL WINAPI SystemTimeToTzSpecificLocalTime(
        LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
        LPSYSTEMTIME lpUniversalTime,
        LPSYSTEMTIME lpLocalTime
        );

    DWORD WINAPI GetTimeZoneInformation(
        LPTIME_ZONE_INFORMATION lpTimeZoneInformation
        );

    BOOL WINAPI SetTimeZoneInformation(
        CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation
        );

    //
    // Routines to convert back and forth between system time and file time
    //

    BOOL WINAPI SystemTimeToFileTime(
        CONST SYSTEMTIME *lpSystemTime,
        LPFILETIME lpFileTime
        );

    BOOL WINAPI FileTimeToLocalFileTime(
        CONST FILETIME *lpFileTime,
        LPFILETIME lpLocalFileTime
        );

    BOOL WINAPI LocalFileTimeToFileTime(
        CONST FILETIME *lpLocalFileTime,
        LPFILETIME lpFileTime
        );

    BOOL WINAPI FileTimeToSystemTime(
        CONST FILETIME *lpFileTime,
        LPSYSTEMTIME lpSystemTime
        );

    LONG WINAPI CompareFileTime(
        CONST FILETIME *lpFileTime1,
        CONST FILETIME *lpFileTime2
        );

    BOOL WINAPI FileTimeToDosDateTime(
        CONST FILETIME *lpFileTime,
        LPWORD lpFatDate,
        LPWORD lpFatTime
        );

    BOOL WINAPI DosDateTimeToFileTime(
        WORD wFatDate,
        WORD wFatTime,
        LPFILETIME lpFileTime
        );

    BOOL WINAPI SetSystemTimeAdjustment(
        DWORD dwTimeAdjustment,
        BOOL  bTimeAdjustmentDisabled
        );

    BOOL WINAPI GetSystemTimeAdjustment(
        PDWORD lpTimeAdjustment,
        PDWORD lpTimeIncrement,
        PBOOL  lpTimeAdjustmentDisabled
        );
    */

    /* GetSystemInfo can't be implemented
    VOID WINAPI GetSystemInfo(
        LPSYSTEM_INFO lpSystemInfo
        );
    */

    /* Format message not implemented
    DWORD WINAPI FormatMessageA(
        DWORD dwFlags,
        LPCVOID lpSource,
        DWORD dwMessageId,
        DWORD dwLanguageId,
        LPSTR lpBuffer,
        DWORD nSize,
        va_list *Arguments
        );

    const DWORD FORMAT_MESSAGE_ALLOCATE_BUFFER  = 0x00000100;
    const DWORD FORMAT_MESSAGE_IGNORE_INSERTS   = 0x00000200;
    const DWORD FORMAT_MESSAGE_FROM_STRING      = 0x00000400;
    const DWORD FORMAT_MESSAGE_FROM_HMODULE     = 0x00000800;
    const DWORD FORMAT_MESSAGE_FROM_SYSTEM      = 0x00001000;
    const DWORD FORMAT_MESSAGE_ARGUMENT_ARRAY   = 0x00002000;
    const DWORD FORMAT_MESSAGE_MAX_WIDTH_MASK   = 0x000000FF;
    */

    /* Pipes not implemented
    HANDLE WINAPI CreateNamedPipeA(
        LPCSTR lpName,
        DWORD dwOpenMode,
        DWORD dwPipeMode,
        DWORD nMaxInstances,
        DWORD nOutBufferSize,
        DWORD nInBufferSize,
        DWORD nDefaultTimeOut,
        LPSECURITY_ATTRIBUTES lpSecurityAttributes
        );

    BOOL WINAPI GetNamedPipeHandleStateA(
        HANDLE hNamedPipe,
        LPDWORD lpState,
        LPDWORD lpCurInstances,
        LPDWORD lpMaxCollectionCount,
        LPDWORD lpCollectDataTimeout,
        LPSTR lpUserName,
        DWORD nMaxUserNameSize
        );

    BOOL WINAPI CallNamedPipeA(
        LPCSTR lpNamedPipeName,
        LPVOID lpInBuffer,
        DWORD nInBufferSize,
        LPVOID lpOutBuffer,
        DWORD nOutBufferSize,
        LPDWORD lpBytesRead,
        DWORD nTimeOut
        );

    BOOL WINAPI WaitNamedPipeA(
        LPCSTR lpNamedPipeName,
        DWORD nTimeOut
        );

    BOOL WINAPI CreatePipe(
        PHANDLE hReadPipe,
        PHANDLE hWritePipe,
        LPSECURITY_ATTRIBUTES lpPipeAttributes,
        DWORD nSize
        );

    BOOL WINAPI ConnectNamedPipe(
        HANDLE hNamedPipe,
        LPOVERLAPPED lpOverlapped
        );

    BOOL WINAPI DisconnectNamedPipe(
        HANDLE hNamedPipe
        );

    BOOL WINAPI SetNamedPipeHandleState(
        HANDLE hNamedPipe,
        LPDWORD lpMode,
        LPDWORD lpMaxCollectionCount,
        LPDWORD lpCollectDataTimeout
        );

    BOOL WINAPI GetNamedPipeInfo(
        HANDLE hNamedPipe,
        LPDWORD lpFlags,
        LPDWORD lpOutBufferSize,
        LPDWORD lpInBufferSize,
        LPDWORD lpMaxInstances
        );

    BOOL WINAPI PeekNamedPipe(
        HANDLE hNamedPipe,
        LPVOID lpBuffer,
        DWORD nBufferSize,
        LPDWORD lpBytesRead,
        LPDWORD lpTotalBytesAvail,
        LPDWORD lpBytesLeftThisMessage
        );

    BOOL WINAPI TransactNamedPipe(
        HANDLE hNamedPipe,
        LPVOID lpInBuffer,
        DWORD nInBufferSize,
        LPVOID lpOutBuffer,
        DWORD nOutBufferSize,
        LPDWORD lpBytesRead,
        LPOVERLAPPED lpOverlapped
        );
    */

    /* Mail slots not implemented
    HANDLE WINAPI CreateMailslotA(
        LPCSTR lpName,
        DWORD nMaxMessageSize,
        DWORD lReadTimeout,
        LPSECURITY_ATTRIBUTES lpSecurityAttributes
        );

    BOOL WINAPI GetMailslotInfo(
        HANDLE hMailslot,
        LPDWORD lpMaxMessageSize,
        LPDWORD lpNextSize,
        LPDWORD lpMessageCount,
        LPDWORD lpReadTimeout
        );

    BOOL WINAPI SetMailslotInfo(
        HANDLE hMailslot,
        DWORD lReadTimeout
        );
    */

    [
    usesgetlasterror,
    entry("MapViewOfFile"),
    helpstring("Opens view of specified file mapping"),
    ]
    LPVOID WINAPI MapViewOfFile(
        [in] HANDLE hFileMappingObject,
        [in] DWORD dwDesiredAccess,
        [in] DWORD dwFileOffsetHigh,
        [in] DWORD dwFileOffsetLow,
        [in] DWORD dwNumberOfBytesToMap
        );

    [
    usesgetlasterror,
    entry("MapViewOfFileEx"),
    helpstring("Opens view of specified file mapping at suggested address"),
    ]
    LPVOID WINAPI MapViewOfFileEx(
        [in] HANDLE hFileMappingObject,
        [in] DWORD dwDesiredAccess,
        [in] DWORD dwFileOffsetHigh,
        [in] DWORD dwFileOffsetLow,
        [in] DWORD dwNumberOfBytesToMap,
        [in] LPVOID lpBaseAddress
        );

    [
    usesgetlasterror,
    entry("FlushViewOfFile"),
    helpstring("Writes file mapping to disk"),
    ]
    BOOL WINAPI FlushViewOfFile(
        [in] LPCVOID lpBaseAddress,
        [in] DWORD dwNumberOfBytesToFlush
        );

    [
    usesgetlasterror,
    entry("UnmapViewOfFile"),
    helpstring("Releases file mapping"),
    ]
    BOOL WINAPI UnmapViewOfFile(
        [in] LPVOID lpBaseAddress
        );

    [
    usesgetlasterror,
    entry("CreateFileMappingA"),
    helpstring("Maps file to memory or creates shared memory (if hFile is -1), assigns lpName to mapping, and returns mapping handle"),
    ]
    HANDLE WINAPI CreateFileMapping(
        [in] HANDLE hFile,
        [in] DWORD lpFileMappingAttributes,
        [in] DWORD flProtect,
        [in] DWORD dwMaximumSizeHigh,
        [in] DWORD dwMaximumSizeLow,
        [in] LPCSTR lpName
        );

    [
    usesgetlasterror,
    entry("OpenFileMappingA"),
    helpstring("Opens existing mapping specified by lpName"),
    ]
    HANDLE WINAPI OpenFileMapping(
        [in] DWORD dwDesiredAccess,
        [in] BOOL bInheritHandle,
        [in] LPCSTR lpName
        );

    /*
    BOOL WINAPI IsTextUnicode(
        CONST LPVOID lpBuffer,
        int cb,
        LPINT lpi
        );
    */

    /* TLS Not Implemented
    DWORD WINAPI TlsAlloc(
        VOID
        );

    //define TLS_OUT_OF_INDEXES (DWORD)0xFFFFFFFF

    LPVOID WINAPI TlsGetValue(
        DWORD dwTlsIndex
        );

    BOOL WINAPI TlsSetValue(
        DWORD dwTlsIndex,
        LPVOID lpTlsValue
        );

    BOOL WINAPI TlsFree(
        DWORD dwTlsIndex
        );

    const DWORD SHUTDOWN_NORETRY               = 0x00000001;
    */


    /* Some directory not implemented
    BOOL WINAPI SetCurrentDirectoryA(
        LPCSTR lpPathName
        );

    DWORD WINAPI GetCurrentDirectoryA(
        DWORD nBufferLength,
        LPSTR lpBuffer
        );

    BOOL WINAPI CreateDirectoryA(
        LPCSTR lpPathName,
        LPSECURITY_ATTRIBUTES lpSecurityAttributes
        );

    BOOL WINAPI CreateDirectoryExA(
        LPCSTR lpTemplateDirectory,
        LPCSTR lpNewDirectory,
        LPSECURITY_ATTRIBUTES lpSecurityAttributes
        );

    BOOL WINAPI RemoveDirectoryA(
        LPCSTR lpPathName
        );

    const DWORD DDD_RAW_TARGET_PATH        = 0x00000001;
    const DWORD DDD_REMOVE_DEFINITION      = 0x00000002;
    const DWORD DDD_EXACT_MATCH_ON_REMOVE  = 0x00000004;


    BOOL WINAPI DefineDosDeviceA(
        DWORD dwFlags,
        LPCSTR lpDeviceName,
        LPCSTR lpTargetPath
        );

    DWORD WINAPI QueryDosDeviceA(
        LPCSTR lpDeviceName,
        LPSTR lpTargetPath,
        DWORD ucchMax
        );

    */

    /* Event logging not implemented
    BOOL WINAPI ClearEventLogA (
        HANDLE hEventLog,
        LPCSTR lpBackupFileName
        );

    BOOL WINAPI BackupEventLogA (
        HANDLE hEventLog,
        LPCSTR lpBackupFileName
        );

    BOOL WINAPI CloseEventLog (
        HANDLE hEventLog
        );

    BOOL WINAPI DeregisterEventSource (
        HANDLE hEventLog
        );

    BOOL WINAPI NotifyChangeEventLog (
        HANDLE hEventLog,
        HANDLE hEvent
        );

    BOOL WINAPI GetNumberOfEventLogRecords (
        HANDLE hEventLog,
        PDWORD NumberOfRecords
        );

    BOOL WINAPI GetOldestEventLogRecord (
        HANDLE hEventLog,
        PDWORD OldestRecord
        );

    HANDLE WINAPI OpenEventLogA (
        LPCSTR lpUNCServerName,
        LPCSTR lpSourceName
        );

    HANDLE WINAPI RegisterEventSourceA (
        LPCSTR lpUNCServerName,
        LPCSTR lpSourceName
        );

    HANDLE WINAPI OpenBackupEventLogA (
        LPCSTR lpUNCServerName,
        LPCSTR lpFileName
        );

    BOOL WINAPI ReadEventLogA (
         HANDLE     hEventLog,
         DWORD      dwReadFlags,
         DWORD      dwRecordOffset,
         LPVOID     lpBuffer,
         DWORD      nNumberOfBytesToRead,
         DWORD      *pnBytesRead,
         DWORD      *pnMinNumberOfBytesNeeded
        );

    BOOL WINAPI ReportEventA (
         HANDLE     hEventLog,