//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1996 - 1999
//
// File: mscatctl.cpp
//
// Contents: Microsoft Internet Security Catalog Utilities
// implements the Certificate Trust List & persistent storage
//
// Functions: CatalogLoadFileData
// CatalogSaveP7UData
// CatalogSaveP7SData
// IsCatalogFile
//
// *** local functions ***
// CatalogLoadData
// CatalogFillCatStore
// CatalogFillCTL
// CatalogFillCTLAttr
// CatalogFreeCTL
// CatalogFreeCTLAttr
// CatalogFillCatMember
// CatalogFillMemAttr
// CatalogFillCatAttr
// CatalogFillCatLevelAttr
//
// History: 05-May-1997 pberkman created
//
//--------------------------------------------------------------------------
#include "global.hxx"
#include "mscat32.h"
//
// for each member, we have at minimum two authenticated attributes.
// 1 = Indirect Data
// 2 = Subject Guid
//
#define CAT_RESERVE_CTL_ATTR 2
// WARNING: this function allocates pbData -- you must delete!
BOOL CatalogLoadData(WCHAR *pwszCatFile, DWORD *cbData, BYTE **pbData);
BOOL CatalogFillCatStore(CRYPTCATSTORE *pCat, PCTL_INFO pCTLInfo);
BOOL CatalogFreeCTL(CTL_INFO *pCTL);
BOOL CatalogFreeCTLAttr(CRYPT_ATTRIBUTE *pCryptAttr);
BOOL CatalogFillCTL(CRYPTCATSTORE *pCat, CTL_INFO *pCTL);
BOOL CatalogFillCatAttr(CRYPTCATSTORE *pCat, CERT_EXTENSION *pAttr);
BOOL CatalogFillCatLevelAttr(CRYPTCATSTORE *pCatStore, CRYPTCATATTRIBUTE *pAttr,
CERT_EXTENSION *pCertAttr);
BOOL CatalogFillCTLAttr(CRYPTCATSTORE *pCatStore, CRYPTCATATTRIBUTE *pAttr,
PCRYPT_ATTRIBUTE pCryptAttr);
CRYPTCATMEMBER *CatalogFillCatMember(CRYPTCATSTORE *pCat, CTL_ENTRY *pEntry);
BOOL CatalogFillMemAttr(CRYPTCATSTORE *pCat, CRYPTCATMEMBER *pMember, CRYPT_ATTRIBUTE *pAttr);
static const char *pszOID = szOID_CATALOG_LIST;
BOOL CatalogLoadFileData(CRYPTCATSTORE *pCat)
{
BOOL fRet;
DWORD cbData;
BYTE *pbData;
cbData = 0;
pbData = NULL;
if (!(CatalogLoadData(pCat->pwszP7File, &cbData, &pbData)))
{
return(FALSE);
}
if (cbData < 1)
{
if (pbData)
{
UnmapViewOfFile(pbData);
}
//
// not signed and we are probably creating it!
//
return(TRUE);
}
PCCTL_CONTEXT pCTLContext;
pCTLContext = (PCCTL_CONTEXT) CertCreateContext(
CERT_STORE_CTL_CONTEXT,
pCat->dwEncodingType,
pbData,
cbData,
CERT_CREATE_CONTEXT_NOCOPY_FLAG |
CERT_CREATE_CONTEXT_NO_HCRYPTMSG_FLAG,
NULL // pCreatePara
);
if (pCTLContext)
{
//
// got it... fill our arrays!
//
fRet = CatalogFillCatStore(pCat, pCTLContext->pCtlInfo);
CertFreeCTLContext(pCTLContext);
} else
fRet = FALSE;
UnmapViewOfFile(pbData);
return(fRet);
}
BOOL CatalogSaveP7SData(CRYPTCATSTORE *pCat, CTL_CONTEXT *pCTLContext)
{
assert(0); // should never be called!
return(TRUE);
}
BOOL CatalogSaveP7UData(CRYPTCATSTORE *pCat)
{
CMSG_SIGNED_ENCODE_INFO sSignInfo;
CTL_INFO sCTLInfo;
DWORD cbEncoded;
BYTE *pbEncoded;
Stack_ *pStack;
//
// sort the data...
//
if (pCat->hReserved) // member stack_
{
pStack = (Stack_ *)pCat->hReserved;
pStack->Sort(WVT_OFFSETOF(CRYPTCATMEMBER, pwszReferenceTag), sizeof(WCHAR *), STACK_SORTTYPE_PWSZ);
}
memset(&sSignInfo, 0x00, sizeof(CMSG_SIGNED_ENCODE_INFO));
sSignInfo.cbSize = sizeof(CMSG_SIGNED_ENCODE_INFO);
if (CatalogFillCTL(pCat, &sCTLInfo))
{
cbEncoded = 0;
CryptMsgEncodeAndSignCTL( pCat->dwEncodingType,
&sCTLInfo,
&sSignInfo,
0,
NULL,
&cbEncoded);
if (cbEncoded > 0)
{
BOOL fRet;
if (!(pbEncoded = (BYTE *)CatalogNew(cbEncoded)))
{
CatalogFreeCTL(&sCTLInfo);
return(FALSE);
}
fRet = CryptMsgEncodeAndSignCTL( pCat->dwEncodingType,
&sCTLInfo,
&sSignInfo,
0,
pbEncoded,
&cbEncoded);
CatalogFreeCTL(&sCTLInfo);
if (fRet)
{
HANDLE hFile;
DWORD lErr;
lErr = GetLastError();
if ((hFile = CreateFileU(pCat->pwszP7File,
GENERIC_WRITE | GENERIC_READ,
0, // no sharing!!
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL)) != INVALID_HANDLE_VALUE)
{
DWORD cbWritten;
if (!(WriteFile(hFile, pbEncoded, cbEncoded, &cbWritten, NULL)) ||
(cbEncoded != cbWritten))
{
fRet = FALSE;
}
CloseHandle(hFile);
if (fRet)
{
SetLastError(lErr);
}
}
}
delete pbEncoded;
return(fRet);
}
CatalogFreeCTL(&sCTLInfo);
}
return(FALSE);
}
BOOL CatalogLoadData(WCHAR *pwszCatFile, DWORD *cbData, BYTE **pbData)
{
HANDLE hFile;
*cbData = 0;
if ((hFile = CreateFileU(pwszCatFile,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
NULL)) == INVALID_HANDLE_VALUE)
{
return(FALSE);
}
if ((*cbData = GetFileSize(hFile, NULL)) == 0xffffffff)
{
*cbData = 0;
CloseHandle(hFile);
return(FALSE);
}
if (*cbData < 10)
{
//
// just created file....
//
*cbData = 0;
CloseHandle(hFile);
return(TRUE);
}
HANDLE hMappedFile;
hMappedFile = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (!(hMappedFile) || (hMappedFile == INVALID_HANDLE_VALUE))
{
*cbData = 0;
CloseHandle(hFile);
return(FALSE);
}
*pbData = (BYTE *)MapViewOfFile(hMappedFile, FILE_MAP_READ, 0, 0, 0);
CloseHandle(hMappedFile);
CloseHandle(hFile);
if ((*pbData) == NULL)
{
return(FALSE);
}
return(TRUE);
}
BOOL CatalogFillCatStore(CRYPTCATSTORE *pCat, CTL_INFO *pCTL)
{
int iAttr;
if (pCTL->cCTLEntry > 0)
{
for (iAttr = 0; iAttr < (int)pCTL->cExtension; iAttr++)
{
if (!(CatalogFillCatAttr(pCat, &pCTL->rgExtension[iAttr])))
{
return(FALSE);
}
}
CRYPTCATMEMBER *pMember;
for (int iEntry = 0; iEntry < (int)pCTL->cCTLEntry; iEntry++)
{
pMember = CatalogFillCatMember(pCat, &pCTL->rgCTLEntry[iEntry]);
if (!(pMember))
{
return(FALSE);
}
if (pCTL->rgCTLEntry[iEntry].cAttribute > 0)
{
for (iAttr = 0; iAttr < (int)pCTL->rgCTLEntry[iEntry].cAttribute; iAttr++)
{
if (!(CatalogFillMemAttr(pCat, pMember,
&pCTL->rgCTLEntry[iEntry].rgAttribute[iAttr])))
{
return(FALSE);
}
}
}
}
return(TRUE);
}
return(TRUE);
}
CRYPTCATMEMBER *CatalogFillCatMember(CRYPTCATSTORE *pCat, CTL_ENTRY *pEntry)
{
if (!(pEntry))
{
return(NULL);
}
Stack_ *pStack;
CRYPTCATMEMBER *pCatMember;
if (!(pCat->hReserved))
{
pStack = new Stack_(&MSCAT_CriticalSection);
if (!(pStack))
{
assert(0);
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return(NULL);
}
pCat->hReserved = (HANDLE)pStack;
}
pStack = (Stack_ *)pCat->hReserved;
if (!(pCatMember = (CRYPTCATMEMBER *)pStack->Add(sizeof(CRYPTCATMEMBER))))
{
return(NULL);
}
memset(pCatMember, 0x00, sizeof(CRYPTCATMEMBER));
pCatMember->cbStruct = sizeof(CRYPTCATMEMBER);
// pwszFileName
// pwszReferenceTag
if (!(pCatMember->pwszReferenceTag = (LPWSTR)CatalogNew(pEntry->SubjectIdentifier.cbData)))
{
return(NULL);
}
memcpy(pCatMember->pwszReferenceTag, pEntry->SubjectIdentifier.pbData,
pEntry->SubjectIdentifier.cbData);
// pIndirectData (will be filled in while getting attributes!
// gSubjectType (will be filled in while getting attributes!
return(pCatMember);
}
BOOL CatalogFillCatAttr(CRYPTCATSTORE *pCat, CERT_EXTENSION *pAttr)
{
if (!(pAttr))
{
return(FALSE);
}
Stack_ *pStack;
CRYPTCATATTRIBUTE *pCatAttr;
if (!(pCat->hAttrs))
{
pStack = new Stack_(&MSCAT_CriticalSection);
if (!(pStack))
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return(FALSE);
}
pCat->hAttrs = (HANDLE)pStack;
}
pStack = (Stack_ *)pCat->hAttrs;
if (!(pCatAttr = (CRYPTCATATTRIBUTE *)pStack->Add(sizeof(CRYPTCATATTRIBUTE))))
{
return(FALSE);
}
memset(pCatAttr, 0x00, sizeof(CRYPTCATATTRIBUTE));
pCatAttr->cbStruct = sizeof(CRYPTCATATTRIBUTE);
CRYPT_ATTRIBUTE sCryptAttr;
CatalogCertExt2CryptAttr(pAttr, &sCryptAttr);
if (!(CatalogDecodeNameValue(pCat, &sCryptAttr, pCatAttr)))
{
return(FALSE);
}
return(TRUE);
}
BOOL CatalogFillMemAttr(CRYPTCATSTORE *pCat, CRYPTCATMEMBER *pMember, CRYPT_ATTRIBUTE *pAttr)
{
if (!(pAttr))
{
return(FALSE);
}
if (strcmp(pAttr->pszObjId, SPC_INDIRECT_DATA_OBJID) == 0)
{
return(CatalogDecodeIndirectData(pCat, pMember, pAttr));
}
if (strcmp(pAttr->pszObjId, CAT_MEMBERINFO_OBJID) == 0)
{
return(CatalogDecodeMemberInfo(pCat, pMember, pAttr));
}
Stack_ *pStack;
CRYPTCATATTRIBUTE *pCatAttr;
if (!(pMember->hReserved))
{
pStack = new Stack_(&MSCAT_CriticalSection);
if (!(pStack))
{
assert(0);
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return(FALSE);
}
pMember->hReserved = (HANDLE)pStack;
}
pStack = (Stack_ *)pMember->hReserved;
if (!(pCatAttr = (CRYPTCATATTRIBUTE *)pStack->Add(sizeof(CRYPTCATATTRIBUTE))))
{
return(FALSE);
}
memset(pCatAttr, 0x00, sizeof(CRYPTCATATTRIBUTE));
pCatAttr->cbStruct = sizeof(CRYPTCATATTRIBUTE);
if (!(CatalogDecodeNameValue(pCat, pAttr, pCatAttr)))
{
return(FALSE);
}
return(TRUE);
}
BOOL CatalogFillCTL(CRYPTCATSTORE *pCat, CTL_INFO *pCTL)
{
typedef HRESULT (WINAPI *pfnCoCreateGuid)(GUID FAR *pguid);
HINSTANCE hOLE;
pfnCoCreateGuid pfnCreateGuid;
memset(pCTL, 0x00, sizeof(CTL_INFO));
// dwVersion
pCTL->dwVersion = CTL_V1;
// SubjectUsage
pCTL->SubjectUsage.cUsageIdentifier = 1;
pCTL->SubjectUsage.rgpszUsageIdentifier = (char **)&pszOID;
// ListIdentifier
if (hOLE = LoadLibraryA("OLE32.DLL"))
{
if (pfnCreateGuid = (pfnCoCreateGuid)GetProcAddress(hOLE, "CoCreateGuid"))
{
if (pCTL->ListIdentifier.pbData = (BYTE *)CatalogNew(sizeof(GUID)))
{
pCTL->ListIdentifier.cbData = sizeof(GUID);
(*pfnCreateGuid)((GUID *)pCTL->ListIdentifier.pbData);
}
}
FreeLibrary(hOLE);
}
// SequenceNumber
// optional!
// ThisUpdate
GetSystemTimeAsFileTime(&pCTL->ThisUpdate);
// NextUpdate
// optional!
// SubjectAlgorithm
pCTL->SubjectAlgorithm.pszObjId = szOID_CATALOG_LIST_MEMBER;
Stack_ *pStackMember;
Stack_ *pStackAttr;
CRYPTCATMEMBER *pMember;
CRYPTCATATTRIBUTE *pAttr;
DWORD dwAttr;
// cCTLEntry & rgCTLEntry
if (pCat->hReserved)
{
pStackMember = (Stack_ *)pCat->hReserved;
// cCTLEntry
pCTL->cCTLEntry = pStackMember->Count();
if (pCTL->cCTLEntry > 0)
{
if (!(pCTL->rgCTLEntry = (PCTL_ENTRY)CatalogNew(sizeof(CTL_ENTRY) *
pStackMember->Count())))
{
return(FALSE);
}
memset(pCTL->rgCTLEntry, 0x00, sizeof(CTL_ENTRY) * pStackMember->Count());
}
DWORD dwMember;
DWORD dwSize;
CTL_ENTRY *pCTLEntry;
//
// copy the members to the ctl_entry
//
dwMember = 0;
while (dwMember < pStackMember->Count())
{
if (!(pMember = (CRYPTCATMEMBER *)pStackMember->Get(dwMember)))
{
return(FALSE);
}
//
// Subject Identifier
//
dwSize = (wcslen(pMember->pwszReferenceTag) + 1) * sizeof(WCHAR);
pCTLEntry = &pCTL->rgCTLEntry[dwMember];
if (!(pCTLEntry->SubjectIdentifier.pbData =
(BYTE *)CatalogNew(dwSize)))
{
return(FALSE);
}
memcpy(pCTLEntry->SubjectIdentifier.pbData,
pMember->pwszReferenceTag,dwSize);
pCTLEntry->SubjectIdentifier.cbData = dwSize;
//
// rgAttribute
// +1 for Indirect Data
// +1 for Subject Guid
//
if (pMember->hReserved)
{
pStackAttr = (Stack_ *)pMember->hReserved;
pCTLEntry->cAttribute = pStackAttr->Count() + CAT_RESERVE_CTL_ATTR;
}
else
{
pCTLEntry->cAttribute = CAT_RESERVE_CTL_ATTR;
}
if (!(pCTLEntry->rgAttribute =
(PCRYPT_ATTRIBUTE)CatalogNew(sizeof(CRYPT_ATTRIBUTE) *
pCTLEntry->cAttribute)))
{
return(FALSE);
}
memset(pCTLEntry->rgAttribute, 0x00,
sizeof(CRYPT_ATTRIBUTE) * pCTLEntry->cAttribute);
//
// put our indirect data in an authenticated attribute
//
if (!(pMember->pIndirectData))
{
CatalogReallyDecodeIndirectData(pCat, pMember, &pMember->sEncodedIndirectData);
}
CatalogEncodeIndirectData(pCat, pMember, &pCTLEntry->rgAttribute[0]);
//
// put our subject guid in an authenticated attribute
//
if ((pMember->gSubjectType.Data1 == 0) &&
(pMember->gSubjectType.Data2 == 0) &&
(pMember->gSubjectType.Data3 == 0))
{
CatalogReallyDecodeMemberInfo(pCat, pMember, &pMember->sEncodedMemberInfo);
}
CatalogEncodeMemberInfo(pCat, pMember, &pCTLEntry->rgAttribute[1]);
if (pMember->hReserved)
{
dwAttr = 0;
while (dwAttr < pStackAttr->Count())
{
pAttr = (CRYPTCATATTRIBUTE *)pStackAttr->Get(dwAttr);
CatalogFillCTLAttr(pCat, pAttr,
&pCTLEntry->rgAttribute[dwAttr + CAT_RESERVE_CTL_ATTR]);
//
// increment our attribute counter!
//
dwAttr++;
}
}
//
// increment our member counter!
//
dwMember++;
}
}
//
// cExtension
// rgExtension
//
if (pCat->hAttrs)
{
pStackAttr = (Stack_ *)pCat->hAttrs;
pCTL->cExtension = pStackAttr->Count();
if (!(pCTL->rgExtension =
(CERT_EXTENSION *)CatalogNew(sizeof(CERT_EXTENSION) * pCTL->cExtension)))
{
return(FALSE);
}
memset(pCTL->rgExtension, 0x00, sizeof(CERT_EXTENSION) * pCTL->cExtension);
dwAttr = 0;
while (dwAttr < pStackAttr->Count())
{
pAttr = (CRYPTCATATTRIBUTE *)pStackAttr->Get(dwAttr);
if (pAttr)
{
CatalogFillCatLevelAttr(pCat, pAttr, &pCTL->rgExtension[dwAttr]);
}
dwAttr++;
}
}
return(TRUE);
}
BOOL CatalogFillCatLevelAttr(CRYPTCATSTORE *pCatStore, CRYPTCATATTRIBUTE *pAttr, CERT_EXTENSION *pCertAttr)
{
CRYPT_ATTR_BLOB sAttrBlob;
CRYPT_ATTRIBUTE sCryptAttr;
memset(&sAttrBlob, 0x00, sizeof(CRYPT_ATTR_BLOB));
memset(&sCryptAttr, 0x00, sizeof(CRYPT_ATTRIBUTE));
sCryptAttr.cValue = 1;
sCryptAttr.rgValue = &sAttrBlob;
if (!(CatalogEncodeNameValue(pCatStore, pAttr, &sCryptAttr)))
{
return(FALSE);
}
CatalogCryptAttr2CertExt(&sCryptAttr, pCertAttr);
return(TRUE);
}
BOOL CatalogFillCTLAttr(CRYPTCATSTORE *pCatStore, CRYPTCATATTRIBUTE *pAttr, PCRYPT_ATTRIBUTE pCryptAttr)
{
if (!(pCryptAttr->rgValue = (PCRYPT_ATTR_BLOB)CatalogNew(sizeof(CRYPT_ATTR_BLOB))))
{
return(FALSE);
}
pCryptAttr->cValue = 1;
memset(pCryptAttr->rgValue, 0x00, sizeof(CRYPT_ATTR_BLOB));
if (!(CatalogEncodeNameValue(pCatStore, pAttr, pCryptAttr)))
{
return(FALSE);
}
return(TRUE);
}
BOOL CatalogFreeCTL(CTL_INFO *pCTL)
{
DWORD dwEntries;
DWORD dwAttributes;
CTL_ENTRY *pCTLEntry;
DELETE_OBJECT(pCTL->ListIdentifier.pbData);
dwEntries = pCTL->cCTLEntry;
while (dwEntries > 0)
{
pCTLEntry = &pCTL->rgCTLEntry[dwEntries - 1];
DELETE_OBJECT(pCTLEntry->SubjectIdentifier.pbData);
dwAttributes = pCTLEntry->cAttribute;
while (dwAttributes > 0)
{
CatalogFreeCTLAttr(&pCTLEntry->rgAttribute[dwAttributes - 1]);
dwAttributes--;
}
DELETE_OBJECT(pCTLEntry->rgAttribute);
dwEntries--;
}
DELETE_OBJECT(pCTL->rgCTLEntry);
for (dwEntries = 0; dwEntries < pCTL->cExtension; dwEntries++)
{
DELETE_OBJECT(pCTL->rgExtension[dwEntries].Value.pbData);
}
DELETE_OBJECT(pCTL->rgExtension);
return(TRUE);
}
BOOL CatalogFreeCTLAttr(CRYPT_ATTRIBUTE *pCryptAttr)
{
if (!(pCryptAttr))
{
return(FALSE);
}
if (pCryptAttr->rgValue)
{
DELETE_OBJECT(pCryptAttr->rgValue->pbData);
DELETE_OBJECT(pCryptAttr->rgValue);
}
return(TRUE);
}
BOOL WINAPI IsCatalogFile(HANDLE hFile, WCHAR *pwszCatalogFile)
{
char *pszCatalogListUsageOID = szOID_CATALOG_LIST;
BOOL fCloseFile;
BOOL fRet;
DWORD cbRead;
DWORD cbFile;
BYTE *pbFile;
PCCTL_CONTEXT pCTLContext;
//
// put a try-except around everything in case there is problems with the
// memory mapped file
//
__try {
pCTLContext = NULL;
pbFile = NULL;
fCloseFile = FALSE;
fRet = FALSE;
if ((hFile == NULL) || (hFile == INVALID_HANDLE_VALUE))
{
if (!(pwszCatalogFile))
{
goto IsCatInvalidParam;
}
if ((hFile = CreateFileU(pwszCatalogFile, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
NULL)) == INVALID_HANDLE_VALUE)
{
goto IsCatFileError;
}
fCloseFile = TRUE;
}
HANDLE hMappedFile;
hMappedFile = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (!(hMappedFile) || (hMappedFile == INVALID_HANDLE_VALUE))
{
goto CreateFileMapFailed;
}
pbFile = (BYTE *)MapViewOfFile(hMappedFile, FILE_MAP_READ, 0, 0, 0);
CloseHandle(hMappedFile);
if (!(pbFile))
{
goto MapViewFailed;
}
if (((cbFile = GetFileSize(hFile, NULL)) == 0xffffffff) ||
(cbFile < 1))
{
goto FileSizeError;
}
if (pbFile[0] != (BYTE)0x30)
{
goto IsCatNotCatalog;
}
pCTLContext = (PCCTL_CONTEXT) CertCreateContext(
CERT_STORE_CTL_CONTEXT,
PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
pbFile,
cbFile,
CERT_CREATE_CONTEXT_NOCOPY_FLAG |
CERT_CREATE_CONTEXT_NO_HCRYPTMSG_FLAG |
CERT_CREATE_CONTEXT_NO_ENTRY_FLAG,
NULL // pCreatePara
);
if (pCTLContext)
{
if (pCTLContext->pCtlInfo->SubjectUsage.cUsageIdentifier)
{
if (strcmp(pCTLContext->pCtlInfo->SubjectUsage.rgpszUsageIdentifier[0],
pszCatalogListUsageOID) == 0)
{
fRet = TRUE;
goto CommonReturn;
}
}
}
goto IsCatNotCatalog;
} __except(EXCEPTION_EXECUTE_HANDLER) {
SetLastError(GetExceptionCode());
goto ErrorReturn;
}
CommonReturn:
if (pCTLContext)
{
CertFreeCTLContext(pCTLContext);
}
if (pbFile)
{
UnmapViewOfFile(pbFile);
}
if (fCloseFile)
{
CloseHandle(hFile);
}
return(fRet);
ErrorReturn:
fRet = FALSE;
goto CommonReturn;
TRACE_ERROR_EX(DBG_SS, IsCatNotCatalog);
TRACE_ERROR_EX(DBG_SS, IsCatFileError);
TRACE_ERROR_EX(DBG_SS, CreateFileMapFailed);
TRACE_ERROR_EX(DBG_SS, MapViewFailed);
SET_ERROR_VAR_EX(DBG_SS, IsCatInvalidParam, ERROR_INVALID_PARAMETER);
SET_ERROR_VAR_EX(DBG_SS, FileSizeError, ERROR_INVALID_PARAMETER);
}