scheduler/event.c

   1 /*
   2  * Win32 events
   3  *
   4  * Copyright 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <string.h>
   9 #include "winerror.h"
  10 #include "winnls.h"
  11 #include "wine/unicode.h"
  12 #include "syslevel.h"
  13 #include "server.h"
  14
  15
  16 /***********************************************************************
  17  *           CreateEventA    (KERNEL32.156)
  18  */
  19 HANDLE WINAPI CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
  20                             BOOL initial_state, LPCSTR name )
  21 {
  22     HANDLE ret;
  23     DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
  24     if (len >= MAX_PATH)
  25     {
  26         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  27         return 0;
  28     }
  29     SERVER_START_REQ
  30     {
  31         struct create_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
  32
  33         req->manual_reset = manual_reset;
  34         req->initial_state = initial_state;
  35         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  36         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
  37         SetLastError(0);
  38         server_call( REQ_CREATE_EVENT );
  39         ret = req->handle;
  40     }
  41     SERVER_END_REQ;
  42     if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
  43     return ret;
  44 }
  45
  46
  47 /***********************************************************************
  48  *           CreateEventW    (KERNEL32.157)
  49  */
  50 HANDLE WINAPI CreateEventW( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
  51                             BOOL initial_state, LPCWSTR name )
  52 {
  53     HANDLE ret;
  54     DWORD len = name ? strlenW(name) : 0;
  55     if (len >= MAX_PATH)
  56     {
  57         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  58         return 0;
  59     }
  60     SERVER_START_REQ
  61     {
  62         struct create_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
  63
  64         req->manual_reset = manual_reset;
  65         req->initial_state = initial_state;
  66         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  67         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
  68         SetLastError(0);
  69         server_call( REQ_CREATE_EVENT );
  70         ret = req->handle;
  71     }
  72     SERVER_END_REQ;
  73     if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
  74     return ret;
  75 }
  76
  77 /***********************************************************************
  78  *           WIN16_CreateEvent    (KERNEL.457)
  79  */
  80 HANDLE WINAPI WIN16_CreateEvent( BOOL manual_reset, BOOL initial_state )
  81 {
  82     return CreateEventA( NULL, manual_reset, initial_state, NULL );
  83 }
  84
  85
  86 /***********************************************************************
  87  *           OpenEventA    (KERNEL32.536)
  88  */
  89 HANDLE WINAPI OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
  90 {
  91     HANDLE ret;
  92     DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
  93     if (len >= MAX_PATH)
  94     {
  95         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  96         return 0;
  97     }
  98     SERVER_START_REQ
  99     {
 100         struct open_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 101
 102         req->access  = access;
 103         req->inherit = inherit;
 104         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
 105         server_call( REQ_OPEN_EVENT );
 106         ret = req->handle;
 107     }
 108     SERVER_END_REQ;
 109     if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
 110     return ret;
 111 }
 112
 113
 114 /***********************************************************************
 115  *           OpenEventW    (KERNEL32.537)
 116  */
 117 HANDLE WINAPI OpenEventW( DWORD access, BOOL inherit, LPCWSTR name )
 118 {
 119     HANDLE ret;
 120     DWORD len = name ? strlenW(name) : 0;
 121     if (len >= MAX_PATH)
 122     {
 123         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 124         return 0;
 125     }
 126     SERVER_START_REQ
 127     {
 128         struct open_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 129
 130         req->access  = access;
 131         req->inherit = inherit;
 132         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
 133         server_call( REQ_OPEN_EVENT );
 134         ret = req->handle;
 135     }
 136     SERVER_END_REQ;
 137     if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
 138     return ret;
 139 }
 140
 141
 142 /***********************************************************************
 143  *           EVENT_Operation
 144  *
 145  * Execute an event operation (set,reset,pulse).
 146  */
 147 static BOOL EVENT_Operation( HANDLE handle, enum event_op op )
 148 {
 149     BOOL ret;
 150     SERVER_START_REQ
 151     {
 152         struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
 153         req->handle = handle;
 154         req->op     = op;
 155         ret = !server_call( REQ_EVENT_OP );
 156     }
 157     SERVER_END_REQ;
 158     return ret;
 159 }
 160
 161
 162 /***********************************************************************
 163  *           PulseEvent    (KERNEL32.557)
 164  */
 165 BOOL WINAPI PulseEvent( HANDLE handle )
 166 {
 167     return EVENT_Operation( handle, PULSE_EVENT );
 168 }
 169
 170
 171 /***********************************************************************
 172  *           SetEvent    (KERNEL32.644)
 173  */
 174 BOOL WINAPI SetEvent( HANDLE handle )
 175 {
 176     return EVENT_Operation( handle, SET_EVENT );
 177 }
 178
 179
 180 /***********************************************************************
 181  *           ResetEvent    (KERNEL32.586)
 182  */
 183 BOOL WINAPI ResetEvent( HANDLE handle )
 184 {
 185     return EVENT_Operation( handle, RESET_EVENT );
 186 }
 187
 188
 189 /***********************************************************************
 190  * NOTE: The Win95 VWin32_Event routines given below are really low-level
 191  *       routines implemented directly by VWin32. The user-mode libraries
 192  *       implement Win32 synchronisation routines on top of these low-level
 193  *       primitives. We do it the other way around here :-)
 194  */
 195
 196 /***********************************************************************
 197  *       VWin32_EventCreate     (KERNEL.442)
 198  */
 199 HANDLE WINAPI VWin32_EventCreate(VOID)
 200 {
 201     HANDLE hEvent = CreateEventA( NULL, FALSE, 0, NULL );
 202     return ConvertToGlobalHandle( hEvent );
 203 }
 204
 205 /***********************************************************************
 206  *       VWin32_EventDestroy    (KERNEL.443)
 207  */
 208 VOID WINAPI VWin32_EventDestroy(HANDLE event)
 209 {
 210     CloseHandle( event );
 211 }
 212
 213 /***********************************************************************
 214  *       VWin32_EventWait       (KERNEL.450)
 215  */
 216 VOID WINAPI VWin32_EventWait(HANDLE event)
 217 {
 218     SYSLEVEL_ReleaseWin16Lock();
 219     WaitForSingleObject( event, INFINITE );
 220     SYSLEVEL_RestoreWin16Lock();
 221 }
 222
 223 /***********************************************************************
 224  *       VWin32_EventSet        (KERNEL.451)
 225  */
 226 VOID WINAPI VWin32_EventSet(HANDLE event)
 227 {
 228     SetEvent( event );
 229 }
 230