server/event.c

   1 /*
   2  * Server-side event management
   3  *
   4  * Copyright (C) 1998 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 <stdarg.h>
  28
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #include "windef.h"
  32 #include "winternl.h"
  33
  34 #include "handle.h"
  35 #include "thread.h"
  36 #include "request.h"
  37 #include "security.h"
  38
  39 struct event
  40 {
  41     struct object  obj;             /* object header */
  42     int            manual_reset;    /* is it a manual reset event? */
  43     int            signaled;        /* event has been signaled */
  44 };
  45
  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 wait_queue_entry *entry );
  49 static void event_satisfied( struct object *obj, struct wait_queue_entry *entry );
  50 static unsigned int event_map_access( struct object *obj, unsigned int access );
  51 static int event_signal( struct object *obj, unsigned int access);
  52
  53 static const struct object_ops event_ops =
  54 {
  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     directory_link_name,       /* link_name */
  69     default_unlink_name,       /* unlink_name */
  70     no_open_file,              /* open_file */
  71     no_close_handle,           /* close_handle */
  72     no_destroy                 /* destroy */
  73 };
  74
  75
  76 struct keyed_event
  77 {
  78     struct object  obj;             /* object header */
  79 };
  80
  81 static void keyed_event_dump( struct object *obj, int verbose );
  82 static struct object_type *keyed_event_get_type( struct object *obj );
  83 static int keyed_event_signaled( struct object *obj, struct wait_queue_entry *entry );
  84 static unsigned int keyed_event_map_access( struct object *obj, unsigned int access );
  85
  86 static const struct object_ops keyed_event_ops =
  87 {
  88     sizeof(struct keyed_event),  /* size */
  89     keyed_event_dump,            /* dump */
  90     keyed_event_get_type,        /* get_type */
  91     add_queue,                   /* add_queue */
  92     remove_queue,                /* remove_queue */
  93     keyed_event_signaled,        /* signaled */
  94     no_satisfied,                /* satisfied */
  95     no_signal,                   /* signal */
  96     no_get_fd,                   /* get_fd */
  97     keyed_event_map_access,      /* map_access */
  98     default_get_sd,              /* get_sd */
  99     default_set_sd,              /* set_sd */
 100     no_lookup_name,              /* lookup_name */
 101     directory_link_name,         /* link_name */
 102     default_unlink_name,         /* unlink_name */
 103     no_open_file,                /* open_file */
 104     no_close_handle,             /* close_handle */
 105     no_destroy                   /* destroy */
 106 };
 107
 108
 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 )
 112 {
 113     struct event *event;
 114
 115     if ((event = create_named_object_dir( root, name, attr, &event_ops )))
 116     {
 117         if (get_error() != STATUS_OBJECT_NAME_EXISTS)
 118         {
 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 );
 126         }
 127     }
 128     return event;
 129 }
 130
 131 struct event *get_event_obj( struct process *process, obj_handle_t handle, unsigned int access )
 132 {
 133     return (struct event *)get_handle_obj( process, handle, access, &event_ops );
 134 }
 135
 136 void pulse_event( struct event *event )
 137 {
 138     event->signaled = 1;
 139     /* wake up all waiters if manual reset, a single one otherwise */
 140     wake_up( &event->obj, !event->manual_reset );
 141     event->signaled = 0;
 142 }
 143
 144 void set_event( struct event *event )
 145 {
 146     event->signaled = 1;
 147     /* wake up all waiters if manual reset, a single one otherwise */
 148     wake_up( &event->obj, !event->manual_reset );
 149 }
 150
 151 void reset_event( struct event *event )
 152 {
 153     event->signaled = 0;
 154 }
 155
 156 static void event_dump( struct object *obj, int verbose )
 157 {
 158     struct event *event = (struct event *)obj;
 159     assert( obj->ops == &event_ops );
 160     fprintf( stderr, "Event manual=%d signaled=%d\n",
 161              event->manual_reset, event->signaled );
 162 }
 163
 164 static struct object_type *event_get_type( struct object *obj )
 165 {
 166     static const WCHAR name[] = {'E','v','e','n','t'};
 167     static const struct unicode_str str = { name, sizeof(name) };
 168     return get_object_type( &str );
 169 }
 170
 171 static int event_signaled( struct object *obj, struct wait_queue_entry *entry )
 172 {
 173     struct event *event = (struct event *)obj;
 174     assert( obj->ops == &event_ops );
 175     return event->signaled;
 176 }
 177
 178 static void event_satisfied( struct object *obj, struct wait_queue_entry *entry )
 179 {
 180     struct event *event = (struct event *)obj;
 181     assert( obj->ops == &event_ops );
 182     /* Reset if it's an auto-reset event */
 183     if (!event->manual_reset) event->signaled = 0;
 184 }
 185
 186 static unsigned int event_map_access( struct object *obj, unsigned int access )
 187 {
 188     if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ | EVENT_QUERY_STATE;
 189     if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE | EVENT_MODIFY_STATE;
 190     if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE;
 191     if (access & GENERIC_ALL)     access |= STANDARD_RIGHTS_ALL | EVENT_QUERY_STATE | EVENT_MODIFY_STATE;
 192     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
 193 }
 194
 195 static int event_signal( struct object *obj, unsigned int access )
 196 {
 197     struct event *event = (struct event *)obj;
 198     assert( obj->ops == &event_ops );
 199
 200     if (!(access & EVENT_MODIFY_STATE))
 201     {
 202         set_error( STATUS_ACCESS_DENIED );
 203         return 0;
 204     }
 205     set_event( event );
 206     return 1;
 207 }
 208
 209 struct keyed_event *create_keyed_event( struct directory *root, const struct unicode_str *name,
 210                                         unsigned int attr, const struct security_descriptor *sd )
 211 {
 212     struct keyed_event *event;
 213
 214     if ((event = create_named_object_dir( root, name, attr, &keyed_event_ops )))
 215     {
 216         if (get_error() != STATUS_OBJECT_NAME_EXISTS)
 217         {
 218             /* initialize it if it didn't already exist */
 219             if (sd) default_set_sd( &event->obj, sd, OWNER_SECURITY_INFORMATION|
 220                                                      GROUP_SECURITY_INFORMATION|
 221                                                      DACL_SECURITY_INFORMATION|
 222                                                      SACL_SECURITY_INFORMATION );
 223         }
 224     }
 225     return event;
 226 }
 227
 228 struct keyed_event *get_keyed_event_obj( struct process *process, obj_handle_t handle, unsigned int access )
 229 {
 230     return (struct keyed_event *)get_handle_obj( process, handle, access, &keyed_event_ops );
 231 }
 232
 233 static void keyed_event_dump( struct object *obj, int verbose )
 234 {
 235     fputs( "Keyed event\n", stderr );
 236 }
 237
 238 static struct object_type *keyed_event_get_type( struct object *obj )
 239 {
 240     static const WCHAR name[] = {'K','e','y','e','d','E','v','e','n','t'};
 241     static const struct unicode_str str = { name, sizeof(name) };
 242     return get_object_type( &str );
 243 }
 244
 245 static enum select_op matching_op( enum select_op op )
 246 {
 247     return op ^ (SELECT_KEYED_EVENT_WAIT ^ SELECT_KEYED_EVENT_RELEASE);
 248 }
 249
 250 static int keyed_event_signaled( struct object *obj, struct wait_queue_entry *entry )
 251 {
 252     struct wait_queue_entry *ptr;
 253     struct process *process;
 254     enum select_op select_op;
 255
 256     assert( obj->ops == &keyed_event_ops );
 257
 258     process = get_wait_queue_thread( entry )->process;
 259     select_op = get_wait_queue_select_op( entry );
 260     if (select_op != SELECT_KEYED_EVENT_WAIT && select_op != SELECT_KEYED_EVENT_RELEASE) return 1;
 261
 262     LIST_FOR_EACH_ENTRY( ptr, &obj->wait_queue, struct wait_queue_entry, entry )
 263     {
 264         if (ptr == entry) continue;
 265         if (get_wait_queue_thread( ptr )->process != process) continue;
 266         if (get_wait_queue_select_op( ptr ) != matching_op( select_op )) continue;
 267         if (get_wait_queue_key( ptr ) != get_wait_queue_key( entry )) continue;
 268         if (wake_thread_queue_entry( ptr )) return 1;
 269     }
 270     return 0;
 271 }
 272
 273 static unsigned int keyed_event_map_access( struct object *obj, unsigned int access )
 274 {
 275     if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ | KEYEDEVENT_WAIT;
 276     if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE | KEYEDEVENT_WAKE;
 277     if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
 278     if (access & GENERIC_ALL)     access |= KEYEDEVENT_ALL_ACCESS;
 279     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
 280 }
 281
 282 /* create an event */
 283 DECL_HANDLER(create_event)
 284 {
 285     struct event *event;
 286     struct unicode_str name;
 287     struct directory *root;
 288     const struct security_descriptor *sd;
 289     const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, &root );
 290
 291     if (!objattr) return;
 292
 293     if ((event = create_event( root, &name, objattr->attributes,
 294                                req->manual_reset, req->initial_state, sd )))
 295     {
 296         if (get_error() == STATUS_OBJECT_NAME_EXISTS)
 297             reply->handle = alloc_handle( current->process, event, req->access, objattr->attributes );
 298         else
 299             reply->handle = alloc_handle_no_access_check( current->process, event,
 300                                                           req->access, objattr->attributes );
 301         release_object( event );
 302     }
 303
 304     if (root) release_object( root );
 305 }
 306
 307 /* open a handle to an event */
 308 DECL_HANDLER(open_event)
 309 {
 310     struct unicode_str name = get_req_unicode_str();
 311
 312     reply->handle = open_object( current->process, req->rootdir, req->access,
 313                                  &event_ops, &name, req->attributes );
 314 }
 315
 316 /* do an event operation */
 317 DECL_HANDLER(event_op)
 318 {
 319     struct event *event;
 320
 321     if (!(event = get_event_obj( current->process, req->handle, EVENT_MODIFY_STATE ))) return;
 322     switch(req->op)
 323     {
 324     case PULSE_EVENT:
 325         pulse_event( event );
 326         break;
 327     case SET_EVENT:
 328         set_event( event );
 329         break;
 330     case RESET_EVENT:
 331         reset_event( event );
 332         break;
 333     default:
 334         set_error( STATUS_INVALID_PARAMETER );
 335         break;
 336     }
 337     release_object( event );
 338 }
 339
 340 /* return details about the event */
 341 DECL_HANDLER(query_event)
 342 {
 343     struct event *event;
 344
 345     if (!(event = get_event_obj( current->process, req->handle, EVENT_QUERY_STATE ))) return;
 346
 347     reply->manual_reset = event->manual_reset;
 348     reply->state = event->signaled;
 349
 350     release_object( event );
 351 }
 352
 353 /* create a keyed event */
 354 DECL_HANDLER(create_keyed_event)
 355 {
 356     struct keyed_event *event;
 357     struct unicode_str name;
 358     struct directory *root;
 359     const struct security_descriptor *sd;
 360     const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, &root );
 361
 362     if (!objattr) return;
 363
 364     if ((event = create_keyed_event( root, &name, objattr->attributes, sd )))
 365     {
 366         if (get_error() == STATUS_OBJECT_NAME_EXISTS)
 367             reply->handle = alloc_handle( current->process, event, req->access, objattr->attributes );
 368         else
 369             reply->handle = alloc_handle_no_access_check( current->process, event,
 370                                                           req->access, objattr->attributes );
 371         release_object( event );
 372     }
 373     if (root) release_object( root );
 374 }
 375
 376 /* open a handle to a keyed event */
 377 DECL_HANDLER(open_keyed_event)
 378 {
 379     struct unicode_str name = get_req_unicode_str();
 380
 381     reply->handle = open_object( current->process, req->rootdir, req->access,
 382                                  &keyed_event_ops, &name, req->attributes );
 383 }