mirror of https://github.com/tongzx/nt5src
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.
1718 lines
52 KiB
1718 lines
52 KiB
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 1999-2000 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
//
|
|
// iasmdbtool.cpp
|
|
//
|
|
// Abstract:
|
|
//
|
|
// dump the "Properties" table from ias.mdb to a text format
|
|
// and also restore ias.mdb from such dump
|
|
//
|
|
//
|
|
// Revision History:
|
|
//
|
|
// tperraut 04/07/1999
|
|
// tperraut 04/03/2000 Version table exported and imported.
|
|
// Set to 0 for old scripts (no version table)
|
|
// tperraut 06/13/2000 Make use of the new upgrade code for IAS. i.e.
|
|
// remove all the code to write into a database.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
#include "stdafx.h"
|
|
|
|
#include <string>
|
|
#include <shlwapi.h>
|
|
|
|
using namespace std;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
IASExpandString(const WCHAR* pInputString, /*in/out*/ WCHAR** ppOutputString);
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef DEBUG
|
|
#define CHECK_CALL_HRES(expr) \
|
|
hres = expr; \
|
|
if (FAILED(hres)) \
|
|
{ \
|
|
wprintf(L"### %S returned 0x%X ###\n", ## #expr, hres); \
|
|
return hres; \
|
|
}
|
|
|
|
#define CHECK_CALL_HRES_NO_RETURN(expr) \
|
|
hres = expr; \
|
|
if (FAILED(hres)) \
|
|
{ \
|
|
wprintf(L"### %S returned 0x%X ###\n", ## #expr, hres); \
|
|
}
|
|
#define CHECK_CALL_HRES_BREAK(expr) \
|
|
hres = expr; \
|
|
if (FAILED(hres)) \
|
|
{ \
|
|
wprintf(L"### %S returned 0x%X ###\n", ## #expr, hres); \
|
|
break; \
|
|
}
|
|
#else //no printf, only the error code return if needed
|
|
#define CHECK_CALL_HRES(expr) \
|
|
hres = expr; \
|
|
if (FAILED(hres)) \
|
|
{ \
|
|
return hres; \
|
|
}
|
|
|
|
#define CHECK_CALL_HRES_NO_RETURN(expr) \
|
|
hres = expr;
|
|
|
|
#define CHECK_CALL_HRES_BREAK(expr) \
|
|
hres = expr; \
|
|
if (FAILED(hres)) break;
|
|
|
|
#endif //DEBUG
|
|
|
|
|
|
#define celems(_x) (sizeof(_x) / sizeof(_x[0]))
|
|
|
|
namespace
|
|
{
|
|
const int SIZELINEMAX = 512;
|
|
const int SIZE_LONG_MAX = 33;
|
|
// Number of files generated
|
|
// here one: backup.mdb
|
|
const int MAX_FILES = 1;
|
|
const int EXTRA_CHAR_SPACE = 32;
|
|
|
|
// file order
|
|
const int BACKUP_NB = 0;
|
|
const int BINARY_NB = 100;
|
|
|
|
// that's a lot
|
|
const int DECOMPRESS_FACTOR = 100;
|
|
const int FILE_BUFFER_SIZE = 1024;
|
|
|
|
struct IASKEY
|
|
{
|
|
const WCHAR* c_wcKey;
|
|
const WCHAR* c_wcValue;
|
|
DWORD c_dwType;
|
|
} IAS_Key_Struct;
|
|
|
|
IASKEY c_wcKEYS[] =
|
|
{
|
|
{
|
|
L"SYSTEM\\CurrentControlSet\\Services\\IAS\\Parameters",
|
|
L"Allow SNMP Set",
|
|
REG_DWORD
|
|
},
|
|
{
|
|
L"SYSTEM\\CurrentControlSet\\Services\\RasMan\\PPP\\ControlProtocols\\BuiltIn",
|
|
L"DefaultDomain",
|
|
REG_SZ
|
|
},
|
|
{
|
|
L"SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Parameters\\AccountLockout",
|
|
L"MaxDenials",
|
|
REG_DWORD
|
|
},
|
|
{
|
|
L"SYSTEM\\CurrentControlSet\\Services\\IAS\\Parameters",
|
|
L"ResetTime (mins)",
|
|
REG_DWORD
|
|
},
|
|
{
|
|
L"SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Policy",
|
|
L"Allow LM Authentication",
|
|
REG_DWORD
|
|
},
|
|
{
|
|
L"SYSTEM\\CurrentControlSet\\Services\\IAS\\Parameters",
|
|
L"Default User Identity",
|
|
REG_SZ
|
|
},
|
|
{
|
|
L"SYSTEM\\CurrentControlSet\\Services\\IAS\\Parameters",
|
|
L"User Identity Attribute",
|
|
REG_DWORD
|
|
},
|
|
{
|
|
L"SYSTEM\\CurrentControlSet\\Services\\IAS\\Parameters",
|
|
L"Override User-Name",
|
|
REG_DWORD
|
|
},
|
|
};
|
|
|
|
const WCHAR c_wcKEYS_FILE[] = L"%TEMP%\\";
|
|
|
|
#ifdef _WIN64
|
|
const WCHAR c_wcIAS_MDB_FILE_NAME[] =
|
|
L"%SystemRoot%\\SysWow64\\ias\\ias.mdb";
|
|
const WCHAR c_wcIAS_OLD[] = L"%SystemRoot%\\SysWow64\\ias\\iasold.mdb";
|
|
|
|
#else
|
|
const WCHAR c_wcIAS_MDB_FILE_NAME[] =
|
|
L"%SystemRoot%\\System32\\ias\\ias.mdb";
|
|
|
|
const WCHAR c_wcIAS_OLD[] = L"%SystemRoot%\\System32\\ias\\iasold.mdb";
|
|
#endif
|
|
|
|
const WCHAR c_wcFILE_BACKUP[] = L"%TEMP%\\Backup.mdb";
|
|
|
|
|
|
|
|
const WCHAR c_wcSELECT_PROPERTIES_INTO[] =
|
|
L"SELECT * "
|
|
L"INTO Properties IN "
|
|
L"\"%TEMP%\\Backup.mdb\" "
|
|
L"FROM Properties;";
|
|
|
|
const WCHAR c_wcSELECT_OBJECTS_INTO[] =
|
|
L"SELECT * "
|
|
L"INTO Objects IN "
|
|
L"\"%TEMP%\\Backup.mdb\" "
|
|
L"FROM Objects;";
|
|
|
|
const WCHAR c_wcSELECT_VERSION_INTO[] =
|
|
L"SELECT * "
|
|
L"INTO Version IN "
|
|
L"\"%TEMP%\\Backup.mdb\" "
|
|
L"FROM Version;";
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// WideToAnsi
|
|
//
|
|
// CALLED BY:everywhere
|
|
//
|
|
// PARAMETERS: lpStr - destination string
|
|
// lpWStr - string to convert
|
|
// cchStr - size of dest buffer
|
|
//
|
|
// DESCRIPTION:
|
|
// converts unicode lpWStr to ansi lpStr.
|
|
// fills in unconvertable chars w/ DPLAY_DEFAULT_CHAR "-"
|
|
//
|
|
//
|
|
// RETURNS: if cchStr is 0, returns the size required to hold the string
|
|
// otherwise, returns the number of chars converted
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
int WideToAnsi(char* lpStr,unsigned short* lpWStr, int cchStr)
|
|
{
|
|
BOOL bDefault;
|
|
|
|
// use the default code page (CP_ACP)
|
|
// -1 indicates WStr must be null terminated
|
|
return WideCharToMultiByte(GetConsoleOutputCP(),0,lpWStr,-1,lpStr,cchStr,"-",&bDefault);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASEnableBackupPrivilege
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT IASEnableBackupPrivilege()
|
|
{
|
|
LONG lResult = ERROR_SUCCESS;
|
|
HANDLE hToken = NULL;
|
|
do
|
|
{
|
|
if ( ! OpenProcessToken(
|
|
GetCurrentProcess(),
|
|
TOKEN_ADJUST_PRIVILEGES,
|
|
&hToken
|
|
))
|
|
{
|
|
lResult = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
LUID luidB;
|
|
if ( ! LookupPrivilegeValue(NULL, SE_BACKUP_NAME, &luidB))
|
|
{
|
|
lResult = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
LUID luidR;
|
|
if ( ! LookupPrivilegeValue(NULL, SE_RESTORE_NAME, &luidR))
|
|
{
|
|
lResult = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
TOKEN_PRIVILEGES tp;
|
|
tp.PrivilegeCount = 1;
|
|
tp.Privileges[0].Luid = luidB;
|
|
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
if ( ! AdjustTokenPrivileges(
|
|
hToken,
|
|
FALSE,
|
|
&tp,
|
|
sizeof(TOKEN_PRIVILEGES),
|
|
NULL,
|
|
NULL
|
|
) )
|
|
{
|
|
lResult = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
tp.PrivilegeCount = 1;
|
|
tp.Privileges[0].Luid = luidR;
|
|
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
if ( ! AdjustTokenPrivileges(
|
|
hToken,
|
|
FALSE,
|
|
&tp,
|
|
sizeof(TOKEN_PRIVILEGES),
|
|
NULL,
|
|
NULL
|
|
) )
|
|
{
|
|
lResult = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
} while (false);
|
|
|
|
if ( hToken )
|
|
{
|
|
CloseHandle(hToken);
|
|
}
|
|
|
|
if ( lResult == ERROR_SUCCESS )
|
|
{
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASSaveRegKeys
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT IASSaveRegKeys()
|
|
{
|
|
HRESULT hres;
|
|
|
|
int c_NbKeys = celems(c_wcKEYS);
|
|
|
|
if ( c_NbKeys == 0 )
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
////////////////////////////
|
|
// Enable backup privilege.
|
|
////////////////////////////
|
|
CHECK_CALL_HRES (IASEnableBackupPrivilege());
|
|
|
|
|
|
WCHAR* CompleteFile;
|
|
CHECK_CALL_HRES (IASExpandString(c_wcKEYS_FILE, &CompleteFile));
|
|
|
|
for ( int i = 0; i < c_NbKeys; ++i )
|
|
{
|
|
DWORD dwType = 0;
|
|
DWORD cbData = SIZELINEMAX / 2;
|
|
|
|
LPVOID pvData = CoTaskMemAlloc(sizeof(WCHAR) * SIZELINEMAX);
|
|
if (!pvData)
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
|
|
DWORD lResult = SHGetValueW(
|
|
HKEY_LOCAL_MACHINE,
|
|
c_wcKEYS[i].c_wcKey,
|
|
c_wcKEYS[i].c_wcValue,
|
|
&dwType,
|
|
pvData,
|
|
&cbData
|
|
);
|
|
|
|
//
|
|
// Try to allocate more memory if cbData returned the size needed
|
|
//
|
|
if ((lResult != ERROR_SUCCESS) && (cbData > SIZELINEMAX))
|
|
{
|
|
CoTaskMemFree(pvData);
|
|
pvData = CoTaskMemAlloc(sizeof(WCHAR) * cbData);
|
|
if ( !pvData )
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
lResult = SHGetValue(
|
|
HKEY_LOCAL_MACHINE,
|
|
c_wcKEYS[i].c_wcKey,
|
|
c_wcKEYS[i].c_wcValue,
|
|
&dwType,
|
|
pvData,
|
|
&cbData
|
|
);
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Create the file (in all situations)
|
|
//
|
|
wstring sFileName(CompleteFile);
|
|
WCHAR buffer[SIZE_LONG_MAX];
|
|
|
|
_itow(i, buffer, 10); // 10 means base 10
|
|
sFileName += buffer;
|
|
sFileName += L".txt";
|
|
|
|
HANDLE hFile = CreateFileW(
|
|
sFileName.c_str(),
|
|
GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
|
|
if ( hFile == INVALID_HANDLE_VALUE )
|
|
{
|
|
hres = E_FAIL;
|
|
CoTaskMemFree(pvData);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// lResult = result of SHGetValue
|
|
// and might be an error but not
|
|
// a memory problem
|
|
//
|
|
if ( lResult == ERROR_SUCCESS )
|
|
{
|
|
//
|
|
// Wrong data type
|
|
//
|
|
if ( dwType != c_wcKEYS[i].c_dwType )
|
|
{
|
|
// There's an error, fail
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#SHGetValue ok but wrong type returned . code %X"
|
|
L" param %s%s\n",
|
|
dwType,
|
|
c_wcKEYS[i].c_wcKey,
|
|
c_wcKEYS[i].c_wcValue
|
|
);
|
|
#endif //DEBUG
|
|
hres = E_FAIL;
|
|
CoTaskMemFree(pvData);
|
|
CloseHandle(hFile);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Save the value to the file
|
|
//
|
|
BYTE* bBuffer = static_cast<BYTE*>(VirtualAlloc
|
|
(
|
|
NULL,
|
|
(cbData > FILE_BUFFER_SIZE)?
|
|
cbData:FILE_BUFFER_SIZE,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE
|
|
));
|
|
#ifdef DEBUG //DEBUG
|
|
wprintf(L"#cbdata = %d \n",cbData);
|
|
#endif //DEBUG
|
|
if ( !bBuffer )
|
|
{
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#VirtualAlloc failed");
|
|
#endif //DEBUG
|
|
CoTaskMemFree(pvData);
|
|
CloseHandle(hFile);
|
|
hres = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
memset(bBuffer, '\0', (cbData > FILE_BUFFER_SIZE)?
|
|
cbData:FILE_BUFFER_SIZE);
|
|
|
|
if ( REG_SZ == c_wcKEYS[i].c_dwType )
|
|
{
|
|
wcscpy((WCHAR*)bBuffer, (WCHAR*)pvData);
|
|
}
|
|
else
|
|
{
|
|
memcpy(bBuffer, pvData, cbData);
|
|
}
|
|
|
|
CoTaskMemFree(pvData);
|
|
|
|
DWORD NumberOfBytesWritten;
|
|
|
|
BOOL bResult = WriteFile(
|
|
hFile,
|
|
bBuffer,
|
|
(cbData > FILE_BUFFER_SIZE)?
|
|
cbData:FILE_BUFFER_SIZE,
|
|
&NumberOfBytesWritten,
|
|
NULL
|
|
);
|
|
|
|
VirtualFree(
|
|
bBuffer,
|
|
(cbData > FILE_BUFFER_SIZE)?
|
|
cbData:FILE_BUFFER_SIZE,
|
|
MEM_RELEASE
|
|
); // ignore result
|
|
CloseHandle(hFile);
|
|
if ( bResult )
|
|
{
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#nb of bytes written %d\n"
|
|
,NumberOfBytesWritten);
|
|
#endif //DEBUG
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#WriteFile failed %X\n",GetLastError());
|
|
#endif //DEBUG
|
|
hres = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// create an empty file
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#REG_SZ = %d, REG_DWORD = %d\n",REG_SZ, REG_DWORD);
|
|
|
|
wprintf(L"#SHGetValue failed code %X"
|
|
L" param %s\\%s\n"
|
|
L"# type = %d cbdata = %d\n",
|
|
lResult,
|
|
c_wcKEYS[i].c_wcKey,
|
|
c_wcKEYS[i].c_wcValue,
|
|
dwType,
|
|
cbData
|
|
);
|
|
wprintf(L"#create an empty file\n\n");
|
|
#endif //DEBUG
|
|
BYTE bBuffer[FILE_BUFFER_SIZE];
|
|
memset(bBuffer, '#', (cbData > FILE_BUFFER_SIZE)?
|
|
cbData:FILE_BUFFER_SIZE);
|
|
|
|
DWORD NumberOfBytesWritten;
|
|
|
|
BOOL bResult = WriteFile(
|
|
hFile,
|
|
&bBuffer,
|
|
FILE_BUFFER_SIZE,
|
|
&NumberOfBytesWritten,
|
|
NULL
|
|
);
|
|
|
|
CoTaskMemFree(pvData);
|
|
CloseHandle(hFile);
|
|
|
|
if ( bResult )
|
|
{
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#nb of bytes written %d\n"
|
|
,NumberOfBytesWritten);
|
|
#endif //DEBUG
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#WriteFile failed\n");
|
|
#endif //DEBUG
|
|
hres = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
////////////
|
|
// Clean
|
|
////////////
|
|
CoTaskMemFree(CompleteFile);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASRestoreRegKeys
|
|
//
|
|
// if something cannot be restored because of an empty
|
|
// backup file (no key saved), that's not an error
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT IASRestoreRegKeys()
|
|
{
|
|
HRESULT hres;
|
|
int c_NbKeys = celems(c_wcKEYS);
|
|
|
|
if ( c_NbKeys == 0 )
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
////////////////////////////
|
|
// Enable backup privilege.
|
|
// and sets hres
|
|
////////////////////////////
|
|
CHECK_CALL_HRES (IASEnableBackupPrivilege());
|
|
|
|
WCHAR* CompleteFile;
|
|
CHECK_CALL_HRES (IASExpandString(c_wcKEYS_FILE, &CompleteFile));
|
|
|
|
for ( int i = 0; i < c_NbKeys; ++i )
|
|
{
|
|
wstring sFileName(CompleteFile);
|
|
WCHAR buffer[SIZE_LONG_MAX];
|
|
DWORD dwDisposition;
|
|
|
|
_itow(i, buffer, 10); // 10 means base 10
|
|
sFileName += buffer;
|
|
sFileName += L".txt";
|
|
|
|
// open the file
|
|
HANDLE hFile = CreateFileW(
|
|
sFileName.c_str(),
|
|
GENERIC_READ,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
|
|
if (INVALID_HANDLE_VALUE == hFile)
|
|
{
|
|
hres = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
// check the type of data expected
|
|
LPVOID lpBuffer = NULL;
|
|
DWORD SizeToRead;
|
|
if (REG_SZ == c_wcKEYS[i].c_dwType)
|
|
{
|
|
lpBuffer = CoTaskMemAlloc(sizeof(WCHAR) * FILE_BUFFER_SIZE);
|
|
SizeToRead = FILE_BUFFER_SIZE;
|
|
}
|
|
else if (REG_DWORD == c_wcKEYS[i].c_dwType)
|
|
{
|
|
lpBuffer = CoTaskMemAlloc(sizeof(DWORD));
|
|
SizeToRead = sizeof(DWORD);
|
|
}
|
|
else
|
|
{
|
|
// unknown
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
if (!lpBuffer)
|
|
{
|
|
CloseHandle(hFile);
|
|
hres = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
|
|
memset(lpBuffer,'\0',SizeToRead);
|
|
|
|
// read the file
|
|
DWORD NumberOfBytesRead;
|
|
ReadFile(
|
|
hFile,
|
|
lpBuffer,
|
|
SizeToRead,
|
|
&NumberOfBytesRead,
|
|
NULL
|
|
); // ignore return value. uses NumberOfBytesRead
|
|
// to determine success condition
|
|
|
|
CloseHandle(hFile);
|
|
|
|
// check if the file contains ####
|
|
if ( NumberOfBytesRead == 0 )
|
|
{
|
|
// problem
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#ReadFile failed %d %d\n",
|
|
SizeToRead,
|
|
NumberOfBytesRead
|
|
);
|
|
#endif //DEBUG
|
|
|
|
CoTaskMemFree(lpBuffer);
|
|
hres = E_FAIL;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
BYTE TempBuffer[sizeof(DWORD)];
|
|
memset(TempBuffer, '#', sizeof(DWORD));
|
|
|
|
if (0 == memcmp(lpBuffer, TempBuffer, sizeof(DWORD)))
|
|
{
|
|
// no key saved, delete existing key if any
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#no key saved, delete existing key if any\n");
|
|
#endif //DEBUG
|
|
HKEY hKeyToDelete = NULL;
|
|
if (ERROR_SUCCESS == RegOpenKeyW(
|
|
HKEY_LOCAL_MACHINE,
|
|
c_wcKEYS[i].c_wcKey,
|
|
&hKeyToDelete
|
|
))
|
|
{
|
|
if (ERROR_SUCCESS != RegDeleteValueW
|
|
(
|
|
hKeyToDelete,
|
|
c_wcKEYS[i].c_wcValue
|
|
))
|
|
{
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#delete existing key failed\n");
|
|
#endif //DEBUG
|
|
}
|
|
RegCloseKey(hKeyToDelete);
|
|
}
|
|
//
|
|
// else do nothing: key doesn't exist
|
|
//
|
|
}
|
|
else
|
|
{
|
|
// key saved: restore value
|
|
// what if the value is bigger than
|
|
// the buffer size?
|
|
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#key saved: restore value\n");
|
|
#endif //DEBUG
|
|
HKEY hKeyToUpdate;
|
|
|
|
|
|
LONG lResult = RegCreateKeyExW(
|
|
HKEY_LOCAL_MACHINE,
|
|
c_wcKEYS[i].c_wcKey,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE |
|
|
REG_OPTION_BACKUP_RESTORE ,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hKeyToUpdate,
|
|
&dwDisposition
|
|
);
|
|
|
|
if (ERROR_SUCCESS != lResult)
|
|
{
|
|
lResult = RegCreateKeyW(
|
|
HKEY_LOCAL_MACHINE,
|
|
c_wcKEYS[i].c_wcKey,
|
|
&hKeyToUpdate
|
|
);
|
|
if (ERROR_SUCCESS != lResult)
|
|
{
|
|
#ifdef DEBUG
|
|
// DEBUG
|
|
wprintf(L"#RegCreateKeyW failed. code %x param %s\n",
|
|
lResult,
|
|
sFileName.c_str()
|
|
);
|
|
#endif //DEBUG
|
|
RegCloseKey(hKeyToUpdate);
|
|
hres = E_FAIL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
if (REG_SZ == c_wcKEYS[i].c_dwType)
|
|
{
|
|
// nb of
|
|
NumberOfBytesRead = (
|
|
( wcslen((WCHAR*)lpBuffer)
|
|
+ 1 // for /0
|
|
) * sizeof(WCHAR)
|
|
);
|
|
};
|
|
|
|
//
|
|
// Key created or key existing
|
|
// both can be here (error = break)
|
|
//
|
|
if (ERROR_SUCCESS != RegSetValueExW(
|
|
hKeyToUpdate,
|
|
c_wcKEYS[i].c_wcValue,
|
|
0,
|
|
c_wcKEYS[i].c_dwType,
|
|
(BYTE*)lpBuffer,
|
|
NumberOfBytesRead
|
|
))
|
|
{
|
|
RegCloseKey(hKeyToUpdate);
|
|
hres = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
RegCloseKey(hKeyToUpdate);
|
|
hres = S_OK;
|
|
}
|
|
|
|
CoTaskMemFree(lpBuffer);
|
|
}
|
|
}
|
|
|
|
/////////
|
|
// Clean
|
|
/////////
|
|
CoTaskMemFree(CompleteFile);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASExpandString
|
|
//
|
|
// Expands strings containing %ENV_VARIABLE%
|
|
//
|
|
// The output string is allocated only when the function succeed
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
IASExpandString(const WCHAR* pInputString, /*in/out*/ WCHAR** ppOutputString)
|
|
{
|
|
_ASSERTE(pInputString);
|
|
_ASSERTE(pppOutputString);
|
|
|
|
HRESULT hres;
|
|
|
|
*ppOutputString = static_cast<WCHAR*>(CoTaskMemAlloc(
|
|
SIZELINEMAX
|
|
* sizeof(WCHAR)
|
|
));
|
|
|
|
if ( ! *ppOutputString )
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
if ( ExpandEnvironmentStringsForUserW(
|
|
NULL,
|
|
pInputString,
|
|
*ppOutputString,
|
|
SIZELINEMAX
|
|
)
|
|
)
|
|
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
CoTaskMemFree(*ppOutputString);
|
|
hres = E_FAIL;
|
|
}
|
|
}
|
|
#ifdef DEBUG // DEBUG
|
|
wprintf(L"#ExpandString: %s\n", *ppOutputString);
|
|
#endif //DEBUG
|
|
|
|
return hres;
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// DeleteTemporaryFiles()
|
|
//
|
|
// delete the temporary files if any
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT DeleteTemporaryFiles()
|
|
{
|
|
HRESULT hres;
|
|
WCHAR* sz_FileBackup;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcFILE_BACKUP,
|
|
&sz_FileBackup
|
|
)
|
|
);
|
|
|
|
DeleteFile(sz_FileBackup); //return value not checked
|
|
CoTaskMemFree(sz_FileBackup);
|
|
|
|
WCHAR* TempPath;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcKEYS_FILE, &TempPath));
|
|
|
|
int c_NbKeys = celems(c_wcKEYS);
|
|
for ( int i = 0; i < c_NbKeys; ++i )
|
|
{
|
|
wstring sFileName(TempPath);
|
|
WCHAR buffer[SIZE_LONG_MAX];
|
|
_itow(i, buffer, 10); // 10 means base 10
|
|
sFileName += buffer;
|
|
sFileName += L".txt";
|
|
|
|
DeleteFile(sFileName.c_str()); //return value not checked
|
|
}
|
|
|
|
CoTaskMemFree(TempPath);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASCompress
|
|
//
|
|
// Wrapper for RtlCompressBuffer
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT IASCompress(
|
|
PUCHAR pInputBuffer,
|
|
ULONG* pulFileSize,
|
|
PUCHAR* ppCompressedBuffer
|
|
)
|
|
{
|
|
ULONG size, ignore;
|
|
|
|
NTSTATUS status = RtlGetCompressionWorkSpaceSize(
|
|
COMPRESSION_FORMAT_LZNT1 | COMPRESSION_ENGINE_MAXIMUM,
|
|
&size,
|
|
&ignore
|
|
);
|
|
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
#ifdef DEBUG
|
|
printf("RtlGetCompressionWorkSpaceSize returned 0x%08X.\n", status);
|
|
#endif //DEBUG
|
|
return E_FAIL;
|
|
}
|
|
|
|
PVOID workSpace;
|
|
workSpace = RtlAllocateHeap(
|
|
RtlProcessHeap(),
|
|
0,
|
|
size
|
|
);
|
|
if ( !workSpace )
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
size = *pulFileSize;
|
|
|
|
// That's a minimum buffer size that can be used
|
|
if ( size < FILE_BUFFER_SIZE )
|
|
{
|
|
size = FILE_BUFFER_SIZE;
|
|
}
|
|
|
|
*ppCompressedBuffer = static_cast<PUCHAR>(RtlAllocateHeap(
|
|
RtlProcessHeap(),
|
|
0,
|
|
size
|
|
));
|
|
|
|
if ( !*ppCompressedBuffer )
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
status = RtlCompressBuffer(
|
|
COMPRESSION_FORMAT_LZNT1 | COMPRESSION_ENGINE_MAXIMUM,
|
|
pInputBuffer,
|
|
size,
|
|
*ppCompressedBuffer,
|
|
size,
|
|
0,
|
|
&size,
|
|
workSpace
|
|
);
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
if (STATUS_BUFFER_TOO_SMALL == status)
|
|
{
|
|
#ifdef DEBUG
|
|
printf("STATUS_BUFFER_TOO_SMALL\n");
|
|
printf("RtlCompressBuffer returned 0x%08X.\n", status);
|
|
#endif //DEBUG
|
|
}
|
|
else
|
|
{
|
|
#ifdef DEBUG
|
|
printf("RtlCompressBuffer returned 0x%08X.\n", status);
|
|
#endif //DEBUG
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
*pulFileSize = size;
|
|
|
|
RtlFreeHeap(
|
|
RtlProcessHeap(),
|
|
0,
|
|
workSpace
|
|
);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASUnCompress
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT IASUnCompress(
|
|
PUCHAR pInputBuffer,
|
|
ULONG* pulFileSize,
|
|
PUCHAR* ppDeCompressedBuffer
|
|
)
|
|
{
|
|
ULONG size, ignore;
|
|
|
|
NTSTATUS status = RtlGetCompressionWorkSpaceSize(
|
|
COMPRESSION_FORMAT_LZNT1 | COMPRESSION_ENGINE_MAXIMUM,
|
|
&size,
|
|
&ignore
|
|
);
|
|
|
|
|
|
if ( !NT_SUCCESS(status) )
|
|
{
|
|
#ifdef DEBUG
|
|
printf("RtlGetCompressionWorkSpaceSize returned 0x%08X.\n", status);
|
|
#endif //DEBUG
|
|
return E_FAIL;
|
|
}
|
|
|
|
size = *pulFileSize;
|
|
|
|
if( FILE_BUFFER_SIZE >= size)
|
|
{
|
|
size = FILE_BUFFER_SIZE;
|
|
}
|
|
|
|
*ppDeCompressedBuffer = static_cast<PUCHAR>(RtlAllocateHeap(
|
|
RtlProcessHeap(),
|
|
0,
|
|
size * DECOMPRESS_FACTOR
|
|
));
|
|
if ( !*ppDeCompressedBuffer )
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
ULONG UncompressedSize;
|
|
|
|
status = RtlDecompressBuffer(
|
|
COMPRESSION_FORMAT_LZNT1 | COMPRESSION_ENGINE_MAXIMUM,
|
|
*ppDeCompressedBuffer,
|
|
size * DECOMPRESS_FACTOR,
|
|
pInputBuffer,
|
|
*pulFileSize ,
|
|
&UncompressedSize
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) )
|
|
{
|
|
#ifdef DEBUG
|
|
printf("RtlUnCompressBuffer returned 0x%08X.\n", status);
|
|
#endif //DEBUG
|
|
|
|
switch (status)
|
|
{
|
|
case STATUS_INVALID_PARAMETER:
|
|
#ifdef DEBUG
|
|
printf("STATUS_INVALID_PARAMETER");
|
|
#endif //DEBUG
|
|
break;
|
|
|
|
case STATUS_BAD_COMPRESSION_BUFFER:
|
|
#ifdef DEBUG
|
|
printf("STATUS_BAD_COMPRESSION_BUFFER ");
|
|
printf("size = %d %d",pulFileSize,UncompressedSize);
|
|
|
|
#endif //DEBUG
|
|
break;
|
|
case STATUS_UNSUPPORTED_COMPRESSION:
|
|
#ifdef DEBUG
|
|
printf("STATUS_UNSUPPORTED_COMPRESSION ");
|
|
#endif //DEBUG
|
|
break;
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
*pulFileSize = UncompressedSize;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASFileToBase64
|
|
//
|
|
// Compress then encode to Base64
|
|
//
|
|
// BSTR by Allocated IASFileToBase64, should be freed by the caller
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
IASFileToBase64(const WCHAR* pFileName, /*out*/ BSTR* pOutputBSTR)
|
|
{
|
|
_ASSERTE(pFileName);
|
|
_ASSERTE(pppOutputString);
|
|
|
|
HRESULT hres;
|
|
|
|
HANDLE hFileHandle = CreateFileW(
|
|
pFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
if ( hFileHandle == INVALID_HANDLE_VALUE )
|
|
{
|
|
#ifdef DEBUG
|
|
wprintf(L"#filename = %s",pFileName);
|
|
wprintf(L"### INVALID_HANDLE_VALUE ###\n");
|
|
#endif //DEBUG
|
|
|
|
hres = E_FAIL;
|
|
return hres;
|
|
}
|
|
|
|
// safe cast from DWORD to ULONG
|
|
ULONG ulFileSize = (ULONG) GetFileSize(
|
|
hFileHandle, // file for which to get size
|
|
NULL// high-order word of file size
|
|
);
|
|
|
|
if (0xFFFFFFFF == ulFileSize)
|
|
{
|
|
#ifdef DEBUG
|
|
wprintf(L"### GetFileSize Failed ###\n");
|
|
#endif //DEBUG
|
|
|
|
hres = E_FAIL;
|
|
return hres;
|
|
}
|
|
|
|
|
|
HANDLE hFileMapping = CreateFileMapping(
|
|
hFileHandle, // handle to file to map
|
|
NULL, // optional security attributes
|
|
PAGE_READONLY, // protection for mapping object
|
|
0, // high-order 32 bits of object size
|
|
0, // low-order 32 bits of object size
|
|
NULL // name of file-mapping object
|
|
);
|
|
|
|
if (NULL == hFileMapping)
|
|
{
|
|
#ifdef DEBUG
|
|
wprintf(L"### CreateFileMapping Failed ###\n");
|
|
#endif //DEBUG
|
|
|
|
hres = E_FAIL;
|
|
return hres;
|
|
}
|
|
|
|
LPVOID pMemoryFile = MapViewOfFile(
|
|
hFileMapping, // file-mapping object to map into
|
|
// address space
|
|
FILE_MAP_READ, // access mode
|
|
0, // high-order 32 bits of file offset
|
|
0, // low-order 32 bits of file offset
|
|
0 // number of bytes to map
|
|
);
|
|
|
|
if (NULL == pMemoryFile)
|
|
{
|
|
#ifdef DEBUG
|
|
wprintf(L"### MapViewOfFile Failed ###\n");
|
|
#endif //DEBUG
|
|
|
|
hres = E_FAIL;
|
|
return hres;
|
|
}
|
|
|
|
|
|
/////////////////////////////
|
|
// NOW compress
|
|
/////////////////////////////
|
|
|
|
WCHAR* pCompressedBuffer;
|
|
|
|
CHECK_CALL_HRES (IASCompress((PUCHAR) pMemoryFile,
|
|
/*IN OUT*/(ULONG *) &ulFileSize,
|
|
/*IN OUT*/(PUCHAR*) &pCompressedBuffer));
|
|
|
|
/////////////////////
|
|
// Encode to Base64
|
|
/////////////////////
|
|
|
|
CHECK_CALL_HRES (ToBase64(
|
|
pCompressedBuffer,
|
|
(ULONG) ulFileSize,
|
|
pOutputBSTR
|
|
)
|
|
);
|
|
|
|
/////////////////////////////
|
|
// Clean
|
|
/////////////////////////////
|
|
|
|
RtlFreeHeap(
|
|
RtlProcessHeap(),
|
|
0,
|
|
pCompressedBuffer
|
|
);
|
|
|
|
BOOL bResult = UnmapViewOfFile(
|
|
pMemoryFile// address where mapped view begins
|
|
);
|
|
if (FALSE == bResult)
|
|
{
|
|
#ifdef DEBUG
|
|
wprintf(L"### UnmapViewOfFile Failed ###\n");
|
|
#endif //DEBUG
|
|
|
|
hres = E_FAIL;
|
|
}
|
|
|
|
CloseHandle(hFileMapping);
|
|
CloseHandle(hFileHandle);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASDumpConfig
|
|
//
|
|
// Dump the configuration to some temporary files, then indidually
|
|
// compress then encode them.
|
|
// one big string is created from those multiple Base64 strings.
|
|
//
|
|
// Remarks: IASDumpConfig does a malloc and allocates memory for
|
|
// *ppDumpString. The calling function will have to free that memory
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
IASDumpConfig(/*inout*/ WCHAR **ppDumpString, /*inout*/ ULONG *ulSize)
|
|
{
|
|
_ASSERTE(ppDumpString);
|
|
_ASSERTE(ulSize);
|
|
|
|
HRESULT hres;
|
|
|
|
///////////////////////////////////////
|
|
// delete the temporary files if any
|
|
///////////////////////////////////////
|
|
CHECK_CALL_HRES (DeleteTemporaryFiles());
|
|
|
|
////////////////////////////////////////////////////
|
|
// Save the Registry keys. that creates many files
|
|
////////////////////////////////////////////////////
|
|
CHECK_CALL_HRES (IASSaveRegKeys());
|
|
|
|
//////////////////////
|
|
// connect to the DB
|
|
//////////////////////
|
|
WCHAR* sz_DBPath;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcIAS_MDB_FILE_NAME, &sz_DBPath));
|
|
|
|
CComPtr<IIASNetshJetHelper> JetHelper;
|
|
CHECK_CALL_HRES (CoCreateInstance(
|
|
__uuidof(CIASNetshJetHelper),
|
|
NULL,
|
|
CLSCTX_SERVER,
|
|
__uuidof(IIASNetshJetHelper),
|
|
(PVOID*) &JetHelper
|
|
));
|
|
|
|
CComBSTR DBPath(sz_DBPath);
|
|
if ( !DBPath ) { return E_OUTOFMEMORY; }
|
|
CHECK_CALL_HRES (JetHelper->OpenJetDatabase(DBPath, TRUE));
|
|
|
|
//////////////////////////////////////
|
|
// Create a new DB named "Backup.mdb"
|
|
//////////////////////////////////////
|
|
WCHAR* sz_FileBackup;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcFILE_BACKUP,
|
|
&sz_FileBackup
|
|
)
|
|
);
|
|
|
|
CComBSTR BackupDb(sz_FileBackup);
|
|
if ( !BackupDb ) { return E_OUTOFMEMORY; }
|
|
CHECK_CALL_HRES (JetHelper->CreateJetDatabase(BackupDb));
|
|
|
|
|
|
//////////////////////////////////////////////////////////
|
|
// exec the sql statements (to export)
|
|
// the content into the temp database
|
|
//////////////////////////////////////////////////////////
|
|
WCHAR* sz_SelectProperties;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcSELECT_PROPERTIES_INTO,
|
|
&sz_SelectProperties
|
|
)
|
|
);
|
|
|
|
CComBSTR SelectProperties(sz_SelectProperties);
|
|
if ( !SelectProperties ) { return E_OUTOFMEMORY; }
|
|
CHECK_CALL_HRES (JetHelper->ExecuteSQLCommand(SelectProperties));
|
|
|
|
WCHAR* sz_SelectObjects;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcSELECT_OBJECTS_INTO,
|
|
&sz_SelectObjects
|
|
)
|
|
);
|
|
|
|
CComBSTR SelectObjects(sz_SelectObjects);
|
|
if ( !SelectObjects ) { return E_OUTOFMEMORY; }
|
|
CHECK_CALL_HRES (JetHelper->ExecuteSQLCommand(SelectObjects));
|
|
|
|
WCHAR* sz_SelectVersion;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcSELECT_VERSION_INTO,
|
|
&sz_SelectVersion
|
|
)
|
|
);
|
|
|
|
CComBSTR SelectVersion(sz_SelectVersion);
|
|
if ( !SelectVersion ) { return E_OUTOFMEMORY; }
|
|
CHECK_CALL_HRES (JetHelper->ExecuteSQLCommand(SelectVersion));
|
|
|
|
/////////////////////////////////////////////
|
|
// transform the file into Base64 BSTR
|
|
/////////////////////////////////////////////
|
|
|
|
BSTR FileBackupBSTR;
|
|
|
|
CHECK_CALL_HRES (IASFileToBase64(
|
|
sz_FileBackup,
|
|
&FileBackupBSTR
|
|
)
|
|
);
|
|
|
|
int NumberOfKeyFiles = celems(c_wcKEYS);
|
|
|
|
BSTR pFileKeys[celems(c_wcKEYS)];
|
|
|
|
WCHAR* sz_FileRegistry;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcKEYS_FILE,
|
|
&sz_FileRegistry
|
|
)
|
|
);
|
|
|
|
for ( int i = 0; i < NumberOfKeyFiles; ++i )
|
|
{
|
|
|
|
wstring sFileName(sz_FileRegistry);
|
|
WCHAR buffer[SIZE_LONG_MAX];
|
|
_itow(i, buffer, 10); // 10 means base 10
|
|
sFileName += buffer;
|
|
sFileName += L".txt";
|
|
|
|
CHECK_CALL_HRES (IASFileToBase64(
|
|
sFileName.c_str(),
|
|
&pFileKeys[i]
|
|
)
|
|
);
|
|
|
|
}
|
|
CoTaskMemFree(sz_FileRegistry);
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// alloc the memory for full the Base64 string
|
|
///////////////////////////////////////////////
|
|
|
|
*ulSize = SysStringByteLen(FileBackupBSTR)
|
|
+ EXTRA_CHAR_SPACE;
|
|
|
|
for ( int j = 0; j < NumberOfKeyFiles; ++j )
|
|
{
|
|
*ulSize += SysStringByteLen(pFileKeys[j]);
|
|
*ulSize += 2; // extra characters
|
|
}
|
|
|
|
*ppDumpString = (WCHAR *) calloc(
|
|
*ulSize ,
|
|
sizeof(WCHAR)
|
|
);
|
|
|
|
//////////////////////////////////////////////////
|
|
// copy the different strings into one big string
|
|
//////////////////////////////////////////////////
|
|
if (*ppDumpString)
|
|
{
|
|
wcsncpy(
|
|
(WCHAR*) *ppDumpString,
|
|
(WCHAR*) FileBackupBSTR,
|
|
SysStringLen(FileBackupBSTR)
|
|
);
|
|
|
|
for ( int k = 0; k < NumberOfKeyFiles; ++k )
|
|
{
|
|
wcscat(
|
|
(WCHAR*) *ppDumpString,
|
|
L"*\\\n"
|
|
);
|
|
|
|
wcsncat(
|
|
(WCHAR*) *ppDumpString,
|
|
(WCHAR*) pFileKeys[k],
|
|
SysStringLen(pFileKeys[k])
|
|
);
|
|
}
|
|
|
|
wcscat(
|
|
(WCHAR*) *ppDumpString,
|
|
L"QWER * QWER\\\n"
|
|
);
|
|
|
|
*ulSize = wcslen(*ppDumpString);
|
|
}
|
|
else
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
#ifdef DEBUG
|
|
wprintf(L"### calloc failed ###\n");
|
|
#endif //DEBUG
|
|
|
|
}
|
|
|
|
///////////////////////////////////////
|
|
// delete the temporary files if any
|
|
///////////////////////////////////////
|
|
CHECK_CALL_HRES (DeleteTemporaryFiles());
|
|
|
|
/////////////////////////////////////////////
|
|
// Clean
|
|
/////////////////////////////////////////////
|
|
|
|
for ( int k = 0; k < NumberOfKeyFiles; ++k )
|
|
{
|
|
SysFreeString(pFileKeys[k]);
|
|
}
|
|
|
|
CoTaskMemFree(sz_SelectVersion);
|
|
CoTaskMemFree(sz_SelectProperties);
|
|
CoTaskMemFree(sz_SelectObjects);
|
|
CoTaskMemFree(sz_FileBackup);
|
|
CoTaskMemFree(sz_DBPath);
|
|
SysFreeString(FileBackupBSTR);
|
|
CHECK_CALL_HRES (JetHelper->CloseJetDatabase());
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IASSaveToFile
|
|
//
|
|
// Remark: if a new table has to be saved, an "entry" for that should be
|
|
// created in that function to deal with the filemname
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT IASSaveToFile(
|
|
/* in */ int Index,
|
|
/* in */ WCHAR* pContent,
|
|
DWORD lSize = 0
|
|
)
|
|
{
|
|
HRESULT hres;
|
|
|
|
wstring sFileName;
|
|
|
|
switch (Index)
|
|
{
|
|
case BACKUP_NB:
|
|
{
|
|
WCHAR* sz_FileBackup;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcIAS_OLD,
|
|
&sz_FileBackup
|
|
)
|
|
);
|
|
sFileName = sz_FileBackup;
|
|
|
|
CoTaskMemFree(sz_FileBackup);
|
|
break;
|
|
}
|
|
|
|
///////////
|
|
// binary
|
|
///////////
|
|
default:
|
|
{
|
|
///////////////////////////////////
|
|
// i + BINARY_NB is the parameter
|
|
///////////////////////////////////
|
|
WCHAR* sz_FileRegistry;
|
|
|
|
CHECK_CALL_HRES (IASExpandString(c_wcKEYS_FILE,
|
|
&sz_FileRegistry
|
|
)
|
|
);
|
|
|
|
sFileName = sz_FileRegistry;
|
|
WCHAR buffer[SIZE_LONG_MAX];
|
|
|
|
_itow(Index - BINARY_NB, buffer, 10); // 10 means base 10
|
|
sFileName += buffer;
|
|
sFileName += L".txt";
|
|
|
|
CoTaskMemFree(sz_FileRegistry);
|
|
break;
|
|
}
|
|
}
|
|
|
|
HANDLE hFile = CreateFileW(
|
|
sFileName.c_str(),
|
|
GENERIC_WRITE,
|
|
FILE_SHARE_WRITE | FILE_SHARE_READ,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
if (INVALID_HANDLE_VALUE == hFile)
|
|
{
|
|
hres = E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
DWORD NumberOfBytesWritten;
|
|
BOOL bResult = WriteFile(
|
|
hFile,
|
|
(LPVOID) pContent,
|
|
lSize,
|
|
&NumberOfBytesWritten,
|
|
NULL
|
|
);
|
|
|
|
if (bResult)
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hres = E_FAIL;
|
|
}
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IASRestoreConfig
|
|
//
|
|
// Clean the DB first, then insert back everything.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT IASRestoreConfig(/*in*/ const WCHAR *pRestoreString)
|
|
{
|
|
_ASSERTE(pRestoreString);
|
|
|
|
bool bCoInitialized = false;
|
|
HRESULT hres = CoInitializeEx(NULL, COINIT_MULTITHREADED);
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
if (RPC_E_CHANGED_MODE == hres)
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
return hres;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bCoInitialized = true;
|
|
}
|
|
|
|
BSTR bstr = NULL;
|
|
do
|
|
{
|
|
///////////////////////////////////////
|
|
// delete the temporary files if any
|
|
///////////////////////////////////////
|
|
CHECK_CALL_HRES_BREAK (DeleteTemporaryFiles());
|
|
|
|
CComPtr<IIASNetshJetHelper> JetHelper;
|
|
CHECK_CALL_HRES_BREAK (CoCreateInstance(
|
|
__uuidof(CIASNetshJetHelper),
|
|
NULL,
|
|
CLSCTX_SERVER,
|
|
__uuidof(IIASNetshJetHelper),
|
|
(PVOID*) &JetHelper
|
|
));
|
|
|
|
bstr = SysAllocStringLen(
|
|
pRestoreString,
|
|
wcslen(pRestoreString) + 2
|
|
);
|
|
|
|
if (bstr == NULL)
|
|
{
|
|
#ifdef DEBUG
|
|
wprintf(L"### IASRestoreConfig->SysAllocStringLen failed\n");
|
|
#endif //DEBUG
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
int RealNumberOfFiles = MAX_FILES + celems(c_wcKEYS);
|
|
|
|
for ( int i = 0; i < RealNumberOfFiles; ++i )
|
|
{
|
|
BLOB lBlob;
|
|
|
|
lBlob.cbSize = 0;
|
|
lBlob.pBlobData = NULL;
|
|
// split the files and registry info
|
|
// uncompress (in memory ?)
|
|
|
|
CHECK_CALL_HRES_BREAK (FromBase64(bstr, &lBlob, i));
|
|
|
|
ULONG ulSize = lBlob.cbSize;
|
|
PUCHAR pDeCompressedBuffer;
|
|
|
|
////////////////////////////////////
|
|
// decode and decompress the base64
|
|
////////////////////////////////////
|
|
|
|
CHECK_CALL_HRES_BREAK (IASUnCompress(
|
|
lBlob.pBlobData,
|
|
&ulSize,
|
|
&pDeCompressedBuffer
|
|
))
|
|
|
|
|
|
if ( i >= MAX_FILES )
|
|
{
|
|
/////////////////////////////////////
|
|
// Binary; i + BINARY_NB used here
|
|
/////////////////////////////////////
|
|
IASSaveToFile(
|
|
i - MAX_FILES + BINARY_NB,
|
|
(WCHAR*)pDeCompressedBuffer,
|
|
(DWORD) ulSize
|
|
);
|
|
}
|
|
else
|
|
{
|
|
IASSaveToFile(
|
|
i,
|
|
(WCHAR*)pDeCompressedBuffer,
|
|
(DWORD) ulSize
|
|
);
|
|
}
|
|
|
|
////////////
|
|
// Clean
|
|
////////////
|
|
RtlFreeHeap(RtlProcessHeap(), 0, pDeCompressedBuffer);
|
|
|
|
CoTaskMemFree(lBlob.pBlobData);
|
|
}
|
|
|
|
///////////////////////////////////////////////////
|
|
// Now Upgrade the database (That's transactional)
|
|
///////////////////////////////////////////////////
|
|
hres = JetHelper->UpgradeDatabase();
|
|
|
|
if ( SUCCEEDED(hres) )
|
|
{
|
|
#ifdef DEBUG
|
|
wprintf(L"### IASRestoreConfig->DB stuff successful\n");
|
|
#endif //DEBUG
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Now restore the registry.
|
|
////////////////////////////////////////////////////////
|
|
hres = IASRestoreRegKeys();
|
|
if ( FAILED(hres) )
|
|
{
|
|
#ifdef DEBUG
|
|
wprintf(L"### IASRestoreConfig->restore reg keys failed\n");
|
|
#endif //DEBUG
|
|
}
|
|
}
|
|
// delete the temporary files
|
|
DeleteTemporaryFiles(); // do not check the result
|
|
} while (false);
|
|
|
|
SysFreeString(bstr);
|
|
|
|
if (bCoInitialized)
|
|
{
|
|
CoUninitialize();
|
|
}
|
|
return hres;
|
|
}
|