secur32_wine.c File Reference

#include "precomp.h"
#include <assert.h>

Include dependency graph for secur32_wine.c:

Go to the source code of this file.

Classes
struct	_SecurePackageTable
struct	_SecureProviderTable

Typedefs
typedef struct _SecurePackageTable	SecurePackageTable
typedef struct _SecureProviderTable	SecureProviderTable

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (schannel)
SECURITY_STATUS WINAPI	schan_EnumerateSecurityPackagesW (PULONG pcPackages, PSecPkgInfoW *ppPackageInfo)
static PSecPkgInfoA	thunk_PSecPkgInfoWToA (ULONG cPackages, const SecPkgInfoW *info)
SECURITY_STATUS WINAPI	schan_EnumerateSecurityPackagesA (PULONG pcPackages, PSecPkgInfoA *ppPackageInfo)
SECURITY_STATUS WINAPI	schan_FreeContextBuffer (PVOID pvoid)
static PWSTR	SECUR32_strdupW (PCWSTR str)
PWSTR	SECUR32_AllocWideFromMultiByte (PCSTR str)
PSTR	SECUR32_AllocMultiByteFromWide (PCWSTR str)
static void	_copyPackageInfo (PSecPkgInfoW info, const SecPkgInfoA *inInfoA, const SecPkgInfoW *inInfoW)
SecureProvider *	SECUR32_addProvider (const SecurityFunctionTableA *fnTableA, const SecurityFunctionTableW *fnTableW, PCWSTR moduleName)
void	SECUR32_addPackages (SecureProvider *provider, ULONG toAdd, const SecPkgInfoA *infoA, const SecPkgInfoW *infoW)

Variables
static CRITICAL_SECTION	cs = { &cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	cs_debug
static SecurePackageTable *	packageTable = NULL
static SecureProviderTable *	providerTable = NULL

Typedef Documentation

SecurePackageTable

typedef struct _SecurePackageTable SecurePackageTable

SecureProviderTable

typedef struct _SecureProviderTable SecureProviderTable

Function Documentation

_copyPackageInfo()

static void _copyPackageInfo ( PSecPkgInfoW  info, const SecPkgInfoA *  inInfoA, const SecPkgInfoW *  inInfoW  )

static

Definition at line 292 of file secur32_wine.c.

{
    if (info && (inInfoA || inInfoW))
    {
        /* odd, I know, but up until Name and Comment the structures are
         * identical
         */
        memcpy(info, inInfoW ? inInfoW : (const SecPkgInfoW *)inInfoA, sizeof(*info));
        if (inInfoW)
        {
            info->Name = SECUR32_strdupW(inInfoW->Name);
            info->Comment = SECUR32_strdupW(inInfoW->Comment);
        }
        else
        {
            info->Name = SECUR32_AllocWideFromMultiByte(inInfoA->Name);
            info->Comment = SECUR32_AllocWideFromMultiByte(inInfoA->Comment);
        }
    }
}

Referenced by SECUR32_addPackages().

schan_EnumerateSecurityPackagesA()

SECURITY_STATUS WINAPI schan_EnumerateSecurityPackagesA	(	PULONG	pcPackages,
		PSecPkgInfoA *	ppPackageInfo
	)

Definition at line 199 of file secur32_wine.c.

{
    SECURITY_STATUS ret;
    PSecPkgInfoW info;
 
    ret = schan_EnumerateSecurityPackagesW(pcPackages, &info);
    if (ret == SEC_E_OK && *pcPackages && info)
    {
        *ppPackageInfo = thunk_PSecPkgInfoWToA(*pcPackages, info);
        if (*pcPackages && !*ppPackageInfo)
        {
            *pcPackages = 0;
            ret = SEC_E_INSUFFICIENT_MEMORY;
        }
        schan_FreeContextBuffer(info);
    }
    return ret;
}

schan_EnumerateSecurityPackagesW()

SECURITY_STATUS WINAPI schan_EnumerateSecurityPackagesW	(	PULONG	pcPackages,
		PSecPkgInfoW *	ppPackageInfo
	)

Definition at line 58 of file secur32_wine.c.

{
    SECURITY_STATUS ret = SEC_E_OK;
 
    TRACE("(%p, %p)\n", pcPackages, ppPackageInfo);
 
    /* windows just crashes if pcPackages or ppPackageInfo is NULL, so will I */
    *pcPackages = 0;
    EnterCriticalSection(&cs);
    if (packageTable)
    {
        SecurePackage *package;
        size_t bytesNeeded;
 
        bytesNeeded = packageTable->numPackages * sizeof(SecPkgInfoW);
        LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
        {
            if (package->infoW.Name)
                bytesNeeded += (lstrlenW(package->infoW.Name) + 1) * sizeof(WCHAR);
            if (package->infoW.Comment)
                bytesNeeded += (lstrlenW(package->infoW.Comment) + 1) * sizeof(WCHAR);
        }
        if (bytesNeeded)
        {
            *ppPackageInfo = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
            if (*ppPackageInfo)
            {
                ULONG i = 0;
                PWSTR nextString;
 
                *pcPackages = packageTable->numPackages;
                nextString = (PWSTR)((PBYTE)*ppPackageInfo +
                 packageTable->numPackages * sizeof(SecPkgInfoW));
                LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
                {
                    PSecPkgInfoW pkgInfo = *ppPackageInfo + i++;
 
                    *pkgInfo = package->infoW;
                    if (package->infoW.Name)
                    {
                        TRACE("Name[%d] = %S\n", i - 1, package->infoW.Name);
                        pkgInfo->Name = nextString;
                        lstrcpyW(nextString, package->infoW.Name);
                        nextString += lstrlenW(nextString) + 1;
                    }
                    else
                        pkgInfo->Name = NULL;
                    if (package->infoW.Comment)
                    {
                        TRACE("Comment[%d] = %S\n", i - 1, package->infoW.Comment);
                        pkgInfo->Comment = nextString;
                        lstrcpyW(nextString, package->infoW.Comment);
                        nextString += lstrlenW(nextString) + 1;
                    }
                    else
                        pkgInfo->Comment = NULL;
                }
            }
            else
                ret = SEC_E_INSUFFICIENT_MEMORY;
        }
    }
    LeaveCriticalSection(&cs);
    TRACE("<-- 0x%08x\n", ret);
    return ret;
}

Referenced by schan_EnumerateSecurityPackagesA().

schan_FreeContextBuffer()

SECURITY_STATUS WINAPI schan_FreeContextBuffer

(

PVOID

pvoid

)

Definition at line 221 of file secur32_wine.c.

{
    HeapFree(GetProcessHeap(), 0, pvoid);
    return SEC_E_OK;
}

Referenced by schan_EnumerateSecurityPackagesA().

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);
}

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;
}

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_strdupW()

