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 object_name
44 {
45 struct list entry; /* entry in the hash list */
46 struct object *obj; /* object owning this name */
47 struct object *parent; /* parent object */
48 data_size_t len; /* name length in bytes */
49 WCHAR name[1];
50 };
51
52 struct namespace
53 {
54 unsigned int hash_size; /* size of hash table */
55 struct list names[1]; /* array of hash entry lists */
56 };
57
58
59 #ifdef DEBUG_OBJECTS
60 static struct list object_list = LIST_INIT(object_list);
61 static struct list static_object_list = LIST_INIT(static_object_list);
62
63 void dump_objects(void)
64 {
65 struct list *p;
66
67 LIST_FOR_EACH( p, &static_object_list )
68 {
69 struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
70 fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
71 ptr->ops->dump( ptr, 1 );
72 }
73 LIST_FOR_EACH( p, &object_list )
74 {
75 struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
76 fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
77 ptr->ops->dump( ptr, 1 );
78 }
79 }
80
81 void close_objects(void)
82 {
83 struct list *ptr;
84
85 /* release the static objects */
86 while ((ptr = list_head( &static_object_list )))
87 {
88 struct object *obj = LIST_ENTRY( ptr, struct object, obj_list );
89 /* move it back to the standard list before freeing */
90 list_remove( &obj->obj_list );
91 list_add_head( &object_list, &obj->obj_list );
92 release_object( obj );
93 }
94
95 dump_objects(); /* dump any remaining objects */
96 }
97
98 #endif /* DEBUG_OBJECTS */
99
100 /*****************************************************************/
101
102 /* malloc replacement */
103 void *mem_alloc( size_t size )
104 {
105 void *ptr = malloc( size );
106 if (ptr) memset( ptr, 0x55, size );
107 else set_error( STATUS_NO_MEMORY );
108 return ptr;
109 }
110
111 /* duplicate a block of memory */
112 void *memdup( const void *data, size_t len )
113 {
114 void *ptr = malloc( len );
115 if (ptr) memcpy( ptr, data, len );
116 else set_error( STATUS_NO_MEMORY );
117 return ptr;
118 }
119
120
121 /*****************************************************************/
122
123 static int get_name_hash( const struct namespace *namespace, const WCHAR *name, data_size_t len )
124 {
125 WCHAR hash = 0;
126 len /= sizeof(WCHAR);
127 while (len--) hash ^= tolowerW(*name++);
128 return hash % namespace->hash_size;
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 /* free the name of an object */
146 static void free_name( struct object *obj )
147 {
148 struct object_name *ptr = obj->name;
149 list_remove( &ptr->entry );
150 if (ptr->parent) release_object( ptr->parent );
151 free( ptr );
152 }
153
154 /* set the name of an existing object */
155 static void set_object_name( struct namespace *namespace,
156 struct object *obj, struct object_name *ptr )
157 {
158 int hash = get_name_hash( namespace, ptr->name, ptr->len );
159
160 list_add_head( &namespace->names[hash], &ptr->entry );
161 ptr->obj = obj;
162 obj->name = ptr;
163 }
164
165 /* get the name of an existing object */
166 const WCHAR *get_object_name( struct object *obj, data_size_t *len )
167 {
168 struct object_name *ptr = obj->name;
169 if (!ptr) return NULL;
170 *len = ptr->len;
171 return ptr->name;
172 }
173
174 /* get the full path name of an existing object */
175 WCHAR *get_object_full_name( struct object *obj, data_size_t *ret_len )
176 {
177 static const WCHAR backslash = '\\';
178 struct object *ptr = obj;
179 data_size_t len = 0;
180 char *ret;
181
182 while (ptr && ptr->name)
183 {
184 struct object_name *name = ptr->name;
185 len += name->len + sizeof(WCHAR);
186 ptr = name->parent;
187 }
188 if (!len) return NULL;
189 if (!(ret = malloc( len ))) return NULL;
190
191 *ret_len = len;
192 while (obj && obj->name)
193 {
194 struct object_name *name = obj->name;
195 memcpy( ret + len - name->len, name->name, name->len );
196 len -= name->len + sizeof(WCHAR);
197 memcpy( ret + len, &backslash, sizeof(WCHAR) );
198 obj = name->parent;
199 }
200 return (WCHAR *)ret;
201 }
202
203 /* allocate and initialize an object */
204 void *alloc_object( const struct object_ops *ops )
205 {
206 struct object *obj = mem_alloc( ops->size );
207 if (obj)
208 {
209 obj->refcount = 1;
210 obj->ops = ops;
211 obj->name = NULL;
212 obj->sd = NULL;
213 list_init( &obj->wait_queue );
214 #ifdef DEBUG_OBJECTS
215 list_add_head( &object_list, &obj->obj_list );
216 #endif
217 return obj;
218 }
219 return NULL;
220 }
221
222 void *create_object( struct namespace *namespace, const struct object_ops *ops,
223 const struct unicode_str *name, struct object *parent )
224 {
225 struct object *obj;
226 struct object_name *name_ptr;
227
228 if (!(name_ptr = alloc_name( name ))) return NULL;
229 if ((obj = alloc_object( ops )))
230 {
231 set_object_name( namespace, obj, name_ptr );
232 if (parent) name_ptr->parent = grab_object( parent );
233 }
234 else
235 free( name_ptr );
236 return obj;
237 }
238
239 void *create_named_object( struct namespace *namespace, const struct object_ops *ops,
240 const struct unicode_str *name, unsigned int attributes )
241 {
242 struct object *obj;
243
244 if (!name || !name->len) return alloc_object( ops );
245
246 if ((obj = find_object( namespace, name, attributes )))
247 {
248 if (attributes & OBJ_OPENIF && obj->ops == ops)
249 set_error( STATUS_OBJECT_NAME_EXISTS );
250 else
251 {
252 release_object( obj );
253 obj = NULL;
254 if (attributes & OBJ_OPENIF)
255 set_error( STATUS_OBJECT_TYPE_MISMATCH );
256 else
257 set_error( STATUS_OBJECT_NAME_COLLISION );
258 }
259 return obj;
260 }
261 if ((obj = create_object( namespace, ops, name, NULL ))) clear_error();
262 return obj;
263 }
264
265 /* dump the name of an object to stderr */
266 void dump_object_name( struct object *obj )
267 {
268 if (!obj->name) fprintf( stderr, "name=\"\"" );
269 else
270 {
271 fprintf( stderr, "name=L\"" );
272 dump_strW( obj->name->name, obj->name->len/sizeof(WCHAR), stderr, "\"\"" );
273 fputc( '\"', stderr );
274 }
275 }
276
277 /* unlink a named object from its namespace, without freeing the object itself */
278 void unlink_named_object( struct object *obj )
279 {
280 if (obj->name) free_name( obj );
281 obj->name = NULL;
282 }
283
284 /* mark an object as being stored statically, i.e. only released at shutdown */
285 void make_object_static( struct object *obj )
286 {
287 #ifdef DEBUG_OBJECTS
288 list_remove( &obj->obj_list );
289 list_add_head( &static_object_list, &obj->obj_list );
290 #endif
291 }
292
293 /* grab an object (i.e. increment its refcount) and return the object */
294 struct object *grab_object( void *ptr )
295 {
296 struct object *obj = (struct object *)ptr;
297 assert( obj->refcount < INT_MAX );
298 obj->refcount++;
299 return obj;
300 }
301
302 /* release an object (i.e. decrement its refcount) */
303 void release_object( void *ptr )
304 {
305 struct object *obj = (struct object *)ptr;
306 assert( obj->refcount );
307 if (!--obj->refcount)
308 {
309 /* if the refcount is 0, nobody can be in the wait queue */
310 assert( list_empty( &obj->wait_queue ));
311 obj->ops->destroy( obj );
312 if (obj->name) free_name( obj );
313 free( obj->sd );
314 #ifdef DEBUG_OBJECTS
315 list_remove( &obj->obj_list );
316 memset( obj, 0xaa, obj->ops->size );
317 #endif
318 free( obj );
319 }
320 }
321
322 /* find an object by its name; the refcount is incremented */
323 struct object *find_object( const struct namespace *namespace, const struct unicode_str *name,
324 unsigned int attributes )
325 {
326 const struct list *list;
327 struct list *p;
328
329 if (!name || !name->len) return NULL;
330
331 list = &namespace->names[ get_name_hash( namespace, name->str, name->len ) ];
332 LIST_FOR_EACH( p, list )
333 {
334 const struct object_name *ptr = LIST_ENTRY( p, struct object_name, entry );
335 if (ptr->len != name->len) continue;
336 if (attributes & OBJ_CASE_INSENSITIVE)
337 {
338 if (!strncmpiW( ptr->name, name->str, name->len/sizeof(WCHAR) ))
339 return grab_object( ptr->obj );
340 }
341 else
342 {
343 if (!memcmp( ptr->name, name->str, name->len ))
344 return grab_object( ptr->obj );
345 }
346 }
347 return NULL;
348 }
349
350 /* find an object by its index; the refcount is incremented */
351 struct object *find_object_index( const struct namespace *namespace, unsigned int index )
352 {
353 unsigned int i;
354
355 /* FIXME: not efficient at all */
356 for (i = 0; i < namespace->hash_size; i++)
357 {
358 const struct object_name *ptr;
359 LIST_FOR_EACH_ENTRY( ptr, &namespace->names[i], const struct object_name, entry )
360 {
361 if (!index--) return grab_object( ptr->obj );
362 }
363 }
364 set_error( STATUS_NO_MORE_ENTRIES );
365 return NULL;
366 }
367
368 /* allocate a namespace */
369 struct namespace *create_namespace( unsigned int hash_size )
370 {
371 struct namespace *namespace;
372 unsigned int i;
373
374 namespace = mem_alloc( sizeof(*namespace) + (hash_size - 1) * sizeof(namespace->names[0]) );
375 if (namespace)
376 {
377 namespace->hash_size = hash_size;
378 for (i = 0; i < hash_size; i++) list_init( &namespace->names[i] );
379 }
380 return namespace;
381 }
382
383 /* functions for unimplemented/default object operations */
384
385 struct object_type *no_get_type( struct object *obj )
386 {
387 return NULL;
388 }
389
390 int no_add_queue( struct object *obj, struct wait_queue_entry *entry )
391 {
392 set_error( STATUS_OBJECT_TYPE_MISMATCH );
393 return 0;
394 }
395
396 int no_satisfied( struct object *obj, struct thread *thread )
397 {
398 return 0; /* not abandoned */
399 }
400
401 int no_signal( struct object *obj, unsigned int access )
402 {
403 set_error( STATUS_OBJECT_TYPE_MISMATCH );
404 return 0;
405 }
406
407 struct fd *no_get_fd( struct object *obj )
408 {
409 set_error( STATUS_OBJECT_TYPE_MISMATCH );
410 return NULL;
411 }
412
413 unsigned int no_map_access( struct object *obj, unsigned int access )
414 {
415 if (access & GENERIC_READ) access |= STANDARD_RIGHTS_READ;
416 if (access & GENERIC_WRITE) access |= STANDARD_RIGHTS_WRITE;
417 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
418 if (access & GENERIC_ALL) access |= STANDARD_RIGHTS_ALL;
419 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
420 }
421
422 struct security_descriptor *default_get_sd( struct object *obj )
423 {
424 return obj->sd;
425 }
426
427 int default_set_sd( struct object *obj, const struct security_descriptor *sd,
428 unsigned int set_info )
429 {
430 struct security_descriptor new_sd, *new_sd_ptr;
431 int present;
432 const SID *owner, *group;
433 const ACL *sacl, *dacl;
434 char *ptr;
435
436 if (!set_info) return 1;
437
438 new_sd.control = sd->control & ~SE_SELF_RELATIVE;
439
440 owner = sd_get_owner( sd );
441 if (set_info & OWNER_SECURITY_INFORMATION && owner)
442 new_sd.owner_len = sd->owner_len;
443 else
444 {
445 owner = token_get_user( current->process->token );
446 new_sd.owner_len = FIELD_OFFSET(SID, SubAuthority[owner->SubAuthorityCount]);
447 new_sd.control |= SE_OWNER_DEFAULTED;
448 }
449
450 group = sd_get_group( sd );
451 if (set_info & GROUP_SECURITY_INFORMATION && group)
452 new_sd.group_len = sd->group_len;
453 else
454 {
455 group = token_get_primary_group( current->process->token );
456 new_sd.group_len = FIELD_OFFSET(SID, SubAuthority[group->SubAuthorityCount]);
457 new_sd.control |= SE_GROUP_DEFAULTED;
458 }
459
460 new_sd.control |= SE_SACL_PRESENT;
461 sacl = sd_get_sacl( sd, &present );
462 if (set_info & SACL_SECURITY_INFORMATION && present)
463 new_sd.sacl_len = sd->sacl_len;
464 else
465 {
466 if (obj->sd) sacl = sd_get_sacl( obj->sd, &present );
467
468 if (obj->sd && present)
469 new_sd.sacl_len = obj->sd->sacl_len;
470 else
471 {
472 new_sd.sacl_len = 0;
473 new_sd.control |= SE_SACL_DEFAULTED;
474 }
475 }
476
477 new_sd.control |= SE_DACL_PRESENT;
478 dacl = sd_get_dacl( sd, &present );
479 if (set_info & DACL_SECURITY_INFORMATION && present)
480 new_sd.dacl_len = sd->dacl_len;
481 else
482 {
483 if (obj->sd) dacl = sd_get_dacl( obj->sd, &present );
484
485 if (obj->sd && present)
486 new_sd.dacl_len = obj->sd->dacl_len;
487 else
488 {
489 dacl = token_get_default_dacl( current->process->token );
490 new_sd.dacl_len = dacl->AclSize;
491 new_sd.control |= SE_DACL_DEFAULTED;
492 }
493 }
494
495 ptr = mem_alloc( sizeof(new_sd) + new_sd.owner_len + new_sd.group_len +
496 new_sd.sacl_len + new_sd.dacl_len );
497 if (!ptr) return 0;
498 new_sd_ptr = (struct security_descriptor*)ptr;
499
500 memcpy( ptr, &new_sd, sizeof(new_sd) );
501 ptr += sizeof(new_sd);
502 memcpy( ptr, owner, new_sd.owner_len );
503 ptr += new_sd.owner_len;
504 memcpy( ptr, group, new_sd.group_len );
505 ptr += new_sd.group_len;
506 memcpy( ptr, sacl, new_sd.sacl_len );
507 ptr += new_sd.sacl_len;
508 memcpy( ptr, dacl, new_sd.dacl_len );
509
510 free( obj->sd );
511 obj->sd = new_sd_ptr;
512 return 1;
513 }
514
515 struct object *no_lookup_name( struct object *obj, struct unicode_str *name,
516 unsigned int attr )
517 {
518 return NULL;
519 }
520
521 struct object *no_open_file( struct object *obj, unsigned int access, unsigned int sharing,
522 unsigned int options )
523 {
524 set_error( STATUS_OBJECT_TYPE_MISMATCH );
525 return NULL;
526 }
527
528 int no_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
529 {
530 return 1; /* ok to close */
531 }
532
533 void no_destroy( struct object *obj )
534 {
535 }
536
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.