2 * Server-side event management
4 * Copyright (C) 1998 Alexandre Julliard
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.
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.
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
30 #define WIN32_NO_STATUS
41 struct object obj
; /* object header */
42 int manual_reset
; /* is it a manual reset event? */
43 int signaled
; /* event has been signaled */
46 static void event_dump( struct object
*obj
, int verbose
);
47 static struct object_type
*event_get_type( struct object
*obj
);
48 static int event_signaled( struct object
*obj
, struct thread
*thread
);
49 static int event_satisfied( struct object
*obj
, struct thread
*thread
);
50 static unsigned int event_map_access( struct object
*obj
, unsigned int access
);
51 static int event_signal( struct object
*obj
, unsigned int access
);
53 static const struct object_ops event_ops
=
55 sizeof(struct event
), /* size */
56 event_dump
, /* dump */
57 event_get_type
, /* get_type */
58 add_queue
, /* add_queue */
59 remove_queue
, /* remove_queue */
60 event_signaled
, /* signaled */
61 event_satisfied
, /* satisfied */
62 event_signal
, /* signal */
63 no_get_fd
, /* get_fd */
64 event_map_access
, /* map_access */
65 default_get_sd
, /* get_sd */
66 default_set_sd
, /* set_sd */
67 no_lookup_name
, /* lookup_name */
68 no_open_file
, /* open_file */
69 no_close_handle
, /* close_handle */
70 no_destroy
/* destroy */
76 struct object obj
; /* object header */
79 static void keyed_event_dump( struct object
*obj
, int verbose
);
80 static struct object_type
*keyed_event_get_type( struct object
*obj
);
81 static int keyed_event_signaled( struct object
*obj
, struct thread
*thread
);
82 static unsigned int keyed_event_map_access( struct object
*obj
, unsigned int access
);
84 static const struct object_ops keyed_event_ops
=
86 sizeof(struct keyed_event
), /* size */
87 keyed_event_dump
, /* dump */
88 keyed_event_get_type
, /* get_type */
89 add_queue
, /* add_queue */
90 remove_queue
, /* remove_queue */
91 keyed_event_signaled
, /* signaled */
92 no_satisfied
, /* satisfied */
93 no_signal
, /* signal */
94 no_get_fd
, /* get_fd */
95 keyed_event_map_access
, /* map_access */
96 default_get_sd
, /* get_sd */
97 default_set_sd
, /* set_sd */
98 no_lookup_name
, /* lookup_name */
99 no_open_file
, /* open_file */
100 no_close_handle
, /* close_handle */
101 no_destroy
/* destroy */
104 #define KEYEDEVENT_WAIT 0x0001
105 #define KEYEDEVENT_WAKE 0x0002
106 #define KEYEDEVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x0003)
109 struct event
*create_event( struct directory
*root
, const struct unicode_str
*name
,
110 unsigned int attr
, int manual_reset
, int initial_state
,
111 const struct security_descriptor
*sd
)
115 if ((event
= create_named_object_dir( root
, name
, attr
, &event_ops
)))
117 if (get_error() != STATUS_OBJECT_NAME_EXISTS
)
119 /* initialize it if it didn't already exist */
120 event
->manual_reset
= manual_reset
;
121 event
->signaled
= initial_state
;
122 if (sd
) default_set_sd( &event
->obj
, sd
, OWNER_SECURITY_INFORMATION
|
123 GROUP_SECURITY_INFORMATION
|
124 DACL_SECURITY_INFORMATION
|
125 SACL_SECURITY_INFORMATION
);
131 struct event
*get_event_obj( struct process
*process
, obj_handle_t handle
, unsigned int access
)
133 return (struct event
*)get_handle_obj( process
, handle
, access
, &event_ops
);
136 void pulse_event( struct event
*event
)
139 /* wake up all waiters if manual reset, a single one otherwise */
140 wake_up( &event
->obj
, !event
->manual_reset
);
144 void set_event( struct event
*event
)
147 /* wake up all waiters if manual reset, a single one otherwise */
148 wake_up( &event
->obj
, !event
->manual_reset
);
151 void reset_event( struct event
*event
)
156 static void event_dump( struct object
*obj
, int verbose
)
158 struct event
*event
= (struct event
*)obj
;
159 assert( obj
->ops
== &event_ops
);
160 fprintf( stderr
, "Event manual=%d signaled=%d ",
161 event
->manual_reset
, event
->signaled
);
162 dump_object_name( &event
->obj
);
163 fputc( '\n', stderr
);
166 static struct object_type
*event_get_type( struct object
*obj
)
168 static const WCHAR name
[] = {'E','v','e','n','t'};
169 static const struct unicode_str str
= { name
, sizeof(name
) };
170 return get_object_type( &str
);
173 static int event_signaled( struct object
*obj
, struct thread
*thread
)
175 struct event
*event
= (struct event
*)obj
;
176 assert( obj
->ops
== &event_ops
);
177 return event
->signaled
;
180 static int event_satisfied( struct object
*obj
, struct thread
*thread
)
182 struct event
*event
= (struct event
*)obj
;
183 assert( obj
->ops
== &event_ops
);
184 /* Reset if it's an auto-reset event */
185 if (!event
->manual_reset
) event
->signaled
= 0;
186 return 0; /* Not abandoned */
189 static unsigned int event_map_access( struct object
*obj
, unsigned int access
)
191 if (access
& GENERIC_READ
) access
|= STANDARD_RIGHTS_READ
| SYNCHRONIZE
| EVENT_QUERY_STATE
;
192 if (access
& GENERIC_WRITE
) access
|= STANDARD_RIGHTS_WRITE
;
193 if (access
& GENERIC_EXECUTE
) access
|= STANDARD_RIGHTS_EXECUTE
;
194 if (access
& GENERIC_ALL
) access
|= STANDARD_RIGHTS_ALL
| EVENT_ALL_ACCESS
;
195 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
198 static int event_signal( struct object
*obj
, unsigned int access
)
200 struct event
*event
= (struct event
*)obj
;
201 assert( obj
->ops
== &event_ops
);
203 if (!(access
& EVENT_MODIFY_STATE
))
205 set_error( STATUS_ACCESS_DENIED
);
212 struct keyed_event
*create_keyed_event( struct directory
*root
, const struct unicode_str
*name
,
213 unsigned int attr
, const struct security_descriptor
*sd
)
215 struct keyed_event
*event
;
217 if ((event
= create_named_object_dir( root
, name
, attr
, &keyed_event_ops
)))
219 if (get_error() != STATUS_OBJECT_NAME_EXISTS
)
221 /* initialize it if it didn't already exist */
222 if (sd
) default_set_sd( &event
->obj
, sd
, OWNER_SECURITY_INFORMATION
|
223 GROUP_SECURITY_INFORMATION
|
224 DACL_SECURITY_INFORMATION
|
225 SACL_SECURITY_INFORMATION
);
231 static void keyed_event_dump( struct object
*obj
, int verbose
)
233 struct keyed_event
*event
= (struct keyed_event
*)obj
;
234 assert( obj
->ops
== &keyed_event_ops
);
235 fprintf( stderr
, "Keyed event " );
236 dump_object_name( &event
->obj
);
237 fputc( '\n', stderr
);
240 static struct object_type
*keyed_event_get_type( struct object
*obj
)
242 static const WCHAR name
[] = {'K','e','y','e','d','E','v','e','n','t'};
243 static const struct unicode_str str
= { name
, sizeof(name
) };
244 return get_object_type( &str
);
247 static int keyed_event_signaled( struct object
*obj
, struct thread
*thread
)
249 assert( obj
->ops
== &keyed_event_ops
);
253 static unsigned int keyed_event_map_access( struct object
*obj
, unsigned int access
)
255 if (access
& GENERIC_READ
) access
|= STANDARD_RIGHTS_READ
| KEYEDEVENT_WAIT
;
256 if (access
& GENERIC_WRITE
) access
|= STANDARD_RIGHTS_WRITE
| KEYEDEVENT_WAKE
;
257 if (access
& GENERIC_EXECUTE
) access
|= STANDARD_RIGHTS_EXECUTE
;
258 if (access
& GENERIC_ALL
) access
|= KEYEDEVENT_ALL_ACCESS
;
259 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
262 /* create an event */
263 DECL_HANDLER(create_event
)
266 struct unicode_str name
;
267 struct directory
*root
= NULL
;
268 const struct object_attributes
*objattr
= get_req_data();
269 const struct security_descriptor
*sd
;
273 if (!objattr_is_valid( objattr
, get_req_data_size() ))
276 sd
= objattr
->sd_len
? (const struct security_descriptor
*)(objattr
+ 1) : NULL
;
277 objattr_get_name( objattr
, &name
);
279 if (objattr
->rootdir
&& !(root
= get_directory_obj( current
->process
, objattr
->rootdir
, 0 )))
282 if ((event
= create_event( root
, &name
, req
->attributes
, req
->manual_reset
, req
->initial_state
, sd
)))
284 if (get_error() == STATUS_OBJECT_NAME_EXISTS
)
285 reply
->handle
= alloc_handle( current
->process
, event
, req
->access
, req
->attributes
);
287 reply
->handle
= alloc_handle_no_access_check( current
->process
, event
, req
->access
, req
->attributes
);
288 release_object( event
);
291 if (root
) release_object( root
);
294 /* open a handle to an event */
295 DECL_HANDLER(open_event
)
297 struct unicode_str name
;
298 struct directory
*root
= NULL
;
301 get_req_unicode_str( &name
);
302 if (req
->rootdir
&& !(root
= get_directory_obj( current
->process
, req
->rootdir
, 0 )))
305 if ((event
= open_object_dir( root
, &name
, req
->attributes
, &event_ops
)))
307 reply
->handle
= alloc_handle( current
->process
, &event
->obj
, req
->access
, req
->attributes
);
308 release_object( event
);
311 if (root
) release_object( root
);
314 /* do an event operation */
315 DECL_HANDLER(event_op
)
319 if (!(event
= get_event_obj( current
->process
, req
->handle
, EVENT_MODIFY_STATE
))) return;
323 pulse_event( event
);
329 reset_event( event
);
332 set_error( STATUS_INVALID_PARAMETER
);
335 release_object( event
);
338 /* return details about the event */
339 DECL_HANDLER(query_event
)
343 if (!(event
= get_event_obj( current
->process
, req
->handle
, EVENT_QUERY_STATE
))) return;
345 reply
->manual_reset
= event
->manual_reset
;
346 reply
->state
= event
->signaled
;
348 release_object( event
);
351 /* create a keyed event */
352 DECL_HANDLER(create_keyed_event
)
354 struct keyed_event
*event
;
355 struct unicode_str name
;
356 struct directory
*root
= NULL
;
357 const struct object_attributes
*objattr
= get_req_data();
358 const struct security_descriptor
*sd
;
360 if (!objattr_is_valid( objattr
, get_req_data_size() )) return;
362 sd
= objattr
->sd_len
? (const struct security_descriptor
*)(objattr
+ 1) : NULL
;
363 objattr_get_name( objattr
, &name
);
365 if (objattr
->rootdir
&& !(root
= get_directory_obj( current
->process
, objattr
->rootdir
, 0 ))) return;
367 if ((event
= create_keyed_event( root
, &name
, req
->attributes
, sd
)))
369 if (get_error() == STATUS_OBJECT_NAME_EXISTS
)
370 reply
->handle
= alloc_handle( current
->process
, event
, req
->access
, req
->attributes
);
372 reply
->handle
= alloc_handle_no_access_check( current
->process
, event
, req
->access
, req
->attributes
);
373 release_object( event
);
375 if (root
) release_object( root
);
378 /* open a handle to a keyed event */
379 DECL_HANDLER(open_keyed_event
)
381 struct unicode_str name
;
382 struct directory
*root
= NULL
;
383 struct keyed_event
*event
;
385 get_req_unicode_str( &name
);
386 if (req
->rootdir
&& !(root
= get_directory_obj( current
->process
, req
->rootdir
, 0 ))) return;
388 if ((event
= open_object_dir( root
, &name
, req
->attributes
, &keyed_event_ops
)))
390 reply
->handle
= alloc_handle( current
->process
, &event
->obj
, req
->access
, req
->attributes
);
391 release_object( event
);
393 if (root
) release_object( root
);