reactos/lib/kernel32/synch/wait.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            lib/kernel32/synch/wait.c
   5  * PURPOSE:         Wait  functions
   6  * PROGRAMMER:      Ariadne ( ariadne@xs4all.nl)
   7  * UPDATE HISTORY:
   8  *                  Created 01/11/98
   9  */
  10
  11 #include <windows.h>
  12 #include <wchar.h>
  13 #include <ddk/ntddk.h>
  14
  15 HANDLE
  16 STDCALL
  17 CreateSemaphoreA(
  18                  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
  19                  LONG lInitialCount,
  20                  LONG lMaximumCount,
  21                  LPCSTR lpName
  22                  )
  23 {
  24         WCHAR NameW[MAX_PATH];
  25         ULONG i = 0;
  26
  27         while ((*lpName)!=0 && i < MAX_PATH)
  28                 {
  29                 NameW[i] = *lpName;
  30                 lpName++;
  31                 i++;
  32                 }
  33         NameW[i] = 0;
  34         return CreateSemaphoreW(
  35                  lpSemaphoreAttributes,
  36                  lInitialCount,
  37                  lMaximumCount,
  38                  NameW
  39                  );
  40 }
  41
  42 HANDLE
  43 STDCALL
  44 CreateSemaphoreW(
  45                  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
  46                  LONG lInitialCount,
  47                  LONG lMaximumCount,
  48                  LPCWSTR lpName
  49                  )
  50 {
  51         OBJECT_ATTRIBUTES ObjectAttributes;
  52         NTSTATUS errCode;
  53         UNICODE_STRING NameString;
  54         HANDLE SemaphoreHandle;
  55
  56         NameString.Length = lstrlenW(lpName)*sizeof(WCHAR);
  57         NameString.Buffer = (WCHAR *)lpName;
  58         NameString.MaximumLength = NameString.Length;
  59
  60         ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
  61         ObjectAttributes.RootDirectory = NULL;
  62         ObjectAttributes.ObjectName = &NameString;
  63         ObjectAttributes.Attributes = OBJ_CASE_INSENSITIVE;
  64         ObjectAttributes.SecurityDescriptor = NULL;
  65         ObjectAttributes.SecurityQualityOfService = NULL;
  66
  67         if ( lpSemaphoreAttributes != NULL ) {
  68                 ObjectAttributes.SecurityDescriptor = lpSemaphoreAttributes->lpSecurityDescriptor;
  69                 if ( lpSemaphoreAttributes->bInheritHandle == TRUE )
  70                         ObjectAttributes.Attributes |= OBJ_INHERIT;
  71         }
  72
  73
  74         errCode = NtCreateSemaphore(
  75         &SemaphoreHandle,
  76         GENERIC_ALL,
  77         &ObjectAttributes,
  78         lInitialCount,
  79         lMaximumCount
  80         );
  81         if (!NT_SUCCESS(errCode))
  82                 {
  83                 SetLastError(RtlNtStatusToDosError(errCode));
  84                 return NULL;
  85                 }
  86
  87         return SemaphoreHandle;
  88 }
  89
  90 HANDLE
  91 STDCALL
  92 CreateMutexA(
  93              LPSECURITY_ATTRIBUTES lpMutexAttributes,
  94              WINBOOL bInitialOwner,
  95              LPCSTR lpName
  96              )
  97 {
  98         WCHAR NameW[MAX_PATH];
  99         ULONG i = 0;
 100
 101         while ((*lpName)!=0 && i < MAX_PATH)
 102         {
 103                 NameW[i] = *lpName;
 104                 lpName++;
 105                 i++;
 106         }
 107         NameW[i] = 0;
 108
 109         return CreateMutexW(
 110              lpMutexAttributes,
 111              bInitialOwner,
 112              NameW
 113              );
 114 }
 115
 116 HANDLE
 117 STDCALL
 118 CreateMutexW(
 119     LPSECURITY_ATTRIBUTES lpMutexAttributes,
 120     WINBOOL bInitialOwner,
 121     LPCWSTR lpName
 122     )
 123 {
 124         OBJECT_ATTRIBUTES ObjectAttributes;
 125         NTSTATUS errCode;
 126         UNICODE_STRING NameString;
 127         HANDLE MutantHandle;
 128
 129         NameString.Length = lstrlenW(lpName)*sizeof(WCHAR);
 130         NameString.Buffer = (WCHAR *)lpName;
 131         NameString.MaximumLength = NameString.Length;
 132
 133         ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
 134         ObjectAttributes.RootDirectory = NULL;
 135         ObjectAttributes.ObjectName = &NameString;
 136         ObjectAttributes.Attributes = OBJ_CASE_INSENSITIVE;
 137         ObjectAttributes.SecurityDescriptor = NULL;
 138         ObjectAttributes.SecurityQualityOfService = NULL;
 139
 140         if ( lpMutexAttributes != NULL ) {
 141                 ObjectAttributes.SecurityDescriptor = lpMutexAttributes->lpSecurityDescriptor;
 142                 if ( lpMutexAttributes->bInheritHandle == TRUE )
 143                         ObjectAttributes.Attributes |= OBJ_INHERIT;
 144         }
 145
 146
 147         errCode = NtCreateMutant(&MutantHandle,GENERIC_ALL, &ObjectAttributes,(BOOLEAN)bInitialOwner);
 148         if (!NT_SUCCESS(errCode))
 149         {
 150                 SetLastError(RtlNtStatusToDosError(errCode));
 151                 return NULL;
 152         }
 153
 154         return MutantHandle;
 155
 156 }
 157
 158
 159 DWORD
 160 STDCALL
 161 WaitForSingleObject(HANDLE  hHandle,
 162                     DWORD  dwMilliseconds)
 163 {
 164    return WaitForSingleObjectEx(hHandle,dwMilliseconds,FALSE);
 165 }
 166
 167
 168 DWORD
 169 STDCALL
 170 WaitForSingleObjectEx(HANDLE hHandle,
 171                       DWORD  dwMilliseconds,
 172                       BOOL   bAlertable)
 173 {
 174    NTSTATUS  errCode;
 175    PLARGE_INTEGER TimePtr;
 176    LARGE_INTEGER Time;
 177    DWORD retCode;
 178
 179    if (dwMilliseconds == INFINITE)
 180      {
 181         TimePtr = NULL;
 182      }
 183    else
 184      {
 185         Time.QuadPart = -10000 * dwMilliseconds;
 186         TimePtr = &Time;
 187      }
 188
 189    errCode = NtWaitForSingleObject(hHandle,
 190                                    (BOOLEAN) bAlertable,
 191                                    TimePtr);
 192    if (errCode == STATUS_TIMEOUT)
 193      {
 194          return WAIT_TIMEOUT;
 195      }
 196    else if (errCode == WAIT_OBJECT_0)
 197      {
 198         return WAIT_OBJECT_0;
 199      }
 200
 201    retCode = RtlNtStatusToDosError(errCode);
 202    SetLastError(retCode);
 203
 204    return 0xFFFFFFFF;
 205 }
 206
 207
 208 DWORD
 209 STDCALL
 210 WaitForMultipleObjects(DWORD nCount,
 211                        CONST HANDLE *lpHandles,
 212                        BOOL  bWaitAll,
 213                        DWORD dwMilliseconds)
 214 {
 215    return WaitForMultipleObjectsEx(nCount,lpHandles,bWaitAll,dwMilliseconds,FALSE);
 216 }
 217
 218
 219 DWORD
 220 STDCALL
 221 WaitForMultipleObjectsEx(DWORD nCount,
 222                          CONST HANDLE *lpHandles,
 223                          BOOL  bWaitAll,
 224                          DWORD dwMilliseconds,
 225                          BOOL  bAlertable)
 226 {
 227    NTSTATUS  errCode;
 228    LARGE_INTEGER Time;
 229    PLARGE_INTEGER TimePtr;
 230    DWORD retCode;
 231
 232    if (dwMilliseconds == INFINITE)
 233      {
 234         TimePtr = NULL;
 235      }
 236    else
 237      {
 238         Time.QuadPart = -10000 * dwMilliseconds;
 239         TimePtr = &Time;
 240      }
 241
 242    errCode = NtWaitForMultipleObjects (nCount,
 243                                        (PHANDLE)lpHandles,
 244                                        (CINT)bWaitAll,
 245                                        (BOOLEAN)bAlertable,
 246                                        TimePtr);
 247
 248    if (errCode == STATUS_TIMEOUT)
 249      {
 250          return WAIT_TIMEOUT;
 251      }
 252    else if ((errCode >= WAIT_OBJECT_0) &&
 253             (errCode <= WAIT_OBJECT_0 + nCount - 1))
 254      {
 255         return errCode;
 256      }
 257
 258    retCode = RtlNtStatusToDosError(errCode);
 259    SetLastError(retCode);
 260
 261    return 0xFFFFFFFF;
 262 }
 263
 264 /* EOF */
 265