wintrust: Add missing prototypes and a missing include directive to mscat.h.
[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;
294     struct list *p;
295
296     if (!name || !name->len) return NULL;
297
298     list = &namespace->names[ get_name_hash( namespace, name->str, name->len ) ];
299     LIST_FOR_EACH( p, list )
300     {
301         const struct object_name *ptr = LIST_ENTRY( p, struct object_name, entry );
302         if (ptr->len != name->len) continue;
303         if (attributes & OBJ_CASE_INSENSITIVE)
304         {
305             if (!strncmpiW( ptr->name, name->str, name->len/sizeof(WCHAR) ))
306                 return grab_object( ptr->obj );
307         }
308         else
309         {
310             if (!memcmp( ptr->name, name->str, name->len ))
311                 return grab_object( ptr->obj );
312         }
313     }
314     return NULL;
315 }
316
317 /* allocate a namespace */
318 struct namespace *create_namespace( unsigned int hash_size )
319 {
320     struct namespace *namespace;
321     unsigned int i;
322
323     namespace = mem_alloc( sizeof(*namespace) + (hash_size - 1) * sizeof(namespace->names[0]) );
324     if (namespace)
325     {
326         namespace->hash_size      = hash_size;
327         for (i = 0; i < hash_size; i++) list_init( &namespace->names[i] );
328     }
329     return namespace;
330 }
331
332 /* functions for unimplemented/default object operations */
333
334 int no_add_queue( struct object *obj, struct wait_queue_entry *entry )
335 {
336     set_error( STATUS_OBJECT_TYPE_MISMATCH );
337     return 0;
338 }
339
340 int no_satisfied( struct object *obj, struct thread *thread )
341 {
342     return 0;  /* not abandoned */
343 }
344
345 int no_signal( struct object *obj, unsigned int access )
346 {
347     set_error( STATUS_OBJECT_TYPE_MISMATCH );
348     return 0;
349 }
350
351 struct fd *no_get_fd( struct object *obj )
352 {
353     set_error( STATUS_OBJECT_TYPE_MISMATCH );
354     return NULL;
355 }
356
357 unsigned int no_map_access( struct object *obj, unsigned int access )
358 {
359     if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ;
360     if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE;
361     if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
362     if (access & GENERIC_ALL)     access |= STANDARD_RIGHTS_ALL;
363     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
364 }
365
366 struct object *no_lookup_name( struct object *obj, struct unicode_str *name,
367                                unsigned int attr )
368 {
369     return NULL;
370 }
371
372 int no_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
373 {
374     return 1;  /* ok to close */
375 }
376
377 void no_destroy( struct object *obj )
378 {
379 }