dll/win32/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 #define WIN32_NO_STATUS
  25 #define WIN32_LEAN_AND_MEAN
  26
  27 //#include <string.h>
  28 #include <stdarg.h>
  29
  30 #include <windef.h>
  31 #include <winbase.h>
  32 #include "handle.h"
  33
  34 #include <wine/debug.h>
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(handle);
  37
  38 #define HANDLE2INDEX(h) ((h)-1)
  39 #define INDEX2HANDLE(i) ((i)+1)
  40
  41 /******************************************************************************
  42  *  init_handle_table
  43  *
  44  * Initializes the HANDLETABLE structure pointed to by lpTable
  45  *
  46  * PARAMS
  47  *  lpTable [I] Pointer to the HANDLETABLE structure, which is to be initialized.
  48  *
  49  * NOTES
  50  *  You have to call destroy_handle_table when you don't need the table
  51  *  any more.
  52  */
  53 void init_handle_table(struct handle_table *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 void destroy_handle_table(struct handle_table *lpTable)
  73 {
  74     TRACE("(lpTable=%p)\n", lpTable);
  75
  76     HeapFree(GetProcessHeap(), 0, lpTable->paEntries);
  77     lpTable->mutex.DebugInfo->Spare[0] = 0;
  78     DeleteCriticalSection(&lpTable->mutex);
  79 }
  80
  81 /******************************************************************************
  82  *  is_valid_handle
  83  *
  84  * Tests if handle is valid given the specified handle table
  85  *
  86  * PARAMS
  87  *  lpTable [I] Pointer to the handle table, with respect to which the handle's
  88  *              validness is tested.
  89  *  handle  [I] The handle tested for validness.
  90  *  dwType  [I] A magic value that identifies the referenced object's type.
  91  *
  92  * RETURNS
  93  *  non zero,  if handle is valid.
  94  *  zero,      if handle is not valid.
  95  */
  96 int is_valid_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)
  97 {
  98     unsigned int index = HANDLE2INDEX(handle);
  99     int ret = 0;
 100
 101     TRACE("(lpTable=%p, handle=%ld)\n", lpTable, handle);
 102
 103     EnterCriticalSection(&lpTable->mutex);
 104
 105     /* We don't use zero handle values */
 106     if (!handle) goto exit;
 107
 108     /* Check for index out of table bounds */
 109     if (index >= lpTable->iEntries) goto exit;
 110
 111     /* Check if this handle is currently allocated */
 112     if (!lpTable->paEntries[index].pObject) goto exit;
 113
 114     /* Check if this handle references an object of the correct type. */
 115     if (lpTable->paEntries[index].pObject->dwType != dwType) goto exit;
 116
 117     ret = 1;
 118 exit:
 119     LeaveCriticalSection(&lpTable->mutex);
 120     return ret;
 121 }
 122
 123 /******************************************************************************
 124  *  grow_handle_table [Internal]
 125  *
 126  * Grows the number of entries in the given table by TABLE_SIZE_INCREMENT
 127  *
 128  * PARAMS
 129  *  lpTable [I] Pointer to the table, which is to be grown
 130  *
 131  * RETURNS
 132  *  non zero,  if successful
 133  *  zero,      if not successful (out of memory on process heap)
 134  *
 135  * NOTES
 136  *  This is a support function for alloc_handle. Do not call!
 137  */
 138 static int grow_handle_table(struct handle_table *lpTable)
 139 {
 140     struct handle_table_entry *newEntries;
 141     unsigned int i, newIEntries;
 142
 143     newIEntries = lpTable->iEntries + TABLE_SIZE_INCREMENT;
 144
 145     newEntries = HeapAlloc(GetProcessHeap(), 0, sizeof(struct handle_table_entry)*newIEntries);
 146     if (!newEntries)
 147         return 0;
 148
 149     if (lpTable->paEntries)
 150     {
 151         memcpy(newEntries, lpTable->paEntries, sizeof(struct handle_table_entry)*lpTable->iEntries);
 152         HeapFree(GetProcessHeap(), 0, lpTable->paEntries);
 153     }
 154
 155     for (i=lpTable->iEntries; i<newIEntries; i++)
 156     {
 157         newEntries[i].pObject = NULL;
 158         newEntries[i].iNextFree = i+1;
 159     }
 160
 161     lpTable->paEntries = newEntries;
 162     lpTable->iEntries = newIEntries;
 163
 164     return 1;
 165 }
 166
 167 /******************************************************************************
 168  *  alloc_handle
 169  *
 170  * Allocates a new handle to the specified object in a given handle table.
 171  *
 172  * PARAMS
 173  *  lpTable  [I] Pointer to the handle table, from which the new handle is
 174  *               allocated.
 175  *  lpObject [I] Pointer to the object, for which a handle shall be allocated.
 176  *  lpHandle [O] Pointer to a handle variable, into which the handle value will
 177  *               be stored. If not successful, this will be
 178  *               INVALID_HANDLE_VALUE
 179  * RETURNS
 180  *  non zero,  if successful
 181  *  zero,      if not successful (no free handle)
 182  */
 183 static int alloc_handle(struct handle_table *lpTable, OBJECTHDR *lpObject, HCRYPTKEY *lpHandle)
 184 {
 185     int ret = 0;
 186
 187     TRACE("(lpTable=%p, lpObject=%p, lpHandle=%p)\n", lpTable, lpObject, lpHandle);
 188
 189     EnterCriticalSection(&lpTable->mutex);
 190     if (lpTable->iFirstFree >= lpTable->iEntries)
 191         if (!grow_handle_table(lpTable))
 192         {
 193             *lpHandle = (HCRYPTKEY)INVALID_HANDLE_VALUE;
 194             goto exit;
 195         }
 196
 197     *lpHandle = INDEX2HANDLE(lpTable->iFirstFree);
 198
 199     lpTable->paEntries[lpTable->iFirstFree].pObject = lpObject;
 200     lpTable->iFirstFree = lpTable->paEntries[lpTable->iFirstFree].iNextFree;
 201     InterlockedIncrement(&lpObject->refcount);
 202
 203     ret = 1;
 204 exit:
 205     LeaveCriticalSection(&lpTable->mutex);
 206     return ret;
 207 }
 208
 209 /******************************************************************************
 210  *  release_handle
 211  *
 212  * Releases resources occupied by the specified handle in the given table.
 213  * The reference count of the handled object is decremented. If it becomes
 214  * zero and if the 'destructor' function pointer member is non NULL, the
 215  * destructor function will be called. Note that release_handle does not
 216  * release resources other than the handle itself. If this is wanted, do it
 217  * in the destructor function.
 218  *
 219  * PARAMS
 220  *  lpTable [I] Pointer to the handle table, from which a handle is to be
 221  *              released.
 222  *  handle  [I] The handle, which is to be released
 223  *  dwType  [I] Identifier for the type of the object, for which a handle is
 224  *              to be released.
 225  *
 226  * RETURNS
 227  *  non zero,  if successful
 228  *  zero,      if not successful (invalid handle)
 229  */
 230 int release_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)
 231 {
 232     unsigned int index = HANDLE2INDEX(handle);
 233     OBJECTHDR *pObject;
 234     int ret = 0;
 235
 236     TRACE("(lpTable=%p, handle=%ld)\n", lpTable, handle);
 237
 238     EnterCriticalSection(&lpTable->mutex);
 239
 240     if (!is_valid_handle(lpTable, handle, dwType))
 241         goto exit;
 242
 243     pObject = lpTable->paEntries[index].pObject;
 244     if (InterlockedDecrement(&pObject->refcount) == 0)
 245     {
 246         TRACE("destroying handle %ld\n", handle);
 247         if (pObject->destructor)
 248             pObject->destructor(pObject);
 249     }
 250
 251     lpTable->paEntries[index].pObject = NULL;
 252     lpTable->paEntries[index].iNextFree = lpTable->iFirstFree;
 253     lpTable->iFirstFree = index;
 254
 255     ret = 1;
 256 exit:
 257     LeaveCriticalSection(&lpTable->mutex);
 258     return ret;
 259 }
 260
 261 /******************************************************************************
 262  *  lookup_handle
 263  *
 264  * Returns the object identified by the handle in the given handle table
 265  *
 266  * PARAMS
 267  *  lpTable    [I] Pointer to the handle table, in which the handle is looked up.
 268  *  handle     [I] The handle, which is to be looked up
 269  *    lplpObject [O] Pointer to the variable, into which the pointer to the
 270  *                   object looked up is copied.
 271  * RETURNS
 272  *  non zero,  if successful
 273  *  zero,      if not successful (invalid handle)
 274  */
 275 int lookup_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject)
 276 {
 277     int ret = 0;
 278
 279     TRACE("(lpTable=%p, handle=%ld, lplpObject=%p)\n", lpTable, handle, lplpObject);
 280
 281     EnterCriticalSection(&lpTable->mutex);
 282     if (!is_valid_handle(lpTable, handle, dwType))
 283     {
 284         *lplpObject = NULL;
 285         goto exit;
 286     }
 287     *lplpObject = lpTable->paEntries[HANDLE2INDEX(handle)].pObject;
 288
 289     ret = 1;
 290 exit:
 291     LeaveCriticalSection(&lpTable->mutex);
 292     return ret;
 293 }
 294
 295 /******************************************************************************
 296  *  copy_handle
 297  *
 298  * Copies a handle. Increments the reference count of the object referenced
 299  * by the handle.
 300  *
 301  * PARAMS
 302  *  lpTable [I] Pointer to the handle table, which holds the handle to be copied.
 303  *  handle  [I] The handle to be copied.
 304  *  copy    [O] Pointer to a handle variable, where the copied handle is put.
 305  *
 306  * RETURNS
 307  *  non zero,  if successful
 308  *  zero,      if not successful (invalid handle or out of memory)
 309  */
 310 int copy_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy)
 311 {
 312     OBJECTHDR *pObject;
 313     int ret;
 314
 315     TRACE("(lpTable=%p, handle=%ld, copy=%p)\n", lpTable, handle, copy);
 316
 317     EnterCriticalSection(&lpTable->mutex);
 318     if (!lookup_handle(lpTable, handle, dwType, &pObject))
 319     {
 320         *copy = (HCRYPTKEY)INVALID_HANDLE_VALUE;
 321         LeaveCriticalSection(&lpTable->mutex);
 322         return 0;
 323     }
 324
 325     ret = alloc_handle(lpTable, pObject, copy);
 326     LeaveCriticalSection(&lpTable->mutex);
 327     return ret;
 328 }
 329
 330 /******************************************************************************
 331  *  new_object
 332  *
 333  * Allocates a new object of size cbSize on the current process's heap.
 334  * Initializes the object header using the destructor and dwType params.
 335  * Allocates a handle to the object in the handle table pointed to by lpTable.
 336  * Returns a pointer to the created object in ppObject.
 337  * Returns a handle to the created object.
 338  *
 339  * PARAMS
 340  *  lpTable    [I] Pointer to the handle table, from which a handle is to be
 341  *              allocated.
 342  *  cbSize     [I] Size of the object to be allocated in bytes.
 343  *  dwType     [I] Object type; will be copied to the object header.
 344  *  destructor [I] Function pointer to a destructor function. Will be called
 345  *                 once the object's reference count gets zero.
 346  *  ppObject   [O] Pointer to a pointer variable, where a pointer to the newly
 347  *                 created object will be stored. You may set this to NULL.
 348  *
 349  * RETURNS
 350  *  INVALID_HANDLE_VALUE,        if something went wrong.
 351  *  a handle to the new object,  if successful.
 352  */
 353 HCRYPTKEY new_object(struct handle_table *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor,
 354                         OBJECTHDR **ppObject)
 355 {
 356     OBJECTHDR *pObject;
 357     HCRYPTKEY hObject;
 358
 359     if (ppObject)
 360         *ppObject = NULL;
 361
 362     pObject = HeapAlloc(GetProcessHeap(), 0, cbSize);
 363     if (!pObject)
 364         return (HCRYPTKEY)INVALID_HANDLE_VALUE;
 365
 366     pObject->dwType = dwType;
 367     pObject->refcount = 0;
 368     pObject->destructor = destructor;
 369
 370     if (!alloc_handle(lpTable, pObject, &hObject))
 371         HeapFree(GetProcessHeap(), 0, pObject);
 372     else
 373         if (ppObject)
 374             *ppObject = pObject;
 375
 376     return hObject;
 377 }