git.oblomov.eu Git - wine/blob - dlls/ntdll/atom.c

   1 /*
   2  * Atom table functions
   3  *
   4  * Copyright 1993, 1994, 1995 Alexandre Julliard
   5  * Copyright 2004,2005 Eric Pouech
   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 <stdlib.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <ctype.h>
  30
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "windef.h"
  34
  35 #include "wine/server.h"
  36 #include "wine/unicode.h"
  37
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(atom);
  41
  42 #define MAX_ATOM_LEN              255
  43
  44 /******************************************************************
  45  *              is_integral_atom
  46  * Returns STATUS_SUCCESS if integral atom and 'pAtom' is filled
  47  *         STATUS_INVALID_PARAMETER if 'atomstr' is too long
  48  *         STATUS_MORE_ENTRIES otherwise
  49  */
  50 static NTSTATUS is_integral_atom( LPCWSTR atomstr, size_t len, RTL_ATOM* pAtom )
  51 {
  52     RTL_ATOM atom;
  53
  54     if (HIWORD( atomstr ))
  55     {
  56         const WCHAR* ptr = atomstr;
  57         if (!len) return STATUS_OBJECT_NAME_INVALID;
  58
  59         if (*ptr++ == '#')
  60         {
  61             atom = 0;
  62             while (ptr < atomstr + len && *ptr >= '0' && *ptr <= '9')
  63             {
  64                 atom = atom * 10 + *ptr++ - '0';
  65             }
  66             if (ptr > atomstr + 1 && ptr == atomstr + len) goto done;
  67         }
  68         if (len > MAX_ATOM_LEN) return STATUS_INVALID_PARAMETER;
  69         return STATUS_MORE_ENTRIES;
  70     }
  71     else atom = LOWORD( atomstr );
  72 done:
  73     if (!atom || atom >= MAXINTATOM) return STATUS_INVALID_PARAMETER;
  74     *pAtom = atom;
  75     return STATUS_SUCCESS;
  76 }
  77
  78 /******************************************************************
  79  *              RtlDeleteAtomFromAtomTable (NTDLL.@)
  80  */
  81 NTSTATUS WINAPI RtlDeleteAtomFromAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom )
  82 {
  83     NTSTATUS    status;
  84
  85     TRACE( "%p %x\n", table, atom );
  86     if (!table) status = STATUS_INVALID_PARAMETER;
  87     else
  88     {
  89         SERVER_START_REQ( delete_atom )
  90         {
  91             req->atom = atom;
  92             req->table = table;
  93             status = wine_server_call( req );
  94         }
  95         SERVER_END_REQ;
  96     }
  97     return status;
  98 }
  99
 100 /******************************************************************
 101  *              integral_atom_name (internal)
 102  *
 103  * Helper for fetching integral (local/global) atoms names.
 104  */
 105 static ULONG integral_atom_name(WCHAR* buffer, ULONG len, RTL_ATOM atom)
 106 {
 107     static const WCHAR fmt[] = {'#','%','u',0};
 108     WCHAR tmp[16];
 109     int ret;
 110
 111     ret = sprintfW( tmp, fmt, atom );
 112     if (!len) return ret * sizeof(WCHAR);
 113     if (len <= ret) ret = len - 1;
 114     memcpy( buffer, tmp, ret * sizeof(WCHAR) );
 115     buffer[ret] = 0;
 116     return ret * sizeof(WCHAR);
 117 }
 118
 119 /******************************************************************
 120  *              RtlQueryAtomInAtomTable (NTDLL.@)
 121  */
 122 NTSTATUS WINAPI RtlQueryAtomInAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom, ULONG* ref,
 123                                          ULONG* pin, WCHAR* name, ULONG* len )
 124 {
 125     NTSTATUS    status = STATUS_SUCCESS;
 126     DWORD       wlen = 0;
 127
 128     if (!table) status = STATUS_INVALID_PARAMETER;
 129     else if (atom < MAXINTATOM)
 130     {
 131         if (!atom) return STATUS_INVALID_PARAMETER;
 132         if (len) wlen = integral_atom_name( name, *len, atom);
 133         if (ref) *ref = 1;
 134         if (pin) *pin = 1;
 135     }
 136     else
 137     {
 138         SERVER_START_REQ( get_atom_information )
 139         {
 140             req->atom = atom;
 141             req->table = table;
 142             if (len && *len && name)
 143                 wine_server_set_reply( req, name, *len );
 144             status = wine_server_call( req );
 145             if (status == STATUS_SUCCESS)
 146             {
 147                 wlen = reply->total;
 148                 if (ref) *ref = reply->count;
 149                 if (pin) *pin = reply->pinned;
 150             }
 151         }
 152         SERVER_END_REQ;
 153     }
 154     if (status == STATUS_SUCCESS && len)
 155     {
 156         if (*len)
 157         {
 158             wlen = min( *len - sizeof(WCHAR), wlen );
 159             if (name) name[wlen / sizeof(WCHAR)] = 0;
 160         }
 161         else status = STATUS_BUFFER_TOO_SMALL;
 162         *len = wlen;
 163     }
 164
 165     TRACE( "%p %x -> %s (%x)\n",
 166            table, atom, len ? debugstr_wn(name, wlen / sizeof(WCHAR)) : NULL, status );
 167     return status;
 168 }
 169
 170 /******************************************************************
 171  *              RtlCreateAtomTable (NTDLL.@)
 172  */
 173 NTSTATUS WINAPI RtlCreateAtomTable( ULONG size, RTL_ATOM_TABLE* table )
 174 {
 175     NTSTATUS    status;
 176
 177     if (*table)
 178     {
 179         if (size) status = STATUS_INVALID_PARAMETER;
 180         else status = STATUS_SUCCESS;
 181     }
 182     else
 183     {
 184         SERVER_START_REQ( init_atom_table )
 185         {
 186             req->entries = size;
 187             status = wine_server_call( req );
 188             *table = reply->table;
 189         }
 190         SERVER_END_REQ;
 191     }
 192     return status;
 193 }
 194
 195 /******************************************************************
 196  *              RtlDestroyAtomTable (NTDLL.@)
 197  */
 198 NTSTATUS WINAPI RtlDestroyAtomTable( RTL_ATOM_TABLE table )
 199 {
 200     if (!table) return STATUS_INVALID_PARAMETER;
 201     return NtClose( (HANDLE)table );
 202 }
 203
 204 /******************************************************************
 205  *              RtlAddAtomToAtomTable (NTDLL.@)
 206  */
 207 NTSTATUS WINAPI RtlAddAtomToAtomTable( RTL_ATOM_TABLE table, const WCHAR* name, RTL_ATOM* atom )
 208 {
 209     NTSTATUS    status;
 210
 211     if (!table) status = STATUS_INVALID_PARAMETER;
 212     else
 213     {
 214         size_t len = HIWORD(name) ? strlenW(name) : 0;
 215         status = is_integral_atom( name, len, atom );
 216         if (status == STATUS_MORE_ENTRIES)
 217         {
 218             SERVER_START_REQ( add_atom )
 219             {
 220                 wine_server_add_data( req, name, len * sizeof(WCHAR) );
 221                 req->table = table;
 222                 status = wine_server_call( req );
 223                 *atom = reply->atom;
 224             }
 225             SERVER_END_REQ;
 226         }
 227     }
 228     TRACE( "%p %s -> %x\n",
 229            table, debugstr_w(name), status == STATUS_SUCCESS ? *atom : 0 );
 230
 231     return status;
 232 }
 233
 234 /******************************************************************
 235  *              RtlLookupAtomInAtomTable (NTDLL.@)
 236  */
 237 NTSTATUS WINAPI RtlLookupAtomInAtomTable( RTL_ATOM_TABLE table, const WCHAR* name, RTL_ATOM* atom )
 238 {
 239     NTSTATUS    status;
 240
 241     if (!table) status = STATUS_INVALID_PARAMETER;
 242     else
 243     {
 244         size_t len = HIWORD(name) ? strlenW(name) : 0;
 245         status = is_integral_atom( name, len, atom );
 246         if (status == STATUS_MORE_ENTRIES)
 247         {
 248             SERVER_START_REQ( find_atom )
 249             {
 250                 wine_server_add_data( req, name, len * sizeof(WCHAR) );
 251                 req->table = table;
 252                 status = wine_server_call( req );
 253                 *atom = reply->atom;
 254             }
 255             SERVER_END_REQ;
 256         }
 257     }
 258     TRACE( "%p %s -> %x\n",
 259            table, debugstr_w(name), status == STATUS_SUCCESS ? *atom : 0 );
 260     return status;
 261 }
 262
 263 /******************************************************************
 264  *              RtlEmptyAtomTable (NTDLL.@)
 265  */
 266 NTSTATUS WINAPI RtlEmptyAtomTable( RTL_ATOM_TABLE table, BOOLEAN delete_pinned )
 267 {
 268     NTSTATUS    status;
 269
 270     if (!table) status = STATUS_INVALID_PARAMETER;
 271     else
 272     {
 273         SERVER_START_REQ( empty_atom_table )
 274         {
 275             req->table = table;
 276             req->if_pinned = delete_pinned;
 277             status = wine_server_call( req );
 278         }
 279         SERVER_END_REQ;
 280     }
 281     return status;
 282 }
 283
 284 /******************************************************************
 285  *              RtlPinAtomInAtomTable (NTDLL.@)
 286  */
 287 NTSTATUS WINAPI RtlPinAtomInAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom )
 288 {
 289     NTSTATUS status;
 290
 291     if (!table) return STATUS_INVALID_PARAMETER;
 292     if (atom < MAXINTATOM) return STATUS_SUCCESS;
 293
 294     SERVER_START_REQ( set_atom_information )
 295     {
 296         req->table = table;
 297         req->atom = atom;
 298         req->pinned = TRUE;
 299         status = wine_server_call( req );
 300     }
 301     SERVER_END_REQ;
 302
 303     return status;
 304 }
 305
 306 /*************************************************
 307  *        Global handle table management
 308  *************************************************/
 309
 310 /******************************************************************
 311  *              NtAddAtom (NTDLL.@)
 312  */
 313 NTSTATUS WINAPI NtAddAtom( const WCHAR* name, ULONG length, RTL_ATOM* atom )
 314 {
 315     NTSTATUS    status;
 316
 317     status = is_integral_atom( name, length / sizeof(WCHAR), atom );
 318     if (status == STATUS_MORE_ENTRIES)
 319     {
 320         SERVER_START_REQ( add_atom )
 321         {
 322             wine_server_add_data( req, name, length );
 323             req->table = NULL;
 324             status = wine_server_call( req );
 325             *atom = reply->atom;
 326         }
 327         SERVER_END_REQ;
 328     }
 329     TRACE( "%s -> %x\n",
 330            debugstr_wn(name, length/sizeof(WCHAR)), status == STATUS_SUCCESS ? *atom : 0 );
 331     return status;
 332 }
 333
 334 /******************************************************************
 335  *              NtDeleteAtom (NTDLL.@)
 336  */
 337 NTSTATUS WINAPI NtDeleteAtom(RTL_ATOM atom)
 338 {
 339     NTSTATUS    status;
 340
 341     SERVER_START_REQ( delete_atom )
 342     {
 343         req->atom = atom;
 344         req->table = NULL;
 345         status = wine_server_call( req );
 346     }
 347     SERVER_END_REQ;
 348     return status;
 349 }
 350
 351 /******************************************************************
 352  *              NtFindAtom (NTDLL.@)
 353  */
 354 NTSTATUS WINAPI NtFindAtom( const WCHAR* name, ULONG length, RTL_ATOM* atom )
 355 {
 356     NTSTATUS    status;
 357
 358     status = is_integral_atom( name, length / sizeof(WCHAR), atom );
 359     if (status == STATUS_MORE_ENTRIES)
 360     {
 361         SERVER_START_REQ( find_atom )
 362         {
 363             wine_server_add_data( req, name, length );
 364             req->table = NULL;
 365             status = wine_server_call( req );
 366             *atom = reply->atom;
 367         }
 368         SERVER_END_REQ;
 369     }
 370     TRACE( "%s -> %x\n",
 371            debugstr_wn(name, length/sizeof(WCHAR)), status == STATUS_SUCCESS ? *atom : 0 );
 372     return status;
 373 }
 374
 375 /******************************************************************
 376  *              NtQueryInformationAtom (NTDLL.@)
 377  */
 378 NTSTATUS WINAPI NtQueryInformationAtom( RTL_ATOM atom, ATOM_INFORMATION_CLASS class,
 379                                         PVOID ptr, ULONG size, PULONG psize )
 380 {
 381     NTSTATUS status;
 382
 383     switch (class)
 384     {
 385     case AtomBasicInformation:
 386         {
 387             ULONG name_len;
 388             ATOM_BASIC_INFORMATION* abi = (ATOM_BASIC_INFORMATION*)ptr;
 389
 390             if (size < sizeof(ATOM_BASIC_INFORMATION))
 391                 return STATUS_INVALID_PARAMETER;
 392             name_len = size - sizeof(ATOM_BASIC_INFORMATION);
 393
 394             if (atom < MAXINTATOM)
 395             {
 396                 if (atom)
 397                 {
 398                     abi->NameLength = integral_atom_name( abi->Name, name_len, atom );
 399                     status = (name_len) ? STATUS_SUCCESS : STATUS_BUFFER_TOO_SMALL;
 400                     abi->ReferenceCount = 1;
 401                     abi->Pinned = 1;
 402                 }
 403                 else status = STATUS_INVALID_PARAMETER;
 404             }
 405             else
 406             {
 407                 SERVER_START_REQ( get_atom_information )
 408                 {
 409                     req->atom = atom;
 410                     req->table = NULL;
 411                     if (name_len) wine_server_set_reply( req, abi->Name, name_len );
 412                     status = wine_server_call( req );
 413                     if (status == STATUS_SUCCESS)
 414                     {
 415                         name_len = wine_server_reply_size( reply );
 416                         if (name_len)
 417                         {
 418                             abi->NameLength = name_len;
 419                             abi->Name[name_len / sizeof(WCHAR)] = '\0';
 420                         }
 421                         else
 422                         {
 423                             name_len = reply->total;
 424                             abi->NameLength = name_len;
 425                             status = STATUS_BUFFER_TOO_SMALL;
 426                         }
 427                         abi->ReferenceCount = reply->count;
 428                         abi->Pinned = reply->pinned;
 429                     }
 430                     else name_len = 0;
 431                 }
 432                 SERVER_END_REQ;
 433             }
 434             TRACE( "%x -> %s (%u)\n",
 435                    atom, debugstr_wn(abi->Name, abi->NameLength / sizeof(WCHAR)),
 436                    status );
 437             if (psize)
 438                 *psize = sizeof(ATOM_BASIC_INFORMATION) + name_len;
 439         }
 440         break;
 441     default:
 442         FIXME( "Unsupported class %u\n", class );
 443         status = STATUS_INVALID_INFO_CLASS;
 444         break;
 445     }
 446     return status;
 447 }