GetPriorityClass
 
 
    GetProcessId
    Prototype: GetProcessId
  
 
    GetProcessTimes
    Prototype: GetProcessTimes
  
 
    GetProcessWorkingSetSize
    Prototype: GetProcessWorkingSetSize
  
 
    GetStdHandle
    
static mono_mutex_t stdhandle_mutex = MONO_MUTEX_INITIALIZER;
gpointer GetStdHandle(WapiStdHandle stdhandle)
Parameters
stdhandle: specifies the file descriptor
Remarks
	 
	 Returns a handle for stdin, stdout, or stderr.  Always returns the
	 same handle for the same 
stdhandle.
	
	 Return value: the handle, or %INVALID_HANDLE_VALUE on error
  
 
    GetSystemInfo
    Prototype: GetSystemInfo
  
 
    GetTempPath
    Prototype: GetTempPath
  
 
    GetThreadContext
    Prototype: GetThreadContext
  
 
    GetTickCount
    Prototype: GetTickCount
  
 
    ImpersonateLoggedOnUser
    Prototype: ImpersonateLoggedOnUser
  
 
    InitializeCriticalSectionAndSpinCount
    gboolean InitializeCriticalSectionAndSpinCount(WapiCriticalSection *section,
					       guint32 spincount G_GNUC_UNUSED)
Parameters
section: The critical section to initialise.spincount: The spin count for this critical section.  Not
Remarks
	 currently used. 
	
	 Initialises a critical section and sets the spin count.  This
	 implementation just calls InitializeCriticalSection().
	
	 Return value: %TRUE on success, %FALSE otherwise.  (%FALSE never
	 happens).
  
 
    InitializeCriticalSection
    void InitializeCriticalSection(WapiCriticalSection *section)
Parameters
section: The critical section to initialise
Remarks
	 
	 Initialises a critical section.
  
 
    ioctlsocket
    Prototype: ioctlsocket
  
 
    LeaveCriticalSection
    Prototype: LeaveCriticalSection
  
 
    LockFile
    Prototype: LockFile
  
 
    MoveFile
    gboolean MoveFile (const gunichar2 *name, const gunichar2 *dest_name)
Parameters
name: a pointer to a NULL-terminated unicode string, that names
Remarks
	 the file to be moved. 
	 
dest_name: a pointer to a NULL-terminated unicode string, that is the
	 new name for the file.
	
	 Renames file 
name to 
dest_name.
	 MoveFile sets ERROR_ALREADY_EXISTS if the destination exists, except
	 when it is the same file as the source.  In that case it silently succeeds.
	
	 Return value: %TRUE on success, %FALSE otherwise.
  
 
    OpenEvent
    Prototype: OpenEvent
  
 
    OpenMutex
    Prototype: OpenMutex
  
 
    OpenProcess
    Prototype: OpenProcess
  
 
    OpenSemaphore
    Prototype: OpenSemaphore
  
 
    OpenThread
    Prototype: OpenThread
  
 
    PulseEvent
    gboolean PulseEvent(gpointer handle)
Parameters
handle: The event handle.
Remarks
	 
	 Sets the event handle 
handle to the signalled state, and then
	 resets it to unsignalled after informing any waiting threads.
	
	 If 
handle is a manual reset event, all waiting threads that can be
	 released immediately are released.  
handle is then reset.  If
	 
handle is an auto reset event, one waiting thread is released even
	 if multiple threads are waiting.
	
	 Return value: %TRUE on success, %FALSE otherwise.  (Currently only
	 ever returns %TRUE).
  
 
    QueryPerformanceCounter
    Prototype: QueryPerformanceCounter
  
 
    QueryPerformanceFrequency
    Prototype: QueryPerformanceFrequency
  
 
    QueueUserAPC
    Prototype: QueueUserAPC
  
 
    ReadFile
    gboolean ReadFile(gpointer handle, gpointer buffer, guint32 numbytes,
		  guint32 *bytesread, WapiOverlapped *overlapped)
Parameters
handle: The file handle to read from.  The handle must have
Remarks
	 %GENERIC_READ access. 
	 
buffer: The buffer to store read data in
	 
numbytes: The maximum number of bytes to read
	 
bytesread: The actual number of bytes read is stored here.  This
	 value can be zero if the handle is positioned at the end of the
	 file.
	 
