secur32_priv.h File Reference

#include <wine/list.h>
#include "wine/wine_supp.h"

Include dependency graph for secur32_priv.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_SecureProvider
struct	_SecurePackage

Typedefs
typedef struct _SecureProvider	SecureProvider
typedef struct _SecurePackage	SecurePackage

Functions
SecureProvider *	SECUR32_addProvider (const SecurityFunctionTableA *fnTableA, const SecurityFunctionTableW *fnTableW, PCWSTR moduleName) DECLSPEC_HIDDEN
void	SECUR32_addPackages (SecureProvider *provider, ULONG toAdd, const SecPkgInfoA *infoA, const SecPkgInfoW *infoW) DECLSPEC_HIDDEN
SecurePackage *	SECUR32_findPackageW (PCWSTR packageName) DECLSPEC_HIDDEN
SecurePackage *	SECUR32_findPackageA (PCSTR packageName) DECLSPEC_HIDDEN
PWSTR	SECUR32_AllocWideFromMultiByte (PCSTR str) DECLSPEC_HIDDEN
PSTR	SECUR32_AllocMultiByteFromWide (PCWSTR str) DECLSPEC_HIDDEN

Typedef Documentation

SecurePackage

typedef struct _SecurePackage SecurePackage

SecureProvider

typedef struct _SecureProvider SecureProvider

Function Documentation

SECUR32_addPackages()

void SECUR32_addPackages	(	SecureProvider *	provider,
		ULONG	toAdd,
		const SecPkgInfoA *	infoA,
		const SecPkgInfoW *	infoW
	)

Definition at line 362 of file secur32_wine.c.

{
    ULONG i;
 
    assert(provider);
    assert(infoA || infoW);
 
    EnterCriticalSection(&cs);
 
    if (!packageTable)
    {
        packageTable = HeapAlloc(GetProcessHeap(), 0, sizeof(SecurePackageTable));
        if (!packageTable)
        {
            LeaveCriticalSection(&cs);
            return;
        }
 
        packageTable->numPackages = 0;
        list_init(&packageTable->table);
    }
 
    for (i = 0; i < toAdd; i++)
    {
        SecurePackage *package = HeapAlloc(GetProcessHeap(), 0, sizeof(SecurePackage));
        if (!package)
            continue;
 
        list_add_tail(&packageTable->table, &package->entry);
 
        package->provider = provider;
        _copyPackageInfo(&package->infoW,
            infoA ? &infoA[i] : NULL,
            infoW ? &infoW[i] : NULL);
    }
    packageTable->numPackages += toAdd;
 
    LeaveCriticalSection(&cs);
}

Referenced by _tryLoadProvider().

SECUR32_addProvider()

SecureProvider * SECUR32_addProvider	(	const SecurityFunctionTableA *	fnTableA,
		const SecurityFunctionTableW *	fnTableW,
		PCWSTR	moduleName
	)

Definition at line 314 of file secur32_wine.c.

{
    SecureProvider *ret;
 
    EnterCriticalSection(&cs);
 
    if (!providerTable)
    {
        providerTable = HeapAlloc(GetProcessHeap(), 0, sizeof(SecureProviderTable));
        if (!providerTable)
        {
            LeaveCriticalSection(&cs);
            return NULL;
        }
 
        list_init(&providerTable->table);
    }
 
    ret = HeapAlloc(GetProcessHeap(), 0, sizeof(SecureProvider));
    if (!ret)
    {
        LeaveCriticalSection(&cs);
        return NULL;
    }
 
    list_add_tail(&providerTable->table, &ret->entry);
    ret->lib = NULL;
 
#ifndef __REACTOS__
    if (fnTableA || fnTableW)
    {
        ret->moduleName = moduleName ? SECUR32_strdupW(moduleName) : NULL;
        _makeFnTableA(&ret->fnTableA, fnTableA, fnTableW);
        _makeFnTableW(&ret->fnTableW, fnTableA, fnTableW);
        ret->loaded = !moduleName;
    }
    else
#endif
    {
        ret->moduleName = SECUR32_strdupW(moduleName);
        ret->loaded = FALSE;
    }
 
    LeaveCriticalSection(&cs);
    return ret;
}

Referenced by _tryLoadProvider().

SECUR32_AllocMultiByteFromWide()

