dlls/rsaenh/handle.c

   1 /*
   2  * dlls/rsaenh/handle.c
   3  * Support code to manage HANDLE tables.
   4  *
   5  * Copyright 1998 Alexandre Julliard
   6  * Copyright 2002-2004 Mike McCormack for CodeWeavers
   7  * Copyright 2004 Michael Jung
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <string.h>
  25 #include <stdarg.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "handle.h"
  30
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(handle);
  34
  35 #define HANDLE2INDEX(h) ((h)-1)
  36 #define INDEX2HANDLE(i) ((i)+1)
  37
  38 /******************************************************************************
  39  *  init_handle_table
  40  *
  41  * Initializes the HANDLETABLE structure pointed to by lpTable
  42  *
  43  * PARAMS
  44  *  lpTable [I] Pointer to the HANDLETABLE structure, which is to be initalized.
  45  *
  46  * NOTES
  47  *  Note that alloc_handle_table calls init_handle_table on it's own, which
  48  *  means that you only have to call init_handle_table, if you use a global
  49  *  variable of type HANDLETABLE for your handle table. However, in this
  50  *  case you have to call destroy_handle_table when you don't need the table
  51  *  any more.
  52  */
  53 void init_handle_table(HANDLETABLE *lpTable)
  54 {
  55     TRACE("(lpTable=%p)\n", lpTable);
  56
  57     lpTable->paEntries = NULL;
  58     lpTable->iEntries = 0;
  59     lpTable->iFirstFree = 0;
  60     InitializeCriticalSection(&lpTable->mutex);
  61     lpTable->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": HANDLETABLE.mutex");
  62 }
  63
  64 /******************************************************************************
  65  *  destroy_handle_table
  66  *
  67  * Destroys the handle table.
  68  *
  69  * PARAMS
  70  *  lpTable [I] Pointer to the handle table, which is to be destroyed.
  71  *
  72  * NOTES
  73  *  Note that release_handle_table takes care of this.
  74  */
  75 void destroy_handle_table(HANDLETABLE *lpTable)
  76 {
  77     TRACE("(lpTable=%p)\n", lpTable);
  78
  79     HeapFree(GetProcessHeap(), 0, lpTable->paEntries);
  80     lpTable->mutex.DebugInfo->Spare[0] = 0;
  81     DeleteCriticalSection(&lpTable->mutex);
  82 }
  83
  84 /******************************************************************************
  85  *  is_valid_handle
  86  *
  87  * Tests if handle is valid given the specified handle table
  88  *
  89  * PARAMS
  90  *  lpTable [I] Pointer to the handle table, with respect to which the handle's
  91  *              validness is tested.
  92  *  handle  [I] The handle tested for validness.
  93  *  dwType  [I] A magic value that identifies the referenced object's type.
  94  *
  95  * RETURNS
  96  *  non zero,  if handle is valid.
  97  *  zero,      if handle is not valid.
  98  */
  99 int is_valid_handle(HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType)
 100 {
 101     unsigned int index = HANDLE2INDEX(handle);
 102     int ret = 0;
 103
 104     TRACE("(lpTable=%p, handle=%ld)\n", lpTable, handle);
 105
 106     EnterCriticalSection(&lpTable->mutex);
 107
 108     /* We don't use zero handle values */
 109     if (!handle) goto exit;
 110
 111     /* Check for index out of table bounds */
 112     if (index >= lpTable->iEntries) goto exit;
 113
 114     /* Check if this handle is currently allocated */
 115     if (!lpTable->paEntries[index].pObject) goto exit;
 116
 117     /* Check if this handle references an object of the correct type. */
 118     if (lpTable->paEntries[index].pObject->dwType != dwType) goto exit;
 119
 120     ret = 1;
 121 exit:
 122     LeaveCriticalSection(&lpTable->mutex);
 123     return ret;
 124 }
 125
 126 /******************************************************************************
 127  *  release_all_handles
 128  *
 129  * Releases all valid handles in the given handle table and shrinks the table
 130  * to zero size.
 131  *
 132  * PARAMS
 133  *  lpTable [I] The table of which all valid handles shall be released.
 134  */
 135 static void release_all_handles(HANDLETABLE *lpTable)
 136 {
 137     unsigned int i;
 138
 139     TRACE("(lpTable=%p)\n", lpTable);
 140
 141     EnterCriticalSection(&lpTable->mutex);
 142     for (i=0; i<lpTable->iEntries; i++)
 143         if (lpTable->paEntries[i].pObject)
 144             release_handle(lpTable, lpTable->paEntries[i].pObject->dwType, INDEX2HANDLE(i));
 145     LeaveCriticalSection(&lpTable->mutex);
 146 }
 147
 148 /******************************************************************************
 149  *  alloc_handle_table
 150  *
 151  * Allocates a new handle table
 152  *
 153  * PARAMS
 154  *  lplpTable [O] Pointer to the variable, to which the pointer to the newly
 155  *                allocated handle table is written.
 156  * RETURNS
 157  *  non zero,  if successful
 158  *  zero,      if not successful (out of process heap memory)
 159  *
 160  * NOTES
 161  *  If all you need is a single handle table, you may as well declare a global
 162  *  variable of type HANDLETABLE and call init_handle_table on your own.
 163  */
 164 int alloc_handle_table(HANDLETABLE **lplpTable)
 165 {
 166     TRACE("(lplpTable=%p)\n", lplpTable);
 167
 168     *lplpTable = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLETABLE));
 169     if (*lplpTable)
 170     {
 171         init_handle_table(*lplpTable);
 172         return 1;
 173     }
 174     else
 175         return 0;
 176 }
 177
 178 /******************************************************************************
 179  *  release_handle_table
 180  *
 181  * Releases a handle table and frees the resources it used.
 182  *
 183  * PARAMS
 184  *  lpTable [I] Pointer to the handle table, which is to be released.
 185  *
 186  * RETURNS
 187  *  non zero,  if successful
 188  *  zero,      if not successful
 189  *
 190  * NOTES
 191  *   All valid handles still in the table are released also.
 192  */
 193 int release_handle_table(HANDLETABLE *lpTable)
 194 {
 195     TRACE("(lpTable=%p)\n", lpTable);
 196
 197     release_all_handles(lpTable);
 198     destroy_handle_table(lpTable);
 199     return (int)HeapFree(GetProcessHeap(), 0, lpTable);
 200 }
 201
 202 /******************************************************************************
 203  *  grow_handle_table [Internal]
 204  *
 205  * Grows the number of entries in the given table by TABLE_SIZE_INCREMENT
 206  *
 207  * PARAMS
 208  *  lpTable [I] Pointer to the table, which is to be grown
 209  *
 210  * RETURNS
 211  *  non zero,  if successful
 212  *  zero,      if not successful (out of memory on process heap)
 213  *
 214  * NOTES
 215  *  This is a support function for alloc_handle. Do not call!
 216  */
 217 static int grow_handle_table(HANDLETABLE *lpTable)
 218 {
 219     HANDLETABLEENTRY *newEntries;
 220     unsigned int i, newIEntries;
 221
 222     newIEntries = lpTable->iEntries + TABLE_SIZE_INCREMENT;
 223
 224     newEntries = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLETABLEENTRY)*newIEntries);
 225     if (!newEntries)
 226         return 0;
 227
 228     if (lpTable->paEntries)
 229     {
 230         memcpy(newEntries, lpTable->paEntries, sizeof(HANDLETABLEENTRY)*lpTable->iEntries);
 231         HeapFree(GetProcessHeap(), 0, lpTable->paEntries);
 232     }
 233
 234     for (i=lpTable->iEntries; i<newIEntries; i++)
 235     {
 236         newEntries[i].pObject = NULL;
 237         newEntries[i].iNextFree = i+1;
 238     }
 239
 240     lpTable->paEntries = newEntries;
 241     lpTable->iEntries = newIEntries;
 242
 243     return 1;
 244 }
 245
 246 /******************************************************************************
 247  *  alloc_handle
 248  *
 249  * Allocates a new handle to the specified object in a given handle table.
 250  *
 251  * PARAMS
 252  *  lpTable  [I] Pointer to the handle table, from which the new handle is
 253  *               allocated.
 254  *  lpObject [I] Pointer to the object, for which a handle shall be allocated.
 255  *  lpHandle [O] Pointer to a handle variable, into which the handle value will
 256  *               be stored. If not successful, this will be
 257  *               INVALID_HANDLE_VALUE
 258  * RETURNS
 259  *  non zero,  if successful
 260  *  zero,      if not successful (no free handle)
 261  */
 262 static int alloc_handle(HANDLETABLE *lpTable, OBJECTHDR *lpObject, HCRYPTKEY *lpHandle)
 263 {
 264     int ret = 0;
 265
 266     TRACE("(lpTable=%p, lpObject=%p, lpHandle=%p)\n", lpTable, lpObject, lpHandle);
 267
 268     EnterCriticalSection(&lpTable->mutex);
 269     if (lpTable->iFirstFree >= lpTable->iEntries)
 270         if (!grow_handle_table(lpTable))
 271         {
 272             *lpHandle = (HCRYPTKEY)INVALID_HANDLE_VALUE;
 273             goto exit;
 274         }
 275
 276     *lpHandle = INDEX2HANDLE(lpTable->iFirstFree);
 277
 278     lpTable->paEntries[lpTable->iFirstFree].pObject = lpObject;
 279     lpTable->iFirstFree = lpTable->paEntries[lpTable->iFirstFree].iNextFree;
 280     InterlockedIncrement(&lpObject->refcount);
 281
 282     ret = 1;
 283 exit:
 284     LeaveCriticalSection(&lpTable->mutex);
 285     return ret;
 286 }
 287
 288 /******************************************************************************
 289  *  release_handle
 290  *
 291  * Releases resources occupied by the specified handle in the given table.
 292  * The reference count of the handled object is decremented. If it becomes
 293  * zero and if the 'destructor' function pointer member is non NULL, the
 294  * destructor function will be called. Note that release_handle does not
 295  * release resources other than the handle itself. If this is wanted, do it
 296  * in the destructor function.
 297  *
 298  * PARAMS
 299  *  lpTable [I] Pointer to the handle table, from which a handle is to be
 300  *              released.
 301  *  handle  [I] The handle, which is to be released
 302  *  dwType  [I] Identifier for the type of the object, for which a handle is
 303  *              to be released.
 304  *
 305  * RETURNS
 306  *  non zero,  if successful
 307  *  zero,      if not successful (invalid handle)
 308  */
 309 int release_handle(HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType)
 310 {
 311     unsigned int index = HANDLE2INDEX(handle);
 312     OBJECTHDR *pObject;
 313     int ret = 0;
 314
 315     TRACE("(lpTable=%p, handle=%ld)\n", lpTable, handle);
 316
 317     EnterCriticalSection(&lpTable->mutex);
 318
 319     if (!is_valid_handle(lpTable, handle, dwType))
 320         goto exit;
 321
 322     pObject = lpTable->paEntries[index].pObject;
 323     if (InterlockedDecrement(&pObject->refcount) == 0)
 324     {
 325         TRACE("destroying handle %ld\n", handle);
 326         if (pObject->destructor)
 327             pObject->destructor(pObject);
 328     }
 329
 330     lpTable->paEntries[index].pObject = NULL;
 331     lpTable->paEntries[index].iNextFree = lpTable->iFirstFree;
 332     lpTable->iFirstFree = index;
 333
 334     ret = 1;
 335 exit:
 336     LeaveCriticalSection(&lpTable->mutex);
 337     return ret;
 338 }
 339
 340 /******************************************************************************
 341  *  lookup_handle
 342  *
 343  * Returns the object identified by the handle in the given handle table
 344  *
 345  * PARAMS
 346  *  lpTable    [I] Pointer to the handle table, in which the handle is looked up.
 347  *  handle     [I] The handle, which is to be looked up
 348  *    lplpObject [O] Pointer to the variable, into which the pointer to the
 349  *                   object looked up is copied.
 350  * RETURNS
 351  *  non zero,  if successful
 352  *  zero,      if not successful (invalid handle)
 353  */
 354 int lookup_handle(HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject)
 355 {
 356     int ret = 0;
 357
 358     TRACE("(lpTable=%p, handle=%ld, lplpObject=%p)\n", lpTable, handle, lplpObject);
 359
 360     EnterCriticalSection(&lpTable->mutex);
 361     if (!is_valid_handle(lpTable, handle, dwType))
 362     {
 363         *lplpObject = NULL;
 364         goto exit;
 365     }
 366     *lplpObject = lpTable->paEntries[HANDLE2INDEX(handle)].pObject;
 367
 368     ret = 1;
 369 exit:
 370     LeaveCriticalSection(&lpTable->mutex);
 371     return ret;
 372 }
 373
 374 /******************************************************************************
 375  *  copy_handle
 376  *
 377  * Copies a handle. Increments the reference count of the object referenced
 378  * by the handle.
 379  *
 380  * PARAMS
 381  *  lpTable [I] Pointer to the handle table, which holds the handle to be copied.
 382  *  handle  [I] The handle to be copied.
 383  *  copy    [O] Pointer to a handle variable, where the copied handle is put.
 384  *
 385  * RETURNS
 386  *  non zero,  if successful
 387  *  zero,      if not successful (invalid handle or out of memory)
 388  */
 389 int copy_handle(HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy)
 390 {
 391     OBJECTHDR *pObject;
 392     int ret;
 393
 394     TRACE("(lpTable=%p, handle=%ld, copy=%p)\n", lpTable, handle, copy);
 395
 396     EnterCriticalSection(&lpTable->mutex);
 397     if (!lookup_handle(lpTable, handle, dwType, &pObject))
 398     {
 399         *copy = (HCRYPTKEY)INVALID_HANDLE_VALUE;
 400         LeaveCriticalSection(&lpTable->mutex);
 401         return 0;
 402     }
 403
 404     ret = alloc_handle(lpTable, pObject, copy);
 405     LeaveCriticalSection(&lpTable->mutex);
 406     return ret;
 407 }
 408
 409 /******************************************************************************
 410  *  new_object
 411  *
 412  * Allocates a new object of size cbSize on the current process's heap.
 413  * Initializes the object header using the destructor and dwType params.
 414  * Allocates a handle to the object in the handle table pointed to by lpTable.
 415  * Returns a pointer to the created object in ppObject.
 416  * Returns a handle to the created object.
 417  *
 418  * PARAMS
 419  *  lpTable    [I] Pointer to the handle table, from which a handle is to be
 420  *              allocated.
 421  *  cbSize     [I] Size of the object to be allocated in bytes.
 422  *  dwType     [I] Object type; will be copied to the object header.
 423  *  destructor [I] Function pointer to a destructor function. Will be called
 424  *                 once the object's reference count gets zero.
 425  *  ppObject   [O] Pointer to a pointer variable, where a pointer to the newly
 426  *                 created object will be stored. You may set this to NULL.
 427  *
 428  * RETURNS
 429  *  INVALID_HANDLE_VALUE,        if something went wrong.
 430  *  a handle to the new object,  if successful.
 431  */
 432 HCRYPTKEY new_object(HANDLETABLE *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor,
 433                         OBJECTHDR **ppObject)
 434 {
 435     OBJECTHDR *pObject;
 436     HCRYPTKEY hObject;
 437
 438     if (ppObject)
 439         *ppObject = NULL;
 440
 441     pObject = HeapAlloc(GetProcessHeap(), 0, cbSize);
 442     if (!pObject)
 443         return (HCRYPTKEY)INVALID_HANDLE_VALUE;
 444
 445     pObject->dwType = dwType;
 446     pObject->refcount = 0;
 447     pObject->destructor = destructor;
 448
 449     if (!alloc_handle(lpTable, pObject, &hObject))
 450         HeapFree(GetProcessHeap(), 0, pObject);
 451     else
 452         if (ppObject)
 453             *ppObject = pObject;
 454
 455     return hObject;
 456 }