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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "thread.h"
  38 #include "unicode.h"
  39
  40
  41 struct object_name
  42 {
  43     struct list         entry;           /* entry in the hash list */
  44     struct object      *obj;             /* object owning this name */
  45     struct object      *parent;          /* parent object */
  46     size_t              len;             /* name length in bytes */
  47     WCHAR               name[1];
  48 };
  49
  50 struct namespace
  51 {
  52     unsigned int        hash_size;       /* size of hash table */
  53     struct list         names[1];        /* array of hash entry lists */
  54 };
  55
  56
  57 #ifdef DEBUG_OBJECTS
  58 static struct list object_list = LIST_INIT(object_list);
  59
  60 void dump_objects(void)
  61 {
  62     struct list *p;
  63
  64     LIST_FOR_EACH( p, &object_list )
  65     {
  66         struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
  67         fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
  68         ptr->ops->dump( ptr, 1 );
  69     }
  70 }
  71 #endif
  72
  73 /*****************************************************************/
  74
  75 /* malloc replacement */
  76 void *mem_alloc( size_t size )
  77 {
  78     void *ptr = malloc( size );
  79     if (ptr) memset( ptr, 0x55, size );
  80     else set_error( STATUS_NO_MEMORY );
  81     return ptr;
  82 }
  83
  84 /* duplicate a block of memory */
  85 void *memdup( const void *data, size_t len )
  86 {
  87     void *ptr = malloc( len );
  88     if (ptr) memcpy( ptr, data, len );
  89     else set_error( STATUS_NO_MEMORY );
  90     return ptr;
  91 }
  92
  93
  94 /*****************************************************************/
  95
  96 static int get_name_hash( const struct namespace *namespace, const WCHAR *name, size_t len )
  97 {
  98     WCHAR hash = 0;
  99     len /= sizeof(WCHAR);
 100     while (len--) hash ^= tolowerW(*name++);
 101     return hash % namespace->hash_size;
 102 }
 103
 104 /* allocate a name for an object */
 105 static struct object_name *alloc_name( const struct unicode_str *name )
 106 {
 107     struct object_name *ptr;
 108
 109     if ((ptr = mem_alloc( sizeof(*ptr) + name->len - sizeof(ptr->name) )))
 110     {
 111         ptr->len = name->len;
 112         ptr->parent = NULL;
 113         memcpy( ptr->name, name->str, name->len );
 114     }
 115     return ptr;
 116 }
 117
 118 /* free the name of an object */
 119 static void free_name( struct object *obj )
 120 {
 121     struct object_name *ptr = obj->name;
 122     list_remove( &ptr->entry );
 123     if (ptr->parent) release_object( ptr->parent );
 124     free( ptr );
 125 }
 126
 127 /* set the name of an existing object */
 128 static void set_object_name( struct namespace *namespace,
 129                              struct object *obj, struct object_name *ptr )
 130 {
 131     int hash = get_name_hash( namespace, ptr->name, ptr->len );
 132
 133     list_add_head( &namespace->names[hash], &ptr->entry );
 134     ptr->obj = obj;
 135     obj->name = ptr;
 136 }
 137
 138 /* get the name of an existing object */
 139 const WCHAR *get_object_name( struct object *obj, size_t *len )
 140 {
 141     struct object_name *ptr = obj->name;
 142     if (!ptr) return NULL;
 143     *len = ptr->len;
 144     return ptr->name;
 145 }
 146
 147 /* allocate and initialize an object */
 148 void *alloc_object( const struct object_ops *ops )
 149 {
 150     struct object *obj = mem_alloc( ops->size );
 151     if (obj)
 152     {
 153         obj->refcount = 1;
 154         obj->ops      = ops;
 155         obj->name     = NULL;
 156         list_init( &obj->wait_queue );
 157 #ifdef DEBUG_OBJECTS
 158         list_add_head( &object_list, &obj->obj_list );
 159 #endif
 160         return obj;
 161     }
 162     return NULL;
 163 }
 164
 165 void *create_object( struct namespace *namespace, const struct object_ops *ops,
 166                      const struct unicode_str *name, struct object *parent )
 167 {
 168     struct object *obj;
 169     struct object_name *name_ptr;
 170
 171     if (!(name_ptr = alloc_name( name ))) return NULL;
 172     if ((obj = alloc_object( ops )))
 173     {
 174         set_object_name( namespace, obj, name_ptr );
 175         if (parent) name_ptr->parent = grab_object( parent );
 176     }
 177     else
 178         free( name_ptr );
 179     return obj;
 180 }
 181
 182 void *create_named_object( struct namespace *namespace, const struct object_ops *ops,
 183                            const struct unicode_str *name, unsigned int attributes )
 184 {
 185     struct object *obj;
 186
 187     if (!name || !name->len) return alloc_object( ops );
 188
 189     if ((obj = find_object( namespace, name, attributes )))
 190     {
 191         if (attributes & OBJ_OPENIF && obj->ops == ops)
 192             set_error( STATUS_OBJECT_NAME_EXISTS );
 193         else
 194         {
 195             release_object( obj );
 196             obj = NULL;
 197             if (attributes & OBJ_OPENIF)
 198                 set_error( STATUS_OBJECT_TYPE_MISMATCH );
 199             else
 200                 set_error( STATUS_OBJECT_NAME_COLLISION );
 201         }
 202         return obj;
 203     }
 204     if ((obj = create_object( namespace, ops, name, NULL ))) clear_error();
 205     return obj;
 206 }
 207
 208 /* dump the name of an object to stderr */
 209 void dump_object_name( struct object *obj )
 210 {
 211     if (!obj->name) fprintf( stderr, "name=\"\"" );
 212     else
 213     {
 214         fprintf( stderr, "name=L\"" );
 215         dump_strW( obj->name->name, obj->name->len/sizeof(WCHAR), stderr, "\"\"" );
 216         fputc( '\"', stderr );
 217     }
 218 }
 219
 220 /* grab an object (i.e. increment its refcount) and return the object */
 221 struct object *grab_object( void *ptr )
 222 {
 223     struct object *obj = (struct object *)ptr;
 224     assert( obj->refcount < INT_MAX );
 225     obj->refcount++;
 226     return obj;
 227 }
 228
 229 /* release an object (i.e. decrement its refcount) */
 230 void release_object( void *ptr )
 231 {
 232     struct object *obj = (struct object *)ptr;
 233     assert( obj->refcount );
 234     if (!--obj->refcount)
 235     {
 236         /* if the refcount is 0, nobody can be in the wait queue */
 237         assert( list_empty( &obj->wait_queue ));
 238         obj->ops->destroy( obj );
 239         if (obj->name) free_name( obj );
 240 #ifdef DEBUG_OBJECTS
 241         list_remove( &obj->obj_list );
 242         memset( obj, 0xaa, obj->ops->size );
 243 #endif
 244         free( obj );
 245     }
 246 }
 247
 248 /* find an object by its name; the refcount is incremented */
 249 struct object *find_object( const struct namespace *namespace, const struct unicode_str *name,
 250                             unsigned int attributes )
 251 {
 252     const struct list *list, *p;
 253
 254     if (!name || !name->len) return NULL;
 255
 256     list = &namespace->names[ get_name_hash( namespace, name->str, name->len ) ];
 257     LIST_FOR_EACH( p, list )
 258     {
 259         const struct object_name *ptr = LIST_ENTRY( p, const struct object_name, entry );
 260         if (ptr->len != name->len) continue;
 261         if (attributes & OBJ_CASE_INSENSITIVE)
 262         {
 263             if (!strncmpiW( ptr->name, name->str, name->len/sizeof(WCHAR) ))
 264                 return grab_object( ptr->obj );
 265         }
 266         else
 267         {
 268             if (!memcmp( ptr->name, name->str, name->len ))
 269                 return grab_object( ptr->obj );
 270         }
 271     }
 272     return NULL;
 273 }
 274
 275 /* allocate a namespace */
 276 struct namespace *create_namespace( unsigned int hash_size )
 277 {
 278     struct namespace *namespace;
 279     unsigned int i;
 280
 281     namespace = mem_alloc( sizeof(*namespace) + (hash_size - 1) * sizeof(namespace->names[0]) );
 282     if (namespace)
 283     {
 284         namespace->hash_size      = hash_size;
 285         for (i = 0; i < hash_size; i++) list_init( &namespace->names[i] );
 286     }
 287     return namespace;
 288 }
 289
 290 /* functions for unimplemented/default object operations */
 291
 292 int no_add_queue( struct object *obj, struct wait_queue_entry *entry )
 293 {
 294     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 295     return 0;
 296 }
 297
 298 int no_satisfied( struct object *obj, struct thread *thread )
 299 {
 300     return 0;  /* not abandoned */
 301 }
 302
 303 int no_signal( struct object *obj, unsigned int access )
 304 {
 305     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 306     return 0;
 307 }
 308
 309 struct fd *no_get_fd( struct object *obj )
 310 {
 311     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 312     return NULL;
 313 }
 314
 315 unsigned int no_map_access( struct object *obj, unsigned int access )
 316 {
 317     if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ;
 318     if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE;
 319     if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
 320     if (access & GENERIC_ALL)     access |= STANDARD_RIGHTS_ALL;
 321     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
 322 }
 323
 324 struct object *no_lookup_name( struct object *obj, struct unicode_str *name,
 325                                unsigned int attr )
 326 {
 327     return NULL;
 328 }
 329
 330 int no_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
 331 {
 332     return 1;  /* ok to close */
 333 }
 334
 335 void no_destroy( struct object *obj )
 336 {
 337 }