overlapped: points to a required %WapiOverlapped structure if
	 
handle has the %FILE_FLAG_OVERLAPPED option set, should be NULL
	 otherwise.
	
	 If 
handle does not have the %FILE_FLAG_OVERLAPPED option set, this
	 function reads up to 
numbytes bytes from the file from the current
	 file position, and stores them in 
buffer.  If there are not enough
	 bytes left in the file, just the amount available will be read.
	 The actual number of bytes read is stored in 
bytesread.
	
	 If 
handle has the %FILE_FLAG_OVERLAPPED option set, the current
	 file position is ignored and the read position is taken from data
	 in the 
overlapped structure.
	
	 Return value: %TRUE if the read succeeds (even if no bytes were
	 read due to an attempt to read past the end of the file), %FALSE on
	 error.
  
 
    ReleaseMutex
    gboolean ReleaseMutex(gpointer handle)
Parameters
handle: The mutex handle.
Remarks
	 
	 Releases ownership if the mutex handle 
handle.
	
	 Return value: %TRUE on success, %FALSE otherwise.  This function
	 fails if the calling thread does not own the mutex 
handle.
  
 
    ReleaseSemaphore
    gboolean ReleaseSemaphore(gpointer handle, gint32 count, gint32 *prevcount)
Parameters
handle: The semaphore handle to release.count: The amount by which the semaphore's count should be
Remarks
	 increased. 
	 
prevcount: Pointer to a location to store the previous count of
	 the semaphore, or %NULL.
	
	 Increases the count of semaphore 
handle by 
count.
	
	 Return value: %TRUE on success, %FALSE otherwise.
  
 
    RemoveDirectory
    gboolean RemoveDirectory (const gunichar2 *name)
Parameters
name: a pointer to a NULL-terminated unicode string, that names
Remarks
	 the directory to be removed. 
	
	 Removes directory 
name
	
	 Return value: %TRUE on success, %FALSE otherwise.
 ReplaceFile
 
 
    ResetEvent
    gboolean ResetEvent(gpointer handle)
Parameters
handle: The event handle.
Remarks
	 
	 Resets the event handle 
handle to the unsignalled state.
	
	 Return value: %TRUE on success, %FALSE otherwise.  (Currently only
	 ever returns %TRUE).
  
 
    ResumeThread
    guint32 ResumeThread(gpointer handle)
Parameters
handle: the thread handle to resume
Remarks
	 
	 Decrements the suspend count of thread 
handle. A thread can only
	 run if its suspend count is zero.
	
	 Return value: the previous suspend count, or 0xFFFFFFFF on error.
  
 
    RevertToSelf
    Prototype: RevertToSelf
  
 
    SetCriticalSectionSpinCount
    guint32 SetCriticalSectionSpinCount(WapiCriticalSection *section G_GNUC_UNUSED, guint32 spincount G_GNUC_UNUSED)
Parameters
section: The critical section to setspincount: The new spin count for this critical section.  Not
Remarks
	 currently used. 
	
	 Sets the spin count for the critical section 
section.  The spin
	 count is currently ignored, and set to zero.
	
	 Return value: The previous spin count.  (Currently always zero).
  
 
    SetCurrentDirectory
    extern gboolean SetCurrentDirectory (const gunichar2 *path)
Parameters
path: path to new directory
Remarks
	 
	 Changes the directory path for the current process.
	
	 Return value: %TRUE on success, %FALSE on failure.
  
 
    SetEndOfFile
    gboolean SetEndOfFile(gpointer handle)
Parameters
handle: The file handle to set.  The handle must have
Remarks
	 %GENERIC_WRITE access. 
	
	 Moves the end-of-file position to the current position of the file
	 pointer.  This function is used to truncate or extend a file.
	
	 Return value: %TRUE on success, %FALSE otherwise.
  
 
    SetEvent
    gboolean SetEvent(gpointer handle)
Parameters
handle: The event handle
Remarks
	 
	 Sets the event handle 
handle to the signalled state.
	
	 If 
handle is a manual reset event, it remains signalled until it
	 is reset with ResetEvent().  An auto reset event remains signalled
	 until a single thread has waited for it, at which time 
handle is
	 automatically reset to unsignalled.
	
	 Return value: %TRUE on success, %FALSE otherwise.  (Currently only
	 ever returns %TRUE).
  
 
    SetFileAttributes
    extern gboolean SetFileAttributes (const gunichar2 *name, guint32 attrs)
