windows-xp/Source/XPSP1/NT/base/fs/sis/sisbkup/sisbkup.cpp

/*++

Copyright (c) 1998-1999	Microsoft Corporation

Module Name:

	sisbackup.cpp

Abstract:

	The SIS Backup dll.

Author:

	Bill Bolosky		[bolosky]		March 1998

Revision History:

--*/


#include "sibp.h"

BOOLEAN
NonSISEnabledVolume(
	PSIB_RESTORE_VOLUME_STRUCTURE	restoreStructure)
/*++

Routine Description:

	Figure out if restoreStructure represents a SIS enabled volume.
	First, we check to see if we've already made the check, in which
	case we return the value we already stored.  If not, then we
	open a root handle, and send down a mal-formed SIS_COPYFILE request.
	If we get back ERROR_INVALID_FUNCTION then it's not SIS enabled.  If
	we get back	ERROR_INVALID_PARAMETER, then it's a SIS-enabled volume.
	If we get back anything else, then we can't prove it's not SIS enabled,
	and we just retry the next time we're asked.

	Caller must hold the mutex in the restore volume structure.

Arguments:

	restoreStructure - A pointer to the restore structure representing
		the volume to check.

Return Value:

	Returns TRUE if this is not a SIS-enabled volume, FALSE if it is or
	if it can't be determined.
--*/
{
	if (restoreStructure->checkedForSISEnabledVolume) {
		return !restoreStructure->isSISEnabledVolume;
	}

	HANDLE volumeRootHandle;
	PWCHAR volumeRootName;

	//
	// Allocate space for a string containing the volume root name including the trailing
	// backslash.  It will be two (wide) characters longer than restoreStructure->volumeRoot
	// because of the backslash and null terminator.
	//
	volumeRootName = (PWCHAR) malloc ((wcslen(restoreStructure->volumeRoot) + 2) * sizeof(WCHAR));

	if (NULL == volumeRootName) {
		//
		// Guess we can't check, just assume it's OK.
		//
#if		DBG
		DbgPrint("SISBkup: NonSISEnabledVolume: unable to allocate space for volume root name\n");
#endif	// DBG
		return FALSE;
	}

	wcscpy(volumeRootName,restoreStructure->volumeRoot);
	wcscat(volumeRootName,L"\\");

	volumeRootHandle = CreateFileW(
						volumeRootName,
						0,													// don't need any access for this check
						FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
						NULL,												// security attributes
						OPEN_EXISTING,
						FILE_FLAG_BACKUP_SEMANTICS,							// needed to open a directory
						NULL);												// hTemplateFile


	free(volumeRootName);
	volumeRootName = NULL;

	if (INVALID_HANDLE_VALUE == volumeRootHandle) {
		return FALSE;
	}

	//
	// Send a malformed FSCTL_SIS_COPYFILE down on the handle we just opened.
	//
	DWORD bytesReturned;
	BOOL worked = DeviceIoControl(
						volumeRootHandle,
						FSCTL_SIS_COPYFILE,
						NULL,					// input buffer (this is a malformed request, after all)
						0,						// i.b. size
						NULL,					// output buffer
						0,						// o.b. size
						&bytesReturned,
						NULL);					// lap

	CloseHandle(volumeRootHandle);

	if (worked) {
		//
		// This is bizarre!
		//

#if		DBG
		DbgPrint("SISBkup: malformed FSCTL_SIS_COPYFILE worked!\n");
#endif	// DBG

		return FALSE;
	}

	if (GetLastError() == ERROR_INVALID_FUNCTION) {
		//
		// No one recognized the copyfile request, or SIS decided that
		// this isn't a SIS enabled volume.  Say no.
		//
		restoreStructure->checkedForSISEnabledVolume = TRUE;
		restoreStructure->isSISEnabledVolume = FALSE;

		return TRUE;
	}

	if (GetLastError() == ERROR_INVALID_PARAMETER) {
		//
		// This means that SIS saw the request and thinks this is
		// a SIS enabled volume.  Say so.
		//

		restoreStructure->checkedForSISEnabledVolume = TRUE;
		restoreStructure->isSISEnabledVolume = TRUE;

		return FALSE;
	}

	//
	// Else, it's some weird error.  We can't prove it's not a SIS volume.
	//

#if		DBG
	DbgPrint("SISBkup: got unexpected error from SIS_FSCTL_COPYFILE, %d\n",GetLastError());
#endif	// DBG
			

	return FALSE;
}

VOID
SipComputeChecksum(
	IN PVOID							buffer,
	IN ULONG							size,
	IN OUT PLONGLONG					checksum)
/*++

Routine Description:

	Compute a checksum for a buffer.  We use the "131 hash," which
	work by keeping a 64 bit running total, and for each 32 bits of
	data multiplying the 64 bits by 131 and adding in the next 32
	bits.  Must be called at PASSIVE_LEVEL, and all aruments
	may be pagable.

Arguments:

	buffer - pointer to the data to be checksummed

	size - size of the data to be checksummed

	checksum - pointer to large integer to receive the checksum.  This
		may be within the buffer, and SipComputeChecksum guarantees that
		the initial value will be used in computing the checksum.

Return Value:

	Returns STATUS_SUCCESS or an error returned from the actual disk write.
--*/
{
	LONGLONG runningTotal;
	PULONG ptr = (PULONG)buffer;
	ULONG bytesRemaining = size;

	runningTotal = *checksum;

	while (bytesRemaining >= sizeof(*ptr)) {
		runningTotal = runningTotal * 131 + *ptr;
		bytesRemaining -= sizeof(*ptr);
		ptr++;
	}

	if (bytesRemaining > 0) {
		ULONG extra;

		ASSERT(bytesRemaining < sizeof (ULONG));
		extra = 0;
		RtlMoveMemory(&extra, ptr, bytesRemaining);
		
		runningTotal = runningTotal * 131 + extra;
	}

	*checksum = runningTotal;
}


void
TryOpeningFile(
	PWCHAR			fileName)
{
	HANDLE		fileHandle;

	fileHandle = CreateFileW(
					fileName,
					GENERIC_READ,
					FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
					NULL,					// security attributes
					OPEN_EXISTING,
					FILE_FLAG_BACKUP_SEMANTICS,
					NULL);					// template file

	if (INVALID_HANDLE_VALUE != fileHandle) {
		CloseHandle(fileHandle);
	}
}

LONG
CsidCompare(
	IN PCSID				id1,
	IN PCSID				id2)
{
	PLONGLONG keyValue1 = (PLONGLONG)id1;
	PLONGLONG keyValue2 = keyValue1 + 1;
	PLONGLONG nodeValue1 = (PLONGLONG)id2;
	PLONGLONG nodeValue2 = nodeValue1 + 1;

	if (*keyValue1 < *nodeValue1) {
		return -1;
	} else if (*keyValue1 > *nodeValue1) {
		return 1;
	} else {
		if (*keyValue2 < *nodeValue2) {
			return -1;
		} else if (*keyValue2 > *nodeValue2) {
			return 1;
		} else {
			return 0;
		}
	}
}

