mscat.h File Reference

#include <mssip.h>
#include <pshpack8.h>
#include <poppack.h>

Include dependency graph for mscat.h:

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

Go to the source code of this file.

Classes
struct	CRYPTCATATTRIBUTE_
struct	CRYPTCATMEMBER_
struct	CATALOG_INFO_
struct	CRYPTCATCDF_

Macros
#define	CRYPTCAT_OPEN_CREATENEW   0x00000001
#define	CRYPTCAT_OPEN_ALWAYS   0x00000002
#define	CRYPTCAT_OPEN_EXISTING   0x00000004
#define	CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES   0x00010000
#define	CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES   0x00020000
#define	CRYPTCAT_OPEN_VERIFYSIGHASH   0x10000000
#define	CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG   0x20000000
#define	CRYPTCAT_OPEN_SORTED   0x40000000
#define	CRYPTCAT_OPEN_FLAGS_MASK   0xffff0000
#define	CRYPTCAT_E_AREA_HEADER   0x00000000
#define	CRYPTCAT_E_AREA_MEMBER   0x00010000
#define	CRYPTCAT_E_AREA_ATTRIBUTE   0x00020000
#define	CRYPTCAT_E_CDF_UNSUPPORTED   0x00000001
#define	CRYPTCAT_E_CDF_DUPLICATE   0x00000002
#define	CRYPTCAT_E_CDF_TAGNOTFOUND   0x00000004
#define	CRYPTCAT_E_CDF_MEMBER_FILE_PATH   0x00010001
#define	CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA   0x00010002
#define	CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND   0x00010004
#define	CRYPTCAT_E_CDF_BAD_GUID_CONV   0x00020001
#define	CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES   0x00020002
#define	CRYPTCAT_E_CDF_ATTR_TYPECOMBO   0x00020004

Typedefs
typedef HANDLE	HCATADMIN
typedef HANDLE	HCATINFO
typedef struct CRYPTCATATTRIBUTE_	CRYPTCATATTRIBUTE
typedef struct CRYPTCATMEMBER_	CRYPTCATMEMBER
typedef struct CATALOG_INFO_	CATALOG_INFO
typedef struct CRYPTCATCDF_	CRYPTCATCDF
typedef void(WINAPI *	PFN_CDF_PARSE_ERROR_CALLBACK) (DWORD, DWORD, WCHAR *)

Functions
BOOL WINAPI	CryptCATAdminAcquireContext (HCATADMIN *, const GUID *, DWORD)
HCATINFO WINAPI	CryptCATAdminAddCatalog (HCATADMIN, PWSTR, PWSTR, DWORD)
BOOL WINAPI	CryptCATAdminCalcHashFromFileHandle (HANDLE, DWORD *, BYTE *, DWORD)
HCATINFO WINAPI	CryptCATAdminEnumCatalogFromHash (HCATADMIN, BYTE *, DWORD, DWORD, HCATINFO *)
BOOL WINAPI	CryptCATAdminReleaseCatalogContext (HCATADMIN, HCATINFO, DWORD)
BOOL WINAPI	CryptCATAdminReleaseContext (HCATADMIN, DWORD)
BOOL WINAPI	CryptCATAdminRemoveCatalog (HCATADMIN, LPCWSTR, DWORD)
BOOL WINAPI	CryptCATAdminResolveCatalogPath (HCATADMIN, WCHAR *, CATALOG_INFO *, DWORD)
BOOL WINAPI	CryptCATCatalogInfoFromContext (HCATINFO, CATALOG_INFO *, DWORD)
BOOL WINAPI	CryptCATCDFClose (CRYPTCATCDF *)
CRYPTCATATTRIBUTE *WINAPI	CryptCATCDFEnumCatAttributes (CRYPTCATCDF *, CRYPTCATATTRIBUTE *, PFN_CDF_PARSE_ERROR_CALLBACK)
LPWSTR WINAPI	CryptCATCDFEnumMembersByCDFTagEx (CRYPTCATCDF *, LPWSTR, PFN_CDF_PARSE_ERROR_CALLBACK, CRYPTCATMEMBER **, BOOL, LPVOID)
CRYPTCATCDF *WINAPI	CryptCATCDFOpen (LPWSTR, PFN_CDF_PARSE_ERROR_CALLBACK)
BOOL WINAPI	CryptCATClose (HANDLE)
CRYPTCATATTRIBUTE *WINAPI	CryptCATEnumerateAttr (HANDLE, CRYPTCATMEMBER *, CRYPTCATATTRIBUTE *)
CRYPTCATATTRIBUTE *WINAPI	CryptCATEnumerateCatAttr (HANDLE, CRYPTCATATTRIBUTE *)
CRYPTCATMEMBER *WINAPI	CryptCATEnumerateMember (HANDLE, CRYPTCATMEMBER *)
CRYPTCATATTRIBUTE *WINAPI	CryptCATGetAttrInfo (HANDLE, CRYPTCATMEMBER *, LPWSTR)
CRYPTCATATTRIBUTE *WINAPI	CryptCATGetCatAttrInfo (HANDLE, LPWSTR)
CRYPTCATMEMBER *WINAPI	CryptCATGetMemberInfo (HANDLE, LPWSTR)
HANDLE WINAPI	CryptCATOpen (LPWSTR, DWORD, HCRYPTPROV, DWORD, DWORD)