Parameters
name: name of fileattrs: attributes to set
Remarks
	 
	 Changes the attributes on a named file.
	
	 Return value: %TRUE on success, %FALSE on failure.
  
 
    SetFilePointer
    guint32 SetFilePointer(gpointer handle, gint32 movedistance,
		       gint32 *highmovedistance, WapiSeekMethod method)
Parameters
handle: The file handle to set.  The handle must have
Remarks
	 %GENERIC_READ or %GENERIC_WRITE access. 
	 
movedistance: Low 32 bits of a signed value that specifies the
	 number of bytes to move the file pointer.
	 
highmovedistance: Pointer to the high 32 bits of a signed value
	 that specifies the number of bytes to move the file pointer, or
	 %NULL.
	 
method: The starting point for the file pointer move.
	
	 Sets the file pointer of an open file.
	
	 The distance to move the file pointer is calculated from
	 
movedistance and 
highmovedistance: If 
highmovedistance is %NULL,
	 
movedistance is the 32-bit signed value; otherwise, 
movedistance
	 is the low 32 bits and 
highmovedistance a pointer to the high 32
	 bits of a 64 bit signed value.  A positive distance moves the file
	 pointer forward from the position specified by 
method; a negative
	 distance moves the file pointer backward.
	
	 If the library is compiled without large file support,
	 
highmovedistance is ignored and its value is set to zero on a
	 successful return.
	
	 Return value: On success, the low 32 bits of the new file pointer.
	 If 
highmovedistance is not %NULL, the high 32 bits of the new file
	 pointer are stored there.  On failure, %INVALID_SET_FILE_POINTER.
  
 
    SetFileTime
    gboolean SetFileTime(gpointer handle, const WapiFileTime *create_time,
		     const WapiFileTime *last_access,
		     const WapiFileTime *last_write)
Parameters
handle: The file handle to set.  The handle must have
Remarks
	 %GENERIC_WRITE access. 
	 
create_time: Points to a %WapiFileTime structure that contains the
	 number of ticks since the epoch that the file was created.  May be
	 %NULL.
	 
last_access: Points to a %WapiFileTime structure that contains the
	 number of ticks since the epoch when the file was last accessed.
	 May be %NULL.
	 
last_write: Points to a %WapiFileTime structure that contains the
	 number of ticks since the epoch when the file was last written to.
	 May be %NULL.
	
	 Sets the number of ticks since the epoch that the file referenced
	 by 
handle was created, last accessed or last modified.  A tick is
	 a 100 nanosecond interval.  The epoch is Midnight, January 1 1601
	 GMT.
	
	 Create time isn't recorded on POSIX file systems, and is ignored.
	
	 Return value: %TRUE on success, %FALSE otherwise.
  
 
    SetLastError
    void SetLastError(guint32 code)
Parameters
code: The error code.
Remarks
	 
	 Sets the error code in the calling thread.
 SetPriorityClass
 
 
    SetProcessWorkingSetSize
    Prototype: SetProcessWorkingSetSize
  
 
    ShellExecuteEx
    Prototype: ShellExecuteEx
  
 
    SignalObjectAndWait
    guint32 SignalObjectAndWait(gpointer signal_handle, gpointer wait,
			    guint32 timeout, gboolean alertable)
Parameters
signal_handle: An object to signalwait: An object to wait fortimeout: The maximum time in milliseconds to wait foralertable: Specifies whether the function returnes when the system
Remarks
	 queues an I/O completion routine or an APC for the calling thread. 
	
	 Atomically signals 
signal and waits for 
wait to become signalled,
	 or 
timeout ms elapses.  If 
timeout is zero, the object's state is
	 tested and the function returns immediately.  If 
timeout is
	 %INFINITE, the function waits forever.
	
	 
signal can be a semaphore, mutex or event object.
	
	 If 
alertable is %TRUE and the system queues an I/O completion
	 routine or an APC for the calling thread, the function returns and
	 the thread calls the completion routine or APC function.  If
	 %FALSE, the function does not return, and the thread does not call
	 the completion routine or APC function.  A completion routine is
	 queued when the ReadFileEx() or WriteFileEx() function in which it
	 was specified has completed.  The calling thread is the thread that
	 initiated the read or write operation.  An APC is queued when
	 QueueUserAPC() is called.  Currently completion routines and APC
	 functions are not supported.
	
	 Return value: %WAIT_ABANDONED - 
