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