scheduler/mutex.c

   1 /*
   2  * Win32 mutexes
   3  *
   4  * Copyright 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <string.h>
   9 #include "winerror.h"
  10 #include "wine/unicode.h"
  11 #include "server.h"
  12
  13
  14 /***********************************************************************
  15  *           CreateMutexA   (KERNEL32.166)
  16  */
  17 HANDLE WINAPI CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCSTR name )
  18 {
  19     HANDLE ret;
  20     DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
  21     if (len >= MAX_PATH)
  22     {
  23         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  24         return 0;
  25     }
  26     SERVER_START_REQ
  27     {
  28         struct create_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
  29
  30         req->owned   = owner;
  31         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  32         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
  33         SetLastError(0);
  34         server_call( REQ_CREATE_MUTEX );
  35         ret = req->handle;
  36     }
  37     SERVER_END_REQ;
  38     if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
  39     return ret;
  40 }
  41
  42
  43 /***********************************************************************
  44  *           CreateMutexW   (KERNEL32.167)
  45  */
  46 HANDLE WINAPI CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCWSTR name )
  47 {
  48     HANDLE ret;
  49     DWORD len = name ? strlenW(name) : 0;
  50     if (len >= MAX_PATH)
  51     {
  52         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  53         return 0;
  54     }
  55     SERVER_START_REQ
  56     {
  57         struct create_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
  58
  59         req->owned   = owner;
  60         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  61         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
  62         SetLastError(0);
  63         server_call( REQ_CREATE_MUTEX );
  64         ret = req->handle;
  65     }
  66     SERVER_END_REQ;
  67     if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
  68     return ret;
  69 }
  70
  71
  72 /***********************************************************************
  73  *           OpenMutexA   (KERNEL32.541)
  74  */
  75 HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
  76 {
  77     HANDLE ret;
  78     DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
  79     if (len >= MAX_PATH)
  80     {
  81         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  82         return 0;
  83     }
  84     SERVER_START_REQ
  85     {
  86         struct open_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
  87
  88         req->access  = access;
  89         req->inherit = inherit;
  90         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
  91         server_call( REQ_OPEN_MUTEX );
  92         ret = req->handle;
  93     }
  94     SERVER_END_REQ;
  95     if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
  96     return ret;
  97 }
  98
  99
 100 /***********************************************************************
 101  *           OpenMutexW   (KERNEL32.542)
 102  */
 103 HANDLE WINAPI OpenMutexW( DWORD access, BOOL inherit, LPCWSTR name )
 104 {
 105     HANDLE ret;
 106     DWORD len = name ? strlenW(name) : 0;
 107     if (len >= MAX_PATH)
 108     {
 109         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 110         return 0;
 111     }
 112     SERVER_START_REQ
 113     {
 114         struct open_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 115
 116         req->access  = access;
 117         req->inherit = inherit;
 118         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
 119         server_call( REQ_OPEN_MUTEX );
 120         ret = req->handle;
 121     }
 122     SERVER_END_REQ;
 123     if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
 124     return ret;
 125 }
 126
 127
 128 /***********************************************************************
 129  *           ReleaseMutex   (KERNEL32.582)
 130  */
 131 BOOL WINAPI ReleaseMutex( HANDLE handle )
 132 {
 133     BOOL ret;
 134     SERVER_START_REQ
 135     {
 136         struct release_mutex_request *req = server_alloc_req( sizeof(*req), 0 );
 137         req->handle = handle;
 138         ret = !server_call( REQ_RELEASE_MUTEX );
 139     }
 140     SERVER_END_REQ;
 141     return ret;
 142 }