Removed extraneous ERR message.
[wine] / server / object.c
1 /*
2  * Server-side objects
3  * These are the server equivalent of K32OBJ
4  *
5  * Copyright (C) 1998 Alexandre Julliard
6  */
7
8 #include <assert.h>
9 #include <limits.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <string.h>
13 #include <unistd.h>
14
15 #include "winerror.h"
16 #include "thread.h"
17 #include "unicode.h"
18
19 int debug_level = 0;
20
21 struct object_name
22 {
23     struct object_name *next;
24     struct object_name *prev;
25     struct object      *obj;
26     size_t              len;
27     WCHAR               name[1];
28 };
29
30 #define NAME_HASH_SIZE 37
31
32 static struct object_name *names[NAME_HASH_SIZE];
33
34 #ifdef DEBUG_OBJECTS
35 static struct object *first;
36
37 void dump_objects(void)
38 {
39     struct object *ptr = first;
40     while (ptr)
41     {
42         fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
43         ptr->ops->dump( ptr, 1 );
44         ptr = ptr->next;
45     }
46 }
47 #endif
48
49 /*****************************************************************/
50
51 /* malloc replacement */
52 void *mem_alloc( size_t size )
53 {
54     void *ptr = malloc( size );
55     if (ptr) memset( ptr, 0x55, size );
56     else if (current) set_error( ERROR_OUTOFMEMORY );
57     return ptr;
58 }
59
60 /* duplicate a block of memory */
61 void *memdup( const void *data, size_t len )
62 {
63     void *ptr = mem_alloc( len );
64     if (ptr) memcpy( ptr, data, len );
65     return ptr;
66 }
67
68
69 /*****************************************************************/
70
71 static int get_name_hash( const WCHAR *name, size_t len )
72 {
73     WCHAR hash = 0;
74     while (len--) hash ^= *name++;
75     return hash % NAME_HASH_SIZE;
76 }
77
78 /* allocate a name for an object */
79 static struct object_name *alloc_name( const WCHAR *name, size_t len )
80 {
81     struct object_name *ptr;
82
83     if ((ptr = mem_alloc( sizeof(*ptr) + len * sizeof(ptr->name[0]) )))
84     {
85         ptr->len = len;
86         memcpy( ptr->name, name, len * sizeof(ptr->name[0]) );
87         ptr->name[len] = 0;
88     }
89     return ptr;
90 }
91
92 /* free the name of an object */
93 static void free_name( struct object *obj )
94 {
95     struct object_name *ptr = obj->name;
96     if (ptr->next) ptr->next->prev = ptr->prev;
97     if (ptr->prev) ptr->prev->next = ptr->next;
98     else
99     {
100         int hash;
101         for (hash = 0; hash < NAME_HASH_SIZE; hash++)
102             if (names[hash] == ptr)
103             {
104                 names[hash] = ptr->next;
105                 break;
106             }
107     }
108     free( ptr );
109 }
110
111 /* set the name of an existing object */
112 static void set_object_name( struct object *obj, struct object_name *ptr )
113 {
114     int hash = get_name_hash( ptr->name, ptr->len );
115
116     if ((ptr->next = names[hash]) != NULL) ptr->next->prev = ptr;
117     ptr->obj = obj;
118     ptr->prev = NULL;
119     names[hash] = ptr;
120     assert( !obj->name );
121     obj->name = ptr;
122 }
123
124 /* allocate and initialize an object */
125 /* if the function fails the fd is closed */
126 void *alloc_object( const struct object_ops *ops, int fd )
127 {
128     struct object *obj = mem_alloc( ops->size );
129     if (obj)
130     {
131         obj->refcount = 1;
132         obj->fd       = fd;
133         obj->select   = -1;
134         obj->ops      = ops;
135         obj->head     = NULL;
136         obj->tail     = NULL;
137         obj->name     = NULL;
138         if ((fd != -1) && (add_select_user( obj ) == -1))
139         {
140             close( fd );
141             free( obj );
142             return NULL;
143         }
144 #ifdef DEBUG_OBJECTS
145         obj->prev = NULL;
146         if ((obj->next = first) != NULL) obj->next->prev = obj;
147         first = obj;
148 #endif
149         return obj;
150     }
151     if (fd != -1) close( fd );
152     return NULL;
153 }
154
155 void *create_named_object( const struct object_ops *ops, const WCHAR *name, size_t len )
156 {
157     struct object *obj;
158     struct object_name *name_ptr;
159
160     if (!name || !len) return alloc_object( ops, -1 );
161     if (!(name_ptr = alloc_name( name, len ))) return NULL;
162
163     if ((obj = find_object( name_ptr->name, name_ptr->len )))
164     {
165         free( name_ptr );  /* we no longer need it */
166         if (obj->ops == ops)
167         {
168             set_error( ERROR_ALREADY_EXISTS );
169             return obj;
170         }
171         set_error( ERROR_INVALID_HANDLE );
172         return NULL;
173     }
174     if ((obj = alloc_object( ops, -1 )))
175     {
176         set_object_name( obj, name_ptr );
177         clear_error();
178     }
179     else free( name_ptr );
180     return obj;
181 }
182
183 /* dump the name of an object to stderr */
184 void dump_object_name( struct object *obj )
185 {
186     if (!obj->name) fprintf( stderr, "name=\"\"" );
187     else
188     {
189         fprintf( stderr, "name=L\"" );
190         dump_strW( obj->name->name, strlenW(obj->name->name), stderr, "\"\"" );
191         fputc( '\"', stderr );
192     }
193 }
194
195 /* grab an object (i.e. increment its refcount) and return the object */
196 struct object *grab_object( void *ptr )
197 {
198     struct object *obj = (struct object *)ptr;
199     assert( obj->refcount < INT_MAX );
200     obj->refcount++;
201     return obj;
202 }
203
204 /* release an object (i.e. decrement its refcount) */
205 void release_object( void *ptr )
206 {
207     struct object *obj = (struct object *)ptr;
208     assert( obj->refcount );
209     if (!--obj->refcount)
210     {
211         /* if the refcount is 0, nobody can be in the wait queue */
212         assert( !obj->head );
213         assert( !obj->tail );
214         obj->ops->destroy( obj );
215         if (obj->name) free_name( obj );
216         if (obj->select != -1) remove_select_user( obj );
217         if (obj->fd != -1) close( obj->fd );
218 #ifdef DEBUG_OBJECTS
219         if (obj->next) obj->next->prev = obj->prev;
220         if (obj->prev) obj->prev->next = obj->next;
221         else first = obj->next;
222         memset( obj, 0xaa, obj->ops->size );
223 #endif
224         free( obj );
225     }
226 }
227
228 /* find an object by its name; the refcount is incremented */
229 struct object *find_object( const WCHAR *name, size_t len )
230 {
231     struct object_name *ptr;
232     if (!name || !len) return NULL;
233     for (ptr = names[ get_name_hash( name, len ) ]; ptr; ptr = ptr->next)
234     {
235         if (ptr->len != len) continue;
236         if (!memcmp( ptr->name, name, len*sizeof(WCHAR) )) return grab_object( ptr->obj );
237     }
238     return NULL;
239 }
240
241 /* functions for unimplemented/default object operations */
242
243 int no_add_queue( struct object *obj, struct wait_queue_entry *entry )
244 {
245     set_error( ERROR_INVALID_HANDLE );
246     return 0;
247 }
248
249 int no_satisfied( struct object *obj, struct thread *thread )
250 {
251     return 0;  /* not abandoned */
252 }
253
254 int no_read_fd( struct object *obj )
255 {
256     set_error( ERROR_INVALID_HANDLE );
257     return -1;
258 }
259
260 int no_write_fd( struct object *obj )
261 {
262     set_error( ERROR_INVALID_HANDLE );
263     return -1;
264 }
265
266 int no_flush( struct object *obj )
267 {
268     set_error( ERROR_INVALID_HANDLE );
269     return 0;
270 }
271
272 int no_get_file_info( struct object *obj, struct get_file_info_request *info )
273 {
274     set_error( ERROR_INVALID_HANDLE );
275     return 0;
276 }
277
278 void no_destroy( struct object *obj )
279 {
280 }
281
282 /* default add_queue() routine for objects that poll() on an fd */
283 int default_poll_add_queue( struct object *obj, struct wait_queue_entry *entry )
284 {
285     if (!obj->head)  /* first on the queue */
286         set_select_events( obj, obj->ops->get_poll_events( obj ) );
287     add_queue( obj, entry );
288     return 1;
289 }
290
291 /* default remove_queue() routine for objects that poll() on an fd */
292 void default_poll_remove_queue( struct object *obj, struct wait_queue_entry *entry )
293 {
294     grab_object(obj);
295     remove_queue( obj, entry );
296     if (!obj->head)  /* last on the queue is gone */
297         set_select_events( obj, 0 );
298     release_object( obj );
299 }
300
301 /* default signaled() routine for objects that poll() on an fd */
302 int default_poll_signaled( struct object *obj, struct thread *thread )
303 {
304     int events = obj->ops->get_poll_events( obj );
305
306     if (check_select_events( obj->fd, events ))
307     {
308         /* stop waiting on select() if we are signaled */
309         set_select_events( obj, 0 );
310         return 1;
311     }
312     /* restart waiting on select() if we are no longer signaled */
313     if (obj->head) set_select_events( obj, events );
314     return 0;
315 }
316
317 /* default handler for poll() events */
318 void default_poll_event( struct object *obj, int event )
319 {
320     /* an error occurred, stop polling this fd to avoid busy-looping */
321     if (event & (POLLERR | POLLHUP)) set_select_events( obj, -1 );
322     wake_up( obj, 0 );
323 }