NTSTATUS
FilenameFromCSid(
	IN PCSID						CSid,
	IN PWCHAR						volumeRoot,
	OUT PWCHAR						*fileName)
{
	PWCHAR uuidString;
	RPC_STATUS status;

	*fileName = (PWCHAR)malloc(
						wcslen(volumeRoot) * sizeof(WCHAR)
						+ SIS_CSDIR_STRING_SIZE
						+ INDEX_MAX_NUMERIC_STRING_LENGTH
						+ sizeof(WCHAR));

	if (NULL == *fileName) {
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	wcscpy(*fileName,volumeRoot);
	wcscat(*fileName,SIS_CSDIR_STRING);

	status = UuidToStringW(CSid,(unsigned short **)&uuidString);
	if (RPC_S_OK != status) {
		free(*fileName);
		*fileName = NULL;
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	wcscat(*fileName,uuidString);
	wcscat(*fileName,L".sis");

	RpcStringFreeW((unsigned short **)&uuidString);

	return STATUS_SUCCESS;
}

NTSTATUS
CSidFromFilename(
	IN PWCHAR						FileName,
	OUT PCSID						CSid)
{
#define	UUID_STRING_MAX_LENGTH	100// Should get this length from somewhere better...

	PWCHAR		trailingSlash;
	PWCHAR		dot;
	WCHAR		uuid[UUID_STRING_MAX_LENGTH];	
	DWORD		uuidChars = 0;


	trailingSlash = wcsrchr(FileName, '\\');

	if (NULL == trailingSlash) {
		//
		// Assume that it's just the CS file without the directory name, etc.
		//
		trailingSlash = FileName - 1;
	}

	dot = wcsrchr(FileName, '.');
	if (NULL != dot) {
		uuidChars = (DWORD)(dot - (trailingSlash + 1));
	}

	if ((uuidChars <= 0) || (uuidChars >= UUID_STRING_MAX_LENGTH)) {

		//
		// Something's bogus about the filename.  Give up.
		//
		return STATUS_OBJECT_NAME_INVALID;
	}

	memcpy(uuid,trailingSlash+1,uuidChars * sizeof(WCHAR));
	uuid[uuidChars] = 0;

	if (RPC_S_OK != UuidFromStringW((unsigned short *)uuid,CSid)) {
		return STATUS_OBJECT_NAME_INVALID;
	}

	return STATUS_SUCCESS;
}

NTSTATUS
SisCreateBackupStructureI(
	IN PWCHAR						volumeRoot,
	OUT PVOID						*sisBackupStructure,
	OUT PWCHAR						*commonStoreRootPathname,
	OUT PULONG						countOfCommonStoreFilesToBackup,
	OUT PWCHAR						**commonStoreFilesToBackup)
{
	PSIB_BACKUP_VOLUME_STRUCTURE	backupVolumeStructure;

	backupVolumeStructure = (PSIB_BACKUP_VOLUME_STRUCTURE)malloc(sizeof(SIB_BACKUP_VOLUME_STRUCTURE));

	if (NULL == backupVolumeStructure) {
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	backupVolumeStructure->linkTree = new AVLTree<BackupFileEntry>;

	if (NULL == backupVolumeStructure->linkTree) {
		free(backupVolumeStructure);

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	//
	// Allocate space for our private copy of the volume root name, being sure to leave space for
	// the terminating NULL.
	//
	backupVolumeStructure->volumeRoot = (PWCHAR)malloc((wcslen(volumeRoot) + 1) * sizeof(WCHAR));
	if (NULL == backupVolumeStructure->volumeRoot) {
		delete backupVolumeStructure->linkTree;
		free(backupVolumeStructure);
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	wcscpy(backupVolumeStructure->volumeRoot, volumeRoot);

	//
	// Allocate space for the common store root pathname that we return, being sure
	// to leave room for the terminating NULL.
	//
	*commonStoreRootPathname = (PWCHAR) malloc(SIS_CSDIR_STRING_SIZE + (wcslen(volumeRoot) + 1) * sizeof(WCHAR));
	if (NULL == *commonStoreRootPathname) {
		free(backupVolumeStructure->volumeRoot);
		delete backupVolumeStructure->linkTree;
		free(backupVolumeStructure);
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	wcscpy(*commonStoreRootPathname,volumeRoot);
	wcscat(*commonStoreRootPathname,SIS_CSDIR_STRING);

	InitializeCriticalSection(backupVolumeStructure->criticalSection);

	*countOfCommonStoreFilesToBackup = 0;
	*commonStoreFilesToBackup = NULL;
	*sisBackupStructure = backupVolumeStructure;

	return STATUS_SUCCESS;

}

NTSTATUS
SisCSFilesToBackupForLinkI(
	IN PVOID						sisBackupStructure,
	IN PVOID						reparseData,
	IN ULONG						reparseDataSize,
	IN PVOID						thisFileContext						OPTIONAL,
	OUT PVOID						*matchingFileContext 				OPTIONAL,
	OUT PULONG						countOfCommonStoreFilesToBackup,
	OUT PWCHAR						**commonStoreFilesToBackup)
{
	PREPARSE_DATA_BUFFER 			reparseDataBuffer = (PREPARSE_DATA_BUFFER)reparseData;
	PSI_REPARSE_BUFFER 				sisReparseBuffer = (PSI_REPARSE_BUFFER)reparseDataBuffer->GenericReparseBuffer.DataBuffer;
	BackupFileEntry 				entry[1];
	BackupFileEntry 				*foundEntry, *newEntry;
	PSIB_BACKUP_VOLUME_STRUCTURE 	backupVolumeStructure = (PSIB_BACKUP_VOLUME_STRUCTURE)sisBackupStructure;
	PVOID 							matchedContext = NULL;
	PWCHAR 							CSFileName[MAX_PATH];
	NTSTATUS						status;

	EnterCriticalSection(backupVolumeStructure->criticalSection);

	if (reparseDataSize != SIS_REPARSE_DATA_SIZE) {
		//
		// It's the wrong size to contain a SIS reparse buffer, so we don't
		// want to add any CS files based on it.
		//

		status = STATUS_INVALID_PARAMETER;
		goto Error;
	}

	if (IO_REPARSE_TAG_SIS != reparseDataBuffer->ReparseTag ||
		sizeof(SI_REPARSE_BUFFER) != reparseDataBuffer->ReparseDataLength) {
		//
		// The size or tag is wrong.  Ignore it.
		//

		status = STATUS_INVALID_PARAMETER;
		goto Error;
	}

	if ((SIS_REPARSE_BUFFER_FORMAT_VERSION != sisReparseBuffer->ReparsePointFormatVersion) &&
		(4 != sisReparseBuffer->ReparsePointFormatVersion)) {
		//
		// We don't understand this format SIS reparse point.  This is probably an
		// old dll version.
		//

		status = STATUS_INVALID_PARAMETER;
		goto Error;
	}

	//
	// The only thing we really care about is the CSIndex of the file.  See if we've
	// already backed up a file with a matching CSIndex by looking in the tree.
	//
	entry->CSid = sisReparseBuffer->CSid;
	
	foundEntry = backupVolumeStructure->linkTree->findFirstLessThanOrEqualTo(entry);

	if ((NULL != foundEntry) && (*foundEntry == entry)) {
		//
		// We already returned the CS file that backs this link.  Return the caller's
		// context for that link.
		//
		matchedContext = foundEntry->callerContext;

		goto BackupNoCSFiles;
	}

	//
	// This is the first time we've seen this particular CS file, so back it up.
	//
	newEntry = new BackupFileEntry;
	if (NULL == newEntry) {
		LeaveCriticalSection(backupVolumeStructure->criticalSection);

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	newEntry->callerContext = thisFileContext;
	newEntry->CSid = sisReparseBuffer->CSid;

	if (!backupVolumeStructure->linkTree->insert(newEntry)) {
		delete newEntry;

		LeaveCriticalSection(backupVolumeStructure->criticalSection);

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	if (NULL != matchingFileContext) {
		*matchingFileContext = NULL;
	}
	*countOfCommonStoreFilesToBackup = 1;

	*commonStoreFilesToBackup = (PWCHAR *)malloc(sizeof(PWCHAR) * *countOfCommonStoreFilesToBackup);

	if (NULL == *commonStoreFilesToBackup) {
		backupVolumeStructure->linkTree->remove(newEntry);
		delete newEntry;
		*countOfCommonStoreFilesToBackup = 0;

		LeaveCriticalSection(backupVolumeStructure->criticalSection);

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	status = FilenameFromCSid(
				&sisReparseBuffer->CSid,
				backupVolumeStructure->volumeRoot,
				&(*commonStoreFilesToBackup)[0]);
				
	LeaveCriticalSection(backupVolumeStructure->criticalSection);

	return STATUS_SUCCESS;

BackupNoCSFiles:

	if (NULL != matchingFileContext) {
		*matchingFileContext = matchedContext;
	}
	*countOfCommonStoreFilesToBackup = 0;
	*commonStoreFilesToBackup = NULL;

	LeaveCriticalSection(backupVolumeStructure->criticalSection);

	return STATUS_SUCCESS;

Error:
	
	if (NULL != matchingFileContext) {
		*matchingFileContext = matchedContext;
	}
	*countOfCommonStoreFilesToBackup = 0;
	*commonStoreFilesToBackup = NULL;

	LeaveCriticalSection(backupVolumeStructure->criticalSection);

	return status;
}

NTSTATUS
SisFreeBackupStructureI(
	IN PVOID						sisBackupStructure)
{
	PSIB_BACKUP_VOLUME_STRUCTURE backupVolumeStructure = (PSIB_BACKUP_VOLUME_STRUCTURE)sisBackupStructure;
	BackupFileEntry *entry;

	while (!backupVolumeStructure->linkTree->empty()) {
		entry = backupVolumeStructure->linkTree->findMin();

		assert(NULL != entry);

		backupVolumeStructure->linkTree->remove(entry);

		delete entry;
	}

	free(backupVolumeStructure->volumeRoot);
	delete backupVolumeStructure->linkTree;

	DeleteCriticalSection(backupVolumeStructure->criticalSection);

	free(backupVolumeStructure);

	return STATUS_SUCCESS;
}

NTSTATUS
SisCreateRestoreStructureI(
	IN PWCHAR						volumeRoot,
	OUT PVOID						*sisRestoreStructure,
	OUT PWCHAR						*commonStoreRootPathname,
	OUT PULONG						countOfCommonStoreFilesToRestore,
	OUT PWCHAR						**commonStoreFilesToRestore)
{
	PSIB_RESTORE_VOLUME_STRUCTURE	restoreVolumeStructure;
	DWORD							sectorsPerCluster, freeClusters, totalClusters;

	restoreVolumeStructure = (PSIB_RESTORE_VOLUME_STRUCTURE)malloc(sizeof(SIB_RESTORE_VOLUME_STRUCTURE));

	if (NULL == restoreVolumeStructure) {
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	restoreVolumeStructure->linkTree = new AVLTree<RestoreFileEntry>;

	if (NULL == restoreVolumeStructure->linkTree) {
		free(restoreVolumeStructure);

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	//
	// Allocate space for our private copy of the volume root name, being sure to leave space for
	// the terminating NULL.
	//
	restoreVolumeStructure->volumeRoot = (PWCHAR)malloc((wcslen(volumeRoot) + 1) * sizeof(WCHAR));
	if (NULL == restoreVolumeStructure->volumeRoot) {
		delete restoreVolumeStructure->linkTree;
		free(restoreVolumeStructure);
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	wcscpy(restoreVolumeStructure->volumeRoot, volumeRoot);

	//
	// Allocate space for the common store root pathname that we return, being sure
	// to leave room for the terminating NULL.
	//
	*commonStoreRootPathname = (PWCHAR) malloc(SIS_CSDIR_STRING_SIZE + (wcslen(volumeRoot) + 1) * sizeof(WCHAR));
	if (NULL == *commonStoreRootPathname) {
		free(restoreVolumeStructure->volumeRoot);
		delete restoreVolumeStructure->linkTree;
		free(restoreVolumeStructure);

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	wcscpy(*commonStoreRootPathname,volumeRoot);
	wcscat(*commonStoreRootPathname,SIS_CSDIR_STRING);

	InitializeCriticalSection(restoreVolumeStructure->criticalSection);

	*countOfCommonStoreFilesToRestore = 0;
	*commonStoreFilesToRestore = NULL;

	if (!GetDiskFreeSpaceW(
			volumeRoot,
			&sectorsPerCluster,
			&restoreVolumeStructure->VolumeSectorSize,
			&freeClusters,
			&totalClusters)) {
		//
		// The call failed.  Just assume it's 512 bytes.
		//
		restoreVolumeStructure->VolumeSectorSize = 512;
	}

	restoreVolumeStructure->sector = (PSIS_BACKPOINTER)malloc(restoreVolumeStructure->VolumeSectorSize);
	if (NULL == restoreVolumeStructure->sector) {
		free(restoreVolumeStructure->volumeRoot);
		delete restoreVolumeStructure->linkTree;
		free(restoreVolumeStructure);

		free(*commonStoreRootPathname);
		*commonStoreRootPathname = NULL;

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	restoreVolumeStructure->alignedSectorBuffer = (PVOID)malloc(restoreVolumeStructure->VolumeSectorSize * 2);
	if (NULL == restoreVolumeStructure->alignedSectorBuffer) {
		free(restoreVolumeStructure->sector);

		free(restoreVolumeStructure->volumeRoot);
		delete restoreVolumeStructure->linkTree;
		free(restoreVolumeStructure);

		free(*commonStoreRootPathname);
		*commonStoreRootPathname = NULL;

		return STATUS_INSUFFICIENT_RESOURCES;
	}
	restoreVolumeStructure->alignedSector = (PVOID)((
			((UINT_PTR)restoreVolumeStructure->alignedSectorBuffer +
				restoreVolumeStructure->VolumeSectorSize) /
					restoreVolumeStructure->VolumeSectorSize) *
					restoreVolumeStructure->VolumeSectorSize);

	ASSERT(restoreVolumeStructure->alignedSector >= restoreVolumeStructure->alignedSectorBuffer);
	ASSERT((PCHAR)restoreVolumeStructure->alignedSectorBuffer + restoreVolumeStructure->VolumeSectorSize >= (PCHAR)restoreVolumeStructure->alignedSector);

	memset(restoreVolumeStructure->alignedSector,255,restoreVolumeStructure->VolumeSectorSize);

	*sisRestoreStructure = restoreVolumeStructure;

	return STATUS_SUCCESS;
}

NTSTATUS
SisFixValidDataLengthI(
	PSIB_RESTORE_VOLUME_STRUCTURE	restoreVolumeStructure,
	IN HANDLE						restoredFileHandle)
{
#define	BIGGER_THAN_AN_ALLOCATION_REGION		(128 * 1024)	// should get this from somewhere else
	//
	// Figure out if we need to extend ValidDataLength.  We need to do this
	// if the final range of the file is unallocated.
	//
	FILE_STANDARD_INFORMATION		standardInfo[1];
	FILE_END_OF_FILE_INFORMATION	endOfFileInfo[1];
	FILE_ALLOCATED_RANGE_BUFFER		inArb[1];
	const unsigned					outArbSize = 10;
	FILE_ALLOCATED_RANGE_BUFFER		outArb[outArbSize];
	NTSTATUS						status;
	IO_STATUS_BLOCK					Iosb[1];
	DWORD							bytesReturned;
	LARGE_INTEGER					rangeToZero;
	FILE_BASIC_INFORMATION			basicInfo[1];
	BOOLEAN							basicInfoValid = FALSE;
	DWORD							nBytesWritten;
	unsigned						i;
	FILE_ZERO_DATA_INFORMATION		zeroInfo[1];
	LARGE_INTEGER					WriteOffset;

	status = NtQueryInformationFile(
				restoredFileHandle,
				Iosb,
				standardInfo,
				sizeof(FILE_STANDARD_INFORMATION),
				FileStandardInformation);
	if (!NT_SUCCESS(status)) {
#if		DBG
		DbgPrint("SisFixValidDataLength: unable to query standard info on link file, 0x%x\n",status);
#endif	// DBG
		return status;
	}
	ASSERT(STATUS_PENDING != status);
	endOfFileInfo->EndOfFile = standardInfo->EndOfFile;

	if (standardInfo->EndOfFile.QuadPart > BIGGER_THAN_AN_ALLOCATION_REGION) {
		rangeToZero.QuadPart = inArb->FileOffset.QuadPart = standardInfo->EndOfFile.QuadPart - BIGGER_THAN_AN_ALLOCATION_REGION;
		rangeToZero.QuadPart -= rangeToZero.QuadPart % BIGGER_THAN_AN_ALLOCATION_REGION;	// round it down.
	} else {
		rangeToZero.QuadPart = inArb->FileOffset.QuadPart = 0;
	}
	inArb->Length.QuadPart = MAXLONGLONG - inArb->FileOffset.QuadPart;

	if (!DeviceIoControl(
			restoredFileHandle,
			FSCTL_QUERY_ALLOCATED_RANGES,
			inArb,
			sizeof(FILE_ALLOCATED_RANGE_BUFFER),
			outArb,
			sizeof(FILE_ALLOCATED_RANGE_BUFFER) * outArbSize,
			&bytesReturned,
			NULL)) {						// lap
#if		DBG
		DbgPrint("SisFixValidDataLength: unable to query allocated ranges on link file, %d\n",GetLastError());
#endif	// DBG
		return STATUS_UNSUCCESSFUL;
	}

	ASSERT(bytesReturned / sizeof(FILE_ALLOCATED_RANGE_BUFFER) < outArbSize);	// this relies on knowledge about the minimum allocated range size
	ASSERT(bytesReturned % sizeof(FILE_ALLOCATED_RANGE_BUFFER) == 0);

	if (bytesReturned > 0) {
		unsigned lastElement = bytesReturned/sizeof(FILE_ALLOCATED_RANGE_BUFFER) - 1;
		ASSERT(lastElement < outArbSize);
		rangeToZero.QuadPart = outArb[lastElement].FileOffset.QuadPart + outArb[lastElement].Length.QuadPart;
	}

	status = NtQueryInformationFile(
				restoredFileHandle,
				Iosb,
				basicInfo,
				sizeof(FILE_BASIC_INFORMATION),
				FileBasicInformation);
	if (NT_SUCCESS(status)) {
		ASSERT(STATUS_PENDING != status);	// because we didn't open the file for overlapped.
		basicInfoValid = TRUE;
	} else {
#if		DBG
		DbgPrint("SisFixValidDataLength: unable to query basic info on link file, 0x%x\n",status);
#endif	// DBG
	}

	WriteOffset.QuadPart = ((standardInfo->EndOfFile.QuadPart +
							 restoreVolumeStructure->VolumeSectorSize +
							 BIGGER_THAN_AN_ALLOCATION_REGION) / restoreVolumeStructure->VolumeSectorSize) *
									restoreVolumeStructure->VolumeSectorSize;
	ASSERT(WriteOffset.QuadPart >= standardInfo->EndOfFile.QuadPart);
	ASSERT(standardInfo->EndOfFile.QuadPart + restoreVolumeStructure->VolumeSectorSize < WriteOffset.QuadPart);

	if ((WriteOffset.LowPart != SetFilePointer(
									restoredFileHandle,
									WriteOffset.LowPart,
									&WriteOffset.HighPart,
									FILE_BEGIN))
		|| (NO_ERROR != GetLastError())) {
#if		DBG
		DbgPrint("SisFixValidDataLength: unable to SetFilePointer, %d\n",GetLastError());
#endif	// DBG
		return STATUS_UNSUCCESSFUL;
	}

	if (!WriteFile(restoredFileHandle,
					restoreVolumeStructure->alignedSectorBuffer,
					restoreVolumeStructure->VolumeSectorSize,						// bytes to write
					&nBytesWritten,
					NULL)) {				// overlapped
#if		DBG
		DbgPrint("SisFixValidDataLength: unable to append a byte to advance ValidDataLength, %d\n",GetLastError());
#endif	// DBG
	}

	//
	// Truncate the file, erasing the sector we just wrote.
	//
	status = NtSetInformationFile(
				restoredFileHandle,
				Iosb,
				endOfFileInfo,
				sizeof(FILE_END_OF_FILE_INFORMATION),
				FileEndOfFileInformation);

	if (rangeToZero.QuadPart < standardInfo->EndOfFile.QuadPart) {
		//
		// Re-zero the end of the file in order to deallocate it.
		//
		zeroInfo->FileOffset = rangeToZero;
		zeroInfo->BeyondFinalZero.QuadPart = MAXLONGLONG;

		if (!DeviceIoControl(
				restoredFileHandle,
				FSCTL_SET_ZERO_DATA,
				zeroInfo,
				sizeof(FILE_ZERO_DATA_INFORMATION),
				NULL,								// output buffer
				0,									// o.b. size
				&bytesReturned,
				NULL)) {							// overlapped
#if		DBG
			DbgPrint("SisFixValidDataLength: unable to zero trailing portion of file, %d\n",GetLastError());
#endif	// DBG
		}
	}

#if		DBG
	if (!NT_SUCCESS(status)) {
		DbgPrint("SisFixValidDataLength: unable to truncate file after extending it to advance ValidDataLength, 0x%x\n",status);
	}
#endif	// DBG


	//
	// Reset the dates on the file.
	//
	status = NtSetInformationFile(
				restoredFileHandle,
				Iosb,
				basicInfo,
				sizeof(FILE_BASIC_INFORMATION),
				FileBasicInformation);
#if		DBG
	if (!NT_SUCCESS(status)) {
		DbgPrint("SisFixValidDataLength: unable to reset times after extending file to advance ValidDataLength, 0x%x\n",status);
	}
#endif	// DBG

	return status;
}


NTSTATUS
SisRestoredLinkI(
	IN PVOID						sisRestoreStructure,
	IN PWCHAR						restoredFileName,
	IN PVOID						reparseData,
	IN ULONG						reparseDataSize,
	OUT PULONG						countOfCommonStoreFilesToRestore,
	OUT PWCHAR						**commonStoreFilesToRestore)
{
	PSIB_RESTORE_VOLUME_STRUCTURE	restoreVolumeStructure = (PSIB_RESTORE_VOLUME_STRUCTURE)sisRestoreStructure;
	PREPARSE_DATA_BUFFER 			reparseDataBuffer = (PREPARSE_DATA_BUFFER)reparseData;
	PSI_REPARSE_BUFFER 				sisReparseBuffer = (PSI_REPARSE_BUFFER)reparseDataBuffer->GenericReparseBuffer.DataBuffer;
	RestoreFileEntry 				entry[1];
	RestoreFileEntry 				*foundEntry, *newEntry;
	PWCHAR							CSFileName = NULL;
	BOOLEAN							foundCSFile;
	HANDLE							fileHandle;
	BOOLEAN							openFile = TRUE;
	NTSTATUS						status;
	DWORD							bytesReturned;
	DWORD							fileAttributes;
	BOOLEAN							readonlyAttributeCleared = FALSE;

	EnterCriticalSection(restoreVolumeStructure->criticalSection);

	if (NonSISEnabledVolume(restoreVolumeStructure)) {
		//
		// This isn't a SIS enabled volume, so tell the user that.
		// There's no NT status code corresponding to ERROR_VOLUME_NOT_SIS_ENABLED,
		// so we set the win32 code and return STATUS_UNSUCCESSFUL, which makes
		// the wrapper function not change the win32 error.
		//

		SetLastError(ERROR_VOLUME_NOT_SIS_ENABLED);

		status = STATUS_UNSUCCESSFUL;
		goto Error;
	}

	//
	// Do consistency checks on the reparse point to see if we can understand it.
	//	

	if (reparseDataSize != SIS_REPARSE_DATA_SIZE) {
		//
		// It's the wrong size to contain a SIS reparse buffer, so we don't
		// want to restore any CS files based on it.
		//

		status = STATUS_INVALID_PARAMETER;
		goto Error;
	}

	if (IO_REPARSE_TAG_SIS != reparseDataBuffer->ReparseTag ||
		sizeof(SI_REPARSE_BUFFER) != reparseDataBuffer->ReparseDataLength) {
		//
		// The size or tag is wrong.  Ignore it.
		//

		status = STATUS_INVALID_PARAMETER;
		goto Error;
	}

	if ((SIS_REPARSE_BUFFER_FORMAT_VERSION != sisReparseBuffer->ReparsePointFormatVersion) &&
		(4 != sisReparseBuffer->ReparsePointFormatVersion)) {
		//
		// We don't understand this format SIS reparse point.  This is probably an
		// old dll version.
		//

		status = STATUS_INVALID_PARAMETER;
		goto Error;
	}

	//
	// The only thing we really care about is the CSid and checksum of the file.  See if we've
	// already returned a file with a matching CSid by looking in the tree.
	//
	entry->CSid = sisReparseBuffer->CSid;
	
	foundEntry = restoreVolumeStructure->linkTree->findFirstLessThanOrEqualTo(entry);

	if ((NULL != foundEntry) && (*foundEntry == entry)) {
		//
		// We already returned the CS file that backs this link.  Enter the name of this file
		// on the linked list for this CS file.
		//

		PendingRestoredFile *restoredFile = new PendingRestoredFile;
		if (NULL == restoredFile) {
			LeaveCriticalSection(restoreVolumeStructure->criticalSection);

#if		DBG
			DbgPrint("couldn't allocate restored file\n");
#endif	// DBG

			return STATUS_INSUFFICIENT_RESOURCES;
		}

		restoredFile->fileName = (PWCHAR) malloc((wcslen(restoredFileName) + 1) * sizeof(WCHAR) );
		if (NULL == restoredFile->fileName) {
			delete restoredFile;

#if		DBG
			DbgPrint("couldn't allocate restored file filename\n");
#endif	// DBG
			LeaveCriticalSection(restoreVolumeStructure->criticalSection);
			return STATUS_INSUFFICIENT_RESOURCES;
		}

		wcscpy(restoredFile->fileName,restoredFileName);
		restoredFile->CSFileChecksum = sisReparseBuffer->CSChecksum;
		restoredFile->next = foundEntry->files;
		foundEntry->files = restoredFile;
		
		goto RestoreNoCSFiles;
	}

	//
	// This is the first time we've seen this particular CS file.  See if it still
	// exists in the \SIS Common Store directory.
	//

	status = FilenameFromCSid(&sisReparseBuffer->CSid,restoreVolumeStructure->volumeRoot,&CSFileName);

	if (!NT_SUCCESS(status)) {
		if (NULL != CSFileName) {
			free(CSFileName);
		}
		LeaveCriticalSection(restoreVolumeStructure->criticalSection);
		return status;
	}

	fileHandle = CreateFileW(
					CSFileName,
					GENERIC_READ | GENERIC_WRITE,
					FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
					NULL,
					OPEN_EXISTING,
					FILE_ATTRIBUTE_NORMAL,
					NULL);

	if (INVALID_HANDLE_VALUE == fileHandle) {
		if (GetLastError() == ERROR_SHARING_VIOLATION) {
			//
			// The file exists, we just couldn't open it.
			//
			foundCSFile = TRUE;
		} else {
			foundCSFile = FALSE;
		}
	} else {
		foundCSFile = TRUE;
		CloseHandle(fileHandle);
	}

	if (foundCSFile) {
		//
		// We don't add it to the tree here, even though that might speed up things somewhat.
		// The reason is that someone could come along and delete all of the references to the
		// file (including the one that we just created) and then the backing file would go away.
		// If we'd entered it in the tree, and we try to restore a subsequent link to the file,
		// we'd not notice that the backing file was gone and would restore a dangling link.
		//

		openFile = FALSE;	// There's no need to open this file, since it's a good link.

		HANDLE restoredFileHandle = CreateFileW(
										restoredFileName,
										GENERIC_READ | GENERIC_WRITE,
										FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
										NULL,
										OPEN_EXISTING,
										FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_NO_BUFFERING|FILE_OPEN_REPARSE_POINT,
										NULL);

		if (INVALID_HANDLE_VALUE == restoredFileHandle) {
			fileAttributes = GetFileAttributesW(restoredFileName);

			if (fileAttributes & FILE_ATTRIBUTE_READONLY) {
				DWORD newFileAttributes = fileAttributes & ~FILE_ATTRIBUTE_READONLY;
				if (0 == newFileAttributes) {
					newFileAttributes = FILE_ATTRIBUTE_NORMAL;
				}

				if (!SetFileAttributesW(restoredFileName,newFileAttributes)) {
#if		DBG
					DbgPrint("sisbkup: SisRestoredLinkI: unable to reset read only attribute on link, %d\n",GetLastError());
#endif	DBG
				} else {
					readonlyAttributeCleared = TRUE;
				}

				//
				// Now that we've (tried to) cleared the read only attribute, re-try the file open.
				//
				restoredFileHandle = CreateFileW(
										restoredFileName,
										GENERIC_READ | GENERIC_WRITE,
										FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
										NULL,
										OPEN_EXISTING,
										FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_NO_BUFFERING|FILE_OPEN_REPARSE_POINT,
										NULL);
			}
		}

		if (INVALID_HANDLE_VALUE != restoredFileHandle) {
			
		} else {
#if		DBG
			DbgPrint("SisRestoredLinkI: Unable to open link file in order to fix ValidDataLength, %d\n",::GetLastError());
#endif	// DBG

			status = STATUS_UNSUCCESSFUL;	// This will leave the win32 error code undisturbed
			goto Error;
		}

		CHAR reparseBuffer[SIS_REPARSE_DATA_SIZE];
		
		if (!DeviceIoControl(
				restoredFileHandle,
				FSCTL_GET_REPARSE_POINT,
				0,
				NULL,
				reparseBuffer,
				SIS_REPARSE_DATA_SIZE,
				&bytesReturned,
				NULL)) {
#if		DBG
			DbgPrint("SisRestoredLinkI: Unable to get reparse point, %d\n",::GetLastError());
#endif	// DBG
			
			status = STATUS_UNSUCCESSFUL;	// This will leave the win32 error code undisturbed
			goto Error;
		}

		status = SisFixValidDataLengthI(restoreVolumeStructure,restoredFileHandle);


		if (!NT_SUCCESS(status)) {
#if		DBG
			DbgPrint("SisRestoredLink: unable to fix up valid data length, 0x%x, %d\n",status,::GetLastError());
#endif	// DBG
			CloseHandle(restoredFileHandle);
			goto Error;
		}

		//
		// Reset the reparse point, which has been destroyed by the last operation.
		//

		if (!DeviceIoControl(
				restoredFileHandle,
				FSCTL_SET_REPARSE_POINT,
				reparseData,
				reparseDataSize,
				NULL,
				0,
				&bytesReturned,
				NULL)) {
#if		DBG
			DbgPrint("SisRestoredLink: unable to reset reparse point, %d\n",::GetLastError());
#endif	// DBG
			CloseHandle(restoredFileHandle);
			status = STATUS_UNSUCCESSFUL;	// This will leave the win32 error code undisturbed

			goto Error;
		}

		CloseHandle(restoredFileHandle);

		if (readonlyAttributeCleared) {
			SetFileAttributesW(restoredFileName,fileAttributes);
			readonlyAttributeCleared = FALSE;
		}

		goto RestoreNoCSFiles;
	}

	//
	// It's not already in the common store directory.  Enter it in the tree and return it to
	// the user.
	//

	newEntry = new RestoreFileEntry;
	if (NULL == newEntry) {
		LeaveCriticalSection(restoreVolumeStructure->criticalSection);

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	newEntry->CSid = sisReparseBuffer->CSid;

	newEntry->files = new PendingRestoredFile;
	if (NULL == newEntry->files) {
		LeaveCriticalSection(restoreVolumeStructure->criticalSection);

		delete newEntry;
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	newEntry->files->next = NULL;
	newEntry->files->fileName = (PWCHAR) malloc((wcslen(restoredFileName) + 1) * sizeof(WCHAR));
	newEntry->files->CSFileChecksum = sisReparseBuffer->CSChecksum;
	if (NULL == newEntry->files->fileName) {
		LeaveCriticalSection(restoreVolumeStructure->criticalSection);

		delete newEntry->files;
		delete newEntry;

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	wcscpy(newEntry->files->fileName,restoredFileName);

	if (!restoreVolumeStructure->linkTree->insert(newEntry)) {
		*countOfCommonStoreFilesToRestore = 0;
		
		LeaveCriticalSection(restoreVolumeStructure->criticalSection);

		delete newEntry->files;
		delete newEntry;		

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	*countOfCommonStoreFilesToRestore = 1;

	*commonStoreFilesToRestore = (PWCHAR *)malloc(sizeof(PWCHAR) * *countOfCommonStoreFilesToRestore);

	if (NULL == *commonStoreFilesToRestore) {
		restoreVolumeStructure->linkTree->remove(newEntry);
		*countOfCommonStoreFilesToRestore = 0;
		
		LeaveCriticalSection(restoreVolumeStructure->criticalSection);

		delete newEntry->files;
		delete newEntry;

		return STATUS_INSUFFICIENT_RESOURCES;
	}

	status = FilenameFromCSid(
				&sisReparseBuffer->CSid,
				restoreVolumeStructure->volumeRoot,
				&(*commonStoreFilesToRestore)[0]);

	if (!NT_SUCCESS(status)) {
		restoreVolumeStructure->linkTree->remove(newEntry);
		*countOfCommonStoreFilesToRestore = 0;
		
		LeaveCriticalSection(restoreVolumeStructure->criticalSection);

		free(*commonStoreFilesToRestore);

		delete newEntry->files;
		delete newEntry;

		return status;
	}
				
	if (openFile) {
		TryOpeningFile(restoredFileName);
	}

	LeaveCriticalSection(restoreVolumeStructure->criticalSection);

	return STATUS_SUCCESS;

RestoreNoCSFiles:

	*countOfCommonStoreFilesToRestore = 0;
	*commonStoreFilesToRestore = NULL;

	if (openFile) {
		TryOpeningFile(restoredFileName);
	}

	LeaveCriticalSection(restoreVolumeStructure->criticalSection);

	return STATUS_SUCCESS;

Error:

	*countOfCommonStoreFilesToRestore = 0;
	*commonStoreFilesToRestore = NULL;

	if (readonlyAttributeCleared) {
		SetFileAttributesW(restoredFileName,fileAttributes);
	}

	if (openFile) {
		TryOpeningFile(restoredFileName);
	}

	LeaveCriticalSection(restoreVolumeStructure->criticalSection);

	return status;
}

NTSTATUS
SisRestoredCommonStoreFileI(
	IN PVOID						sisRestoreStructure,
	IN PWCHAR						commonStoreFileName)
{
	PSIB_RESTORE_VOLUME_STRUCTURE	restoreVolumeStructure = (PSIB_RESTORE_VOLUME_STRUCTURE)sisRestoreStructure;
	HANDLE							fileHandle = INVALID_HANDLE_VALUE;
	NTSTATUS						status;
	DWORD							bytesRead, bytesWritten;
	LONGLONG						checksum;
	CSID							CSid;
	RestoreFileEntry 				entry[1];
	RestoreFileEntry 				*foundEntry, *newEntry;
	PWCHAR							BPStreamName = NULL;

	status = CSidFromFilename(commonStoreFileName,&CSid);

	if (!NT_SUCCESS(status)) {
		//
		// It was a bogus filename.  Punt.
		//

		return status;
	}

	BPStreamName = (PWCHAR) malloc((wcslen(commonStoreFileName) + 1) * sizeof(WCHAR) + BACKPOINTER_STREAM_NAME_SIZE);
	if (NULL == BPStreamName) {
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	wcscpy(BPStreamName, commonStoreFileName);
	wcscat(BPStreamName, BACKPOINTER_STREAM_NAME);

	//
	// We just need to reinitialize the backpointer stream for this file so that it looks like
	// it has no references.
	//

	EnterCriticalSection(restoreVolumeStructure->criticalSection);

	if (NonSISEnabledVolume(restoreVolumeStructure)) {
		//
		// This isn't a SIS enabled volume, so tell the user that.
		// There's no NT status code corresponding to ERROR_VOLUME_NOT_SIS_ENABLED,
		// so we set the win32 code and return STATUS_UNSUCCESSFUL, which makes
		// the wrapper function not change the win32 error.
		//

		SetLastError(ERROR_VOLUME_NOT_SIS_ENABLED);
		status = STATUS_UNSUCCESSFUL;
		goto Error;
	}

	//
	// Now open the file.
	//

	fileHandle = CreateFileW(
					BPStreamName,
					GENERIC_READ | GENERIC_WRITE,
					0,								// exclusive
					NULL,
					OPEN_EXISTING,
					FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS,
					NULL);

	free(BPStreamName);
	BPStreamName = NULL;

	if (INVALID_HANDLE_VALUE == fileHandle) {
		status = STATUS_UNSUCCESSFUL;		// This will cause the C wrapper to not call SetLastError
#if		DBG
		DbgPrint("SisRestoredCommonStoreFile: unable to open common store file, %d\n",GetLastError());
#endif	// DBG
		goto Error;
	}

	//
	// Read in the first sector.
	//
	if (!ReadFile(
			fileHandle,
			restoreVolumeStructure->sector,
			restoreVolumeStructure->VolumeSectorSize,
			&bytesRead,
			NULL)) {

		status = STATUS_UNSUCCESSFUL;		// This will cause the C wrapper to not call SetLastError
#if		DBG
		DbgPrint("SisRestoredCommonStoreFile: Unable to read in first BP sector, %d\n",GetLastError());
#endif	// DBG
		goto Error;
	}

	if (bytesRead < sizeof(SIS_BACKPOINTER_STREAM_HEADER)) {

		status = STATUS_UNSUCCESSFUL;		// This will cause the C wrapper to not call SetLastError
		goto Error;
	}

#define	Header ((PSIS_BACKPOINTER_STREAM_HEADER)restoreVolumeStructure->sector)

	if ((BACKPOINTER_STREAM_FORMAT_VERSION != Header->FormatVersion) ||
		(BACKPOINTER_MAGIC != Header->Magic)) {
#undef	Header

#if		DBG
		DbgPrint("SisRectoredCommonStoreFile: restored CS file has bogus header format version/Magic\n");
#endif	// DBG
		
	} else {
		//
		// Fill in the backpointer portion of the sector with
		// null entries.
		//
		for (unsigned i = SIS_BACKPOINTER_RESERVED_ENTRIES;
			 i < (restoreVolumeStructure->VolumeSectorSize / sizeof(SIS_BACKPOINTER));
			 i++) {
			restoreVolumeStructure->sector[i].LinkFileIndex.QuadPart = MAXLONGLONG;
			restoreVolumeStructure->sector[i].LinkFileNtfsId.QuadPart = MAXLONGLONG;
		}

		//
		// Write out the new sector.
		//
		SetFilePointer(fileHandle,0,NULL,FILE_BEGIN);
	
		if (!WriteFile(
			fileHandle,
			restoreVolumeStructure->sector,
			restoreVolumeStructure->VolumeSectorSize,
			&bytesWritten,
			NULL)) {
#if		DBG	
			DbgPrint("SisRestoredCommonStoreFile: write failed %d\n",GetLastError());
#endif	// DBG
		}
	}

	//
	// Make the stream be exactly one sector long.
	//
	SetFilePointer(fileHandle,restoreVolumeStructure->VolumeSectorSize,NULL,FILE_BEGIN);
	SetEndOfFile(fileHandle);

	CloseHandle(fileHandle);
	fileHandle = INVALID_HANDLE_VALUE;

	//
	// Look up in the tree and find the files that we restored to this link.
	// Open them and rewrite their reparse points.
	//

	entry->CSid = CSid;

	foundEntry = restoreVolumeStructure->linkTree->findFirstLessThanOrEqualTo(entry);
	if ((NULL != foundEntry) && (*foundEntry == entry)) {
		//
		// We've got a match.  Cruise the list and set the reparse points on all of the
		// files.
		//


		while (NULL != foundEntry->files) {
			HANDLE					restoredFileHandle;
			PendingRestoredFile		*thisFile = foundEntry->files;
			DWORD					bytesReturned;
			DWORD					fileAttributes;
			BOOLEAN					readOnlyAttributeCleared = FALSE;

			restoredFileHandle = CreateFileW(
									thisFile->fileName,
									GENERIC_READ | GENERIC_WRITE,
									0,								// exclusive
									NULL,
									OPEN_EXISTING,
									FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_NO_BUFFERING,
									NULL);

			if (INVALID_HANDLE_VALUE == restoredFileHandle) {
				//
				// Check the read only file attribute, and reset it if necessary.
				//
				fileAttributes = GetFileAttributesW(thisFile->fileName);
				if (fileAttributes & FILE_ATTRIBUTE_READONLY) {
					DWORD newFileAttributes = fileAttributes & ~FILE_ATTRIBUTE_READONLY;
					if (0 == newFileAttributes) {
						newFileAttributes = FILE_ATTRIBUTE_NORMAL;
					}
					if (!SetFileAttributesW(thisFile->fileName,newFileAttributes)) {
#if		DBG
						DbgPrint("sisbkup: unable to clear read only attribute on file %ws\n",thisFile->fileName);
#endif	// DBG
					}
					readOnlyAttributeCleared = TRUE;

					restoredFileHandle = CreateFileW(
											thisFile->fileName,
											GENERIC_READ | GENERIC_WRITE,
											0,								// exclusive
											NULL,
											OPEN_EXISTING,
											FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_NO_BUFFERING,
											NULL);

				}
			} 

			if (INVALID_HANDLE_VALUE != restoredFileHandle) {
				SisFixValidDataLengthI(restoreVolumeStructure, restoredFileHandle);
				
				//
				// Rewrite the reparse point.
				//
				CHAR reparseBuffer[SIS_REPARSE_DATA_SIZE];
				PSI_REPARSE_BUFFER sisReparseBuffer;
#define	reparseData ((PREPARSE_DATA_BUFFER)reparseBuffer)

				reparseData->ReparseTag = IO_REPARSE_TAG_SIS;
				reparseData->Reserved = 0xb010;		// ??
				reparseData->ReparseDataLength = sizeof(SI_REPARSE_BUFFER);

				sisReparseBuffer = (PSI_REPARSE_BUFFER)reparseData->GenericReparseBuffer.DataBuffer;

				sisReparseBuffer->ReparsePointFormatVersion = SIS_REPARSE_BUFFER_FORMAT_VERSION;
				sisReparseBuffer->Reserved = 0xb111b010;
				sisReparseBuffer->CSid = CSid;
				sisReparseBuffer->LinkIndex.QuadPart = 0;			// This just gets reset by the filter driver
			    sisReparseBuffer->LinkFileNtfsId.QuadPart = 0;		// This just gets reset by the filter driver
			    sisReparseBuffer->CSFileNtfsId.QuadPart	= 0;		// This just gets reset by the filter driver

				//
				// Use the CS file checksum that was read from the reparse point on the backup
				// tape.  We need this for security reasons, because otherwise a bogus backed up
				// link could suddenly become valid.
				//

				sisReparseBuffer->CSChecksum = thisFile->CSFileChecksum;

			    //
			    // Compute the checksum.
			    //
				sisReparseBuffer->Checksum.QuadPart = 0;
			    SipComputeChecksum(
				    sisReparseBuffer,
				    sizeof(SI_REPARSE_BUFFER) - sizeof sisReparseBuffer->Checksum,
				    &sisReparseBuffer->Checksum.QuadPart);

				//
				// Set the reparse point.
				//
				if (!DeviceIoControl(
						restoredFileHandle,
						FSCTL_SET_REPARSE_POINT,
						reparseBuffer,
						FIELD_OFFSET(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) +
							reparseData->ReparseDataLength,
						NULL,
						0,
						&bytesReturned,
						NULL)) {
#if		DBG
					DbgPrint("sisbackup: SisRestoredCommonStoreFile: set reparse point failed %d\n",GetLastError());
#endif	// DBG
				}

				CloseHandle(restoredFileHandle);
				
#undef	reparseData
			} else {
#if		DBG
				DbgPrint("sisbackup: unable to open link file for file %ws, %d\n",thisFile->fileName,GetLastError());
#endif	// DBG
			}

			if (readOnlyAttributeCleared) {
				if (!SetFileAttributesW(thisFile->fileName,fileAttributes)) {
#if		DBG
					DbgPrint("sisbackup: unable to reset read only attribute on %ws\n",thisFile->fileName);
#endif	// DBG
				}
			}

			foundEntry->files = thisFile->next;
			free(thisFile->fileName);
			delete thisFile;
		}

		restoreVolumeStructure->linkTree->remove(foundEntry);
		delete foundEntry;
	} else {
#if		DBG
		DbgPrint("restored common store file: didn't find tree match\n");
#endif	// DBG
	}


	LeaveCriticalSection(restoreVolumeStructure->criticalSection);

	return STATUS_SUCCESS;

Error:

	if (INVALID_HANDLE_VALUE != fileHandle) {
		CloseHandle(fileHandle);
	}

	LeaveCriticalSection(restoreVolumeStructure->criticalSection);

	return status;
}

NTSTATUS
SisFreeRestoreStructureI(
	IN PVOID						sisRestoreStructure)
{
	PSIB_RESTORE_VOLUME_STRUCTURE	restoreVolumeStructure = (PSIB_RESTORE_VOLUME_STRUCTURE)sisRestoreStructure;
	RestoreFileEntry *entry;

	//
	// Cruise the link tree and clean up any remaining file entries.
	//
	while (NULL != (entry = restoreVolumeStructure->linkTree->findMin())) {

		while (NULL != entry->files) {
			PendingRestoredFile *thisFile = entry->files;

			entry->files = thisFile->next;

			free(thisFile->fileName);
			delete thisFile;
		}

		restoreVolumeStructure->linkTree->remove(entry);
	}

	DeleteCriticalSection(restoreVolumeStructure->criticalSection);

	free(restoreVolumeStructure->sector);
	free(restoreVolumeStructure->alignedSectorBuffer);
    free(restoreVolumeStructure->volumeRoot);
	delete restoreVolumeStructure->linkTree;
	free(restoreVolumeStructure);

	return STATUS_SUCCESS;
}


extern "C" {

BOOL __stdcall
SisCreateBackupStructure(
	IN PWCHAR						volumeRoot,
	OUT PVOID						*sisBackupStructure,
	OUT PWCHAR						*commonStoreRootPathname,
	OUT PULONG						countOfCommonStoreFilesToBackup,
	OUT PWCHAR						**commonStoreFilesToBackup)
{
	NTSTATUS status;

	status = SisCreateBackupStructureI(
						volumeRoot,
						sisBackupStructure,
						commonStoreRootPathname,
						countOfCommonStoreFilesToBackup,
						commonStoreFilesToBackup);

	if (STATUS_UNSUCCESSFUL != status) {
		SetLastError(RtlNtStatusToDosError(status));
	}
	return NT_SUCCESS(status);
}


BOOL __stdcall
SisCSFilesToBackupForLink(
	IN PVOID						sisBackupStructure,
	IN PVOID						reparseData,
	IN ULONG						reparseDataSize,
	IN PVOID						thisFileContext						OPTIONAL,
	OUT PVOID						*matchingFileContext 				OPTIONAL,
	OUT PULONG						countOfCommonStoreFilesToBackup,
	OUT PWCHAR						**commonStoreFilesToBackup)
{
	NTSTATUS status;

	status = SisCSFilesToBackupForLinkI(
						sisBackupStructure,
						reparseData,
						reparseDataSize,
						thisFileContext,
						matchingFileContext,
						countOfCommonStoreFilesToBackup,
						commonStoreFilesToBackup);

	if (STATUS_UNSUCCESSFUL != status) {
		SetLastError(RtlNtStatusToDosError(status));
	}
	return NT_SUCCESS(status);
}

BOOL __stdcall
SisFreeBackupStructure(
	IN PVOID						sisBackupStructure)
{
	NTSTATUS status;

	status = SisFreeBackupStructureI(
							sisBackupStructure);

	if (STATUS_UNSUCCESSFUL != status) {
		SetLastError(RtlNtStatusToDosError(status));
	}
	return NT_SUCCESS(status);
}

BOOL __stdcall
SisCreateRestoreStructure(
	IN PWCHAR						volumeRoot,
	OUT PVOID						*sisRestoreStructure,
	OUT PWCHAR						*commonStoreRootPathname,
	OUT PULONG						countOfCommonStoreFilesToRestore,
	OUT PWCHAR						**commonStoreFilesToRestore)
{
	NTSTATUS status;

	status = SisCreateRestoreStructureI(
						volumeRoot,
						sisRestoreStructure,
						commonStoreRootPathname,
						countOfCommonStoreFilesToRestore,
						commonStoreFilesToRestore);

	if (STATUS_UNSUCCESSFUL != status) {
		SetLastError(RtlNtStatusToDosError(status));
	}
	return NT_SUCCESS(status);
}

BOOL __stdcall
SisRestoredLink(
	IN PVOID						sisRestoreStructure,
	IN PWCHAR						restoredFileName,
	IN PVOID						reparseData,
	IN ULONG						reparseDataSize,
	OUT PULONG						countOfCommonStoreFilesToRestore,
	OUT PWCHAR						**commonStoreFilesToRestore)
{
	NTSTATUS status;

	status = SisRestoredLinkI(
						sisRestoreStructure,
						restoredFileName,
						reparseData,
						reparseDataSize,
						countOfCommonStoreFilesToRestore,
						commonStoreFilesToRestore);

	if (STATUS_UNSUCCESSFUL != status) {
		SetLastError(RtlNtStatusToDosError(status));
	}
	return NT_SUCCESS(status);
}

BOOL __stdcall
SisRestoredCommonStoreFile(
	IN PVOID						sisRestoreStructure,
	IN PWCHAR						commonStoreFileName)
{
	NTSTATUS status;

	status =  SisRestoredCommonStoreFileI(
						sisRestoreStructure,
						commonStoreFileName);

	if (STATUS_UNSUCCESSFUL != status) {
		SetLastError(RtlNtStatusToDosError(status));
	}
	return NT_SUCCESS(status);
}

BOOL __stdcall
SisFreeRestoreStructure(
	IN PVOID						sisRestoreStructure)
{
	NTSTATUS status;

	status = SisFreeRestoreStructureI(
						sisRestoreStructure);

	if (STATUS_UNSUCCESSFUL != status) {
		SetLastError(RtlNtStatusToDosError(status));
	}
	return NT_SUCCESS(status);
}

VOID __stdcall
SisFreeAllocatedMemory(
	IN PVOID						allocatedSpace)
{
	if (NULL != allocatedSpace) {
		free(allocatedSpace);
	}
}

BOOL WINAPI DLLEntryPoint(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved)
{
  return( TRUE );
}


}