1075 lines
33 KiB
C
1075 lines
33 KiB
C
#include "precomp.h"
|
|
#pragma hdrstop
|
|
/* File: list.c */
|
|
/*************************************************************************
|
|
** Common: Copy List building commands.
|
|
**************************************************************************/
|
|
|
|
|
|
//
|
|
// BUGBUG Ramonsa - pclnTail points to the end of the copy list, and it is
|
|
// used (and updated) when adding items to the list.
|
|
// However, it is NOT updated when removing elements from
|
|
// the list. This means that once an element is removed,
|
|
// the list gets corrupted and it is not safe to add
|
|
// new elements to the list.
|
|
//
|
|
|
|
extern PSTF APIENTRY PstfAlloc(VOID);
|
|
extern BOOL APIENTRY FFreePstf(PSTF);
|
|
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Adds all files in the section to the current copy list with
|
|
** the given source and destination paths.
|
|
** Arguments:
|
|
** szSect: non-Null, non-empty string which specifies the INF section
|
|
** to include.
|
|
** szSrcDir: non-Null, non-empty valid dir string (drive, colon, root
|
|
** slash, and optional subdirs) for the location to find the source
|
|
** files.
|
|
** szDstDir: non-Null, non-empty valid dir string for the location to
|
|
** write resulting files.
|
|
** Notes:
|
|
** Requires that the current INF structure was initialized with a
|
|
** successful call to GrcOpenInf().
|
|
** Requires that the Symbol Table was initialized with a successful
|
|
** call to FInitSymTab() and that the file-description-option-symbols
|
|
** (eg STF_BACKUP) are set appropriately.
|
|
** Returns:
|
|
** grcOkay if successful.
|
|
** grcINFBadFDLine if any lines had invalid formats.
|
|
** grcINFMissingLine if section line not found.
|
|
** grcINFMissingSection if section not found
|
|
** grcOutOfMemory if we ran out of memory while trying to add to the list.
|
|
** grcNotOkay otherwise.
|
|
**
|
|
**************************************************************************/
|
|
GRC APIENTRY GrcAddSectionFilesToCopyList(szSect, szSrcDir,
|
|
szDstDir)
|
|
SZ szSect;
|
|
SZ szSrcDir;
|
|
SZ szDstDir;
|
|
{
|
|
POER poer;
|
|
GRC grc;
|
|
SZ szSrcDirNew;
|
|
SZ szDstDirNew;
|
|
PINFPERMINFO pPermInfo = pLocalInfPermInfo();
|
|
|
|
ChkArg(szSect != (SZ)NULL && *szSect != '\0', 1, grcNotOkay);
|
|
// ChkArg(szSrcDir != (SZ)NULL && FValidDir(szSrcDir), 2, grcNotOkay);
|
|
ChkArg(szSrcDir != (SZ)NULL, 2, grcNotOkay);
|
|
ChkArg(szDstDir != (SZ)NULL && FValidDir(szDstDir), 3, grcNotOkay);
|
|
|
|
PreCondSymTabInit(grcNotOkay);
|
|
PreCondInfOpen(grcNotOkay);
|
|
|
|
if ((szSrcDirNew = SzDupl(szSrcDir)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
if (!FAddSzToFreeTable(szSrcDirNew, pPermInfo ))
|
|
{
|
|
SFree(szSrcDirNew);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((szDstDirNew = SzDupl(szDstDir)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
if (!FAddSzToFreeTable(szDstDirNew, pPermInfo))
|
|
{
|
|
SFree(szDstDirNew);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((poer = PoerAlloc()) == (POER)NULL)
|
|
return(grcOutOfMemory);
|
|
|
|
if ((grc = GrcFillPoerFromSymTab(poer)) == grcOkay)
|
|
grc = GrcAddSectionFilesToCList(sfoCopy, szSect, (SZ)NULL, szSrcDirNew,
|
|
szDstDirNew, poer);
|
|
|
|
EvalAssert(FSetPoerToEmpty(poer));
|
|
EvalAssert(FFreePoer(poer));
|
|
|
|
return(grc);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Adds the file identified by the key in given section to
|
|
** the copy list.
|
|
** Arguments:
|
|
** szSect: non-Null, non-empty string which specifies the INF section
|
|
** to include.
|
|
** szKey: non-Null, non-empty string to search for as a key in the
|
|
** specified section.
|
|
** szSrcDir: non-Null, non-empty valid dir string (drive, colon, root
|
|
** slash, and optional subdirs) for the location to find the source
|
|
** files.
|
|
** szDstDir: non-Null, non-empty valid dir string for the location to
|
|
** write resulting files.
|
|
** Notes:
|
|
** Requires that the current INF structure was initialized with a
|
|
** successful call to GrcOpenInf().
|
|
** Requires that the Symbol Table was initialized with a successful
|
|
** call to FInitSymTab() and that the file-description-option-symbols
|
|
** (eg STF_BACKUP) are set appropriately.
|
|
** Returns:
|
|
** grcOkay if successful.
|
|
** grcINFBadFDLine if line had an invalid format.
|
|
** grcINFMissingLine if section line not found.
|
|
** grcINFMissingSection if section not found
|
|
** grcOutOfMemory if we ran out of memory while trying to add to the list.
|
|
** grcNotOkay otherwise.
|
|
**
|
|
**************************************************************************/
|
|
GRC APIENTRY GrcAddSectionKeyFileToCopyList(szSect, szKey,
|
|
szSrcDir, szDstDir)
|
|
SZ szSect;
|
|
SZ szKey;
|
|
SZ szSrcDir;
|
|
SZ szDstDir;
|
|
{
|
|
POER poer;
|
|
GRC grc;
|
|
SZ szSrcDirNew;
|
|
SZ szDstDirNew;
|
|
PINFPERMINFO pPermInfo = pLocalInfPermInfo();
|
|
|
|
ChkArg(szSect != (SZ)NULL && *szSect != '\0', 1, grcNotOkay);
|
|
ChkArg(szKey != (SZ)NULL && *szKey != '\0', 2, grcNotOkay);
|
|
ChkArg(szSrcDir != (SZ)NULL, 3, grcNotOkay);
|
|
ChkArg(szDstDir != (SZ)NULL && FValidDir(szDstDir), 4, grcNotOkay);
|
|
|
|
PreCondSymTabInit(grcNotOkay);
|
|
PreCondInfOpen(grcNotOkay);
|
|
|
|
if ((szSrcDirNew = SzDupl(szSrcDir)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
if (!FAddSzToFreeTable(szSrcDirNew, pPermInfo))
|
|
{
|
|
SFree(szSrcDirNew);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((szDstDirNew = SzDupl(szDstDir)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
if (!FAddSzToFreeTable(szDstDirNew, pPermInfo))
|
|
{
|
|
SFree(szDstDirNew);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((poer = PoerAlloc()) == (POER)NULL)
|
|
return(grcOutOfMemory);
|
|
|
|
if ((grc = GrcFillPoerFromSymTab(poer)) == grcOkay)
|
|
grc = GrcAddSectionFilesToCList(sfoCopy, szSect, szKey, szSrcDirNew,
|
|
szDstDirNew, poer);
|
|
|
|
EvalAssert(FSetPoerToEmpty(poer));
|
|
EvalAssert(FFreePoer(poer));
|
|
|
|
return(grc);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Adds the Nth file in given section to the current copy list.
|
|
** Arguments:
|
|
** szSect: non-Null, non-empty string which specifies the INF section
|
|
** to include.
|
|
** nLine: positive integer specifying which line of the above section
|
|
** to include in the list.
|
|
** szSrcDir: non-Null, non-empty valid dir string (drive, colon, root
|
|
** slash, and optional subdirs) for the location to find the source
|
|
** files.
|
|
** szDstDir: non-Null, non-empty valid dir string for the location to
|
|
** write resulting files.
|
|
** Notes:
|
|
** Requires that the current INF structure was initialized with a
|
|
** successful call to GrcOpenInf().
|
|
** Requires that the Symbol Table was initialized with a successful
|
|
** call to FInitSymTab() and that the file-description-option-symbols
|
|
** (eg STF_BACKUP) are set appropriately.
|
|
** Returns:
|
|
** grcOkay if successful.
|
|
** grcINFBadFDLine if line did not exist or had an invalid format.
|
|
** grcINFMissingLine if section line not found.
|
|
** grcINFMissingSection if section not found.
|
|
** grcOutOfMemory if we ran out of memory while trying to add to the list.
|
|
** grcNotOkay otherwise.
|
|
**
|
|
**************************************************************************/
|
|
GRC APIENTRY GrcAddNthSectionFileToCopyList(SZ szSect,
|
|
UINT nLine,
|
|
SZ szSrcDir,
|
|
SZ szDstDir)
|
|
{
|
|
POER poer;
|
|
GRC grc;
|
|
SZ szSrcDirNew;
|
|
SZ szDstDirNew;
|
|
INT Line;
|
|
PINFPERMINFO pPermInfo = pLocalInfPermInfo();
|
|
|
|
ChkArg(szSect != (SZ)NULL && *szSect != '\0', 1, grcNotOkay);
|
|
ChkArg(nLine > 0, 2, grcNotOkay);
|
|
ChkArg(szSrcDir != (SZ)NULL, 3, grcNotOkay);
|
|
ChkArg(szDstDir != (SZ)NULL && FValidDir(szDstDir), 4, grcNotOkay);
|
|
|
|
PreCondSymTabInit(grcNotOkay);
|
|
PreCondInfOpen(grcNotOkay);
|
|
|
|
if ((szSrcDirNew = SzDupl(szSrcDir)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
if (!FAddSzToFreeTable(szSrcDirNew, pPermInfo))
|
|
{
|
|
SFree(szSrcDirNew);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((szDstDirNew = SzDupl(szDstDir)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
if (!FAddSzToFreeTable(szDstDirNew, pPermInfo))
|
|
{
|
|
SFree(szDstDirNew);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((poer = PoerAlloc()) == (POER)NULL)
|
|
return(grcOutOfMemory);
|
|
|
|
if ((grc = GrcFillPoerFromSymTab(poer)) == grcOkay){
|
|
if ( FindInfSectionLine(szSect) == -1 )
|
|
grc = grcINFMissingSection;
|
|
else if ((Line = FindNthLineFromInfSection(szSect, nLine)) != -1)
|
|
grc = GrcAddLineToCList(Line,sfoCopy, szSrcDirNew, szDstDirNew, poer);
|
|
else
|
|
grc = grcINFMissingLine;
|
|
}
|
|
|
|
EvalAssert(FSetPoerToEmpty(poer));
|
|
EvalAssert(FFreePoer(poer));
|
|
|
|
return(grc);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Adds a section of file lines to the Copy List.
|
|
** Arguments:
|
|
** sfo: currently unused - reserved for future use.
|
|
** szSect: non-Null, non-empty string which specifies the INF section
|
|
** to include.
|
|
** szKey: string to search for as a key in szSect. If this is Null
|
|
** then all the lines of szSect are included.
|
|
** szSrcDir: non-Null, non-empty valid dir string (drive, colon, root
|
|
** slash, and optional subdirs) for the location to find the source
|
|
** files.
|
|
** szDstDir: non-Null, non-empty valid dir string for the location to
|
|
** write resulting files.
|
|
** poer: non-Null record of default options to be used if the
|
|
** particular INF line does not explicitly specify an option.
|
|
** Notes:
|
|
** Requires that the current INF structure was initialized with a
|
|
** successful call to GrcOpenInf().
|
|
** Requires that the Symbol Table was initialized with a successful
|
|
** call to FInitSymTab().
|
|
** Returns:
|
|
** grcOkay if successful.
|
|
** grcINFBadFDLine if any lines had invalid formats.
|
|
** grcINFMissingSection if section not found.
|
|
** grcINFMissingLine if section line not found
|
|
** grcOutOfMemory if we ran out of memory while trying to add to the list.
|
|
** grcNotOkay otherwise.
|
|
**
|
|
**************************************************************************/
|
|
GRC APIENTRY GrcAddSectionFilesToCList(SFO sfo,
|
|
SZ szSect,
|
|
SZ szKey,
|
|
SZ szSrcDir,
|
|
SZ szDstDir,
|
|
POER poer)
|
|
{
|
|
GRC grc;
|
|
INT Line;
|
|
|
|
ChkArg(szSect != (SZ)NULL && *szSect != '\0', 2, grcNotOkay);
|
|
ChkArg(szSrcDir != (SZ)NULL, 4, grcNotOkay);
|
|
ChkArg(szDstDir != (SZ)NULL && FValidDir(szDstDir), 5, grcNotOkay);
|
|
ChkArg(poer != (POER)NULL && FValidPoer(poer), 6, grcNotOkay);
|
|
|
|
PreCondSymTabInit(grcNotOkay);
|
|
PreCondInfOpen(grcNotOkay);
|
|
|
|
Unused(sfo);
|
|
|
|
if (szKey != (SZ)NULL)
|
|
{
|
|
if ((Line = FindLineFromInfSectionKey(szSect, szKey)) != -1)
|
|
grc = GrcAddLineToCList(Line, sfo, szSrcDir, szDstDir, poer);
|
|
else
|
|
grc = grcINFMissingLine;
|
|
}
|
|
else if ( FindInfSectionLine(szSect) == -1 )
|
|
grc = grcINFMissingSection;
|
|
else if (CKeysFromInfSection(szSect, fTrue) == 0)
|
|
grc = grcOkay;
|
|
else if ((Line = FindFirstLineFromInfSection(szSect)) == -1)
|
|
grc = grcINFMissingLine;
|
|
else
|
|
{
|
|
while ((grc = GrcAddLineToCList(Line, sfo, szSrcDir, szDstDir, poer)) ==
|
|
grcOkay &&
|
|
((Line = FindNextLineFromInf(Line)) != -1))
|
|
;
|
|
}
|
|
|
|
return(grc);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Adds the given INF file line to the Copy List.
|
|
** Arguments:
|
|
** sfo: currently unused - reserved for future use.
|
|
** szSrcDir: non-Null, non-empty valid dir string (drive, colon, root
|
|
** slash, and optional subdirs) for the location to find the source
|
|
** files.
|
|
** szDstDir: non-Null, non-empty valid dir string for the location to
|
|
** write resulting files.
|
|
** poer: non-Null record of default options to be used if the
|
|
** particular INF line does not explicitly specify an option.
|
|
** Notes:
|
|
** Requires that the current INF structure was initialized with a
|
|
** successful call to GrcOpenInf() and that the current INF read
|
|
** location is defined.
|
|
** Requires that the Symbol Table was initialized with a successful
|
|
** call to FInitSymTab().
|
|
** Returns:
|
|
** grcOkay if successful.
|
|
** grcINFBadFDLine if any lines had invalid formats.
|
|
** grcOutOfMemory if we ran out of memory while trying to add to the list.
|
|
** grcNotOkay otherwise.
|
|
** Assumes:
|
|
** Current .INF line is a section file line.
|
|
** No circular list-include-statements.
|
|
**
|
|
**************************************************************************/
|
|
GRC APIENTRY GrcAddLineToCList(INT Line,
|
|
SFO sfo,
|
|
SZ szSrcDir,
|
|
SZ szDstDir,
|
|
POER poer)
|
|
{
|
|
ChkArg(szSrcDir != (SZ)NULL, 1, grcNotOkay);
|
|
ChkArg(szDstDir != (SZ)NULL && FValidDir(szDstDir), 2, grcNotOkay);
|
|
ChkArg(poer != (POER)NULL && FValidPoer(poer), 3, grcNotOkay);
|
|
|
|
PreCondSymTabInit(grcNotOkay);
|
|
PreCondInfOpen(grcNotOkay);
|
|
|
|
Unused(sfo);
|
|
|
|
if (FListIncludeStatementLine(Line))
|
|
{
|
|
SZ szSect = (SZ)NULL;
|
|
SZ szKey = (SZ)NULL;
|
|
GRC grc;
|
|
|
|
if ((grc = GrcGetListIncludeSectionLine(Line, &szSect, &szKey)) != grcOkay)
|
|
return(grc);
|
|
|
|
Assert(szSect != (SZ)NULL && szSect != '\0');
|
|
|
|
grc = GrcAddSectionFilesToCList(sfoCopy, szSect, szKey, szSrcDir,
|
|
szDstDir, poer);
|
|
|
|
SFree(szSect);
|
|
|
|
if (szKey != (SZ)NULL)
|
|
SFree(szKey);
|
|
|
|
return(grc);
|
|
}
|
|
else
|
|
{
|
|
PSFD psfd;
|
|
GRC grc;
|
|
PINFPERMINFO pPermInfo = pLocalInfPermInfo();
|
|
|
|
if ((grc = GrcGetSectionFileLine(Line, &psfd, poer)) != grcOkay)
|
|
return(grc);
|
|
if (!FAddNewSzsInPoerToFreeTable(&(psfd->oer), poer, pPermInfo))
|
|
{
|
|
EvalAssert(FFreePsfd(psfd));
|
|
return(grcOutOfMemory);
|
|
}
|
|
if ((grc = GrcAddPsfdToCList(szSrcDir, szDstDir, psfd)) != grcOkay)
|
|
{
|
|
EvalAssert(FSetPoerToEmpty(&(psfd->oer)));
|
|
EvalAssert(FFreePsfd(psfd));
|
|
return(grc);
|
|
}
|
|
|
|
Assert(FValidCopyList( pPermInfo ));
|
|
}
|
|
|
|
return(grcOkay);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Adds an Inf Section File Description record to the Copy List.
|
|
** Arguments:
|
|
** szSrcDir: non-Null, non-empty valid dir string (drive, colon, root
|
|
** slash, and optional subdirs) for the location to find the source
|
|
** files.
|
|
** szDstDir: non-Null, non-empty valid dir string for the location to
|
|
** write resulting files.
|
|
** psfd: non-Null record with all fields and options instantiated.
|
|
** Returns:
|
|
** grcOkay if successful.
|
|
** grcOutOfMemory if we ran out of memory while trying to add to the list.
|
|
** grcNotOkay otherwise.
|
|
**
|
|
**************************************************************************/
|
|
GRC APIENTRY GrcAddPsfdToCList(szSrcDir, szDstDir, psfd)
|
|
SZ szSrcDir;
|
|
SZ szDstDir;
|
|
PSFD psfd;
|
|
{
|
|
PCLN pcln;
|
|
|
|
ChkArg(szSrcDir != (SZ)NULL, 1, grcNotOkay);
|
|
ChkArg(szDstDir != (SZ)NULL && FValidDir(szDstDir), 2, grcNotOkay);
|
|
ChkArg(psfd != (PSFD)NULL && FValidPsfd(psfd), 3, grcNotOkay);
|
|
|
|
if ((pcln = PclnAlloc()) == (PCLN)NULL)
|
|
return(grcOutOfMemory);
|
|
|
|
pcln->szSrcDir = szSrcDir;
|
|
pcln->szDstDir = szDstDir;
|
|
pcln->psfd = psfd;
|
|
|
|
pcln->pclnNext = *(pLocalInfPermInfo()->ppclnTail);
|
|
*(pLocalInfPermInfo()->ppclnTail) = pcln;
|
|
pLocalInfPermInfo()->ppclnTail = &(pcln->pclnNext);
|
|
|
|
return(grcOkay);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Free all nodes in Copy List, restore List to initial empty state,
|
|
** and free all shared strings.
|
|
** Arguments:
|
|
** none
|
|
** Returns:
|
|
** Always returns fTrue.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FFreeCopyList( PINFPERMINFO pPermInfo )
|
|
{
|
|
PreCondition(FValidCopyList( pPermInfo ), fFalse);
|
|
|
|
while (pPermInfo->pclnHead != (PCLN)NULL)
|
|
{
|
|
PCLN pcln = pPermInfo->pclnHead;
|
|
|
|
pPermInfo->pclnHead = pcln->pclnNext;
|
|
EvalAssert(FFreePcln(pcln));
|
|
}
|
|
|
|
pPermInfo->ppclnTail = &(pPermInfo->pclnHead);
|
|
|
|
EvalAssert(FFreeFreeTable( pPermInfo ));
|
|
|
|
return(fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Allocates a Copy List Node.
|
|
** Arguments:
|
|
** none
|
|
** Returns:
|
|
** Returns pcln if successful, NULL if not (i.e. out of mem.)
|
|
**
|
|
**************************************************************************/
|
|
PCLN APIENTRY PclnAlloc()
|
|
{
|
|
PCLN pcln;
|
|
|
|
if ((pcln = (PCLN)SAlloc((CB)sizeof(CLN))) != (PCLN)NULL)
|
|
{
|
|
pcln->szSrcDir = (SZ)NULL;
|
|
pcln->szDstDir = (SZ)NULL;
|
|
pcln->psfd = (PSFD)NULL;
|
|
pcln->pclnNext = (PCLN)NULL;
|
|
}
|
|
|
|
return(pcln);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Frees copy list node.
|
|
** Arguments:
|
|
** pcln: non-Null pcln structure to be freed.
|
|
** Returns:
|
|
** fTrue always.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FFreePcln(pcln)
|
|
PCLN pcln;
|
|
{
|
|
ChkArg(pcln != (PCLN)NULL, 1, fFalse);
|
|
|
|
if (pcln->psfd != (PSFD)NULL)
|
|
{
|
|
EvalAssert(FSetPoerToEmpty(&((pcln->psfd)->oer)));
|
|
EvalAssert(FFreePsfd(pcln->psfd));
|
|
}
|
|
|
|
SFree(pcln);
|
|
|
|
return(fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Prints the contents of the Copy List to a specified file.
|
|
** Arguments:
|
|
** pfh: non-Null valid file pointer which has been opened for writing.
|
|
** pcln: non-Null Copy List node to print.
|
|
** Returns:
|
|
** fTrue if successful, fFalse if not.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FPrintPcln(pfh, pcln)
|
|
PFH pfh;
|
|
PCLN pcln;
|
|
{
|
|
BOOL fOkay = fTrue;
|
|
|
|
ChkArg(pfh != (PFH)NULL, 1, fFalse);
|
|
ChkArg(pcln != (PCLN)NULL, 2, fFalse);
|
|
|
|
if (!FWriteSzToFile(pfh,"\r\nszSrcDir: "))
|
|
fOkay = fFalse;
|
|
if (!FWriteSzToFile(pfh, pcln->szSrcDir))
|
|
fOkay = fFalse;
|
|
if (!FWriteSzToFile(pfh,"\r\nszDstDir: "))
|
|
fOkay = fFalse;
|
|
if (!FWriteSzToFile(pfh, pcln->szDstDir))
|
|
fOkay = fFalse;
|
|
|
|
if (!FPrintPsfd(pfh, pcln->psfd))
|
|
fOkay = fFalse;
|
|
|
|
if (!FWriteSzToFile(pfh, "\r\n"))
|
|
return(fFalse);
|
|
|
|
return(fOkay);
|
|
}
|
|
|
|
|
|
#if DBG
|
|
/*
|
|
** Purpose:
|
|
** Validates a Copy List Node.
|
|
** Arguments:
|
|
** pcln: non-Null Copy List Node to validate.
|
|
** Returns:
|
|
** fTrue if valid; fFalse otherwise.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FValidPcln(pcln)
|
|
PCLN pcln;
|
|
{
|
|
if (pcln->szSrcDir == (SZ)NULL ||
|
|
pcln->szDstDir == (SZ)NULL ||
|
|
!FValidDir(pcln->szDstDir) ||
|
|
!FValidPsfd(pcln->psfd))
|
|
return(fFalse);
|
|
|
|
return(fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Validates the entire Copy List.
|
|
** Arguments:
|
|
** none
|
|
** Returns:
|
|
** fTrue if valid; fFalse otherwise.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FValidCopyList( PINFPERMINFO pPermInfo )
|
|
{
|
|
PCLN pcln = pPermInfo->pclnHead;
|
|
|
|
while (pcln != NULL) {
|
|
|
|
if (!FValidPcln(pcln)) {
|
|
return(fFalse);
|
|
}
|
|
pcln = pcln->pclnNext;
|
|
}
|
|
|
|
if ( pPermInfo->ppclnTail != (PPCLN)NULL &&
|
|
*(pPermInfo->ppclnTail) != pcln) {
|
|
return(fFalse);
|
|
}
|
|
|
|
return(fTrue);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Purpose:
|
|
** Initializes the Shared String Table for strings that need to be freed
|
|
** when the Copy List is freed.
|
|
** Arguments:
|
|
** none
|
|
** Returns:
|
|
** fTrue if successful; fFalse otherwise.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FInitFreeTable( PINFPERMINFO pPermInfo)
|
|
{
|
|
return( pPermInfo->pstfHead == (PSTF)NULL);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Adds a shared string to the String-Table for later Freeing.
|
|
** Arguments:
|
|
** sz: non-Null shared string to be stored.
|
|
** Returns:
|
|
** fTrue if successful; fFalse otherwise.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FAddSzToFreeTable( SZ sz, PINFPERMINFO pPermInfo )
|
|
{
|
|
ChkArg(sz != (SZ)NULL, 1, fFalse);
|
|
|
|
if ( (pPermInfo->pstfHead == (PSTF)NULL) ||
|
|
(pPermInfo->pstfHead->cszFree == 0) ) {
|
|
|
|
PSTF pstfNew;
|
|
|
|
if ((pstfNew = PstfAlloc()) == (PSTF)NULL)
|
|
return(fFalse);
|
|
|
|
pstfNew->pstfNext = pPermInfo->pstfHead;
|
|
pPermInfo->pstfHead = pstfNew;
|
|
}
|
|
|
|
Assert( pPermInfo->pstfHead != (PSTF)NULL &&
|
|
pPermInfo->pstfHead->cszFree > 0);
|
|
|
|
pPermInfo->pstfHead->rgsz[--(pPermInfo->pstfHead->cszFree)] = sz;
|
|
|
|
return(fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Adds all the strings that are new in an OER record into the shared
|
|
** Strings Table for later freeing.
|
|
** Arguments:
|
|
** poerNew: non-Null OER for the new values.
|
|
** poer: non-Null OER of old values.
|
|
** Returns:
|
|
** fTrue if each changed SZ value can be stored in the shared String-Table
|
|
** for later Freeing; fFalse otherwise.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FAddNewSzsInPoerToFreeTable(poerNew, poer, pPermInfo)
|
|
POER poerNew;
|
|
POER poer;
|
|
PINFPERMINFO pPermInfo;
|
|
{
|
|
ChkArg(poerNew != (POER)NULL && FValidPoer(poerNew), 1, fFalse);
|
|
ChkArg(poer != (POER)NULL && FValidPoer(poer), 2, fFalse);
|
|
|
|
if (poerNew->szDescription != (SZ)NULL &&
|
|
poerNew->szDescription != poer->szDescription &&
|
|
!FAddSzToFreeTable(poerNew->szDescription, pPermInfo))
|
|
return(fFalse);
|
|
|
|
if (poerNew->szDate != (SZ)NULL &&
|
|
poerNew->szDate != poer->szDate &&
|
|
!FAddSzToFreeTable(poerNew->szDate, pPermInfo))
|
|
return(fFalse);
|
|
|
|
if (poerNew->szDest != (SZ)NULL &&
|
|
poerNew->szDest != poer->szDest &&
|
|
!FAddSzToFreeTable(poerNew->szDest, pPermInfo))
|
|
return(fFalse);
|
|
|
|
if (poerNew->szRename != (SZ)NULL &&
|
|
poerNew->szRename != poer->szRename &&
|
|
!FAddSzToFreeTable(poerNew->szRename, pPermInfo))
|
|
return(fFalse);
|
|
|
|
if (poerNew->szAppend != (SZ)NULL &&
|
|
poerNew->szAppend != poer->szAppend &&
|
|
!FAddSzToFreeTable(poerNew->szAppend, pPermInfo))
|
|
return(fFalse);
|
|
|
|
if (poerNew->szBackup != (SZ)NULL &&
|
|
poerNew->szBackup != poer->szBackup &&
|
|
!FAddSzToFreeTable(poerNew->szBackup, pPermInfo))
|
|
return(fFalse);
|
|
|
|
return(fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Allocates an STF structure.
|
|
** Arguments:
|
|
** none
|
|
** Returns:
|
|
** non-Null STF pointer if successful; Null otherwise.
|
|
**
|
|
**************************************************************************/
|
|
PSTF APIENTRY PstfAlloc(VOID)
|
|
{
|
|
PSTF pstf;
|
|
|
|
if ((pstf = (PSTF)SAlloc((CB)sizeof(STF))) != (PSTF)NULL)
|
|
pstf->cszFree = cszPerStf;
|
|
|
|
return(pstf);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Frees an allocated STF structure.
|
|
** Arguments:
|
|
** pstf: non-Null, allocated STF structure.
|
|
** Returns:
|
|
** fTrue always.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FFreePstf(pstf)
|
|
PSTF pstf;
|
|
{
|
|
USHORT iszToFree;
|
|
|
|
ChkArg(pstf != (PSTF)NULL && pstf->cszFree <= cszPerStf, 1, fFalse);
|
|
|
|
for (iszToFree = pstf->cszFree; iszToFree < cszPerStf; iszToFree++)
|
|
{
|
|
Assert(pstf->rgsz[iszToFree] != (SZ)NULL);
|
|
SFree(pstf->rgsz[iszToFree]);
|
|
}
|
|
|
|
SFree(pstf);
|
|
|
|
return(fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Frees the shared strings in the String-Table and the String-Table
|
|
** itself.
|
|
** Arguments:
|
|
** none
|
|
** Returns:
|
|
** fTrue always.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FFreeFreeTable( PINFPERMINFO pPermInfo )
|
|
{
|
|
while ( pPermInfo->pstfHead != (PSTF)NULL)
|
|
{
|
|
PSTF pstfCur;
|
|
|
|
pstfCur = pPermInfo->pstfHead;
|
|
pPermInfo->pstfHead = pstfCur->pstfNext;
|
|
EvalAssert(FFreePstf(pstfCur));
|
|
}
|
|
|
|
return(fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Initializes an empty OER structure by pulling default values from
|
|
** the Symbol Table. (Examples of symbols are STF_VITAL, STF_ROOT.)
|
|
** Arguments:
|
|
** poer: non-Null OER record to fill.
|
|
** Notes:
|
|
** Requires that the Symbol Table was initialized with a successful
|
|
** call to FInitSymTab().
|
|
** Returns:
|
|
** grcOkay if successful.
|
|
** grcOutOfMemory if out of memory.
|
|
** grcInvalidPoer if the file-description-option-symbols (eg STF_DATE)
|
|
** are not set appropriately.
|
|
** grcNotOkay otherwise.
|
|
**
|
|
**************************************************************************/
|
|
GRC APIENTRY GrcFillPoerFromSymTab(poer)
|
|
POER poer;
|
|
{
|
|
SZ szValue;
|
|
PINFPERMINFO pPermInfo = pLocalInfPermInfo();
|
|
PSTR Pointer;
|
|
|
|
|
|
ChkArg(poer != (POER)NULL, 1, grcNotOkay);
|
|
|
|
PreCondSymTabInit(grcNotOkay);
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_DESCRIPTION")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->szDescription = (SZ)NULL;
|
|
else if ((poer->szDescription = SzDupl(szValue)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
else if (!FAddSzToFreeTable(poer->szDescription, pPermInfo))
|
|
{
|
|
SFree(poer->szDescription);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_VERSION")) == (SZ)NULL)
|
|
poer->ulVerMS = poer->ulVerLS = 0L;
|
|
else if (!FParseVersion(szValue, &(poer->ulVerMS), &(poer->ulVerLS)))
|
|
return(grcInvalidPoer);
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_DATE")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
szValue = "1980-01-01";
|
|
if ((poer->szDate = SzDupl(szValue)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
else if (!FAddSzToFreeTable(poer->szDate, pPermInfo))
|
|
{
|
|
SFree(poer->szDate);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_DEST")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->szDest = (SZ)NULL;
|
|
else if ((poer->szDest = SzDupl(szValue)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
else if (!FAddSzToFreeTable(poer->szDest, pPermInfo))
|
|
{
|
|
SFree(poer->szDest);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_RENAME")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->szRename = (SZ)NULL;
|
|
else if ((poer->szRename = SzDupl(szValue)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
else if (!FAddSzToFreeTable(poer->szRename, pPermInfo ))
|
|
{
|
|
SFree(poer->szRename);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_APPEND")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->szAppend = (SZ)NULL;
|
|
else if ((poer->szAppend = SzDupl(szValue)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
else if (!FAddSzToFreeTable(poer->szAppend, pPermInfo))
|
|
{
|
|
SFree(poer->szAppend);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_BACKUP")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->szBackup = (SZ)NULL;
|
|
else if ((poer->szBackup = SzDupl(szValue)) == (SZ)NULL)
|
|
return(grcOutOfMemory);
|
|
else if (!FAddSzToFreeTable(poer->szBackup, pPermInfo))
|
|
{
|
|
SFree(poer->szBackup);
|
|
return(grcOutOfMemory);
|
|
}
|
|
|
|
//
|
|
// New attribute added which means copy the file only if it exists on
|
|
// the target
|
|
//
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_UPGRADEONLY")) == (SZ)NULL ||
|
|
*szValue == '\0') {
|
|
poer->oef &= ~oefUpgradeOnly;
|
|
}
|
|
else {
|
|
poer->oef |= oefUpgradeOnly;
|
|
}
|
|
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_READONLY")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->oef &= ~oefReadOnly;
|
|
else
|
|
poer->oef |= oefReadOnly;
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_SETTIMESTAMP")) == (SZ)NULL ||
|
|
*szValue != '\0')
|
|
poer->oef |= oefTimeStamp;
|
|
else
|
|
poer->oef &= ~oefTimeStamp;
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_ROOT")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->oef &= ~oefRoot;
|
|
else
|
|
poer->oef |= oefRoot;
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_COPY")) == (SZ)NULL ||
|
|
*szValue != '\0')
|
|
poer->oef |= oefCopy;
|
|
else
|
|
poer->oef &= ~oefCopy;
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_DECOMPRESS")) == (SZ)NULL ||
|
|
*szValue != '\0')
|
|
poer->oef |= oefDecompress;
|
|
else
|
|
poer->oef &= ~oefDecompress;
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_VITAL")) == (SZ)NULL ||
|
|
*szValue != '\0')
|
|
poer->oef |= oefVital;
|
|
else
|
|
poer->oef &= ~oefVital;
|
|
|
|
if( ( (Pointer = SzGetNthFieldFromInfSectionKey("Signature","FileType",1)) == NULL ) ||
|
|
( _stricmp( Pointer, "MICROSOFT_FILE" ) != 0 )
|
|
) {
|
|
poer->oef |= oefThirdPartyFile;
|
|
} else {
|
|
poer->oef &= ~oefThirdPartyFile;
|
|
}
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_UNDO")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->oef &= ~oefUndo;
|
|
else
|
|
poer->oef |= oefUndo;
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_CSDVER")) == (SZ)NULL ||
|
|
*szValue == '\0')
|
|
poer->oef &= ~oefCsdInstall;
|
|
else
|
|
poer->oef |= oefCsdInstall;
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_SIZE")) == (SZ)NULL)
|
|
poer->lSize = 1L;
|
|
else
|
|
poer->lSize = atol(szValue);
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_TIME")) == (SZ)NULL)
|
|
poer->ctuCopyTime = 0;
|
|
else
|
|
poer->ctuCopyTime = (USHORT)atoi(szValue); // 1632
|
|
|
|
if ((szValue = SzFindSymbolValueInSymTab("STF_OVERWRITE")) == (SZ)NULL ||
|
|
CrcStringCompare(szValue, "ALWAYS") == crcEqual)
|
|
poer->owm = owmAlways;
|
|
else if (CrcStringCompare(szValue, "NEVER") == crcEqual)
|
|
poer->owm = owmNever;
|
|
else if (CrcStringCompare(szValue, "OLDER") == crcEqual)
|
|
poer->owm = owmOlder;
|
|
else if (CrcStringCompare(szValue, "VERIFYSOURCEOLDER") == crcEqual)
|
|
poer->owm = owmVerifySourceOlder;
|
|
else if (CrcStringCompare(szValue, "UNPROTECTED") == crcEqual)
|
|
poer->owm = owmUnprotected;
|
|
else
|
|
return(grcInvalidPoer);
|
|
|
|
if (!FValidPoer(poer))
|
|
return(grcInvalidPoer);
|
|
|
|
return(grcOkay);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Resets an OER record to appear empty, so that shared strings are not
|
|
** freed accidently.
|
|
** Arguments:
|
|
** poer: non-Null OER to reset.
|
|
** Returns:
|
|
** fTrue always.
|
|
**
|
|
**************************************************************************/
|
|
BOOL APIENTRY FSetPoerToEmpty(poer)
|
|
POER poer;
|
|
{
|
|
poer->szDescription = (SZ)NULL;
|
|
poer->szDate = (SZ)NULL;
|
|
poer->szDest = (SZ)NULL;
|
|
poer->szRename = (SZ)NULL;
|
|
poer->szAppend = (SZ)NULL;
|
|
poer->szBackup = (SZ)NULL;
|
|
|
|
return(fTrue);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Returns a pointer to pclnHead.
|
|
** Arguments:
|
|
** none
|
|
** Returns:
|
|
** non-Null pointer to pclnHead
|
|
**
|
|
**************************************************************************/
|
|
//PPCLN APIENTRY PpclnHeadList( PINFPERMINFO pPermInfo )
|
|
//{
|
|
// return(&(pPermInfo->pclnHead));
|
|
//}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Returns a pointer to ppclnTail.
|
|
** Arguments:
|
|
** none
|
|
** Returns:
|
|
** non-Null pointer to ppclnTail
|
|
**
|
|
**************************************************************************/
|
|
//PPPCLN APIENTRY PppclnTailList( PINFPERMINFO pPermInfo )
|
|
//{
|
|
// return(&(pPermInfo->ppclnTail));
|
|
//}
|