HANDLE
WINAPI
CreateWaitableTimerW(
LPSECURITY_ATTRIBUTES lpTimerAttributes,
BOOL bManualReset,
LPCWSTR lpTimerName
)
{
NTSTATUS Status;
OBJECT_ATTRIBUTES Obja;
POBJECT_ATTRIBUTES pObja;
HANDLE Handle;
UNICODE_STRING ObjectName;
if ( ARGUMENT_PRESENT(lpTimerName) ) {
RtlInitUnicodeString(&ObjectName,lpTimerName);
pObja = BaseFormatObjectAttributes(&Obja,lpTimerAttributes,&ObjectName);
}
else {
pObja = BaseFormatObjectAttributes(&Obja,lpTimerAttributes,NULL);
}
Status = NtCreateTimer(
&Handle,
TIMER_ALL_ACCESS,
pObja,
bManualReset ? NotificationTimer : SynchronizationTimer
);
if ( NT_SUCCESS(Status) ) {
if ( Status == STATUS_OBJECT_NAME_EXISTS ) {
SetLastError(ERROR_ALREADY_EXISTS);
}
else {
SetLastError(0);
}
return Handle;
}
else {
BaseSetLastNTError(Status);
return NULL;
}
}
HANDLE
APIENTRY
CreateFileMappingW(
HANDLE hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD flProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCWSTR lpName
)
/*++
Routine Description:
A file mapping object can be created using CreateFileMapping
Creating a file mapping object creates the potential for mapping a
view of the file into an address space. File mapping objects may be
shared either through process creation or handle duplication.
Having a handle to a file mapping object allows for mapping of the
file. It does not mean that the file is actually mapped.
A file mapping object has a maximum size. This is used to size the
file. A file may not grow beyond the size specified in the mapping
object. While not required, it is recommended that when opening a
file that you intend to map, the file should be opened for exclusive
access. Win32 does not require that a mapped file and a file
accessed via the IO primitives (ReadFile/WriteFile) are coherent.
In addition to the STANDARD_RIGHTS_REQUIRED access flags, the
following object type specific access flags are valid for file
mapping objects:
- FILE_MAP_WRITE - Write map access to the file mapping object is
desired. This allows a writable view of the file to be
mapped. Note that if flProtect does not include
PAGE_READWRITE, this access type does not allow writing the
mapped file.
- FILE_MAP_READ - Read map access to the file mapping object is
desired. This allows a readablee view of the file to be
mapped.
- FILE_MAP_ALL_ACCESS - This set of access flags specifies all of
the possible access flags for a file mapping object.
Arguments:
hFile - Supplies an open handle to a file that a mapping object is
to be created for. The file must be opened with an access mode
that is compatible with the specified pretection flags. A value
of INVALID_HANDLE_VALUE specifies that the mapping object is
backed by the system paging file. If this is the case, a size
must be specified.
lpFileMappingAttributes - An optional parameter that may be used to
specify the attributes of the new file mapping object. If the
parameter is not specified, then the file mapping object is
created without a security descriptor, and the resulting handle
is not inherited on process creation:
flProtect - The protection desired for mapping object when the file
is mapped.
flProtect Values
PAGE_READONLY - Read access to the committed region of pages is
allowed. An attempt to write or execute the committed
region results in an access violation. The specified hFile
must have been created with GENERIC_READ access.
PAGE_READWRITE - Read and write access to the committed region
of pages is allowed. The specified hFile must have been
created with GENERIC_READ and GENERIC_WRITE access.
PAGE_WRITECOPY - Read and copy on write access to the committed
region of pages is allowed. The specified hFile must have been
created with GENERIC_READ access.
dwMaximumSizeHigh - Supplies the high order 32-bits of the maximum
size of the file mapping object.
dwMaximumSizeLow - Supplies the low order 32-bits of the maximum
size of the file mapping object. A value of zero along with a
value of zero in dwMaximumSizeHigh indicates that the size of
the file mapping object is equal to the current size of the file
specified by hFile.
lpName - Supplies the name ofthe file mapping object.
Return Value:
NON-NULL - Returns a handle to the new file mapping object. The
handle has full access to the new file mapping object and may be
used in any API that requires a handle to a file mapping object.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
HANDLE Section;
NTSTATUS Status;
LARGE_INTEGER SectionSizeData;
PLARGE_INTEGER SectionSize;
OBJECT_ATTRIBUTES Obja;
POBJECT_ATTRIBUTES pObja;
ACCESS_MASK DesiredAccess;
UNICODE_STRING ObjectName;
ULONG AllocationAttributes;
DesiredAccess = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ;
AllocationAttributes = flProtect & (SEC_FILE | SEC_IMAGE | SEC_RESERVE | SEC_COMMIT | SEC_NOCACHE);
flProtect ^= AllocationAttributes;
if (AllocationAttributes == 0) {
AllocationAttributes = SEC_COMMIT;
}
if ( flProtect == PAGE_READWRITE ) {
DesiredAccess |= (SECTION_MAP_READ | SECTION_MAP_WRITE);
}
else
if ( flProtect != PAGE_READONLY && flProtect != PAGE_WRITECOPY ) {
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
if ( ARGUMENT_PRESENT(lpName) ) {
RtlInitUnicodeString(&ObjectName,lpName);
pObja = BaseFormatObjectAttributes(&Obja,lpFileMappingAttributes,&ObjectName);
}
else {
pObja = BaseFormatObjectAttributes(&Obja,lpFileMappingAttributes,NULL);
}
if ( dwMaximumSizeLow || dwMaximumSizeHigh ) {
SectionSize = &SectionSizeData;
SectionSize->LowPart = dwMaximumSizeLow;
SectionSize->HighPart = dwMaximumSizeHigh;
}
else {
SectionSize = NULL;
}
if (hFile == INVALID_HANDLE_VALUE) {
hFile = NULL;
if ( !SectionSize ) {
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
}
Status = NtCreateSection(
&Section,
DesiredAccess,
pObja,
SectionSize,
flProtect,
AllocationAttributes,
hFile
);
if ( !NT_SUCCESS(Status) ) {
BaseSetLastNTError(Status);
return Section = NULL;
}
else {
if ( Status == STATUS_OBJECT_NAME_EXISTS ) {
SetLastError(ERROR_ALREADY_EXISTS);
}
else {
SetLastError(0);
}
}
return Section;
}
HANDLE
APIENTRY
CreateMutexW(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCWSTR lpName
)
/*++
Routine Description:
A mutex object can be created and a handle opened for access to the
object with the CreateMutex function.
A new mutex object is created and a handle opened to the object with
ownership as determined by the InitialOwner parameter. The status
of the newly created mutex object is set to not abandoned.
In addition to the STANDARD_RIGHTS_REQUIRED access flags, the
following object type specific access flags are valid for mutex
objects:
- MUTEX_MODIFY_STATE - Modify access to the mutex is desired.
This allows a process to release a mutex.
- SYNCHRONIZE - Synchronization access (wait or release) to the
mutex object is desired.
- MUTEX_ALL_ACCESS - All possible types of access to the mutex
object are desired.
Arguments:
lpMutexAttributes - An optional parameter that may be used to specify
the attributes of the new mutex. If the parameter is not
specified, then the mutex is created without a security
descriptor, and the resulting handle is not inherited on process
creation.
bInitialOwner - A boolean value that determines whether the creator
of the object desires immediate ownership of the mutex object.
lpName - Supplies an optional unicode name for the mutex.
Return Value:
NON-NULL - Returns a handle to the new mutex. The handle has full
access to the new mutex and may be used in any API that
requires a handle to a mutex object.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
OBJECT_ATTRIBUTES Obja;
POBJECT_ATTRIBUTES pObja;
HANDLE Handle;
UNICODE_STRING ObjectName;
if ( ARGUMENT_PRESENT(lpName) ) {
RtlInitUnicodeString(&ObjectName,lpName);
pObja = BaseFormatObjectAttributes(&Obja,lpMutexAttributes,&ObjectName);
}
else {
pObja = BaseFormatObjectAttributes(&Obja,lpMutexAttributes,NULL);
}
Status = NtCreateMutant(
&Handle,
MUTANT_ALL_ACCESS,
pObja,
(BOOLEAN)bInitialOwner
);
if ( NT_SUCCESS(Status) ) {
if ( Status == STATUS_OBJECT_NAME_EXISTS ) {
SetLastError(ERROR_ALREADY_EXISTS);
}
else {
SetLastError(0);
}
return Handle;
}
else {
BaseSetLastNTError(Status);
return NULL;
}
}
HANDLE
APIENTRY
CreateSemaphoreW(
LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCWSTR lpName
)
/*++
Routine Description:
A semaphore object is created and a handle opened for access to the
object with the CreateSemaphore function.
The CreateSemaphore function causes a semaphore object to be created
which contains the specified initial and maximum counts.
In addition to the STANDARD_RIGHTS_REQUIRED access flags, the
following object type specific access flags are valid for semaphore
objects:
- SEMAPHORE_MODIFY_STATE - Modify state access (release) to the
semaphore is desired.
- SYNCHRONIZE - Synchronization access (wait) to the semaphore
is desired.
- SEMAPHORE_ALL_ACCESS - This set of access flags specifies all
of the possible access flags for a semaphore object.
Arguments:
lpSemaphoreAttributes - An optional parameter that may be used to
specify the attributes of the new semaphore. If the parameter
is not specified, then the semaphore is created without a
security descriptor, , and the resulting handle is not inherited
on process creation.
lInitialCount - The initial count for the semaphore, this value
must be positive and less than or equal to the maximum count.
lMaximumCount - The maximum count for the semaphore, this value
must be greater than zero..
lpName - Supplies an optional unicode name for the object.
Return Value:
NON-NULL - Returns a handle to the new semaphore. The handle has
full access to the new semaphore and may be used in any API that
requires a handle to a semaphore object.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
OBJECT_ATTRIBUTES Obja;
POBJECT_ATTRIBUTES pObja;
HANDLE Handle;
UNICODE_STRING ObjectName;
if ( ARGUMENT_PRESENT(lpName) ) {
RtlInitUnicodeString(&ObjectName,lpName);
pObja = BaseFormatObjectAttributes(&Obja,lpSemaphoreAttributes,&ObjectName);
}
else {
pObja = BaseFormatObjectAttributes(&Obja,lpSemaphoreAttributes,NULL);
}
Status = NtCreateSemaphore(
&Handle,
SEMAPHORE_ALL_ACCESS,
pObja,
lInitialCount,
lMaximumCount
);
if ( NT_SUCCESS(Status) ) {
if ( Status == STATUS_OBJECT_NAME_EXISTS ) {
SetLastError(ERROR_ALREADY_EXISTS);
}
else {
SetLastError(0);
}
return Handle;
}
else {
BaseSetLastNTError(Status);
return NULL;
}
}
HANDLE
APIENTRY
CreateEventW(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPCWSTR lpName
)
/*++
Routine Description:
An event object is created and a handle opened for access to the
object with the CreateEvent function.
The CreateEvent function creates an event object with the specified
initial state. If an event is in the Signaled state (TRUE), a wait
operation on the event does not block. If the event is in the Not-
Signaled state (FALSE), a wait operation on the event blocks until
the specified event attains a state of Signaled, or the timeout
value is exceeded.
In addition to the STANDARD_RIGHTS_REQUIRED access flags, the following
object type specific access flags are valid for event objects:
- EVENT_MODIFY_STATE - Modify state access (set and reset) to
the event is desired.
- SYNCHRONIZE - Synchronization access (wait) to the event is
desired.
- EVENT_ALL_ACCESS - This set of access flags specifies all of
the possible access flags for an event object.
Arguments:
lpEventAttributes - An optional parameter that may be used to
specify the attributes of the new event. If the parameter is
not specified, then the event is created without a security
descriptor, and the resulting handle is not inherited on process
creation.
bManualReset - Supplies a flag which if TRUE specifies that the
event must be manually reset. If the value is FALSE, then after
releasing a single waiter, the system automaticaly resets the
event.
bInitialState - The initial state of the event object, one of TRUE
or FALSE. If the InitialState is specified as TRUE, the event's
current state value is set to one, otherwise it is set to zero.
lpName - Optional unicode name of event
Return Value:
NON-NULL - Returns a handle to the new event. The handle has full
access to the new event and may be used in any API that requires
a handle to an event object.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
OBJECT_ATTRIBUTES Obja;
POBJECT_ATTRIBUTES pObja;
HANDLE Handle;
UNICODE_STRING ObjectName;
if ( ARGUMENT_PRESENT(lpName) ) {
RtlInitUnicodeString(&ObjectName,lpName);
pObja = BaseFormatObjectAttributes(&Obja,lpEventAttributes,&ObjectName);
}
else {
pObja = BaseFormatObjectAttributes(&Obja,lpEventAttributes,NULL);
}
Status = NtCreateEvent(
&Handle,
EVENT_ALL_ACCESS,
pObja,
bManualReset ? NotificationEvent : SynchronizationEvent,
(BOOLEAN)bInitialState
);
if ( NT_SUCCESS(Status) ) {
if ( Status == STATUS_OBJECT_NAME_EXISTS ) {
SetLastError(ERROR_ALREADY_EXISTS);
}
else {
SetLastError(0);
}
return Handle;
}
else {
BaseSetLastNTError(Status);
return NULL;
}
}
/*
* @implemented
*/
HANDLE
NTAPI
CreateFileMappingW(HANDLE hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD flProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCWSTR lpName)
{
NTSTATUS Status;
HANDLE SectionHandle;
OBJECT_ATTRIBUTES LocalAttributes;
POBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING SectionName;
ACCESS_MASK DesiredAccess;
LARGE_INTEGER LocalSize;
PLARGE_INTEGER SectionSize = NULL;
ULONG Attributes;
/* Set default access */
DesiredAccess = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ;
/* Get the attributes for the actual allocation and cleanup flProtect */
Attributes = flProtect & (SEC_FILE | SEC_IMAGE | SEC_RESERVE | SEC_NOCACHE | SEC_COMMIT | SEC_LARGE_PAGES);
flProtect ^= Attributes;
/* If the caller didn't say anything, assume SEC_COMMIT */
if (!Attributes) Attributes = SEC_COMMIT;
/* Now check if the caller wanted write access */
if (flProtect == PAGE_READWRITE)
{
/* Give it */
DesiredAccess |= SECTION_MAP_WRITE;
}
else if (flProtect == PAGE_EXECUTE_READWRITE)
{
/* Give it */
DesiredAccess |= (SECTION_MAP_WRITE | SECTION_MAP_EXECUTE);
}
else if (flProtect == PAGE_EXECUTE_READ)
{
/* Give it */
DesiredAccess |= SECTION_MAP_EXECUTE;
}
else if ((flProtect != PAGE_READONLY) && (flProtect != PAGE_WRITECOPY))
{
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
/* Now check if we got a name */
if (lpName) RtlInitUnicodeString(&SectionName, lpName);
/* Now convert the object attributes */
ObjectAttributes = BaseFormatObjectAttributes(&LocalAttributes,
lpFileMappingAttributes,
lpName ? &SectionName : NULL);
/* Check if we got a size */
if (dwMaximumSizeLow || dwMaximumSizeHigh)
{
/* Use a LARGE_INTEGER and convert */
SectionSize = &LocalSize;
SectionSize->LowPart = dwMaximumSizeLow;
SectionSize->HighPart = dwMaximumSizeHigh;
}
/* Make sure the handle is valid */
if (hFile == INVALID_HANDLE_VALUE)
{
/* It's not, we'll only go on if we have a size */
hFile = NULL;
if (!SectionSize)
{
/* No size, so this isn't a valid non-mapped section */
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
}
/* Now create the actual section */
Status = NtCreateSection(&SectionHandle,
DesiredAccess,
ObjectAttributes,
SectionSize,
flProtect,
Attributes,
hFile);
if (!NT_SUCCESS(Status))
{
/* We failed */
BaseSetLastNTError(Status);
return NULL;
}
else if (Status == STATUS_OBJECT_NAME_EXISTS)
{
SetLastError(ERROR_ALREADY_EXISTS);
}
else
{
SetLastError(ERROR_SUCCESS);
}
/* Return the section */
return SectionHandle;
}
