You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1890 lines
42 KiB
1890 lines
42 KiB
/*
|
|
* path.c - Path ADT module.
|
|
*/
|
|
|
|
|
|
/* Headers
|
|
**********/
|
|
|
|
#include "project.h"
|
|
#pragma hdrstop
|
|
|
|
#include "volume.h"
|
|
|
|
|
|
/* Constants
|
|
************/
|
|
|
|
/* PATHLIST PTRARRAY allocation parameters */
|
|
|
|
#define NUM_START_PATHS (32)
|
|
#define NUM_PATHS_TO_ADD (32)
|
|
|
|
/* PATHLIST string table allocation parameters */
|
|
|
|
#define NUM_PATH_HASH_BUCKETS (67)
|
|
|
|
|
|
/* Types
|
|
********/
|
|
|
|
/* path list */
|
|
|
|
typedef struct _pathlist
|
|
{
|
|
/* array of pointers to PATHs */
|
|
|
|
HPTRARRAY hpa;
|
|
|
|
/* list of volumes */
|
|
|
|
HVOLUMELIST hvl;
|
|
|
|
/* table of path suffix strings */
|
|
|
|
HSTRINGTABLE hst;
|
|
}
|
|
PATHLIST;
|
|
DECLARE_STANDARD_TYPES(PATHLIST);
|
|
|
|
/* path structure */
|
|
|
|
typedef struct _path
|
|
{
|
|
/* reference count */
|
|
|
|
ULONG ulcLock;
|
|
|
|
/* handle to parent volume */
|
|
|
|
HVOLUME hvol;
|
|
|
|
/* handle to path suffix string */
|
|
|
|
HSTRING hsPathSuffix;
|
|
|
|
/* pointer to PATH's parent PATHLIST */
|
|
|
|
PPATHLIST pplParent;
|
|
}
|
|
PATH;
|
|
DECLARE_STANDARD_TYPES(PATH);
|
|
|
|
/* PATH search structure used by PathSearchCmp() */
|
|
|
|
typedef struct _pathsearchinfo
|
|
{
|
|
HVOLUME hvol;
|
|
|
|
LPCTSTR pcszPathSuffix;
|
|
}
|
|
PATHSEARCHINFO;
|
|
DECLARE_STANDARD_TYPES(PATHSEARCHINFO);
|
|
|
|
/* database path list header */
|
|
|
|
typedef struct _dbpathlistheader
|
|
{
|
|
/* number of paths in list */
|
|
|
|
LONG lcPaths;
|
|
}
|
|
DBPATHLISTHEADER;
|
|
DECLARE_STANDARD_TYPES(DBPATHLISTHEADER);
|
|
|
|
/* database path structure */
|
|
|
|
typedef struct _dbpath
|
|
{
|
|
/* old handle to path */
|
|
|
|
HPATH hpath;
|
|
|
|
/* old handle to parent volume */
|
|
|
|
HVOLUME hvol;
|
|
|
|
/* old handle to path suffix string */
|
|
|
|
HSTRING hsPathSuffix;
|
|
}
|
|
DBPATH;
|
|
DECLARE_STANDARD_TYPES(DBPATH);
|
|
|
|
|
|
/***************************** Private Functions *****************************/
|
|
|
|
/* Module Prototypes
|
|
********************/
|
|
|
|
PRIVATE_CODE COMPARISONRESULT PathSortCmp(PCVOID, PCVOID);
|
|
PRIVATE_CODE COMPARISONRESULT PathSearchCmp(PCVOID, PCVOID);
|
|
PRIVATE_CODE BOOL UnifyPath(PPATHLIST, HVOLUME, LPCTSTR, PPATH *);
|
|
PRIVATE_CODE BOOL CreatePath(PPATHLIST, HVOLUME, LPCTSTR, PPATH *);
|
|
PRIVATE_CODE void DestroyPath(PPATH);
|
|
PRIVATE_CODE void UnlinkPath(PCPATH);
|
|
PRIVATE_CODE void LockPath(PPATH);
|
|
PRIVATE_CODE BOOL UnlockPath(PPATH);
|
|
PRIVATE_CODE PATHRESULT TranslateVOLUMERESULTToPATHRESULT(VOLUMERESULT);
|
|
PRIVATE_CODE TWINRESULT WritePath(HCACHEDFILE, PPATH);
|
|
PRIVATE_CODE TWINRESULT ReadPath(HCACHEDFILE, PPATHLIST, HHANDLETRANS, HHANDLETRANS, HHANDLETRANS);
|
|
|
|
#if defined(DEBUG) || defined(VSTF)
|
|
|
|
PRIVATE_CODE BOOL IsValidPCPATHLIST(PCPATHLIST);
|
|
PRIVATE_CODE BOOL IsValidPCPATH(PCPATH);
|
|
|
|
#endif
|
|
|
|
#if defined(DEBUG)
|
|
|
|
PRIVATE_CODE BOOL IsValidPCPATHSEARCHINFO(PCPATHSEARCHINFO);
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
** PathSortCmp()
|
|
**
|
|
** Pointer comparison function used to sort the module array of paths.
|
|
**
|
|
** Arguments: pcpath1 - pointer to first path
|
|
** pcpath2 - pointer to second path
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** The internal paths are sorted by:
|
|
** 1) volume
|
|
** 2) path suffix
|
|
** 3) pointer value
|
|
*/
|
|
PRIVATE_CODE COMPARISONRESULT PathSortCmp(PCVOID pcpath1, PCVOID pcpath2)
|
|
{
|
|
COMPARISONRESULT cr;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pcpath1, CPATH));
|
|
ASSERT(IS_VALID_STRUCT_PTR(pcpath2, CPATH));
|
|
|
|
cr = CompareVolumes(((PCPATH)pcpath1)->hvol,
|
|
((PCPATH)pcpath2)->hvol);
|
|
|
|
if (cr == CR_EQUAL)
|
|
{
|
|
cr = ComparePathStringsByHandle(((PCPATH)pcpath1)->hsPathSuffix,
|
|
((PCPATH)pcpath2)->hsPathSuffix);
|
|
|
|
if (cr == CR_EQUAL)
|
|
cr = ComparePointers(pcpath1, pcpath2);
|
|
}
|
|
|
|
return(cr);
|
|
}
|
|
|
|
|
|
/*
|
|
** PathSearchCmp()
|
|
**
|
|
** Pointer comparison function used to search for a path.
|
|
**
|
|
** Arguments: pcpathsi - pointer to PATHSEARCHINFO describing path to
|
|
** search for
|
|
** pcpath - pointer to path to examine
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** The internal paths are searched by:
|
|
** 1) volume
|
|
** 2) path suffix string
|
|
*/
|
|
PRIVATE_CODE COMPARISONRESULT PathSearchCmp(PCVOID pcpathsi, PCVOID pcpath)
|
|
{
|
|
COMPARISONRESULT cr;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pcpathsi, CPATHSEARCHINFO));
|
|
ASSERT(IS_VALID_STRUCT_PTR(pcpath, CPATH));
|
|
|
|
cr = CompareVolumes(((PCPATHSEARCHINFO)pcpathsi)->hvol,
|
|
((PCPATH)pcpath)->hvol);
|
|
|
|
if (cr == CR_EQUAL)
|
|
cr = ComparePathStrings(((PCPATHSEARCHINFO)pcpathsi)->pcszPathSuffix,
|
|
GetString(((PCPATH)pcpath)->hsPathSuffix));
|
|
|
|
return(cr);
|
|
}
|
|
|
|
|
|
/*
|
|
** UnifyPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL UnifyPath(PPATHLIST ppl, HVOLUME hvol, LPCTSTR pcszPathSuffix,
|
|
PPATH *pppath)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(ppl, CPATHLIST));
|
|
ASSERT(IS_VALID_HANDLE(hvol, VOLUME));
|
|
ASSERT(IsValidPathSuffix(pcszPathSuffix));
|
|
ASSERT(IS_VALID_WRITE_PTR(pppath, PPATH));
|
|
|
|
/* Allocate space for PATH structure. */
|
|
|
|
if (AllocateMemory(sizeof(**pppath), pppath))
|
|
{
|
|
if (CopyVolume(hvol, ppl->hvl, &((*pppath)->hvol)))
|
|
{
|
|
if (AddString(pcszPathSuffix, ppl->hst, GetHashBucketIndex, &((*pppath)->hsPathSuffix)))
|
|
{
|
|
ARRAYINDEX aiUnused;
|
|
|
|
/* Initialize remaining PATH fields. */
|
|
|
|
(*pppath)->ulcLock = 0;
|
|
(*pppath)->pplParent = ppl;
|
|
|
|
/* Add new PATH to array. */
|
|
|
|
if (AddPtr(ppl->hpa, PathSortCmp, *pppath, &aiUnused))
|
|
bResult = TRUE;
|
|
else
|
|
{
|
|
DeleteString((*pppath)->hsPathSuffix);
|
|
UNIFYPATH_BAIL1:
|
|
DeleteVolume((*pppath)->hvol);
|
|
UNIFYPATH_BAIL2:
|
|
FreeMemory(*pppath);
|
|
}
|
|
}
|
|
else
|
|
goto UNIFYPATH_BAIL1;
|
|
}
|
|
else
|
|
goto UNIFYPATH_BAIL2;
|
|
}
|
|
|
|
ASSERT(! bResult ||
|
|
IS_VALID_STRUCT_PTR(*pppath, CPATH));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** CreatePath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL CreatePath(PPATHLIST ppl, HVOLUME hvol, LPCTSTR pcszPathSuffix,
|
|
PPATH *pppath)
|
|
{
|
|
BOOL bResult;
|
|
ARRAYINDEX aiFound;
|
|
PATHSEARCHINFO pathsi;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(ppl, CPATHLIST));
|
|
ASSERT(IS_VALID_HANDLE(hvol, VOLUME));
|
|
ASSERT(IsValidPathSuffix(pcszPathSuffix));
|
|
ASSERT(IS_VALID_WRITE_PTR(pppath, CPATH));
|
|
|
|
/* Does a path for the given volume and path suffix already exist? */
|
|
|
|
pathsi.hvol = hvol;
|
|
pathsi.pcszPathSuffix = pcszPathSuffix;
|
|
|
|
bResult = SearchSortedArray(ppl->hpa, &PathSearchCmp, &pathsi, &aiFound);
|
|
|
|
if (bResult)
|
|
/* Yes. Return it. */
|
|
*pppath = GetPtr(ppl->hpa, aiFound);
|
|
else
|
|
bResult = UnifyPath(ppl, hvol, pcszPathSuffix, pppath);
|
|
|
|
if (bResult)
|
|
LockPath(*pppath);
|
|
|
|
ASSERT(! bResult ||
|
|
IS_VALID_STRUCT_PTR(*pppath, CPATH));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** DestroyPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE void DestroyPath(PPATH ppath)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(ppath, CPATH));
|
|
|
|
DeleteVolume(ppath->hvol);
|
|
DeleteString(ppath->hsPathSuffix);
|
|
FreeMemory(ppath);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** UnlinkPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE void UnlinkPath(PCPATH pcpath)
|
|
{
|
|
HPTRARRAY hpa;
|
|
ARRAYINDEX aiFound;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pcpath, CPATH));
|
|
|
|
hpa = pcpath->pplParent->hpa;
|
|
|
|
if (EVAL(SearchSortedArray(hpa, &PathSortCmp, pcpath, &aiFound)))
|
|
{
|
|
ASSERT(GetPtr(hpa, aiFound) == pcpath);
|
|
|
|
DeletePtr(hpa, aiFound);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** LockPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE void LockPath(PPATH ppath)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(ppath, CPATH));
|
|
|
|
ASSERT(ppath->ulcLock < ULONG_MAX);
|
|
ppath->ulcLock++;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** UnlockPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL UnlockPath(PPATH ppath)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(ppath, CPATH));
|
|
|
|
if (EVAL(ppath->ulcLock > 0))
|
|
ppath->ulcLock--;
|
|
|
|
return(ppath->ulcLock > 0);
|
|
}
|
|
|
|
|
|
/*
|
|
** TranslateVOLUMERESULTToPATHRESULT()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE PATHRESULT TranslateVOLUMERESULTToPATHRESULT(VOLUMERESULT vr)
|
|
{
|
|
PATHRESULT pr;
|
|
|
|
switch (vr)
|
|
{
|
|
case VR_SUCCESS:
|
|
pr = PR_SUCCESS;
|
|
break;
|
|
|
|
case VR_UNAVAILABLE_VOLUME:
|
|
pr = PR_UNAVAILABLE_VOLUME;
|
|
break;
|
|
|
|
case VR_OUT_OF_MEMORY:
|
|
pr = PR_OUT_OF_MEMORY;
|
|
break;
|
|
|
|
default:
|
|
ASSERT(vr == VR_INVALID_PATH);
|
|
pr = PR_INVALID_PATH;
|
|
break;
|
|
}
|
|
|
|
return(pr);
|
|
}
|
|
|
|
|
|
/*
|
|
** WritePath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE TWINRESULT WritePath(HCACHEDFILE hcf, PPATH ppath)
|
|
{
|
|
TWINRESULT tr;
|
|
DBPATH dbpath;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hcf, CACHEDFILE));
|
|
ASSERT(IS_VALID_STRUCT_PTR(ppath, CPATH));
|
|
|
|
/* Write database path. */
|
|
|
|
dbpath.hpath = (HPATH)ppath;
|
|
dbpath.hvol = ppath->hvol;
|
|
dbpath.hsPathSuffix = ppath->hsPathSuffix;
|
|
|
|
if (WriteToCachedFile(hcf, (PCVOID)&dbpath, sizeof(dbpath), NULL))
|
|
tr = TR_SUCCESS;
|
|
else
|
|
tr = TR_BRIEFCASE_WRITE_FAILED;
|
|
|
|
return(tr);
|
|
}
|
|
|
|
|
|
/*
|
|
** ReadPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE TWINRESULT ReadPath(HCACHEDFILE hcf, PPATHLIST ppl,
|
|
HHANDLETRANS hhtVolumes,
|
|
HHANDLETRANS hhtStrings,
|
|
HHANDLETRANS hhtPaths)
|
|
{
|
|
TWINRESULT tr;
|
|
DBPATH dbpath;
|
|
DWORD dwcbRead;
|
|
HVOLUME hvol;
|
|
HSTRING hsPathSuffix;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hcf, CACHEDFILE));
|
|
ASSERT(IS_VALID_STRUCT_PTR(ppl, CPATHLIST));
|
|
ASSERT(IS_VALID_HANDLE(hhtVolumes, HANDLETRANS));
|
|
ASSERT(IS_VALID_HANDLE(hhtStrings, HANDLETRANS));
|
|
ASSERT(IS_VALID_HANDLE(hhtPaths, HANDLETRANS));
|
|
|
|
if (ReadFromCachedFile(hcf, &dbpath, sizeof(dbpath), &dwcbRead) &&
|
|
dwcbRead == sizeof(dbpath) &&
|
|
TranslateHandle(hhtVolumes, (HGENERIC)(dbpath.hvol), (PHGENERIC)&hvol) &&
|
|
TranslateHandle(hhtStrings, (HGENERIC)(dbpath.hsPathSuffix), (PHGENERIC)&hsPathSuffix))
|
|
{
|
|
PPATH ppath;
|
|
|
|
if (CreatePath(ppl, hvol, GetString(hsPathSuffix), &ppath))
|
|
{
|
|
/*
|
|
* To leave read paths with 0 initial lock count, we must undo
|
|
* the LockPath() performed by CreatePath().
|
|
*/
|
|
|
|
UnlockPath(ppath);
|
|
|
|
if (AddHandleToHandleTranslator(hhtPaths,
|
|
(HGENERIC)(dbpath.hpath),
|
|
(HGENERIC)ppath))
|
|
tr = TR_SUCCESS;
|
|
else
|
|
{
|
|
UnlinkPath(ppath);
|
|
DestroyPath(ppath);
|
|
|
|
tr = TR_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
else
|
|
tr = TR_OUT_OF_MEMORY;
|
|
}
|
|
else
|
|
tr = TR_CORRUPT_BRIEFCASE;
|
|
|
|
return(tr);
|
|
}
|
|
|
|
|
|
#if defined(DEBUG) || defined(VSTF)
|
|
|
|
/*
|
|
** IsValidPCPATHLIST()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL IsValidPCPATHLIST(PCPATHLIST pcpl)
|
|
{
|
|
return(IS_VALID_READ_PTR(pcpl, CPATHLIST) &&
|
|
IS_VALID_HANDLE(pcpl->hpa, PTRARRAY) &&
|
|
IS_VALID_HANDLE(pcpl->hvl, VOLUMELIST) &&
|
|
IS_VALID_HANDLE(pcpl->hst, STRINGTABLE));
|
|
}
|
|
|
|
|
|
/*
|
|
** IsValidPCPATH()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL IsValidPCPATH(PCPATH pcpath)
|
|
{
|
|
return(IS_VALID_READ_PTR(pcpath, CPATH) &&
|
|
IS_VALID_HANDLE(pcpath->hvol, VOLUME) &&
|
|
IS_VALID_HANDLE(pcpath->hsPathSuffix, STRING) &&
|
|
IsValidPathSuffix(GetString(pcpath->hsPathSuffix)) &&
|
|
IS_VALID_READ_PTR(pcpath->pplParent, CPATHLIST));
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#if defined(DEBUG)
|
|
|
|
/*
|
|
** IsValidPCPATHSEARCHINFO()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL IsValidPCPATHSEARCHINFO(PCPATHSEARCHINFO pcpathsi)
|
|
{
|
|
return(IS_VALID_READ_PTR(pcpathsi, CPATHSEARCHINFO) &&
|
|
IS_VALID_HANDLE(pcpathsi->hvol, VOLUME) &&
|
|
IsValidPathSuffix(pcpathsi->pcszPathSuffix));
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************** Public Functions *****************************/
|
|
|
|
|
|
/*
|
|
** CreatePathList()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL CreatePathList(DWORD dwFlags, HWND hwndOwner, PHPATHLIST phpl)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
PPATHLIST ppl;
|
|
|
|
ASSERT(FLAGS_ARE_VALID(dwFlags, ALL_RLI_IFLAGS));
|
|
ASSERT(IS_FLAG_CLEAR(dwFlags, RLI_IFL_ALLOW_UI) ||
|
|
IS_VALID_HANDLE(hwndOwner, WND));
|
|
ASSERT(IS_VALID_WRITE_PTR(phpl, HPATHLIST));
|
|
|
|
if (AllocateMemory(sizeof(*ppl), &ppl))
|
|
{
|
|
NEWPTRARRAY npa;
|
|
|
|
/* Create pointer array of paths. */
|
|
|
|
npa.aicInitialPtrs = NUM_START_PATHS;
|
|
npa.aicAllocGranularity = NUM_PATHS_TO_ADD;
|
|
npa.dwFlags = NPA_FL_SORTED_ADD;
|
|
|
|
if (CreatePtrArray(&npa, &(ppl->hpa)))
|
|
{
|
|
if (CreateVolumeList(dwFlags, hwndOwner, &(ppl->hvl)))
|
|
{
|
|
NEWSTRINGTABLE nszt;
|
|
|
|
/* Create string table for path suffix strings. */
|
|
|
|
nszt.hbc = NUM_PATH_HASH_BUCKETS;
|
|
|
|
if (CreateStringTable(&nszt, &(ppl->hst)))
|
|
{
|
|
*phpl = (HPATHLIST)ppl;
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DestroyVolumeList(ppl->hvl);
|
|
CREATEPATHLIST_BAIL1:
|
|
DestroyPtrArray(ppl->hpa);
|
|
CREATEPATHLIST_BAIL2:
|
|
FreeMemory(ppl);
|
|
}
|
|
}
|
|
else
|
|
goto CREATEPATHLIST_BAIL1;
|
|
}
|
|
else
|
|
goto CREATEPATHLIST_BAIL2;
|
|
}
|
|
|
|
ASSERT(! bResult ||
|
|
IS_VALID_HANDLE(*phpl, PATHLIST));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** DestroyPathList()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void DestroyPathList(HPATHLIST hpl)
|
|
{
|
|
ARRAYINDEX aicPtrs;
|
|
ARRAYINDEX ai;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpl, PATHLIST));
|
|
|
|
/* First free all paths in array. */
|
|
|
|
aicPtrs = GetPtrCount(((PCPATHLIST)hpl)->hpa);
|
|
|
|
for (ai = 0; ai < aicPtrs; ai++)
|
|
DestroyPath(GetPtr(((PCPATHLIST)hpl)->hpa, ai));
|
|
|
|
/* Now wipe out the array. */
|
|
|
|
DestroyPtrArray(((PCPATHLIST)hpl)->hpa);
|
|
|
|
ASSERT(! GetVolumeCount(((PCPATHLIST)hpl)->hvl));
|
|
DestroyVolumeList(((PCPATHLIST)hpl)->hvl);
|
|
|
|
ASSERT(! GetStringCount(((PCPATHLIST)hpl)->hst));
|
|
DestroyStringTable(((PCPATHLIST)hpl)->hst);
|
|
|
|
FreeMemory((PPATHLIST)hpl);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** InvalidatePathListInfo()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void InvalidatePathListInfo(HPATHLIST hpl)
|
|
{
|
|
InvalidateVolumeListInfo(((PCPATHLIST)hpl)->hvl);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** ClearPathListInfo()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void ClearPathListInfo(HPATHLIST hpl)
|
|
{
|
|
ClearVolumeListInfo(((PCPATHLIST)hpl)->hvl);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** AddPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
|
|
PUBLIC_CODE PATHRESULT AddPath(HPATHLIST hpl, LPCTSTR pcszPath, PHPATH phpath)
|
|
{
|
|
PATHRESULT pr;
|
|
HVOLUME hvol;
|
|
TCHAR rgchPathSuffix[MAX_PATH_LEN];
|
|
LPCTSTR pszPath;
|
|
|
|
#ifdef UNICODE
|
|
WCHAR szUnicode[MAX_PATH];
|
|
#endif
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpl, PATHLIST));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszPath, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(phpath, HPATH));
|
|
|
|
// On NT, we want to convert a unicode string to an ANSI shortened path for
|
|
// the sake of interop
|
|
|
|
#if defined(UNICODE)
|
|
{
|
|
CHAR szAnsi[MAX_PATH];
|
|
szUnicode[0] = L'\0';
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, pcszPath, -1, szAnsi, ARRAYSIZE(szAnsi), NULL, NULL);
|
|
MultiByteToWideChar(CP_ACP, 0, szAnsi, -1, szUnicode, ARRAYSIZE(szUnicode));
|
|
if (lstrcmp(szUnicode, pcszPath))
|
|
{
|
|
// Cannot convert losslessly from Unicode -> Ansi, so get the short path
|
|
|
|
lstrcpyn(szUnicode, pcszPath, ARRAYSIZE(szUnicode));
|
|
SheShortenPath(szUnicode, TRUE);
|
|
pszPath = szUnicode;
|
|
}
|
|
else
|
|
{
|
|
// It will convert OK, so just use the original
|
|
|
|
pszPath = pcszPath;
|
|
}
|
|
}
|
|
#else
|
|
pszPath = pcszPath;
|
|
#endif
|
|
|
|
pr = TranslateVOLUMERESULTToPATHRESULT(
|
|
AddVolume(((PCPATHLIST)hpl)->hvl, pszPath, &hvol, rgchPathSuffix, ARRAYSIZE(rgchPathSuffix)));
|
|
|
|
if (pr == PR_SUCCESS)
|
|
{
|
|
PPATH ppath;
|
|
|
|
if (CreatePath((PPATHLIST)hpl, hvol, rgchPathSuffix, &ppath))
|
|
*phpath = (HPATH)ppath;
|
|
else
|
|
pr = PR_OUT_OF_MEMORY;
|
|
|
|
DeleteVolume(hvol);
|
|
}
|
|
|
|
ASSERT(pr != PR_SUCCESS ||
|
|
IS_VALID_HANDLE(*phpath, PATH));
|
|
|
|
return(pr);
|
|
}
|
|
|
|
|
|
/*
|
|
** AddChildPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL AddChildPath(HPATHLIST hpl, HPATH hpathParent,
|
|
LPCTSTR pcszSubPath, PHPATH phpathChild)
|
|
{
|
|
BOOL bResult;
|
|
TCHAR rgchChildPathSuffix[MAX_PATH_LEN];
|
|
LPCTSTR pcszPathSuffix;
|
|
LPTSTR pszPathSuffixEnd;
|
|
PPATH ppathChild;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpl, PATHLIST));
|
|
ASSERT(IS_VALID_HANDLE(hpathParent, PATH));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszSubPath, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(phpathChild, HPATH));
|
|
|
|
ComposePath(rgchChildPathSuffix,
|
|
GetString(((PCPATH)hpathParent)->hsPathSuffix),
|
|
pcszSubPath, ARRAYSIZE(rgchChildPathSuffix));
|
|
|
|
pcszPathSuffix = rgchChildPathSuffix;
|
|
|
|
if (IS_SLASH(*pcszPathSuffix))
|
|
pcszPathSuffix++;
|
|
|
|
pszPathSuffixEnd = CharPrev(pcszPathSuffix,
|
|
pcszPathSuffix + lstrlen(pcszPathSuffix));
|
|
|
|
if (IS_SLASH(*pszPathSuffixEnd))
|
|
*pszPathSuffixEnd = TEXT('\0');
|
|
|
|
ASSERT(IsValidPathSuffix(pcszPathSuffix));
|
|
|
|
bResult = CreatePath((PPATHLIST)hpl, ((PCPATH)hpathParent)->hvol,
|
|
pcszPathSuffix, &ppathChild);
|
|
|
|
if (bResult)
|
|
*phpathChild = (HPATH)ppathChild;
|
|
|
|
ASSERT(! bResult ||
|
|
IS_VALID_HANDLE(*phpathChild, PATH));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** DeletePath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void DeletePath(HPATH hpath)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
|
|
if (! UnlockPath((PPATH)hpath))
|
|
{
|
|
UnlinkPath((PPATH)hpath);
|
|
DestroyPath((PPATH)hpath);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** CopyPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL CopyPath(HPATH hpathSrc, HPATHLIST hplDest, PHPATH phpathCopy)
|
|
{
|
|
BOOL bResult;
|
|
PPATH ppath;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpathSrc, PATH));
|
|
ASSERT(IS_VALID_HANDLE(hplDest, PATHLIST));
|
|
ASSERT(IS_VALID_WRITE_PTR(phpathCopy, HPATH));
|
|
|
|
/* Is the destination path list the source path's path list? */
|
|
|
|
if (((PCPATH)hpathSrc)->pplParent == (PCPATHLIST)hplDest)
|
|
{
|
|
/* Yes. Use the source path. */
|
|
|
|
LockPath((PPATH)hpathSrc);
|
|
ppath = (PPATH)hpathSrc;
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
bResult = CreatePath((PPATHLIST)hplDest, ((PCPATH)hpathSrc)->hvol,
|
|
GetString(((PCPATH)hpathSrc)->hsPathSuffix),
|
|
&ppath);
|
|
|
|
if (bResult)
|
|
*phpathCopy = (HPATH)ppath;
|
|
|
|
ASSERT(! bResult ||
|
|
IS_VALID_HANDLE(*phpathCopy, PATH));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** GetPathString()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void GetPathString(HPATH hpath, LPTSTR pszPathBuf, int cchMax)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszPathBuf, STR, cchMax));
|
|
|
|
GetPathRootString(hpath, pszPathBuf, cchMax);
|
|
CatPath(pszPathBuf, GetString(((PPATH)hpath)->hsPathSuffix), cchMax);
|
|
|
|
ASSERT(IsCanonicalPath(pszPathBuf));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** GetPathRootString()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void GetPathRootString(HPATH hpath, LPTSTR pszPathRootBuf, int cchMax)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszPathRootBuf, STR, cchMax));
|
|
|
|
GetVolumeRootPath(((PPATH)hpath)->hvol, pszPathRootBuf, cchMax);
|
|
|
|
ASSERT(IsCanonicalPath(pszPathRootBuf));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** GetPathSuffixString()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void GetPathSuffixString(HPATH hpath, LPTSTR pszPathSuffixBuf)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszPathSuffixBuf, STR, MAX_PATH_LEN));
|
|
|
|
ASSERT(lstrlen(GetString(((PPATH)hpath)->hsPathSuffix)) < MAX_PATH_LEN);
|
|
MyLStrCpyN(pszPathSuffixBuf, GetString(((PPATH)hpath)->hsPathSuffix), MAX_PATH_LEN);
|
|
|
|
ASSERT(IsValidPathSuffix(pszPathSuffixBuf));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** AllocatePathString()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL AllocatePathString(HPATH hpath, LPTSTR *ppszPath)
|
|
{
|
|
TCHAR rgchPath[MAX_PATH_LEN];
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppszPath, LPTSTR));
|
|
|
|
GetPathString(hpath, rgchPath, ARRAYSIZE(rgchPath));
|
|
|
|
return(StringCopy(rgchPath, ppszPath));
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
/*
|
|
** DebugGetPathString()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** N.b., DebugGetPathString() must be non-intrusive.
|
|
*/
|
|
PUBLIC_CODE LPCTSTR DebugGetPathString(HPATH hpath)
|
|
{
|
|
/* Allow 4 debug paths. */
|
|
static TCHAR SrgrgchPaths[][MAX_PATH_LEN] = { TEXT(""), TEXT(""), TEXT(""), TEXT("") };
|
|
static UINT SuiPath = 0;
|
|
LPTSTR pszPath;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
|
|
pszPath = SrgrgchPaths[SuiPath];
|
|
|
|
DebugGetVolumeRootPath(((PPATH)hpath)->hvol, pszPath, ARRAYSIZE(SrgrchPaths[SuiPath]));
|
|
CatPath(pszPath, GetString(((PPATH)hpath)->hsPathSuffix), ARRAYSIZE(SrgrchPaths[SuiPath]));
|
|
|
|
SuiPath++;
|
|
SuiPath %= ARRAY_ELEMENTS(SrgrgchPaths);
|
|
|
|
return(pszPath);
|
|
}
|
|
|
|
|
|
/*
|
|
** GetPathCount()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE ULONG GetPathCount(HPATHLIST hpl)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpl, PATHLIST));
|
|
|
|
return(GetPtrCount(((PCPATHLIST)hpl)->hpa));
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
** IsPathVolumeAvailable()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL IsPathVolumeAvailable(HPATH hpath)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
|
|
return(IsVolumeAvailable(((PCPATH)hpath)->hvol));
|
|
}
|
|
|
|
|
|
/*
|
|
** GetPathVolumeID()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE HVOLUMEID GetPathVolumeID(HPATH hpath)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
|
|
return((HVOLUMEID)hpath);
|
|
}
|
|
|
|
|
|
/*
|
|
** MyIsPathOnVolume()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** MyIsPathOnVolume() will fail for a new root path alias for a volume. E.g.,
|
|
** if the same net resource is connected to both X: and Y:, MyIsPathOnVolume()
|
|
** will only return TRUE for the drive root path that the net resource was
|
|
** connected to through the given HVOLUME.
|
|
*/
|
|
PUBLIC_CODE BOOL MyIsPathOnVolume(LPCTSTR pcszPath, HPATH hpath)
|
|
{
|
|
BOOL bResult;
|
|
TCHAR rgchVolumeRootPath[MAX_PATH_LEN];
|
|
|
|
ASSERT(IsFullPath(pcszPath));
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
|
|
rgchVolumeRootPath[0] = TEXT('\0');
|
|
if (IsVolumeAvailable(((PPATH)hpath)->hvol))
|
|
{
|
|
GetVolumeRootPath(((PPATH)hpath)->hvol, rgchVolumeRootPath, ARRAYSIZE(rgchVolumeRootPath));
|
|
|
|
bResult = (MyLStrCmpNI(pcszPath, rgchVolumeRootPath,
|
|
lstrlen(rgchVolumeRootPath))
|
|
== CR_EQUAL);
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT((TEXT("MyIsPathOnVolume(): Failing on unavailable volume %s."),
|
|
DebugGetVolumeRootPath(((PPATH)hpath)->hvol, rgchVolumeRootPath,
|
|
ARRAYSIZE(rgchVolumeRootPath))));
|
|
|
|
bResult = FALSE;
|
|
}
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** ComparePaths()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** PATHs are compared by:
|
|
** 1) volume
|
|
** 2) path suffix
|
|
*/
|
|
PUBLIC_CODE COMPARISONRESULT ComparePaths(HPATH hpath1, HPATH hpath2)
|
|
{
|
|
COMPARISONRESULT cr;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpath1, PATH));
|
|
ASSERT(IS_VALID_HANDLE(hpath2, PATH));
|
|
|
|
/* This comparison works across path lists. */
|
|
|
|
cr = ComparePathVolumes(hpath1, hpath2);
|
|
|
|
if (cr == CR_EQUAL)
|
|
cr = ComparePathStringsByHandle(((PCPATH)hpath1)->hsPathSuffix,
|
|
((PCPATH)hpath2)->hsPathSuffix);
|
|
|
|
return(cr);
|
|
}
|
|
|
|
|
|
/*
|
|
** ComparePathVolumes()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE COMPARISONRESULT ComparePathVolumes(HPATH hpath1, HPATH hpath2)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpath1, PATH));
|
|
ASSERT(IS_VALID_HANDLE(hpath2, PATH));
|
|
|
|
return(CompareVolumes(((PCPATH)hpath1)->hvol, ((PCPATH)hpath2)->hvol));
|
|
}
|
|
|
|
|
|
/*
|
|
** IsPathPrefix()
|
|
**
|
|
** Determines whether or not one path is a prefix of another.
|
|
**
|
|
** Arguments: hpathChild - whole path (longer or same length)
|
|
** hpathParent - prefix path to test (shorter or same length)
|
|
**
|
|
** Returns: TRUE if the second path is a prefix of the first path. FALSE
|
|
** if not.
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** Read 'IsPathPrefix(A, B)' as 'Is A in B's subtree?'.
|
|
*/
|
|
PUBLIC_CODE BOOL IsPathPrefix(HPATH hpathChild, HPATH hpathParent)
|
|
{
|
|
BOOL bResult;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpathParent, PATH));
|
|
ASSERT(IS_VALID_HANDLE(hpathChild, PATH));
|
|
|
|
if (ComparePathVolumes(hpathParent, hpathChild) == CR_EQUAL)
|
|
{
|
|
TCHAR rgchParentSuffix[MAX_PATH_LEN];
|
|
TCHAR rgchChildSuffix[MAX_PATH_LEN];
|
|
int nParentSuffixLen;
|
|
int nChildSuffixLen;
|
|
|
|
/* Ignore path roots when comparing path strings. */
|
|
|
|
GetPathSuffixString(hpathParent, rgchParentSuffix);
|
|
GetPathSuffixString(hpathChild, rgchChildSuffix);
|
|
|
|
/* Only root paths should have no path suffix off the root. */
|
|
|
|
nParentSuffixLen = lstrlen(rgchParentSuffix);
|
|
nChildSuffixLen = lstrlen(rgchChildSuffix);
|
|
|
|
/*
|
|
* The parent path is a path prefix of the child path iff:
|
|
* 1) The parent's path suffix string is shorter than or the same
|
|
* length as the child's path suffix string.
|
|
* 2) The two path suffix strings match through the length of the
|
|
* parent's path suffix string.
|
|
* 3) The prefix of the child's path suffix string is followed
|
|
* immediately by a null terminator or a path separator.
|
|
*/
|
|
|
|
bResult = (nChildSuffixLen >= nParentSuffixLen &&
|
|
MyLStrCmpNI(rgchParentSuffix, rgchChildSuffix,
|
|
nParentSuffixLen) == CR_EQUAL &&
|
|
(nChildSuffixLen == nParentSuffixLen || /* same paths */
|
|
! nParentSuffixLen || /* root parent */
|
|
IS_SLASH(rgchChildSuffix[nParentSuffixLen]))); /* non-root parent */
|
|
}
|
|
else
|
|
bResult = FALSE;
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** SubtreesIntersect()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** N.b., two subtrees cannot both intersect a third subtree unless they
|
|
** intersect each other.
|
|
*/
|
|
PUBLIC_CODE BOOL SubtreesIntersect(HPATH hpath1, HPATH hpath2)
|
|
{
|
|
ASSERT(IS_VALID_HANDLE(hpath1, PATH));
|
|
ASSERT(IS_VALID_HANDLE(hpath2, PATH));
|
|
|
|
return(IsPathPrefix(hpath1, hpath2) ||
|
|
IsPathPrefix(hpath2, hpath1));
|
|
}
|
|
|
|
|
|
/*
|
|
** FindEndOfRootSpec()
|
|
**
|
|
** Finds the end of the root specification in a path string.
|
|
**
|
|
** Arguments: pcszPath - path to examine for root specification
|
|
** hpath - handle to PATH that path string was generated from
|
|
**
|
|
** Returns: pointer to first character after end of root specification
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** Examples:
|
|
**
|
|
** input path output string
|
|
** ---------- -------------
|
|
** c:\ <empty string>
|
|
** c:\foo foo
|
|
** c:\foo\bar foo\bar
|
|
** \\pyrex\user\ <empty string>
|
|
** \\pyrex\user\foo foo
|
|
** \\pyrex\user\foo\bar foo\bar
|
|
*/
|
|
PUBLIC_CODE LPTSTR FindEndOfRootSpec(LPCTSTR pcszFullPath, HPATH hpath)
|
|
{
|
|
LPCTSTR pcsz;
|
|
UINT ucchPathLen;
|
|
UINT ucchSuffixLen;
|
|
|
|
ASSERT(IsCanonicalPath(pcszFullPath));
|
|
ASSERT(IS_VALID_HANDLE(hpath, PATH));
|
|
|
|
ucchPathLen = lstrlen(pcszFullPath);
|
|
ucchSuffixLen = lstrlen(GetString(((PCPATH)hpath)->hsPathSuffix));
|
|
|
|
pcsz = pcszFullPath + ucchPathLen;
|
|
|
|
if (ucchPathLen > ucchSuffixLen)
|
|
pcsz -= ucchSuffixLen;
|
|
else
|
|
/* Assume path is root path. */
|
|
ERROR_OUT((TEXT("FindEndOfRootSpec(): Path suffix %s is longer than full path %s."),
|
|
GetString(((PCPATH)hpath)->hsPathSuffix),
|
|
pcszFullPath));
|
|
|
|
ASSERT(IsValidPathSuffix(pcsz));
|
|
|
|
return((LPTSTR)pcsz);
|
|
}
|
|
|
|
|
|
/*
|
|
** FindPathSuffix()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE LPTSTR FindChildPathSuffix(HPATH hpathParent, HPATH hpathChild,
|
|
LPTSTR pszChildSuffixBuf)
|
|
{
|
|
LPCTSTR pcszChildSuffix;
|
|
TCHAR rgchParentSuffix[MAX_PATH_LEN];
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpathParent, PATH));
|
|
ASSERT(IS_VALID_HANDLE(hpathChild, PATH));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszChildSuffixBuf, STR, MAX_PATH_LEN));
|
|
|
|
ASSERT(IsPathPrefix(hpathChild, hpathParent));
|
|
|
|
GetPathSuffixString(hpathParent, rgchParentSuffix);
|
|
GetPathSuffixString(hpathChild, pszChildSuffixBuf);
|
|
|
|
ASSERT(lstrlen(rgchParentSuffix) <= lstrlen(pszChildSuffixBuf));
|
|
pcszChildSuffix = pszChildSuffixBuf + lstrlen(rgchParentSuffix);
|
|
|
|
if (IS_SLASH(*pcszChildSuffix))
|
|
pcszChildSuffix++;
|
|
|
|
ASSERT(IsValidPathSuffix(pcszChildSuffix));
|
|
|
|
return((LPTSTR)pcszChildSuffix);
|
|
}
|
|
|
|
|
|
/*
|
|
** ComparePointers()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE COMPARISONRESULT ComparePointers(PCVOID pcv1, PCVOID pcv2)
|
|
{
|
|
COMPARISONRESULT cr;
|
|
|
|
/* pcv1 and pcv2 may be any value. */
|
|
|
|
if (pcv1 < pcv2)
|
|
cr = CR_FIRST_SMALLER;
|
|
else if (pcv1 > pcv2)
|
|
cr = CR_FIRST_LARGER;
|
|
else
|
|
cr = CR_EQUAL;
|
|
|
|
return(cr);
|
|
}
|
|
|
|
|
|
/*
|
|
** TWINRESULTFromLastError()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE TWINRESULT TWINRESULTFromLastError(TWINRESULT tr)
|
|
{
|
|
switch (GetLastError())
|
|
{
|
|
case ERROR_OUTOFMEMORY:
|
|
tr = TR_OUT_OF_MEMORY;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return(tr);
|
|
}
|
|
|
|
|
|
/*
|
|
** WritePathList()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE TWINRESULT WritePathList(HCACHEDFILE hcf, HPATHLIST hpl)
|
|
{
|
|
TWINRESULT tr;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hcf, CACHEDFILE));
|
|
ASSERT(IS_VALID_HANDLE(hpl, PATHLIST));
|
|
|
|
tr = WriteVolumeList(hcf, ((PCPATHLIST)hpl)->hvl);
|
|
|
|
if (tr == TR_SUCCESS)
|
|
{
|
|
tr = WriteStringTable(hcf, ((PCPATHLIST)hpl)->hst);
|
|
|
|
if (tr == TR_SUCCESS)
|
|
{
|
|
DWORD dwcbDBPathListHeaderOffset;
|
|
|
|
tr = TR_BRIEFCASE_WRITE_FAILED;
|
|
|
|
/* Save initial file position. */
|
|
|
|
dwcbDBPathListHeaderOffset = GetCachedFilePointerPosition(hcf);
|
|
|
|
if (dwcbDBPathListHeaderOffset != INVALID_SEEK_POSITION)
|
|
{
|
|
DBPATHLISTHEADER dbplh;
|
|
|
|
/* Leave space for path list header. */
|
|
|
|
ZeroMemory(&dbplh, sizeof(dbplh));
|
|
|
|
if (WriteToCachedFile(hcf, (PCVOID)&dbplh, sizeof(dbplh), NULL))
|
|
{
|
|
ARRAYINDEX aicPtrs;
|
|
ARRAYINDEX ai;
|
|
LONG lcPaths = 0;
|
|
|
|
tr = TR_SUCCESS;
|
|
|
|
aicPtrs = GetPtrCount(((PCPATHLIST)hpl)->hpa);
|
|
|
|
/* Write all paths. */
|
|
|
|
for (ai = 0; ai < aicPtrs; ai++)
|
|
{
|
|
PPATH ppath;
|
|
|
|
ppath = GetPtr(((PCPATHLIST)hpl)->hpa, ai);
|
|
|
|
/*
|
|
* As a sanity check, don't save any path with a lock count
|
|
* of 0. A 0 lock count implies that the path has not been
|
|
* referenced since it was restored from the database, or
|
|
* something is broken.
|
|
*/
|
|
|
|
if (ppath->ulcLock > 0)
|
|
{
|
|
tr = WritePath(hcf, ppath);
|
|
|
|
if (tr == TR_SUCCESS)
|
|
{
|
|
ASSERT(lcPaths < LONG_MAX);
|
|
lcPaths++;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
ERROR_OUT((TEXT("WritePathList(): PATH for path %s has 0 lock count and will not be written."),
|
|
DebugGetPathString((HPATH)ppath)));
|
|
}
|
|
|
|
/* Save path list header. */
|
|
|
|
if (tr == TR_SUCCESS)
|
|
{
|
|
dbplh.lcPaths = lcPaths;
|
|
|
|
tr = WriteDBSegmentHeader(hcf, dwcbDBPathListHeaderOffset, &dbplh,
|
|
sizeof(dbplh));
|
|
|
|
TRACE_OUT((TEXT("WritePathList(): Wrote %ld paths."),
|
|
dbplh.lcPaths));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(tr);
|
|
}
|
|
|
|
|
|
/*
|
|
** ReadPathList()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE TWINRESULT ReadPathList(HCACHEDFILE hcf, HPATHLIST hpl,
|
|
PHHANDLETRANS phht)
|
|
{
|
|
TWINRESULT tr;
|
|
HHANDLETRANS hhtVolumes;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hcf, CACHEDFILE));
|
|
ASSERT(IS_VALID_HANDLE(hpl, PATHLIST));
|
|
ASSERT(IS_VALID_WRITE_PTR(phht, HHANDLETRANS));
|
|
|
|
tr = ReadVolumeList(hcf, ((PCPATHLIST)hpl)->hvl, &hhtVolumes);
|
|
|
|
if (tr == TR_SUCCESS)
|
|
{
|
|
HHANDLETRANS hhtStrings;
|
|
|
|
tr = ReadStringTable(hcf, ((PCPATHLIST)hpl)->hst, &hhtStrings);
|
|
|
|
if (tr == TR_SUCCESS)
|
|
{
|
|
DBPATHLISTHEADER dbplh;
|
|
DWORD dwcbRead;
|
|
|
|
tr = TR_CORRUPT_BRIEFCASE;
|
|
|
|
if (ReadFromCachedFile(hcf, &dbplh, sizeof(dbplh), &dwcbRead) &&
|
|
dwcbRead == sizeof(dbplh))
|
|
{
|
|
HHANDLETRANS hht;
|
|
|
|
if (CreateHandleTranslator(dbplh.lcPaths, &hht))
|
|
{
|
|
LONG l;
|
|
|
|
tr = TR_SUCCESS;
|
|
|
|
TRACE_OUT((TEXT("ReadPathList(): Reading %ld paths."),
|
|
dbplh.lcPaths));
|
|
|
|
for (l = 0; l < dbplh.lcPaths; l++)
|
|
{
|
|
tr = ReadPath(hcf, (PPATHLIST)hpl, hhtVolumes, hhtStrings,
|
|
hht);
|
|
|
|
if (tr != TR_SUCCESS)
|
|
break;
|
|
}
|
|
|
|
if (tr == TR_SUCCESS)
|
|
{
|
|
PrepareForHandleTranslation(hht);
|
|
*phht = hht;
|
|
|
|
ASSERT(IS_VALID_HANDLE(hpl, PATHLIST));
|
|
ASSERT(IS_VALID_HANDLE(*phht, HANDLETRANS));
|
|
}
|
|
else
|
|
DestroyHandleTranslator(hht);
|
|
}
|
|
else
|
|
tr = TR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
DestroyHandleTranslator(hhtStrings);
|
|
}
|
|
|
|
DestroyHandleTranslator(hhtVolumes);
|
|
}
|
|
|
|
return(tr);
|
|
}
|
|
|
|
|
|
/*
|
|
** IsValidHPATH()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL IsValidHPATH(HPATH hp)
|
|
{
|
|
return(IS_VALID_STRUCT_PTR((PCPATH)hp, CPATH));
|
|
}
|
|
|
|
|
|
/*
|
|
** IsValidHVOLUMEID()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL IsValidHVOLUMEID(HVOLUMEID hvid)
|
|
{
|
|
return(IS_VALID_HANDLE((HPATH)hvid, PATH));
|
|
}
|
|
|
|
|
|
#if defined(DEBUG) || defined(VSTF)
|
|
|
|
/*
|
|
** IsValidHPATHLIST()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL IsValidHPATHLIST(HPATHLIST hpl)
|
|
{
|
|
return(IS_VALID_STRUCT_PTR((PCPATHLIST)hpl, CPATHLIST));
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/***************************** Exported Functions ****************************/
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
@doc SYNCENGAPI
|
|
|
|
@api TWINRESULT | IsPathOnVolume | Determines whether or not a given path is on
|
|
a given volume.
|
|
|
|
@parm PCSTR | pcszPath | A pointer to a string indicating the path to be
|
|
checked.
|
|
|
|
@parm HVOLUMEID | hvid | A handle to a volume ID.
|
|
|
|
@parm PBOOL | pbOnVolume | A pointer to a BOOL to be filled in with TRUE if the
|
|
given path is on the given volume, or FALSE if not. *pbOnVolume is only valid
|
|
if TR_SUCCESS is returned.
|
|
|
|
@rdesc If the volume check was successful, TR_SUCCESS is returned. Otherwise,
|
|
the volume check was not successful, and the return value indicates the error
|
|
that occurred.
|
|
|
|
******************************************************************************/
|
|
|
|
SYNCENGAPI TWINRESULT WINAPI IsPathOnVolume(LPCTSTR pcszPath, HVOLUMEID hvid,
|
|
PBOOL pbOnVolume)
|
|
{
|
|
TWINRESULT tr;
|
|
|
|
if (BeginExclusiveBriefcaseAccess())
|
|
{
|
|
DebugEntry(IsPathOnVolume);
|
|
|
|
#ifdef EXPV
|
|
/* Verify parameters. */
|
|
|
|
if (IS_VALID_STRING_PTR(pcszPath, CSTR) &&
|
|
IS_VALID_HANDLE(hvid, VOLUMEID) &&
|
|
IS_VALID_WRITE_PTR(pbOnVolume, BOOL))
|
|
#endif
|
|
{
|
|
TCHAR rgchFullPath[MAX_PATH_LEN];
|
|
LPTSTR pszFileName;
|
|
DWORD dwPathLen;
|
|
|
|
dwPathLen = GetFullPathName(pcszPath, ARRAYSIZE(rgchFullPath),
|
|
rgchFullPath, &pszFileName);
|
|
|
|
if (dwPathLen > 0 && dwPathLen < ARRAYSIZE(rgchFullPath))
|
|
{
|
|
*pbOnVolume = MyIsPathOnVolume(rgchFullPath, (HPATH)hvid);
|
|
|
|
tr = TR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(! dwPathLen);
|
|
|
|
tr = TR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
#ifdef EXPV
|
|
else
|
|
tr = TR_INVALID_PARAMETER;
|
|
#endif
|
|
|
|
DebugExitTWINRESULT(IsPathOnVolume, tr);
|
|
|
|
EndExclusiveBriefcaseAccess();
|
|
}
|
|
else
|
|
tr = TR_REENTERED;
|
|
|
|
return(tr);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
@doc SYNCENGAPI
|
|
|
|
@api TWINRESULT | GetVolumeDescription | Retrieves some descriptive information
|
|
for a volume, if that information is available.
|
|
|
|
@parm HVOLUMEID | hvid | A handle to a volume ID.
|
|
|
|
@parm PVOLUMEDESC | pvoldesc | A pointer to a VOLUMEDESC to be filled in with
|
|
information describing the volume. The ulSize field of the VOLUMEDESC
|
|
structure should be filled in with sizeof(VOLUMEDESC) before calling
|
|
GetVolumeDescription().
|
|
|
|
@rdesc If the volume was described successfully, TR_SUCCESS is returned.
|
|
Otherwise, the volume was not described successfully, and the return value
|
|
indicates the error that occurred.
|
|
|
|
******************************************************************************/
|
|
|
|
SYNCENGAPI TWINRESULT WINAPI GetVolumeDescription(HVOLUMEID hvid,
|
|
PVOLUMEDESC pvoldesc)
|
|
{
|
|
TWINRESULT tr;
|
|
|
|
if (BeginExclusiveBriefcaseAccess())
|
|
{
|
|
DebugEntry(GetVolumeDescription);
|
|
|
|
#ifdef EXPV
|
|
/* Verify parameters. */
|
|
|
|
if (IS_VALID_HANDLE(hvid, VOLUMEID) &&
|
|
IS_VALID_WRITE_PTR(pvoldesc, VOLUMEDESC) &&
|
|
EVAL(pvoldesc->ulSize == sizeof(*pvoldesc)))
|
|
#endif
|
|
{
|
|
DescribeVolume(((PCPATH)hvid)->hvol, pvoldesc);
|
|
|
|
tr = TR_SUCCESS;
|
|
}
|
|
#ifdef EXPV
|
|
else
|
|
tr = TR_INVALID_PARAMETER;
|
|
#endif
|
|
|
|
DebugExitTWINRESULT(GetVolumeDescription, tr);
|
|
|
|
EndExclusiveBriefcaseAccess();
|
|
}
|
|
else
|
|
tr = TR_REENTERED;
|
|
|
|
return(tr);
|
|
}
|
|
|