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