user32: Limit text in the edit field of a combo box.
[wine] / server / timer.c
1 /*
2  * Waitable timers management
3  *
4  * Copyright (C) 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 <stdio.h>
26 #include <stdlib.h>
27 #include <sys/time.h>
28 #include <sys/types.h>
29 #include <stdarg.h>
30
31 #include "ntstatus.h"
32 #define WIN32_NO_STATUS
33 #include "windef.h"
34 #include "winternl.h"
35
36 #include "file.h"
37 #include "handle.h"
38 #include "request.h"
39
40 struct timer
41 {
42     struct object        obj;       /* object header */
43     int                  manual;    /* manual reset */
44     int                  signaled;  /* current signaled state */
45     int                  period;    /* timer period in ms */
46     struct timeval       when;      /* next expiration */
47     struct timeout_user *timeout;   /* timeout user */
48     struct thread       *thread;    /* thread that set the APC function */
49     void                *callback;  /* callback APC function */
50     void                *arg;       /* callback argument */
51 };
52
53 static void timer_dump( struct object *obj, int verbose );
54 static int timer_signaled( struct object *obj, struct thread *thread );
55 static int timer_satisfied( struct object *obj, struct thread *thread );
56 static unsigned int timer_map_access( struct object *obj, unsigned int access );
57 static void timer_destroy( struct object *obj );
58
59 static const struct object_ops timer_ops =
60 {
61     sizeof(struct timer),      /* size */
62     timer_dump,                /* dump */
63     add_queue,                 /* add_queue */
64     remove_queue,              /* remove_queue */
65     timer_signaled,            /* signaled */
66     timer_satisfied,           /* satisfied */
67     no_signal,                 /* signal */
68     no_get_fd,                 /* get_fd */
69     timer_map_access,          /* map_access */
70     no_lookup_name,            /* lookup_name */
71     no_close_handle,           /* close_handle */
72     timer_destroy              /* destroy */
73 };
74
75
76 /* create a timer object */
77 static struct timer *create_timer( struct directory *root, const struct unicode_str *name,
78                                    unsigned int attr, int manual )
79 {
80     struct timer *timer;
81
82     if ((timer = create_named_object_dir( root, name, attr, &timer_ops )))
83     {
84         if (get_error() != STATUS_OBJECT_NAME_EXISTS)
85         {
86             /* initialize it if it didn't already exist */
87             timer->manual       = manual;
88             timer->signaled     = 0;
89             timer->when.tv_sec  = 0;
90             timer->when.tv_usec = 0;
91             timer->period       = 0;
92             timer->timeout      = NULL;
93             timer->thread       = NULL;
94         }
95     }
96     return timer;
97 }
98
99 /* callback on timer expiration */
100 static void timer_callback( void *private )
101 {
102     struct timer *timer = (struct timer *)private;
103
104     /* queue an APC */
105     if (timer->thread)
106     {
107         if (!thread_queue_apc( timer->thread, &timer->obj, timer->callback, APC_TIMER, 0,
108                                (void *)timer->when.tv_sec, (void *)timer->when.tv_usec, timer->arg))
109         {
110             release_object( timer->thread );
111             timer->thread = NULL;
112         }
113     }
114
115     if (timer->period)  /* schedule the next expiration */
116     {
117         add_timeout( &timer->when, timer->period );
118         timer->timeout = add_timeout_user( &timer->when, timer_callback, timer );
119     }
120     else timer->timeout = NULL;
121
122     /* wake up waiters */
123     timer->signaled = 1;
124     wake_up( &timer->obj, 0 );
125 }
126
127 /* cancel a running timer */
128 static int cancel_timer( struct timer *timer )
129 {
130     int signaled = timer->signaled;
131
132     if (timer->timeout)
133     {
134         remove_timeout_user( timer->timeout );
135         timer->timeout = NULL;
136     }
137     if (timer->thread)
138     {
139         thread_cancel_apc( timer->thread, &timer->obj, 0 );
140         release_object( timer->thread );
141         timer->thread = NULL;
142     }
143     return signaled;
144 }
145
146 /* set the timer expiration and period */
147 static int set_timer( struct timer *timer, const abs_time_t *expire, int period,
148                       void *callback, void *arg )
149 {
150     int signaled = cancel_timer( timer );
151     if (timer->manual)
152     {
153         period = 0;  /* period doesn't make any sense for a manual timer */
154         timer->signaled = 0;
155     }
156     if (!expire->sec && !expire->usec)
157     {
158         /* special case: use now + period as first expiration */
159         gettimeofday( &timer->when, NULL );
160         add_timeout( &timer->when, period );
161     }
162     else
163     {
164         timer->when.tv_sec  = expire->sec;
165         timer->when.tv_usec = expire->usec;
166     }
167     timer->period       = period;
168     timer->callback     = callback;
169     timer->arg          = arg;
170     if (callback) timer->thread = (struct thread *)grab_object( current );
171     timer->timeout = add_timeout_user( &timer->when, timer_callback, timer );
172     return signaled;
173 }
174
175 static void timer_dump( struct object *obj, int verbose )
176 {
177     struct timer *timer = (struct timer *)obj;
178     assert( obj->ops == &timer_ops );
179     fprintf( stderr, "Timer manual=%d when=%ld.%06ld period=%d ",
180              timer->manual, timer->when.tv_sec, timer->when.tv_usec, timer->period );
181     dump_object_name( &timer->obj );
182     fputc( '\n', stderr );
183 }
184
185 static int timer_signaled( struct object *obj, struct thread *thread )
186 {
187     struct timer *timer = (struct timer *)obj;
188     assert( obj->ops == &timer_ops );
189     return timer->signaled;
190 }
191
192 static int timer_satisfied( struct object *obj, struct thread *thread )
193 {
194     struct timer *timer = (struct timer *)obj;
195     assert( obj->ops == &timer_ops );
196     if (!timer->manual) timer->signaled = 0;
197     return 0;
198 }
199
200 static unsigned int timer_map_access( struct object *obj, unsigned int access )
201 {
202     if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ | SYNCHRONIZE | TIMER_QUERY_STATE;
203     if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE | TIMER_MODIFY_STATE;
204     if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
205     if (access & GENERIC_ALL)     access |= TIMER_ALL_ACCESS;
206     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
207 }
208
209 static void timer_destroy( struct object *obj )
210 {
211     struct timer *timer = (struct timer *)obj;
212     assert( obj->ops == &timer_ops );
213
214     if (timer->timeout) remove_timeout_user( timer->timeout );
215     if (timer->thread) release_object( timer->thread );
216 }
217
218 /* create a timer */
219 DECL_HANDLER(create_timer)
220 {
221     struct timer *timer;
222     struct unicode_str name;
223     struct directory *root = NULL;
224
225     reply->handle = 0;
226     get_req_unicode_str( &name );
227     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
228         return;
229
230     if ((timer = create_timer( root, &name, req->attributes, req->manual )))
231     {
232         reply->handle = alloc_handle( current->process, timer, req->access, req->attributes );
233         release_object( timer );
234     }
235
236     if (root) release_object( root );
237 }
238
239 /* open a handle to a timer */
240 DECL_HANDLER(open_timer)
241 {
242     struct unicode_str name;
243     struct directory *root = NULL;
244     struct timer *timer;
245
246     get_req_unicode_str( &name );
247     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
248         return;
249
250     if ((timer = open_object_dir( root, &name, req->attributes, &timer_ops )))
251     {
252         reply->handle = alloc_handle( current->process, &timer->obj, req->access, req->attributes );
253         release_object( timer );
254     }
255
256     if (root) release_object( root );
257 }
258
259 /* set a waitable timer */
260 DECL_HANDLER(set_timer)
261 {
262     struct timer *timer;
263
264     if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
265                                                  TIMER_MODIFY_STATE, &timer_ops )))
266     {
267         reply->signaled = set_timer( timer, &req->expire, req->period, req->callback, req->arg );
268         release_object( timer );
269     }
270 }
271
272 /* cancel a waitable timer */
273 DECL_HANDLER(cancel_timer)
274 {
275     struct timer *timer;
276
277     if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
278                                                  TIMER_MODIFY_STATE, &timer_ops )))
279     {
280         reply->signaled = cancel_timer( timer );
281         release_object( timer );
282     }
283 }
284
285 /* Get information on a waitable timer */
286 DECL_HANDLER(get_timer_info)
287 {
288     struct timer *timer;
289
290     if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
291                                                  TIMER_QUERY_STATE, &timer_ops )))
292     {
293         reply->when.sec  = timer->when.tv_sec;
294         reply->when.usec = timer->when.tv_usec;
295         reply->signaled  = timer->signaled;
296         release_object( timer );
297     }
298 }