scheduler/timer.c

   1 /*
   2  * Win32 waitable timers
   3  *
   4  * Copyright 1999 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <string.h>
  26
  27 #define NONAMELESSUNION
  28 #define NONAMELESSSTRUCT
  29 #include "winerror.h"
  30 #include "winnls.h"
  31 #include "wine/unicode.h"
  32 #include "wine/server.h"
  33 #include "wine/debug.h"
  34 #include "ntdll_misc.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(timer);
  37
  38
  39 /***********************************************************************
  40  *           CreateWaitableTimerA    (KERNEL32.@)
  41  */
  42 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
  43 {
  44     WCHAR buffer[MAX_PATH];
  45
  46     if (!name) return CreateWaitableTimerW( sa, manual, NULL );
  47
  48     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
  49     {
  50         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  51         return 0;
  52     }
  53     return CreateWaitableTimerW( sa, manual, buffer );
  54 }
  55
  56
  57 /***********************************************************************
  58  *           CreateWaitableTimerW    (KERNEL32.@)
  59  */
  60 HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWSTR name )
  61 {
  62     HANDLE ret;
  63     DWORD len = name ? strlenW(name) : 0;
  64     if (len >= MAX_PATH)
  65     {
  66         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  67         return 0;
  68     }
  69     SERVER_START_REQ( create_timer )
  70     {
  71         req->manual  = manual;
  72         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  73         wine_server_add_data( req, name, len * sizeof(WCHAR) );
  74         SetLastError(0);
  75         wine_server_call_err( req );
  76         ret = reply->handle;
  77     }
  78     SERVER_END_REQ;
  79     return ret;
  80 }
  81
  82
  83 /***********************************************************************
  84  *           OpenWaitableTimerA    (KERNEL32.@)
  85  */
  86 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
  87 {
  88     WCHAR buffer[MAX_PATH];
  89
  90     if (!name) return OpenWaitableTimerW( access, inherit, NULL );
  91
  92     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
  93     {
  94         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  95         return 0;
  96     }
  97     return OpenWaitableTimerW( access, inherit, buffer );
  98 }
  99
 100
 101 /***********************************************************************
 102  *           OpenWaitableTimerW    (KERNEL32.@)
 103  */
 104 HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
 105 {
 106     HANDLE ret;
 107     DWORD len = name ? strlenW(name) : 0;
 108     if (len >= MAX_PATH)
 109     {
 110         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 111         return 0;
 112     }
 113     SERVER_START_REQ( open_timer )
 114     {
 115         req->access  = access;
 116         req->inherit = inherit;
 117         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 118         wine_server_call_err( req );
 119         ret = reply->handle;
 120     }
 121     SERVER_END_REQ;
 122     return ret;
 123 }
 124
 125
 126 /***********************************************************************
 127  *           SetWaitableTimer    (KERNEL32.@)
 128  */
 129 BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG period,
 130                               PTIMERAPCROUTINE callback, LPVOID arg, BOOL resume )
 131 {
 132     BOOL ret;
 133
 134     SERVER_START_REQ( set_timer )
 135     {
 136         if (!when->s.LowPart && !when->s.HighPart)
 137         {
 138             /* special case to start timeout on now+period without too many calculations */
 139             req->expire.sec  = 0;
 140             req->expire.usec = 0;
 141         }
 142         else NTDLL_get_server_timeout( &req->expire, when );
 143
 144         req->handle   = handle;
 145         req->period   = period;
 146         req->callback = callback;
 147         req->arg      = arg;
 148         if (resume) SetLastError( ERROR_NOT_SUPPORTED ); /* set error but can still succeed */
 149         ret = !wine_server_call_err( req );
 150     }
 151     SERVER_END_REQ;
 152     return ret;
 153 }
 154
 155
 156 /***********************************************************************
 157  *           CancelWaitableTimer    (KERNEL32.@)
 158  */
 159 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
 160 {
 161     BOOL ret;
 162     SERVER_START_REQ( cancel_timer )
 163     {
 164         req->handle = handle;
 165         ret = !wine_server_call_err( req );
 166     }
 167     SERVER_END_REQ;
 168     return ret;
 169 }
 170
 171
 172 /***********************************************************************
 173  *           CreateTimerQueue  (KERNEL32.@)
 174  */
 175 HANDLE WINAPI CreateTimerQueue()
 176 {
 177     FIXME("stub\n");
 178     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 179     return NULL;
 180 }
 181
 182
 183 /***********************************************************************
 184  *           DeleteTimerQueueEx  (KERNEL32.@)
 185  */
 186 BOOL WINAPI DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent)
 187 {
 188     FIXME("(%p, %p): stub\n", TimerQueue, CompletionEvent);
 189     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 190     return 0;
 191 }
 192
 193 /***********************************************************************
 194  *           CreateTimerQueueTimer  (KERNEL32.@)
 195  *
 196  * Creates a timer-queue timer. This timer expires at the specified due
 197  * time (in ms), then after every specified period (in ms). When the timer
 198  * expires, the callback function is called.
 199  *
 200  * RETURNS
 201  *   nonzero on success or zero on faillure
 202  *
 203  * BUGS
 204  *   Unimplemented
 205  */
 206 BOOL WINAPI CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue,
 207                                    WAITORTIMERCALLBACK Callback, PVOID Parameter,
 208                                    DWORD DueTime, DWORD Period, ULONG Flags )
 209 {
 210     FIXME("stub\n");
 211     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 212     return TRUE;
 213 }
 214
 215 /***********************************************************************
 216  *           DeleteTimerQueueTimer  (KERNEL32.@)
 217  *
 218  * Cancels a timer-queue timer.
 219  *
 220  * RETURNS
 221  *   nonzero on success or zero on faillure
 222  *
 223  * BUGS
 224  *   Unimplemented
 225  */
 226 BOOL WINAPI DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
 227                                    HANDLE CompletionEvent )
 228 {
 229     FIXME("stub\n");
 230     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 231     return TRUE;
 232 }