handle.c File Reference

#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "handle.h"
#include "wine/debug.h"

Include dependency graph for handle.c:

Go to the source code of this file.

Macros
#define	HANDLE2INDEX(h)   ((h)-1)
#define	INDEX2HANDLE(i)   ((i)+1)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (handle)
void	init_handle_table (struct handle_table *lpTable)
void	destroy_handle_table (struct handle_table *lpTable)
BOOL	is_valid_handle (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)
static BOOL	grow_handle_table (struct handle_table *lpTable)
static BOOL	alloc_handle (struct handle_table *lpTable, OBJECTHDR *lpObject, HCRYPTKEY *lpHandle)
BOOL	release_handle (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)
BOOL	lookup_handle (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject)
BOOL	copy_handle (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy)
HCRYPTKEY	new_object (struct handle_table *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor, OBJECTHDR **ppObject)

Macro Definition Documentation

HANDLE2INDEX

#define HANDLE2INDEX

(

h

)

((h)-1)

Definition at line 36 of file handle.c.

INDEX2HANDLE

#define INDEX2HANDLE

(

i

)

((i)+1)

Definition at line 37 of file handle.c.

Function Documentation

alloc_handle()

static BOOL alloc_handle ( struct handle_table *  lpTable, OBJECTHDR *  lpObject, HCRYPTKEY *  lpHandle  )

static

Definition at line 181 of file handle.c.

{
    BOOL ret = FALSE;
 
    TRACE("(lpTable=%p, lpObject=%p, lpHandle=%p)\n", lpTable, lpObject, lpHandle);
        
    EnterCriticalSection(&lpTable->mutex);
    if (lpTable->iFirstFree >= lpTable->iEntries) 
        if (!grow_handle_table(lpTable))
        {
            *lpHandle = (HCRYPTKEY)INVALID_HANDLE_VALUE;
            goto exit;
        }
 
    *lpHandle = INDEX2HANDLE(lpTable->iFirstFree);
    
    lpTable->paEntries[lpTable->iFirstFree].pObject = lpObject;
    lpTable->iFirstFree = lpTable->paEntries[lpTable->iFirstFree].iNextFree;
    InterlockedIncrement(&lpObject->refcount);
 
    ret = TRUE;
exit:
    LeaveCriticalSection(&lpTable->mutex);
    return ret;
}

Referenced by copy_handle(), and new_object().

copy_handle()

BOOL copy_handle	(	struct handle_table *	lpTable,
		HCRYPTKEY	handle,
		DWORD	dwType,
		HCRYPTKEY *	copy
	)

Definition at line 308 of file handle.c.

{
    OBJECTHDR *pObject;
    BOOL ret;
 
    TRACE("(lpTable=%p, handle=%Id, copy=%p)\n", lpTable, handle, copy);
 
    EnterCriticalSection(&lpTable->mutex);
    if (!lookup_handle(lpTable, handle, dwType, &pObject)) 
    {
        *copy = (HCRYPTKEY)INVALID_HANDLE_VALUE;
        LeaveCriticalSection(&lpTable->mutex);
        return FALSE;
    }
 
    ret = alloc_handle(lpTable, pObject, copy);
    LeaveCriticalSection(&lpTable->mutex);
    return ret;
}

Referenced by release_and_install_key(), and RSAENH_CPGetUserKey().

destroy_handle_table()

void destroy_handle_table

(

struct handle_table *

lpTable

)

Definition at line 70 of file handle.c.

{
    TRACE("(lpTable=%p)\n", lpTable);
        
    free(lpTable->paEntries);
    lpTable->mutex.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&lpTable->mutex);
}

Referenced by DllMain().

grow_handle_table()

static BOOL grow_handle_table ( struct handle_table *  lpTable )

static

Definition at line 136 of file handle.c.

{
    struct handle_table_entry *newEntries;
    unsigned int i, newIEntries;
 
    newIEntries = lpTable->iEntries + TABLE_SIZE_INCREMENT;
 
    newEntries = malloc(sizeof(struct handle_table_entry)*newIEntries);
    if (!newEntries)
        return FALSE;
 
    if (lpTable->paEntries)
    {
        memcpy(newEntries, lpTable->paEntries, sizeof(struct handle_table_entry)*lpTable->iEntries);
        free(lpTable->paEntries);
    }
 
    for (i=lpTable->iEntries; i<newIEntries; i++)
    {
        newEntries[i].pObject = NULL;
        newEntries[i].iNextFree = i+1;
    }
 
    lpTable->paEntries = newEntries;
    lpTable->iEntries = newIEntries;
 
    return TRUE;
}

Referenced by alloc_handle().

init_handle_table()

void init_handle_table

(

struct handle_table *

lpTable

)

Definition at line 51 of file handle.c.

{
    TRACE("(lpTable=%p)\n", lpTable);
        
    lpTable->paEntries = NULL;
    lpTable->iEntries = 0;
    lpTable->iFirstFree = 0;
    InitializeCriticalSectionEx(&lpTable->mutex, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    lpTable->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": HANDLETABLE.mutex");
}

Referenced by DllMain().

is_valid_handle()

BOOL is_valid_handle	(	struct handle_table *	lpTable,
		HCRYPTKEY	handle,
		DWORD	dwType
	)

Definition at line 94 of file handle.c.

