1188 lines
34 KiB
C++
1188 lines
34 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1998 - 1998.
|
|
//
|
|
// File: scanfiles.cxx
|
|
//
|
|
// Contents: User file migration code
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 28-Sep-99 PhilipLa Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "scanhead.cxx"
|
|
#pragma hdrstop
|
|
|
|
#include <common.hxx>
|
|
#include <filelist.hxx>
|
|
#include <section.hxx>
|
|
#include <special.hxx>
|
|
|
|
#include <scanstate.hxx>
|
|
|
|
#include <bothchar.hxx>
|
|
|
|
#include <fileutil.cxx>
|
|
|
|
CSection *g_pcsSectionList = NULL;
|
|
|
|
CRuleList g_crlExcludeWildcards;
|
|
CRuleList g_crlIncludeWildcards;
|
|
|
|
CSpecialDirectory g_csd;
|
|
CSysFileList g_sfl;
|
|
|
|
|
|
DWORD ProcessSysFiles(HINF hi, const TCHAR *ptsName);
|
|
|
|
DWORD InitializeFiles()
|
|
{
|
|
DWORD dwErr;
|
|
|
|
dwErr = g_csd.Init();
|
|
if (dwErr)
|
|
{
|
|
return dwErr;
|
|
}
|
|
|
|
if (CopyFiles)
|
|
{
|
|
dwErr = ProcessSysFiles(InputInf, SYSFILES_LABEL);
|
|
if (dwErr != 0)
|
|
return dwErr;
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
void CleanupFiles(void)
|
|
{
|
|
FreeSectionList(g_pcsSectionList);
|
|
g_pcsSectionList = NULL;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------
|
|
DWORD ComputeTemp()
|
|
{
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
void EraseTemp()
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
DWORD PickUpThisFile( char *file, char * dest)
|
|
{
|
|
DWORD dwErr;
|
|
DWORD dwIndex;
|
|
|
|
if ((file == NULL) ||
|
|
(file[0] == 0))
|
|
{
|
|
//Wacky NULL strings must not be added as rules.
|
|
//Ignore them and return success.
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
if (Verbose)
|
|
Win32Printf(LogFile,
|
|
"Copy %s to the destination machine.\r\n",
|
|
file );
|
|
|
|
TCHAR *ptsFile, *ptsDest;
|
|
TCHAR tsFileName[MAX_PATH + 1];
|
|
TCHAR tsTemp[MAX_PATH + 1];
|
|
|
|
#ifdef _UNICODE
|
|
TCHAR tsDest[MAX_PATH + 1];
|
|
|
|
if (!(MultiByteToWideChar(AreFileAPIsAnsi() ? CP_ACP : CP_OEMCP,
|
|
MB_ERR_INVALID_CHARS,
|
|
file,
|
|
-1,
|
|
tsFileName
|
|
MAX_PATH + 1)))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INVALID_PARAMETER);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Couldn't convert output path %s to Unicode.\r\n",
|
|
file);
|
|
return dwErr;
|
|
}
|
|
|
|
if (dest &&
|
|
(!(MultiByteToWideChar(AreFileAPIsAnsi() ? CP_ACP : CP_OEMCP,
|
|
MB_ERR_INVALID_CHARS,
|
|
dest,
|
|
-1,
|
|
tsDest,
|
|
MAX_PATH + 1))))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INVALID_PARAMETER);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Couldn't convert output path %s to Unicode.\r\n",
|
|
dest);
|
|
return dwErr;
|
|
}
|
|
|
|
ptsFile = tsFileName;
|
|
ptsDest = tsDest;
|
|
#else
|
|
ptsFile = file;
|
|
ptsDest = dest;
|
|
#endif //_UNICODE
|
|
|
|
if (_tcslen(ptsFile) > MAX_PATH)
|
|
{
|
|
if (DebugOutput)
|
|
{
|
|
Win32Printf(LogFile, "Error: ptsFile too long %s\r\n", ptsFile);
|
|
}
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
_tcscpy(tsTemp, ptsFile);
|
|
dwErr = g_csd.ExpandMacro(tsTemp, tsFileName, &ptsFile, TRUE);
|
|
if (dwErr)
|
|
return dwErr;
|
|
|
|
CRuleList *prlDest;
|
|
dwErr = g_crlIncludeWildcards.SetName(ptsFile, &prlDest);
|
|
if (!dwErr && ptsDest)
|
|
dwErr = prlDest->SetDestination(ptsDest);
|
|
|
|
//Remove it from the system files list if it's in there.
|
|
g_sfl.RemoveName(ptsFile);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
DWORD CopyAFile(const TCHAR *ptsSourcePath, const TCHAR *ptsName)
|
|
{
|
|
BOOL fPath = FALSE;
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
DWORD dwLen;
|
|
TCHAR ptsMigrationPath[MAX_PATH + 1];
|
|
TCHAR ptsPath[MAX_PATH + 1];
|
|
TCHAR ptsSourceFullPath[MAX_PATH + 1];
|
|
|
|
// If the source filename is too long, skip it
|
|
if ( (_tcslen(ptsName) + _tcslen(ptsSourcePath) + 1) > MAX_PATH )
|
|
{
|
|
Win32PrintfResource(LogFile,
|
|
IDS_FILE_COPYERROR,
|
|
ptsName);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Could Not Copy Too Long Source Filename: %s\\%s\r\n",
|
|
ptsSourcePath,
|
|
ptsName);
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
|
|
_tcscpy(ptsSourceFullPath, ptsSourcePath);
|
|
_tcscat(ptsSourceFullPath, TEXT("\\"));
|
|
_tcscat(ptsSourceFullPath, ptsName);
|
|
|
|
#ifdef _UNICODE
|
|
if (!(dwLen = MultiByteToWideChar(AreFileAPIsAnsi() ? CP_ACP : CP_OEMCP,
|
|
MB_ERR_INVALID_CHARS,
|
|
MigrationPath,
|
|
-1,
|
|
ptsMigrationPath,
|
|
MAX_PATH + 1)))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INVALID_PARAMETER);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Couldn't convert output path %s to Unicode.\r\n",
|
|
MigrationPath);
|
|
return dwErr;
|
|
}
|
|
#else
|
|
dwLen = _tcslen(MigrationPath);
|
|
if (dwLen > MAX_PATH)
|
|
{
|
|
if (DebugOutput)
|
|
{
|
|
Win32Printf(LogFile, "Error: MigrationPath too long %s\r\n", MigrationPath);
|
|
}
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
_tcscpy(ptsMigrationPath, MigrationPath);
|
|
#endif
|
|
|
|
// If the destination path is too long, skip this file
|
|
if ( (dwLen + _tcslen(ptsSourcePath) + _tcslen(ptsName)+1) > MAX_PATH )
|
|
{
|
|
Win32PrintfResource(LogFile,
|
|
IDS_FILE_COPYERROR,
|
|
ptsName);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Could Not Copy To Too Long Destination Filename: %s\\%c%s\\%s\r\n",
|
|
ptsMigrationPath,
|
|
ptsSourcePath[0],
|
|
ptsSourcePath+2,
|
|
ptsName);
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
|
|
_tcscpy(ptsPath, ptsMigrationPath);
|
|
|
|
ptsPath[dwLen++] = TEXT('\\');
|
|
|
|
//Copy drive letter
|
|
ptsPath[dwLen++] = ptsSourcePath[0];
|
|
|
|
//Skip the colon
|
|
_tcscpy(ptsPath + dwLen, ptsSourcePath + 2);
|
|
dwLen = dwLen + _tcslen(ptsSourcePath) - 2;
|
|
|
|
ptsPath[dwLen++] = TEXT('\\');
|
|
_tcscpy(ptsPath + dwLen, ptsName);
|
|
|
|
if (ReallyCopyFiles)
|
|
{
|
|
while (!CopyFile(ptsSourceFullPath,
|
|
ptsPath,
|
|
TRUE))
|
|
{
|
|
dwErr = GetLastError();
|
|
|
|
if (dwErr == ERROR_PATH_NOT_FOUND)
|
|
{
|
|
if (fPath)
|
|
{
|
|
//We already tried to create the path, so something
|
|
//else must be wrong. Punt-arooney.
|
|
break;
|
|
}
|
|
|
|
dwErr = ERROR_SUCCESS;
|
|
|
|
TCHAR *ptsPos;
|
|
DWORD dwPos;
|
|
//Try to create all the necessary directories
|
|
TCHAR ptsDirectory[MAX_PATH + 1];
|
|
|
|
// ptsPath is built inside this function and guarenteed to be less than MAX_PATH
|
|
_tcscpy(ptsDirectory, ptsPath);
|
|
dwPos = _tcslen(ptsMigrationPath) + 1;
|
|
|
|
//Create every directory along this path
|
|
while (ptsPos = _tcschr(ptsDirectory + dwPos, TEXT('\\')))
|
|
{
|
|
*ptsPos = TEXT(0);
|
|
//Create the directory
|
|
|
|
if (!CreateDirectory(ptsDirectory,
|
|
NULL))
|
|
{
|
|
dwErr = GetLastError();
|
|
if (dwErr != ERROR_ALREADY_EXISTS)
|
|
{
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Error %lu trying to create "
|
|
"directory %s\r\n",
|
|
dwErr,
|
|
ptsDirectory);
|
|
|
|
break;
|
|
}
|
|
dwErr = ERROR_SUCCESS;
|
|
}
|
|
|
|
//Put the backslash back in
|
|
*ptsPos = TEXT('\\');
|
|
//Update dwLen
|
|
dwPos = ptsPos - ptsDirectory + 1;
|
|
}
|
|
if (dwErr)
|
|
break;
|
|
fPath = TRUE;
|
|
}
|
|
else if (dwErr == ERROR_ACCESS_DENIED)
|
|
{
|
|
// Ignore files that we don't have permission to copy anyway
|
|
Win32PrintfResource(LogFile,
|
|
IDS_ACCESS_DENIED,
|
|
ptsSourceFullPath);
|
|
dwErr = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (dwErr)
|
|
{
|
|
Win32PrintfResource(LogFile,
|
|
IDS_FILE_COPYERROR,
|
|
ptsSourceFullPath);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Error %lu while copying from %s to %s\r\n",
|
|
dwErr,
|
|
ptsSourceFullPath,
|
|
ptsPath);
|
|
}
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
const TCHAR * GetSpecialDirectoryName(const TCHAR *ptsPath)
|
|
{
|
|
TCHAR buf[MAX_PATH + 1];
|
|
|
|
if (_tcslen(ptsPath) > MAX_PATH)
|
|
{
|
|
if (DebugOutput)
|
|
{
|
|
Win32Printf(LogFile, "Error: ptsPath too long %s\r\n", ptsPath);
|
|
}
|
|
return NULL;
|
|
}
|
|
_tcscpy(buf, ptsPath);
|
|
|
|
DEBUG_ASSERT(buf[_tcslen(ptsPath) - 1] == TEXT('\\'));
|
|
|
|
buf[_tcslen(ptsPath) - 1] = 0;
|
|
|
|
for (ULONG i = 0; i < g_csd.GetDirectoryCount(); i++)
|
|
{
|
|
if (g_csd.GetDirectoryPath(i) &&
|
|
(_tcsicmp(buf, g_csd.GetDirectoryPath(i)) == 0))
|
|
{
|
|
return g_csd.GetDirectoryName(i);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
BOOL ExcludeFile(const TCHAR *ptsRoot,
|
|
const TCHAR *ptsName,
|
|
const WIN32_FIND_DATA *pwfd,
|
|
CRuleList **pprlMatch,
|
|
DWORD *pdwMatchFit)
|
|
{
|
|
BOOL f;
|
|
TCHAR *ptsExt;
|
|
|
|
// This used to exclude HIDDEN and SYSTEM files,
|
|
// but it turns out we do want to migrate those
|
|
// if we have a matching rule. Note that system
|
|
// files will be excluded if they are listed in the
|
|
// system files section of the INF files.
|
|
if (pwfd->dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY)
|
|
{
|
|
if (pprlMatch)
|
|
*pprlMatch = NULL;
|
|
|
|
//Infinite strength on this hit, we should never take these
|
|
//files even if we have a good include rule.
|
|
if (pdwMatchFit)
|
|
*pdwMatchFit = MAX_WEIGHT;
|
|
return TRUE;
|
|
}
|
|
|
|
f = g_crlExcludeWildcards.MatchAgainstRuleList(ptsRoot,
|
|
ptsName,
|
|
pprlMatch,
|
|
pdwMatchFit);
|
|
|
|
if (!f && !CopyFiles)
|
|
{
|
|
//User specified no file copy, so pretend there's a low
|
|
//priority rule that returned a hit. Any explicit include
|
|
//(which will only be coming from PickUpThisFile) will win.
|
|
if (pprlMatch)
|
|
*pprlMatch = NULL;
|
|
if (pdwMatchFit)
|
|
*pdwMatchFit = 1;
|
|
return TRUE;
|
|
}
|
|
return f;
|
|
}
|
|
|
|
|
|
BOOL IncludeFile(const TCHAR *ptsRoot,
|
|
const TCHAR *ptsName,
|
|
const WIN32_FIND_DATA *pwfd,
|
|
CRuleList **pprlMatch)
|
|
{
|
|
CRuleList *prlExclude = NULL;
|
|
CRuleList *prlInclude = NULL;
|
|
|
|
DWORD dwBestExcludeFit = 0;
|
|
DWORD dwBestIncludeFit = 0;
|
|
|
|
ExcludeFile(ptsRoot,
|
|
ptsName,
|
|
pwfd,
|
|
&prlExclude,
|
|
&dwBestExcludeFit);
|
|
|
|
g_crlIncludeWildcards.MatchAgainstRuleList(ptsRoot,
|
|
ptsName,
|
|
&prlInclude,
|
|
&dwBestIncludeFit);
|
|
|
|
if (DebugOutput)
|
|
Win32Printf(LogFile, "File %s%s rule weighting: \r\n Best exclude %lu = %s\r\n Best include %lu = %s\r\n",
|
|
ptsRoot,
|
|
(ptsName == NULL) ? TEXT("") : ptsName,
|
|
dwBestExcludeFit,
|
|
((prlExclude == NULL) ?
|
|
TEXT("NULL") :
|
|
prlExclude->GetFullName()),
|
|
dwBestIncludeFit,
|
|
((prlInclude == NULL) ?
|
|
TEXT("NULL") :
|
|
prlInclude->GetFullName()));
|
|
|
|
|
|
// Include the file when Include rating is stronger than Exclude rating, OR
|
|
// There is an Exclude and Include rule that both match this equally, OR
|
|
// No rules match this and we include by default, OR
|
|
// No rules match this and it's a directory
|
|
|
|
if ( (dwBestIncludeFit > dwBestExcludeFit) ||
|
|
( (dwBestIncludeFit == dwBestExcludeFit) &&
|
|
( (ExcludeByDefault == FALSE) ||
|
|
(dwBestIncludeFit > 0) ||
|
|
(pwfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))))
|
|
{
|
|
if (ptsName && g_sfl.LookupName(ptsName))
|
|
{
|
|
// If this file is listed as a system file in our rules,
|
|
// then always exclude it
|
|
if (pprlMatch)
|
|
*pprlMatch = NULL;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//Include the file
|
|
if (pprlMatch)
|
|
*pprlMatch = prlInclude;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (pprlMatch)
|
|
*pprlMatch = prlExclude;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL PathPrefix(const TCHAR *ptsPath, const TCHAR *ptsInclude)
|
|
{
|
|
TCHAR ptsIncludePath[MAX_PATH + 1];
|
|
TCHAR ptsWildPath[MAX_PATH + 1];
|
|
|
|
if (_tcslen(ptsPath) + 2 > MAX_PATH)
|
|
{
|
|
if (DebugOutput)
|
|
{
|
|
Win32Printf(LogFile, "Error: ptsPath too long %s\r\n", ptsPath);
|
|
}
|
|
return FALSE;
|
|
}
|
|
_tcscpy(ptsWildPath, ptsPath);
|
|
_tcscat(ptsWildPath, TEXT("*\\"));
|
|
|
|
DeconstructFilename(ptsInclude,
|
|
ptsIncludePath,
|
|
NULL,
|
|
NULL);
|
|
|
|
if (ptsIncludePath[0])
|
|
{
|
|
BOOL fRet = IsPatternMatchFull(ptsWildPath, ptsIncludePath, NULL) ||
|
|
IsPatternMatchFull(ptsIncludePath, ptsPath, NULL);
|
|
return fRet;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IncludeDirectory(const TCHAR *ptsPath, const WIN32_FIND_DATA *pwfd)
|
|
{
|
|
CRuleList *prl = g_crlIncludeWildcards.GetNextRule();
|
|
while (prl != NULL)
|
|
{
|
|
if (PathPrefix(ptsPath, prl->GetFullName()))
|
|
{
|
|
return TRUE;
|
|
}
|
|
prl = prl->GetNextRule();
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
DWORD ProcessFileTree(TCHAR *ptsRoot,
|
|
CSection *pcsSection,
|
|
ULONG cRecursionLevel)
|
|
{
|
|
DWORD dwErr;
|
|
HANDLE hNext;
|
|
WIN32_FIND_DATA wfd;
|
|
TCHAR ptsStart[MAX_PATH];
|
|
const TCHAR *ptsSpecialName = GetSpecialDirectoryName(ptsRoot);
|
|
|
|
if ((cRecursionLevel < 2) || (ptsSpecialName != NULL))
|
|
{
|
|
pcsSection = new CSection;
|
|
if (pcsSection == NULL)
|
|
{
|
|
Win32PrintfResource(LogFile, IDS_NOT_ENOUGH_MEMORY);
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
|
|
if (g_pcsSectionList == NULL)
|
|
{
|
|
g_pcsSectionList = pcsSection;
|
|
}
|
|
else
|
|
{
|
|
g_pcsSectionList->AddToList(pcsSection);
|
|
}
|
|
dwErr = pcsSection->SetSectionTitle((ptsSpecialName == NULL) ?
|
|
ptsRoot :
|
|
ptsSpecialName);
|
|
if (dwErr)
|
|
{
|
|
return dwErr;
|
|
}
|
|
dwErr = pcsSection->SetSectionPath(ptsRoot);
|
|
if (dwErr)
|
|
{
|
|
return dwErr;
|
|
}
|
|
}
|
|
|
|
if (_tcslen(ptsRoot) + 3 >= MAX_PATH)
|
|
{
|
|
if (DebugOutput)
|
|
{
|
|
Win32Printf(LogFile, "Error: ptsRoot too long %s\r\n", ptsRoot);
|
|
}
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
_tcscpy(ptsStart, ptsRoot);
|
|
_tcscat(ptsStart, TEXT("*.*"));
|
|
|
|
hNext = FindFirstFile(ptsStart, &wfd);
|
|
|
|
if (hNext == INVALID_HANDLE_VALUE)
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_FILE_ENUMFAIL, ptsStart);
|
|
return dwErr;
|
|
}
|
|
|
|
//Files first, then directories
|
|
do
|
|
{
|
|
CRuleList *prl = NULL;
|
|
DWORD dwIndex;
|
|
|
|
TCHAR *ptsName = ((wfd.cFileName) ?
|
|
wfd.cFileName :
|
|
wfd.cAlternateFileName);
|
|
|
|
if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
IncludeFile(ptsRoot, ptsName, &wfd, &prl))
|
|
{
|
|
ULONG i;
|
|
TCHAR buf[MAX_PATH+1];
|
|
TCHAR *ptsScratch;
|
|
|
|
ptsScratch = ptsRoot + pcsSection->GetSectionPathLength() + 1;
|
|
if (_tcslen(ptsScratch) + _tcslen(ptsName) > MAX_PATH)
|
|
{
|
|
if (DebugOutput)
|
|
{
|
|
Win32Printf(LogFile, "Error: buf too long %s%s\r\n", ptsScratch, ptsName);
|
|
}
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
_tcscpy(buf, ptsScratch);
|
|
_tcscat(buf, ptsName);
|
|
|
|
// Win32Printf(STDOUT, "%s%s\r\n", ptsRoot, ptsName);
|
|
dwErr = pcsSection->SetName(buf, &i, FALSE);
|
|
if (dwErr)
|
|
return dwErr;
|
|
if ((prl != NULL) && (prl->GetDestination() != NULL))
|
|
{
|
|
dwErr = pcsSection->SetDestination(
|
|
prl->GetDestination(),
|
|
i);
|
|
if (dwErr)
|
|
return dwErr;
|
|
}
|
|
|
|
}
|
|
}
|
|
while (0 != FindNextFile(hNext, &wfd));
|
|
|
|
|
|
hNext = FindFirstFile(ptsStart, &wfd);
|
|
|
|
if (hNext == INVALID_HANDLE_VALUE)
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_FILE_ENUMFAIL, ptsStart);
|
|
return dwErr;
|
|
}
|
|
|
|
do
|
|
{
|
|
TCHAR ptsPath[MAX_PATH + 1];
|
|
TCHAR *ptsName = ((wfd.cFileName) ?
|
|
wfd.cFileName :
|
|
wfd.cAlternateFileName);
|
|
|
|
|
|
if (_tcslen(ptsRoot) + _tcslen(ptsName) + 1 > MAX_PATH)
|
|
{
|
|
if (DebugOutput)
|
|
{
|
|
Win32Printf(LogFile, "Error: filename too long %s%s\\\r\n", ptsRoot, ptsName);
|
|
}
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
_tcscpy(ptsPath, ptsRoot);
|
|
_tcscat(ptsPath, ptsName);
|
|
_tcscat(ptsPath, TEXT("\\"));
|
|
|
|
|
|
if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
_tcscmp(ptsName, TEXT(".")) &&
|
|
_tcscmp(ptsName, TEXT("..")))
|
|
{
|
|
if (IncludeFile(ptsPath, NULL, &wfd, NULL) ||
|
|
IncludeDirectory(ptsPath, &wfd))
|
|
{
|
|
ProcessFileTree(ptsPath, pcsSection, cRecursionLevel + 1);
|
|
}
|
|
}
|
|
}
|
|
while (0 != FindNextFile(hNext, &wfd));
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
DWORD AddInfSectionToRuleList(INFCONTEXT *pic,
|
|
CRuleList *pfl,
|
|
BOOL fAllowRename)
|
|
{
|
|
TCHAR buf[MAX_PATH + 1];
|
|
TCHAR bufMacro[MAX_PATH + 1];
|
|
TCHAR *ptsFinalName;
|
|
TCHAR bufTag[MAX_PATH + 1];
|
|
DWORD dwErr;
|
|
CRuleList *prl;
|
|
|
|
do
|
|
{
|
|
DWORD dwIndex;
|
|
DWORD cFields;
|
|
BOOL fDirectoryTag = FALSE;
|
|
cFields = SetupGetFieldCount(pic);
|
|
|
|
if (((cFields != 1) && !fAllowRename) ||
|
|
((cFields > 2) && fAllowRename))
|
|
{
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Line contains more than one file name\r\n");
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (!SetupGetStringField(pic,
|
|
1,
|
|
buf,
|
|
MAX_PATH + 1,
|
|
NULL))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupGetStringField returned %lu\r\n",
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
|
|
if (SetupGetStringField(pic,
|
|
0,
|
|
bufTag,
|
|
MAX_PATH + 1,
|
|
NULL))
|
|
{
|
|
if (_tcsicmp(bufTag, buf))
|
|
{
|
|
//Someone put a field identifier on there. The only
|
|
//one we recognize is 'dir'
|
|
if (_tcsicmp(bufTag, TEXT("dir")))
|
|
{
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Unknown tag %s\r\n",
|
|
bufTag);
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
fDirectoryTag = TRUE;
|
|
}
|
|
}
|
|
|
|
dwErr = g_csd.ExpandMacro(buf, bufMacro, &ptsFinalName, TRUE);
|
|
if (dwErr)
|
|
return dwErr;
|
|
|
|
DWORD ccFinalName = _tcslen(ptsFinalName);
|
|
if ((fDirectoryTag) && (ptsFinalName[ccFinalName-1] != '\\'))
|
|
{
|
|
//Append a backslash if there isn't one already
|
|
if (ccFinalName > MAX_PATH)
|
|
{
|
|
if (DebugOutput)
|
|
{
|
|
Win32Printf(LogFile, "Error: ptsFinalName too long: %s\\\r\n", ptsFinalName);
|
|
}
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
else
|
|
{
|
|
_tcscat(ptsFinalName, TEXT("\\"));
|
|
}
|
|
}
|
|
|
|
dwErr = pfl->SetName(ptsFinalName, &prl);
|
|
if (dwErr)
|
|
{
|
|
return dwErr;
|
|
}
|
|
|
|
if (cFields == 2)
|
|
{
|
|
if (!SetupGetStringField(pic,
|
|
2,
|
|
buf,
|
|
MAX_PATH + 1,
|
|
NULL))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupGetStringField returned %lu\r\n",
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
dwErr = prl->SetDestination(buf);
|
|
if (dwErr)
|
|
{
|
|
return dwErr;
|
|
}
|
|
}
|
|
}
|
|
while (SetupFindNextLine(pic, pic));
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
DWORD ProcessCopyFiles(HINF hi, const TCHAR *ptsName)
|
|
{
|
|
DWORD dwErr;
|
|
INFCONTEXT ic;
|
|
|
|
if (!SetupFindFirstLine(hi,
|
|
ptsName,
|
|
NULL,
|
|
&ic))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_SECTION_NAME_NOT_FOUND, ptsName);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupFindFirstLine failed on section %s with %lu\r\n",
|
|
ptsName,
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
|
|
dwErr = AddInfSectionToRuleList(&ic, &g_crlIncludeWildcards, TRUE);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD ProcessDelFiles(HINF hi, const TCHAR *ptsName)
|
|
{
|
|
DWORD dwErr;
|
|
INFCONTEXT ic;
|
|
|
|
if (!SetupFindFirstLine(hi,
|
|
ptsName,
|
|
NULL,
|
|
&ic))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_SECTION_NAME_NOT_FOUND, ptsName);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupFindFirstLine failed on section %s with %lu\r\n",
|
|
ptsName,
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
|
|
dwErr = AddInfSectionToRuleList(&ic, &g_crlExcludeWildcards, FALSE);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
DWORD ProcessSysFiles(HINF hi, const TCHAR *ptsName)
|
|
{
|
|
DWORD dwErr;
|
|
INFCONTEXT ic;
|
|
|
|
if (!SetupFindFirstLine(hi,
|
|
ptsName,
|
|
NULL,
|
|
&ic))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_SECTION_NAME_NOT_FOUND, ptsName);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupFindFirstLine failed on section %s with %lu\r\n",
|
|
ptsName,
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
|
|
LONG cLines = SetupGetLineCount(hi,
|
|
ptsName);
|
|
if (cLines == -1)
|
|
{
|
|
//Error
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Couldn't get line count for System Files section\r\n");
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
g_sfl.SetInitialSize(cLines);
|
|
|
|
|
|
TCHAR buf[MAX_PATH + 1];
|
|
TCHAR bufMacro[MAX_PATH + 1];
|
|
TCHAR *ptsFinalName;
|
|
|
|
do
|
|
{
|
|
DWORD cFields;
|
|
cFields = SetupGetFieldCount(&ic);
|
|
|
|
if (cFields != 1)
|
|
{
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Sys file line contains multiple fields\r\n");
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (!SetupGetStringField(&ic,
|
|
1,
|
|
buf,
|
|
MAX_PATH + 1,
|
|
NULL))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupGetStringField returned %lu\r\n",
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
|
|
dwErr = g_csd.ExpandMacro(buf, bufMacro, &ptsFinalName, TRUE);
|
|
if (dwErr)
|
|
return dwErr;
|
|
|
|
//Add the name to the sys file list
|
|
dwErr = g_sfl.AddName(ptsFinalName);
|
|
if (dwErr)
|
|
return dwErr;
|
|
|
|
} while (SetupFindNextLine(&ic, &ic));
|
|
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
DWORD ParseInputFile(HINF hi)
|
|
{
|
|
DWORD dwErr;
|
|
INFCONTEXT ic;
|
|
|
|
if (!SetupFindFirstLine(hi,
|
|
EXTENSION_SECTION,
|
|
NULL,
|
|
&ic))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile,
|
|
IDS_SECTION_NAME_NOT_FOUND,
|
|
EXTENSION_SECTION);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupFindFirstLine failed with %lu\r\n", dwErr);
|
|
return dwErr;
|
|
}
|
|
|
|
do
|
|
{
|
|
DWORD cFields;
|
|
cFields = SetupGetFieldCount(&ic);
|
|
TCHAR buf[MAX_PATH + 1];
|
|
|
|
if (!SetupGetStringField(&ic,
|
|
0,
|
|
buf,
|
|
MAX_PATH + 1,
|
|
NULL))
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupGetStringField failed with %lu\r\n",
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
|
|
if (_tcsicmp(buf, COPYFILES_LABEL) == 0)
|
|
{
|
|
//Add files in all sections to the include list
|
|
for (DWORD j = 1; j < cFields + 1; j++)
|
|
{
|
|
if (!SetupGetStringField(&ic,
|
|
j,
|
|
buf,
|
|
MAX_PATH + 1,
|
|
NULL))
|
|
{
|
|
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupGetStringField failed with %lu\r\n",
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
dwErr = ProcessCopyFiles(hi, buf);
|
|
if (dwErr != 0)
|
|
return dwErr;
|
|
}
|
|
}
|
|
else if (_tcsicmp(buf, DELFILES_LABEL) == 0)
|
|
{
|
|
//Add files in all sections to the include list
|
|
for (DWORD j = 1; j < cFields + 1; j++)
|
|
{
|
|
if (!SetupGetStringField(&ic,
|
|
j,
|
|
buf,
|
|
MAX_PATH + 1,
|
|
NULL))
|
|
{
|
|
|
|
dwErr = GetLastError();
|
|
Win32PrintfResource(LogFile, IDS_INF_ERROR);
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"SetupGetStringField failed with %lu\r\n",
|
|
dwErr);
|
|
return dwErr;
|
|
}
|
|
dwErr = ProcessDelFiles(hi, buf);
|
|
if (dwErr != 0)
|
|
return dwErr;
|
|
}
|
|
}
|
|
}
|
|
while (SetupFindNextLine(&ic, &ic));
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
DWORD OutputSectionList(CSection *pcs)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
CSection *pcsTemp = pcs;
|
|
|
|
Win32Printf(OutputFile, "[%s]\r\n", COPYFILE_SECTION);
|
|
while (pcsTemp != NULL)
|
|
{
|
|
if (pcsTemp->GetNameCount() != 0)
|
|
Win32Printf(OutputFile,"%s\r\n", pcsTemp->GetSectionTitle());
|
|
pcsTemp = pcsTemp->GetNextSection();
|
|
}
|
|
|
|
Win32Printf(OutputFile, "\r\n");
|
|
|
|
pcsTemp = pcs;
|
|
while (pcsTemp != NULL)
|
|
{
|
|
if (pcsTemp->GetNameCount() != 0)
|
|
{
|
|
Win32Printf(OutputFile,"[%s]\r\n", pcsTemp->GetSectionTitle());
|
|
|
|
for (ULONG i = 0; i < pcsTemp->GetNameCount(); i++)
|
|
{
|
|
Win32Printf(OutputFile,"\"%s\"", pcsTemp->GetFullFileName(i));
|
|
if (pcsTemp->GetDestination(i) != NULL)
|
|
{
|
|
Win32Printf(OutputFile,",\"%s\"", pcsTemp->GetDestination(i));
|
|
}
|
|
Win32Printf(OutputFile, "\r\n");
|
|
if ((dwErr = CopyAFile(pcsTemp->GetSectionPath(),
|
|
pcsTemp->GetFullFileName(i))))
|
|
{
|
|
return dwErr;
|
|
}
|
|
}
|
|
Win32Printf(OutputFile, "\r\n");
|
|
}
|
|
pcsTemp = pcsTemp->GetNextSection();
|
|
}
|
|
|
|
pcsTemp = pcs;
|
|
|
|
DWORD dwSection = 10000;
|
|
Win32Printf(OutputFile, "[%s]\r\n", DESTINATIONDIRS_SECTION);
|
|
while (pcsTemp != NULL)
|
|
{
|
|
if (pcsTemp->GetNameCount() != 0)
|
|
{
|
|
Win32Printf(OutputFile,"%s=%lu\r\n",
|
|
pcsTemp->GetSectionTitle(),
|
|
dwSection++);
|
|
}
|
|
pcsTemp = pcsTemp->GetNextSection();
|
|
}
|
|
Win32Printf(OutputFile,"\r\n");
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
void OutputSpecialDirectoryList(CSpecialDirectory *psd)
|
|
{
|
|
Win32Printf(OutputFile, "[%s]\r\n", SPECIALDIRS_SECTION);
|
|
for (ULONG i = 0; i < psd->GetDirectoryCount(); i++)
|
|
{
|
|
if (psd->GetDirectoryPath(i) != NULL)
|
|
{
|
|
Win32Printf(OutputFile,
|
|
"%s=\"%s\"\r\n",
|
|
psd->GetDirectoryName(i),
|
|
psd->GetDirectoryPath(i));
|
|
}
|
|
}
|
|
Win32Printf(OutputFile, "\r\n");
|
|
}
|
|
|
|
|
|
DWORD ScanFiles()
|
|
{
|
|
DWORD dwErr;
|
|
DWORD dwDrives;
|
|
TCHAR tcDriveName[5];
|
|
|
|
|
|
//If we're copying files, grab all the rules from the input file
|
|
//Otherwise, we'll only take things specified by PickUpThisFile
|
|
if (CopyFiles)
|
|
{
|
|
dwErr = ParseInputFile(InputInf);
|
|
|
|
if (dwErr)
|
|
return dwErr;
|
|
}
|
|
|
|
dwDrives = GetLogicalDrives();
|
|
|
|
for (int i = 0; i < 26; i++)
|
|
{
|
|
if (dwDrives & 1)
|
|
{
|
|
tcDriveName[0] = (TCHAR)'A' + i;
|
|
tcDriveName[1] = (TCHAR)':';
|
|
tcDriveName[2] = (TCHAR)'\\';
|
|
tcDriveName[3] = 0;
|
|
|
|
|
|
UINT uiDriveType = GetDriveType(tcDriveName);
|
|
TCHAR *tcDriveTypeName;
|
|
|
|
if (uiDriveType == DRIVE_FIXED)
|
|
{
|
|
ProcessFileTree(tcDriveName, NULL, 0);
|
|
}
|
|
else if (uiDriveType == DRIVE_NO_ROOT_DIR)
|
|
{
|
|
if (Verbose)
|
|
Win32Printf(STDERR,
|
|
"Warning: GetDriveType returned "
|
|
"DRIVE_NO_ROOT_DIR for drive %s\r\n",
|
|
tcDriveName);
|
|
}
|
|
}
|
|
dwDrives = dwDrives >> 1;
|
|
}
|
|
|
|
dwErr = OutputSectionList(g_pcsSectionList);
|
|
if (dwErr)
|
|
return dwErr;
|
|
|
|
OutputSpecialDirectoryList(&g_csd);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|