/*++
Copyright (c) 1997 Microsoft Corporation
Module Name:
utils2.c
Abstract:
utillities to update lnk/msi/... file
Author:
Xiaofeng Zang (xiaoz) 08-Oct-2001 Created
Revision History:
<alias> <date> <comments>
--*/
#define NOT_USE_SAFE_STRING
#include "clmt.h"
#include <objbase.h>
#include <shellapi.h>
#include <shlguid.h>
#include <comdef.h>
#include <iads.h>
#include <adsiid.h>
#include <adshlp.h>
#define STRSAFE_LIB
#include <strsafe.h>
class CServiceHandle
{
public :
CServiceHandle() { _h = 0; }
CServiceHandle( SC_HANDLE hSC ) : _h( hSC ) {}
~CServiceHandle() { Free(); }
void Set( SC_HANDLE h ) { _h = h; }
SC_HANDLE Get() { return _h; }
BOOL IsNull() { return ( 0 == _h ); }
void Free() { if ( 0 != _h ) CloseServiceHandle( _h ); _h = 0; }
private:
SC_HANDLE _h;
};
//+-------------------------------------------------------------------------
//
// Function: IsServiceRunning
//
// Synopsis: Determines if a service is running
//
// Arguments: pwcServiceName -- The name (short or long) of the service
//
// Returns: TRUE if the service is running, FALSE otherwise or if the
// system is low on resources or the status can't be queried.
//
// History: 3/22/2002 geoffguo Created
//
//--------------------------------------------------------------------------
BOOL IsServiceRunning(LPCTSTR pwcServiceName)
{
CServiceHandle xhSC( OpenSCManager( 0, 0, SC_MANAGER_ALL_ACCESS ) );
if ( xhSC.IsNull() )
return FALSE;
CServiceHandle xhService( OpenService( xhSC.Get(),
pwcServiceName,
SERVICE_QUERY_STATUS ) );
if ( xhSC.IsNull() )
return FALSE;
SERVICE_STATUS svcStatus;
if ( QueryServiceStatus( xhService.Get(), &svcStatus ) )
return ( SERVICE_RUNNING == svcStatus.dwCurrentState );
return FALSE;
}
HRESULT AddNeedUpdateLnkFile(
LPTSTR pszShortcutFile,
PREG_STRING_REPLACE lpStrList)
{
HRESULT hr;
IShellLink *psl = NULL;
TCHAR szGotPath [MAX_PATH];
TCHAR szNewPath [2*MAX_PATH];
TCHAR szArg[INFOTIPSIZE+1],szNewArg[2*INFOTIPSIZE+1];
WIN32_FIND_DATA wfd;
IPersistFile *ppf = NULL;
int nIcon;
LPTSTR lpszOneline = NULL;
size_t cchOneline = 0;
TCHAR szIndex[MAX_PATH];
LPTSTR lpszAppend = TEXT("");
BOOL bLnkUpdated = FALSE;
BOOL bTargetGot = FALSE;
BOOL bTargetUpdated = FALSE;
DWORD dwAttrib;
LPTSTR lpszStrWithExtraQuote;
if (!pszShortcutFile || !pszShortcutFile[0] || !lpStrList)
{
hr = S_FALSE;
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: InValid Parameter(s)"));
goto Cleanup;
}
//Allocate memory for "LnkFile,TargetPath,IconPath,Working Dir,Relative Path and Argument"
cchOneline = lstrlen(pszShortcutFile) + 5 * MAX_PATH + INFOTIPSIZE+1;
if (!(lpszOneline = (LPTSTR)malloc(cchOneline * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
// Get a pointer to the IShellLink interface.
hr = CoCreateInstance (CLSID_ShellLink,
NULL,
CLSCTX_INPROC_SERVER,
IID_IShellLink,
(void **)&psl);
if (FAILED (hr))
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: CoCreateInstance CLSID_ShellLink return %d (%#x)\n"), hr, hr);
goto Cleanup;
}
// Get a pointer to the IPersistFile interface.
hr = psl->QueryInterface (IID_IPersistFile, (void **)&ppf);
if (FAILED(hr))
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: QueryInterface IID_IPersistFile return %d (%#x)\n"), hr, hr);
goto Cleanup;
}
// Load the shortcut.
hr = ppf->Load (pszShortcutFile, STGM_READWRITE );
if (FAILED(hr))
{
hr = S_FALSE;
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: can not load shortcut file %s"),pszShortcutFile);
goto Cleanup;
}
hr = StringCchPrintf(lpszOneline,cchOneline,TEXT("\"%s\""),pszShortcutFile);
if (FAILED(hr))
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: buffer lpszOneline is too small for %s"),pszShortcutFile);
goto Cleanup;
}
// Get the path to the shortcut target.
hr = psl->GetPath (szGotPath,
ARRAYSIZE(szGotPath),
(WIN32_FIND_DATA *)&wfd,
SLGP_RAWPATH);
if (SUCCEEDED (hr))
{ //Succeeded get the target
DWORD dwNum ;
DPF (INFinf,TEXT("AddNeedUpdateLnkFile: GetPath %s OK "), szGotPath);
//Set bTargetGot so that it cab be used to set relative target path
bTargetGot = TRUE;
//szGotPath contains LNK's target path, if dwNum >0 , it means szGotPath
//contains (localized) path that we renamed
dwNum = GetMaxMatchNum(szGotPath,lpStrList);
//call ReplaceMultiMatchInString ,to replace szGotPath's localized folder
//with english one, and put new path in szNewPath
if (dwNum && ReplaceMultiMatchInString(szGotPath,szNewPath,ARRAYSIZE(szNewPath),dwNum,lpStrList, &dwAttrib, TRUE))
{
lpszAppend = szNewPath;
bTargetUpdated = TRUE;
bLnkUpdated = TRUE;
}
}
else
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: GetPath %s Error = %d"), szGotPath,hr);
}
if (MyStrCmpI(lpszAppend,TEXT("")))
{
hr = AddExtraQuoteEtc(lpszAppend,&lpszStrWithExtraQuote);
if (SUCCEEDED(hr))
{
if (lpszStrWithExtraQuote)
{
lpszAppend = lpszStrWithExtraQuote;
}
}
}
else
{
lpszStrWithExtraQuote = NULL;
}
//Append the new quoted target path to lpszOneline
hr = StringCchPrintf(lpszOneline,cchOneline,TEXT("%s,\"%s\""),lpszOneline,lpszAppend);
FreePointer(lpszStrWithExtraQuote);
//check StringCchPrintf here, because we want to free lpszStrWithExtraQuote before
//we do a jump (if necessary)
if (FAILED(hr))
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: buffer lpszOneline is too small for %s"),lpszAppend);
goto Cleanup;
}
//if we arrive here , we have succeeded in appeneding target to the lszOneline
//we will update relative target path ,which is relative to where the current
//lnk resides
lpszAppend = TEXT("");
if (bTargetGot) //this means we succeeded get the target path
{
DWORD dwNum ;
//szNewLnkFilePath is the lnk full path with localized folder renamed to english one(if any)
TCHAR szNewLnkFilePath[2*MAX_PATH],szCurrTarget[2*MAX_PATH];
TCHAR szExpandedCurrTarget[2*MAX_PATH];
TCHAR szNewTarget[2*MAX_PATH];
//Check to see whether current pszShortcutFile resides a direcory that contains
//localized folder we renamed
dwNum = GetMaxMatchNum(pszShortcutFile,lpStrList);
if (dwNum)
{
if (!ReplaceMultiMatchInString(pszShortcutFile,szNewLnkFilePath,
ARRAYSIZE(szNewLnkFilePath),dwNum,lpStrList, &dwAttrib, TRUE))
{
//szNewLnkFilePath now is full path with localized folder renamed to english one
//if we fail do ReplaceMultiMatchInString, just clone to szNewLnkFilePath
hr = StringCchCopy(szNewLnkFilePath,ARRAYSIZE(szNewLnkFilePath),pszShortcutFile);
if (FAILED(hr))
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: buffer szNewLnkFilePath is too small for %s"),pszShortcutFile);
goto Cleanup;
}
}
}
else
{
//If pszShortcutFile does not contains any localized folder we renamed,
//just clone to szNewLnkFilePath
hr = StringCchCopy(szNewLnkFilePath,ARRAYSIZE(szNewLnkFilePath),pszShortcutFile);
if (FAILED(hr))
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: buffer szNewLnkFilePath is too small for %s"),pszShortcutFile);
goto Cleanup;
}
}
if (bTargetUpdated)
{
if (FAILED(hr = StringCchCopy(szCurrTarget,ARRAYSIZE(szCurrTarget),szNewPath)))
{
goto Cleanup;
}
}
else
{
if (FAILED(hr = StringCchCopy(szCurrTarget,ARRAYSIZE(szCurrTarget),szGotPath)))
{
goto Cleanup;
}
}
//target may contains enviroment variable
if (!ExpandEnvironmentStrings(szCurrTarget,szExpandedCurrTarget,ARRAYSIZE(szExpandedCurrTarget)))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
//Check whether target contains the folder we renamed
dwNum = GetMaxMatchNum(szExpandedCurrTarget,lpStrList);
if (dwNum)
{
if (!ReplaceMultiMatchInString(szExpandedCurrTarget,szNewTarget,ARRAYSIZE(szNewTarget),dwNum,lpStrList, &dwAttrib, TRUE))
{
hr = StringCchCopy(szNewTarget,ARRAYSIZE(szNewTarget),szExpandedCurrTarget);
if (FAILED(hr))
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: buffer szNewTarget is too small for %s"),szExpandedCurrTarget);
goto Cleanup;
}
}
}
else
{
hr = StringCchCopy(szNewTarget,ARRAYSIZE(szNewTarget),szExpandedCurrTarget);
if (FAILED(hr))
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: buffer szNewTarget is too small for %s"),szExpandedCurrTarget);
goto Cleanup;
}
}
if (PathRelativePathTo(szNewPath,szNewLnkFilePath,0,szNewTarget,0))
{
lpszAppend = szNewPath;
bLnkUpdated = TRUE;
}
}
if (MyStrCmpI(lpszAppend,TEXT("")))
{
hr = AddExtraQuoteEtc(lpszAppend,&lpszStrWithExtraQuote);
if (SUCCEEDED(hr))
{
if (lpszStrWithExtraQuote)
{
lpszAppend = lpszStrWithExtraQuote;
}
}
}
else
{
lpszStrWithExtraQuote = NULL;
}
hr = StringCchPrintf(lpszOneline,cchOneline,TEXT("%s,\"%s\""),lpszOneline,lpszAppend);
FreePointer(lpszStrWithExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
lpszAppend = TEXT("");
hr = psl->GetIconLocation (szGotPath,ARRAYSIZE(szGotPath),&nIcon);
if (SUCCEEDED (hr))
{
DWORD dwNum ;
DPF (INFinf,TEXT("AddNeedUpdateLnkFile: GetIconPath %s OK "), szGotPath);
dwNum = GetMaxMatchNum(szGotPath,lpStrList);
if (dwNum && ReplaceMultiMatchInString(szGotPath,szNewPath,ARRAYSIZE(szNewPath),dwNum,lpStrList, &dwAttrib, TRUE))
{
lpszAppend = szNewPath;
bLnkUpdated = TRUE;
}
}
else
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: GetIconPath %s Error = %d"), szGotPath,hr);
}
if (MyStrCmpI(lpszAppend,TEXT("")))
{
hr = AddExtraQuoteEtc(lpszAppend,&lpszStrWithExtraQuote);
if (SUCCEEDED(hr))
{
if (lpszStrWithExtraQuote)
{
lpszAppend = lpszStrWithExtraQuote;
}
}
}
else
{
lpszStrWithExtraQuote = NULL;
}
hr = StringCchPrintf(lpszOneline,cchOneline,TEXT("%s,\"%s\""),lpszOneline,lpszAppend);
FreePointer(lpszStrWithExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
lpszAppend = TEXT("");
hr = psl->GetWorkingDirectory (szGotPath,ARRAYSIZE(szGotPath));
if (SUCCEEDED (hr))
{
DWORD dwNum ;
DPF (INFinf,TEXT("AddNeedUpdateLnkFile: GetWorkingDirPath %s OK "), szGotPath);
dwNum = GetMaxMatchNum(szGotPath,lpStrList);
if (dwNum && ReplaceMultiMatchInString(szGotPath,szNewPath,ARRAYSIZE(szNewPath),dwNum,lpStrList, &dwAttrib, TRUE))
{
bLnkUpdated = TRUE;
lpszAppend = szNewPath;
}
}
else
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: GetWorkingDirPath %s Error = %d"), szGotPath,hr);
}
if (MyStrCmpI(lpszAppend,TEXT("")))
{
hr = AddExtraQuoteEtc(lpszAppend,&lpszStrWithExtraQuote);
if (SUCCEEDED(hr))
{
if (lpszStrWithExtraQuote)
{
lpszAppend = lpszStrWithExtraQuote;
}
}
}
else
{
lpszStrWithExtraQuote = NULL;
}
hr = StringCchPrintf(lpszOneline,cchOneline,TEXT("%s,\"%s\""),lpszOneline,lpszAppend);
FreePointer(lpszStrWithExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
lpszAppend = TEXT("");
hr = psl->GetArguments (szArg,ARRAYSIZE(szArg));
if (SUCCEEDED (hr))
{
DWORD dwNum ;
DPF (INFinf,TEXT("AddNeedUpdateLnkFile: GetArguments %s OK "), szArg);
dwNum = GetMaxMatchNum(szArg,lpStrList);
if (dwNum && ReplaceMultiMatchInString(szArg,szNewArg,ARRAYSIZE(szNewArg),dwNum,lpStrList, &dwAttrib, TRUE))
{
bLnkUpdated = TRUE;
lpszAppend = szNewArg;
}
}
else
{
DPF (INFwar,TEXT("AddNeedUpdateLnkFile: GetArguments %s Error = %d"), pszShortcutFile,hr);
}
if (MyStrCmpI(lpszAppend,TEXT("")))
{
hr = AddExtraQuoteEtc(lpszAppend,&lpszStrWithExtraQuote);
if (SUCCEEDED(hr))
{
if (lpszStrWithExtraQuote)
{
lpszAppend = lpszStrWithExtraQuote;
}
}
}
else
{
lpszStrWithExtraQuote = NULL;
}
hr = StringCchPrintf(lpszOneline,cchOneline,TEXT("%s,\"%s\""),lpszOneline,lpszAppend);
FreePointer(lpszStrWithExtraQuote);
if (FAILED(hr))
{
goto Cleanup;
}
if (bLnkUpdated)
{
g_dwKeyIndex++;
_itot(g_dwKeyIndex,szIndex,16);
if (!WritePrivateProfileString(TEXT("LNK"),szIndex,lpszOneline,g_szToDoINFFileName))
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
else
{
hr = S_OK;
}
}
else
{
hr = S_OK;
}
Cleanup:
if (psl)
{
psl->Release ();
}
if (ppf)
{
ppf->Release ();
}
FreePointer(lpszOneline);
return hr;
}
HRESULT BatchFixPathInLink(
HINF hInf,
LPTSTR lpszSection)
{
HRESULT hr;
IShellLink *psl = NULL;
WIN32_FIND_DATA wfd;
IPersistFile *ppf = NULL;
int nIcon;
BOOL bSucceedOnce = FALSE;
UINT LineCount,LineNo;
INFCONTEXT InfContext;
LPTSTR lpszLnkFile = NULL,lpszPath = NULL,lpszIcon = NULL,lpszWorkingDir = NULL,
lpszRelPath = NULL,lpszArg = NULL;
DWORD cchMaxLnkFile = 0,cchMaxPath = 0,cchMaxIcon = 0,cchMaxWorkingDir = 0,
cchMaxRelPath = 0,cchMaxArg = 0;
DWORD dwFileAttrib;
BOOL bFileAttribChanged ;
if ((hInf == INVALID_HANDLE_VALUE) || !lpszSection)
{
hr = E_INVALIDARG;
goto Cleanup;
}
LineCount = (UINT)SetupGetLineCount(hInf,lpszSection);
if ((LONG)LineCount <= 0)
{
hr = S_FALSE;
DPF(INFwar ,TEXT("section name %s is empty failed !"),lpszSection);
goto Cleanup;
}
for(LineNo=0; LineNo<LineCount; LineNo++)
{
DWORD cchTmpLnkFile = 0,cchTmpPath = 0,cchTmpIcon = 0,cchTmpWorkingDir = 0,
cchTmpRelPath = 0,cchTmpArg = 0;
if (!SetupGetLineByIndex(hInf,lpszSection,LineNo,&InfContext))
{
DPF(INFerr ,TEXT("can not get line %n of section %s !"),LineNo, lpszSection);
hr = E_FAIL;
goto Cleanup;
}
if (!SetupGetStringField(&InfContext,1,NULL,0,&cchTmpLnkFile))
{
DPF(INFerr ,TEXT("get [%s] 's line %d 's Field 1 failed !"),lpszSection, LineNo);
hr = E_FAIL;
goto Cleanup;
}
if (!SetupGetStringField(&InfContext,2,NULL,0,&cchTmpPath))
{
DPF(INFerr ,TEXT("get [%s] 's line %d 's Field 2 failed !"),lpszSection, LineNo);
hr = E_FAIL;
goto Cleanup;
}
if (!SetupGetStringField(&InfContext,3,NULL,0,&cchTmpRelPath))
{
DPF(INFerr ,TEXT("get [%s] 's line %d 's Field 3 failed !"),lpszSection, LineNo);
hr = E_FAIL;
goto Cleanup;
}
if (!SetupGetStringField(&InfContext,4,NULL,0,&cchTmpIcon))
{
DPF(INFerr ,TEXT("get [%s] 's line %d 's Field 4 failed !"),lpszSection, LineNo);
hr = E_FAIL;
goto Cleanup;
}
if (!SetupGetStringField(&InfContext,5,NULL,0,&cchTmpWorkingDir))
{
DPF(INFerr ,TEXT("get [%s] 's line %d 's Field 5 failed !"),lpszSection, LineNo);
hr = E_FAIL;
goto Cleanup;
}
if (!SetupGetStringField(&InfContext,6,NULL,0,&cchTmpArg))
{
DPF(INFerr ,TEXT("get [%s] 's line %d 's Field 6 failed !"),lpszSection, LineNo);
hr = E_FAIL;
goto Cleanup;
}
cchMaxLnkFile = max(cchMaxLnkFile,cchTmpLnkFile);
cchMaxPath = max(cchMaxPath,cchTmpPath);
cchMaxIcon = max(cchMaxIcon,cchTmpIcon);
cchMaxWorkingDir = max(cchMaxWorkingDir,cchTmpWorkingDir);
cchMaxRelPath = max(cchMaxRelPath,cchTmpRelPath);
cchMaxArg = max(cchMaxArg,cchTmpArg);
}
if (cchMaxLnkFile)
{
if (!(lpszLnkFile = (LPTSTR)malloc(++cchMaxLnkFile * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
}
if (cchMaxPath)
{
if (!(lpszPath = (LPTSTR)malloc(++cchMaxPath * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
}
if (cchMaxIcon)
{
if (!(lpszIcon = (LPTSTR)malloc(++cchMaxIcon * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
}
if (cchMaxWorkingDir)
{
if (!(lpszWorkingDir = (LPTSTR)malloc(++cchMaxWorkingDir * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
}
if (cchMaxRelPath)
{
if (!(lpszRelPath = (LPTSTR)malloc(++cchMaxRelPath * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
}
if (cchMaxArg)
{
if (!(lpszArg = (LPTSTR)malloc(++cchMaxArg * sizeof(TCHAR))))
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
}
hr = CoCreateInstance (CLSID_ShellLink,
NULL,
CLSCTX_INPROC_SERVER,
IID_IShellLink,
(void **)&psl);
if (FAILED (hr))
{
psl = NULL;
goto Cleanup;
}
// Get a pointer to the IPersistFile interface.
hr = psl->QueryInterface (IID_IPersistFile, (void **)&ppf);
if (FAILED(hr))
{
ppf = NULL;
goto Cleanup;
}
for(LineNo=0; LineNo<LineCount; LineNo++)
{
BOOL bSucceededOnce = FALSE;
SetupGetLineByIndex(hInf,lpszSection,LineNo,&InfContext);
if (lpszLnkFile)
{
SetupGetStringField(&InfContext,1,lpszLnkFile,cchMaxLnkFile,NULL);
}
if (lpszPath)
{
SetupGetStringField(&InfContext,2,lpszPath,cchMaxPath,NULL);
}
if (lpszRelPath)
{
SetupGetStringField(&InfContext,3,lpszRelPath,cchMaxRelPath,NULL);
}
if (lpszIcon)
{
SetupGetStringField(&InfContext,4,lpszIcon,cchMaxIcon,NULL);
}
if (lpszWorkingDir)
{
SetupGetStringField(&InfContext,5,lpszWorkingDir,cchMaxWorkingDir,NULL);
}
if (lpszArg)
{
SetupGetStringField(&InfContext,6,lpszArg,cchMaxArg,NULL);
}
bFileAttribChanged = FALSE;
dwFileAttrib = GetFileAttributes(lpszLnkFile);
if (INVALID_FILE_ATTRIBUTES == dwFileAttrib)
{
//but put a waring log here
continue;
}
if ( (dwFileAttrib & FILE_ATTRIBUTE_READONLY)
||(dwFileAttrib & FILE_ATTRIBUTE_SYSTEM) )
{
if (!SetFileAttributes(lpszLnkFile,FILE_ATTRIBUTE_NORMAL))
{
//but put a waring log here
continue;
}
bFileAttribChanged = TRUE;
}
hr = ppf->Load (lpszLnkFile, STGM_READWRITE );
if (FAILED(hr))
{
//but put a waring log here
continue;
}
if (lpszPath && lpszPath[0])
{
hr = psl->SetPath (lpszPath);
if (SUCCEEDED(hr))
{
bSucceededOnce = TRUE;
}
}
if (lpszRelPath && lpszRelPath[0])
{
hr = psl->SetRelativePath(lpszRelPath,0);
if (SUCCEEDED(hr))
{
bSucceededOnce = TRUE;
}
}
if (lpszIcon && lpszIcon[0])
{
TCHAR szGotPath[MAX_PATH];
hr = psl->GetIconLocation (szGotPath,ARRAYSIZE(szGotPath),&nIcon);
if (SUCCEEDED(hr))
{
hr = psl->SetIconLocation (lpszIcon,nIcon);
if (SUCCEEDED(hr))
{
bSucceededOnce = TRUE;
}
}
}
if (lpszWorkingDir && lpszWorkingDir[0])
{
hr = psl->SetWorkingDirectory (lpszWorkingDir);
if (SUCCEEDED(hr))
{
bSucceededOnce = TRUE;
}
}
if (lpszArg && lpszArg[0])
{
hr = psl->SetArguments (lpszArg);
if (SUCCEEDED(hr))
{
bSucceededOnce = TRUE;
}
}
if (bSucceededOnce)
{
hr = ppf->Save (lpszLnkFile,TRUE);
if (! SUCCEEDED (hr))
{
DPF (dlError,TEXT("FixPathInLink: Save %s Error = %d"), lpszLnkFile,hr);
}
else
{
DPF (dlInfo,TEXT("FixPathInLink: Save %s OK = %d"), lpszLnkFile,hr);
}
}
if (bFileAttribChanged)
{
SetFileAttributes (lpszLnkFile, dwFileAttrib);
}
}
hr = S_OK;
Cleanup:
if (psl)
{
psl->Release ();
}
if (ppf)
{
ppf->Release ();
}
FreePointer(lpszPath);
FreePointer(lpszIcon);
FreePointer(lpszRelPath);
FreePointer(lpszWorkingDir);
FreePointer(lpszArg);
FreePointer(lpszLnkFile);
return hr;
}
HRESULT RenameRDN(
LPTSTR lpContainerPathWithLDAP,
LPTSTR lpOldFQDNWithLDAP,
LPTSTR lpNewRDNWithCN
)
{
HRESULT hr;
IADsContainer *pContainer = NULL;
IDispatch *pDispatch = NULL;
BSTR bstrOldFQDNWithLDAP = SysAllocString(lpOldFQDNWithLDAP);
BSTR bstrNewRDNWithCN = SysAllocString(lpNewRDNWithCN);
if (!bstrOldFQDNWithLDAP || !bstrNewRDNWithCN )
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
hr = ADsGetObject(lpContainerPathWithLDAP,
IID_IADsContainer,
(VOID **) &pContainer);
if (SUCCEEDED(hr))
{
// Rename the RDN here
hr = pContainer->MoveHere(bstrOldFQDNWithLDAP,
bstrNewRDNWithCN,
&pDispatch);
if (SUCCEEDED(hr))
{
pDispatch->Release();
}
pContainer->Release();
}
Cleanup:
if (bstrOldFQDNWithLDAP)
{
SysFreeString(bstrOldFQDNWithLDAP);
}
if (bstrNewRDNWithCN)
{
SysFreeString(bstrNewRDNWithCN);
}
return hr;
}
// Pass in the interface ptr to the property value
// will return a BSTR value of the data.
// The IADsPropertyValue::get_ADsType() is called to retrieve the
// ADSTYPE valued enum
// This enum is then used to determine which IADsPropertyValue method
// to call to receive the actual data
// CALLER assumes responsibility for freeing returned BSTR
HRESULT GetIADsPropertyValueAsBSTR(BSTR * pbsRet,IADsPropertyEntry *pAdsEntry, IADsPropertyValue * pAdsPV)
{
HRESULT hr = S_OK;
long lAdsType;
hr = pAdsPV->get_ADsType(&lAdsType);
if (FAILED(hr))
return hr;
switch (lAdsType)
{
case ADSTYPE_INVALID :
{
*pbsRet = SysAllocString(L"<ADSTYPE_INVALID>");
}
break;
case ADSTYPE_DN_STRING :
{
hr = pAdsPV->get_DNString(pbsRet);
}
break;
case ADSTYPE_CASE_EXACT_STRING :
{
hr = pAdsPV->get_CaseExactString(pbsRet);
}
break;
case ADSTYPE_CASE_IGNORE_STRING :
{
hr = pAdsPV->get_CaseIgnoreString(pbsRet);
}
break;
case ADSTYPE_PRINTABLE_STRING :
{
hr = pAdsPV->get_PrintableString(pbsRet);
}
break;
case ADSTYPE_NUMERIC_STRING :
{
hr = pAdsPV->get_NumericString(pbsRet);
}
break;
case ADSTYPE_BOOLEAN :
{
long b;
hr = pAdsPV->get_Boolean(&b);
if (SUCCEEDED(hr))
{
if (b)
*pbsRet = SysAllocString(L"<TRUE>");
else
*pbsRet = SysAllocString(L"<FALSE>");
}
}
break;
case ADSTYPE_INTEGER :
{
long lInt;
hr = pAdsPV->get_Integer(&lInt);
if (SUCCEEDED(hr))
{
WCHAR wOut[100];
hr = StringCchPrintf(wOut,ARRAYSIZE(wOut),L"%d",lInt);
*pbsRet = SysAllocString(wOut);
}
}
break;
case ADSTYPE_OCTET_STRING :
{
*pbsRet = SysAllocString(L"<ADSTYPE_OCTET_STRING>");
BSTR bsName= NULL;
VARIANT vOctet;
DWORD dwSLBound;
DWORD dwSUBound;
void HUGEP *pArray;
VariantInit(&vOctet);
//Get the name of the property to handle
//the properties we're interested in.
pAdsEntry->get_Name(&bsName);
hr = pAdsPV->get_OctetString(&vOctet);
//Get a pointer to the bytes in the octet string.
if (SUCCEEDED(hr))
{
hr = SafeArrayGetLBound( V_ARRAY(&vOctet),
1,
(long FAR *) &dwSLBound );
hr = SafeArrayGetUBound( V_ARRAY(&vOctet),
1,
(long FAR *) &dwSUBound );
if (SUCCEEDED(hr))
{
hr = SafeArrayAccessData( V_ARRAY(&vOctet),
&pArray );
if (FAILED(hr))
{
break;
}
}
else
{
break;
}
/* Since an Octet String has a specific meaning
depending on the attribute name, handle two
common ones here
*/
if (0==wcscmp(L"objectGUID", bsName))
{
//LPOLESTR szDSGUID = new WCHAR [39];
WCHAR szDSGUID[39];
//Cast to LPGUID
LPGUID pObjectGUID = (LPGUID)pArray;
//Convert GUID to string.
::StringFromGUID2(*pObjectGUID, szDSGUID, 39);
*pbsRet = SysAllocString(szDSGUID);
}
else if (0==wcscmp(L"objectSid", bsName))
{
PSID pObjectSID = (PSID)pArray;
//Convert SID to string.
LPOLESTR szSID = NULL;
ConvertSidToStringSid(pObjectSID, &szSID);
*pbsRet = SysAllocString(szSID);
LocalFree(szSID);
}
else
{
*pbsRet = SysAllocString(L"<Value of type Octet String. No Conversion>");
}
SafeArrayUnaccessData( V_ARRAY(&vOctet) );
VariantClear(&vOctet);
}
SysFreeString(bsName);
}
break;
case ADSTYPE_LARGE_INTEGER :
{
*pbsRet = SysAllocString(L"<ADSTYPE_LARGE_INTEGER>");
}
break;
case ADSTYPE_PROV_SPECIFIC :
{
*pbsRet = SysAllocString(L"<ADSTYPE_PROV_SPECIFIC>");
}
break;
case ADSTYPE_OBJECT_CLASS :
{
hr = pAdsPV->get_CaseIgnoreString(pbsRet);
}
break;
case ADSTYPE_PATH :
{
hr = pAdsPV->get_CaseIgnoreString(pbsRet);
}
break;
case ADSTYPE_NT_SECURITY_DESCRIPTOR :
{
*pbsRet = SysAllocString(L"<ADSTYPE_NT_SECURITY_DESCRIPTOR>");
}
break;
default:
*pbsRet = SysAllocString(L"<UNRECOGNIZED>");
break;
}
return hr;
}
HRESULT PropertyValueHelper(
LPTSTR lpObjPathWithLDAP,
LPTSTR lpPropName,
LPTSTR *lplpValue,
LPTSTR lpNewValue)
{
IADsPropertyList *pList = NULL;
IADsPropertyEntry *pEntry = NULL;
IADs *pObj = NULL;
VARIANT var,varEnrty;
long valType = ADSTYPE_PATH;
HRESULT hr;
BSTR bstrPropName = NULL;
BSTR bstrNewValue = NULL;
// bind to directory object
hr = ADsGetObject(lpObjPathWithLDAP,
IID_IADsPropertyList,
(void**)&pList);
if (S_OK != hr)
{
pList = NULL;
goto exit;
}
// initialize the property cache
hr = pList->QueryInterface(IID_IADs,(void**)&pObj);
if (S_OK != hr)
{
pObj = NULL;
goto exit;
}
pObj->GetInfo();
// get a property entry
VariantInit(&varEnrty);
bstrPropName = SysAllocString(lpPropName);
if (!bstrPropName)
{
hr = E_OUTOFMEMORY;
goto exit;
}
hr = pList->GetPropertyItem(bstrPropName, valType, &varEnrty);
hr = V_DISPATCH(&varEnrty)->QueryInterface(IID_IADsPropertyEntry,
(void**)&pEntry);
if (S_OK != hr)
{
pEntry = NULL;
goto exit;
}
VariantInit(&var);
hr = pEntry->get_Values(&var);
if (S_OK != hr)
{
goto exit;
}
LONG dwSLBound = 0;
LONG dwSUBound = 0;
LONG i;
hr = SafeArrayGetLBound(V_ARRAY(&var),1,(long FAR *)&dwSLBound);
if (S_OK != hr)
{
goto exit;
}
hr = SafeArrayGetUBound(V_ARRAY(&var),1,(long FAR *)&dwSUBound);
if (S_OK != hr)
{
goto exit;
}
if (dwSLBound || dwSLBound)
{
//we only interested in one enrty
goto exit;
}
VARIANT v;
VariantInit(&v);
i = 0;
hr = SafeArrayGetElement(V_ARRAY(&var),(long FAR *)&i,&v);
if (FAILED(hr))
{
goto exit;
}
IDispatch * pDispEntry = V_DISPATCH(&v);
IADsPropertyValue * pAdsPV = NULL;
hr = pDispEntry->QueryInterface(IID_IADsPropertyValue,(void **) &pAdsPV);
if (SUCCEEDED(hr))
{
BSTR bValue;
// Get the value as a BSTR
hr = GetIADsPropertyValueAsBSTR(&bValue,pEntry,pAdsPV);
if (hr == S_OK)
{
if (lplpValue)
{
*lplpValue = (LPTSTR)malloc( (lstrlen(bValue)+1)*sizeof(TCHAR));
if (!*lplpValue)
{
hr = E_OUTOFMEMORY;
goto exit;
}
hr = StringCchCopy(*lplpValue,lstrlen(bValue)+1,bValue);
}
}
}
if (lpNewValue)
{
bstrNewValue = SysAllocString(lpNewValue);
if (!bstrNewValue)
{
hr = E_OUTOFMEMORY;
goto exit;
}
hr = pAdsPV->put_CaseIgnoreString(bstrNewValue);
}
i = 0;
hr = SafeArrayPutElement(V_ARRAY(&var),&i,&v);
if (hr != S_OK)
{
goto exit;
}
hr = pEntry->put_ControlCode(ADS_PROPERTY_UPDATE);
hr = pEntry->put_Values(var);
pList->PutPropertyItem(varEnrty);
pObj->SetInfo();
hr = S_OK;
exit:;
if (bstrPropName)
{
SysFreeString(bstrPropName);
}
if (bstrNewValue)
{
SysFreeString(bstrNewValue);
}
if (pEntry)
{
pEntry->Release();
}
if (pObj)
{
pObj->Release();
}
if (pList)
{
pList->Release();
}
return hr;
}
BOOL UpdateSecurityTemplatesSection (
LPTSTR lpINFFile,
LPTSTR lpNewInf,
LPTSTR lpszSection,
PREG_STRING_REPLACE lpStrList)
{
HRESULT hr = S_OK;
DWORD cchInSection, CchBufSize, cchOutputSize, cchBufLen;
DWORD dwAttrib;
BOOL bUpdated = FALSE;
LPTSTR lpBuf = NULL;
LPTSTR lpNewBuf, lpOldBuf, lpLineBuf, lpEnd, lpOutputBuf, lpTemp;
if (lpINFFile && lpszSection)
{
//
// allocate max size of buffer
//
CchBufSize = 0x7FFFF;
do
{
if (lpBuf)
{
MEMFREE(lpBuf);
CchBufSize *= 2;
}
lpBuf = (LPTSTR) MEMALLOC(CchBufSize * sizeof(TCHAR));
if (!lpBuf)
{
hr = E_OUTOFMEMORY;
goto Exit;
}
cchInSection = GetPrivateProfileSection(lpszSection,
lpBuf,
CchBufSize,
lpINFFile);
} while (cchInSection == CchBufSize -2);
lpEnd = lpBuf;
lpOutputBuf = NULL;
cchOutputSize = 0;
bUpdated = FALSE;
while(lpEnd < (lpBuf + cchInSection))
{
dwAttrib = 0;
lpNewBuf = ReplaceSingleString (
lpEnd,
REG_SZ,
lpStrList,
NULL,
&dwAttrib,
TRUE);
if (!lpNewBuf)
{
lpNewBuf = ReplaceSingleString (
lpEnd,
REG_SZ,
lpStrList,
NULL,
&dwAttrib,
FALSE);
}
if (!lpNewBuf)
{
lpLineBuf = lpEnd;
}
else
{
bUpdated = TRUE;
lpLineBuf = lpNewBuf;
if (StrStrI(lpEnd, L"ProgramFiles") && StrStrI(lpNewBuf, L"Programs"))
{
//Correct the wrong string replacement
//the difference between "Programs" and "Program Files" is " File"
CchBufSize = lstrlen(lpEnd)+6;
free(lpNewBuf);
lpNewBuf = (LPTSTR)calloc(CchBufSize, sizeof(TCHAR));
if (lpNewBuf)
{
lpTemp = StrStrI(lpEnd, L"=");
if (lpTemp)
{
*lpTemp = (TCHAR)'\0';
hr = StringCchCopy(lpNewBuf, CchBufSize, lpEnd);
*lpTemp = (TCHAR)'=';
hr = StringCchCat(lpNewBuf, CchBufSize, L"= Program Files");
lpLineBuf = lpNewBuf;
if (hr != S_OK)
DPF(REGerr, L"UpdateSecurityTemplatesSection: StringCchCat failed.");
}
else
{
free(lpNewBuf);
lpLineBuf = lpEnd;
lpNewBuf = NULL;
bUpdated = FALSE;
}
}
else
{
hr = E_OUTOFMEMORY;
goto Exit;
}
}
}
cchBufLen = lstrlen(lpLineBuf);
lpOldBuf = NULL;
if (lpOutputBuf)
{
lpOldBuf = lpOutputBuf;
lpOutputBuf = (LPTSTR)MEMREALLOC(lpOldBuf, (cchOutputSize+cchBufLen+2)*sizeof(TCHAR));
}
else
{
lpOutputBuf = (LPTSTR)MEMALLOC((cchBufLen+2)*sizeof(TCHAR));
cchOutputSize = 0;
}
if (lpOutputBuf == NULL)
{
if (lpOldBuf)
MEMFREE(lpOldBuf);
if (lpBuf)
MEMFREE(lpBuf);
if (lpNewBuf)
free(lpNewBuf);
hr = E_OUTOFMEMORY;
goto Exit;
}
hr = StringCchCopy(&lpOutputBuf[cchOutputSize], cchBufLen+1, lpLineBuf);
if (hr != S_OK)
DPF(REGerr, L"UpdateSecurityTemplatesSection3: failed.");
cchOutputSize += cchBufLen+1;
lpEnd += lstrlen(lpEnd)+1;
if (lpNewBuf)
free(lpNewBuf);
}
if (lpOutputBuf)
lpOutputBuf[cchOutputSize] = (TCHAR)'\0';
//Workarround since the function cannot delete the section: Delete the section
WritePrivateProfileSection (lpszSection, NULL, lpNewInf);
if (!WritePrivateProfileSection (lpszSection, lpOutputBuf, lpNewInf))
{
DPF(INFerr, L"UpdateSecurityTemplatesSection: the section %s in file %s Update failed", lpszSection, lpNewInf);
}
if (lpOutputBuf)
MEMFREE(lpOutputBuf);
if (lpBuf)
MEMFREE(lpBuf);
}
Exit:
return bUpdated;
}
HRESULT UpdateSecurityTemplates(
LPTSTR lpINFFile,
PREG_STRING_REPLACE lpStrList)
{
HRESULT hr = E_FAIL;
DWORD cchRead;
DWORD cchBuf = 1024;
LPTSTR lpBuf, lpOldBuf;
LPTSTR lpSection;
BOOL bUpdate;
TCHAR szIndex[16];
TCHAR szNewInf[MAX_PATH];
DPF(REGmsg, L"Enter UpdateSecurityTemplates: %s", lpINFFile);
lpBuf = (LPTSTR)MEMALLOC(cchBuf * sizeof(TCHAR));
if (lpBuf == NULL)
{
return E_OUTOFMEMORY;
}
cchRead = GetPrivateProfileSectionNames(lpBuf,
cchBuf,
lpINFFile);
while (cchRead == (cchBuf - 2))
{
// Buffer is too small, reallocate until we have enough
lpOldBuf = lpBuf;
cchBuf += 1024;
lpBuf = (LPTSTR)MEMREALLOC(lpOldBuf, cchBuf * sizeof(TCHAR));
if (lpBuf == NULL)
{
MEMFREE(lpOldBuf);
return E_OUTOFMEMORY;
}
// Read the data from section again
cchRead = GetPrivateProfileSectionNames(lpBuf,
cchBuf,
lpINFFile);
}
// At this point we have big enough buffer and data in it
if (cchRead > 0)
{
hr = StringCchPrintf(szNewInf, MAX_PATH, TEXT("%s.clmt"), lpINFFile);
CopyFile(lpINFFile, szNewInf, FALSE);
lpSection = (LPTSTR)MultiSzTok(lpBuf);
bUpdate = FALSE;
while (lpSection != NULL)
{
if (UpdateSecurityTemplatesSection(lpINFFile, szNewInf, lpSection, lpStrList))
{
bUpdate = TRUE;
DPF(INFmsg, L"UpdateSecurityTemplatesSection: the section %s in file %s Updated", lpSection, lpINFFile);
}
// Get next section name
lpSection = (LPTSTR)MultiSzTok(NULL);
}
if (bUpdate)
{
g_dwKeyIndex++;
_itot(g_dwKeyIndex,szIndex,16);
if (!WritePrivateProfileString(TEXT("INF Update"),szIndex,szNewInf,g_szToDoINFFileName))
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
}
}
else
{
SetLastError(ERROR_NOT_FOUND);
}
MEMFREE(lpBuf);
DPF(REGmsg, L"Exit UpdateSecurityTemplates:");
return hr;
}
HRESULT BatchINFUpdate(HINF hInf)
{
HRESULT hr = S_OK;
UINT LineCount,LineNo;
DWORD dwRequired;
INFCONTEXT InfContext;
LPTSTR lpTemp;
LPTSTR lpszSection = TEXT("INF Update");
TCHAR chTemp;
TCHAR szFileNameIn[MAX_PATH];
TCHAR szFileNameOut[MAX_PATH];
DPF(INFmsg ,TEXT("Enter BatchINFUpdate:"));
if ((hInf == INVALID_HANDLE_VALUE))
{
hr = E_INVALIDARG;
goto Exit;
}
LineCount = (UINT)SetupGetLineCount(hInf,lpszSection);
if ((LONG)LineCount <= 0)
{
hr = S_FALSE;
DPF(INFwar ,TEXT("BatchINFUpdate: failed. Section %s is empty!"),lpszSection);
goto Exit;
}
for(LineNo=0; LineNo<LineCount; LineNo++)
{
if (!SetupGetLineByIndex(hInf,lpszSection,LineNo,&InfContext))
{
DPF(INFerr ,TEXT("BatchINFUpdate: can not get line %n of section %s !"),LineNo, lpszSection);
hr = E_FAIL;
goto Exit;
}
if (!SetupGetStringField(&InfContext,1,szFileNameIn,MAX_PATH,&dwRequired))
{
DPF(INFerr ,TEXT("BatchINFUpdate: get [%s] 's line %d 's Field 1 failed !"),lpszSection, LineNo);
hr = E_FAIL;
goto Exit;
}
lpTemp = StrStrI(szFileNameIn, TEXT(".clmt"));
if (lpTemp)
{
*lpTemp = (TCHAR)'\0';
hr = StringCchPrintf(szFileNameOut, MAX_PATH, TEXT("%s.bak"), szFileNameIn);
MoveFile(szFileNameIn, szFileNameOut);
hr = StringCchCopy(szFileNameOut, MAX_PATH, szFileNameIn);
*lpTemp = (TCHAR)'.';
MoveFile(szFileNameIn, szFileNameOut);
DPF(INFinf ,TEXT("BatchINFUpdate: %s is updated and backup file is %s.bak"), szFileNameOut, szFileNameOut);
}
}
Exit:
DPF(INFmsg ,TEXT("Exit BatchINFUpdate: hr = %d"), hr);
return hr;
}