2 * Server-side directory object management
4 * Copyright (C) 2005 Vitaliy Margolen
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
23 #include "wine/port.h"
29 #include <sys/types.h>
32 #define WIN32_NO_STATUS
42 #define HASH_SIZE 7 /* default hash size */
46 struct object obj
; /* object header */
49 static void object_type_dump( struct object
*obj
, int verbose
);
50 static struct object_type
*object_type_get_type( struct object
*obj
);
52 static const struct object_ops object_type_ops
=
54 sizeof(struct object_type
), /* size */
55 object_type_dump
, /* dump */
56 object_type_get_type
, /* get_type */
57 no_add_queue
, /* add_queue */
58 NULL
, /* remove_queue */
61 no_signal
, /* signal */
62 no_get_fd
, /* get_fd */
63 no_map_access
, /* map_access */
64 default_get_sd
, /* get_sd */
65 default_set_sd
, /* set_sd */
66 no_lookup_name
, /* lookup_name */
67 no_open_file
, /* open_file */
68 no_close_handle
, /* close_handle */
69 no_destroy
/* destroy */
75 struct object obj
; /* object header */
76 struct namespace *entries
; /* directory's name space */
79 static void directory_dump( struct object
*obj
, int verbose
);
80 static struct object_type
*directory_get_type( struct object
*obj
);
81 static struct object
*directory_lookup_name( struct object
*obj
, struct unicode_str
*name
,
83 static void directory_destroy( struct object
*obj
);
85 static const struct object_ops directory_ops
=
87 sizeof(struct directory
), /* size */
88 directory_dump
, /* dump */
89 directory_get_type
, /* get_type */
90 no_add_queue
, /* add_queue */
91 NULL
, /* remove_queue */
94 no_signal
, /* signal */
95 no_get_fd
, /* get_fd */
96 default_fd_map_access
, /* map_access */
97 default_get_sd
, /* get_sd */
98 default_set_sd
, /* set_sd */
99 directory_lookup_name
, /* lookup_name */
100 no_open_file
, /* open_file */
101 no_close_handle
, /* close_handle */
102 directory_destroy
/* destroy */
105 static struct directory
*root_directory
;
106 static struct directory
*dir_objtype
;
109 static void object_type_dump( struct object
*obj
, int verbose
)
111 assert( obj
->ops
== &object_type_ops
);
113 fputs( "Object type ", stderr
);
114 dump_object_name( obj
);
115 fputc( '\n', stderr
);
118 static struct object_type
*object_type_get_type( struct object
*obj
)
120 static const WCHAR name
[] = {'O','b','j','e','c','t','T','y','p','e'};
121 static const struct unicode_str str
= { name
, sizeof(name
) };
122 return get_object_type( &str
);
125 static void directory_dump( struct object
*obj
, int verbose
)
127 assert( obj
->ops
== &directory_ops
);
129 fputs( "Directory ", stderr
);
130 dump_object_name( obj
);
131 fputc( '\n', stderr
);
134 static struct object_type
*directory_get_type( struct object
*obj
)
136 static const WCHAR name
[] = {'D','i','r','e','c','t','o','r','y'};
137 static const struct unicode_str str
= { name
, sizeof(name
) };
138 return get_object_type( &str
);
141 static struct object
*directory_lookup_name( struct object
*obj
, struct unicode_str
*name
,
144 struct directory
*dir
= (struct directory
*)obj
;
145 struct object
*found
;
146 struct unicode_str tmp
;
149 assert( obj
->ops
== &directory_ops
);
151 if (!(p
= memchrW( name
->str
, '\\', name
->len
/ sizeof(WCHAR
) )))
152 /* Last element in the path name */
155 tmp
.len
= (p
- name
->str
) * sizeof(WCHAR
);
158 if ((found
= find_object( dir
->entries
, &tmp
, attr
)))
160 /* Skip trailing \\ */
164 tmp
.len
+= sizeof(WCHAR
);
166 /* Move to the next element*/
168 name
->len
-= tmp
.len
;
174 if (tmp
.len
== 0) /* Double backslash */
175 set_error( STATUS_OBJECT_NAME_INVALID
);
176 else if (p
) /* Path still has backslashes */
177 set_error( STATUS_OBJECT_PATH_NOT_FOUND
);
184 static void directory_destroy( struct object
*obj
)
186 struct directory
*dir
= (struct directory
*)obj
;
187 assert( obj
->ops
== &directory_ops
);
188 free( dir
->entries
);
191 static struct directory
*create_directory( struct directory
*root
, const struct unicode_str
*name
,
192 unsigned int attr
, unsigned int hash_size
,
193 const struct security_descriptor
*sd
)
195 struct directory
*dir
;
197 if ((dir
= create_named_object_dir( root
, name
, attr
, &directory_ops
)) &&
198 get_error() != STATUS_OBJECT_NAME_EXISTS
)
200 if (!(dir
->entries
= create_namespace( hash_size
)))
202 release_object( dir
);
205 if (sd
) default_set_sd( &dir
->obj
, sd
, OWNER_SECURITY_INFORMATION
| GROUP_SECURITY_INFORMATION
|
206 DACL_SECURITY_INFORMATION
| SACL_SECURITY_INFORMATION
);
211 struct directory
*get_directory_obj( struct process
*process
, obj_handle_t handle
, unsigned int access
)
213 return (struct directory
*)get_handle_obj( process
, handle
, access
, &directory_ops
);
216 /******************************************************************************
217 * Find an object by its name in a given root object
220 * root [I] directory to start search from or NULL to start from \\
221 * name [I] object name to search for
222 * attr [I] OBJECT_ATTRIBUTES.Attributes
223 * name_left [O] [optional] leftover name if object is not found
226 * NULL: If params are invalid
227 * Found: If object with exact name is found returns that object
228 * (name_left->len == 0). Object's refcount is incremented
229 * Not found: The last matched parent. (name_left->len > 0)
230 * Parent's refcount is incremented.
232 struct object
*find_object_dir( struct directory
*root
, const struct unicode_str
*name
,
233 unsigned int attr
, struct unicode_str
*name_left
)
235 struct object
*obj
, *parent
;
236 struct unicode_str name_tmp
;
238 if (name
) name_tmp
= *name
;
239 else name_tmp
.len
= 0;
242 * - Either rootdir or name have to be specified
243 * - If root is specified path shouldn't start with backslash */
246 if (name_tmp
.len
&& name_tmp
.str
[0] == '\\')
248 set_error( STATUS_OBJECT_PATH_SYNTAX_BAD
);
251 parent
= grab_object( root
);
255 if (!name_tmp
.len
|| name_tmp
.str
[0] != '\\')
257 set_error( STATUS_OBJECT_PATH_SYNTAX_BAD
);
260 parent
= grab_object( &root_directory
->obj
);
261 /* skip leading backslash */
263 name_tmp
.len
-= sizeof(WCHAR
);
266 /* Special case for opening RootDirectory */
267 if (!name_tmp
.len
) goto done
;
269 while ((obj
= parent
->ops
->lookup_name( parent
, &name_tmp
, attr
)))
271 /* move to the next element */
272 release_object ( parent
);
277 release_object( parent
);
282 if (name_left
) *name_left
= name_tmp
;
286 /* create a named (if name is present) or unnamed object. */
287 void *create_named_object_dir( struct directory
*root
, const struct unicode_str
*name
,
288 unsigned int attributes
, const struct object_ops
*ops
)
290 struct object
*obj
, *new_obj
= NULL
;
291 struct unicode_str new_name
;
293 if (!name
|| !name
->len
)
295 if ((new_obj
= alloc_object( ops
))) clear_error();
299 if (!(obj
= find_object_dir( root
, name
, attributes
, &new_name
))) return NULL
;
302 if (attributes
& OBJ_OPENIF
&& obj
->ops
== ops
)
303 set_error( STATUS_OBJECT_NAME_EXISTS
);
306 release_object( obj
);
308 if (attributes
& OBJ_OPENIF
)
309 set_error( STATUS_OBJECT_TYPE_MISMATCH
);
311 set_error( STATUS_OBJECT_NAME_COLLISION
);
316 /* ATM we can't insert objects into anything else but directories */
317 if (obj
->ops
!= &directory_ops
)
318 set_error( STATUS_OBJECT_TYPE_MISMATCH
);
321 struct directory
*dir
= (struct directory
*)obj
;
322 if ((new_obj
= create_object( dir
->entries
, ops
, &new_name
, &dir
->obj
)))
326 release_object( obj
);
330 /* open a new handle to an existing object */
331 void *open_object_dir( struct directory
*root
, const struct unicode_str
*name
,
332 unsigned int attr
, const struct object_ops
*ops
)
334 struct unicode_str name_left
;
337 if ((obj
= find_object_dir( root
, name
, attr
, &name_left
)))
339 if (name_left
.len
) /* not fully parsed */
340 set_error( STATUS_OBJECT_NAME_NOT_FOUND
);
341 else if (ops
&& obj
->ops
!= ops
)
342 set_error( STATUS_OBJECT_TYPE_MISMATCH
);
346 release_object( obj
);
351 /* retrieve an object type, creating it if needed */
352 struct object_type
*get_object_type( const struct unicode_str
*name
)
354 struct object_type
*type
;
356 if ((type
= open_object_dir( dir_objtype
, name
, 0, &object_type_ops
)))
359 if ((type
= create_named_object_dir( dir_objtype
, name
, 0, &object_type_ops
)))
362 make_object_static( &type
->obj
);
368 /* Global initialization */
370 void init_directories(void)
373 static const WCHAR dir_globalW
[] = {'\\','?','?'};
374 static const WCHAR dir_driverW
[] = {'D','r','i','v','e','r'};
375 static const WCHAR dir_deviceW
[] = {'D','e','v','i','c','e'};
376 static const WCHAR dir_nullW
[] = {'\\','D','e','v','i','c','e','\\','N','u','l','l'};
377 static const WCHAR dir_basenamedW
[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s'};
378 static const WCHAR dir_named_pipeW
[] = {'\\','D','e','v','i','c','e','\\','N','a','m','e','d','P','i','p','e'};
379 static const WCHAR dir_mailslotW
[] = {'\\','D','e','v','i','c','e','\\','M','a','i','l','S','l','o','t'};
380 static const WCHAR dir_objtypeW
[] = {'O','b','j','e','c','t','T','y','p','e','s'};
381 static const WCHAR dir_sessionsW
[] = {'S','e','s','s','i','o','n','s'};
382 static const WCHAR dir_kernelW
[] = {'K','e','r','n','e','l','O','b','j','e','c','t','s'};
383 static const WCHAR dir_windowsW
[] = {'W','i','n','d','o','w','s'};
384 static const WCHAR dir_winstationsW
[] = {'W','i','n','d','o','w','S','t','a','t','i','o','n','s'};
385 static const struct unicode_str dir_global_str
= {dir_globalW
, sizeof(dir_globalW
)};
386 static const struct unicode_str dir_driver_str
= {dir_driverW
, sizeof(dir_driverW
)};
387 static const struct unicode_str dir_device_str
= {dir_deviceW
, sizeof(dir_deviceW
)};
388 static const struct unicode_str dir_null_str
= {dir_nullW
, sizeof(dir_nullW
)};
389 static const struct unicode_str dir_basenamed_str
= {dir_basenamedW
, sizeof(dir_basenamedW
)};
390 static const struct unicode_str dir_named_pipe_str
= {dir_named_pipeW
, sizeof(dir_named_pipeW
)};
391 static const struct unicode_str dir_mailslot_str
= {dir_mailslotW
, sizeof(dir_mailslotW
)};
392 static const struct unicode_str dir_objtype_str
= {dir_objtypeW
, sizeof(dir_objtypeW
)};
393 static const struct unicode_str dir_sessions_str
= {dir_sessionsW
, sizeof(dir_sessionsW
)};
394 static const struct unicode_str dir_kernel_str
= {dir_kernelW
, sizeof(dir_kernelW
)};
395 static const struct unicode_str dir_windows_str
= {dir_windowsW
, sizeof(dir_windowsW
)};
396 static const struct unicode_str dir_winstations_str
= {dir_winstationsW
, sizeof(dir_winstationsW
)};
399 static const WCHAR link_dosdevW
[] = {'D','o','s','D','e','v','i','c','e','s'};
400 static const WCHAR link_globalW
[] = {'G','l','o','b','a','l'};
401 static const WCHAR link_localW
[] = {'L','o','c','a','l'};
402 static const WCHAR link_nulW
[] = {'N','U','L'};
403 static const WCHAR link_pipeW
[] = {'P','I','P','E'};
404 static const WCHAR link_mailslotW
[] = {'M','A','I','L','S','L','O','T'};
405 static const WCHAR link_0W
[] = {'0'};
406 static const WCHAR link_sessionW
[] = {'S','e','s','s','i','o','n'};
407 static const WCHAR link_sessionsW
[] = {'\\','S','e','s','s','i','o','n','s'};
408 static const struct unicode_str link_dosdev_str
= {link_dosdevW
, sizeof(link_dosdevW
)};
409 static const struct unicode_str link_global_str
= {link_globalW
, sizeof(link_globalW
)};
410 static const struct unicode_str link_local_str
= {link_localW
, sizeof(link_localW
)};
411 static const struct unicode_str link_nul_str
= {link_nulW
, sizeof(link_nulW
)};
412 static const struct unicode_str link_pipe_str
= {link_pipeW
, sizeof(link_pipeW
)};
413 static const struct unicode_str link_mailslot_str
= {link_mailslotW
, sizeof(link_mailslotW
)};
414 static const struct unicode_str link_0_str
= {link_0W
, sizeof(link_0W
)};
415 static const struct unicode_str link_session_str
= {link_sessionW
, sizeof(link_sessionW
)};
416 static const struct unicode_str link_sessions_str
= {link_sessionsW
, sizeof(link_sessionsW
)};
419 static const WCHAR named_pipeW
[] = {'N','a','m','e','d','P','i','p','e'};
420 static const WCHAR mailslotW
[] = {'M','a','i','l','S','l','o','t'};
421 static const WCHAR nullW
[] = {'N','u','l','l'};
422 static const struct unicode_str named_pipe_str
= {named_pipeW
, sizeof(named_pipeW
)};
423 static const struct unicode_str mailslot_str
= {mailslotW
, sizeof(mailslotW
)};
424 static const struct unicode_str null_str
= {nullW
, sizeof(nullW
)};
427 static const WCHAR event_low_memW
[] = {'L','o','w','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n'};
428 static const WCHAR event_low_pagedW
[] = {'L','o','w','P','a','g','e','d','P','o','o','l','C','o','n','d','i','t','i','o','n'};
429 static const WCHAR event_low_nonpgW
[] = {'L','o','w','N','o','n','P','a','g','e','d','P','o','o','l','C','o','n','d','i','t','i','o','n'};
430 static const WCHAR event_high_memW
[] = {'H','i','g','h','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n'};
431 static const WCHAR event_high_pagedW
[] = {'H','i','g','h','P','a','g','e','d','P','o','o','l','C','o','n','d','i','t','i','o','n'};
432 static const WCHAR event_high_nonpgW
[] = {'H','i','g','h','N','o','n','P','a','g','e','d','P','o','o','l','C','o','n','d','i','t','i','o','n'};
433 static const WCHAR keyed_event_crit_sectW
[] = {'C','r','i','t','S','e','c','O','u','t','O','f','M','e','m','o','r','y','E','v','e','n','t'};
434 static const struct unicode_str kernel_events
[] =
436 { event_low_memW
, sizeof(event_low_memW
) },
437 { event_low_pagedW
, sizeof(event_low_pagedW
) },
438 { event_low_nonpgW
, sizeof(event_low_nonpgW
) },
439 { event_high_memW
, sizeof(event_high_memW
) },
440 { event_high_pagedW
, sizeof(event_high_pagedW
) },
441 { event_high_nonpgW
, sizeof(event_high_nonpgW
) }
443 static const struct unicode_str keyed_event_crit_sect_str
= {keyed_event_crit_sectW
, sizeof(keyed_event_crit_sectW
)};
445 struct directory
*dir_driver
, *dir_device
, *dir_global
, *dir_basenamed
, *dir_sessions
, *dir_kernel
, *dir_windows
, *dir_winstation
;
446 struct symlink
*link_dosdev
, *link_global1
, *link_global2
, *link_local
, *link_nul
, *link_pipe
, *link_mailslot
, *link_0
, *link_session
;
447 struct keyed_event
*keyed_event
;
450 root_directory
= create_directory( NULL
, NULL
, 0, HASH_SIZE
, NULL
);
451 dir_driver
= create_directory( root_directory
, &dir_driver_str
, 0, HASH_SIZE
, NULL
);
452 dir_device
= create_directory( root_directory
, &dir_device_str
, 0, HASH_SIZE
, NULL
);
453 dir_objtype
= create_directory( root_directory
, &dir_objtype_str
, 0, HASH_SIZE
, NULL
);
454 dir_sessions
= create_directory( root_directory
, &dir_sessions_str
, 0, HASH_SIZE
, NULL
);
455 dir_kernel
= create_directory( root_directory
, &dir_kernel_str
, 0, HASH_SIZE
, NULL
);
456 dir_windows
= create_directory( root_directory
, &dir_windows_str
, 0, HASH_SIZE
, NULL
);
457 dir_winstation
= create_directory( dir_windows
, &dir_winstations_str
, 0, HASH_SIZE
, NULL
);
458 make_object_static( &root_directory
->obj
);
459 make_object_static( &dir_driver
->obj
);
460 make_object_static( &dir_objtype
->obj
);
461 make_object_static( &dir_winstation
->obj
);
463 dir_global
= create_directory( NULL
, &dir_global_str
, 0, HASH_SIZE
, NULL
);
464 /* use a larger hash table for this one since it can contain a lot of objects */
465 dir_basenamed
= create_directory( NULL
, &dir_basenamed_str
, 0, 37, NULL
);
468 create_named_pipe_device( dir_device
, &named_pipe_str
);
469 create_mailslot_device( dir_device
, &mailslot_str
);
470 create_unix_device( dir_device
, &null_str
, "/dev/null" );
473 link_dosdev
= create_symlink( root_directory
, &link_dosdev_str
, 0, &dir_global_str
, NULL
);
474 link_global1
= create_symlink( dir_global
, &link_global_str
, 0, &dir_global_str
, NULL
);
475 link_global2
= create_symlink( dir_basenamed
, &link_global_str
, 0, &dir_basenamed_str
, NULL
);
476 link_local
= create_symlink( dir_basenamed
, &link_local_str
, 0, &dir_basenamed_str
, NULL
);
477 link_nul
= create_symlink( dir_global
, &link_nul_str
, 0, &dir_null_str
, NULL
);
478 link_pipe
= create_symlink( dir_global
, &link_pipe_str
, 0, &dir_named_pipe_str
, NULL
);
479 link_mailslot
= create_symlink( dir_global
, &link_mailslot_str
, 0, &dir_mailslot_str
, NULL
);
480 link_0
= create_symlink( dir_sessions
, &link_0_str
, 0, &dir_basenamed_str
, NULL
);
481 link_session
= create_symlink( dir_basenamed
, &link_session_str
, 0, &link_sessions_str
, NULL
);
482 make_object_static( (struct object
*)link_dosdev
);
483 make_object_static( (struct object
*)link_global1
);
484 make_object_static( (struct object
*)link_global2
);
485 make_object_static( (struct object
*)link_local
);
486 make_object_static( (struct object
*)link_nul
);
487 make_object_static( (struct object
*)link_pipe
);
488 make_object_static( (struct object
*)link_mailslot
);
489 make_object_static( (struct object
*)link_0
);
490 make_object_static( (struct object
*)link_session
);
493 for (i
= 0; i
< sizeof(kernel_events
)/sizeof(kernel_events
[0]); i
++)
495 struct event
*event
= create_event( dir_kernel
, &kernel_events
[i
], 0, 1, 0, NULL
);
496 make_object_static( (struct object
*)event
);
498 keyed_event
= create_keyed_event( dir_kernel
, &keyed_event_crit_sect_str
, 0, NULL
);
499 make_object_static( (struct object
*)keyed_event
);
501 /* the objects hold references so we can release these directories */
502 release_object( dir_global
);
503 release_object( dir_device
);
504 release_object( dir_basenamed
);
505 release_object( dir_sessions
);
506 release_object( dir_kernel
);
507 release_object( dir_windows
);
510 /* create a directory object */
511 DECL_HANDLER(create_directory
)
513 struct unicode_str name
;
514 struct directory
*dir
, *root
= NULL
;
515 const struct security_descriptor
*sd
;
516 const struct object_attributes
*objattr
= get_req_object_attributes( &sd
, &name
);
518 if (!objattr
) return;
519 if (objattr
->rootdir
&& !(root
= get_directory_obj( current
->process
, objattr
->rootdir
, 0 ))) return;
521 if ((dir
= create_directory( root
, &name
, objattr
->attributes
, HASH_SIZE
, sd
)))
523 reply
->handle
= alloc_handle( current
->process
, dir
, req
->access
, objattr
->attributes
);
524 release_object( dir
);
527 if (root
) release_object( root
);
530 /* open a directory object */
531 DECL_HANDLER(open_directory
)
533 struct unicode_str name
;
534 struct directory
*dir
, *root
= NULL
;
536 get_req_unicode_str( &name
);
537 if (req
->rootdir
&& !(root
= get_directory_obj( current
->process
, req
->rootdir
, 0 )))
540 if ((dir
= open_object_dir( root
, &name
, req
->attributes
, &directory_ops
)))
542 reply
->handle
= alloc_handle( current
->process
, &dir
->obj
, req
->access
, req
->attributes
);
543 release_object( dir
);
546 if (root
) release_object( root
);
549 /* get a directory entry by index */
550 DECL_HANDLER(get_directory_entry
)
552 struct directory
*dir
= get_directory_obj( current
->process
, req
->handle
, DIRECTORY_QUERY
);
555 struct object
*obj
= find_object_index( dir
->entries
, req
->index
);
558 data_size_t name_len
, type_len
= 0;
559 const WCHAR
*type_name
= NULL
;
560 const WCHAR
*name
= get_object_name( obj
, &name_len
);
561 struct object_type
*type
= obj
->ops
->get_type( obj
);
563 if (type
) type_name
= get_object_name( &type
->obj
, &type_len
);
565 if (name_len
+ type_len
<= get_reply_max_size())
567 void *ptr
= set_reply_data_size( name_len
+ type_len
);
570 reply
->name_len
= name_len
;
571 memcpy( ptr
, name
, name_len
);
572 memcpy( (char *)ptr
+ name_len
, type_name
, type_len
);
575 else set_error( STATUS_BUFFER_OVERFLOW
);
577 if (type
) release_object( type
);
578 release_object( obj
);
580 release_object( dir
);
584 /* unlink a named object */
585 DECL_HANDLER(unlink_object
)
587 struct object
*obj
= get_handle_obj( current
->process
, req
->handle
, 0, NULL
);
591 unlink_named_object( obj
);
592 release_object( obj
);
596 /* query object type name information */
597 DECL_HANDLER(get_object_type
)
600 struct object_type
*type
;
603 if (!(obj
= get_handle_obj( current
->process
, req
->handle
, 0, NULL
))) return;
605 if ((type
= obj
->ops
->get_type( obj
)))
607 if ((name
= get_object_name( &type
->obj
, &reply
->total
)))
608 set_reply_data( name
, min( reply
->total
, get_reply_max_size() ) );
609 release_object( type
);
611 release_object( obj
);