gdiplus: Changed the way the direction of the endcap is calculated to make LineCapArr...
[wine/multimedia.git] / server / object.c
blob7f44b71ed1df433309511a5e9afe2763d5c3fc0e
1 /*
2 * Server-side objects
4 * Copyright (C) 1998 Alexandre Julliard
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.
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.
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
21 #include "config.h"
22 #include "wine/port.h"
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>
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "winternl.h"
36 #include "file.h"
37 #include "thread.h"
38 #include "unicode.h"
41 struct object_name
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];
50 struct namespace
52 unsigned int hash_size; /* size of hash table */
53 struct list names[1]; /* array of hash entry lists */
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);
61 void dump_objects(void)
63 struct list *p;
65 LIST_FOR_EACH( p, &static_object_list )
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 );
71 LIST_FOR_EACH( p, &object_list )
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 );
79 void close_objects(void)
81 struct list *ptr;
83 /* release the static objects */
84 while ((ptr = list_head( &static_object_list )))
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 );
93 dump_objects(); /* dump any remaining objects */
96 #endif /* DEBUG_OBJECTS */
98 /*****************************************************************/
100 /* malloc replacement */
101 void *mem_alloc( size_t size )
103 void *ptr = malloc( size );
104 if (ptr) memset( ptr, 0x55, size );
105 else set_error( STATUS_NO_MEMORY );
106 return ptr;
109 /* duplicate a block of memory */
110 void *memdup( const void *data, size_t len )
112 void *ptr = malloc( len );
113 if (ptr) memcpy( ptr, data, len );
114 else set_error( STATUS_NO_MEMORY );
115 return ptr;
119 /*****************************************************************/
121 static int get_name_hash( const struct namespace *namespace, const WCHAR *name, data_size_t len )
123 WCHAR hash = 0;
124 len /= sizeof(WCHAR);
125 while (len--) hash ^= tolowerW(*name++);
126 return hash % namespace->hash_size;
129 /* allocate a name for an object */
130 static struct object_name *alloc_name( const struct unicode_str *name )
132 struct object_name *ptr;
134 if ((ptr = mem_alloc( sizeof(*ptr) + name->len - sizeof(ptr->name) )))
136 ptr->len = name->len;
137 ptr->parent = NULL;
138 memcpy( ptr->name, name->str, name->len );
140 return ptr;
143 /* free the name of an object */
144 static void free_name( struct object *obj )
146 struct object_name *ptr = obj->name;
147 list_remove( &ptr->entry );
148 if (ptr->parent) release_object( ptr->parent );
149 free( ptr );
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 )
156 int hash = get_name_hash( namespace, ptr->name, ptr->len );
158 list_add_head( &namespace->names[hash], &ptr->entry );
159 ptr->obj = obj;
160 obj->name = ptr;
163 /* get the name of an existing object */
164 const WCHAR *get_object_name( struct object *obj, data_size_t *len )
166 struct object_name *ptr = obj->name;
167 if (!ptr) return NULL;
168 *len = ptr->len;
169 return ptr->name;
172 /* allocate and initialize an object */
173 void *alloc_object( const struct object_ops *ops )
175 struct object *obj = mem_alloc( ops->size );
176 if (obj)
178 obj->refcount = 1;
179 obj->ops = ops;
180 obj->name = NULL;
181 obj->sd = NULL;
182 list_init( &obj->wait_queue );
183 #ifdef DEBUG_OBJECTS
184 list_add_head( &object_list, &obj->obj_list );
185 #endif
186 return obj;
188 return NULL;
191 void *create_object( struct namespace *namespace, const struct object_ops *ops,
192 const struct unicode_str *name, struct object *parent )
194 struct object *obj;
195 struct object_name *name_ptr;
197 if (!(name_ptr = alloc_name( name ))) return NULL;
198 if ((obj = alloc_object( ops )))
200 set_object_name( namespace, obj, name_ptr );
201 if (parent) name_ptr->parent = grab_object( parent );
203 else
204 free( name_ptr );
205 return obj;
208 void *create_named_object( struct namespace *namespace, const struct object_ops *ops,
209 const struct unicode_str *name, unsigned int attributes )
211 struct object *obj;
213 if (!name || !name->len) return alloc_object( ops );
215 if ((obj = find_object( namespace, name, attributes )))
217 if (attributes & OBJ_OPENIF && obj->ops == ops)
218 set_error( STATUS_OBJECT_NAME_EXISTS );
219 else
221 release_object( obj );
222 obj = NULL;
223 if (attributes & OBJ_OPENIF)
224 set_error( STATUS_OBJECT_TYPE_MISMATCH );
225 else
226 set_error( STATUS_OBJECT_NAME_COLLISION );
228 return obj;
230 if ((obj = create_object( namespace, ops, name, NULL ))) clear_error();
231 return obj;
234 /* dump the name of an object to stderr */
235 void dump_object_name( struct object *obj )
237 if (!obj->name) fprintf( stderr, "name=\"\"" );
238 else
240 fprintf( stderr, "name=L\"" );
241 dump_strW( obj->name->name, obj->name->len/sizeof(WCHAR), stderr, "\"\"" );
242 fputc( '\"', stderr );
246 /* unlink a named object from its namespace, without freeing the object itself */
247 void unlink_named_object( struct object *obj )
249 if (obj->name) free_name( obj );
250 obj->name = NULL;
253 /* mark an object as being stored statically, i.e. only released at shutdown */
254 void make_object_static( struct object *obj )
256 #ifdef DEBUG_OBJECTS
257 list_remove( &obj->obj_list );
258 list_add_head( &static_object_list, &obj->obj_list );
259 #endif
262 /* grab an object (i.e. increment its refcount) and return the object */
263 struct object *grab_object( void *ptr )
265 struct object *obj = (struct object *)ptr;
266 assert( obj->refcount < INT_MAX );
267 obj->refcount++;
268 return obj;
271 /* release an object (i.e. decrement its refcount) */
272 void release_object( void *ptr )
274 struct object *obj = (struct object *)ptr;
275 assert( obj->refcount );
276 if (!--obj->refcount)
278 /* if the refcount is 0, nobody can be in the wait queue */
279 assert( list_empty( &obj->wait_queue ));
280 obj->ops->destroy( obj );
281 if (obj->name) free_name( obj );
282 free( obj->sd );
283 #ifdef DEBUG_OBJECTS
284 list_remove( &obj->obj_list );
285 memset( obj, 0xaa, obj->ops->size );
286 #endif
287 free( obj );
291 /* find an object by its name; the refcount is incremented */
292 struct object *find_object( const struct namespace *namespace, const struct unicode_str *name,
293 unsigned int attributes )
295 const struct list *list;
296 struct list *p;
298 if (!name || !name->len) return NULL;
300 list = &namespace->names[ get_name_hash( namespace, name->str, name->len ) ];
301 LIST_FOR_EACH( p, list )
303 const struct object_name *ptr = LIST_ENTRY( p, struct object_name, entry );
304 if (ptr->len != name->len) continue;
305 if (attributes & OBJ_CASE_INSENSITIVE)
307 if (!strncmpiW( ptr->name, name->str, name->len/sizeof(WCHAR) ))
308 return grab_object( ptr->obj );
310 else
312 if (!memcmp( ptr->name, name->str, name->len ))
313 return grab_object( ptr->obj );
316 return NULL;
319 /* allocate a namespace */
320 struct namespace *create_namespace( unsigned int hash_size )
322 struct namespace *namespace;
323 unsigned int i;
325 namespace = mem_alloc( sizeof(*namespace) + (hash_size - 1) * sizeof(namespace->names[0]) );
326 if (namespace)
328 namespace->hash_size = hash_size;
329 for (i = 0; i < hash_size; i++) list_init( &namespace->names[i] );
331 return namespace;
334 /* functions for unimplemented/default object operations */
336 int no_add_queue( struct object *obj, struct wait_queue_entry *entry )
338 set_error( STATUS_OBJECT_TYPE_MISMATCH );
339 return 0;
342 int no_satisfied( struct object *obj, struct thread *thread )
344 return 0; /* not abandoned */
347 int no_signal( struct object *obj, unsigned int access )
349 set_error( STATUS_OBJECT_TYPE_MISMATCH );
350 return 0;
353 struct fd *no_get_fd( struct object *obj )
355 set_error( STATUS_OBJECT_TYPE_MISMATCH );
356 return NULL;
359 unsigned int no_map_access( struct object *obj, unsigned int access )
361 if (access & GENERIC_READ) access |= STANDARD_RIGHTS_READ;
362 if (access & GENERIC_WRITE) access |= STANDARD_RIGHTS_WRITE;
363 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
364 if (access & GENERIC_ALL) access |= STANDARD_RIGHTS_ALL;
365 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
368 struct object *no_lookup_name( struct object *obj, struct unicode_str *name,
369 unsigned int attr )
371 return NULL;
374 struct object *no_open_file( struct object *obj, unsigned int access, unsigned int sharing,
375 unsigned int options )
377 set_error( STATUS_OBJECT_TYPE_MISMATCH );
378 return NULL;
381 int no_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
383 return 1; /* ok to close */
386 void no_destroy( struct object *obj )