main.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include "ntstatus.h"
#include <windef.h>
#include <winbase.h>
#include <security.h>
#include <schannel.h>
#include <ntsecapi.h>
#include <ntsecpkg.h>
#include "wine/test.h"

Include dependency graph for main.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	SECURITY_WIN32
#define	SECPKG_FUNCTION_TABLE_SIZE_1
#define	SECPKG_FUNCTION_TABLE_SIZE_2
#define	SECPKG_FUNCTION_TABLE_SIZE_3
#define	SECPKG_FUNCTION_TABLE_SIZE_4
#define	SECPKG_FUNCTION_TABLE_SIZE_5
#define	SECPKG_FUNCTION_TABLE_SIZE_6
#define	SECPKG_FUNCTION_TABLE_SIZE_7   sizeof(SECPKG_FUNCTION_TABLE)
#define	LSA_BASE_CAPS

Functions
static	NTSTATUS (NTAPI *pSpLsaModeInitialize)(ULONG
static void	testInitialize (void)
static PSECPKG_FUNCTION_TABLE	getNextSecPkgTable (PSECPKG_FUNCTION_TABLE pTable, ULONG Version)
static void	testGetInfo (void)
	START_TEST (main)

Variables
static	PULONG

Macro Definition Documentation

LSA_BASE_CAPS

#define LSA_BASE_CAPS

Value:

    ( \
    SECPKG_FLAG_INTEGRITY         | \
    SECPKG_FLAG_PRIVACY           | \
    SECPKG_FLAG_CONNECTION        | \
    SECPKG_FLAG_MULTI_REQUIRED    | \
    SECPKG_FLAG_EXTENDED_ERROR    | \
    SECPKG_FLAG_IMPERSONATION     | \
    SECPKG_FLAG_ACCEPT_WIN32_NAME | \
    SECPKG_FLAG_STREAM            | \
    SECPKG_FLAG_MUTUAL_AUTH )

Definition at line 50 of file main.c.

SECPKG_FUNCTION_TABLE_SIZE_1

#define SECPKG_FUNCTION_TABLE_SIZE_1

Value:

    FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
    SetContextAttributes)

Definition at line 36 of file main.c.

SECPKG_FUNCTION_TABLE_SIZE_2

#define SECPKG_FUNCTION_TABLE_SIZE_2

Value:

    FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
    SetCredentialsAttributes)

Definition at line 38 of file main.c.

SECPKG_FUNCTION_TABLE_SIZE_3

#define SECPKG_FUNCTION_TABLE_SIZE_3

Value:

    FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
    ChangeAccountPassword)

Definition at line 40 of file main.c.

SECPKG_FUNCTION_TABLE_SIZE_4

#define SECPKG_FUNCTION_TABLE_SIZE_4

Value:

    FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
    QueryMetaData)

Definition at line 42 of file main.c.

SECPKG_FUNCTION_TABLE_SIZE_5

#define SECPKG_FUNCTION_TABLE_SIZE_5

Value:

    FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
    ValidateTargetInfo)

Definition at line 44 of file main.c.

SECPKG_FUNCTION_TABLE_SIZE_6

#define SECPKG_FUNCTION_TABLE_SIZE_6

Value:

    FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
    PostLogonUser)

Definition at line 46 of file main.c.

SECPKG_FUNCTION_TABLE_SIZE_7

#define SECPKG_FUNCTION_TABLE_SIZE_7   sizeof(SECPKG_FUNCTION_TABLE)

Definition at line 48 of file main.c.

SECURITY_WIN32

#define SECURITY_WIN32

Definition at line 27 of file main.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 24 of file main.c.

Function Documentation

getNextSecPkgTable()

static PSECPKG_FUNCTION_TABLE getNextSecPkgTable ( PSECPKG_FUNCTION_TABLE  pTable, ULONG  Version  )

static

Definition at line 139 of file main.c.

