scheduler/timer.c

   1 /*
   2  * Win32 waitable timers
   3  *
   4  * Copyright 1999 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 "file.h"  /* for FILETIME routines */
  13 #include "server.h"
  14
  15
  16 /***********************************************************************
  17  *           CreateWaitableTimerA    (KERNEL32.861)
  18  */
  19 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
  20 {
  21     HANDLE ret;
  22     DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
  23     if (len >= MAX_PATH)
  24     {
  25         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  26         return 0;
  27     }
  28     SERVER_START_REQ
  29     {
  30         struct create_timer_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
  31
  32         req->manual  = manual;
  33         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  34         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
  35         SetLastError(0);
  36         server_call( REQ_CREATE_TIMER );
  37         ret = req->handle;
  38     }
  39     SERVER_END_REQ;
  40     if (ret == INVALID_HANDLE_VALUE) ret = 0; /* must return 0 on failure, not -1 */
  41     return ret;
  42 }
  43
  44
  45 /***********************************************************************
  46  *           CreateWaitableTimerW    (KERNEL32.862)
  47  */
  48 HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWSTR name )
  49 {
  50     HANDLE ret;
  51     DWORD len = name ? strlenW(name) : 0;
  52     if (len >= MAX_PATH)
  53     {
  54         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  55         return 0;
  56     }
  57     SERVER_START_REQ
  58     {
  59         struct create_timer_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
  60
  61         req->manual  = manual;
  62         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  63         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
  64         SetLastError(0);
  65         server_call( REQ_CREATE_TIMER );
  66         ret = req->handle;
  67     }
  68     SERVER_END_REQ;
  69     if (ret == INVALID_HANDLE_VALUE) ret = 0; /* must return 0 on failure, not -1 */
  70     return ret;
  71 }
  72
  73
  74 /***********************************************************************
  75  *           OpenWaitableTimerA    (KERNEL32.881)
  76  */
  77 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
  78 {
  79     HANDLE ret;
  80     DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
  81     if (len >= MAX_PATH)
  82     {
  83         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  84         return 0;
  85     }
  86     SERVER_START_REQ
  87     {
  88         struct open_timer_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
  89
  90         req->access  = access;
  91         req->inherit = inherit;
  92         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
  93         server_call( REQ_OPEN_TIMER );
  94         ret = req->handle;
  95     }
  96     SERVER_END_REQ;
  97     if (ret == INVALID_HANDLE_VALUE) ret = 0; /* must return 0 on failure, not -1 */
  98     return ret;
  99 }
 100
 101
 102 /***********************************************************************
 103  *           OpenWaitableTimerW    (KERNEL32.882)
 104  */
 105 HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
 106 {
 107     HANDLE ret;
 108     DWORD len = name ? strlenW(name) : 0;
 109     if (len >= MAX_PATH)
 110     {
 111         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 112         return 0;
 113     }
 114     SERVER_START_REQ
 115     {
 116         struct open_timer_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 117
 118         req->access  = access;
 119         req->inherit = inherit;
 120         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
 121         server_call( REQ_OPEN_TIMER );
 122         ret = req->handle;
 123     }
 124     SERVER_END_REQ;
 125     if (ret == INVALID_HANDLE_VALUE) ret = 0; /* must return 0 on failure, not -1 */
 126     return ret;
 127 }
 128
 129
 130 /***********************************************************************
 131  *           SetWaitableTimer    (KERNEL32.894)
 132  */
 133 BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG period,
 134                               PTIMERAPCROUTINE callback, LPVOID arg, BOOL resume )
 135 {
 136     BOOL ret;
 137     LARGE_INTEGER exp = *when;
 138
 139     if (exp.s.HighPart < 0)  /* relative time */
 140     {
 141         LARGE_INTEGER now;
 142         NtQuerySystemTime( &now );
 143         exp.QuadPart = RtlLargeIntegerSubtract( now.QuadPart, exp.QuadPart );
 144     }
 145
 146     SERVER_START_REQ
 147     {
 148         struct set_timer_request *req = server_alloc_req( sizeof(*req), 0 );
 149
 150         if (!exp.s.LowPart && !exp.s.HighPart)
 151         {
 152             /* special case to start timeout on now+period without too many calculations */
 153             req->sec  = 0;
 154             req->usec = 0;
 155         }
 156         else
 157         {
 158             DWORD remainder;
 159             req->sec  = DOSFS_FileTimeToUnixTime( (FILETIME *)&exp, &remainder );
 160             req->usec = remainder / 10;  /* convert from 100-ns to us units */
 161         }
 162         req->handle   = handle;
 163         req->period   = period;
 164         req->callback = callback;
 165         req->arg      = arg;
 166         if (resume) SetLastError( ERROR_NOT_SUPPORTED ); /* set error but can still succeed */
 167         ret = !server_call( REQ_SET_TIMER );
 168     }
 169     SERVER_END_REQ;
 170     return ret;
 171 }
 172
 173
 174 /***********************************************************************
 175  *           CancelWaitableTimer    (KERNEL32.857)
 176  */
 177 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
 178 {
 179     BOOL ret;
 180     SERVER_START_REQ
 181     {
 182         struct cancel_timer_request *req = server_alloc_req( sizeof(*req), 0 );
 183         req->handle = handle;
 184         ret = !server_call( REQ_CANCEL_TIMER );
 185     }
 186     SERVER_END_REQ;
 187     return ret;
 188 }