wait is a mutex that was not
	 released by the owning thread when it exited.  Ownershop of the
	 mutex object is granted to the calling thread and the mutex is set
	 to nonsignalled.  %WAIT_IO_COMPLETION - the wait was ended by one
	 or more user-mode asynchronous procedure calls queued to the
	 thread.  %WAIT_OBJECT_0 - The state of 
wait is signalled.
	 %WAIT_TIMEOUT - The 
timeout interval elapsed and 
wait's state is
	 still not signalled.  %WAIT_FAILED - an error occurred.
  
 
    SleepEx
    guint32 SleepEx(guint32 ms, gboolean alertable)
Parameters
ms: The time in milliseconds to suspend foralertable: if TRUE, the wait can be interrupted by an APC call
Remarks
	 
	 Suspends execution of the current thread for 
ms milliseconds.  A
	 value of zero causes the thread to relinquish its time slice.  A
	 value of %INFINITE causes an infinite delay.
  
  
 
    SuspendThread
    guint32 SuspendThread(gpointer handle)
Parameters
handle: the thread handle to suspend
Remarks
	 
	 Increments the suspend count of thread 
handle. A thread can only
	 run if its suspend count is zero.
	
	 Return value: the previous suspend count, or 0xFFFFFFFF on error.
  
 
    TerminateProcess
    Prototype: TerminateProcess
  
 
    TlsAlloc
    guint32 TlsAlloc(void)
Remarks
	 
	 Allocates a Thread Local Storage (TLS) index.  Any thread in the
	 same process can use this index to store and retrieve values that
	 are local to that thread.
	
	 Return value: The index value, or %TLS_OUT_OF_INDEXES if no index
	 is available.
  
 
    TlsFree
    gboolean TlsFree(guint32 idx)
Parameters
idx: The TLS index to free
Remarks
	 
	 Releases a TLS index, making it available for reuse.  This call
	 will delete any TLS data stored under index 
idx in all threads.
	
	 Return value: %TRUE on success, %FALSE otherwise.
  
 
    TlsGetValue
    gpointer TlsGetValue(guint32 idx)
Parameters
idx: The TLS index to retrieve
Remarks
	 
	 Retrieves the TLS data stored under index 
idx.
	
	 Return value: The value stored in the TLS index 
idx in the current
	 thread, or %NULL on error.  As %NULL can be a valid return value,
	 in this case GetLastError() returns %ERROR_SUCCESS.
  
 
    TlsSetValue
    gboolean TlsSetValue(guint32 idx, gpointer value)
Parameters
idx: The TLS index to storevalue: The value to store under index idx
Remarks
	 
	 Stores 
value at TLS index 
idx.
	
	 Return value: %TRUE on success, %FALSE otherwise.
 TransmitFile
 
 
    TryEnterCriticalSection
    gboolean TryEnterCriticalSection(WapiCriticalSection *section)
Parameters
section: The critical section to try and enter
Remarks
	 
	 Attempts to enter a critical section without blocking.  If
	 successful the calling thread takes ownership of the critical
	 section.
	
	 A thread can recursively call EnterCriticalSection() and
	 TryEnterCriticalSection(), but must call LeaveCriticalSection() an
	 equal number of times.
	
	 Return value: %TRUE if the thread successfully locked the critical
	 section, %FALSE otherwise.
  
 
    UnlockFile
    Prototype: UnlockFile
 VerLanguageName
VerQueryValue
WaitForInputIdle
 
 
    WaitForMultipleObjectsEx
    guint32 WaitForMultipleObjectsEx(guint32 numobjects, gpointer *handles,
				 gboolean waitall, guint32 timeout,
				 gboolean alertable)
Parameters
numobjects: The number of objects in handles. The maximum allowed
Remarks
	 is %MAXIMUM_WAIT_OBJECTS. 
	 
handles: An array of object handles.  Duplicates are not allowed.
	 
waitall: If %TRUE, this function waits until all of the handles
	 are signalled.  If %FALSE, this function returns when any object is
	 signalled.
	 
timeout: The maximum time in milliseconds to wait for.
	 