{
    size_t size;
    PSECPKG_FUNCTION_TABLE pNextTable;
 
    if (Version == SECPKG_INTERFACE_VERSION)
        size = SECPKG_FUNCTION_TABLE_SIZE_1;
    else if (Version == SECPKG_INTERFACE_VERSION_2)
        size = SECPKG_FUNCTION_TABLE_SIZE_2;
    else if (Version == SECPKG_INTERFACE_VERSION_3)
        size = SECPKG_FUNCTION_TABLE_SIZE_3;
    else if (Version == SECPKG_INTERFACE_VERSION_4)
        size = SECPKG_FUNCTION_TABLE_SIZE_4;
    else if (Version == SECPKG_INTERFACE_VERSION_5)
        size = SECPKG_FUNCTION_TABLE_SIZE_5;
    else if (Version == SECPKG_INTERFACE_VERSION_6)
        size = SECPKG_FUNCTION_TABLE_SIZE_6;
    else if (Version == SECPKG_INTERFACE_VERSION_7)
        size = SECPKG_FUNCTION_TABLE_SIZE_7;
    else {
        ok(FALSE, "Unknown package version 0x%x\n", Version);
        return NULL;
    }
 
    pNextTable = (PSECPKG_FUNCTION_TABLE)((PBYTE)pTable + size);
    /* Win7 function tables appear to be SECPKG_INTERFACE_VERSION_6 format,
       but unfortunately SpLsaModeInitialize returns SECPKG_INTERFACE_VERSION_3.
       We detect that by comparing the "Initialize" pointer from the old table
       to the "FreeCredentialsHandle" pointer of the new table. These functions
       have different numbers of arguments, so they can't possibly point to the
       same implementation */
    if (broken((void *) pTable->Initialize == (void *) pNextTable->FreeCredentialsHandle &&
               pNextTable->FreeCredentialsHandle != NULL))
    {
        win_skip("Invalid function pointers for next package\n");
        return NULL;
    }
 
    return pNextTable;
}

Referenced by testGetInfo().

NTSTATUS()

static NTSTATUS ( NTAPI *  pSpLsaModeInitialize )

static

START_TEST()

START_TEST

(

main

)

Definition at line 240 of file main.c.

{
    HMODULE hMod = LoadLibraryA("schannel.dll");
    if (!hMod) {
        win_skip("schannel.dll not available\n");
        return;
    }
 
    pSpLsaModeInitialize  = (void *)GetProcAddress(hMod, "SpLsaModeInitialize");
    pSpUserModeInitialize = (void *)GetProcAddress(hMod, "SpUserModeInitialize");
 
    if (pSpLsaModeInitialize && pSpUserModeInitialize)
    {
        testInitialize();
        testGetInfo();
    }
    else win_skip( "schannel functions not found\n" );
 
    FreeLibrary(hMod);
}

testGetInfo()

static void testGetInfo ( void  )

static

Definition at line 181 of file main.c.

{
    PSECPKG_FUNCTION_TABLE pTables;
    SecPkgInfoW PackageInfo;
    ULONG cTables, Version;
    NTSTATUS status;
 
    /* Get the dispatch table */
    status = pSpLsaModeInitialize(0, &Version, &pTables, &cTables);
    ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
 
    /* Passing NULL into ->GetInfo causes a crash. */
 
    /* First package: Unified */
    status = pTables->GetInfo(&PackageInfo);
    ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
    ok(PackageInfo.fCapabilities == LSA_BASE_CAPS ||
       PackageInfo.fCapabilities == (LSA_BASE_CAPS|SECPKG_FLAG_APPCONTAINER_PASSTHROUGH),
       "fCapabilities: 0x%x\n", PackageInfo.fCapabilities);
    ok(PackageInfo.wVersion == 1, "wVersion: %d\n", PackageInfo.wVersion);
    ok(PackageInfo.wRPCID == 14, "wRPCID: %d\n", PackageInfo.wRPCID);
    ok(PackageInfo.cbMaxToken == 0x4000 ||
       PackageInfo.cbMaxToken == 0x6000, /* Vista */
       "cbMaxToken: 0x%x\n",
       PackageInfo.cbMaxToken);
 
    /* Second package */
    if (cTables == 1)
    {
        win_skip("Second package missing\n");
        return;
    }
    pTables = getNextSecPkgTable(pTables, Version);
    if (!pTables)
        return;
    if (!pTables->GetInfo)
    {
        win_skip("GetInfo function missing\n");
        return;
    }
    status = pTables->GetInfo(&PackageInfo);
    ok(SUCCEEDED(status) ||
       status == SEC_E_UNSUPPORTED_FUNCTION, /* win2k3 */
       "status: 0x%x\n", status);
 
    if (SUCCEEDED(status))
    {
        ok(PackageInfo.fCapabilities == LSA_BASE_CAPS ||
           PackageInfo.fCapabilities == (LSA_BASE_CAPS|SECPKG_FLAG_APPCONTAINER_PASSTHROUGH),
           "fCapabilities: 0x%x\n", PackageInfo.fCapabilities);
        ok(PackageInfo.wVersion == 1, "wVersion: %d\n", PackageInfo.wVersion);
        ok(PackageInfo.wRPCID == 14, "wRPCID: %d\n", PackageInfo.wRPCID);
        ok(PackageInfo.cbMaxToken == 0x4000 ||
           PackageInfo.cbMaxToken == 0x6000, /* Win7 */
           "cbMaxToken: 0x%x\n",
           PackageInfo.cbMaxToken);
    }
}