{
    unsigned int index = HANDLE2INDEX(handle);
    BOOL ret = FALSE;
 
    TRACE("(lpTable=%p, handle=%Id)\n", lpTable, handle);
    
    EnterCriticalSection(&lpTable->mutex);
        
    /* We don't use zero handle values */
    if (!handle) goto exit;
 
    /* Check for index out of table bounds */    
    if (index >= lpTable->iEntries) goto exit;
    
    /* Check if this handle is currently allocated */
    if (!lpTable->paEntries[index].pObject) goto exit;
    
    /* Check if this handle references an object of the correct type. */
    if (lpTable->paEntries[index].pObject->dwType != dwType) goto exit;
 
    ret = TRUE;
exit:
    LeaveCriticalSection(&lpTable->mutex);
    return ret;
}

Referenced by crypt_export_key(), initialize_stdio_handles_nolock(), lookup_handle(), release_handle(), RSAENH_CPDecrypt(), RSAENH_CPDeriveKey(), RSAENH_CPDestroyHash(), RSAENH_CPDestroyKey(), RSAENH_CPDuplicateHash(), RSAENH_CPDuplicateKey(), RSAENH_CPEncrypt(), RSAENH_CPExportKey(), RSAENH_CPGenRandom(), RSAENH_CPGetHashParam(), RSAENH_CPGetKeyParam(), RSAENH_CPSetHashParam(), RSAENH_CPSetKeyParam(), and RSAENH_CPVerifySignature().

lookup_handle()

BOOL lookup_handle	(	struct handle_table *	lpTable,
		HCRYPTKEY	handle,
		DWORD	dwType,
		OBJECTHDR **	lplpObject
	)

Definition at line 273 of file handle.c.

{
    BOOL ret = FALSE;
 
    TRACE("(lpTable=%p, handle=%Id, lplpObject=%p)\n", lpTable, handle, lplpObject);
    
    EnterCriticalSection(&lpTable->mutex);
    if (!is_valid_handle(lpTable, handle, dwType)) 
    {
        *lplpObject = NULL;
        goto exit;
    }
    *lplpObject = lpTable->paEntries[HANDLE2INDEX(handle)].pObject;
 
    ret = TRUE;
exit:
    LeaveCriticalSection(&lpTable->mutex);
    return ret;
}

Referenced by copy_handle(), crypt_export_key(), finalize_hash(), get_key_container(), import_symmetric_key(), read_key_container(), read_key_value(), RSAENH_CPCreateHash(), RSAENH_CPDecrypt(), RSAENH_CPDeriveKey(), RSAENH_CPDuplicateHash(), RSAENH_CPDuplicateKey(), RSAENH_CPEncrypt(), RSAENH_CPExportKey(), RSAENH_CPGetHashParam(), RSAENH_CPGetKeyParam(), RSAENH_CPHashData(), RSAENH_CPHashSessionKey(), RSAENH_CPSetHashParam(), RSAENH_CPSetKeyParam(), RSAENH_CPSignHash(), RSAENH_CPVerifySignature(), store_key_pair(), store_key_permissions(), tls1_p(), tls1_prf(), and update_hash().

new_object()

HCRYPTKEY new_object	(	struct handle_table *	lpTable,
		size_t	cbSize,
		DWORD	dwType,
		DESTRUCTOR	destructor,
		OBJECTHDR **	ppObject
	)

Definition at line 351 of file handle.c.

{
    OBJECTHDR *pObject;
    HCRYPTKEY hObject;
 
    if (ppObject)
        *ppObject = NULL;
 
    pObject = malloc(cbSize);
    if (!pObject)
        return (HCRYPTKEY)INVALID_HANDLE_VALUE;
 
    pObject->dwType = dwType;
    pObject->refcount = 0;
    pObject->destructor = destructor;
 
    if (!alloc_handle(lpTable, pObject, &hObject))
        free(pObject);
    else
        if (ppObject)
            *ppObject = pObject;
 
    return hObject;
}

Referenced by alloc_key(), new_key_container(), RSAENH_CPCreateHash(), RSAENH_CPDuplicateHash(), RSAENH_CPDuplicateKey(), and StorageImpl_Refresh().

release_handle()

BOOL release_handle	(	struct handle_table *	lpTable,
		HCRYPTKEY	handle,
		DWORD	dwType
	)

Definition at line 228 of file handle.c.

{
    unsigned int index = HANDLE2INDEX(handle);
    OBJECTHDR *pObject;
    BOOL ret = FALSE;
 
    TRACE("(lpTable=%p, handle=%Id)\n", lpTable, handle);
    
    EnterCriticalSection(&lpTable->mutex);
    
    if (!is_valid_handle(lpTable, handle, dwType))
        goto exit;
 
    pObject = lpTable->paEntries[index].pObject;
    if (InterlockedDecrement(&pObject->refcount) == 0)
    {
        TRACE("destroying handle %Id\n", handle);
        if (pObject->destructor)
            pObject->destructor(pObject);
    }
 
    lpTable->paEntries[index].pObject = NULL;
    lpTable->paEntries[index].iNextFree = lpTable->iFirstFree;
    lpTable->iFirstFree = index;
 
    ret = TRUE;
exit:
    LeaveCriticalSection(&lpTable->mutex);
    return ret;
}

Referenced by import_plaintext_key(), read_key_container(), release_key_container_keys(), RSAENH_CPAcquireContext(), RSAENH_CPDestroyHash(), RSAENH_CPDestroyKey(), RSAENH_CPReleaseContext(), and tls1_prf().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

handle

)