able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/security/services/ca/certmmc/misc.cpp

1398 lines
38 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1997 - 1999
//
// File: misc.cpp
//
//--------------------------------------------------------------------------
#include <stdafx.h>
#include <float.h>
#include "certsrv.h"
#include "misc.h"
#include "clibres.h"
#include "setupids.h"
#include "csresstr.h"
#include <comdef.h>
#include <activeds.h>
#include <dsgetdc.h>
#include <lm.h>
#include "urls.h"
#include "csdisp.h"
bool operator==(
const struct _QUERY_RESTRICTION& lhs,
const struct _QUERY_RESTRICTION& rhs)
{
return
0==_wcsicmp(lhs.szField, rhs.szField) &&
lhs.iOperation==rhs.iOperation &&
variant_t(&lhs.varValue)==variant_t(&rhs.varValue);
}
PQUERY_RESTRICTION QueryRestrictionFound(
PQUERY_RESTRICTION pQR,
PQUERY_RESTRICTION pQRListHead)
{
while(pQRListHead)
{
if(*pQR==*pQRListHead)
return pQRListHead;
pQRListHead = pQRListHead->pNext;
}
return NULL;
}
// returns (if cstr.IsEmpty()) ? NULL : cstr)
LPCWSTR GetNullMachineName(CString* pcstr)
{
LPCWSTR szMachine = (pcstr->IsEmpty()) ? NULL : (LPCWSTR)*pcstr;
return szMachine;
}
BOOL FIsCurrentMachine(LPCWSTR str)
{
BOOL fIsCurrentMachine = FALSE;
LPWSTR szName1 = NULL, szName2 = NULL;
DWORD dwErr;
dwErr = myGetComputerNames(&szName1, &szName2);
_JumpIfError(dwErr, error, "myGetComputerNames");
if ((str != NULL) &&
(wcslen(str) > 2) &&
(str[0] == '\\') &&
(str[1] == '\\') )
str = &str[2]; // skip whackwhack
// if machine specified as not current machine
if ( (NULL == str) ||
(str[0] == '\0') ||
(0 == lstrcmpi(str, szName1)) ||
(0 == lstrcmpi(str, szName2)) )
fIsCurrentMachine = TRUE;
error:
if (szName1)
LocalFree(szName1);
if (szName2)
LocalFree(szName2);
return fIsCurrentMachine;
}
/////////////////////////////////////////
// fxns to load/save cstrings to a streams
STDMETHODIMP CStringLoad(CString& cstr, IStream *pStm)
{
ASSERT(pStm);
HRESULT hr;
DWORD cbSize=0;
// get cbSize (bytes)
hr = ReadOfSize(pStm, &cbSize, sizeof(cbSize));
_JumpIfError(hr, Ret, "ReadOfSize cbSize");
// get string
hr = ReadOfSize(pStm, cstr.GetBuffer(cbSize/sizeof(WCHAR)), cbSize);
cstr.ReleaseBuffer();
_JumpIfError(hr, Ret, "Read cstr.GetBuffer");
Ret:
return hr;
}
STDMETHODIMP CStringSave(CString& cstr, IStream *pStm, BOOL fClearDirty)
{
ASSERT(pStm);
HRESULT hr;
// Write the string (null cstr will return 0 chars, output nullstr "")
DWORD cbSize = (cstr.GetLength()+1)*sizeof(WCHAR);
// write size in bytes
hr = WriteOfSize(pStm, &cbSize, sizeof(cbSize));
_JumpIfError(hr, error, "WriteOfSize cbSize");
// write string (null cstr will return 0 chars, output nullstr "")
hr = WriteOfSize(pStm, (LPWSTR)(LPCWSTR)cstr, cbSize);
_JumpIfError(hr, error, "Write cstr");
error:
return hr;
}
STDMETHODIMP CStringGetSizeMax(CString& cstr, int* piSize)
{
*piSize = sizeof(DWORD);
*piSize += (cstr.GetLength()+1)* sizeof(WCHAR);
return S_OK;
}
STDMETHODIMP VariantLoad(VARIANT& var, IStream *pStm)
{
HRESULT hr;
VARIANT varTmp;
DWORD dwSize;
VariantInit(&varTmp);
VariantInit(&var);
// get target variant type
hr = ReadOfSize(pStm, &var.vt, sizeof(var.vt));
_JumpIfError(hr, error, "Read type");
// get cb
hr = ReadOfSize(pStm, &dwSize, sizeof(DWORD));
_JumpIfError(hr, error, "Read cb");
varTmp.vt = VT_BSTR;
varTmp.bstrVal = SysAllocStringByteLen(NULL, dwSize);
_JumpIfOutOfMemory(hr, error, varTmp.bstrVal);
// get pb
hr = ReadOfSize(pStm, varTmp.bstrVal, dwSize);
_JumpIfError(hr, error, "Read pb");
// change type to target type var.vt
hr = VariantChangeType(&var, &varTmp, 0, var.vt);
_JumpIfError(hr, error, "VariantChangeType");
error:
VariantClear(&varTmp);
return hr;
}
STDMETHODIMP VariantSave(VARIANT& var, IStream *pStm, BOOL fClearDirty)
{
HRESULT hr;
DWORD dwSize;
VARIANT varTmp;
VariantInit(&varTmp);
// write variant type
hr = WriteOfSize(pStm, &var.vt, sizeof(var.vt));
_JumpIfError(hr, error, "Write type");
// convert to bstr
hr = VariantChangeType(&varTmp, &var, 0, VT_BSTR);
_JumpIfError(hr, error, "VariantChangeType");
// write cb
dwSize = SysStringByteLen(varTmp.bstrVal);
hr = WriteOfSize(pStm, &dwSize, sizeof(DWORD));
_JumpIfError(hr, error, "Write cb");
// write pb
hr = WriteOfSize(pStm, varTmp.bstrVal, dwSize);
_JumpIfError(hr, error, "Write pb");
error:
VariantClear(&varTmp);
return hr;
}
STDMETHODIMP VariantGetSizeMax(VARIANT& var, int* piSize)
{
HRESULT hr;
VARIANT varTmp;
VariantInit(&varTmp);
// write var type, cb
*piSize = sizeof(var.vt) + sizeof(DWORD);
// write pb len: convert to bstr
hr = VariantChangeType(&varTmp, &var, 0, VT_BSTR);
_JumpIfError(hr, error, "VariantChangeType");
*piSize += SysStringByteLen(varTmp.bstrVal);
error:
VariantClear(&varTmp);
return hr;
}
DWORD AllocAndReturnConfigValue(HKEY hKey, LPCWSTR szConfigEntry, PBYTE* ppbOut, DWORD* pcbOut, DWORD* pdwType)
{
DWORD dwRet;
dwRet = RegQueryValueExW(
hKey,
szConfigEntry,
NULL,
pdwType,
NULL,
pcbOut);
_JumpIfError(dwRet, Ret, "RegQueryValueExW");
ASSERT(ppbOut != NULL);
*ppbOut = new BYTE[*pcbOut];
_JumpIfOutOfMemory(dwRet, Ret, *ppbOut);
dwRet = RegQueryValueExW(
hKey,
szConfigEntry,
NULL,
pdwType,
*ppbOut,
pcbOut);
if (dwRet != ERROR_SUCCESS)
{
delete [] *ppbOut;
*ppbOut = NULL;
_JumpError(dwRet, Ret, "RegQueryValueExW");
}
Ret:
return dwRet;
}
//////////////////////////////////////////////////////////////////
// given an error code and a console pointer, will pop error dlg
void DisplayCertSrvErrorWithContext(HWND hwnd, DWORD dwErr, UINT iRscContext)
{
CString cstrContext;
cstrContext.LoadString(iRscContext);
DisplayCertSrvErrorWithContext(hwnd, dwErr, (LPCWSTR)cstrContext);
}
void DisplayCertSrvErrorWithContext(HWND hwnd, DWORD dwErr, LPCWSTR szContext)
{
CString cstrTitle, cstrContext, cstrFullText;
cstrTitle.LoadString(IDS_MSG_TITLE);
cstrContext = szContext;
if (dwErr != ERROR_SUCCESS)
{
WCHAR const *pwszError = myGetErrorMessageText(dwErr, TRUE);
cstrFullText = pwszError;
// Free the buffer
if (NULL != pwszError)
{
LocalFree(const_cast<WCHAR *>(pwszError));
}
if (!cstrContext.IsEmpty())
cstrFullText += L"\n\n";
}
if (!cstrContext.IsEmpty())
cstrFullText += cstrContext;
::MessageBoxW(hwnd, cstrFullText, cstrTitle,
MB_OK|
(S_OK!=dwErr?MB_ICONERROR:MB_ICONINFORMATION));
}
void DisplayGenericCertSrvError(HWND hwnd, DWORD dwErr)
{
DisplayCertSrvErrorWithContext(hwnd, dwErr, (UINT)0);
}
void DisplayGenericCertSrvError(LPCONSOLE pConsole, DWORD dwErr)
{
ASSERT(pConsole);
WCHAR const *pwszError = myGetErrorMessageText(dwErr, TRUE);
// ...
// Display the string.
CString cstrTitle;
cstrTitle.LoadString(IDS_MSG_TITLE);
pConsole->MessageBoxW(pwszError, cstrTitle, MB_OK, NULL);
// Free the buffer.
if (NULL != pwszError)
{
LocalFree(const_cast<WCHAR *>(pwszError));
}
}
enum ENUM_PERIOD DurationEnumFromNonLocalizedString(LPCWSTR szPeriod)
{
if (0 == wcscmp(wszPERIODYEARS, szPeriod))
return ENUM_PERIOD_YEARS;
if (0 == wcscmp(wszPERIODMONTHS, szPeriod))
return ENUM_PERIOD_MONTHS;
if (0 == wcscmp(wszPERIODWEEKS, szPeriod))
return ENUM_PERIOD_WEEKS;
if (0 == wcscmp(wszPERIODDAYS, szPeriod))
return ENUM_PERIOD_DAYS;
if (0 == wcscmp(wszPERIODHOURS, szPeriod))
return ENUM_PERIOD_HOURS;
if (0 == wcscmp(wszPERIODMINUTES, szPeriod))
return ENUM_PERIOD_MINUTES;
if (0 == wcscmp(wszPERIODSECONDS, szPeriod))
return ENUM_PERIOD_SECONDS;
return ENUM_PERIOD_INVALID;
}
BOOL StringFromDurationEnum(int iEnum, CString* pcstr, BOOL fLocalized)
{
if (NULL == pcstr)
return FALSE;
switch (iEnum)
{
case(ENUM_PERIOD_YEARS):
if (fLocalized)
*pcstr = g_cResources.m_szPeriod_Years;
else
*pcstr = wszPERIODYEARS;
break;
case(ENUM_PERIOD_MONTHS):
if (fLocalized)
*pcstr = g_cResources.m_szPeriod_Months;
else
*pcstr = wszPERIODMONTHS;
break;
case(ENUM_PERIOD_WEEKS):
if (fLocalized)
*pcstr = g_cResources.m_szPeriod_Weeks;
else
*pcstr = wszPERIODWEEKS;
break;
case(ENUM_PERIOD_DAYS):
if (fLocalized)
*pcstr = g_cResources.m_szPeriod_Days;
else
*pcstr = wszPERIODDAYS;
break;
case(ENUM_PERIOD_HOURS):
if (fLocalized)
*pcstr = g_cResources.m_szPeriod_Hours;
else
*pcstr = wszPERIODHOURS;
break;
case(ENUM_PERIOD_MINUTES):
if (fLocalized)
*pcstr = g_cResources.m_szPeriod_Minutes;
else
*pcstr = wszPERIODMINUTES;
break;
case(ENUM_PERIOD_SECONDS):
if (fLocalized)
*pcstr = g_cResources.m_szPeriod_Seconds;
else
*pcstr = wszPERIODSECONDS;
break;
}
if (! (pcstr->IsEmpty()) )
return TRUE;
return FALSE;
}
LPCWSTR OperationToStr(int iOperation)
{
switch(iOperation)
{
case CVR_SEEK_EQ:
return L"=";
case CVR_SEEK_LT:
return L"<";
case CVR_SEEK_LE:
return L"<=";
case CVR_SEEK_GE:
return L">=";
case CVR_SEEK_GT:
return L">";
}
return NULL;
}
int StrToOperation(LPCWSTR szOperation)
{
if (0 == wcscmp(szOperation, L"="))
return CVR_SEEK_EQ;
else if (0 == wcscmp(szOperation, L"<"))
return CVR_SEEK_LT;
else if (0 == wcscmp(szOperation, L"<="))
return CVR_SEEK_LE;
else if (0 == wcscmp(szOperation, L">="))
return CVR_SEEK_GE;
else if (0 == wcscmp(szOperation, L">"))
return CVR_SEEK_GT;
return 0;
}
// returns localized string time (even for date!)
BOOL MakeDisplayStrFromDBVariant(VARIANT* pvt, VARIANT* pvOut)
{
HRESULT hr;
VariantInit(pvOut);
LPWSTR szLocalTime = NULL;
ASSERT(pvt);
ASSERT(pvOut);
if ((NULL == pvt) || (NULL == pvOut))
return FALSE;
if (pvt->vt == VT_DATE)
{
hr = myGMTDateToWszLocalTime(
&pvt->date,
FALSE,
&szLocalTime);
_JumpIfError(hr, error, "myGMTDateToWszLocalTime");
pvOut->bstrVal = ::SysAllocString(szLocalTime);
_JumpIfOutOfMemory(hr, error, pvOut->bstrVal);
pvOut->vt = VT_BSTR;
}
else
{
hr = VariantChangeType(pvOut, pvt, 0, VT_BSTR);
_JumpIfError(hr, error, "VariantChangeType");
}
error:
if (szLocalTime)
LocalFree(szLocalTime);
return (pvOut->vt == VT_BSTR);
}
DWORD CryptAlgToStr(CString* pcstrAlgName, LPCWSTR szProv, DWORD dwProvType, DWORD dwAlg)
{
DWORD dwRet;
HCRYPTPROV hCrypt = NULL;
DWORD Flags = CRYPT_FIRST;
DWORD cb;
PROV_ENUMALGS Alg;
pcstrAlgName->Empty();
if (!CryptAcquireContext(
&hCrypt,
NULL,
szProv,
dwProvType,
CRYPT_VERIFYCONTEXT))
{
dwRet = GetLastError();
_JumpError(dwRet, Ret, "CryptAcquireContext");
}
while (TRUE)
{
cb = sizeof(Alg);
if (!CryptGetProvParam(hCrypt, PP_ENUMALGS, (BYTE *) &Alg, &cb, Flags))
break;
if (Alg.aiAlgid == dwAlg)
{
*pcstrAlgName = Alg.szName;
break;
}
Flags = 0;
}
dwRet = ERROR_SUCCESS;
Ret:
if (hCrypt)
CryptReleaseContext(hCrypt, 0);
return dwRet;
}
LPCWSTR FindUnlocalizedColName(LPCWSTR strColumn)
{
HRESULT hr = S_OK;
LPCWSTR szTrial = NULL;
for(DWORD dwIndex=0; (S_OK == hr); dwIndex++)
{
hr = myGetColumnName(
dwIndex,
FALSE, // unlocalized
&szTrial);
_PrintIfError(hr, "myGetColumnName");
if ((S_OK == hr) && (NULL != szTrial))
{
if (0 == wcscmp(strColumn, szTrial))
return szTrial;
}
}
return NULL;
}
// given field, op, variant, copies into data struct
PQUERY_RESTRICTION NewQueryRestriction(LPCWSTR szField, UINT iOp, VARIANT* pvarValue)
{
DWORD dwLen = sizeof(QUERY_RESTRICTION);
dwLen += WSZ_BYTECOUNT(szField);
PQUERY_RESTRICTION pNew = (QUERY_RESTRICTION*)LocalAlloc(LPTR, dwLen);
if (NULL == pNew)
return NULL;
PBYTE pCurWrite = ((PBYTE)pNew) + sizeof(QUERY_RESTRICTION) ;
pNew->szField = (LPWSTR)pCurWrite;
wcscpy(pNew->szField, szField);
pNew->iOperation = iOp;
// copy data pointed to by pvarValue
CopyMemory(&pNew->varValue, pvarValue, sizeof(VARIANT));
// good enough except for string -- alloc for it
if (VT_BSTR == pvarValue->vt)
{
pNew->varValue.bstrVal = SysAllocString(pvarValue->bstrVal);
if (NULL == pNew->varValue.bstrVal)
{
// failed!
FreeQueryRestriction(pNew);
pNew = NULL;
}
}
return pNew;
}
void FreeQueryRestriction(PQUERY_RESTRICTION pQR)
{
VariantClear(&pQR->varValue);
LocalFree(pQR);
}
void FreeQueryRestrictionList(PQUERY_RESTRICTION pQR)
{
PQUERY_RESTRICTION pTmp;
while(pQR)
{
pTmp = pQR->pNext;
FreeQueryRestriction(pQR);
pQR = pTmp;
}
}
void ListInsertAtEnd(void** ppList, void* pElt)
{
if (pElt != NULL)
{
// he's always at the end of the list
((PELT_PTR)pElt)->pNext = NULL;
void* pCurPtr = *ppList;
if (*ppList == NULL)
{
*ppList = pElt;
}
else
{
while( ((PELT_PTR)pCurPtr)->pNext != NULL )
{
pCurPtr = ((PELT_PTR)pCurPtr)->pNext;
}
((PELT_PTR)pCurPtr)->pNext = (PELT_PTR) pElt;
}
}
return;
}
// dwIndex should be zero at first, then passed in for each consecutive call
LPWSTR RegEnumKeyContaining(
HKEY hBaseKey,
LPCWSTR szContainsString,
DWORD* pdwIndex)
{
HRESULT hr = S_OK;
LPWSTR szKeyName = NULL;
LPWSTR szBuf = NULL;
DWORD cbBuf = 0, cbBufUsed;
FILETIME ft;
ASSERT(pdwIndex);
hr = RegQueryInfoKey(
hBaseKey,
NULL,
NULL, // classes
NULL, // reserved
NULL, // cSubkeys
&cbBuf, // maxsubkeylen in chars (not counting null term)
NULL, // max class len
NULL, // num values
NULL, // max value name len
NULL, // max value len
NULL, // sec descr
NULL // last filetime
);
_JumpIfError(hr, Ret, "RegQueryInfoKey");
cbBuf += 1;
cbBuf *= sizeof(WCHAR);
szBuf = (LPWSTR)LocalAlloc(LMEM_FIXED, cbBuf);
_JumpIfOutOfMemory(hr, Ret, szBuf);
for (; ; (*pdwIndex)++)
{
// tell api how much memory we have (incl NULL char)
cbBufUsed = cbBuf;
hr = RegEnumKeyEx(
hBaseKey,
*pdwIndex,
szBuf,
&cbBufUsed, // doesn't get updated in small buffer case?!
NULL,
NULL,
NULL,
&ft);
_JumpIfError2(hr, Ret, "RegEnumKeyEx", ERROR_NO_MORE_ITEMS);
// we have data, check if it is one we're interested in
if (NULL != wcsstr(szBuf, szContainsString))
break;
}
// don't point at this one again
(*pdwIndex)++;
hr = S_OK;
Ret:
if (S_OK != hr)
{
LocalFree(szBuf);
szBuf = NULL;
}
return ( szBuf );
}
DISPLAYSTRING_EXPANSION g_displayStrings[11] =
{
{ wszFCSAPARM_SERVERDNSNAME, IDS_TOKEN_SERVERDNSNAME, IDS_TOKENDESC_SERVERDNSNAME }, //%1
{ wszFCSAPARM_SERVERSHORTNAME, IDS_TOKEN_SERVERSHORTNAME, IDS_TOKENDESC_SERVERSHORTNAME }, //%2
{ wszFCSAPARM_SANITIZEDCANAME, IDS_TOKEN_SANITIZEDCANAME, IDS_TOKENDESC_SANITIZEDCANAME }, //%3
{ wszFCSAPARM_CERTFILENAMESUFFIX, IDS_TOKEN_CERTFILENAMESUFFIX, IDS_TOKENDESC_CERTFILENAMESUFFIX }, //%4
{ L"", IDS_DESCR_UNKNOWN, IDS_DESCR_UNKNOWN }, // %5 not available
{ wszFCSAPARM_CONFIGDN, IDS_TOKEN_CONFIGDN, IDS_TOKENDESC_CONFIGDN }, //%6
{ wszFCSAPARM_SANITIZEDCANAMEHASH, IDS_TOKEN_SANITIZEDCANAMEHASH, IDS_TOKENDESC_SANITIZEDCANAMEHASH }, //%7
{ wszFCSAPARM_CRLFILENAMESUFFIX, IDS_TOKEN_CRLFILENAMESUFFIX, IDS_TOKENDESC_CRLFILENAMESUFFIX }, //%8
{ wszFCSAPARM_CRLDELTAFILENAMESUFFIX, IDS_TOKEN_CRLDELTAFILENAMESUFFIX,IDS_TOKENDESC_CRLDELTAFILENAMESUFFIX}, //%9
{ wszFCSAPARM_DSCRLATTRIBUTE, IDS_TOKEN_DSCRLATTRIBUTE, IDS_TOKENDESC_DSCRLATTRIBUTE }, //%10
{ wszFCSAPARM_DSCACERTATTRIBUTE, IDS_TOKEN_DSCACERTATTRIBUTE, IDS_TOKENDESC_DSCACERTATTRIBUTE }, //%11
};
/////////////////////////////////////////
// fxns to load resources automatically
CLocalizedResources g_cResources;
CLocalizedResources::CLocalizedResources()
{
m_fLoaded = FALSE;
}
BOOL CLocalizedResources::Load()
{
if (!m_fLoaded)
{
HINSTANCE hRsrc = AfxGetResourceHandle();
myVerifyResourceStrings(g_hInstance);
// Load strings from resources
m_ColumnHead_Name.LoadString(IDS_COLUMN_NAME);
m_ColumnHead_Size.LoadString(IDS_COLUMN_SIZE);
m_ColumnHead_Type.LoadString(IDS_COLUMN_TYPE);
m_ColumnHead_Description.LoadString(IDS_COLUMN_DESCRIPTION);
m_DescrStr_CA.LoadString(IDS_DESCR_CA);
m_DescrStr_Unknown.LoadString(IDS_DESCR_UNKNOWN);
m_szFilterApplied.LoadString(IDS_STATUSBAR_FILTER_APPLIED);
m_szSortedAscendingTemplate.LoadString(IDS_STATUSBAR_SORTEDBY_ASCEND);
m_szSortedDescendingTemplate.LoadString(IDS_STATUSBAR_SORTEDBY_DESCEND);
m_szStoppedServerMsg.LoadString(IDS_STOPPED_SERVER_MSG);
m_szStatusBarErrorFormat.LoadString(IDS_STATUSBAR_ERRORTEMPLATE);
m_szRevokeReason_Unspecified.LoadString(IDS_CRL_REASON_UNSPECIFIED);
m_szRevokeReason_KeyCompromise.LoadString(IDS_CRL_REASON_KEY_COMPROMISE);
m_szRevokeReason_CaCompromise.LoadString(IDS_CRL_REASON_CA_COMPROMISE);
m_szRevokeReason_Affiliation.LoadString(IDS_CRL_REASON_AFFILIATION_CHANGED);
m_szRevokeReason_Superseded.LoadString(IDS_CRL_REASON_SUPERSEDED);
m_szRevokeReason_Cessatation.LoadString(IDS_CRL_REASON_CESSATION_OF_OPERATION);
m_szRevokeReason_CertHold.LoadString(IDS_CRL_REASON_CERTIFICATE_HOLD);
m_szRevokeReason_RemoveFromCRL.LoadString(IDS_CRL_REASON_REMOVE_FROM_CRL);
m_szPeriod_Seconds.LoadString(IDS_PERIOD_SECONDS);
m_szPeriod_Minutes.LoadString(IDS_PERIOD_MINUTES);
m_szPeriod_Hours.LoadString(IDS_PERIOD_HOURS);
m_szPeriod_Days.LoadString(IDS_PERIOD_DAYS);
m_szPeriod_Weeks.LoadString(IDS_PERIOD_WEEKS);
m_szPeriod_Months.LoadString(IDS_PERIOD_MONTHS);
m_szPeriod_Years.LoadString(IDS_PERIOD_YEARS);
m_szYes.LoadString(IDS_YES);
// Load the bitmaps from the dll
m_bmpSvrMgrToolbar1.LoadBitmap(IDB_TOOLBAR_SVRMGR1);
// load view strings to struct members, point to struct members
int i;
// viewResult items
for(i=0; ((viewResultItems[i].item.strName != NULL) && (viewResultItems[i].item.strStatusBarText != NULL)); i++)
{
LoadString(hRsrc, viewResultItems[i].uiString1, viewResultItems[i].szString1, sizeof(viewResultItems[i].szString1));
viewResultItems[i].item.strName = viewResultItems[i].szString1;
LoadString(hRsrc, viewResultItems[i].uiString2, viewResultItems[i].szString2, sizeof(viewResultItems[i].szString2));
viewResultItems[i].item.strStatusBarText = viewResultItems[i].szString2;
}
// taskResultItemsSingleSel
for(i=0; ((taskResultItemsSingleSel[i].myitem.item.strName != NULL) && (taskResultItemsSingleSel[i].myitem.item.strStatusBarText != NULL)); i++)
{
LoadString(hRsrc, taskResultItemsSingleSel[i].myitem.uiString1, taskResultItemsSingleSel[i].myitem.szString1, sizeof(taskResultItemsSingleSel[i].myitem.szString1));
taskResultItemsSingleSel[i].myitem.item.strName = taskResultItemsSingleSel[i].myitem.szString1;
LoadString(hRsrc, taskResultItemsSingleSel[i].myitem.uiString2, taskResultItemsSingleSel[i].myitem.szString2, sizeof(taskResultItemsSingleSel[i].myitem.szString2));
taskResultItemsSingleSel[i].myitem.item.strStatusBarText = taskResultItemsSingleSel[i].myitem.szString2;
}
// task start/stop
for(i=0; ((taskStartStop[i].item.strName != NULL) && (taskStartStop[i].item.strStatusBarText != NULL)); i++)
{
LoadString(hRsrc, taskStartStop[i].uiString1, taskStartStop[i].szString1, sizeof(taskStartStop[i].szString1));
taskStartStop[i].item.strName = taskStartStop[i].szString1;
LoadString(hRsrc, taskStartStop[i].uiString2, taskStartStop[i].szString2, sizeof(taskStartStop[i].szString2));
taskStartStop[i].item.strStatusBarText = taskStartStop[i].szString2;
}
// taskitems
for(i=0; ((taskItems[i].myitem.item.strName != NULL) && (taskItems[i].myitem.item.strStatusBarText != NULL)); i++)
{
LoadString(hRsrc, taskItems[i].myitem.uiString1, taskItems[i].myitem.szString1, sizeof(taskItems[i].myitem.szString1));
taskItems[i].myitem.item.strName = taskItems[i].myitem.szString1;
LoadString(hRsrc, taskItems[i].myitem.uiString2, taskItems[i].myitem.szString2, sizeof(taskItems[i].myitem.szString2));
taskItems[i].myitem.item.strStatusBarText = taskItems[i].myitem.szString2;
}
// topitems
for(i=0; ((topItems[i].myitem.item.strName != NULL) && (topItems[i].myitem.item.strStatusBarText != NULL)); i++)
{
LoadString(hRsrc, topItems[i].myitem.uiString1, topItems[i].myitem.szString1, sizeof(topItems[i].myitem.szString1));
topItems[i].myitem.item.strName = topItems[i].myitem.szString1;
LoadString(hRsrc, topItems[i].myitem.uiString2, topItems[i].myitem.szString2, sizeof(topItems[i].myitem.szString2));
topItems[i].myitem.item.strStatusBarText = topItems[i].myitem.szString2;
}
for (i=0; ((SvrMgrToolbar1Buttons[i].item.lpButtonText != NULL) && (SvrMgrToolbar1Buttons[i].item.lpTooltipText != NULL)); i++)
{
LoadString(hRsrc, SvrMgrToolbar1Buttons[i].uiString1, SvrMgrToolbar1Buttons[i].szString1, sizeof(SvrMgrToolbar1Buttons[i].szString1));
SvrMgrToolbar1Buttons[i].item.lpButtonText = SvrMgrToolbar1Buttons[i].szString1;
LoadString(hRsrc, SvrMgrToolbar1Buttons[i].uiString2, SvrMgrToolbar1Buttons[i].szString2, sizeof(SvrMgrToolbar1Buttons[i].szString2));
SvrMgrToolbar1Buttons[i].item.lpTooltipText = SvrMgrToolbar1Buttons[i].szString2;
}
// load replacement tokens
for (i=0; i<DISPLAYSTRINGS_TOKEN_COUNT; i++)
{
g_displayStrings[i].pcstrExpansionString = new CString;
if (g_displayStrings[i].pcstrExpansionString != NULL)
g_displayStrings[i].pcstrExpansionString->LoadString(g_displayStrings[i].uTokenID);
g_displayStrings[i].pcstrExpansionStringDescr = new CString;
if (g_displayStrings[i].pcstrExpansionStringDescr != NULL)
g_displayStrings[i].pcstrExpansionStringDescr->LoadString(g_displayStrings[i].uTokenDescrID);
}
m_fLoaded = TRUE;
}
return m_fLoaded;
}
CLocalizedResources::~CLocalizedResources()
{
m_fLoaded = FALSE;
for (int i=0; i<DISPLAYSTRINGS_TOKEN_COUNT; i++)
{
if (g_displayStrings[i].pcstrExpansionString)
delete g_displayStrings[i].pcstrExpansionString;
if (g_displayStrings[i].pcstrExpansionStringDescr)
delete g_displayStrings[i].pcstrExpansionStringDescr;
}
}
HRESULT ReadOfSize(IStream* pStm, void* pbData, ULONG cbData)
{
HRESULT hr;
ULONG nBytesRead;
hr = pStm->Read(pbData, cbData, &nBytesRead);
if ((hr == S_OK) && (nBytesRead != cbData))
hr = HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
return hr;
}
HRESULT WriteOfSize(IStream* pStm, void* pbData, ULONG cbData)
{
HRESULT hr;
ULONG nBytesWritten;
hr = pStm->Write(pbData, cbData, &nBytesWritten);
if ((hr == S_OK) && (nBytesWritten != cbData))
hr = HRESULT_FROM_WIN32(ERROR_HANDLE_DISK_FULL);
return hr;
}
HRESULT
myOIDToName(
IN WCHAR const *pwszObjId,
OUT LPWSTR* pszName)
{
HRESULT hr = S_OK;
WCHAR const *pwszName = L"";
WCHAR const *pwszName1 = L"";
WCHAR const *pwszName2;
WCHAR *pwszT = NULL;
WCHAR rgwchName[64];
if (pszName == NULL)
{
hr = E_POINTER;
_JumpError(hr, error, "pszName NULL");
}
pwszT = (LPWSTR) LocalAlloc(LMEM_FIXED, (1 + 1 + wcslen(pwszObjId)) * sizeof(WCHAR));
if (NULL == pwszT)
{
hr = E_OUTOFMEMORY;
_JumpError(hr, error, "no memory for skip counts array");
}
wcscpy(&pwszT[1], pwszObjId);
*pwszT = L'+';
pwszName1 = myGetOIDName(pwszT); // Group OID lookup
*pwszT = L'-';
pwszName2 = myGetOIDName(pwszT); // Generic OID lookup
if (0 == lstrcmpi(pwszName1, pwszName2))
{
pwszName2 = L""; // display only one if they're the same
}
if (L'\0' == *pwszName1)
{
pwszName1 = pwszName2;
pwszName2 = L"";
}
if (L'\0' != *pwszName2 &&
ARRAYSIZE(rgwchName) > wcslen(pwszName1) + wcslen(pwszName2) + 3)
{
wcscpy(rgwchName, pwszName1);
wcscat(rgwchName, L" " wszLPAREN);
wcscat(rgwchName, pwszName2);
wcscat(rgwchName, wszRPAREN);
pwszName1 = rgwchName;
}
*pszName = (LPWSTR)LocalAlloc(LMEM_FIXED, (wcslen(pwszName1)+1)*sizeof(WCHAR));
if (NULL == *pszName)
{
hr = E_OUTOFMEMORY;
_JumpError(hr, error, "pszName");
}
wcscpy(*pszName, pwszName1);
error:
if (NULL != pwszT)
{
LocalFree(pwszT);
}
return hr;
}
#include "csdisp.h"
HRESULT
myDumpFormattedObject(
IN WCHAR const *pwszObjId,
IN BYTE const *pbObject,
IN DWORD cbObject,
OUT LPWSTR* ppwszFormatted)
{
HRESULT hr = S_OK;
char * pszObjId = NULL;
DWORD cbFormatted;
WCHAR const *pwszDescriptiveName;
if (ppwszFormatted == NULL)
{
hr = E_POINTER;
_JumpError(hr, error, "NULL param");
}
if (!ConvertWszToSz(&pszObjId, pwszObjId, -1))
{
hr = E_OUTOFMEMORY;
_JumpError(hr, error, "ConvertWszToSz");
}
// format the object using the installed formatting function
if (!CryptFormatObject(
X509_ASN_ENCODING,
0,
CRYPT_FORMAT_STR_MULTI_LINE | CRYPT_FORMAT_STR_NO_HEX,
NULL,
pszObjId,
pbObject,
cbObject,
NULL,
&cbFormatted))
{
hr = myHLastError();
_JumpIfError(hr, error, "CryptFormatObject");
}
*ppwszFormatted = (WCHAR *) LocalAlloc(LMEM_FIXED, cbFormatted);
if (NULL == *ppwszFormatted)
{
hr = E_OUTOFMEMORY;
_JumpError(hr, error, "LocalAlloc");
}
if (!CryptFormatObject(
X509_ASN_ENCODING,
0,
CRYPT_FORMAT_STR_MULTI_LINE | CRYPT_FORMAT_STR_NO_HEX,
NULL,
pszObjId,
pbObject,
cbObject,
*ppwszFormatted,
&cbFormatted))
{
hr = myHLastError();
_JumpError(hr, error, "CryptFormatObject");
}
/*
if (g_fVerbose)
{
if (0 == strcmp(szOID_SUBJECT_ALT_NAME, pszObjId) ||
0 == strcmp(szOID_SUBJECT_ALT_NAME2, pszObjId) ||
0 == strcmp(szOID_ISSUER_ALT_NAME, pszObjId) ||
0 == strcmp(szOID_ISSUER_ALT_NAME2, pszObjId))
{
DumpAltName(pbObject, cbObject);
}
}
*/
error:
if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr || CRYPT_E_ASN1_BADTAG == hr)
{
// fix up nonfatal errors
CString cstrUnknown;
cstrUnknown.LoadString(IDS_UNKNOWN_EXTENSION);
hr = myDupString((LPCWSTR)cstrUnknown, ppwszFormatted);
_PrintIfError(hr, "myDupString failure");
}
if (pszObjId)
LocalFree(pszObjId);
return hr;
}
void
InplaceStripControlChars(WCHAR* szString)
{
// remove \r and \n AND \t formatting through end-of-string
if (NULL != szString)
{
while (*szString != L'\0')
{
switch(*szString)
{
case L'\r':
case L'\n':
case L'\t':
*szString = L' ';
break;
}
szString++;
}
}
}
HANDLE EnablePrivileges(LPCWSTR ppcwszPrivileges[], ULONG cPrivileges)
{
BOOL fResult = FALSE;
HANDLE hToken = INVALID_HANDLE_VALUE;
HANDLE hOriginalThreadToken = INVALID_HANDLE_VALUE;
PTOKEN_PRIVILEGES ptp;
ULONG nBufferSize;
// Note that TOKEN_PRIVILEGES includes a single LUID_AND_ATTRIBUTES
nBufferSize = sizeof(TOKEN_PRIVILEGES) + (cPrivileges - 1)*sizeof(LUID_AND_ATTRIBUTES);
ptp = (PTOKEN_PRIVILEGES)LocalAlloc(LPTR, nBufferSize);
if (!ptp)
return INVALID_HANDLE_VALUE;
//
// Initialize the Privileges Structure
//
ptp->PrivilegeCount = cPrivileges;
for (ULONG i = 0; i < cPrivileges; i++)
{
fResult = LookupPrivilegeValue(NULL, ppcwszPrivileges[i], &ptp->Privileges[i].Luid);
if (!fResult)
break;
ptp->Privileges[i].Attributes = SE_PRIVILEGE_ENABLED;
}
if(fResult)
{
//
// Open the Token
//
hToken = hOriginalThreadToken = INVALID_HANDLE_VALUE;
fResult = OpenThreadToken(GetCurrentThread(), TOKEN_DUPLICATE, FALSE, &hToken);
if (fResult)
hOriginalThreadToken = hToken; // Remember the thread token
else
fResult = OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE, &hToken);
}
if (fResult)
{
HANDLE hNewToken;
//
// Duplicate that Token
//
fResult = DuplicateTokenEx(hToken,
TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
NULL, // PSECURITY_ATTRIBUTES
SecurityImpersonation, // SECURITY_IMPERSONATION_LEVEL
TokenImpersonation, // TokenType
&hNewToken); // Duplicate token
if (fResult)
{
//
// Add new privileges
//
fResult = AdjustTokenPrivileges(hNewToken, // TokenHandle
FALSE, // DisableAllPrivileges
ptp, // NewState
0, // BufferLength
NULL, // PreviousState
NULL); // ReturnLength
if (fResult)
{
//
// Begin impersonating with the new token
//
fResult = SetThreadToken(NULL, hNewToken);
}
CloseHandle(hNewToken);
}
}
// If something failed, don't return a token
if (!fResult)
hOriginalThreadToken = INVALID_HANDLE_VALUE;
// Close the original token if we aren't returning it
if (hOriginalThreadToken == INVALID_HANDLE_VALUE && hToken != INVALID_HANDLE_VALUE)
CloseHandle(hToken);
// If we succeeded, but there was no original thread token,
// return NULL to indicate we need to do SetThreadToken(NULL, NULL)
// to release privs.
if (fResult && hOriginalThreadToken == INVALID_HANDLE_VALUE)
hOriginalThreadToken = NULL;
LocalFree(ptp);
return hOriginalThreadToken;
}
void ReleasePrivileges(HANDLE hToken)
{
if (INVALID_HANDLE_VALUE != hToken)
{
SetThreadToken(NULL, hToken);
if (hToken)
CloseHandle(hToken);
}
}
HRESULT
myGetActiveModule(
CertSvrCA *pCA,
IN BOOL fPolicyModule,
IN DWORD Index,
OPTIONAL OUT LPOLESTR *ppwszProgIdModule, // CoTaskMem*
OPTIONAL OUT CLSID *pclsidModule)
{
HRESULT hr;
WCHAR *pwsz;
variant_t var;
hr = pCA->GetConfigEntry(
fPolicyModule?wszREGKEYPOLICYMODULES:wszREGKEYEXITMODULES,
wszREGACTIVE,
&var);
_JumpIfError(hr, error, "GetConfigEntry");
hr = HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
if(V_VT(&var)==VT_BSTR)
{
pwsz = V_BSTR(&var);
}
else if(V_VT(&var)==(VT_ARRAY|VT_BSTR))
{
SafeArrayEnum<BSTR> saenum(V_ARRAY(&var));
hr = saenum.GetAt(Index, pwsz);
_JumpIfError(hr, error, "GetConfigEntry");
}
else
{
_JumpError(hr, error, "Bad active entry type");
}
if(!pwsz)
{
_JumpError(hr, error, "empty entry");
}
if (NULL != pclsidModule)
{
hr = CLSIDFromProgID(pwsz, pclsidModule);
_JumpIfError(hr, error, "CLSIDFromProgID");
}
if (NULL != ppwszProgIdModule)
{
*ppwszProgIdModule = (LPOLESTR) CoTaskMemAlloc(
(wcslen(pwsz) + 1) * sizeof(WCHAR));
if (NULL == *ppwszProgIdModule)
{
hr = E_OUTOFMEMORY;
_JumpError(hr, error, "CoTaskMemAlloc");
}
wcscpy(*ppwszProgIdModule, pwsz);
}
hr = S_OK; // not reset after ERROR_MOD_NOT_FOUND in all cases
error:
return(hr);
}
HRESULT FindComputerObjectSid(
LPCWSTR pcwszCAComputerDNSName,
PSID &pSid)
{
HRESULT hr = S_OK;
ADS_SEARCHPREF_INFO asi[1];
IDirectorySearch *pSearch = NULL;
LPWSTR pwszAttr = L"objectSid";
ADS_SEARCH_HANDLE hADS = NULL;
static LPCWSTR pwszgc = L"GC://";
static LPCWSTR pwszformat = L"(&(objectClass=computer)(servicePrincipalName=host/%s))";
LPWSTR pwszSearchFilter = NULL;
LPWSTR pwszGC = NULL;
DWORD dwres;
PDOMAIN_CONTROLLER_INFO pdci = NULL;
ADS_SEARCH_COLUMN col;
dwres = DsGetDcName(
NULL,
NULL,
NULL,
NULL,
DS_RETURN_DNS_NAME|DS_DIRECTORY_SERVICE_REQUIRED,
&pdci);
if(NO_ERROR != dwres)
{
hr = myHError(dwres);
_JumpIfError(hr, error, "DsGetDcName");
}
pwszGC = (LPWSTR)LocalAlloc(LMEM_FIXED,
sizeof(WCHAR)*(wcslen(pwszgc)+wcslen(pdci->DnsForestName)+1));
_JumpIfAllocFailed(pwszGC, error);
wcscpy(pwszGC, pwszgc);
wcscat(pwszGC, pdci->DnsForestName);
hr = ADsGetObject(pwszGC, IID_IDirectorySearch, (void**)&pSearch);
_JumpIfError(hr, error, "ADsGetObject(GC:)");
asi[0].dwSearchPref = ADS_SEARCHPREF_SEARCH_SCOPE;
asi[0].vValue.dwType = ADSTYPE_INTEGER;
asi[0].vValue.Integer = ADS_SCOPE_SUBTREE;
hr = pSearch->SetSearchPreference(asi, 1);
_JumpIfError(hr, error, "SetSearchPreference");
pwszSearchFilter = (LPWSTR)LocalAlloc(LMEM_FIXED,
sizeof(WCHAR)*(wcslen(pwszformat)+wcslen(pcwszCAComputerDNSName)+1));
wsprintf(pwszSearchFilter, pwszformat, pcwszCAComputerDNSName);
hr = pSearch->ExecuteSearch(
pwszSearchFilter,
&pwszAttr,
1,
&hADS);
_JumpIfErrorStr(hr, error, "ExecuteSearch", pwszSearchFilter);
hr = pSearch->GetFirstRow(hADS);
_JumpIfError(hr, error, "GetFirstRow");
hr = pSearch->GetColumn(hADS, pwszAttr, &col);
_JumpIfErrorStr(hr, error, "GetColumn", pwszAttr);
CSASSERT(IsValidSid(col.pADsValues[0].OctetString.lpValue));
CSASSERT(GetLengthSid(col.pADsValues[0].OctetString.lpValue)==
col.pADsValues[0].OctetString.dwLength);
pSid = LocalAlloc(LMEM_FIXED, col.pADsValues[0].OctetString.dwLength);
_JumpIfAllocFailed(pSid, error);
CopySid(col.pADsValues[0].OctetString.dwLength,
pSid,
col.pADsValues[0].OctetString.lpValue);
error:
if(pdci)
NetApiBufferFree(pdci);
if(pSearch)
{
pSearch->FreeColumn(&col);
if(hADS)
pSearch->CloseSearchHandle(hADS);
pSearch->Release();
}
LOCAL_FREE(pwszSearchFilter);
LOCAL_FREE(pwszGC);
return hr;
}
HRESULT IsUserDomainAdministrator(BOOL* pfIsAdministrator)
{
HRESULT hr = S_OK;
*pfIsAdministrator = FALSE;
PSID psidAdministrators;
SID_IDENTIFIER_AUTHORITY siaNtAuthority = SECURITY_NT_AUTHORITY;
BOOL bResult = AllocateAndInitializeSid (&siaNtAuthority, 2,
SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0, &psidAdministrators);
if ( bResult )
{
bResult = CheckTokenMembership (0, psidAdministrators,
pfIsAdministrator);
ASSERT (bResult);
if ( !bResult )
{
hr = myHLastError ();
_PrintError(hr, "CheckTokenMembership");
}
FreeSid (psidAdministrators);
}
else
{
hr = myHLastError ();
_PrintError(hr, "AllocateAndInitializeSid");
}
return hr;
}
BOOL RestartService(HWND hWnd, CertSvrMachine* pMachine)
{
// notify user we can't apply immediately
CString cstrText;
cstrText.LoadString(IDS_CONFIRM_SERVICE_RESTART);
if (IDYES == ::MessageBox(hWnd, (LPCWSTR)cstrText, (LPCWSTR)g_cResources.m_DescrStr_CA, MB_YESNO | MB_ICONWARNING ))
{
DWORD dwErr;
// stop the service
if (pMachine->IsCertSvrServiceRunning())
pMachine->CertSvrStartStopService(hWnd, FALSE);
// start the serviec
dwErr = pMachine->CertSvrStartStopService(hWnd, TRUE);
if (S_OK != dwErr)
DisplayGenericCertSrvError(hWnd, dwErr);
return TRUE;
}
return FALSE; // didn't restart
}
Reference in a new issue Copy permalink