static IXMLDOMNode* XMLLoadFile(const TCHAR* pszFile)
{
HRESULT hr;
IXMLDOMElement* pRoot;
IXMLDOMDocument* pXMLDoc;
hr = CoCreateInstance(CLSID_DOMDocument,
NULL,
CLSCTX_INPROC_SERVER,
IID_IXMLDOMDocument,
(void**)&pXMLDoc);
if(FAILED(hr))
return NULL;
_variant_t vSrc(pszFile);
VARIANT_BOOL vBool = VARIANT_FALSE;
hr = pXMLDoc->load(vSrc, &vBool);
if(FAILED(hr))
{
FC_RELEASE_PTR(pXMLDoc);
return NULL;
}
if(vBool!=VARIANT_TRUE)
{
FC_RELEASE_PTR(pXMLDoc);
return NULL;
}
pRoot = NULL;
hr = pXMLDoc->get_documentElement(&pRoot);
FC_RELEASE_PTR(pXMLDoc);
if(FAILED(hr) || !pRoot)
return NULL;
return pRoot;
}
bool COpenGL::SetShadersGLSL(const TCHAR *glslFileName)
{
char *fragment=NULL, *vertex=NULL;
IXMLDOMDocument * pXMLDoc = NULL;
IXMLDOMElement * pXDE = NULL;
IXMLDOMNode * pXDN = NULL;
HRESULT hr;
BSTR queryString, nodeContent;
TCHAR errorMsg[MAX_PATH + 50];
if(fragmentShader) {
glDetachShader(shaderProgram,fragmentShader);
glDeleteShader(fragmentShader);
fragmentShader = 0;
}
if(vertexShader) {
glDetachShader(shaderProgram,vertexShader);
glDeleteShader(vertexShader);
vertexShader = 0;
}
if(shaderProgram) {
glUseProgram(0);
glDeleteProgram(shaderProgram);
shaderProgram = 0;
}
if(glslFileName==NULL || *glslFileName==TEXT('\0'))
return true;
if(!LoadShaderFunctions()) {
MessageBox(NULL, TEXT("Unable to load OpenGL shader functions"), TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
hr = CoCreateInstance(CLSID_DOMDocument,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&pXMLDoc));
if(FAILED(hr)) {
MessageBox(NULL, TEXT("Error creating XML Parser"), TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
VARIANT fileName;
VARIANT_BOOL ret;
fileName.vt = VT_BSTR;
#ifdef UNICODE
fileName.bstrVal = SysAllocString(glslFileName);
#else
wchar_t tempfilename[MAX_PATH];
MultiByteToWideChar(CP_UTF8,0,glslFileName,-1,tempfilename,MAX_PATH);
fileName.bstrVal = SysAllocString(tempfilename);
#endif
hr = pXMLDoc->load(fileName,&ret);
SysFreeString(fileName.bstrVal);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading GLSL shader file:\n%s"),glslFileName);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
VARIANT attributeValue;
BSTR attributeName;
hr = pXMLDoc->get_documentElement(&pXDE);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading root element from file:\n%s"),glslFileName);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
attributeName=SysAllocString(L"language");
pXDE->getAttribute(attributeName,&attributeValue);
SysFreeString(attributeName);
pXDE->Release();
if(attributeValue.vt!=VT_BSTR || lstrcmpiW(attributeValue.bstrVal,L"glsl")) {
_stprintf(errorMsg,TEXT("Shader language is <%s>, expected <GLSL> in file:\n%s"),attributeValue.bstrVal,glslFileName);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
pXMLDoc->Release();
return false;
}
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
queryString=SysAllocString(L"/shader/fragment");
hr = pXMLDoc->selectSingleNode(queryString,&pXDN);
SysFreeString(queryString);
if(hr == S_OK) {
hr = pXDN->get_text(&nodeContent);
if(hr == S_OK) {
int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,fragment,0,NULL,NULL);
fragment = new char[requiredChars];
WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,fragment,requiredChars,NULL,NULL);
}
SysFreeString(nodeContent);
pXDN->Release();
pXDN = NULL;
}
queryString=SysAllocString(L"/shader/vertex");
hr = pXMLDoc->selectSingleNode(queryString,&pXDN);
SysFreeString(queryString);
if(hr == S_OK) {
hr = pXDN->get_text(&nodeContent);
if(hr == S_OK) {
int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,vertex,0,NULL,NULL);
vertex = new char[requiredChars];
WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,vertex,requiredChars,NULL,NULL);
}
SysFreeString(nodeContent);
pXDN->Release();
pXDN = NULL;
}
pXMLDoc->Release();
if(!fragment && !vertex) {
_stprintf(errorMsg,TEXT("No vertex or fragment program in file:\n%s"),glslFileName);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
return false;
}
shaderProgram = glCreateProgram ();
if(vertex) {
vertexShader = glCreateShader (GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, (const GLchar **)&vertex, NULL);
glCompileShader(vertexShader);
glAttachShader(shaderProgram, vertexShader);
delete[] vertex;
}
if(fragment) {
fragmentShader = glCreateShader (GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, (const GLchar **)&fragment, NULL);
glCompileShader(fragmentShader);
glAttachShader(shaderProgram, fragmentShader);
delete[] fragment;
}
glLinkProgram(shaderProgram);
glUseProgram(shaderProgram);
shader_type = OGL_SHADER_GLSL;
return true;
}
HRESULT
CIhvProfileBase::LoadXml
(
IN BSTR bstrProfileData
)
{
HRESULT hr = S_OK;
IXMLDOMDocument* pDOMDoc = NULL;
IXMLDOMElement* pDocElem = NULL;
BSTR bstrIhvProfile = NULL;
VARIANT_BOOL vfSuccess;
if ( !bstrProfileData )
{
hr = GetDefaultXml( &bstrIhvProfile );
BAIL_ON_FAILURE( hr );
}
else
{
bstrIhvProfile = bstrProfileData;
}
if ( m_pRootNode )
{
hr = E_UNEXPECTED;
BAIL_ON_FAILURE( hr );
}
hr =
CoCreateInstance
(
CLSID_DOMDocument,
NULL,
CLSCTX_ALL,
IID_IXMLDOMDocument,
(LPVOID *) &pDOMDoc
);
BAIL_ON_FAILURE( hr );
hr =
pDOMDoc->loadXML
(
bstrIhvProfile,
&vfSuccess
);
BAIL_ON_FAILURE( hr );
if ( VARIANT_TRUE != vfSuccess )
{
hr = E_UNEXPECTED;
BAIL_ON_FAILURE( hr );
}
hr =
pDOMDoc->get_documentElement
(
&pDocElem
);
BAIL_ON_FAILURE( hr );
// Caching the pointer to the document element
// in a member variable.
m_pRootNode = pDocElem;
pDocElem = NULL;
error:
if ( !bstrProfileData )
{
SYS_FREE_STRING( bstrIhvProfile );
}
RELEASE_INTERFACE( pDOMDoc );
RELEASE_INTERFACE( pDocElem );
return hr;
}
bool CDirect3D::SetShaderHLSL(const TCHAR *file)
{
//MUDLORD: the guts
//Compiles a shader from files on disc
//Sets LUT textures to texture files in PNG format.
TCHAR folder[MAX_PATH];
TCHAR rubyLUTfileName[MAX_PATH];
TCHAR *slash;
char *shaderText = NULL;
TCHAR errorMsg[MAX_PATH + 50];
IXMLDOMDocument * pXMLDoc = NULL;
IXMLDOMElement * pXDE = NULL;
IXMLDOMNode * pXDN = NULL;
BSTR queryString, nodeContent;
HRESULT hr;
shaderTimer = 1.0f;
shaderTimeStart = 0;
shaderTimeElapsed = 0;
if(effect) {
effect->Release();
effect = NULL;
}
for(int i = 0; i < MAX_SHADER_TEXTURES; i++) {
if (rubyLUT[i] != NULL) {
rubyLUT[i]->Release();
rubyLUT[i] = NULL;
}
}
if (file == NULL || *file==TEXT('\0'))
return true;
hr = CoCreateInstance(CLSID_DOMDocument,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&pXMLDoc));
if(FAILED(hr)) {
MessageBox(NULL, TEXT("Error creating XML Parser"), TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
VARIANT fileName;
VARIANT_BOOL ret;
fileName.vt = VT_BSTR;
#ifdef UNICODE
fileName.bstrVal = SysAllocString(file);
#else
wchar_t tempfilename[MAX_PATH];
MultiByteToWideChar(CP_UTF8,0,file,-1,tempfilename,MAX_PATH);
fileName.bstrVal = SysAllocString(tempfilename);
#endif
hr = pXMLDoc->load(fileName,&ret);
SysFreeString(fileName.bstrVal);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading HLSL shader file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
VARIANT attributeValue;
BSTR attributeName;
hr = pXMLDoc->get_documentElement(&pXDE);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading root element from file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
attributeName=SysAllocString(L"language");
pXDE->getAttribute(attributeName,&attributeValue);
SysFreeString(attributeName);
pXDE->Release();
if(attributeValue.vt!=VT_BSTR || lstrcmpiW(attributeValue.bstrVal,L"hlsl")) {
_stprintf(errorMsg,TEXT("Shader language is <%s>, expected <HLSL> in file:\n%s"),attributeValue.bstrVal,file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
pXMLDoc->Release();
return false;
}
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
queryString=SysAllocString(L"/shader/source");
hr = pXMLDoc->selectSingleNode(queryString,&pXDN);
SysFreeString(queryString);
if(hr == S_OK) {
hr = pXDN->get_text(&nodeContent);
if(hr == S_OK) {
int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,shaderText,0,NULL,NULL);
shaderText = new char[requiredChars];
WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,shaderText,requiredChars,NULL,NULL);
}
SysFreeString(nodeContent);
pXDN->Release();
pXDN = NULL;
}
pXMLDoc->Release();
if(!shaderText) {
_stprintf(errorMsg,TEXT("No HLSL shader program in file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
LPD3DXBUFFER pBufferErrors = NULL;
hr = D3DXCreateEffect( pDevice,shaderText,strlen(shaderText),NULL, NULL,
D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, NULL, &effect,
&pBufferErrors );
delete[] shaderText;
if( FAILED(hr) ) {
_stprintf(errorMsg,TEXT("Error parsing HLSL shader file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(pBufferErrors) {
LPVOID pCompilErrors = pBufferErrors->GetBufferPointer();
MessageBox(NULL, (const TCHAR*)pCompilErrors, TEXT("FX Compile Error"),
MB_OK|MB_ICONEXCLAMATION);
}
return false;
}
lstrcpy(folder,file);
slash = _tcsrchr(folder,TEXT('\\'));
if(slash)
*(slash+1)=TEXT('\0');
else
*folder=TEXT('\0');
SetCurrentDirectory(S9xGetDirectoryT(DEFAULT_DIR));
for(int i = 0; i < MAX_SHADER_TEXTURES; i++) {
_stprintf(rubyLUTfileName, TEXT("%srubyLUT%d.png"), folder, i);
hr = D3DXCreateTextureFromFile(pDevice,rubyLUTfileName,&rubyLUT[i]);
if FAILED(hr){
rubyLUT[i] = NULL;
}
}
D3DXHANDLE hTech;
effect->FindNextValidTechnique(NULL,&hTech);
effect->SetTechnique( hTech );
shader_type = D3D_SHADER_HLSL;
return true;
}
/******************************************************************
ExecXmlConfig - entry point for XmlConfig Custom Action
*******************************************************************/
extern "C" UINT __stdcall ExecXmlConfig(
__in MSIHANDLE hInstall
)
{
//AssertSz(FALSE, "debug ExecXmlConfig");
HRESULT hr = S_OK;
HRESULT hrOpenFailure = S_OK;
UINT er = ERROR_SUCCESS;
BOOL fIsWow64Process = FALSE;
BOOL fIsFSRedirectDisabled = FALSE;
BOOL fPreserveDate = FALSE;
LPWSTR pwzCustomActionData = NULL;
LPWSTR pwzData = NULL;
LPWSTR pwzFile = NULL;
LPWSTR pwzElementPath = NULL;
LPWSTR pwzVerifyPath = NULL;
LPWSTR pwzName = NULL;
LPWSTR pwzValue = NULL;
LPWSTR pwz = NULL;
int cAdditionalChanges = 0;
IXMLDOMDocument* pixd = NULL;
IXMLDOMNode* pixn = NULL;
IXMLDOMNode* pixnVerify = NULL;
IXMLDOMNode* pixnNewNode = NULL;
IXMLDOMNode* pixnRemovedChild = NULL;
IXMLDOMDocument* pixdNew = NULL;
IXMLDOMElement* pixeNew = NULL;
FILETIME ft;
int id = IDRETRY;
eXmlAction xa;
eXmlPreserveDate xd;
// initialize
hr = WcaInitialize(hInstall, "ExecXmlConfig");
ExitOnFailure(hr, "failed to initialize");
hr = XmlInitialize();
ExitOnFailure(hr, "failed to initialize xml utilities");
hr = WcaGetProperty( L"CustomActionData", &pwzCustomActionData);
ExitOnFailure(hr, "failed to get CustomActionData");
WcaLog(LOGMSG_TRACEONLY, "CustomActionData: %ls", pwzCustomActionData);
pwz = pwzCustomActionData;
hr = WcaReadIntegerFromCaData(&pwz, (int*) &xa);
ExitOnFailure(hr, "failed to process CustomActionData");
// Initialize the Wow64 API - store the result in fWow64APIPresent
// If it fails, this doesn't warrant an error yet, because we only need the Wow64 API in some cases
WcaInitializeWow64();
fIsWow64Process = WcaIsWow64Process();
if (xaOpenFile != xa && xaOpenFilex64 != xa)
{
ExitOnFailure(hr = E_INVALIDARG, "invalid custom action data");
}
// loop through all the passed in data
while (pwz && *pwz)
{
hr = WcaReadStringFromCaData(&pwz, &pwzFile);
ExitOnFailure(hr, "failed to read file name from custom action data");
// Default to not preserve date, preserve it if any modifications require us to
fPreserveDate = FALSE;
// Open the file
ReleaseNullObject(pixd);
if (xaOpenFilex64 == xa)
{
if (!fIsWow64Process)
{
hr = E_NOTIMPL;
ExitOnFailure(hr, "Custom action was told to act on a 64-bit component, but the custom action process is not running in WOW.");
}
hr = WcaDisableWow64FSRedirection();
ExitOnFailure(hr, "Custom action was told to act on a 64-bit component, but was unable to disable filesystem redirection through the Wow64 API.");
fIsFSRedirectDisabled = TRUE;
}
hr = XmlLoadDocumentFromFileEx(pwzFile, XML_LOAD_PRESERVE_WHITESPACE, &pixd);
if (FAILED(hr))
{
// Ignore the return code for now. If they try to add something, we'll fail the install. If all they do is remove stuff then it doesn't matter.
hrOpenFailure = hr;
hr = S_OK;
}
else
{
hrOpenFailure = S_OK;
}
WcaLog(LOGMSG_VERBOSE, "Configuring Xml File: %ls", pwzFile);
while (pwz && *pwz)
{
// If we skip past an element that has additional changes we need to strip them off the stream before
// moving on to the next element. Do that now and then restart the outer loop.
if (cAdditionalChanges > 0)
{
while (cAdditionalChanges > 0)
{
hr = WcaReadStringFromCaData(&pwz, &pwzName);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzValue);
ExitOnFailure(hr, "failed to process CustomActionData");
cAdditionalChanges--;
}
continue;
}
hr = WcaReadIntegerFromCaData(&pwz, (int*) &xa);
ExitOnFailure(hr, "failed to process CustomActionData");
// Break if we need to move on to a different file
if (xaOpenFile == xa || xaOpenFilex64 == xa)
{
break;
}
hr = WcaReadIntegerFromCaData(&pwz, (int*) &xd);
ExitOnFailure(hr, "failed to process CustomActionData");
if (xdPreserve == xd)
{
fPreserveDate = TRUE;
}
// Get path, name, and value to be written
hr = WcaReadStringFromCaData(&pwz, &pwzElementPath);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzVerifyPath);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzName);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzValue);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadIntegerFromCaData(&pwz, &cAdditionalChanges);
ExitOnFailure(hr, "failed to process CustomActionData");
// If we failed to open the file and we're adding something to the file, we've got a problem. Otherwise, just continue on since the file's already gone.
if (FAILED(hrOpenFailure))
{
if (xaCreateElement == xa || xaWriteValue == xa || xaWriteDocument == xa)
{
MessageExitOnFailure1(hr = hrOpenFailure, msierrXmlConfigFailedOpen, "failed to load XML file: %ls", pwzFile);
}
else
{
continue;
}
}
// Select the node we're about to modify
ReleaseNullObject(pixn);
hr = XmlSelectSingleNode(pixd, pwzElementPath, &pixn);
// If we failed to find the node that we are going to add to, we've got a problem. Otherwise, just continue since the node's already gone.
if (S_FALSE == hr)
{
if (xaCreateElement == xa || xaWriteValue == xa || xaWriteDocument == xa)
{
hr = HRESULT_FROM_WIN32(ERROR_OBJECT_NOT_FOUND);
}
else
{
hr = S_OK;
continue;
}
}
MessageExitOnFailure2(hr, msierrXmlConfigFailedSelect, "failed to find node: %ls in XML file: %ls", pwzElementPath, pwzFile);
// Make the modification
switch (xa)
{
case xaWriteValue:
if (pwzName && *pwzName)
{
// We're setting an attribute
hr = XmlSetAttribute(pixn, pwzName, pwzValue);
ExitOnFailure2(hr, "failed to set attribute: %ls to value %ls", pwzName, pwzValue);
}
else
{
// We're setting the text of the node
hr = XmlSetText(pixn, pwzValue);
ExitOnFailure2(hr, "failed to set text to: %ls for element %ls. Make sure that XPath points to an element.", pwzValue, pwzElementPath);
}
break;
case xaWriteDocument:
if (NULL != pwzVerifyPath && 0 != pwzVerifyPath[0])
{
hr = XmlSelectSingleNode(pixn, pwzVerifyPath, &pixnVerify);
if (S_OK == hr)
{
// We found the verify path which means we have no further work to do
continue;
}
ExitOnFailure1(hr, "failed to query verify path: %ls", pwzVerifyPath);
}
hr = XmlLoadDocumentEx(pwzValue, XML_LOAD_PRESERVE_WHITESPACE, &pixdNew);
ExitOnFailure(hr, "Failed to load value as document.");
hr = pixdNew->get_documentElement(&pixeNew);
ExitOnFailure(hr, "Failed to get document element.");
hr = pixn->appendChild(pixeNew, NULL);
ExitOnFailure(hr, "Failed to append document element on to parent element.");
ReleaseNullObject(pixeNew);
ReleaseNullObject(pixdNew);
break;
case xaCreateElement:
if (NULL != pwzVerifyPath && 0 != pwzVerifyPath[0])
{
hr = XmlSelectSingleNode(pixn, pwzVerifyPath, &pixnVerify);
if (S_OK == hr)
{
// We found the verify path which means we have no further work to do
continue;
}
ExitOnFailure1(hr, "failed to query verify path: %ls", pwzVerifyPath);
}
hr = XmlCreateChild(pixn, pwzName, &pixnNewNode);
ExitOnFailure1(hr, "failed to create child element: %ls", pwzName);
if (pwzValue && *pwzValue)
{
hr = XmlSetText(pixnNewNode, pwzValue);
ExitOnFailure2(hr, "failed to set text to: %ls for node: %ls", pwzValue, pwzName);
}
while (cAdditionalChanges > 0)
{
hr = WcaReadStringFromCaData(&pwz, &pwzName);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzValue);
ExitOnFailure(hr, "failed to process CustomActionData");
// Set the additional attribute
hr = XmlSetAttribute(pixnNewNode, pwzName, pwzValue);
ExitOnFailure2(hr, "failed to set attribute: %ls to value %ls", pwzName, pwzValue);
cAdditionalChanges--;
}
ReleaseNullObject(pixnNewNode);
break;
case xaDeleteValue:
if (pwzName && *pwzName)
{
// Delete the attribute
hr = XmlRemoveAttribute(pixn, pwzName);
ExitOnFailure1(hr, "failed to remove attribute: %ls", pwzName);
}
else
{
// Clear the text value for the node
hr = XmlSetText(pixn, L"");
ExitOnFailure(hr, "failed to clear text value");
}
break;
case xaDeleteElement:
if (NULL != pwzVerifyPath && 0 != pwzVerifyPath[0])
{
hr = XmlSelectSingleNode(pixn, pwzVerifyPath, &pixnVerify);
if (S_OK == hr)
{
hr = pixn->removeChild(pixnVerify, &pixnRemovedChild);
ExitOnFailure(hr, "failed to remove created child element");
ReleaseNullObject(pixnRemovedChild);
}
else
{
WcaLog(LOGMSG_VERBOSE, "Failed to select path %ls for deleting. Skipping...", pwzVerifyPath);
hr = S_OK;
}
}
else
{
// TODO: This requires a VerifyPath to delete an element. Should we support not having one?
WcaLog(LOGMSG_VERBOSE, "No VerifyPath specified for delete element of ID: %ls", pwzElementPath);
}
break;
default:
ExitOnFailure(hr = E_UNEXPECTED, "Invalid modification specified in custom action data");
break;
}
}
// Now that we've made all of the changes to this file, save it and move on to the next
if (S_OK == hrOpenFailure)
{
if (fPreserveDate)
{
hr = FileGetTime(pwzFile, NULL, NULL, &ft);
ExitOnFailure1(hr, "failed to get modified time of file : %ls", pwzFile);
}
int iSaveAttempt = 0;
do
{
hr = XmlSaveDocument(pixd, pwzFile);
if (FAILED(hr))
{
id = WcaErrorMessage(msierrXmlConfigFailedSave, hr, INSTALLMESSAGE_ERROR | MB_ABORTRETRYIGNORE, 1, pwzFile);
switch (id)
{
case IDABORT:
ExitOnFailure1(hr, "Failed to save changes to XML file: %ls", pwzFile);
case IDRETRY:
hr = S_FALSE; // hit me, baby, one more time
break;
case IDIGNORE:
hr = S_OK; // pretend everything is okay and bail
break;
case 0: // No UI case, MsiProcessMessage returns 0
if (STIERR_SHARING_VIOLATION == hr)
{
// Only in case of sharing violation do we retry 30 times, once a second.
if (iSaveAttempt < 30)
{
hr = S_FALSE;
++iSaveAttempt;
WcaLog(LOGMSG_VERBOSE, "Unable to save changes to XML file: %ls, retry attempt: %x", pwzFile, iSaveAttempt);
Sleep(1000);
}
else
{
ExitOnFailure1(hr, "Failed to save changes to XML file: %ls", pwzFile);
}
}
break;
default: // Unknown error
ExitOnFailure1(hr, "Failed to save changes to XML file: %ls", pwzFile);
}
}
} while (S_FALSE == hr);
if (fPreserveDate)
{
hr = FileSetTime(pwzFile, NULL, NULL, &ft);
ExitOnFailure1(hr, "failed to set modified time of file : %ls", pwzFile);
}
if (fIsFSRedirectDisabled)
{
fIsFSRedirectDisabled = FALSE;
WcaRevertWow64FSRedirection();
}
}
}
LExit:
// Make sure we revert FS Redirection if necessary before exiting
if (fIsFSRedirectDisabled)
{
fIsFSRedirectDisabled = FALSE;
WcaRevertWow64FSRedirection();
}
WcaFinalizeWow64();
ReleaseStr(pwzCustomActionData);
ReleaseStr(pwzData);
ReleaseStr(pwzFile);
ReleaseStr(pwzElementPath);
ReleaseStr(pwzVerifyPath);
ReleaseStr(pwzName);
ReleaseStr(pwzValue);
ReleaseObject(pixeNew);
ReleaseObject(pixdNew);
ReleaseObject(pixn);
ReleaseObject(pixd);
ReleaseObject(pixnNewNode);
ReleaseObject(pixnRemovedChild);
XmlUninitialize();
if (FAILED(hr))
{
er = ERROR_INSTALL_FAILURE;
}
return WcaFinalize(er);
}
///////////////////////////////////////////////////////////////
// 功能: XML 文档文本转换成扫描参数结构
// 参数: sXMLDocText [in] XML文档的文本
// sp [out] 扫描参数结构
// 返回: true - 成功, false - 失败
bool ScanParamXML::XMLToScanParam( const string &sXMLDocText, ScanParameter &sp )
{
try
{
IXMLDOMDocument *pXmlDoc = NULL;
IXMLDOMNode *pXmlDomNode = NULL;
// 得到关于IXMLDOMDocument 接口的指针 pXMLDOC
HRESULT hr = ::CoCreateInstance( CLSID_DOMDocument,
NULL,
CLSCTX_INPROC_SERVER,
IID_IXMLDOMDocument,
( void ** )&pXmlDoc );
if( S_OK != hr )
{
return false;
}
//得到关于IXMLDOMNode接口的指针pXDN
hr = pXmlDoc->QueryInterface( IID_IXMLDOMNode,
( void ** )&pXmlDomNode );
if( S_OK != hr )
{
return false;
}
VARIANT_BOOL bOk;
_variant_t varSrc = sXMLDocText.c_str();
IXMLDOMElement *pRootNode; // 根结点
IXMLDOMNode *pNode;
IXMLDOMNode *pNodeOut;
pXmlDoc->loadXML( varSrc.bstrVal, &bOk ); // 从字符串建立XML文档
// 取得根结点
pXmlDoc->get_documentElement( &pRootNode );
pRootNode->get_nodeName( &varSrc.bstrVal );
// 遍历根结点的子结点
for( pRootNode->get_firstChild( &pNode );
pNode != NULL; pNode->get_nextSibling( &pNode ) )
{
pNode->get_nodeName( &varSrc.bstrVal );
// cout << "Node name: " << varSrc.operator _bstr_t().operator char *() << endl;
string sNodeName = _bstr_t( varSrc.bstrVal ).operator char *();
if( sNodeName == string( "Depth" ) )
{ // 发现 Depth 结点
varSrc = ReadNodeText( pNode );
sp.nDepth = atoi( _bstr_t( varSrc.bstrVal ).operator char *() );
//cout << "Depth value: " << sp.nDepth << endl;
}
else if( sNodeName == string( "TryTimes" ) )
{ // 发现 TryTimes 结点
varSrc = ReadNodeText( pNode );
sp.nTryTimes = atoi( _bstr_t( varSrc.bstrVal ).operator char *() );
//cout << "TryTimes value: " << sp.nTryTimes << endl;
}
else if( sNodeName == string( "Timeout" ) )
{ // 发现 Timeout 结点
varSrc = ReadNodeText( pNode );
sp.nTimeout = atoi( _bstr_t( varSrc.bstrVal ).operator char *() );
//cout << "Timeout value: " << sp.nTimeout << endl;
}
else if( sNodeName == string( "MaxTreadCount" ) )
{ // 发现 MaxTreadCount 结点
varSrc = ReadNodeText( pNode );
sp.nMaxTreadCount = atoi( _bstr_t( varSrc.bstrVal ).operator char *() );
//cout << "MaxTreadCount value: " << sp.nMaxTreadCount << endl;
}
else if( sNodeName == string( "SubScan" ) )
{ // 发现 SubScan 结点
varSrc = ReadNodeText( pNode );
sp.bSubScan = ( string( _bstr_t( varSrc.bstrVal ).operator char *() ) == XML_TRUE ) ;
//cout << "SubScan value: " << sp.bSubScan << endl;
}
else if( sNodeName == string( "DefaultCommunityGet" ) )
{ // 发现 DefaultCommunityGet 结点
varSrc = ReadNodeText( pNode );
sp.sDefaultCommunityOfGet = _bstr_t( varSrc.bstrVal ).operator char *();
//cout << "DefaultCommunityGet value: " << sp.sDefaultCommunityOfGet << endl;
}
else if( sNodeName == string( "DefaultCommunitySet" ) )
{ // 发现 DefaultCommunitySet 结点
varSrc = ReadNodeText( pNode );
sp.sDefaultCommunityOfSet = _bstr_t( varSrc.bstrVal ).operator char *();
//cout << "DefaultCommunityOfSet value: " << sp.sDefaultCommunityOfSet << endl;
}
else if( sNodeName == string( "Communitys" ) )
{ // 发现 Communitys 结点
ReadCommunityListNode( pNode, sp.vcCommunityList );
}
else if( sNodeName == string( "AddStartEnds" ) )
{ // 发现 AddStartEnds 结点
ReadIpScopeListNode( pNode, sp.viIpScopeList ); // 读IpScopeList结点
}
else if( sNodeName == string( "FilterStartEnds" ) )
{ // 发现 FilterStartEnds 结点
ReadIpScopeListNode( pNode, sp.viFilterStartEndList ); // 读IpScopeList结点
}
else if( sNodeName == string( "SubnetList" ) )
{ // 发现 SubnetList 结点
ReadIpScopeListNode( pNode, sp.viSubnetList ); // 读IpScopeList结点
}
else if( sNodeName == string( "SeedIpList" ) )
{ // 发现 SeedIp 结点
ReadStringListNode( pNode, sp.vsSeedIpList );
}
}
// cout << "XMLToScanParam done successfully!" << endl;
}
catch(...)
{
return false;
}
return true;
}
