gdiplus: Alphabetized header.
[wine] / server / atom.c
1 /*
2  * Server-side atom management
3  *
4  * Copyright (C) 1999, 2000 Alexandre Julliard
5  * Copyright (C) 2000 Turchanov Sergei
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32
33 #include "unicode.h"
34 #include "request.h"
35 #include "object.h"
36 #include "process.h"
37 #include "handle.h"
38 #include "user.h"
39 #include "winuser.h"
40 #include "winternl.h"
41
42 #define HASH_SIZE     37
43 #define MIN_HASH_SIZE 4
44 #define MAX_HASH_SIZE 0x200
45
46 #define MAX_ATOM_LEN  255
47 #define MIN_STR_ATOM  0xc000
48 #define MAX_ATOMS     0x4000
49
50 struct atom_entry
51 {
52     struct atom_entry *next;   /* hash table list */
53     struct atom_entry *prev;   /* hash table list */
54     int                count;  /* reference count */
55     short              pinned; /* whether the atom is pinned or not */
56     atom_t             atom;   /* atom handle */
57     unsigned short     hash;   /* string hash */
58     unsigned short     len;    /* string len */
59     WCHAR              str[1]; /* atom string */
60 };
61
62 struct atom_table
63 {
64     struct object       obj;                 /* object header */
65     int                 count;               /* count of atom handles */
66     int                 last;                /* last handle in-use */
67     struct atom_entry **handles;             /* atom handles */
68     int                 entries_count;       /* humber of hash entries */
69     struct atom_entry **entries;             /* hash table entries */
70 };
71
72 static void atom_table_dump( struct object *obj, int verbose );
73 static void atom_table_destroy( struct object *obj );
74
75 static const struct object_ops atom_table_ops =
76 {
77     sizeof(struct atom_table),    /* size */
78     atom_table_dump,              /* dump */
79     no_add_queue,                 /* add_queue */
80     NULL,                         /* remove_queue */
81     NULL,                         /* signaled */
82     NULL,                         /* satisfied */
83     no_signal,                    /* signal */
84     no_get_fd,                    /* get_fd */
85     no_map_access,                /* map_access */
86     no_lookup_name,               /* lookup_name */
87     no_open_file,                 /* open_file */
88     no_close_handle,              /* close_handle */
89     atom_table_destroy            /* destroy */
90 };
91
92 static struct atom_table *global_table;
93
94 /* create an atom table */
95 static struct atom_table *create_table(int entries_count)
96 {
97     struct atom_table *table;
98
99     if ((table = alloc_object( &atom_table_ops )))
100     {
101         if ((entries_count < MIN_HASH_SIZE) ||
102             (entries_count > MAX_HASH_SIZE)) entries_count = HASH_SIZE;
103         table->entries_count = entries_count;
104         if (!(table->entries = malloc( sizeof(*table->entries) * table->entries_count )))
105         {
106             set_error( STATUS_NO_MEMORY );
107             goto fail;
108         }
109         memset( table->entries, 0, sizeof(*table->entries) * table->entries_count );
110         table->count = 64;
111         table->last  = -1;
112         if ((table->handles = mem_alloc( sizeof(*table->handles) * table->count )))
113             return table;
114 fail:
115         release_object( table );
116         table = NULL;
117     }
118     return table;
119 }
120
121 /* retrieve an entry pointer from its atom */
122 static struct atom_entry *get_atom_entry( struct atom_table *table, atom_t atom )
123 {
124     struct atom_entry *entry = NULL;
125     if (table && (atom >= MIN_STR_ATOM) && (atom <= MIN_STR_ATOM + table->last))
126         entry = table->handles[atom - MIN_STR_ATOM];
127     if (!entry) set_error( STATUS_INVALID_HANDLE );
128     return entry;
129 }
130
131 /* add an atom entry in the table and return its handle */
132 static atom_t add_atom_entry( struct atom_table *table, struct atom_entry *entry )
133 {
134     int i;
135     for (i = 0; i <= table->last; i++)
136         if (!table->handles[i]) goto found;
137     if (i == table->count)
138     {
139         struct atom_entry **new_table = NULL;
140         int new_size = table->count + table->count / 2;
141         if (new_size > MAX_ATOMS) new_size = MAX_ATOMS;
142         if (new_size > table->count)
143             new_table = realloc( table->handles, sizeof(*table->handles) * new_size );
144         if (!new_table)
145         {
146             set_error( STATUS_NO_MEMORY );
147             return 0;
148         }
149         table->count = new_size;
150         table->handles = new_table;
151     }
152     table->last = i;
153  found:
154     table->handles[i] = entry;
155     entry->atom = i + MIN_STR_ATOM;
156     return entry->atom;
157 }
158
159 /* compute the hash code for a string */
160 static unsigned short atom_hash( struct atom_table *table, const WCHAR *str, data_size_t len )
161 {
162     unsigned int i;
163     unsigned short hash = 0;
164     for (i = 0; i < len; i++) hash ^= toupperW(str[i]) + i;
165     return hash % table->entries_count;
166 }
167
168 /* dump an atom table */
169 static void atom_table_dump( struct object *obj, int verbose )
170 {
171     int i;
172     struct atom_table *table = (struct atom_table *)obj;
173     assert( obj->ops == &atom_table_ops );
174
175     fprintf( stderr, "Atom table size=%d entries=%d\n",
176              table->last + 1, table->entries_count );
177     if (!verbose) return;
178     for (i = 0; i <= table->last; i++)
179     {
180         struct atom_entry *entry = table->handles[i];
181         if (!entry) continue;
182         fprintf( stderr, "  %04x: ref=%d pinned=%c hash=%d \"",
183                  entry->atom, entry->count, entry->pinned ? 'Y' : 'N', entry->hash );
184         dump_strW( entry->str, entry->len, stderr, "\"\"");
185         fprintf( stderr, "\"\n" );
186     }
187 }
188
189 /* destroy the atom table */
190 static void atom_table_destroy( struct object *obj )
191 {
192     int i;
193     struct atom_table *table = (struct atom_table *)obj;
194     assert( obj->ops == &atom_table_ops );
195     if (table->handles)
196     {
197         for (i = 0; i <= table->last; i++) free( table->handles[i] );
198         free( table->handles );
199     }
200     free( table->entries );
201 }
202
203 /* find an atom entry in its hash list */
204 static struct atom_entry *find_atom_entry( struct atom_table *table, const WCHAR *str,
205                                            data_size_t len, unsigned short hash )
206 {
207     struct atom_entry *entry = table->entries[hash];
208     while (entry)
209     {
210         if (entry->len == len && !memicmpW( entry->str, str, len )) break;
211         entry = entry->next;
212     }
213     return entry;
214 }
215
216 /* add an atom to the table */
217 static atom_t add_atom( struct atom_table *table, const WCHAR *str, data_size_t len )
218 {
219     struct atom_entry *entry;
220     unsigned short hash = atom_hash( table, str, len );
221     atom_t atom = 0;
222
223     if (!len)
224     {
225         set_error( STATUS_OBJECT_NAME_INVALID );
226         return 0;
227     }
228     if (len > MAX_ATOM_LEN)
229     {
230         set_error( STATUS_INVALID_PARAMETER );
231         return 0;
232     }
233     if ((entry = find_atom_entry( table, str, len, hash )))  /* exists already */
234     {
235         entry->count++;
236         return entry->atom;
237     }
238
239     if ((entry = mem_alloc( sizeof(*entry) + (len - 1) * sizeof(WCHAR) )))
240     {
241         if ((atom = add_atom_entry( table, entry )))
242         {
243             entry->prev  = NULL;
244             if ((entry->next = table->entries[hash])) entry->next->prev = entry;
245             table->entries[hash] = entry;
246             entry->count  = 1;
247             entry->pinned = 0;
248             entry->hash   = hash;
249             entry->len    = len;
250             memcpy( entry->str, str, len * sizeof(WCHAR) );
251         }
252         else free( entry );
253     }
254     else set_error( STATUS_NO_MEMORY );
255     return atom;
256 }
257
258 /* delete an atom from the table */
259 static void delete_atom( struct atom_table *table, atom_t atom, int if_pinned )
260 {
261     struct atom_entry *entry = get_atom_entry( table, atom );
262     if (!entry) return;
263     if (entry->pinned && !if_pinned) set_error( STATUS_WAS_LOCKED );
264     else if (!--entry->count)
265     {
266         if (entry->next) entry->next->prev = entry->prev;
267         if (entry->prev) entry->prev->next = entry->next;
268         else table->entries[entry->hash] = entry->next;
269         table->handles[atom - MIN_STR_ATOM] = NULL;
270         free( entry );
271     }
272 }
273
274 /* find an atom in the table */
275 static atom_t find_atom( struct atom_table *table, const WCHAR *str, data_size_t len )
276 {
277     struct atom_entry *entry;
278
279     if (!len)
280     {
281         set_error( STATUS_OBJECT_NAME_INVALID );
282         return 0;
283     }
284     if (len > MAX_ATOM_LEN)
285     {
286         set_error( STATUS_INVALID_PARAMETER );
287         return 0;
288     }
289     if (table && (entry = find_atom_entry( table, str, len, atom_hash(table, str, len) )))
290         return entry->atom;
291     set_error( STATUS_OBJECT_NAME_NOT_FOUND );
292     return 0;
293 }
294
295 static struct atom_table *get_global_table( struct winstation *winstation, int create )
296 {
297     struct atom_table *table = winstation ? winstation->atom_table : global_table;
298     if (!table)
299     {
300         if (create)
301         {
302             table = create_table( HASH_SIZE );
303             if (winstation) winstation->atom_table = table;
304             else
305             {
306                 global_table = table;
307                 make_object_static( &global_table->obj );
308             }
309         }
310         else set_error( STATUS_OBJECT_NAME_NOT_FOUND );
311     }
312     return table;
313 }
314
315 static struct atom_table *get_table( obj_handle_t h, int create )
316 {
317     struct atom_table *table = NULL;
318
319     if (h)
320     {
321         table = (struct atom_table *)get_handle_obj( current->process, h, 0, &atom_table_ops );
322     }
323     else
324     {
325         table = get_global_table( NULL, 1 );
326         if (table) grab_object( table );
327     }
328     return table;
329 }
330
331 /* add an atom in the global table; used for window properties */
332 atom_t add_global_atom( struct winstation *winstation, const WCHAR *str, data_size_t len )
333 {
334     struct atom_table *global_table = get_global_table( winstation, 1 );
335     if (!global_table) return 0;
336     return add_atom( global_table, str, len );
337 }
338
339 /* find an atom in the global table; used for window properties */
340 atom_t find_global_atom( struct winstation *winstation, const WCHAR *str, data_size_t len )
341 {
342     struct atom_table *global_table = get_global_table( winstation, 0 );
343     struct atom_entry *entry;
344
345     if (!len || len > MAX_ATOM_LEN || !global_table) return 0;
346     if ((entry = find_atom_entry( global_table, str, len, atom_hash(global_table, str, len) )))
347         return entry->atom;
348     return 0;
349 }
350
351 /* increment the ref count of a global atom; used for window properties */
352 int grab_global_atom( struct winstation *winstation, atom_t atom )
353 {
354     if (atom >= MIN_STR_ATOM)
355     {
356         struct atom_table *global_table = get_global_table( winstation, 0 );
357         if (global_table)
358         {
359             struct atom_entry *entry = get_atom_entry( global_table, atom );
360             if (entry) entry->count++;
361             return (entry != NULL);
362         }
363         else return 0;
364     }
365     else return 1;
366 }
367
368 /* decrement the ref count of a global atom; used for window properties */
369 void release_global_atom( struct winstation *winstation, atom_t atom )
370 {
371     if (atom >= MIN_STR_ATOM)
372     {
373         struct atom_table *global_table = get_global_table( winstation, 0 );
374         if (global_table) delete_atom( global_table, atom, 1 );
375     }
376 }
377
378 /* add a global atom */
379 DECL_HANDLER(add_atom)
380 {
381     struct atom_table *table = get_table( req->table, 1 );
382     if (table)
383     {
384         reply->atom = add_atom( table, get_req_data(), get_req_data_size() / sizeof(WCHAR) );
385         release_object( table );
386     }
387 }
388
389 /* delete a global atom */
390 DECL_HANDLER(delete_atom)
391 {
392     struct atom_table *table = get_table( req->table, 0 );
393     if (table)
394     {
395         delete_atom( table, req->atom, 0 );
396         release_object( table );
397     }
398 }
399
400 /* find a global atom */
401 DECL_HANDLER(find_atom)
402 {
403     struct atom_table *table = get_table( req->table, 0 );
404     if (table)
405     {
406         reply->atom = find_atom( table, get_req_data(), get_req_data_size() / sizeof(WCHAR) );
407         release_object( table );
408     }
409 }
410
411 /* get global atom name */
412 DECL_HANDLER(get_atom_information)
413 {
414     struct atom_table *table = get_table( req->table, 0 );
415     if (table)
416     {
417         struct atom_entry *entry;
418
419         if ((entry = get_atom_entry( table, req->atom )))
420         {
421             data_size_t len = entry->len * sizeof(WCHAR);
422             if (get_reply_max_size())
423                 set_reply_data( entry->str, min( len, get_reply_max_size()));
424             reply->count = entry->count;
425             reply->pinned = entry->pinned;
426             reply->total = len;
427         }
428         else reply->count = -1;
429         release_object( table );
430     }
431 }
432
433 /* set global atom name */
434 DECL_HANDLER(set_atom_information)
435 {
436     struct atom_table *table = get_table( req->table, 0 );
437     if (table)
438     {
439         struct atom_entry *entry;
440
441         if ((entry = get_atom_entry( table, req->atom )))
442         {
443             if (req->pinned) entry->pinned = 1;
444         }
445         release_object( table );
446     }
447 }
448
449 /* init a (local) atom table */
450 DECL_HANDLER(init_atom_table)
451 {
452     struct atom_table* table = create_table( req->entries );
453
454     if (table)
455     {
456         reply->table = alloc_handle( current->process, table, 0, 0 );
457         release_object( table );
458     }
459 }
460
461 /* set global atom name */
462 DECL_HANDLER(empty_atom_table)
463 {
464     struct atom_table *table = get_table( req->table, 1 );
465     if (table)
466     {
467         int i;
468         struct atom_entry *entry;
469
470         for (i = 0; i <= table->last; i++)
471         {
472             entry = table->handles[i];
473             if (entry && (!entry->pinned || req->if_pinned))
474             {
475                 if (entry->next) entry->next->prev = entry->prev;
476                 if (entry->prev) entry->prev->next = entry->next;
477                 else table->entries[entry->hash] = entry->next;
478                 table->handles[i] = NULL;
479                 free( entry );
480             }
481         }
482         release_object( table );
483     }
484 }