winscard: Update win32.api to fix the winapi_check warnings.
[wine] / server / device.c
1 /*
2  * Server-side device support
3  *
4  * Copyright (C) 2007 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 <assert.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stdarg.h>
25
26 #include "ntstatus.h"
27 #define WIN32_NO_STATUS
28 #include "windef.h"
29 #include "winternl.h"
30
31 #include "object.h"
32 #include "file.h"
33 #include "handle.h"
34 #include "request.h"
35
36 struct ioctl_call
37 {
38     struct object          obj;           /* object header */
39     struct list            dev_entry;     /* entry in device queue */
40     struct list            mgr_entry;     /* entry in manager queue */
41     struct device         *device;        /* device containing this ioctl */
42     struct thread         *thread;        /* thread that queued the ioctl */
43     void                  *user_arg;      /* user arg used to identify the request */
44     struct async          *async;         /* pending async op */
45     ioctl_code_t           code;          /* ioctl code */
46     unsigned int           status;        /* resulting status (or STATUS_PENDING) */
47     data_size_t            in_size;       /* size of input data */
48     void                  *in_data;       /* input data */
49     data_size_t            out_size;      /* size of output data */
50     void                  *out_data;      /* output data */
51 };
52
53 static void ioctl_call_dump( struct object *obj, int verbose );
54 static int ioctl_call_signaled( struct object *obj, struct thread *thread );
55 static void ioctl_call_destroy( struct object *obj );
56
57 static const struct object_ops ioctl_call_ops =
58 {
59     sizeof(struct ioctl_call),        /* size */
60     ioctl_call_dump,                  /* dump */
61     add_queue,                        /* add_queue */
62     remove_queue,                     /* remove_queue */
63     ioctl_call_signaled,              /* signaled */
64     no_satisfied,                     /* satisfied */
65     no_signal,                        /* signal */
66     no_get_fd,                        /* get_fd */
67     no_map_access,                    /* map_access */
68     no_lookup_name,                   /* lookup_name */
69     no_open_file,                     /* open_file */
70     no_close_handle,                  /* close_handle */
71     ioctl_call_destroy                /* destroy */
72 };
73
74
75 struct device_manager
76 {
77     struct object          obj;           /* object header */
78     struct list            devices;       /* list of devices */
79     struct list            requests;      /* list of pending ioctls across all devices */
80 };
81
82 static void device_manager_dump( struct object *obj, int verbose );
83 static int device_manager_signaled( struct object *obj, struct thread *thread );
84 static void device_manager_destroy( struct object *obj );
85
86 static const struct object_ops device_manager_ops =
87 {
88     sizeof(struct device_manager),    /* size */
89     device_manager_dump,              /* dump */
90     add_queue,                        /* add_queue */
91     remove_queue,                     /* remove_queue */
92     device_manager_signaled,          /* signaled */
93     no_satisfied,                     /* satisfied */
94     no_signal,                        /* signal */
95     no_get_fd,                        /* get_fd */
96     no_map_access,                    /* map_access */
97     no_lookup_name,                   /* lookup_name */
98     no_open_file,                     /* open_file */
99     no_close_handle,                  /* close_handle */
100     device_manager_destroy            /* destroy */
101 };
102
103
104 struct device
105 {
106     struct object          obj;           /* object header */
107     struct device_manager *manager;       /* manager for this device (or NULL if deleted) */
108     struct fd             *fd;            /* file descriptor for ioctl */
109     void                  *user_ptr;      /* opaque ptr for client side */
110     struct list            entry;         /* entry in device manager list */
111     struct list            requests;      /* list of pending ioctl requests */
112 };
113
114 static void device_dump( struct object *obj, int verbose );
115 static struct fd *device_get_fd( struct object *obj );
116 static void device_destroy( struct object *obj );
117 static struct object *device_open_file( struct object *obj, unsigned int access,
118                                         unsigned int sharing, unsigned int options );
119 static enum server_fd_type device_get_fd_type( struct fd *fd );
120 static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
121                                   const void *data, data_size_t size );
122
123 static const struct object_ops device_ops =
124 {
125     sizeof(struct device),            /* size */
126     device_dump,                      /* dump */
127     no_add_queue,                     /* add_queue */
128     NULL,                             /* remove_queue */
129     NULL,                             /* signaled */
130     no_satisfied,                     /* satisfied */
131     no_signal,                        /* signal */
132     device_get_fd,                    /* get_fd */
133     no_map_access,                    /* map_access */
134     no_lookup_name,                   /* lookup_name */
135     device_open_file,                 /* open_file */
136     no_close_handle,                  /* close_handle */
137     device_destroy                    /* destroy */
138 };
139
140 static const struct fd_ops device_fd_ops =
141 {
142     default_fd_get_poll_events,       /* get_poll_events */
143     default_poll_event,               /* poll_event */
144     no_flush,                         /* flush */
145     device_get_fd_type,               /* get_fd_type */
146     device_ioctl,                     /* ioctl */
147     default_fd_queue_async,           /* queue_async */
148     default_fd_reselect_async,        /* reselect_async */
149     default_fd_cancel_async           /* cancel_async */
150 };
151
152
153 static void ioctl_call_dump( struct object *obj, int verbose )
154 {
155     struct ioctl_call *ioctl = (struct ioctl_call *)obj;
156     fprintf( stderr, "Ioctl call code=%08x device=%p\n", ioctl->code, ioctl->device );
157 }
158
159 static int ioctl_call_signaled( struct object *obj, struct thread *thread )
160 {
161     struct ioctl_call *ioctl = (struct ioctl_call *)obj;
162
163     return !ioctl->device;  /* device is cleared once the ioctl has completed */
164 }
165
166 static void ioctl_call_destroy( struct object *obj )
167 {
168     struct ioctl_call *ioctl = (struct ioctl_call *)obj;
169
170     free( ioctl->in_data );
171     free( ioctl->out_data );
172     if (ioctl->async)
173     {
174         async_terminate( ioctl->async, STATUS_CANCELLED );
175         release_object( ioctl->async );
176     }
177     if (ioctl->device) release_object( ioctl->device );
178     release_object( ioctl->thread );
179 }
180
181 static struct ioctl_call *create_ioctl( struct device *device, ioctl_code_t code,
182                                         const void *in_data, data_size_t in_size,
183                                         data_size_t out_size )
184 {
185     struct ioctl_call *ioctl;
186
187     if ((ioctl = alloc_object( &ioctl_call_ops )))
188     {
189         ioctl->device   = (struct device *)grab_object( device );
190         ioctl->code     = code;
191         ioctl->async    = NULL;
192         ioctl->status   = STATUS_PENDING;
193         ioctl->in_size  = in_size;
194         ioctl->in_data  = NULL;
195         ioctl->out_size = out_size;
196         ioctl->out_data = NULL;
197
198         if (ioctl->in_size && !(ioctl->in_data = memdup( in_data, in_size )))
199         {
200             release_object( ioctl );
201             ioctl = NULL;
202         }
203     }
204     return ioctl;
205 }
206
207 static void set_ioctl_result( struct ioctl_call *ioctl, unsigned int status,
208                               const void *out_data, data_size_t out_size )
209 {
210     struct device *device = ioctl->device;
211
212     if (!device) return;  /* already finished */
213
214     /* FIXME: handle the STATUS_PENDING case */
215     ioctl->status = status;
216     ioctl->out_size = min( ioctl->out_size, out_size );
217     if (ioctl->out_size && !(ioctl->out_data = memdup( out_data, ioctl->out_size )))
218         ioctl->out_size = 0;
219     release_object( device );
220     ioctl->device = NULL;
221     if (ioctl->async)
222     {
223         async_terminate( ioctl->async, ioctl->out_size ? STATUS_ALERTED : status );
224         release_object( ioctl->async );
225         ioctl->async = NULL;
226     }
227     wake_up( &ioctl->obj, 0 );
228 }
229
230
231 static void device_dump( struct object *obj, int verbose )
232 {
233     struct device *device = (struct device *)obj;
234
235     fprintf( stderr, "Device " );
236     dump_object_name( &device->obj );
237     fputc( '\n', stderr );
238 }
239
240 static struct fd *device_get_fd( struct object *obj )
241 {
242     struct device *device = (struct device *)obj;
243
244     return (struct fd *)grab_object( device->fd );
245 }
246
247 static void device_destroy( struct object *obj )
248 {
249     struct device *device = (struct device *)obj;
250     struct ioctl_call *ioctl, *next;
251
252     LIST_FOR_EACH_ENTRY_SAFE( ioctl, next, &device->requests, struct ioctl_call, dev_entry )
253     {
254         list_remove( &ioctl->dev_entry );
255         release_object( ioctl );  /* no longer on the device queue */
256     }
257     if (device->fd) release_object( device->fd );
258     if (device->manager) list_remove( &device->entry );
259 }
260
261 static struct object *device_open_file( struct object *obj, unsigned int access,
262                                         unsigned int sharing, unsigned int options )
263 {
264     return grab_object( obj );
265 }
266
267 static enum server_fd_type device_get_fd_type( struct fd *fd )
268 {
269     return FD_TYPE_DEVICE;
270 }
271
272 static struct ioctl_call *find_ioctl_call( struct device *device, struct thread *thread,
273                                            void *user_arg )
274 {
275     struct ioctl_call *ioctl;
276
277     LIST_FOR_EACH_ENTRY( ioctl, &device->requests, struct ioctl_call, dev_entry )
278         if (ioctl->thread == thread && ioctl->user_arg == user_arg) return ioctl;
279
280     set_error( STATUS_INVALID_PARAMETER );
281     return NULL;
282 }
283
284 static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
285                                   const void *data, data_size_t size )
286 {
287     struct device *device = get_fd_user( fd );
288     struct ioctl_call *ioctl;
289     obj_handle_t handle;
290
291     if (!device->manager)  /* it has been deleted */
292     {
293         set_error( STATUS_FILE_DELETED );
294         return 0;
295     }
296
297     if (!(ioctl = create_ioctl( device, code, data, size, get_reply_max_size() )))
298         return 0;
299
300     ioctl->thread   = (struct thread *)grab_object( current );
301     ioctl->user_arg = async_data->arg;
302
303     if (!(handle = alloc_handle( current->process, ioctl, SYNCHRONIZE, 0 )))
304     {
305         release_object( ioctl );
306         return 0;
307     }
308
309     if (!(ioctl->async = fd_queue_async( device->fd, async_data, ASYNC_TYPE_WAIT, 0 )))
310     {
311         close_handle( current->process, handle );
312         release_object( ioctl );
313         return 0;
314     }
315     list_add_tail( &device->requests, &ioctl->dev_entry );
316     list_add_tail( &device->manager->requests, &ioctl->mgr_entry );
317     if (list_head( &device->manager->requests ) == &ioctl->mgr_entry)  /* first one */
318         wake_up( &device->manager->obj, 0 );
319     /* don't release ioctl since it is now queued in the device */
320     set_error( STATUS_PENDING );
321     return handle;
322 }
323
324 static struct device *create_device( struct directory *root, const struct unicode_str *name,
325                                      struct device_manager *manager, unsigned int attr )
326 {
327     struct device *device;
328
329     if ((device = create_named_object_dir( root, name, attr, &device_ops )))
330     {
331         if (get_error() != STATUS_OBJECT_NAME_EXISTS)
332         {
333             /* initialize it if it didn't already exist */
334             device->manager = manager;
335             list_add_tail( &manager->devices, &device->entry );
336             list_init( &device->requests );
337             if (!(device->fd = alloc_pseudo_fd( &device_fd_ops, &device->obj, 0 )))
338             {
339                 release_object( device );
340                 device = NULL;
341             }
342         }
343     }
344     return device;
345 }
346
347 static void delete_device( struct device *device )
348 {
349     struct ioctl_call *ioctl;
350
351     if (!device->manager) return;  /* already deleted */
352
353     /* terminate all pending requests */
354     LIST_FOR_EACH_ENTRY( ioctl, &device->requests, struct ioctl_call, dev_entry )
355     {
356         list_remove( &ioctl->mgr_entry );
357         set_ioctl_result( ioctl, STATUS_FILE_DELETED, NULL, 0 );
358     }
359     unlink_named_object( &device->obj );
360     list_remove( &device->entry );
361     device->manager = NULL;
362 }
363
364
365 static void device_manager_dump( struct object *obj, int verbose )
366 {
367     fprintf( stderr, "Device manager\n" );
368 }
369
370 static int device_manager_signaled( struct object *obj, struct thread *thread )
371 {
372     struct device_manager *manager = (struct device_manager *)obj;
373
374     return !list_empty( &manager->requests );
375 }
376
377 static void device_manager_destroy( struct object *obj )
378 {
379     struct device_manager *manager = (struct device_manager *)obj;
380     struct list *ptr;
381
382     while ((ptr = list_head( &manager->devices )))
383     {
384         struct device *device = LIST_ENTRY( ptr, struct device, entry );
385         delete_device( device );
386     }
387 }
388
389 static struct device_manager *create_device_manager(void)
390 {
391     struct device_manager *manager;
392
393     if ((manager = alloc_object( &device_manager_ops )))
394     {
395         list_init( &manager->devices );
396         list_init( &manager->requests );
397     }
398     return manager;
399 }
400
401
402 /* create a device manager */
403 DECL_HANDLER(create_device_manager)
404 {
405     struct device_manager *manager = create_device_manager();
406
407     if (manager)
408     {
409         reply->handle = alloc_handle( current->process, manager, req->access, req->attributes );
410         release_object( manager );
411     }
412 }
413
414
415 /* create a device */
416 DECL_HANDLER(create_device)
417 {
418     struct device *device;
419     struct unicode_str name;
420     struct device_manager *manager;
421     struct directory *root = NULL;
422
423     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
424                                                              0, &device_manager_ops )))
425         return;
426
427     get_req_unicode_str( &name );
428     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
429     {
430         release_object( manager );
431         return;
432     }
433
434     if ((device = create_device( root, &name, manager, req->attributes )))
435     {
436         device->user_ptr = req->user_ptr;
437         reply->handle = alloc_handle( current->process, device, req->access, req->attributes );
438         release_object( device );
439     }
440
441     if (root) release_object( root );
442     release_object( manager );
443 }
444
445
446 /* delete a device */
447 DECL_HANDLER(delete_device)
448 {
449     struct device *device;
450
451     if ((device = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
452     {
453         delete_device( device );
454         release_object( device );
455     }
456 }
457
458
459 /* retrieve the next pending device ioctl request */
460 DECL_HANDLER(get_next_device_request)
461 {
462     struct ioctl_call *ioctl;
463     struct device_manager *manager;
464     struct list *ptr;
465
466     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
467                                                              0, &device_manager_ops )))
468         return;
469
470     if (req->prev)
471     {
472         if ((ioctl = (struct ioctl_call *)get_handle_obj( current->process, req->prev,
473                                                           0, &ioctl_call_ops )))
474         {
475             set_ioctl_result( ioctl, req->status, get_req_data(), get_req_data_size() );
476             close_handle( current->process, req->prev );  /* avoid an extra round-trip for close */
477             release_object( ioctl );
478         }
479         clear_error();
480     }
481
482     if ((ptr = list_head( &manager->requests )))
483     {
484         ioctl = LIST_ENTRY( ptr, struct ioctl_call, mgr_entry );
485         reply->code = ioctl->code;
486         reply->user_ptr = ioctl->device->user_ptr;
487         reply->in_size = ioctl->in_size;
488         reply->out_size = ioctl->out_size;
489         if (ioctl->in_size > get_reply_max_size()) set_error( STATUS_BUFFER_OVERFLOW );
490         else if ((reply->next = alloc_handle( current->process, ioctl, 0, 0 )))
491         {
492             set_reply_data_ptr( ioctl->in_data, ioctl->in_size );
493             ioctl->in_data = NULL;
494             ioctl->in_size = 0;
495             list_remove( &ioctl->mgr_entry );
496             list_init( &ioctl->mgr_entry );
497         }
498     }
499     else set_error( STATUS_PENDING );
500
501     release_object( manager );
502 }
503
504
505 /* retrieve results of an async ioctl */
506 DECL_HANDLER(get_ioctl_result)
507 {
508     struct device *device;
509     struct ioctl_call *ioctl;
510
511     if (!(device = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
512         return;
513
514     if ((ioctl = find_ioctl_call( device, current, req->user_arg )))
515     {
516         if (ioctl->out_data)
517         {
518             data_size_t size = min( ioctl->out_size, get_reply_max_size() );
519             if (size)
520             {
521                 set_reply_data_ptr( ioctl->out_data, size );
522                 ioctl->out_data = NULL;
523             }
524         }
525         set_error( ioctl->status );
526         list_remove( &ioctl->dev_entry );
527         release_object( ioctl );  /* no longer on the device queue */
528     }
529     release_object( device );
530 }