Macro Definition Documentation

CRYPTCAT_E_AREA_ATTRIBUTE

#define CRYPTCAT_E_AREA_ATTRIBUTE   0x00020000

Definition at line 43 of file mscat.h.

CRYPTCAT_E_AREA_HEADER

#define CRYPTCAT_E_AREA_HEADER   0x00000000

Definition at line 41 of file mscat.h.

CRYPTCAT_E_AREA_MEMBER

#define CRYPTCAT_E_AREA_MEMBER   0x00010000

Definition at line 42 of file mscat.h.

CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES

#define CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES   0x00020002

Definition at line 54 of file mscat.h.

CRYPTCAT_E_CDF_ATTR_TYPECOMBO

#define CRYPTCAT_E_CDF_ATTR_TYPECOMBO   0x00020004

Definition at line 55 of file mscat.h.

CRYPTCAT_E_CDF_BAD_GUID_CONV

#define CRYPTCAT_E_CDF_BAD_GUID_CONV   0x00020001

Definition at line 53 of file mscat.h.

CRYPTCAT_E_CDF_DUPLICATE

#define CRYPTCAT_E_CDF_DUPLICATE   0x00000002

Definition at line 46 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_FILE_PATH

#define CRYPTCAT_E_CDF_MEMBER_FILE_PATH   0x00010001

Definition at line 49 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND

#define CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND   0x00010004

Definition at line 51 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA

#define CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA   0x00010002

Definition at line 50 of file mscat.h.

CRYPTCAT_E_CDF_TAGNOTFOUND

#define CRYPTCAT_E_CDF_TAGNOTFOUND   0x00000004

Definition at line 47 of file mscat.h.

CRYPTCAT_E_CDF_UNSUPPORTED

#define CRYPTCAT_E_CDF_UNSUPPORTED   0x00000001

Definition at line 45 of file mscat.h.

CRYPTCAT_OPEN_ALWAYS

#define CRYPTCAT_OPEN_ALWAYS   0x00000002

Definition at line 32 of file mscat.h.

CRYPTCAT_OPEN_CREATENEW

#define CRYPTCAT_OPEN_CREATENEW   0x00000001

Definition at line 31 of file mscat.h.

CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES

#define CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES   0x00010000

Definition at line 34 of file mscat.h.

CRYPTCAT_OPEN_EXISTING

#define CRYPTCAT_OPEN_EXISTING   0x00000004

Definition at line 33 of file mscat.h.

CRYPTCAT_OPEN_FLAGS_MASK

#define CRYPTCAT_OPEN_FLAGS_MASK   0xffff0000

Definition at line 39 of file mscat.h.

CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES

#define CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES   0x00020000

Definition at line 35 of file mscat.h.

CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG

#define CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG   0x20000000

Definition at line 37 of file mscat.h.

CRYPTCAT_OPEN_SORTED

#define CRYPTCAT_OPEN_SORTED   0x40000000

Definition at line 38 of file mscat.h.

CRYPTCAT_OPEN_VERIFYSIGHASH

#define CRYPTCAT_OPEN_VERIFYSIGHASH   0x10000000

Definition at line 36 of file mscat.h.

Typedef Documentation

CATALOG_INFO

typedef struct CATALOG_INFO_ CATALOG_INFO

CRYPTCATATTRIBUTE

typedef struct CRYPTCATATTRIBUTE_ CRYPTCATATTRIBUTE

CRYPTCATCDF

typedef struct CRYPTCATCDF_ CRYPTCATCDF

CRYPTCATMEMBER

typedef struct CRYPTCATMEMBER_ CRYPTCATMEMBER

HCATADMIN

typedef HANDLE HCATADMIN

Definition at line 24 of file mscat.h.

HCATINFO

typedef HANDLE HCATINFO

Definition at line 25 of file mscat.h.

