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