server/object.c

   1 /*
   2  * Server-side objects
   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 <limits.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <stdarg.h>
  31 #ifdef HAVE_VALGRIND_MEMCHECK_H
  32 #include <valgrind/memcheck.h>
  33 #endif
  34
  35 #include "ntstatus.h"
  36 #define WIN32_NO_STATUS
  37 #include "winternl.h"
  38
  39 #include "file.h"
  40 #include "process.h"
  41 #include "thread.h"
  42 #include "unicode.h"
  43 #include "security.h"
  44
  45
  46 struct namespace
  47 {
  48     unsigned int        hash_size;       /* size of hash table */
  49     struct list         names[1];        /* array of hash entry lists */
  50 };
  51
  52
  53 #ifdef DEBUG_OBJECTS
  54 static struct list object_list = LIST_INIT(object_list);
  55 static struct list static_object_list = LIST_INIT(static_object_list);
  56
  57 void dump_objects(void)
  58 {
  59     struct list *p;
  60
  61     LIST_FOR_EACH( p, &static_object_list )
  62     {
  63         struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
  64         fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
  65         dump_object_name( ptr );
  66         ptr->ops->dump( ptr, 1 );
  67     }
  68     LIST_FOR_EACH( p, &object_list )
  69     {
  70         struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
  71         fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
  72         dump_object_name( ptr );
  73         ptr->ops->dump( ptr, 1 );
  74     }
  75 }
  76
  77 void close_objects(void)
  78 {
  79     struct list *ptr;
  80
  81     /* release the static objects */
  82     while ((ptr = list_head( &static_object_list )))
  83     {
  84         struct object *obj = LIST_ENTRY( ptr, struct object, obj_list );
  85         /* move it back to the standard list before freeing */
  86         list_remove( &obj->obj_list );
  87         list_add_head( &object_list, &obj->obj_list );
  88         release_object( obj );
  89     }
  90
  91     dump_objects();  /* dump any remaining objects */
  92 }
  93
  94 #endif  /* DEBUG_OBJECTS */
  95
  96 /*****************************************************************/
  97
  98 /* mark a block of memory as uninitialized for debugging purposes */
  99 static inline void mark_block_uninitialized( void *ptr, size_t size )
 100 {
 101     memset( ptr, 0x55, size );
 102 #if defined(VALGRIND_MAKE_MEM_UNDEFINED)
 103     VALGRIND_DISCARD( VALGRIND_MAKE_MEM_UNDEFINED( ptr, size ));
 104 #elif defined(VALGRIND_MAKE_WRITABLE)
 105     VALGRIND_DISCARD( VALGRIND_MAKE_WRITABLE( ptr, size ));
 106 #endif
 107 }
 108
 109 /* malloc replacement */
 110 void *mem_alloc( size_t size )
 111 {
 112     void *ptr = malloc( size );
 113     if (ptr) mark_block_uninitialized( ptr, size );
 114     else set_error( STATUS_NO_MEMORY );
 115     return ptr;
 116 }
 117
 118 /* duplicate a block of memory */
 119 void *memdup( const void *data, size_t len )
 120 {
 121     void *ptr = malloc( len );
 122     if (ptr) memcpy( ptr, data, len );
 123     else set_error( STATUS_NO_MEMORY );
 124     return ptr;
 125 }
 126
 127
 128 /*****************************************************************/
 129
 130 static int get_name_hash( const struct namespace *namespace, const WCHAR *name, data_size_t len )
 131 {
 132     WCHAR hash = 0;
 133     len /= sizeof(WCHAR);
 134     while (len--) hash ^= tolowerW(*name++);
 135     return hash % namespace->hash_size;
 136 }
 137
 138 void namespace_add( struct namespace *namespace, struct object_name *ptr )
 139 {
 140     int hash = get_name_hash( namespace, ptr->name, ptr->len );
 141
 142     list_add_head( &namespace->names[hash], &ptr->entry );
 143 }
 144
 145 /* allocate a name for an object */
 146 static struct object_name *alloc_name( const struct unicode_str *name )
 147 {
 148     struct object_name *ptr;
 149
 150     if ((ptr = mem_alloc( sizeof(*ptr) + name->len - sizeof(ptr->name) )))
 151     {
 152         ptr->len = name->len;
 153         ptr->parent = NULL;
 154         memcpy( ptr->name, name->str, name->len );
 155     }
 156     return ptr;
 157 }
 158
 159 /* get the name of an existing object */
 160 const WCHAR *get_object_name( struct object *obj, data_size_t *len )
 161 {
 162     struct object_name *ptr = obj->name;
 163     if (!ptr) return NULL;
 164     *len = ptr->len;
 165     return ptr->name;
 166 }
 167
 168 /* get the full path name of an existing object */
 169 WCHAR *get_object_full_name( struct object *obj, data_size_t *ret_len )
 170 {
 171     static const WCHAR backslash = '\\';
 172     struct object *ptr = obj;
 173     data_size_t len = 0;
 174     char *ret;
 175
 176     while (ptr && ptr->name)
 177     {
 178         struct object_name *name = ptr->name;
 179         len += name->len + sizeof(WCHAR);
 180         ptr = name->parent;
 181     }
 182     if (!len) return NULL;
 183     if (!(ret = malloc( len ))) return NULL;
 184
 185     *ret_len = len;
 186     while (obj && obj->name)
 187     {
 188         struct object_name *name = obj->name;
 189         memcpy( ret + len - name->len, name->name, name->len );
 190         len -= name->len + sizeof(WCHAR);
 191         memcpy( ret + len, &backslash, sizeof(WCHAR) );
 192         obj = name->parent;
 193     }
 194     return (WCHAR *)ret;
 195 }
 196
 197 /* allocate and initialize an object */
 198 void *alloc_object( const struct object_ops *ops )
 199 {
 200     struct object *obj = mem_alloc( ops->size );
 201     if (obj)
 202     {
 203         obj->refcount     = 1;
 204         obj->handle_count = 0;
 205         obj->ops          = ops;
 206         obj->name         = NULL;
 207         obj->sd           = NULL;
 208         list_init( &obj->wait_queue );
 209 #ifdef DEBUG_OBJECTS
 210         list_add_head( &object_list, &obj->obj_list );
 211 #endif
 212         return obj;
 213     }
 214     return NULL;
 215 }
 216
 217 /* free an object once it has been destroyed */
 218 void free_object( struct object *obj )
 219 {
 220     free( obj->sd );
 221 #ifdef DEBUG_OBJECTS
 222     list_remove( &obj->obj_list );
 223     memset( obj, 0xaa, obj->ops->size );
 224 #endif
 225     free( obj );
 226 }
 227
 228 /* find an object by name starting from the specified root */
 229 /* if it doesn't exist, its parent is returned, and name_left contains the remaining name */
 230 struct object *lookup_named_object( struct object *root, const struct unicode_str *name,
 231                                     unsigned int attr, struct unicode_str *name_left )
 232 {
 233     struct object *obj, *parent;
 234     struct unicode_str name_tmp = *name, *ptr = &name_tmp;
 235
 236     if (root)
 237     {
 238         /* if root is specified path shouldn't start with backslash */
 239         if (name_tmp.len && name_tmp.str[0] == '\\')
 240         {
 241             set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
 242             return NULL;
 243         }
 244         parent = grab_object( root );
 245     }
 246     else
 247     {
 248         if (!name_tmp.len || name_tmp.str[0] != '\\')
 249         {
 250             set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
 251             return NULL;
 252         }
 253         /* skip leading backslash */
 254         name_tmp.str++;
 255         name_tmp.len -= sizeof(WCHAR);
 256         parent = get_root_directory();
 257     }
 258
 259     if (!name_tmp.len) ptr = NULL;  /* special case for empty path */
 260
 261     clear_error();
 262
 263     while ((obj = parent->ops->lookup_name( parent, ptr, attr )))
 264     {
 265         /* move to the next element */
 266         release_object ( parent );
 267         parent = obj;
 268     }
 269     if (get_error())
 270     {
 271         release_object( parent );
 272         return NULL;
 273     }
 274
 275     if (name_left) *name_left = name_tmp;
 276     return parent;
 277 }
 278
 279 static struct object *create_object( struct object *parent, const struct object_ops *ops,
 280                                      const struct unicode_str *name, const struct security_descriptor *sd )
 281 {
 282     struct object *obj;
 283     struct object_name *name_ptr;
 284
 285     if (!(name_ptr = alloc_name( name ))) return NULL;
 286     if (!(obj = alloc_object( ops ))) goto failed;
 287     if (sd && !default_set_sd( obj, sd, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
 288                                DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION ))
 289         goto failed;
 290     if (!obj->ops->link_name( obj, name_ptr, parent )) goto failed;
 291
 292     name_ptr->obj = obj;
 293     obj->name = name_ptr;
 294     return obj;
 295
 296 failed:
 297     if (obj) free_object( obj );
 298     free( name_ptr );
 299     return NULL;
 300 }
 301
 302 /* create an object as named child under the specified parent */
 303 void *create_named_object( struct object *parent, const struct object_ops *ops,
 304                            const struct unicode_str *name, unsigned int attributes,
 305                            const struct security_descriptor *sd )
 306 {
 307     struct object *obj, *new_obj;
 308     struct unicode_str new_name;
 309
 310     clear_error();
 311
 312     if (!name || !name->len)
 313     {
 314         if (!(new_obj = alloc_object( ops ))) return NULL;
 315         if (sd && !default_set_sd( new_obj, sd, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
 316                                    DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION ))
 317         {
 318             free_object( new_obj );
 319             return NULL;
 320         }
 321         return new_obj;
 322     }
 323
 324     if (!(obj = lookup_named_object( parent, name, attributes, &new_name ))) return NULL;
 325
 326     if (!new_name.len)
 327     {
 328         if (attributes & OBJ_OPENIF && obj->ops == ops)
 329             set_error( STATUS_OBJECT_NAME_EXISTS );
 330         else
 331         {
 332             release_object( obj );
 333             obj = NULL;
 334             if (attributes & OBJ_OPENIF)
 335                 set_error( STATUS_OBJECT_TYPE_MISMATCH );
 336             else
 337                 set_error( STATUS_OBJECT_NAME_COLLISION );
 338         }
 339         return obj;
 340     }
 341
 342     new_obj = create_object( obj, ops, &new_name, sd );
 343     release_object( obj );
 344     return new_obj;
 345 }
 346
 347 /* open a object by name under the specified parent */
 348 void *open_named_object( struct object *parent, const struct object_ops *ops,
 349                          const struct unicode_str *name, unsigned int attributes )
 350 {
 351     struct unicode_str name_left;
 352     struct object *obj;
 353
 354     if ((obj = lookup_named_object( parent, name, attributes, &name_left )))
 355     {
 356         if (name_left.len) /* not fully parsed */
 357             set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 358         else if (ops && obj->ops != ops)
 359             set_error( STATUS_OBJECT_TYPE_MISMATCH );
 360         else
 361             return obj;
 362
 363         release_object( obj );
 364     }
 365     return NULL;
 366 }
 367
 368 /* recursive helper for dump_object_name */
 369 static void dump_name( struct object *obj )
 370 {
 371     struct object_name *name = obj->name;
 372
 373     if (!name) return;
 374     if (name->parent) dump_name( name->parent );
 375     fputs( "\\\\", stderr );
 376     dump_strW( name->name, name->len / sizeof(WCHAR), stderr, "[]" );
 377 }
 378
 379 /* dump the name of an object to stderr */
 380 void dump_object_name( struct object *obj )
 381 {
 382     if (!obj->name) return;
 383     fputc( '[', stderr );
 384     dump_name( obj );
 385     fputs( "] ", stderr );
 386 }
 387
 388 /* unlink a named object from its namespace, without freeing the object itself */
 389 void unlink_named_object( struct object *obj )
 390 {
 391     struct object_name *name_ptr = obj->name;
 392
 393     if (!name_ptr) return;
 394     obj->name = NULL;
 395     obj->ops->unlink_name( obj, name_ptr );
 396     if (name_ptr->parent) release_object( name_ptr->parent );
 397     free( name_ptr );
 398 }
 399
 400 /* mark an object as being stored statically, i.e. only released at shutdown */
 401 void make_object_static( struct object *obj )
 402 {
 403 #ifdef DEBUG_OBJECTS
 404     list_remove( &obj->obj_list );
 405     list_add_head( &static_object_list, &obj->obj_list );
 406 #endif
 407 }
 408
 409 /* grab an object (i.e. increment its refcount) and return the object */
 410 struct object *grab_object( void *ptr )
 411 {
 412     struct object *obj = (struct object *)ptr;
 413     assert( obj->refcount < INT_MAX );
 414     obj->refcount++;
 415     return obj;
 416 }
 417
 418 /* release an object (i.e. decrement its refcount) */
 419 void release_object( void *ptr )
 420 {
 421     struct object *obj = (struct object *)ptr;
 422     assert( obj->refcount );
 423     if (!--obj->refcount)
 424     {
 425         assert( !obj->handle_count );
 426         /* if the refcount is 0, nobody can be in the wait queue */
 427         assert( list_empty( &obj->wait_queue ));
 428         unlink_named_object( obj );
 429         obj->ops->destroy( obj );
 430         free_object( obj );
 431     }
 432 }
 433
 434 /* find an object by its name; the refcount is incremented */
 435 struct object *find_object( const struct namespace *namespace, const struct unicode_str *name,
 436                             unsigned int attributes )
 437 {
 438     const struct list *list;
 439     struct list *p;
 440
 441     if (!name || !name->len) return NULL;
 442
 443     list = &namespace->names[ get_name_hash( namespace, name->str, name->len ) ];
 444     LIST_FOR_EACH( p, list )
 445     {
 446         const struct object_name *ptr = LIST_ENTRY( p, struct object_name, entry );
 447         if (ptr->len != name->len) continue;
 448         if (attributes & OBJ_CASE_INSENSITIVE)
 449         {
 450             if (!strncmpiW( ptr->name, name->str, name->len/sizeof(WCHAR) ))
 451                 return grab_object( ptr->obj );
 452         }
 453         else
 454         {
 455             if (!memcmp( ptr->name, name->str, name->len ))
 456                 return grab_object( ptr->obj );
 457         }
 458     }
 459     return NULL;
 460 }
 461
 462 /* find an object by its index; the refcount is incremented */
 463 struct object *find_object_index( const struct namespace *namespace, unsigned int index )
 464 {
 465     unsigned int i;
 466
 467     /* FIXME: not efficient at all */
 468     for (i = 0; i < namespace->hash_size; i++)
 469     {
 470         const struct object_name *ptr;
 471         LIST_FOR_EACH_ENTRY( ptr, &namespace->names[i], const struct object_name, entry )
 472         {
 473             if (!index--) return grab_object( ptr->obj );
 474         }
 475     }
 476     set_error( STATUS_NO_MORE_ENTRIES );
 477     return NULL;
 478 }
 479
 480 /* allocate a namespace */
 481 struct namespace *create_namespace( unsigned int hash_size )
 482 {
 483     struct namespace *namespace;
 484     unsigned int i;
 485
 486     namespace = mem_alloc( sizeof(*namespace) + (hash_size - 1) * sizeof(namespace->names[0]) );
 487     if (namespace)
 488     {
 489         namespace->hash_size      = hash_size;
 490         for (i = 0; i < hash_size; i++) list_init( &namespace->names[i] );
 491     }
 492     return namespace;
 493 }
 494
 495 /* functions for unimplemented/default object operations */
 496
 497 struct object_type *no_get_type( struct object *obj )
 498 {
 499     return NULL;
 500 }
 501
 502 int no_add_queue( struct object *obj, struct wait_queue_entry *entry )
 503 {
 504     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 505     return 0;
 506 }
 507
 508 void no_satisfied( struct object *obj, struct wait_queue_entry *entry )
 509 {
 510 }
 511
 512 int no_signal( struct object *obj, unsigned int access )
 513 {
 514     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 515     return 0;
 516 }
 517
 518 struct fd *no_get_fd( struct object *obj )
 519 {
 520     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 521     return NULL;
 522 }
 523
 524 unsigned int no_map_access( struct object *obj, unsigned int access )
 525 {
 526     if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ;
 527     if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE;
 528     if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
 529     if (access & GENERIC_ALL)     access |= STANDARD_RIGHTS_ALL;
 530     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
 531 }
 532
 533 struct security_descriptor *default_get_sd( struct object *obj )
 534 {
 535     return obj->sd;
 536 }
 537
 538 int set_sd_defaults_from_token( struct object *obj, const struct security_descriptor *sd,
 539                                 unsigned int set_info, struct token *token )
 540 {
 541     struct security_descriptor new_sd, *new_sd_ptr;
 542     int present;
 543     const SID *owner = NULL, *group = NULL;
 544     const ACL *sacl, *dacl;
 545     char *ptr;
 546
 547     if (!set_info) return 1;
 548
 549     new_sd.control = sd->control & ~SE_SELF_RELATIVE;
 550
 551     if (set_info & OWNER_SECURITY_INFORMATION && sd->owner_len)
 552     {
 553         owner = sd_get_owner( sd );
 554         new_sd.owner_len = sd->owner_len;
 555     }
 556     else if (obj->sd && obj->sd->owner_len)
 557     {
 558         owner = sd_get_owner( obj->sd );
 559         new_sd.owner_len = obj->sd->owner_len;
 560     }
 561     else if (token)
 562     {
 563         owner = token_get_user( token );
 564         new_sd.owner_len = security_sid_len( owner );
 565     }
 566     else new_sd.owner_len = 0;
 567
 568     if (set_info & GROUP_SECURITY_INFORMATION && sd->group_len)
 569     {
 570         group = sd_get_group( sd );
 571         new_sd.group_len = sd->group_len;
 572     }
 573     else if (obj->sd && obj->sd->group_len)
 574     {
 575         group = sd_get_group( obj->sd );
 576         new_sd.group_len = obj->sd->group_len;
 577     }
 578     else if (token)
 579     {
 580         group = token_get_primary_group( token );
 581         new_sd.group_len = security_sid_len( group );
 582     }
 583     else new_sd.group_len = 0;
 584
 585     new_sd.control |= SE_SACL_PRESENT;
 586     sacl = sd_get_sacl( sd, &present );
 587     if (set_info & SACL_SECURITY_INFORMATION && present)
 588         new_sd.sacl_len = sd->sacl_len;
 589     else
 590     {
 591         if (obj->sd) sacl = sd_get_sacl( obj->sd, &present );
 592
 593         if (obj->sd && present)
 594             new_sd.sacl_len = obj->sd->sacl_len;
 595         else
 596             new_sd.sacl_len = 0;
 597     }
 598
 599     new_sd.control |= SE_DACL_PRESENT;
 600     dacl = sd_get_dacl( sd, &present );
 601     if (set_info & DACL_SECURITY_INFORMATION && present)
 602         new_sd.dacl_len = sd->dacl_len;
 603     else
 604     {
 605         if (obj->sd) dacl = sd_get_dacl( obj->sd, &present );
 606
 607         if (obj->sd && present)
 608             new_sd.dacl_len = obj->sd->dacl_len;
 609         else if (token)
 610         {
 611             dacl = token_get_default_dacl( token );
 612             new_sd.dacl_len = dacl->AclSize;
 613         }
 614         else new_sd.dacl_len = 0;
 615     }
 616
 617     ptr = mem_alloc( sizeof(new_sd) + new_sd.owner_len + new_sd.group_len +
 618                      new_sd.sacl_len + new_sd.dacl_len );
 619     if (!ptr) return 0;
 620     new_sd_ptr = (struct security_descriptor*)ptr;
 621
 622     memcpy( ptr, &new_sd, sizeof(new_sd) );
 623     ptr += sizeof(new_sd);
 624     memcpy( ptr, owner, new_sd.owner_len );
 625     ptr += new_sd.owner_len;
 626     memcpy( ptr, group, new_sd.group_len );
 627     ptr += new_sd.group_len;
 628     memcpy( ptr, sacl, new_sd.sacl_len );
 629     ptr += new_sd.sacl_len;
 630     memcpy( ptr, dacl, new_sd.dacl_len );
 631
 632     free( obj->sd );
 633     obj->sd = new_sd_ptr;
 634     return 1;
 635 }
 636
 637 /** Set the security descriptor using the current primary token for defaults. */
 638 int default_set_sd( struct object *obj, const struct security_descriptor *sd,
 639                     unsigned int set_info )
 640 {
 641     return set_sd_defaults_from_token( obj, sd, set_info, current->process->token );
 642 }
 643
 644 struct object *no_lookup_name( struct object *obj, struct unicode_str *name,
 645                                unsigned int attr )
 646 {
 647     if (!name) set_error( STATUS_OBJECT_TYPE_MISMATCH );
 648     return NULL;
 649 }
 650
 651 int no_link_name( struct object *obj, struct object_name *name, struct object *parent )
 652 {
 653     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 654     return 0;
 655 }
 656
 657 void default_unlink_name( struct object *obj, struct object_name *name )
 658 {
 659     list_remove( &name->entry );
 660 }
 661
 662 struct object *no_open_file( struct object *obj, unsigned int access, unsigned int sharing,
 663                              unsigned int options )
 664 {
 665     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 666     return NULL;
 667 }
 668
 669 int no_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
 670 {
 671     return 1;  /* ok to close */
 672 }
 673
 674 void no_destroy( struct object *obj )
 675 {
 676 }