PFN_CDF_PARSE_ERROR_CALLBACK

typedef void(WINAPI * PFN_CDF_PARSE_ERROR_CALLBACK) (DWORD, DWORD, WCHAR *)

Definition at line 103 of file mscat.h.

Function Documentation

CryptCATAdminAcquireContext()

BOOL WINAPI CryptCATAdminAcquireContext	(	HCATADMIN *	catAdmin,
		const GUID *	sys,
		DWORD	dwFlags
	)

Definition at line 97 of file crypt.c.

{
    static const WCHAR catroot[] =
        {'\\','c','a','t','r','o','o','t',0};
    static const WCHAR fmt[] =
        {'%','s','\\','{','%','0','8','x','-','%','0','4','x','-','%','0',
         '4','x','-','%','0','2','x','%','0','2','x','-','%','0','2','x',
         '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',
         '%','0','2','x','}',0};
    static const GUID defsys =
        {0x127d0a1d,0x4ef2,0x11d1,{0x86,0x08,0x00,0xc0,0x4f,0xc2,0x95,0xee}};
 
    WCHAR catroot_dir[MAX_PATH];
    struct catadmin *ca;
 
    TRACE("%p %s %x\n", catAdmin, debugstr_guid(sys), dwFlags);
 
    if (!catAdmin || dwFlags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (!(ca = HeapAlloc(GetProcessHeap(), 0, sizeof(*ca))))
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    GetSystemDirectoryW(catroot_dir, MAX_PATH);
    lstrcatW(catroot_dir, catroot);
 
    /* create the directory if it doesn't exist */
    CreateDirectoryW(catroot_dir, NULL);
 
    if (!sys) sys = &defsys;
    swprintf(ca->path, fmt, catroot_dir, sys->Data1, sys->Data2,
             sys->Data3, sys->Data4[0], sys->Data4[1], sys->Data4[2],
             sys->Data4[3], sys->Data4[4], sys->Data4[5], sys->Data4[6],
             sys->Data4[7]);
 
    /* create the directory if it doesn't exist */
    CreateDirectoryW(ca->path, NULL);
 
    ca->magic = CATADMIN_MAGIC;
    ca->find = INVALID_HANDLE_VALUE;
 
    *catAdmin = ca;
    return TRUE;
}

Referenced by InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminAddCatalog()

HCATINFO WINAPI CryptCATAdminAddCatalog	(	HCATADMIN	catAdmin,
		PWSTR	catalogFile,
		PWSTR	selectBaseName,
		DWORD	flags
	)

Definition at line 162 of file crypt.c.

{
    static const WCHAR slashW[] = {'\\',0};
    struct catadmin *ca = catAdmin;
    struct catinfo *ci;
    WCHAR *target;
    DWORD len;
 
    TRACE("%p %s %s %d\n", catAdmin, debugstr_w(catalogFile),
          debugstr_w(selectBaseName), flags);
 
    if (!selectBaseName)
    {
        FIXME("NULL basename not handled\n");
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    if (!ca || ca->magic != CATADMIN_MAGIC || !catalogFile || flags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    len = lstrlenW(ca->path) + lstrlenW(selectBaseName) + 2;
    if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
    lstrcpyW(target, ca->path);
    lstrcatW(target, slashW);
    lstrcatW(target, selectBaseName);
 
    if (!CopyFileW(catalogFile, target, FALSE))
    {
        HeapFree(GetProcessHeap(), 0, target);
        return NULL;
    }
    SetFileAttributesW(target, FILE_ATTRIBUTE_SYSTEM);
 
    if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci))))
    {
        HeapFree(GetProcessHeap(), 0, target);
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
    ci->magic = CATINFO_MAGIC;
    lstrcpyW(ci->file, target);
 
    HeapFree(GetProcessHeap(), 0, target);
    return ci;
}

Referenced by InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminCalcHashFromFileHandle()

BOOL WINAPI CryptCATAdminCalcHashFromFileHandle	(	HANDLE	hFile,
		DWORD *	pcbHash,
		BYTE *	pbHash,
		DWORD	dwFlags
	)

Definition at line 219 of file crypt.c.