PSTR SECUR32_AllocMultiByteFromWide

(

PCWSTR

str

)

Definition at line 268 of file secur32_wine.c.

{
    PSTR ret;
 
    if (str)
    {
        int charsNeeded = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0,
         NULL, NULL);
 
        if (charsNeeded)
        {
            ret = HeapAlloc(GetProcessHeap(), 0, charsNeeded);
            if (ret)
                WideCharToMultiByte(CP_ACP, 0, str, -1, ret, charsNeeded,
                 NULL, NULL);
        }
        else
            ret = NULL;
    }
    else
        ret = NULL;
    return ret;
}

Referenced by thunk_AcquireCredentialsHandleW(), thunk_AddCredentialsW(), thunk_ContextAttributesWToA(), thunk_InitializeSecurityContextW(), and thunk_QueryCredentialsAttributesA().

SECUR32_AllocWideFromMultiByte()

PWSTR SECUR32_AllocWideFromMultiByte

(

PCSTR

str

)

Definition at line 246 of file secur32_wine.c.

{
    PWSTR ret;
 
    if (str)
    {
        int charsNeeded = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 
        if (charsNeeded)
        {
            ret = HeapAlloc(GetProcessHeap(), 0, charsNeeded * sizeof(WCHAR));
            if (ret)
                MultiByteToWideChar(CP_ACP, 0, str, -1, ret, charsNeeded);
        }
        else
            ret = NULL;
    }
    else
        ret = NULL;
    return ret;
}

Referenced by _copyPackageInfo(), thunk_ContextAttributesAToW(), and thunk_QueryCredentialsAttributesW().

SECUR32_findPackageA()

SecurePackage * SECUR32_findPackageA

(

PCSTR

packageName

)

Definition at line 631 of file sspi.c.

{
    SecurePackage *ret;
 
    if (packageName)
    {
        UNICODE_STRING package;
 
        RtlCreateUnicodeStringFromAsciiz(&package, packageName);
        ret = SECUR32_findPackageW(package.Buffer);
        RtlFreeUnicodeString(&package);
    }
    else
        ret = NULL;
    return ret;
}

SECUR32_findPackageW()

SecurePackage * SECUR32_findPackageW

(

PCWSTR

packageName

)

Definition at line 577 of file sspi.c.

{
    SecurePackage *ret = NULL;
    BOOL matched = FALSE;
 
#ifdef __REACTOS__
    if (!packageTable)
        SECUR32_initializeProviders();
#endif
 
    if (packageTable && packageName)
    {
        LIST_FOR_EACH_ENTRY(ret, &packageTable->table, SecurePackage, entry)
        {
            matched = !lstrcmpiW(ret->infoW.Name, packageName);
        if (matched)
        break;
        }
        
    if (!matched)
        return NULL;
 
    if (ret->provider && !ret->provider->loaded)
        {
            ret->provider->lib = LoadLibraryW(ret->provider->moduleName);
            if (ret->provider->lib)
            {
                INIT_SECURITY_INTERFACE_W pInitSecurityInterfaceW =
                 (INIT_SECURITY_INTERFACE_W)GetProcAddress(ret->provider->lib,
                 SECURITY_ENTRYPOINT_ANSIW);
                INIT_SECURITY_INTERFACE_A pInitSecurityInterfaceA =
                 (INIT_SECURITY_INTERFACE_A)GetProcAddress(ret->provider->lib,
                 SECURITY_ENTRYPOINT_ANSIA);
                PSecurityFunctionTableA fnTableA = NULL;
                PSecurityFunctionTableW fnTableW = NULL;
 
                if (pInitSecurityInterfaceA)
                    fnTableA = pInitSecurityInterfaceA();
                if (pInitSecurityInterfaceW)
                    fnTableW = pInitSecurityInterfaceW();
                /* don't update built-in SecurityFunctionTable */
                if (fnTableA != &securityFunctionTableA)
                    _makeFnTableA(&ret->provider->fnTableA, fnTableA, fnTableW);
                if (fnTableW != &securityFunctionTableW)
                    _makeFnTableW(&ret->provider->fnTableW, fnTableA, fnTableW);
                ret->provider->loaded = TRUE;
            }
            else
                ret = NULL;
        }
    }
    return ret;
}

Referenced by SECUR32_findPackageA().