alertable: if TRUE, the wait can be interrupted by an APC call
	
	 This function returns when either one or more of 
handles is
	 signalled, or 
timeout ms elapses.  If 
timeout is zero, the state
	 of each item of 
handles is tested and the function returns
	 immediately.  If 
timeout is %INFINITE, the function waits forever.
	
	 Return value: %WAIT_OBJECT_0 to %WAIT_OBJECT_0 + 
numobjects - 1 -
	 if 
waitall is %TRUE, indicates that all objects are signalled.  If
	 
waitall is %FALSE, the return value minus %WAIT_OBJECT_0 indicates
	 the first index into 
handles of the objects that are signalled.
	 %WAIT_ABANDONED_0 to %WAIT_ABANDONED_0 + 
numobjects - 1 - if
	 
waitall is %TRUE, indicates that all objects are signalled, and at
	 least one object is an abandoned mutex object (See
	 WaitForSingleObject() for a description of abandoned mutexes.)  If
	 
waitall is %FALSE, the return value minus %WAIT_ABANDONED_0
	 indicates the first index into 
handles of an abandoned mutex.
	 %WAIT_TIMEOUT - The 
timeout interval elapsed and no objects in
	 
handles are signalled.  %WAIT_FAILED - an error occurred.
	 %WAIT_IO_COMPLETION - the wait was ended by an APC.
  
 
    WaitForMultipleObjects
    Prototype: WaitForMultipleObjects
  
 
    WaitForSingleObjectEx
    guint32 WaitForSingleObjectEx(gpointer handle, guint32 timeout,
			      gboolean alertable)
Parameters
handle: an object to wait fortimeout: the maximum time in milliseconds to wait foralertable: if TRUE, the wait can be interrupted by an APC call
Remarks
	 
	 This function returns when either 
handle is signalled, or 
timeout
	 ms elapses.  If 
timeout is zero, the object's state is tested and
	 the function returns immediately.  If 
timeout is %INFINITE, the
	 function waits forever.
	
	 Return value: %WAIT_ABANDONED - 
handle is a mutex that was not
	 released by the owning thread when it exited.  Ownership of the
	 mutex object is granted to the calling thread and the mutex is set
	 to nonsignalled.  %WAIT_OBJECT_0 - The state of 
handle is
	 signalled.  %WAIT_TIMEOUT - The 
timeout interval elapsed and
	 
handle's state is still not signalled.  %WAIT_FAILED - an error
	 occurred. %WAIT_IO_COMPLETION - the wait was ended by an APC.
  
 
    WaitForSingleObject
    Prototype: WaitForSingleObject
  
 
    WriteFile
    gboolean WriteFile(gpointer handle, gconstpointer buffer, guint32 numbytes,
		   guint32 *byteswritten, WapiOverlapped *overlapped)
Parameters
handle: The file handle to write to.  The handle must have
Remarks
	 %GENERIC_WRITE access. 
	 
buffer: The buffer to read data from.
	 
numbytes: The maximum number of bytes to write.
	 
byteswritten: The actual number of bytes written is stored here.
	 If the handle is positioned at the file end, the length of the file
	 is extended.  This parameter may be %NULL.
	 
overlapped: points to a required %WapiOverlapped structure if
	 
handle has the %FILE_FLAG_OVERLAPPED option set, should be NULL
	 otherwise.
	
	 If 
handle does not have the %FILE_FLAG_OVERLAPPED option set, this
	 function writes up to 
numbytes bytes from 
buffer to the file at
	 the current file position.  If 
handle is positioned at the end of
	 the file, the file is extended.  The actual number of bytes written
	 is stored in 
byteswritten.
	
	 If 
handle has the %FILE_FLAG_OVERLAPPED option set, the current
	 file position is ignored and the write position is taken from data
	 in the 
overlapped structure.
	
	 Return value: %TRUE if the write succeeds, %FALSE on error.
  
 
    WSACleanup
    Prototype: WSACleanup
  
 
    WSAGetLastError
    Prototype: WSAGetLastError
  
 
    WSAIoctl
    Prototype: WSAIoctl
  
 
    WSARecv
    Prototype: WSARecv
  
 
    WSASend
    Prototype: WSASend
  
 
    WSASetLastError
    Prototype: WSASetLastError
  
 
    WSAStartup
    Prototype: WSAStartup
 Extended APIs