{
    BOOL ret = FALSE;
 
    TRACE("%p %p %p %x\n", hFile, pcbHash, pbHash, dwFlags);
 
    if (!hFile || !pcbHash || dwFlags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (*pcbHash < 20)
    {
        *pcbHash = 20;
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return TRUE;
    }
 
    *pcbHash = 20;
    if (pbHash)
    {
        HCRYPTPROV prov;
        HCRYPTHASH hash;
        DWORD bytes_read;
        BYTE *buffer;
 
        if (!(buffer = HeapAlloc(GetProcessHeap(), 0, 4096)))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
        ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
        if (!ret)
        {
            HeapFree(GetProcessHeap(), 0, buffer);
            return FALSE;
        }
        ret = CryptCreateHash(prov, CALG_SHA1, 0, 0, &hash);
        if (!ret)
        {
            HeapFree(GetProcessHeap(), 0, buffer);
            CryptReleaseContext(prov, 0);
            return FALSE;
        }
        while ((ret = ReadFile(hFile, buffer, 4096, &bytes_read, NULL)) && bytes_read)
        {
            CryptHashData(hash, buffer, bytes_read, 0);
        }
        if (ret) ret = CryptGetHashParam(hash, HP_HASHVAL, pbHash, pcbHash, 0);
 
        HeapFree(GetProcessHeap(), 0, buffer);
        CryptDestroyHash(hash);
        CryptReleaseContext(prov, 0);
    }
    return ret;
}

Referenced by InitFunctionPtrs().

CryptCATAdminEnumCatalogFromHash()

HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash	(	HCATADMIN	hCatAdmin,
		BYTE *	pbHash,
		DWORD	cbHash,
		DWORD	dwFlags,
		HCATINFO *	phPrevCatInfo
	)

Definition at line 280 of file crypt.c.

{
    static const WCHAR slashW[] = {'\\',0};
    static const WCHAR globW[]  = {'\\','*','.','c','a','t',0};
 
    struct catadmin *ca = hCatAdmin;
    WIN32_FIND_DATAW data;
    HCATINFO prev = NULL;
    HCRYPTPROV prov;
    DWORD size;
    BOOL ret;
 
    TRACE("%p %p %d %x %p\n", hCatAdmin, pbHash, cbHash, dwFlags, phPrevCatInfo);
 
    if (!ca || ca->magic != CATADMIN_MAGIC || !pbHash || cbHash != 20 || dwFlags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    if (phPrevCatInfo) prev = *phPrevCatInfo;
 
    ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
    if (!ret) return NULL;
 
    if (!prev)
    {
        WCHAR *path;
 
        size = lstrlenW(ca->path) * sizeof(WCHAR) + sizeof(globW);
        if (!(path = HeapAlloc(GetProcessHeap(), 0, size)))
        {
            CryptReleaseContext(prov, 0);
            SetLastError(ERROR_OUTOFMEMORY);
            return NULL;
        }
        lstrcpyW(path, ca->path);
        lstrcatW(path, globW);
 
        FindClose(ca->find);
        ca->find = FindFirstFileW(path, &data);
 
        HeapFree(GetProcessHeap(), 0, path);
        if (ca->find == INVALID_HANDLE_VALUE)
        {
            CryptReleaseContext(prov, 0);
            return NULL;
        }
    }
    else if (!FindNextFileW(ca->find, &data))
    {
        CryptCATAdminReleaseCatalogContext(hCatAdmin, prev, 0);
        CryptReleaseContext(prov, 0);
        return NULL;
    }
 
    while (1)
    {
        WCHAR *filename;
        CRYPTCATMEMBER *member = NULL;
        struct catinfo *ci;
        HANDLE hcat;
 
        size = (lstrlenW(ca->path) + lstrlenW(data.cFileName) + 2) * sizeof(WCHAR);
        if (!(filename = HeapAlloc(GetProcessHeap(), 0, size)))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return NULL;
        }
        lstrcpyW(filename, ca->path);
        lstrcatW(filename, slashW);
        lstrcatW(filename, data.cFileName);
 
        hcat = CryptCATOpen(filename, CRYPTCAT_OPEN_EXISTING, prov, 0, 0);
        if (hcat == INVALID_HANDLE_VALUE)
        {
            WARN("couldn't open %s (%u)\n", debugstr_w(filename), GetLastError());
            continue;
        }
        while ((member = CryptCATEnumerateMember(hcat, member)))
        {
            if (member->pIndirectData->Digest.cbData != cbHash)
            {
                WARN("amount of hash bytes differs: %u/%u\n", member->pIndirectData->Digest.cbData, cbHash);
                continue;
            }
            if (!memcmp(member->pIndirectData->Digest.pbData, pbHash, cbHash))
            {
                TRACE("file %s matches\n", debugstr_w(data.cFileName));
 
                CryptCATClose(hcat);
                CryptReleaseContext(prov, 0);
                if (!phPrevCatInfo)
                {
                    FindClose(ca->find);
                    ca->find = INVALID_HANDLE_VALUE;
                }
                ci = create_catinfo(filename);
                HeapFree(GetProcessHeap(), 0, filename);
                return ci;
            }
        }
        CryptCATClose(hcat);
        HeapFree(GetProcessHeap(), 0, filename);
 
        if (!FindNextFileW(ca->find, &data))
        {
            FindClose(ca->find);
            ca->find = INVALID_HANDLE_VALUE;
            CryptReleaseContext(prov, 0);
            return NULL;
        }
    }
    return NULL;
}

CryptCATAdminReleaseCatalogContext()

BOOL WINAPI CryptCATAdminReleaseCatalogContext	(	HCATADMIN	hCatAdmin,
		HCATINFO	hCatInfo,
		DWORD	dwFlags
	)

Definition at line 412 of file crypt.c.

{
    struct catinfo *ci = hCatInfo;
    struct catadmin *ca = hCatAdmin;
 
    TRACE("%p %p %x\n", hCatAdmin, hCatInfo, dwFlags);
 
    if (!ca || ca->magic != CATADMIN_MAGIC || !ci || ci->magic != CATINFO_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    ci->magic = 0;
    return HeapFree(GetProcessHeap(), 0, ci);
}

Referenced by CryptCATAdminEnumCatalogFromHash(), InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminReleaseContext()

BOOL WINAPI CryptCATAdminReleaseContext	(	HCATADMIN	hCatAdmin,
		DWORD	dwFlags
	)

Definition at line 444 of file crypt.c.

{
    struct catadmin *ca = hCatAdmin;
 
    TRACE("%p %x\n", hCatAdmin, dwFlags);
 
    if (!ca || ca->magic != CATADMIN_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (ca->find != INVALID_HANDLE_VALUE) FindClose(ca->find);
    ca->magic = 0;
    return HeapFree(GetProcessHeap(), 0, ca);
}

Referenced by InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminRemoveCatalog()

BOOL WINAPI CryptCATAdminRemoveCatalog	(	HCATADMIN	hCatAdmin,
		LPCWSTR	pwszCatalogFile,
		DWORD	dwFlags
	)

Definition at line 475 of file crypt.c.

{
    struct catadmin *ca = hCatAdmin;
 
    TRACE("%p %s %x\n", hCatAdmin, debugstr_w(pwszCatalogFile), dwFlags);
 
    if (!ca || ca->magic != CATADMIN_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* Only delete when there is a filename and no path */
    if (pwszCatalogFile && pwszCatalogFile[0] != 0 &&
        !wcschr(pwszCatalogFile, '\\') && !wcschr(pwszCatalogFile, '/') &&
        !wcschr(pwszCatalogFile, ':'))
    {
        static const WCHAR slashW[] = {'\\',0};
        WCHAR *target;
        DWORD len;
 
        len = lstrlenW(ca->path) + lstrlenW(pwszCatalogFile) + 2;
        if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
        lstrcpyW(target, ca->path);
        lstrcatW(target, slashW);
        lstrcatW(target, pwszCatalogFile);
 
        DeleteFileW(target);
 
        HeapFree(GetProcessHeap(), 0, target);
    }
 
    return TRUE;
}

Referenced by InitFunctionPtrs().

CryptCATAdminResolveCatalogPath()

BOOL WINAPI CryptCATAdminResolveCatalogPath	(	HCATADMIN	hcatadmin,
		WCHAR *	catalog_file,
		CATALOG_INFO *	info,
		DWORD	flags
	)

Definition at line 517 of file crypt.c.

{
    static const WCHAR slashW[] = {'\\',0};
    struct catadmin *ca = hcatadmin;
 
    TRACE("%p %s %p %x\n", hcatadmin, debugstr_w(catalog_file), info, flags);
 
    if (!ca || ca->magic != CATADMIN_MAGIC || !info || info->cbStruct != sizeof(*info) || flags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    lstrcpyW(info->wszCatalogFile, ca->path);
    lstrcatW(info->wszCatalogFile, slashW);
    lstrcatW(info->wszCatalogFile, catalog_file);
 
    return TRUE;
}

CryptCATCatalogInfoFromContext()

BOOL WINAPI CryptCATCatalogInfoFromContext	(	HCATINFO	hcatinfo,
		CATALOG_INFO *	info,
		DWORD	flags
	)

Definition at line 835 of file crypt.c.

{
    struct catinfo *ci = hcatinfo;
 
    TRACE("%p, %p, %x\n", hcatinfo, info, flags);
 
    if (!hcatinfo || hcatinfo == INVALID_HANDLE_VALUE || ci->magic != CATINFO_MAGIC ||
        flags || !info || info->cbStruct != sizeof(*info))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    lstrcpyW(info->wszCatalogFile, ci->file);
    return TRUE;
}

Referenced by InitFunctionPtrs().

CryptCATCDFClose()

BOOL WINAPI CryptCATCDFClose

(

CRYPTCATCDF *

pCDF

)

Definition at line 984 of file crypt.c.

{
    FIXME("(%p) stub\n", pCDF);
 
    return FALSE;
}

Referenced by InitFunctionPtrs().

CryptCATCDFEnumCatAttributes()

CRYPTCATATTRIBUTE *WINAPI CryptCATCDFEnumCatAttributes	(	CRYPTCATCDF *	pCDF,
		CRYPTCATATTRIBUTE *	pPrevAttr,
		PFN_CDF_PARSE_ERROR_CALLBACK	pfnParseError
	)

Definition at line 994 of file crypt.c.

{
    FIXME("(%p %p %p) stub\n", pCDF, pPrevAttr, pfnParseError);
 
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATCDFEnumMembersByCDFTagEx()

LPWSTR WINAPI CryptCATCDFEnumMembersByCDFTagEx	(	CRYPTCATCDF *	pCDF,
		LPWSTR	pwszPrevCDFTag,
		PFN_CDF_PARSE_ERROR_CALLBACK	pfnParseError,
		CRYPTCATMEMBER **	ppMember,
		BOOL	fContinueOnError,
		LPVOID	pvReserved
	)

Definition at line 1006 of file crypt.c.

{
    FIXME("(%p %s %p %p %d %p) stub\n", pCDF, debugstr_w(pwszPrevCDFTag), pfnParseError,
          ppMember, fContinueOnError, pvReserved);
 
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATCDFOpen()

CRYPTCATCDF *WINAPI CryptCATCDFOpen	(	LPWSTR	pwszFilePath,
		PFN_CDF_PARSE_ERROR_CALLBACK	pfnParseError
	)

Definition at line 1020 of file crypt.c.

{
    FIXME("(%s %p) stub\n", debugstr_w(pwszFilePath), pfnParseError);
 
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATClose()

BOOL WINAPI CryptCATClose

(

HANDLE

hCatalog

)

Definition at line 540 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    TRACE("(%p)\n", hCatalog);
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    HeapFree(GetProcessHeap(), 0, cc->attr);
    HeapFree(GetProcessHeap(), 0, cc->inner);
    CryptMsgClose(cc->msg);
 
    cc->magic = 0;
    HeapFree(GetProcessHeap(), 0, cc);
    return TRUE;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), and InitFunctionPtrs().

CryptCATEnumerateAttr()

CRYPTCATATTRIBUTE *WINAPI CryptCATEnumerateAttr	(	HANDLE	hCatalog,
		CRYPTCATMEMBER *	member,
		CRYPTCATATTRIBUTE *	prev
	)

Definition at line 614 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %p, %p\n", hCatalog, member, prev);
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATEnumerateCatAttr()

CRYPTCATATTRIBUTE *WINAPI CryptCATEnumerateCatAttr	(	HANDLE	hCatalog,
		CRYPTCATATTRIBUTE *	prev
	)

Definition at line 632 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %p\n", hCatalog, prev);
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATEnumerateMember()

CRYPTCATMEMBER *WINAPI CryptCATEnumerateMember	(	HANDLE	hCatalog,
		CRYPTCATMEMBER *	prev
	)

Definition at line 650 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
    CRYPTCATMEMBER *member = prev;
    CTL_ENTRY *entry;
    DWORD size, i;
 
    TRACE("%p, %p\n", hCatalog, prev);
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    /* dumping the contents makes me think that dwReserved is the iteration number */
    if (!member)
    {
        if (!(member = HeapAlloc(GetProcessHeap(), 0, sizeof(*member))))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return NULL;
        }
        member->cbStruct = sizeof(*member);
        member->pwszFileName = member->pwszReferenceTag = NULL;
        member->dwReserved = 0;
        member->hReserved = NULL;
        member->gSubjectType = cc->subject;
        member->fdwMemberFlags = 0;
        member->pIndirectData = NULL;
        member->dwCertVersion = cc->inner->dwVersion;
    }
    else member->dwReserved++;
 
    if (member->dwReserved >= cc->inner->cCTLEntry)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto error;
    }
 
    /* list them backwards, like native */
    entry = &cc->inner->rgCTLEntry[cc->inner->cCTLEntry - member->dwReserved - 1];
 
    member->sEncodedIndirectData.cbData = member->sEncodedMemberInfo.cbData = 0;
    member->sEncodedIndirectData.pbData = member->sEncodedMemberInfo.pbData = NULL;
    HeapFree(GetProcessHeap(), 0, member->pIndirectData);
    member->pIndirectData = NULL;
 
    for (i = 0; i < entry->cAttribute; i++)
    {
        CRYPT_ATTRIBUTE *attr = entry->rgAttribute + i;
 
        if (attr->cValue != 1)
        {
            ERR("Can't handle attr->cValue of %u\n", attr->cValue);
            continue;
        }
        if (!strcmp(attr->pszObjId, CAT_MEMBERINFO_OBJID))
        {
            CAT_MEMBERINFO *mi;
            BOOL ret;
 
            member->sEncodedMemberInfo.cbData = attr->rgValue->cbData;
            member->sEncodedMemberInfo.pbData = attr->rgValue->pbData;
 
            CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
 
            if (!(mi = HeapAlloc(GetProcessHeap(), 0, size)))
            {
                SetLastError(ERROR_OUTOFMEMORY);
                goto error;
            }
            ret = CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, mi, &size);
            if (ret)
            {
                UNICODE_STRING guid;
 
                member->dwCertVersion = mi->dwCertVersion;
                RtlInitUnicodeString(&guid, mi->pwszSubjGuid);
                if (RtlGUIDFromString(&guid, &member->gSubjectType))
                {
                    HeapFree(GetProcessHeap(), 0, mi);
                    goto error;
                }
            }
            HeapFree(GetProcessHeap(), 0, mi);
            if (!ret) goto error;
        }
        else if (!strcmp(attr->pszObjId, SPC_INDIRECT_DATA_OBJID))
        {
            /* SPC_INDIRECT_DATA_CONTENT is equal to SIP_INDIRECT_DATA */
 
            member->sEncodedIndirectData.cbData = attr->rgValue->cbData;
            member->sEncodedIndirectData.pbData = attr->rgValue->pbData;
 
            CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
 
            if (!(member->pIndirectData = HeapAlloc(GetProcessHeap(), 0, size)))
            {
                SetLastError(ERROR_OUTOFMEMORY);
                goto error;
            }
            CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, member->pIndirectData, &size);
        }
        else
            /* this object id should probably be handled in CryptCATEnumerateAttr */
            FIXME("unhandled object id \"%s\"\n", attr->pszObjId);
    }
 
    if (!member->sEncodedMemberInfo.cbData || !member->sEncodedIndirectData.cbData)
    {
        ERR("Corrupted catalog entry?\n");
        SetLastError(CRYPT_E_ATTRIBUTES_MISSING);
        goto error;
    }
    size = (2 * member->pIndirectData->Digest.cbData + 1) * sizeof(WCHAR);
    if (member->pwszReferenceTag)
        member->pwszReferenceTag = HeapReAlloc(GetProcessHeap(), 0, member->pwszReferenceTag, size);
    else
        member->pwszReferenceTag = HeapAlloc(GetProcessHeap(), 0, size);
 
    if (!member->pwszReferenceTag)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        goto error;
    }
    /* FIXME: reference tag is usually the file hash but doesn't have to be */
    for (i = 0; i < member->pIndirectData->Digest.cbData; i++)
    {
        DWORD sub;
 
        sub = member->pIndirectData->Digest.pbData[i] >> 4;
        member->pwszReferenceTag[i * 2] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
        sub = member->pIndirectData->Digest.pbData[i] & 0xf;
        member->pwszReferenceTag[i * 2 + 1] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
    }
    member->pwszReferenceTag[i * 2] = 0;
    return member;
 
error:
    HeapFree(GetProcessHeap(), 0, member->pIndirectData);
    HeapFree(GetProcessHeap(), 0, member->pwszReferenceTag);
    HeapFree(GetProcessHeap(), 0, member);
    return NULL;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), and InitFunctionPtrs().

CryptCATGetAttrInfo()

CRYPTCATATTRIBUTE *WINAPI CryptCATGetAttrInfo	(	HANDLE	hCatalog,
		CRYPTCATMEMBER *	member,
		LPWSTR	tag
	)

Definition at line 563 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %p, %s\n", hCatalog, member, debugstr_w(tag));
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

CryptCATGetCatAttrInfo()

CRYPTCATATTRIBUTE *WINAPI CryptCATGetCatAttrInfo	(	HANDLE	hCatalog,
		LPWSTR	tag
	)

Definition at line 581 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %s\n", hCatalog, debugstr_w(tag));
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

CryptCATGetMemberInfo()

CRYPTCATMEMBER *WINAPI CryptCATGetMemberInfo	(	HANDLE	hCatalog,
		LPWSTR	tag
	)

Definition at line 596 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %s\n", hCatalog, debugstr_w(tag));
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

CryptCATOpen()

HANDLE WINAPI CryptCATOpen	(	LPWSTR	pwszFileName,
		DWORD	fdwOpenFlags,
		HCRYPTPROV	hProv,
		DWORD	dwPublicVersion,
		DWORD	dwEncodingType
	)

Definition at line 854 of file crypt.c.

{
    HANDLE file, hmsg;
    BYTE *buffer = NULL;
    DWORD size, flags = OPEN_EXISTING;
    struct cryptcat *cc;
 
    TRACE("%s, %x, %lx, %x, %x\n", debugstr_w(pwszFileName), fdwOpenFlags,
          hProv, dwPublicVersion, dwEncodingType);
 
    if (!pwszFileName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
 
    if (!dwEncodingType)  dwEncodingType  = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
 
    if (fdwOpenFlags & CRYPTCAT_OPEN_ALWAYS)    flags |= OPEN_ALWAYS;
    if (fdwOpenFlags & CRYPTCAT_OPEN_CREATENEW) flags |= CREATE_NEW;
 
    file = CreateFileW(pwszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, flags, 0, NULL);
    if (file == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
 
    size = GetFileSize(file, NULL);
    if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size)))
    {
        CloseHandle(file);
        SetLastError(ERROR_OUTOFMEMORY);
        return INVALID_HANDLE_VALUE;
    }
    if (!(hmsg = CryptMsgOpenToDecode(dwEncodingType, 0, 0, hProv, NULL, NULL)))
    {
        CloseHandle(file);
        HeapFree(GetProcessHeap(), 0, buffer);
        return INVALID_HANDLE_VALUE;
    }
    if (!ReadFile(file, buffer, size, &size, NULL) || !CryptMsgUpdate(hmsg, buffer, size, TRUE))
    {
        CloseHandle(file);
        HeapFree(GetProcessHeap(), 0, buffer);
        CryptMsgClose(hmsg);
        return INVALID_HANDLE_VALUE;
    }
    HeapFree(GetProcessHeap(), 0, buffer);
    CloseHandle(file);
 
    size = sizeof(DWORD);
    if (!(cc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cc))))
    {
        CryptMsgClose(hmsg);
        SetLastError(ERROR_OUTOFMEMORY);
        return INVALID_HANDLE_VALUE;
    }
 
    cc->msg = hmsg;
    cc->encoding = dwEncodingType;
    if (CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_COUNT_PARAM, 0, &cc->attr_count, &size))
    {
        DWORD i, sum = 0;
        BYTE *p;
 
        for (i = 0; i < cc->attr_count; i++)
        {
            if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
            {
                CryptMsgClose(hmsg);
                HeapFree(GetProcessHeap(), 0, cc);
                return INVALID_HANDLE_VALUE;
            }
            sum += size;
        }
        if (!(cc->attr = HeapAlloc(GetProcessHeap(), 0, sizeof(*cc->attr) * cc->attr_count + sum)))
        {
            CryptMsgClose(hmsg);
            HeapFree(GetProcessHeap(), 0, cc);
            SetLastError(ERROR_OUTOFMEMORY);
            return INVALID_HANDLE_VALUE;
        }
        p = (BYTE *)(cc->attr + cc->attr_count);
        for (i = 0; i < cc->attr_count; i++)
        {
            if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
            {
                CryptMsgClose(hmsg);
                HeapFree(GetProcessHeap(), 0, cc->attr);
                HeapFree(GetProcessHeap(), 0, cc);
                return INVALID_HANDLE_VALUE;
            }
            if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, p, &size))
            {
                CryptMsgClose(hmsg);
                HeapFree(GetProcessHeap(), 0, cc->attr);
                HeapFree(GetProcessHeap(), 0, cc);
                return INVALID_HANDLE_VALUE;
            }
            p += size;
        }
        cc->inner = decode_inner_content(hmsg, dwEncodingType, &cc->inner_len);
        if (!cc->inner || !CryptSIPRetrieveSubjectGuid(pwszFileName, NULL, &cc->subject))
        {
            CryptMsgClose(hmsg);
            HeapFree(GetProcessHeap(), 0, cc->attr);
            HeapFree(GetProcessHeap(), 0, cc->inner);
            HeapFree(GetProcessHeap(), 0, cc);
            return INVALID_HANDLE_VALUE;
        }
        cc->magic = CRYPTCAT_MAGIC;
        return cc;
    }
    HeapFree(GetProcessHeap(), 0, cc);
    return INVALID_HANDLE_VALUE;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), and InitFunctionPtrs().