Referenced by START_TEST().

testInitialize()

static void testInitialize ( void  )

static

Definition at line 66 of file main.c.

{
    PSECPKG_USER_FUNCTION_TABLE pUserTables, pUserTables2;
    PSECPKG_FUNCTION_TABLE pTables, pTables2;
    ULONG cTables = 0, cUserTables = 0, Version = 0;
    NTSTATUS status;
 
    /* Passing NULL into one of the parameters of SpLsaModeInitialize or
       SpUserModeInitialize causes a crash. */
 
    /* SpLsaModeInitialize does not care about the LSA version. */
    status = pSpLsaModeInitialize(0, &Version, &pTables2, &cTables);
    ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
    ok(cTables == 2 ||
       broken(cTables == 1), /* Win2k */
       "cTables: %d\n", cTables);
    ok(pTables2 != NULL,"pTables: %p\n", pTables2);
 
    /* We can call it as many times we want. */
    status = pSpLsaModeInitialize(0x10000, &Version, &pTables, &cTables);
    ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
    ok(cTables == 2 ||
       broken(cTables == 1), /* Win2k */
       "cTables: %d\n", cTables);
    ok(pTables != NULL, "pTables: %p\n", pTables);
    /* It will always return the same pointer. */
    ok(pTables == pTables2, "pTables: %p, pTables2: %p\n", pTables, pTables2);
 
    status = pSpLsaModeInitialize(0x23456, &Version, &pTables, &cTables);
    ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
    ok(cTables == 2 ||
       broken(cTables == 1), /* Win2k */
       "cTables: %d\n", cTables);
    ok(pTables != NULL, "pTables: %p\n", pTables);
    ok(pTables == pTables2, "pTables: %p, pTables2: %p\n", pTables, pTables2);
 
    /* Bad versions to SpUserModeInitialize. Parameters unchanged */
    Version = 0xdead;
    cUserTables = 0xdead;
    pUserTables = NULL;
    status = pSpUserModeInitialize(0, &Version, &pUserTables, &cUserTables);
    ok(status == STATUS_INVALID_PARAMETER, "status: 0x%x\n", status);
    ok(Version == 0xdead, "Version: 0x%x\n", Version);
    ok(cUserTables == 0xdead, "cTables: %d\n", cUserTables);
    ok(pUserTables == NULL, "pUserTables: %p\n", pUserTables);
 
    status = pSpUserModeInitialize(0x20000, &Version, &pUserTables,
                                   &cUserTables);
    ok(status == STATUS_INVALID_PARAMETER, "status: 0x%x\n", status);
    ok(Version == 0xdead, "Version: 0x%x\n", Version);
    ok(cUserTables == 0xdead, "cTables: %d\n", cUserTables);
    ok(pUserTables == NULL, "pUserTables: %p\n", pUserTables);
 
    /* Good version to SpUserModeInitialize */
    status = pSpUserModeInitialize(SECPKG_INTERFACE_VERSION, &Version,
                                   &pUserTables, &cUserTables);
    ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
    ok(Version == SECPKG_INTERFACE_VERSION, "Version: 0x%x\n", Version);
    ok(cUserTables == 2 ||
       broken(cUserTables == 4), /* Win2k */
       "cUserTables: %d\n", cUserTables);
    ok(pUserTables != NULL, "pUserTables: %p\n", pUserTables);
 
    /* Initializing user again */
    status = pSpUserModeInitialize(SECPKG_INTERFACE_VERSION, &Version,
                                   &pUserTables2, &cTables);
    ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
    ok(pUserTables == pUserTables2, "pUserTables: %p, pUserTables2: %p\n",
       pUserTables, pUserTables2);
}

Referenced by START_TEST(), and test_provider_funcs().

Variable Documentation

PULONG

PSECPKG_USER_FUNCTION_TABLE PULONG

Definition at line 61 of file main.c.