static PWSTR SECUR32_strdupW ( PCWSTR  str )

static

Definition at line 231 of file secur32_wine.c.

{
    PWSTR ret;
 
    if (str)
    {
        ret = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(str) + 1) * sizeof(WCHAR));
        if (ret)
            lstrcpyW(ret, str);
    }
    else
        ret = NULL;
    return ret;
}

Referenced by _copyPackageInfo(), and SECUR32_addProvider().

thunk_PSecPkgInfoWToA()

static PSecPkgInfoA thunk_PSecPkgInfoWToA ( ULONG  cPackages, const SecPkgInfoW *  info  )

static

Definition at line 129 of file secur32_wine.c.

{
    PSecPkgInfoA ret;
 
    if (info)
    {
        size_t bytesNeeded = cPackages * sizeof(SecPkgInfoA);
        ULONG i;
 
        for (i = 0; i < cPackages; i++)
        {
            if (info[i].Name)
                bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info[i].Name,
                 -1, NULL, 0, NULL, NULL);
            if (info[i].Comment)
                bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info[i].Comment,
                 -1, NULL, 0, NULL, NULL);
        }
        ret = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
        if (ret)
        {
            PSTR nextString;
 
            nextString = (PSTR)((PBYTE)ret + cPackages * sizeof(SecPkgInfoA));
            for (i = 0; i < cPackages; i++)
            {
                PSecPkgInfoA pkgInfo = ret + i;
                int bytes;
 
                memcpy(pkgInfo, &info[i], sizeof(SecPkgInfoA));
                if (info[i].Name)
                {
                    pkgInfo->Name = nextString;
                    /* just repeat back to WideCharToMultiByte how many bytes
                     * it requires, since we asked it earlier
                     */
                    bytes = WideCharToMultiByte(CP_ACP, 0, info[i].Name, -1,
                     NULL, 0, NULL, NULL);
                    WideCharToMultiByte(CP_ACP, 0, info[i].Name, -1,
                     pkgInfo->Name, bytes, NULL, NULL);
                    nextString += lstrlenA(nextString) + 1;
                }
                else
                    pkgInfo->Name = NULL;
                if (info[i].Comment)
                {
                    pkgInfo->Comment = nextString;
                    /* just repeat back to WideCharToMultiByte how many bytes
                     * it requires, since we asked it earlier
                     */
                    bytes = WideCharToMultiByte(CP_ACP, 0, info[i].Comment, -1,
                     NULL, 0, NULL, NULL);
                    WideCharToMultiByte(CP_ACP, 0, info[i].Comment, -1,
                     pkgInfo->Comment, bytes, NULL, NULL);
                    nextString += lstrlenA(nextString) + 1;
                }
                else
                    pkgInfo->Comment = NULL;
            }
        }
    }
    else
        ret = NULL;
    return ret;
}

Referenced by schan_EnumerateSecurityPackagesA().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

schannel

)

Variable Documentation

cs

CRITICAL_SECTION cs = { &cs_debug, -1, 0, 0, 0, 0 }

static

Globals

Definition at line 44 of file secur32_wine.c.

Referenced by schan_EnumerateSecurityPackagesW(), SECUR32_addPackages(), and SECUR32_addProvider().

cs_debug

CRITICAL_SECTION_DEBUG cs_debug

static

Initial value:

=
{
    0, 0, &cs,
    { &cs_debug.ProcessLocksList, &cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": cs") }
}

Definition at line 45 of file secur32_wine.c.

packageTable

SecurePackageTable* packageTable = NULL

static

Definition at line 52 of file secur32_wine.c.

Referenced by schan_EnumerateSecurityPackagesW(), and SECUR32_addPackages().

providerTable

SecureProviderTable* providerTable = NULL

static

Definition at line 53 of file secur32_wine.c.

Referenced by SECUR32_addProvider().