server/directory.c

   1 /*
   2  * Server-side directory object management
   3  *
   4  * Copyright (C) 2005 Vitaliy Margolen
   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
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <sys/types.h>
  30
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "winternl.h"
  34 #include "ddk/wdm.h"
  35
  36 #include "handle.h"
  37 #include "request.h"
  38 #include "process.h"
  39 #include "file.h"
  40 #include "unicode.h"
  41
  42 #define HASH_SIZE 7  /* default hash size */
  43
  44 struct object_type
  45 {
  46     struct object     obj;        /* object header */
  47 };
  48
  49 static void object_type_dump( struct object *obj, int verbose );
  50 static struct object_type *object_type_get_type( struct object *obj );
  51
  52 static const struct object_ops object_type_ops =
  53 {
  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 */
  59     NULL,                         /* signaled */
  60     NULL,                         /* satisfied */
  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 */
  70 };
  71
  72
  73 struct directory
  74 {
  75     struct object     obj;        /* object header */
  76     struct namespace *entries;    /* directory's name space */
  77 };
  78
  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,
  82                                              unsigned int attr );
  83 static void directory_destroy( struct object *obj );
  84
  85 static const struct object_ops directory_ops =
  86 {
  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 */
  92     NULL,                         /* signaled */
  93     NULL,                         /* satisfied */
  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 */
 103 };
 104
 105 static struct directory *root_directory;
 106 static struct directory *dir_objtype;
 107
 108
 109 static void object_type_dump( struct object *obj, int verbose )
 110 {
 111     assert( obj->ops == &object_type_ops );
 112
 113     fputs( "Object type ", stderr );
 114     dump_object_name( obj );
 115     fputc( '\n', stderr );
 116 }
 117
 118 static struct object_type *object_type_get_type( struct object *obj )
 119 {
 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 );
 123 }
 124
 125 static void directory_dump( struct object *obj, int verbose )
 126 {
 127     assert( obj->ops == &directory_ops );
 128
 129     fputs( "Directory ", stderr );
 130     dump_object_name( obj );
 131     fputc( '\n', stderr );
 132 }
 133
 134 static struct object_type *directory_get_type( struct object *obj )
 135 {
 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 );
 139 }
 140
 141 static struct object *directory_lookup_name( struct object *obj, struct unicode_str *name,
 142                                              unsigned int attr )
 143 {
 144     struct directory *dir = (struct directory *)obj;
 145     struct object *found;
 146     struct unicode_str tmp;
 147     const WCHAR *p;
 148
 149     assert( obj->ops == &directory_ops );
 150
 151     if (!(p = memchrW( name->str, '\\', name->len / sizeof(WCHAR) )))
 152         /* Last element in the path name */
 153         tmp.len = name->len;
 154     else
 155         tmp.len = (p - name->str) * sizeof(WCHAR);
 156
 157     tmp.str = name->str;
 158     if ((found = find_object( dir->entries, &tmp, attr )))
 159     {
 160         /* Skip trailing \\ */
 161         if (p)
 162         {
 163             p++;
 164             tmp.len += sizeof(WCHAR);
 165         }
 166         /* Move to the next element*/
 167         name->str = p;
 168         name->len -= tmp.len;
 169         return found;
 170     }
 171
 172     if (name->str)
 173     {
 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 );
 178         else
 179             clear_error();
 180     }
 181     return NULL;
 182 }
 183
 184 static void directory_destroy( struct object *obj )
 185 {
 186     struct directory *dir = (struct directory *)obj;
 187     assert( obj->ops == &directory_ops );
 188     free( dir->entries );
 189 }
 190
 191 static struct directory *create_directory( struct directory *root, const struct unicode_str *name,
 192                                            unsigned int attr, unsigned int hash_size )
 193 {
 194     struct directory *dir;
 195
 196     if ((dir = create_named_object_dir( root, name, attr, &directory_ops )) &&
 197         get_error() != STATUS_OBJECT_NAME_EXISTS)
 198     {
 199         if (!(dir->entries = create_namespace( hash_size )))
 200         {
 201             release_object( dir );
 202             dir = NULL;
 203         }
 204     }
 205     return dir;
 206 }
 207
 208 struct directory *get_directory_obj( struct process *process, obj_handle_t handle, unsigned int access )
 209 {
 210     return (struct directory *)get_handle_obj( process, handle, access, &directory_ops );
 211 }
 212
 213 /******************************************************************************
 214  * Find an object by its name in a given root object
 215  *
 216  * PARAMS
 217  *  root      [I] directory to start search from or NULL to start from \\
 218  *  name      [I] object name to search for
 219  *  attr      [I] OBJECT_ATTRIBUTES.Attributes
 220  *  name_left [O] [optional] leftover name if object is not found
 221  *
 222  * RETURNS
 223  *  NULL:      If params are invalid
 224  *  Found:     If object with exact name is found returns that object
 225  *             (name_left->len == 0). Object's refcount is incremented
 226  *  Not found: The last matched parent. (name_left->len > 0)
 227  *             Parent's refcount is incremented.
 228  */
 229 struct object *find_object_dir( struct directory *root, const struct unicode_str *name,
 230                                 unsigned int attr, struct unicode_str *name_left )
 231 {
 232     struct object *obj, *parent;
 233     struct unicode_str name_tmp;
 234
 235     if (name) name_tmp = *name;
 236     else name_tmp.len = 0;
 237
 238     /* Arguments check:
 239      * - Either rootdir or name have to be specified
 240      * - If root is specified path shouldn't start with backslash */
 241     if (root)
 242     {
 243         if (name_tmp.len && name_tmp.str[0] == '\\')
 244         {
 245             set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
 246             return NULL;
 247         }
 248         parent = grab_object( root );
 249     }
 250     else
 251     {
 252         if (!name_tmp.len || name_tmp.str[0] != '\\')
 253         {
 254             set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
 255             return NULL;
 256         }
 257         parent = grab_object( &root_directory->obj );
 258         /* skip leading backslash */
 259         name_tmp.str++;
 260         name_tmp.len -= sizeof(WCHAR);
 261     }
 262
 263     /* Special case for opening RootDirectory */
 264     if (!name_tmp.len) goto done;
 265
 266     while ((obj = parent->ops->lookup_name( parent, &name_tmp, attr )))
 267     {
 268         /* move to the next element */
 269         release_object ( parent );
 270         parent = obj;
 271     }
 272     if (get_error())
 273     {
 274         release_object( parent );
 275         return NULL;
 276     }
 277
 278     done:
 279     if (name_left) *name_left = name_tmp;
 280     return parent;
 281 }
 282
 283 /* create a named (if name is present) or unnamed object. */
 284 void *create_named_object_dir( struct directory *root, const struct unicode_str *name,
 285                                unsigned int attributes, const struct object_ops *ops )
 286 {
 287     struct object *obj, *new_obj = NULL;
 288     struct unicode_str new_name;
 289
 290     if (!name || !name->len) return alloc_object( ops );
 291
 292     if (!(obj = find_object_dir( root, name, attributes, &new_name ))) return NULL;
 293     if (!new_name.len)
 294     {
 295         if (attributes & OBJ_OPENIF && obj->ops == ops)
 296             set_error( STATUS_OBJECT_NAME_EXISTS );
 297         else
 298         {
 299             release_object( obj );
 300             obj = NULL;
 301             if (attributes & OBJ_OPENIF)
 302                 set_error( STATUS_OBJECT_TYPE_MISMATCH );
 303             else
 304                 set_error( STATUS_OBJECT_NAME_COLLISION );
 305         }
 306         return obj;
 307     }
 308
 309     /* ATM we can't insert objects into anything else but directories */
 310     if (obj->ops != &directory_ops)
 311         set_error( STATUS_OBJECT_TYPE_MISMATCH );
 312     else
 313     {
 314         struct directory *dir = (struct directory *)obj;
 315         if ((new_obj = create_object( dir->entries, ops, &new_name, &dir->obj )))
 316             clear_error();
 317     }
 318
 319     release_object( obj );
 320     return new_obj;
 321 }
 322
 323 /* open a new handle to an existing object */
 324 void *open_object_dir( struct directory *root, const struct unicode_str *name,
 325                        unsigned int attr, const struct object_ops *ops )
 326 {
 327     struct unicode_str name_left;
 328     struct object *obj;
 329
 330     if ((obj = find_object_dir( root, name, attr, &name_left )))
 331     {
 332         if (name_left.len) /* not fully parsed */
 333             set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 334         else if (ops && obj->ops != ops)
 335             set_error( STATUS_OBJECT_TYPE_MISMATCH );
 336         else
 337             return obj;
 338
 339         release_object( obj );
 340     }
 341     return NULL;
 342 }
 343
 344 /* retrieve an object type, creating it if needed */
 345 struct object_type *get_object_type( const struct unicode_str *name )
 346 {
 347     struct object_type *type;
 348
 349     if ((type = open_object_dir( dir_objtype, name, 0, &object_type_ops )))
 350         return type;
 351
 352     if ((type = create_named_object_dir( dir_objtype, name, 0, &object_type_ops )))
 353     {
 354         grab_object( type );
 355         make_object_static( &type->obj );
 356         clear_error();
 357     }
 358     return type;
 359 }
 360
 361 /* Global initialization */
 362
 363 void init_directories(void)
 364 {
 365     /* Directories */
 366     static const WCHAR dir_globalW[] = {'\\','?','?'};
 367     static const WCHAR dir_driverW[] = {'D','r','i','v','e','r'};
 368     static const WCHAR dir_deviceW[] = {'D','e','v','i','c','e'};
 369     static const WCHAR dir_basenamedW[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s'};
 370     static const WCHAR dir_named_pipeW[] = {'\\','D','e','v','i','c','e','\\','N','a','m','e','d','P','i','p','e'};
 371     static const WCHAR dir_mailslotW[] = {'\\','D','e','v','i','c','e','\\','M','a','i','l','S','l','o','t'};
 372     static const WCHAR dir_objtypeW[] = {'O','b','j','e','c','t','T','y','p','e','s',};
 373     static const struct unicode_str dir_global_str = {dir_globalW, sizeof(dir_globalW)};
 374     static const struct unicode_str dir_driver_str = {dir_driverW, sizeof(dir_driverW)};
 375     static const struct unicode_str dir_device_str = {dir_deviceW, sizeof(dir_deviceW)};
 376     static const struct unicode_str dir_basenamed_str = {dir_basenamedW, sizeof(dir_basenamedW)};
 377     static const struct unicode_str dir_named_pipe_str = {dir_named_pipeW, sizeof(dir_named_pipeW)};
 378     static const struct unicode_str dir_mailslot_str = {dir_mailslotW, sizeof(dir_mailslotW)};
 379     static const struct unicode_str dir_objtype_str = {dir_objtypeW, sizeof(dir_objtypeW)};
 380
 381     /* symlinks */
 382     static const WCHAR link_dosdevW[] = {'D','o','s','D','e','v','i','c','e','s'};
 383     static const WCHAR link_globalW[] = {'G','l','o','b','a','l'};
 384     static const WCHAR link_localW[]  = {'L','o','c','a','l'};
 385     static const WCHAR link_pipeW[]   = {'P','I','P','E'};
 386     static const WCHAR link_mailslotW[] = {'M','A','I','L','S','L','O','T'};
 387     static const struct unicode_str link_dosdev_str = {link_dosdevW, sizeof(link_dosdevW)};
 388     static const struct unicode_str link_global_str = {link_globalW, sizeof(link_globalW)};
 389     static const struct unicode_str link_local_str  = {link_localW, sizeof(link_localW)};
 390     static const struct unicode_str link_pipe_str   = {link_pipeW, sizeof(link_pipeW)};
 391     static const struct unicode_str link_mailslot_str = {link_mailslotW, sizeof(link_mailslotW)};
 392
 393     /* devices */
 394     static const WCHAR named_pipeW[] = {'N','a','m','e','d','P','i','p','e'};
 395     static const WCHAR mailslotW[] = {'M','a','i','l','S','l','o','t'};
 396     static const struct unicode_str named_pipe_str = {named_pipeW, sizeof(named_pipeW)};
 397     static const struct unicode_str mailslot_str = {mailslotW, sizeof(mailslotW)};
 398
 399     struct directory *dir_driver, *dir_device, *dir_global, *dir_basenamed;
 400     struct symlink *link_dosdev, *link_global1, *link_global2, *link_local, *link_pipe, *link_mailslot;
 401
 402     root_directory = create_directory( NULL, NULL, 0, HASH_SIZE );
 403     dir_driver     = create_directory( root_directory, &dir_driver_str, 0, HASH_SIZE );
 404     dir_device     = create_directory( root_directory, &dir_device_str, 0, HASH_SIZE );
 405     dir_objtype    = create_directory( root_directory, &dir_objtype_str, 0, HASH_SIZE );
 406     make_object_static( &root_directory->obj );
 407     make_object_static( &dir_driver->obj );
 408     make_object_static( &dir_objtype->obj );
 409
 410     dir_global     = create_directory( NULL, &dir_global_str, 0, HASH_SIZE );
 411     /* use a larger hash table for this one since it can contain a lot of objects */
 412     dir_basenamed  = create_directory( NULL, &dir_basenamed_str, 0, 37 );
 413
 414     /* devices */
 415     create_named_pipe_device( dir_device, &named_pipe_str );
 416     create_mailslot_device( dir_device, &mailslot_str );
 417
 418     /* symlinks */
 419     link_dosdev    = create_symlink( root_directory, &link_dosdev_str, 0, &dir_global_str );
 420     link_global1   = create_symlink( dir_global, &link_global_str, 0, &dir_global_str );
 421     link_global2   = create_symlink( dir_basenamed, &link_global_str, 0, &dir_basenamed_str );
 422     link_local     = create_symlink( dir_basenamed, &link_local_str, 0, &dir_basenamed_str );
 423     link_pipe      = create_symlink( dir_global, &link_pipe_str, 0, &dir_named_pipe_str );
 424     link_mailslot  = create_symlink( dir_global, &link_mailslot_str, 0, &dir_mailslot_str );
 425     make_object_static( (struct object *)link_dosdev );
 426     make_object_static( (struct object *)link_global1 );
 427     make_object_static( (struct object *)link_global2 );
 428     make_object_static( (struct object *)link_local );
 429     make_object_static( (struct object *)link_pipe );
 430     make_object_static( (struct object *)link_mailslot );
 431
 432     /* the symlinks or devices hold references so we can release these */
 433     release_object( dir_global );
 434     release_object( dir_device );
 435     release_object( dir_basenamed );
 436 }
 437
 438 /* create a directory object */
 439 DECL_HANDLER(create_directory)
 440 {
 441     struct unicode_str name;
 442     struct directory *dir, *root = NULL;
 443
 444     reply->handle = 0;
 445     get_req_unicode_str( &name );
 446     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
 447         return;
 448
 449     if ((dir = create_directory( root, &name, req->attributes, HASH_SIZE )))
 450     {
 451         reply->handle = alloc_handle( current->process, dir, req->access, req->attributes );
 452         release_object( dir );
 453     }
 454
 455     if (root) release_object( root );
 456 }
 457
 458 /* open a directory object */
 459 DECL_HANDLER(open_directory)
 460 {
 461     struct unicode_str name;
 462     struct directory *dir, *root = NULL;
 463
 464     get_req_unicode_str( &name );
 465     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
 466         return;
 467
 468     if ((dir = open_object_dir( root, &name, req->attributes, &directory_ops )))
 469     {
 470         reply->handle = alloc_handle( current->process, &dir->obj, req->access, req->attributes );
 471         release_object( dir );
 472     }
 473
 474     if (root) release_object( root );
 475 }
 476
 477 /* get a directory entry by index */
 478 DECL_HANDLER(get_directory_entry)
 479 {
 480     struct directory *dir = get_directory_obj( current->process, req->handle, DIRECTORY_QUERY );
 481     if (dir)
 482     {
 483         struct object *obj = find_object_index( dir->entries, req->index );
 484         if (obj)
 485         {
 486             data_size_t name_len, type_len = 0;
 487             const WCHAR *type_name = NULL;
 488             const WCHAR *name = get_object_name( obj, &name_len );
 489             struct object_type *type = obj->ops->get_type( obj );
 490
 491             if (type) type_name = get_object_name( &type->obj, &type_len );
 492
 493             if (name_len + type_len <= get_reply_max_size())
 494             {
 495                 void *ptr = set_reply_data_size( name_len + type_len );
 496                 if (ptr)
 497                 {
 498                     reply->name_len = name_len;
 499                     memcpy( ptr, name, name_len );
 500                     memcpy( (char *)ptr + name_len, type_name, type_len );
 501                 }
 502             }
 503             else set_error( STATUS_BUFFER_OVERFLOW );
 504
 505             if (type) release_object( type );
 506             release_object( obj );
 507         }
 508         release_object( dir );
 509     }
 510 }
 511
 512 /* unlink a named object */
 513 DECL_HANDLER(unlink_object)
 514 {
 515     struct object *obj = get_handle_obj( current->process, req->handle, 0, NULL );
 516
 517     if (obj)
 518     {
 519         unlink_named_object( obj );
 520         release_object( obj );
 521     }
 522 }