You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1178 lines
39 KiB
1178 lines
39 KiB
//
|
|
// UTILS.CPP
|
|
//
|
|
#include "precomp.h"
|
|
|
|
static BOOL isAnimBitmapFileValidHelper(HWND hDlg, UINT nID, LPTSTR pszBuffer, PUINT pcch, UINT nIDTooBig,
|
|
UINT nIDTooSmall, long lBmpMinWidth, long lBmpMaxWidth);
|
|
static BOOL isBitmapFileValidHelper(HWND hDlg, UINT nID, LPTSTR pszBuffer, PUINT pcch,
|
|
int cx, int cy, UINT nIDTooBig, UINT nIDTooSmall, DWORD dwFlags);
|
|
static BOOL browseForFileHelper(HWND hDlg, LPTSTR pszFileName, DWORD cchSize, DWORD dwFilterMasks,
|
|
LPCTSTR pcszTitle);
|
|
static BOOL browseForFolderHelper(HWND hDlg, LPTSTR pszFileName, LPCTSTR pcszDesc);
|
|
static void exportRegTree2InfHelper(HKEY hk, LPCTSTR pszHive, LPCTSTR pszKey, HANDLE hInf, BOOL fUseLdids);
|
|
static void exportRegValue2InfHelper(HKEY hkSubKey, LPCTSTR pcszValue, LPCTSTR pcszRootKey, LPCTSTR pcszSubKey, HANDLE hInf, BOOL fUseLdids);
|
|
static void exportRegKey2InfHelper(HKEY hkSubKey, LPCTSTR pcszRootKey, LPCTSTR pcszSubKey, HANDLE hInf, BOOL fUseLdids);
|
|
static void signFileHelper(LPCTSTR pcszFilename, LPCTSTR pcszDir, LPCTSTR pcszIns, LPTSTR pszUnsignedFiles, LPCTSTR pcszCustInf, BOOL fTest);
|
|
|
|
BOOL WINAPI CheckField(HWND hDlg, int nIDDlgItem, DWORD dwFlags, LPARAM lParam /*= 0*/)
|
|
{
|
|
TCHAR szField[INTERNET_MAX_URL_LENGTH];
|
|
HWND hCtrl;
|
|
UINT nID, nStartPos;
|
|
|
|
hCtrl = GetDlgItem(hDlg, nIDDlgItem);
|
|
if (hCtrl == NULL)
|
|
return FALSE;
|
|
|
|
szField[0] = TEXT('\0');
|
|
GetWindowText(hCtrl, szField, countof(szField));
|
|
StrRemoveWhitespace(szField);
|
|
|
|
nID = nStartPos = 0;
|
|
if (HasFlag(dwFlags, FC_NONNULL)) {
|
|
if (szField[0] == TEXT('\0')) {
|
|
nID = IDS_CF_EMPTY_FIELD;
|
|
nStartPos = 0;
|
|
}
|
|
}
|
|
else
|
|
if (szField[0] == TEXT('\0'))
|
|
return TRUE;
|
|
|
|
if (nID == 0 && HasFlag(dwFlags, FC_URL))
|
|
if (!PathIsURL(szField)) {
|
|
nID = IDS_CF_INVALID_URL;
|
|
nStartPos = 0;
|
|
}
|
|
|
|
if (nID == 0 && HasFlag(dwFlags, FC_NOSPACE)) {
|
|
LPCTSTR pszChar;
|
|
|
|
for (pszChar = szField; *pszChar; pszChar = CharNext(pszChar))
|
|
if (IsSpace(*pszChar)) {
|
|
nID = IDS_CF_INVALID_SPACE;
|
|
nStartPos = 0;
|
|
}
|
|
}
|
|
|
|
if (nID == 0 && HasFlag(dwFlags, FC_NOCOLON)) {
|
|
if (StrChr(szField, TEXT(':'))) {
|
|
nID = IDS_CF_INVALID_COLON;
|
|
nStartPos = 0;
|
|
}
|
|
}
|
|
|
|
if (nID == 0 && HasFlag(dwFlags, FC_NUMBER)) {
|
|
int nLen = StrLen(szField);
|
|
|
|
for (int nIndex = 0; nIndex < nLen; nIndex++) {
|
|
if (!(szField[nIndex] >= TEXT('0') && szField[nIndex] <= TEXT('9'))) {
|
|
nID = IDS_CF_INVALID_NUMBER;
|
|
nStartPos = nIndex;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!(nID == 0 && HasFlag(dwFlags, FC_URL)) &&
|
|
(nID == 0 || HasFlag(dwFlags, FC_URL)) && HasFlag(dwFlags, FC_PATH)) {
|
|
LPCTSTR pszError;
|
|
DWORD dwResult = PIVP_VALID;
|
|
|
|
ASSERT(HasFlag(dwFlags, FC_URL) ? nID != 0 : TRUE);
|
|
|
|
nID = nStartPos = 0;
|
|
SetFlag(&dwFlags, FC_PATH, FALSE);
|
|
|
|
if (HasFlag(dwFlags, FC_FILE))
|
|
{
|
|
if (HasFlag(dwFlags, FC_EXISTS))
|
|
SetFlag((LPDWORD)&lParam, PIVP_FILE_ONLY);
|
|
}
|
|
else if (HasFlag(dwFlags, FC_DIR))
|
|
{
|
|
if (HasFlag(dwFlags, FC_EXISTS))
|
|
SetFlag((LPDWORD)&lParam, PIVP_FOLDER_ONLY);
|
|
}
|
|
|
|
dwResult = PathIsValidPathEx(szField, (DWORD) lParam, &pszError);
|
|
|
|
// check for extended character in the field
|
|
if (dwResult == PIVP_VALID) {
|
|
if (HasFlag(dwFlags, FC_FILE))
|
|
{
|
|
SetFlag((LPDWORD)&lParam, PIVP_FILE_ONLY, FALSE);
|
|
if (HasFlag(dwFlags, FC_NOEXCHAR))
|
|
SetFlag((LPDWORD)&lParam, (PIVP_FILENAME_ONLY | PIVP_EXCHAR_INVALID));
|
|
else
|
|
SetFlag((LPDWORD)&lParam, (PIVP_FILENAME_ONLY | PIVP_0x5C_INVALID));
|
|
|
|
dwResult = PathIsValidPathEx(PathFindFileName(szField), (DWORD) lParam, &pszError);
|
|
}
|
|
else if (HasFlag(dwFlags, FC_DIR))
|
|
{
|
|
if (HasFlag(dwFlags, FC_NOEXCHAR))
|
|
dwResult = PathIsValidPathEx(szField, PIVP_EXCHAR_INVALID, &pszError);
|
|
}
|
|
}
|
|
|
|
if (dwResult != PIVP_VALID) {
|
|
static struct {
|
|
DWORD dwError;
|
|
UINT nID;
|
|
} rgMap[] = {
|
|
{ PIVP_CHAR, IDS_CF_CHAR },
|
|
{ PIVP_WILD, IDS_CF_WILD },
|
|
{ PIVP_RELATIVE, IDS_CF_RELATIVE },
|
|
{ PIVP_FIRST_CHAR, IDS_CF_FIRST_CHAR },
|
|
{ PIVP_PRESLASH, IDS_CF_PRESLASH },
|
|
{ PIVP_SPACE, IDS_CF_SPACE },
|
|
{ PIVP_FWDSLASH, IDS_CF_FWDSLASH },
|
|
{ PIVP_COLON, IDS_CF_COLON },
|
|
{ PIVP_DRIVE, IDS_CF_DRIVE },
|
|
{ PIVP_SEPARATOR, IDS_CF_SEPARATOR },
|
|
{ PIVP_DBCS, IDS_CF_DBCS },
|
|
{ PIVP_0x5C, IDS_CF_0x5C },
|
|
{ PIVP_DOESNT_EXIST, IDS_CF_DOESNT_EXIST },
|
|
{ PIVP_NOT_FILE, IDS_CF_NOT_FILE },
|
|
{ PIVP_NOT_FOLDER, IDS_CF_NOT_FOLDER },
|
|
{ PIVP_EXCHAR, IDS_CF_EXCHAR },
|
|
{ 0, IDS_CF_UNKNOWN }
|
|
};
|
|
|
|
ASSERT(pszError >= szField);
|
|
for (UINT i = 0; i < countof(rgMap)-1; i++)
|
|
if (dwResult == rgMap[i].dwError)
|
|
break;
|
|
ASSERT(i < countof(rgMap));
|
|
|
|
nID = rgMap[i].nID;
|
|
nStartPos = (pszError != NULL ? (int)(pszError - szField) : 0);
|
|
}
|
|
}
|
|
|
|
if (nID != 0) {
|
|
ErrorMessageBox(hDlg, nID);
|
|
Edit_SetSel(hCtrl, nStartPos, -1);
|
|
SetFocus(hCtrl);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL WINAPI IsAnimBitmapFileValidA(HWND hDlg, UINT nID, LPSTR pszBuffer, PUINT pcch, UINT nIDTooBig,
|
|
UINT nIDTooSmall, long lBmpMinWidth, long lBmpMaxWidth)
|
|
{
|
|
LPTSTR pszBuf;
|
|
BOOL fRet;
|
|
|
|
USES_CONVERSION;
|
|
|
|
if ((pcch != NULL) && (*pcch != 0))
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, (*pcch) * sizeof(TCHAR));
|
|
else
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, MAX_PATH * sizeof(TCHAR));
|
|
|
|
if (pszBuf == NULL)
|
|
fRet = FALSE;
|
|
else
|
|
{
|
|
A2Tbux(pszBuffer, pszBuf);
|
|
fRet = isAnimBitmapFileValidHelper(hDlg, nID, pszBuf, pcch, nIDTooBig, nIDTooSmall, lBmpMinWidth, lBmpMaxWidth);
|
|
T2Abux(pszBuf, pszBuffer);
|
|
LocalFree(pszBuf);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL WINAPI IsAnimBitmapFileValidW(HWND hDlg, UINT nID, LPWSTR pwszBuffer, PUINT pcch, UINT nIDTooBig,
|
|
UINT nIDTooSmall, long lBmpMinWidth, long lBmpMaxWidth)
|
|
{
|
|
LPTSTR pszBuf;
|
|
BOOL fRet;
|
|
|
|
USES_CONVERSION;
|
|
|
|
if ((pcch != NULL) && (*pcch != 0))
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, (*pcch) * sizeof(TCHAR));
|
|
else
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, MAX_PATH * sizeof(TCHAR));
|
|
|
|
if (pszBuf == NULL)
|
|
fRet = FALSE;
|
|
else
|
|
{
|
|
W2Tbux(pwszBuffer, pszBuf);
|
|
fRet = isAnimBitmapFileValidHelper(hDlg, nID, pszBuf, pcch, nIDTooBig, nIDTooSmall, lBmpMinWidth, lBmpMaxWidth);
|
|
T2Wbux(pszBuf, pwszBuffer);
|
|
LocalFree(pszBuf);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL WINAPI IsBitmapFileValidA(HWND hDlg, UINT nID, LPSTR pszBuffer, PUINT pcch, int cx, int cy,
|
|
UINT nIDTooBig, UINT nIDTooSmall, DWORD dwFlags /*= 0 */)
|
|
{
|
|
LPTSTR pszBuf;
|
|
BOOL fRet;
|
|
|
|
USES_CONVERSION;
|
|
|
|
if ((pcch != NULL) && (*pcch != 0))
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, (*pcch) * sizeof(TCHAR));
|
|
else
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, MAX_PATH * sizeof(TCHAR));
|
|
|
|
if (pszBuf == NULL)
|
|
fRet = FALSE;
|
|
else
|
|
{
|
|
A2Tbux(pszBuffer, pszBuf);
|
|
fRet = isBitmapFileValidHelper(hDlg, nID, pszBuf, pcch, cx, cy, nIDTooBig, nIDTooSmall, dwFlags);
|
|
T2Abux(pszBuf, pszBuffer);
|
|
LocalFree(pszBuf);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL WINAPI IsBitmapFileValidW(HWND hDlg, UINT nID, LPWSTR pwszBuffer, PUINT pcch, int cx, int cy,
|
|
UINT nIDTooBig, UINT nIDTooSmall, DWORD dwFlags /*= 0 */)
|
|
{
|
|
LPTSTR pszBuf;
|
|
BOOL fRet;
|
|
|
|
USES_CONVERSION;
|
|
|
|
if ((pcch != NULL) && (*pcch != 0))
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, (*pcch) * sizeof(TCHAR));
|
|
else
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, MAX_PATH * sizeof(TCHAR));
|
|
|
|
if (pszBuf == NULL)
|
|
fRet = FALSE;
|
|
else
|
|
{
|
|
W2Tbux(pwszBuffer, pszBuf);
|
|
fRet = isBitmapFileValidHelper(hDlg, nID, pszBuf, pcch, cx, cy, nIDTooBig, nIDTooSmall, dwFlags);
|
|
T2Wbux(pszBuf, pwszBuffer);
|
|
LocalFree(pszBuf);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
void WINAPI SetLBWidth(HWND hLb)
|
|
{
|
|
HDC hDc = GetDC( hLb );
|
|
LONG wMax = 0;
|
|
SIZE sText;
|
|
POINT point;
|
|
int i;
|
|
int nItems = (int) SendMessage( hLb, LB_GETCOUNT, 0, 0 );
|
|
for (i = 0; i < nItems ; i++ )
|
|
{
|
|
TCHAR szText[MAX_PATH];
|
|
SendMessage(hLb, LB_GETTEXT, i, (LPARAM) szText);
|
|
GetTextExtentPoint32( hDc, szText, StrLen(szText), &sText );
|
|
if (sText.cx > wMax) wMax = sText.cx;
|
|
}
|
|
|
|
point.y=0;
|
|
point.x=wMax;
|
|
|
|
LPtoDP(hDc,&point,1); //TODO: this is still not exactly what we want--why does it have extra space???!!
|
|
|
|
SendMessage( hLb, LB_SETHORIZONTALEXTENT, point.x, 0 );
|
|
ReleaseDC(hLb, hDc);
|
|
}
|
|
|
|
BOOL WINAPI BrowseForFileA(HWND hDlg, LPSTR pszFileName, DWORD cchSize, DWORD dwFilterMasks, LPCSTR pcszTitle /* = NULL */)
|
|
{
|
|
LPTSTR pszBuf = (LPTSTR)LocalAlloc(LPTR, cchSize * sizeof(TCHAR));
|
|
BOOL fRet;
|
|
|
|
USES_CONVERSION;
|
|
|
|
if (pszBuf == NULL)
|
|
fRet = FALSE;
|
|
else
|
|
{
|
|
A2Tbux(pszFileName, pszBuf);
|
|
fRet = browseForFileHelper(hDlg, pszBuf, cchSize, dwFilterMasks,
|
|
(pcszTitle == NULL) ? NULL : A2CT(pcszTitle));
|
|
T2Abux(pszBuf, pszFileName);
|
|
LocalFree(pszBuf);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL WINAPI BrowseForFileW(HWND hDlg, LPWSTR pwszFileName, DWORD cchSize, DWORD dwFilterMasks, LPCWSTR pcwszTitle /*= NULL */)
|
|
{
|
|
LPTSTR pszBuf = (LPTSTR)LocalAlloc(LPTR, cchSize * sizeof(TCHAR));
|
|
BOOL fRet;
|
|
|
|
USES_CONVERSION;
|
|
|
|
if (pszBuf == NULL)
|
|
fRet = FALSE;
|
|
else
|
|
{
|
|
W2Tbux(pwszFileName, pszBuf);
|
|
fRet = browseForFileHelper(hDlg, pszBuf, cchSize, dwFilterMasks,
|
|
(pcwszTitle == NULL) ? NULL : W2CT(pcwszTitle));
|
|
T2Wbux(pszBuf, pwszFileName);
|
|
LocalFree(pszBuf);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL WINAPI BrowseForFolderA(HWND hDlg, LPSTR pszFileName, LPCSTR pcszDesc /*= NULL */)
|
|
{
|
|
TCHAR szFileName[MAX_PATH];
|
|
BOOL fRet;
|
|
|
|
USES_CONVERSION;
|
|
|
|
fRet = browseForFolderHelper(hDlg, szFileName, (pcszDesc == NULL) ? NULL : A2CT(pcszDesc));
|
|
T2Abux(szFileName, pszFileName);
|
|
return fRet;
|
|
}
|
|
|
|
BOOL WINAPI BrowseForFolderW(HWND hDlg, LPWSTR pwszFileName, LPCWSTR pcwszDesc /* = NULL */)
|
|
{
|
|
TCHAR szFileName[MAX_PATH];
|
|
BOOL fRet;
|
|
|
|
USES_CONVERSION;
|
|
|
|
fRet = browseForFolderHelper(hDlg, szFileName, (pcwszDesc == NULL) ? NULL : W2CT(pcwszDesc));
|
|
T2Wbux(szFileName, pwszFileName);
|
|
|
|
return fRet;
|
|
}
|
|
|
|
void WINAPI ExportRegTree2InfA(HKEY hkSubKey, LPCSTR pcszRootKey, LPCSTR pcszSubKey, HANDLE hInf, BOOL fUseLdids /*= FALSE */)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
exportRegTree2InfHelper(hkSubKey, A2CT(pcszRootKey), A2CT(pcszSubKey), hInf, fUseLdids);
|
|
}
|
|
|
|
void WINAPI ExportRegTree2InfW(HKEY hkSubKey, LPCWSTR pcwszRootKey, LPCWSTR pcwszSubKey, HANDLE hInf, BOOL fUseLdids /*= FALSE */)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
exportRegTree2InfHelper(hkSubKey, W2CT(pcwszRootKey), W2CT(pcwszSubKey), hInf, fUseLdids);
|
|
}
|
|
|
|
void WINAPI ExportRegKey2InfA(HKEY hkSubKey, LPCSTR pcszRootKey, LPCSTR pcszSubKey, HANDLE hInf, BOOL fUseLdids /*= FALSE */)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
exportRegKey2InfHelper(hkSubKey, A2CT(pcszRootKey), A2CT(pcszSubKey), hInf, fUseLdids);
|
|
}
|
|
|
|
void WINAPI ExportRegKey2InfW(HKEY hkSubKey, LPCWSTR pcwszRootKey, LPCWSTR pcwszSubKey, HANDLE hInf, BOOL fUseLdids /*= FALSE */)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
exportRegKey2InfHelper(hkSubKey, W2CT(pcwszRootKey), W2CT(pcwszSubKey), hInf, fUseLdids);
|
|
}
|
|
|
|
void WINAPI ExportRegValue2InfA(HKEY hkSubKey, LPCSTR pcszValue, LPCSTR pcszRootKey, LPCSTR pcszSubKey, HANDLE hInf, BOOL fUseLdids /* = FALSE */)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
exportRegValue2InfHelper(hkSubKey, A2CT(pcszValue), A2CT(pcszRootKey), A2CT(pcszSubKey), hInf, fUseLdids);
|
|
}
|
|
|
|
void WINAPI ExportRegValue2InfW(HKEY hkSubKey, LPCWSTR pcwszValue, LPCWSTR pcwszRootKey, LPCWSTR pcwszSubKey, HANDLE hInf, BOOL fUseLdids /* = FALSE */)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
exportRegValue2InfHelper(hkSubKey, W2CT(pcwszValue), W2CT(pcwszRootKey), W2CT(pcwszSubKey), hInf, fUseLdids);
|
|
}
|
|
|
|
void AppendCommaHex(LPTSTR pszBuf, BYTE bData, DWORD dwFlags)
|
|
{
|
|
CHAR szData[2] = "0";
|
|
CHAR c1;
|
|
|
|
USES_CONVERSION;
|
|
|
|
if (dwFlags & 0x0001)
|
|
StrCat(pszBuf, TEXT(","));
|
|
|
|
c1 = (CHAR)('0' + ((bData >> 4) & 0x0f));
|
|
if (c1 > '9')
|
|
c1 += 'A' - '9' - 1;
|
|
*szData = c1;
|
|
|
|
StrCat(pszBuf, A2T(szData));
|
|
|
|
c1 = (CHAR)('0' + (bData & 0x0f));
|
|
if (c1 > '9')
|
|
c1 += 'A' - '9' - 1;
|
|
*szData = c1;
|
|
|
|
StrCat(pszBuf, A2T(szData));
|
|
}
|
|
|
|
void WINAPI SignFileA(LPCSTR pcszFilename, LPCSTR pcszDir, LPCSTR pcszIns, LPSTR pszUnsignedFiles /* = NULL */, LPCSTR pcszCustInf /* = NULL */, BOOL fTest /* = FALSE */)
|
|
{
|
|
LPTSTR pszBuf = NULL;
|
|
|
|
USES_CONVERSION;
|
|
|
|
// allocate enough to for one file along with carriage return, new line and null termination
|
|
// we'll manually append to the end of unsigned files to save on thunking
|
|
|
|
if (pszUnsignedFiles != NULL)
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, (MAX_PATH + 3)*sizeof(TCHAR));
|
|
|
|
signFileHelper(A2CT(pcszFilename), A2CT(pcszDir), A2CT(pcszIns), pszBuf,
|
|
(pcszCustInf == NULL) ? NULL : A2CT(pcszCustInf), fTest);
|
|
|
|
if (pszBuf != NULL)
|
|
{
|
|
StrCatA(pszUnsignedFiles, T2A(pszBuf));
|
|
LocalFree(pszBuf);
|
|
}
|
|
}
|
|
|
|
void WINAPI SignFileW(LPCWSTR pcwszFilename, LPCWSTR pcwszDir, LPCWSTR pcwszIns, LPWSTR pwszUnsignedFiles /* = NULL */, LPCWSTR pcwszCustInf /* = NULL */, BOOL fTest /* = FALSE */)
|
|
{
|
|
LPTSTR pszBuf = NULL;
|
|
|
|
USES_CONVERSION;
|
|
|
|
// allocate enough to for one file along with carriage return, new line and null termination
|
|
// we'll manually append to the end of unsigned files to save on thunking
|
|
|
|
if (pwszUnsignedFiles != NULL)
|
|
pszBuf = (LPTSTR)LocalAlloc(LPTR, (MAX_PATH + 3)*sizeof(TCHAR));
|
|
|
|
signFileHelper(W2CT(pcwszFilename), W2CT(pcwszDir), W2CT(pcwszIns), pszBuf,
|
|
(pcwszCustInf == NULL) ? NULL : W2CT(pcwszCustInf), fTest);
|
|
|
|
if (pszBuf != NULL)
|
|
{
|
|
StrCatW(pwszUnsignedFiles, T2W(pszBuf));
|
|
LocalFree(pszBuf);
|
|
}
|
|
}
|
|
|
|
void MoveFileToWorkDir(LPCTSTR pcszFile, LPCTSTR pcszSrcDir, LPCTSTR pcszWorkDir, BOOL fHTM /* = FALSE */)
|
|
{
|
|
TCHAR szFile[MAX_PATH];
|
|
|
|
PathCombine(szFile, pcszWorkDir, pcszFile);
|
|
|
|
if (!PathFileExists(szFile))
|
|
{
|
|
PathCombine(szFile, pcszSrcDir, pcszFile);
|
|
|
|
if (PathFileExists(szFile))
|
|
{
|
|
CopyFileToDir(szFile, pcszWorkDir);
|
|
if (fHTM)
|
|
CopyHtmlImgs(szFile, pcszWorkDir, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
if (fHTM)
|
|
DeleteHtmlImgs(szFile, pcszSrcDir, NULL, NULL);
|
|
|
|
DeleteFileInDir(pcszFile, pcszSrcDir);
|
|
}
|
|
|
|
static BOOL isAnimBitmapFileValidHelper(HWND hDlg, UINT nID, LPTSTR pszBuffer, PUINT pcch, UINT nIDTooBig,
|
|
UINT nIDTooSmall, long lBmpMinWidth, long lBmpMaxWidth)
|
|
{
|
|
TCHAR szFile[MAX_PATH];
|
|
HANDLE hBmp;
|
|
HWND hCtrl;
|
|
BITMAP bmLarge;
|
|
UINT nLen,
|
|
nIDError = 0;
|
|
|
|
if (!CheckField(hDlg, nID, FC_FILE | FC_EXISTS))
|
|
return FALSE;
|
|
|
|
nLen = GetDlgItemText(hDlg, nID, szFile, ARRAYSIZE(szFile));
|
|
|
|
//----- Set "out" and "in-out parameters" -----
|
|
if (pszBuffer != NULL)
|
|
if (pcch != NULL) {
|
|
StrCpyN(pszBuffer, szFile, *pcch);
|
|
*pcch = nLen;
|
|
}
|
|
else
|
|
StrCpy(pszBuffer, szFile); // no checking for size
|
|
|
|
if (nLen == 0)
|
|
return TRUE; // consider valid
|
|
|
|
hCtrl = GetDlgItem(hDlg, nID);
|
|
|
|
//----- Check that this is a bitmap -----
|
|
hBmp = LoadImage(NULL, szFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
if (hBmp == NULL) {
|
|
ErrorMessageBox(hDlg, IDS_INVALIDBITMAP);
|
|
|
|
SendMessage(hCtrl, EM_SETSEL, 0, -1);
|
|
SetFocus(hCtrl);
|
|
return FALSE;
|
|
}
|
|
|
|
//----- Check the dimensions -----
|
|
GetObject(hBmp, sizeof(BITMAP), &bmLarge);
|
|
DeleteObject(hBmp);
|
|
|
|
if (bmLarge.bmWidth > lBmpMaxWidth)
|
|
nIDError = nIDTooBig;
|
|
else if (bmLarge.bmWidth < lBmpMinWidth)
|
|
nIDError = nIDTooSmall;
|
|
else if (bmLarge.bmBitsPixel > 8)
|
|
nIDError = IDS_TOOMANYCOLORS;
|
|
|
|
if (nIDError != 0)
|
|
{
|
|
ErrorMessageBox(hDlg, nIDError);
|
|
|
|
SendMessage(hCtrl, EM_SETSEL, 0, -1);
|
|
SetFocus(hCtrl);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// isBitmapFileValidHelper
|
|
// Verifies that file is a valid bitmap. Also optionally checks the dimenstions of this
|
|
// bitmap if in-parameters cx and cy are not 0s.
|
|
//
|
|
// Returns: obvious;
|
|
//
|
|
// Used by: in dialog procedures mostly in OnOK sort of handlers
|
|
//
|
|
static BOOL isBitmapFileValidHelper(HWND hDlg, UINT nID, LPTSTR pszBuffer, PUINT pcch,
|
|
int cx, int cy, UINT nIDTooBig, UINT nIDTooSmall,
|
|
DWORD dwFlags /* = 0 */)
|
|
{
|
|
TCHAR szFile[MAX_PATH] = TEXT("");
|
|
BITMAP bm;
|
|
HANDLE hBmp;
|
|
HWND hCtrl;
|
|
UINT nLen,
|
|
nIDError = 0;
|
|
|
|
if (!CheckField(hDlg, nID, FC_FILE | FC_EXISTS))
|
|
return FALSE;
|
|
|
|
nLen = GetDlgItemText(hDlg, nID, szFile, ARRAYSIZE(szFile));
|
|
|
|
//----- Set "out" and "in-out parameters" -----
|
|
if (pszBuffer != NULL)
|
|
if (pcch != NULL) {
|
|
StrCpyN(pszBuffer, szFile, *pcch);
|
|
*pcch = nLen;
|
|
}
|
|
else
|
|
StrCpy(pszBuffer, szFile); // no checking for size
|
|
|
|
if (nLen == 0)
|
|
return TRUE; // consider valid
|
|
|
|
// backdoor
|
|
if ((GetKeyState(VK_SHIFT) & 0x8000) > 0)
|
|
return TRUE;
|
|
|
|
hCtrl = GetDlgItem(hDlg, nID);
|
|
|
|
//----- Check that this is a bitmap -----
|
|
// Note. The docs say that LR_LOADFROMFILE is not supported on NT?
|
|
hBmp = LoadImage(NULL, szFile, IMAGE_BITMAP, 0, 0,
|
|
LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
|
|
if (hBmp == NULL) {
|
|
ErrorMessageBox(hDlg, IDS_INVALIDBITMAP);
|
|
|
|
SendMessage(hCtrl, EM_SETSEL, 0, -1);
|
|
SetFocus(hCtrl);
|
|
return FALSE;
|
|
}
|
|
|
|
if (cx == 0 && cy == 0) {
|
|
DeleteObject(hBmp);
|
|
return TRUE;
|
|
}
|
|
|
|
GetObject(hBmp, sizeof(BITMAP), &bm);
|
|
DeleteObject(hBmp); // no longer needed
|
|
|
|
//----- Check the dimensions if interested -----
|
|
|
|
if (dwFlags & BMP_EXACT)
|
|
{
|
|
if ((bm.bmWidth > cx) || (bm.bmHeight > cy))
|
|
nIDError = nIDTooBig;
|
|
else if ((bm.bmWidth < cx) || (bm.bmHeight < cy))
|
|
nIDError = nIDTooSmall;
|
|
}
|
|
else
|
|
{
|
|
LONG cxBigTolerance, cyBigTolerance,
|
|
cxSmallTolerance = 0, cySmallTolerance = 0;
|
|
|
|
// Note. The current tolearne is 10%.
|
|
ASSERT(cx > 0 && cy > 0);
|
|
|
|
if (dwFlags & BMP_SMALLER)
|
|
{
|
|
cxBigTolerance = cx;
|
|
cyBigTolerance = cy;
|
|
}
|
|
else
|
|
{
|
|
cxBigTolerance = cx + cx/10;
|
|
cyBigTolerance = cy + cy/10;
|
|
cxSmallTolerance = cx - cx/10;
|
|
cySmallTolerance = cy - cy/10;
|
|
}
|
|
ASSERT(cxSmallTolerance >= 0 && cySmallTolerance >= 0);
|
|
|
|
if (bm.bmWidth > cxBigTolerance || bm.bmHeight > cyBigTolerance)
|
|
nIDError = nIDTooBig;
|
|
else if (!(dwFlags & BMP_SMALLER) &&
|
|
(bm.bmWidth < cxSmallTolerance || bm.bmHeight < cySmallTolerance))
|
|
nIDError = nIDTooSmall;
|
|
}
|
|
|
|
if ((nIDError==0) && (bm.bmBitsPixel > 8))
|
|
nIDError = IDS_TOOMANYCOLORS;
|
|
|
|
if (nIDError != 0) {
|
|
ErrorMessageBox(hDlg, nIDError);
|
|
|
|
SendMessage(hCtrl, EM_SETSEL, 0, -1);
|
|
SetFocus(hCtrl);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
typedef struct tagFILTERS
|
|
{
|
|
DWORD dwFilterMask;
|
|
UINT uFilterId;
|
|
UINT uDescId;
|
|
} FILTERS;
|
|
|
|
|
|
// order that filters show up in browse dialog is based on order in this array
|
|
|
|
static FILTERS s_afFilters[] =
|
|
{
|
|
{ GFN_CDF, IDS_CDF_FILTER, IDS_COMP_CDF },
|
|
{ GFN_ICO, IDS_ICO_FILTER, IDS_COMP_ICO },
|
|
{ GFN_PICTURE, IDS_IMAGES_FILTER, IDS_COMP_IMAGES },
|
|
{ GFN_LOCALHTM, IDS_HTMLDOC_FILTER, IDS_COMP_FILEHTML },
|
|
{ GFN_MYCOMP, IDS_MYCOMP_FILTER, IDS_COMP_MYCOMP },
|
|
{ GFN_CONTROLP, IDS_CONTROLP_FILTER, IDS_COMP_CONTROLP },
|
|
{ GFN_CERTIFICATE, IDS_CERTIFICATE_FILTER, IDS_COMP_CERT },
|
|
{ GFN_BMP, IDS_BMP_FILTER, IDS_COMP_FILEBMP },
|
|
{ GFN_ADM, IDS_ADM_FILTER, IDS_COMP_ADM },
|
|
{ GFN_INS, IDS_INS_FILTER, IDS_COMP_INSFILE },
|
|
{ GFN_PVK, IDS_PVK_FILTER, IDS_COMP_PVK },
|
|
{ GFN_SPC, IDS_SPC_FILTER, IDS_COMP_SPC },
|
|
{ GFN_SCRIPT, IDS_SCRIPT_FILTER, IDS_COMP_SCRIPT },
|
|
{ GFN_TXT, IDS_TXT_FILTER, IDS_COMP_TXT },
|
|
{ GFN_EXE, IDS_EXE_FILTER, IDS_COMP_EXE },
|
|
{ GFN_CAB, IDS_CAB_FILTER, IDS_COMP_CAB },
|
|
{ GFN_RULES, IDS_RULES_FILTER, IDS_COMP_RULES },
|
|
{ GFN_ISP, IDS_ISP_FILTER, IDS_COMP_ISP },
|
|
{ GFN_WAV, IDS_WAV_FILTER, IDS_COMP_WAV },
|
|
{ GFN_GIF, IDS_GIF_FILTER, IDS_COMP_GIF }
|
|
};
|
|
|
|
static BOOL browseForFileHelper(HWND hDlg, LPTSTR pszFileName, DWORD cchSize, DWORD dwFilterMasks,
|
|
LPCTSTR pcszTitle /* = NULL */)
|
|
{
|
|
OPENFILENAME ofn;
|
|
TCHAR szTitle[MAX_PATH];
|
|
TCHAR szBrowseDir[MAX_PATH];
|
|
TCHAR szFilter[MAX_PATH];
|
|
static TCHAR szDefaultDir[MAX_PATH];
|
|
|
|
if (pszFileName == NULL)
|
|
return FALSE;
|
|
|
|
ZeroMemory((PVOID) &ofn, sizeof(ofn));
|
|
|
|
// initialize the relevant fields in ofn
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hwndOwner = hDlg;
|
|
ofn.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST;
|
|
|
|
if (pcszTitle == NULL || ISNULL(pcszTitle))
|
|
{
|
|
if (LoadString(g_hInst, IDS_BROWSE, szTitle, ARRAYSIZE(szTitle)))
|
|
ofn.lpstrTitle = szTitle;
|
|
}
|
|
else
|
|
ofn.lpstrTitle = pcszTitle;
|
|
|
|
// initialize the InitialDir field
|
|
if (*pszFileName)
|
|
{
|
|
StrCpy(szBrowseDir, pszFileName);
|
|
if (PathIsUNCServer(szBrowseDir) ||
|
|
((PathIsDirectory(szBrowseDir) || PathRemoveFileSpec(szBrowseDir)) && PathFileExists(szBrowseDir)))
|
|
ofn.lpstrInitialDir = szBrowseDir;
|
|
}
|
|
else if (*szDefaultDir)
|
|
{
|
|
ofn.lpstrInitialDir = szDefaultDir;
|
|
}
|
|
else {
|
|
if (!FAILED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, szBrowseDir))) //default to my docs
|
|
ofn.lpstrInitialDir = szBrowseDir;
|
|
}
|
|
|
|
|
|
*pszFileName = TEXT('\0');
|
|
ofn.lpstrFile = pszFileName;
|
|
ofn.nMaxFile = cchSize;
|
|
|
|
// set the filter
|
|
if (dwFilterMasks)
|
|
{
|
|
LPTSTR pszFilter;
|
|
INT cchFilter, cchRead;
|
|
|
|
// load the description for the filter
|
|
pszFilter = szFilter;
|
|
cchFilter = ARRAYSIZE(szFilter) - 1; // room for the final second nul char
|
|
for (int i = 0; i < ARRAYSIZE(s_afFilters); i++)
|
|
{
|
|
if (dwFilterMasks & s_afFilters[i].dwFilterMask)
|
|
{
|
|
cchRead = LoadString(g_hDLLInst, s_afFilters[i].uDescId, pszFilter, cchFilter);
|
|
cchFilter -= cchRead + 1;
|
|
// filter description
|
|
if ((cchRead != 0) && (cchFilter != 0))
|
|
{
|
|
pszFilter += cchRead;
|
|
*pszFilter++ = TEXT('\0');
|
|
}
|
|
|
|
cchRead = LoadString(g_hDLLInst, s_afFilters[i].uFilterId, pszFilter, cchFilter);
|
|
cchFilter -= cchRead + 1;
|
|
// filter extensions
|
|
if ((cchRead != 0) && (cchFilter != 0))
|
|
{
|
|
pszFilter += cchRead;
|
|
*pszFilter++ = TEXT('\0');
|
|
}
|
|
}
|
|
}
|
|
|
|
// double nul terminate the string.
|
|
*pszFilter = TEXT('\0');
|
|
|
|
ofn.lpstrFilter = szFilter;
|
|
}
|
|
|
|
BOOL bRetVal = GetOpenFileName(&ofn);
|
|
//save the dir so we return here.
|
|
StrCpy(szDefaultDir,ofn.lpstrFile);
|
|
PathRemoveFileSpec(szDefaultDir);
|
|
|
|
return bRetVal;
|
|
}
|
|
|
|
static BOOL browseForFolderHelper(HWND hDlg, LPTSTR pszFileName, LPCTSTR pcszDesc)
|
|
{
|
|
LPITEMIDLIST pId;
|
|
BROWSEINFO bInfo;
|
|
|
|
ZeroMemory(&bInfo, sizeof(bInfo));
|
|
bInfo.hwndOwner = hDlg;
|
|
bInfo.pidlRoot = NULL;
|
|
bInfo.ulFlags = BIF_RETURNONLYFSDIRS | BIF_RETURNFSANCESTORS;
|
|
bInfo.pszDisplayName = pszFileName;
|
|
if (pcszDesc)
|
|
bInfo.lpszTitle = pcszDesc;
|
|
pId = SHBrowseForFolder(&bInfo);
|
|
if (!pId)
|
|
return FALSE;
|
|
|
|
SHGetPathFromIDList(pId, pszFileName);
|
|
|
|
// BUGBUG: <oliverl> shoule we free pId?
|
|
return TRUE;
|
|
}
|
|
|
|
void WINAPI ErrorMessageBox(HWND hWnd, UINT idErrorStr, DWORD dwFlags /* = 0 */)
|
|
{
|
|
TCHAR szTitle[MAX_PATH],
|
|
szMsg[MAX_PATH];
|
|
|
|
if (LoadString(g_hDLLInst, IDS_TITLE, szTitle, ARRAYSIZE(szTitle)) == 0)
|
|
LoadString(g_hInst, IDS_TITLE, szTitle, ARRAYSIZE(szTitle));
|
|
|
|
if (LoadString(g_hDLLInst, idErrorStr, szMsg, ARRAYSIZE(szMsg)) == 0)
|
|
LoadString(g_hInst, idErrorStr, szMsg, ARRAYSIZE(szMsg));
|
|
|
|
MessageBox(hWnd, szMsg, szTitle,
|
|
dwFlags ? dwFlags : MB_OK | MB_SETFOREGROUND | MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
static void exportRegTree2InfHelper(HKEY hk, LPCTSTR pszHive, LPCTSTR pszKey, HANDLE hInf, BOOL fUseLdids)
|
|
// Export all the value names and sub-keys under pcszSubKey to hInf as AddReg lines
|
|
{
|
|
TCHAR szSubKey[MAX_PATH],
|
|
szFullSubKey[MAX_PATH];
|
|
DWORD dwIndex = 0;
|
|
DWORD dwSub = countof(szSubKey);
|
|
|
|
exportRegKey2InfHelper(hk, pszHive, pszKey, hInf, fUseLdids);
|
|
while (RegEnumKeyEx(hk, dwIndex, szSubKey, &dwSub, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
|
|
HKEY hkSub;
|
|
|
|
if (RegOpenKeyEx(hk, szSubKey, 0, KEY_ENUMERATE_SUB_KEYS | KEY_READ, &hkSub) == ERROR_SUCCESS) {
|
|
wnsprintf(szFullSubKey, ARRAYSIZE(szFullSubKey), TEXT("%s\\%s"), pszKey, szSubKey);
|
|
exportRegTree2InfHelper(hkSub, pszHive, szFullSubKey, hInf, fUseLdids);
|
|
WriteStringToFile(hInf, (LPCVOID) TEXT("\r\n"), 2);
|
|
RegCloseKey(hkSub);
|
|
}
|
|
|
|
dwIndex++;
|
|
dwSub = countof(szSubKey);
|
|
}
|
|
}
|
|
|
|
static const TCHAR c_szSzType[] = TEXT("%s,\"%s\",%s,,\"%s\"");
|
|
static const TCHAR c_szDwordType[] = TEXT("%s,\"%s\",%s,0x10001");
|
|
static const TCHAR c_szBinaryType[] = TEXT("%s,\"%s\",%s,1");
|
|
|
|
static void exportRegValue2InfHelper(HKEY hkSubKey, LPCTSTR pcszValue, LPCTSTR pcszRootKey, LPCTSTR pcszSubKey, HANDLE hInf, BOOL fUseLdids)
|
|
{
|
|
TCHAR szInfLine[(4 * MAX_URL) + MAX_PATH];
|
|
BYTE rgbData[2*MAX_URL];
|
|
DWORD cbData,
|
|
dwType;
|
|
LONG lResult;
|
|
int i, j, k;
|
|
|
|
cbData = 2*MAX_URL;
|
|
lResult = RegQueryValueEx(hkSubKey, pcszValue, NULL, &dwType, rgbData, &cbData);
|
|
if ((lResult != ERROR_SUCCESS) || ((pcszValue == NULL) && (cbData <= 1)))
|
|
return;
|
|
|
|
switch (dwType) {
|
|
case REG_EXPAND_SZ:
|
|
|
|
// use shlwapi API to get the expanded value, then fall through to write addreg
|
|
// entry to inf as REG_SZ
|
|
|
|
lResult = SHQueryValueEx(hkSubKey, pcszValue, NULL, &dwType, rgbData, &cbData);
|
|
if ((lResult != ERROR_SUCCESS) || ((pcszValue == NULL) && (cbData <= 1)))
|
|
return;
|
|
|
|
case REG_SZ:
|
|
if (fUseLdids)
|
|
PathReplaceWithLDIDs((LPTSTR)rgbData);
|
|
|
|
wnsprintf(szInfLine, ARRAYSIZE(szInfLine), c_szSzType, pcszRootKey, pcszSubKey,
|
|
(pcszValue == NULL) ? TEXT("") : pcszValue, (LPCTSTR)rgbData);
|
|
break;
|
|
|
|
case REG_DWORD:
|
|
wnsprintf(szInfLine, ARRAYSIZE(szInfLine), c_szDwordType, pcszRootKey, pcszSubKey, pcszValue);
|
|
for (i = 0; i < 4; i++)
|
|
AppendCommaHex(szInfLine, rgbData[i], 1);
|
|
break;
|
|
|
|
case REG_BINARY:
|
|
default:
|
|
wnsprintf(szInfLine, ARRAYSIZE(szInfLine), c_szBinaryType, pcszRootKey, pcszSubKey, pcszValue);
|
|
for (i = 0, j = k = StrLen(szInfLine);
|
|
i < (int)cbData && k < countof(szInfLine); i++, j += 3, k += 3) {
|
|
AppendCommaHex(szInfLine, rgbData[i], 1);
|
|
|
|
if (j >= 240) {
|
|
StrCat(szInfLine, TEXT("\\\r\n"));
|
|
j = 0;
|
|
k += 3;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
StrCat(szInfLine, TEXT("\r\n"));
|
|
WriteStringToFile(hInf, szInfLine, StrLen(szInfLine));
|
|
}
|
|
|
|
static void exportRegKey2InfHelper(HKEY hkSubKey, LPCTSTR pcszRootKey, LPCTSTR pcszSubKey, HANDLE hInf, BOOL fUseLdids)
|
|
// Export all the value names under pcszSubKey to hInf as AddReg lines
|
|
{
|
|
DWORD dwIndex;
|
|
TCHAR szValue[MAX_PATH];
|
|
DWORD cchValue, dwType;
|
|
|
|
for (dwIndex = 0, cchValue = countof(szValue);
|
|
RegEnumValue(hkSubKey, dwIndex, szValue, &cchValue, NULL, &dwType, NULL, NULL) == ERROR_SUCCESS;
|
|
dwIndex++, cchValue = countof(szValue))
|
|
exportRegValue2InfHelper(hkSubKey, szValue, pcszRootKey, pcszSubKey, hInf, fUseLdids);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Private routines (non-exported)
|
|
|
|
static void signFileHelper(LPCTSTR pcszFilename, LPCTSTR pcszDir, LPCTSTR pcszIns, LPTSTR pszUnsignedFiles, LPCTSTR pcszCustInf, BOOL fTest)
|
|
{
|
|
DWORD dwExitCode=0, dwLen;
|
|
static BOOL s_fFirst = TRUE;
|
|
TCHAR szDesc[MAX_PATH];
|
|
TCHAR szPVKPath[MAX_PATH];
|
|
TCHAR szSPCPath[MAX_PATH];
|
|
TCHAR szInfoUrl[INTERNET_MAX_URL_LENGTH];
|
|
TCHAR szTimeUrl[INTERNET_MAX_URL_LENGTH];
|
|
TCHAR szDest[MAX_PATH];
|
|
TCHAR szCmd[INTERNET_MAX_URL_LENGTH + MAX_PATH];
|
|
|
|
// note that pcszDir is only passed in as NULL if we're test signing something
|
|
|
|
if (!InsGetString(IS_CABSIGN, IK_PVK, szPVKPath, countof(szPVKPath), pcszIns) ||
|
|
!InsGetString(IS_CABSIGN, IK_SPC, szSPCPath, countof(szSPCPath), pcszIns))
|
|
return;
|
|
|
|
if (s_fFirst && !fTest)
|
|
{
|
|
s_fFirst = FALSE;
|
|
|
|
if (pcszCustInf != NULL)
|
|
{
|
|
if (InsGetString(IS_CABSIGN, RV_COMPANYNAME, szDesc, countof(szDesc), pcszIns))
|
|
{
|
|
HKEY hKey;
|
|
|
|
if(RegOpenKeyEx(HKEY_CURRENT_USER, RK_TRUSTKEY, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
|
|
{
|
|
TCHAR szKey[MAX_PATH];
|
|
TCHAR szValue[MAX_PATH];
|
|
DWORD dwValueKey,dwValue;
|
|
int iEntry=0;
|
|
|
|
dwValueKey=countof(szKey);
|
|
dwValue=sizeof(szValue);
|
|
|
|
ZeroMemory(szCmd, sizeof(szCmd));
|
|
if(RegEnumValue(hKey, 0, szKey, &dwValueKey, NULL, NULL, (BYTE *) szValue, &dwValue) == ERROR_SUCCESS)
|
|
{
|
|
do
|
|
{
|
|
if(StrCmpI(szValue, szDesc) == 0)
|
|
{
|
|
wnsprintf(szInfoUrl, ARRAYSIZE(szInfoUrl), CABSIGN_INF_ADD, szKey, szValue);
|
|
StrCat(szCmd, szInfoUrl);
|
|
}
|
|
iEntry++;
|
|
dwValueKey=countof(szKey);
|
|
dwValue=sizeof(szValue);
|
|
|
|
} while (RegEnumValue(hKey, iEntry, szKey, &dwValueKey, NULL, NULL, (BYTE *) szValue, &dwValue) != ERROR_NO_MORE_ITEMS);
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
if (ISNONNULL(szCmd))
|
|
{
|
|
InsDeleteSection(TEXT("IEAK.Company.reg"), pcszCustInf);
|
|
WritePrivateProfileSection(TEXT("IEAK.Company.reg"), szCmd, pcszCustInf);
|
|
InsFlushChanges(pcszCustInf);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pcszDir != NULL)
|
|
{
|
|
PathCombine(szDest, pcszDir, PathFindFileName(szPVKPath));
|
|
CopyFile(szPVKPath, szDest, FALSE);
|
|
PathCombine(szDest, pcszDir, PathFindFileName(szSPCPath));
|
|
CopyFile(szSPCPath, szDest, FALSE);
|
|
}
|
|
}
|
|
|
|
InsGetString(IS_CABSIGN, IK_NAME, szDesc, countof(szDesc), pcszIns);
|
|
|
|
if (pcszDir != NULL)
|
|
PathCombine(szDest, pcszDir, TEXT("SIGNCODE.EXE"));
|
|
else
|
|
{
|
|
StrCpy(szDest, pcszFilename);
|
|
PathRemoveFileSpec(szDest);
|
|
CopyFileToDir(szPVKPath, szDest);
|
|
CopyFileToDir(szSPCPath, szDest);
|
|
PathAppend(szDest, TEXT("signcode.exe"));
|
|
}
|
|
|
|
|
|
wnsprintf(szCmd, countof(szCmd), TEXT("\"%s\" -spc \"%s\" -v \"%s\" -n \"%s\""),
|
|
szDest, PathFindFileName(szSPCPath), PathFindFileName(szPVKPath), szDesc);
|
|
|
|
if ((pcszDir != NULL) &&
|
|
InsGetString(IS_CABSIGN, IK_CSURL, szInfoUrl, countof(szInfoUrl), pcszIns))
|
|
{
|
|
dwLen = StrLen(szCmd);
|
|
wnsprintf(szCmd + dwLen, countof(szCmd) - dwLen, TEXT(" -i \"%s\""), szInfoUrl);
|
|
}
|
|
|
|
if ((pcszDir != NULL) &&
|
|
InsGetString(IS_CABSIGN, IK_CSTIME, szTimeUrl, countof(szTimeUrl), pcszIns))
|
|
{
|
|
dwLen = StrLen(szCmd);
|
|
wnsprintf(szCmd + dwLen, countof(szCmd) - dwLen, TEXT(" -t \"%s\""), szTimeUrl);
|
|
}
|
|
|
|
dwLen = StrLen(szCmd);
|
|
wnsprintf(szCmd + dwLen, countof(szCmd) - dwLen, TEXT(" \"%s\""), PathFindFileName(pcszFilename));
|
|
|
|
if (pcszDir == NULL)
|
|
PathRemoveFileSpec(szDest);
|
|
|
|
if (!RunAndWait(szCmd, (pcszDir == NULL) ? szDest : pcszDir, SW_HIDE, &dwExitCode)
|
|
|| (dwExitCode == -1))
|
|
{
|
|
if (pszUnsignedFiles != NULL)
|
|
{
|
|
StrCat(pszUnsignedFiles, TEXT("\r\n"));
|
|
StrCat(pszUnsignedFiles, pcszFilename);
|
|
}
|
|
}
|
|
|
|
if (pcszDir == NULL)
|
|
{
|
|
DeleteFileInDir(szPVKPath, szDest);
|
|
DeleteFileInDir(szSPCPath, szDest);
|
|
}
|
|
}
|
|
|
|
void WINAPI DoReboot(HWND hwndUI)
|
|
{
|
|
TCHAR szMsg[MAX_PATH];
|
|
TCHAR szTitle[128];
|
|
|
|
LoadString(g_hInst, IDS_TITLE, szTitle, ARRAYSIZE(szTitle));
|
|
LoadString(g_hDLLInst, IDS_RESTARTYESNO, szMsg, ARRAYSIZE(szMsg));
|
|
|
|
if (MessageBox(hwndUI, szMsg, szTitle, MB_YESNO) == IDNO)
|
|
return;
|
|
|
|
if (IsOS(OS_NT))
|
|
{
|
|
HANDLE hToken;
|
|
TOKEN_PRIVILEGES tkp;
|
|
|
|
// get a token from this process
|
|
if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
|
|
{
|
|
// get the LUID for the shutdown privilege
|
|
LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
|
|
|
|
tkp.PrivilegeCount = 1;
|
|
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
//get the shutdown privilege for this proces
|
|
AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
|
|
}
|
|
|
|
ExitWindowsEx(EWX_REBOOT, 0);
|
|
}
|
|
else
|
|
ExitWindowsEx(EWX_REBOOT, 0);
|
|
}
|
|
|
|
void WINAPI ShowInetcpl(HWND hDlg, DWORD dwPages, DWORD dwMode /*= IEM_ADMIN*/)
|
|
{
|
|
HKEY hkInetcpl = NULL;
|
|
HINSTANCE hInetcpl = NULL;
|
|
DWORD dwGeneral = 0, dwSecurity = 0, dwContent = 0,
|
|
dwConnect = 0, dwPrograms = 0, dwAdvanced = 0,
|
|
dwPrivacy = 0, dwIEAK = 0, dwAutoconfig = 0;
|
|
|
|
// set restrictions to disable pages we aren't interested in,
|
|
// tracking whether or not we set or cleared the restriction
|
|
if (SHCreateKeyHKCU(RK_INETCPL, KEY_DEFAULT_ACCESS, &hkInetcpl) == ERROR_SUCCESS)
|
|
{
|
|
dwGeneral = RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_GENERALTAB,
|
|
(dwPages & INET_PAGE_GENERAL) ? 0 : 1);
|
|
|
|
dwSecurity = RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_SECURITYTAB,
|
|
(dwPages & INET_PAGE_SECURITY) ? 0 : 1);
|
|
|
|
dwContent = RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_CONTENTTAB,
|
|
(dwPages & INET_PAGE_CONTENT) ? 0 : 1);
|
|
|
|
dwConnect = RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_CONNECTIONSTAB,
|
|
(dwPages & INET_PAGE_CONNECTION) ? 0 : 1);
|
|
|
|
dwPrivacy = RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_PRIVACYTAB,
|
|
(dwPages & INET_PAGE_PRIVACY) ? 0 : 1);
|
|
|
|
dwPrograms = RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_PROGRAMSTAB,
|
|
(dwPages & INET_PAGE_PROGRAMS) ? 0 : 1);
|
|
|
|
dwAdvanced = RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_ADVANCEDTAB,
|
|
(dwPages & INET_PAGE_ADVANCED) ? 0 : 1);
|
|
|
|
dwIEAK = RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_IEAK, 1);
|
|
|
|
// always set restriction to disable autoconfig exposure in inetcpl if we're not
|
|
// running in corp mode
|
|
if (!HasFlag(dwMode, IEM_ADMIN))
|
|
dwAutoconfig = RegSaveRestoreDWORD(hkInetcpl, TEXT("Autoconfig"), 1);
|
|
}
|
|
|
|
if ((hInetcpl = LoadLibrary(TEXT("inetcpl.cpl"))) != NULL)
|
|
{
|
|
typedef BOOL (WINAPI * LAUNCHINTERNETCONTROLPANEL)(HWND hDlg);
|
|
LAUNCHINTERNETCONTROLPANEL pLaunchInternetControlPanel;
|
|
|
|
if ((pLaunchInternetControlPanel = (LAUNCHINTERNETCONTROLPANEL)
|
|
GetProcAddress(hInetcpl, "LaunchInternetControlPanel")) != NULL)
|
|
pLaunchInternetControlPanel(hDlg);
|
|
|
|
FreeLibrary(hInetcpl);
|
|
}
|
|
|
|
if (hkInetcpl != NULL)
|
|
{
|
|
// reset the restrictions that we set, in this case we'll be passing in FALSE for those
|
|
// we set which will clear the value, and TRUE for those we didn't set which will leave
|
|
// them as set
|
|
|
|
RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_GENERALTAB, dwGeneral);
|
|
RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_SECURITYTAB, dwSecurity);
|
|
RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_CONTENTTAB, dwContent);
|
|
RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_CONNECTIONSTAB, dwConnect);
|
|
RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_PROGRAMSTAB, dwPrograms);
|
|
RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_PRIVACYTAB, dwPrivacy);
|
|
RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_ADVANCEDTAB, dwAdvanced);
|
|
RegSaveRestoreDWORD(hkInetcpl, REGSTR_VAL_INETCPL_IEAK, dwIEAK);
|
|
|
|
if (!HasFlag(dwMode, IEM_ADMIN))
|
|
RegSaveRestoreDWORD(hkInetcpl, TEXT("Autoconfig"), dwAutoconfig);
|
|
}
|
|
}
|