windows-xp/Source/XPSP1/NT/enduser/stuff/itircl/common/filesys/filesys.c

/*****************************************************************************
 *                                                                            *
 *  FILESYS.C                                                                 *
 *                                                                            *
 *  Copyright (C) Microsoft Corporation 1995.                          		  *
 *  All Rights reserved.                                                      *
 *                                                                            *
 ******************************************************************************
 *                                                                            *
 *  Module Intent                                                             *
 *                                                                            *
 *  All main File System commands (opening, closing)				          *
 *	any given offset, or in a temp file.									  *
 *                                                                            *
 ******************************************************************************
 *                                                                            *
 *  Current Owner:  davej                                                     *
 *****************************************************************************/

/*****************************************************************************
 *
 *  Created 07/17/95 - davej
 *           3/05/97     erinfox Change errors to HRESULTS
 *
 *****************************************************************************/

static char s_aszModule[] = __FILE__;    /* For error report */

#include <mvopsys.h>
#include <iterror.h>
#include <orkin.h>
#include <misc.h>
#include <wrapstor.h>
#include <_mvutil.h>

/*****************************************************************************
 *                                                                            *
 *                               Defines                                      *
 *                                                                            *
 *****************************************************************************/


/*****************************************************************************
 *                                                                            *
 *                               Prototypes                                   *
 *                                                                            *
 *****************************************************************************/

/***************************************************************************
 *                                                                           *
 *                         Private Functions                                 *
 *                                                                           *
 ***************************************************************************/

// FACCESS_READWRITE
// FACCESS_READ		
BOOL PASCAL FAR FHfsAccess(HFS hfs, BYTE bFlags)
{
	QFSHR   qfshr;
	BOOL 	bHasAccess=FALSE;
	if (hfs == NULL || (qfshr = _GLOBALLOCK(hfs)) == NULL)
	{
	    return FALSE;
	}

	if ((qfshr->fsh.bFlags&FSH_READWRITE) && (bFlags&FACCESS_READWRITE))
		bHasAccess=TRUE;
	if (bFlags&FACCESS_READ) 
		bHasAccess=TRUE;

	_GLOBALUNLOCK(hfs);
	return bHasAccess;
}

/***************************************************************************
 *
 *	@doc	PRIVATE
 *
 *	@func	HFS PASCAL NEAR | HfsOpenFileSysFmInternal |
 *		Open or Create a file system
 *
 *  @parm	FM | fmFileName |
 *		File name of file system to open or create (FM is identical to LPSTR)
 *
 *	@parm	BYTE | bFlags |
 *		Combinations of the FSH_ flags
 * 	@flag FSH_READWRITE	 	| (0x01)	FS will be updated
 *	@flag FSH_READONLY 	 	| (0x02)	FS will be read only, no updating
 *	@flag FSH_CREATE 	 	| (0x04)	Create a new FS
 *	@flag FSH_M14		 	| (0x08)	Not used really, since we return										
 *	@flag FSH_FASTUPDATE	| (0x10)	System Btree is not copied to temp file
 *											unless absolutely necessary
 *	@flag FSH_DISKBTREE		| (0x20)	System Btree is always copied to disk if
 *											possible for speed.  Btree may be very very
 *											large, and this is NOT recommended for on-line	
 *
 *	@parm	FS_PARAMS FAR * | lpfsp |
 *		File system initialization parameters (currently btree block size)
 *
 *  @parm	PHRESULT | lpErrb |
 *		Error return
 *
 *	@rdesc	Returns a valid HFS or NULL if an error.
 *
 ***************************************************************************/

HFS PASCAL NEAR HfsOpenFileSysFmInternal(FM fm,
    BYTE bFlags, FS_PARAMS FAR *qfsp, PHRESULT phr)
{
#ifdef MOSMAP // {
	// Disable function
	if (bFlags&(FSH_CREATE|FSH_READWRITE))
	{	
		SetErrCode (phr, ERR_NOTSUPPORTED);
		return NULL;
	}
#else // } {
	HFS           	hfs;
	QFSHR         	qfshr;
	BTREE_PARAMS  	btp;
	
	/* make file system header */

	if (( hfs =  _GLOBALALLOC(GMEM_ZEROINIT|GMEM_SHARE| GMEM_MOVEABLE,
	    (LONG)sizeof( FSHR) ) ) == NULL )
	{
		SetErrCode (phr, E_OUTOFMEMORY);
		return NULL;
	}

	qfshr = _GLOBALLOCK(hfs);

	_INITIALIZECRITICALSECTION(&qfshr->cs);

	// Copy File Moniker
	if ((qfshr->fm = FmCopyFm(fm, phr)) == fmNil)
	{
	 	SetErrCode(phr,E_OUTOFMEMORY);
		exit0:
			_DELETECRITICALSECTION(&qfshr->cs);
			_GLOBALUNLOCK(hfs);
			_GLOBALFREE(hfs);
			return 0;
	}

	// Open or Create fid
	if (bFlags&FSH_CREATE)
		qfshr->fid = FidCreateFm(qfshr->fm, wReadWrite, wReadWrite, phr);	
	else
		qfshr->fid = FidOpenFm(qfshr->fm,
            (WORD)((bFlags & FSH_READONLY)?(wReadOnly | wShareRead) : (wReadWrite | wShareNone)), phr);
	if (qfshr->fid == fidNil)
	{
		exit1:
			//FreeListDestroy(qfshr->hfl);
			SetErrCode(phr,E_NOPERMISSION);
			DisposeFm(qfshr->fm);
			goto exit0;		
	}

	qfshr->hsfbFirst=NULL;
	qfshr->hsfbSystem=NULL;

	// Initialize global SubFile header blocks array - shared by everyone :-)
	// So we take multi-threading precautions
	if (!_INTERLOCKEDINCREMENT(&mv_gsfa_count))
	{
		HANDLE hSfa;
		
		mv_gsfa_count=1L;
		mv_gsfa=NULL;
		_INITIALIZECRITICALSECTION(&mv_gsfa_cs);

		if (((hSfa=_GLOBALALLOC(GMEM_ZEROINIT|GMEM_MOVEABLE|GMEM_SHARE,sizeof(SF)*MAXSUBFILES))==NULL) || 
			((mv_gsfa=(SF FAR *)_GLOBALLOCK(hSfa))==NULL))
		{
			if (hSfa)
				_GLOBALFREE(hSfa);
			SetErrCode (phr, E_OUTOFMEMORY);
			exit2:
				if (!(_INTERLOCKEDDECREMENT(&mv_gsfa_count)))
				{
					if (mv_gsfa)
					{
					 	_GLOBALUNLOCK(GlobalHandle(mv_gsfa));
						_GLOBALFREE(GlobalHandle(mv_gsfa));
						mv_gsfa=NULL;
					}
					_DELETECRITICALSECTION(&mv_gsfa_cs);
					mv_gsfa_count=-1L;
				}
				goto exit1;
		}
		mv_gsfa[0].hsfb=(HSFB)-1;				
	}
	
	if (bFlags&(FSH_READWRITE|FSH_DISKBTREE))
	{	
		// If we are ambitious, we can try lower scratch sizes, but if we are that low
		// on memory, chances are we are just going to fail a few steps from here.
		HANDLE hBuf;
		if (!(hBuf=_GLOBALALLOC(GMEM_ZEROINIT|GMEM_MOVEABLE|GMEM_SHARE,(DWORD)SCRATCHBUFSIZE)))
		{	
			SetErrCode(phr, E_OUTOFMEMORY);
			goto exit2;
		}	

		if (!(qfshr->sb.lpvBuffer=_GLOBALLOCK(hBuf)))
		{
			_GLOBALFREE(hBuf);
			goto exit2;
		}
		qfshr->sb.lcbBuffer=(LONG)SCRATCHBUFSIZE;
		_INITIALIZECRITICALSECTION(&qfshr->sb.cs);
	}

	if (!(bFlags&FSH_CREATE))
	{
	 	BYTE bFlagsBtree=0L;

	 	if ((LcbReadFid(qfshr->fid, &qfshr->fsh,(LONG)sizeof(FSH), 
	 		phr)) != (LONG)sizeof(FSH)) 
		{
			SetErrCode (phr, E_FILEINVALID);	
			exit3:
				if (bFlags&(FSH_READWRITE|FSH_DISKBTREE))
					_DELETECRITICALSECTION(&qfshr->sb.cs);
				if (qfshr->sb.lpvBuffer)
				{	
					if (!(bFlags&(FSH_READWRITE|FSH_DISKBTREE)))
						_DELETECRITICALSECTION(&qfshr->sb.cs);
					_GLOBALUNLOCK(GlobalHandle(qfshr->sb.lpvBuffer));
					_GLOBALFREE(GlobalHandle(qfshr->sb.lpvBuffer));
				}
				RcCloseFid(qfshr->fid);
				if (bFlags&FSH_CREATE)
					RcUnlinkFm(qfshr->fm);
				goto exit2;
		}
		/* Handle MAC swapping */

        if (qfshr->fsh.wMagic == SWAPWORD(wFileSysMagic))
        {
		    qfshr->fsh.wMagic = SWAPWORD(qfshr->fsh.wMagic);
		    qfshr->fsh.foDirectory.dwOffset = SWAPLONG(qfshr->fsh.foDirectory.dwOffset);
		    qfshr->fsh.foDirectory.dwHigh = SWAPLONG(qfshr->fsh.foDirectory.dwHigh);
		    qfshr->fsh.foFreeList.dwOffset = SWAPLONG(qfshr->fsh.foFreeList.dwOffset);
		    qfshr->fsh.foFreeList.dwHigh = SWAPLONG(qfshr->fsh.foFreeList.dwHigh);
		    qfshr->fsh.foEof.dwOffset = SWAPLONG(qfshr->fsh.foEof.dwOffset);	
		    qfshr->fsh.foEof.dwHigh = SWAPLONG(qfshr->fsh.foEof.dwHigh);	
        }
	    qfshr->fsh.bFlags=(qfshr->fsh.bFlags&(~(FSH_READWRITE|FSH_READONLY)))|bFlags;


		if (qfshr->fsh.wMagic != wFileSysMagic)
		{
	        SetErrCode (phr, E_FILEINVALID);	
			goto exit3;
		}
		if (qfshr->fsh.bVersion != bFileSysVersion) 
		{
			if (qfshr->fsh.bVersion == bFileSysVersionOld)
			{
				qfshr->fsh.bFlags|=FSH_M14;
				SetErrCode(phr, E_BADVERSION); // Try another error specially for M14?
				goto exit3;
			}
			else
			{
				SetErrCode(phr, E_BADVERSION);
				goto exit3;
			}
		}
		// Open Free List if r/w mode
		if (bFlags&FSH_READWRITE)
		{	
			if ((!FoEquals(FoSeekFid(qfshr->fid,qfshr->fsh.foFreeList,wSeekSet,
				phr),qfshr->fsh.foFreeList))	||
				((qfshr->hfl=FreeListInitFromFid( qfshr->fid, phr ))==NULL))
			{
			 	goto exit3;	
			}
		}

		// Open Btree making temp file for btree
		//if ((qfshr->hbt = HbtOpenBtreeSz(NULL, hfs,
		//	(BYTE)((qfshr->fsh.bFlags&FSH_READONLY?HFOPEN_READ:HFOPEN_READWRITE)|HFOPEN_SYSTEM),
		//	NULL, phr)) == NULL) 

		// Open Btree, temp only gets made if necessary

		bFlagsBtree|=HFOPEN_SYSTEM;
		if (qfshr->fsh.bFlags&FSH_READONLY)
		{
		 	bFlagsBtree|=HFOPEN_READ;
			if (qfshr->fsh.bFlags&FSH_DISKBTREE)
				bFlagsBtree|=HFOPEN_FORCETEMP;
		}
		else
		{
		 	bFlagsBtree|=HFOPEN_READWRITE;
		 	if (qfshr->fsh.bFlags&FSH_FASTUPDATE)
				bFlagsBtree|=HFOPEN_NOTEMP;
		}
		
		//if ((qfshr->hbt = HbtOpenBtreeSz(NULL, hfs,
		//	(BYTE)((qfshr->fsh.bFlags&FSH_READONLY?HFOPEN_READ:
		//	((qfshr->fsh.bFlags&FSH_FASTUPDATE)?HFOPEN_NOTEMP:0)|HFOPEN_READWRITE)|
		//	HFOPEN_SYSTEM),
		//	NULL, phr)) == NULL) 

		if ((qfshr->hbt = HbtOpenBtreeSz(NULL, hfs, bFlagsBtree, phr))==NULL)		
		{
			exit4:
				if (qfshr->hfl)
					FreeListDestroy(qfshr->hfl);
				goto exit3;
		}
	}
	else
	{
        WORD wFreeListSize = wDefaultFreeListSize;
        if ((qfsp) && (qfsp->wFreeListSize))
            wFreeListSize = qfsp->wFreeListSize;
        
		qfshr->fsh.wMagic       = wFileSysMagic;
		qfshr->fsh.bVersion     = bFileSysVersion;
		qfshr->fsh.bFlags       = FSH_READWRITE;
		qfshr->fsh.foFreeList.dwOffset   = sizeof(FSH);	// Free list directly after header
		qfshr->fsh.foFreeList.dwHigh = 0L;
		qfshr->fsh.foDirectory = foNil; // Filled in with system file start
		if (bFlags&FSH_READWRITE)
		{	if ((qfshr->hfl=FreeListInit(wFreeListSize, phr))==NULL)
			{
		 		goto exit3;
			}
		}
		qfshr->fsh.foEof.dwOffset = sizeof(FSH)+FreeListSize(qfshr->hfl,phr);  // Free starts here

		qfshr->fsh.foEof.dwHigh = 0L;

		/* build btree directory */
		btp.hfs       = hfs;
		btp.bFlags    = HFOPEN_READWRITE|HFOPEN_SYSTEM;
		if (qfsp != NULL)
		{
			btp.cbBlock = qfsp->cbBlock;
		}
		else
		{
			btp.cbBlock = cbBtreeBlockDefault;
		}
		lstrcpy(btp.rgchFormat, "VOO1"); //  "VY", KT_VSTI, FMT_VNUM_FO, FMT_VNUM_LCB, file byte // 'VOL1' works too

		qfshr->hbt = HbtCreateBtreeSz(NULL, &btp, phr);
		if (qfshr->hbt == NULL) 
		{
			goto exit4;
		}
	}

	// NO harm writing out file system file so far (???)
	//LSeekFid(qfshr->fid, 0L, wSeekSet, phr);
	//LcbWriteFid(qfshr->fid, &qfshr->fsh, sizeof(FSH), phr);
	//Lcb ... also no need to write it out yet!

	/* return handle to file system */
	_GLOBALUNLOCK(hfs);
	return hfs;

#endif //}
}

/***************************************************************************
 *
 *	@doc	INTERNAL API
 *
 *	@func	HFS PASCAL FAR | HfsCreateFileSysFm |
 *		Creates a new file system
 *
 *  @parm	FM | fmFileName |
 *		File name of file system to open or create (FM is same as LPSTR)
 *
 *	@parm	FS_PARAMS FAR * | lpfsp |
 *		File system initialization parameters (currently btree block size)
 *
 *  @parm	PHRESULT | lpErrb |
 *		Error return
 *
 *	@rdesc	Returns a valid HFS or NULL if an error.
 *
 ***************************************************************************/

PUBLIC HFS PASCAL FAR EXPORT_API HfsCreateFileSysFm(FM fm,
    FS_PARAMS FAR *qfsp, PHRESULT phr)
{
 	return HfsOpenFileSysFmInternal(fm,FSH_CREATE|FSH_READWRITE,qfsp,phr);
}

/***************************************************************************
 *
 *	@doc	INTERNAL API
 *
 *	@func	HFS PASCAL FAR | HfsOpenFm |
 *		Open an existing file system
 *
 *  @parm	FM | fmFileName |
 *		File name of file system to open (FM is same as LPSTR)
 *
 *	@parm	BYTE | bFlags |
 *		Any of the FSH_ flags
 * 	@flag FSH_READWRITE	 	| (BYTE)0x01	FS will be updated
 *	@flag FSH_READONLY 	 	| (BYTE)0x02	FS will be read only, no updating
 *	@flag FSH_M14		 	| (BYTE)0x08	Not used really, since we return										
 *	@flag FSH_FASTUPDATE	| (BYTE)0x10	System Btree is not copied to temp file
 *											unless absolutely necessary
 *	@flag FSH_DISKBTREE		| (BYTE)0x20	System Btree is always copied to disk if
 *											possible for speed.  Btree may be very very
 *											large, and this is NOT recommended for on-line	
 *
 *  @parm	PHRESULT | lpErrb |
 *		Error return
 *
 *	@rdesc	Returns a valid HFS or NULL if an error.
 *
 ***************************************************************************/

PUBLIC	HFS PASCAL FAR EXPORT_API HfsOpenFm(FM fm, BYTE bFlags,
	PHRESULT phr)
{
	if (bFlags&FSH_CREATE)
	{
	 	SetErrCode(phr, E_INVALIDARG);
		return NULL;
	}
	return HfsOpenFileSysFmInternal(fm,bFlags,NULL,phr);
}

/***************************************************************************
 *
 *	@doc	INTERNAL API
 *
 *	@func	HRESULT PASCAL FAR | RcCloseHfs |
 *		Close an opened File System
 *
 *  @parm	HFS | hfs |
 *		Handle of opened file system
 *
 *	@rdesc	Returns S_OK if closed OK, else an error
 *
 *	@comm
 *		state IN:   
 *		state OUT:
 *		Notes:      
 *
 ***************************************************************************/

HRESULT PASCAL FAR RcCloseHfs(HFS hfs)
{
	QFSHR   qfshr;
	HRESULT    errb;

	if (hfs == NULL || (qfshr = _GLOBALLOCK(hfs)) == NULL)
	{
	    return(E_INVALIDARG);
	}
    
	if (!mv_gsfa_count)
		return E_ASSERT;

	_ENTERCRITICALSECTION(&qfshr->cs);

	// We need to:
	// 	(1) close all subfiles if any open
	//	(2) close the btree
	//  (3) r/w write free list
	//  (4) r/w write header

	RcCloseEveryHf(hfs);

	//while (qfshr->hsfbFirst)
	//{
	// 	qfshr->hsfbFirst=HsfbCloseHsfb(qfshr->hsfbFirst, &errb);
	//	if (errb.err!=S_OK)
	//		break;
	//}
	
	if ((errb = RcCloseOrFlushHbt(qfshr->hbt, TRUE)) != S_OK)
	{
		/* out of disk space, internal error, or out of file handles. */
		if (errb != E_HANDLE)
		{
			/* attempt to invalidate FS by clobbering magic number */
			LSeekFid(qfshr->fid, 0L, wSeekSet, NULL);
			qfshr->fsh.wMagic = 0;
			LcbWriteFid(qfshr->fid, &qfshr->fsh, (LONG)sizeof(FSH), NULL);
		}
	}
	else
	{
		if (qfshr->fsh.bFlags & FSH_READWRITE)
		{
			FoSeekFid(qfshr->fid, qfshr->fsh.foFreeList, wSeekSet, NULL);
			FreeListWriteToFid(qfshr->hfl, qfshr->fid, NULL);
			FreeListDestroy(qfshr->hfl);

			if (LSeekFid(qfshr->fid, 0L, wSeekSet, &errb) == 0L)
			{
    			LcbWriteFid(qfshr->fid, &qfshr->fsh, (LONG)sizeof(FSH), &errb);
			}			
		}
	}
	
	// Remove our access to the global subfile handle object
	if (!(_INTERLOCKEDDECREMENT(&mv_gsfa_count)))
	{
		// Last person using subfile array deletes it too!
		// Can we use the GlobalHandle function OK in all environments?
		_GLOBALUNLOCK(GlobalHandle(mv_gsfa));
		_GLOBALFREE(GlobalHandle(mv_gsfa));
		mv_gsfa=NULL;
		mv_gsfa_count=-1L;
		_DELETECRITICALSECTION(&mv_gsfa_cs);
	}
	
	RcCloseFid(qfshr->fid);
	
	_LEAVECRITICALSECTION(&qfshr->cs);
	_DELETECRITICALSECTION(&qfshr->cs);
	if (qfshr->sb.lpvBuffer)
	{
		_DELETECRITICALSECTION(&qfshr->sb.cs);
		_GLOBALUNLOCK(GlobalHandle(qfshr->sb.lpvBuffer));
		_GLOBALFREE(GlobalHandle(qfshr->sb.lpvBuffer));
	}
	DisposeFm(qfshr->fm);
	_GLOBALUNLOCK(hfs);
	_GLOBALFREE(hfs);
	
	return errb;
}

/***************************************************************************
 *
 *	@doc	INTERNAL API
 *
 *	@func	HRESULT PASCAL FAR | RcFlushHfs |
 *		Write all temporary info in file system to FS file
 *
 *  @parm	HFS | hfs |
 *		Handle of opened file system
 *
 *	@rdesc	Returns S_OK if closed OK, else an error
 *
 *	@comm
 *		state IN:   
 *		state OUT:
 *		Notes:      
 *
 ***************************************************************************/

HRESULT PASCAL FAR RcFlushHfs(HFS hfs)
{
	QFSHR   qfshr;
	HRESULT    errb;
	//HSFB hsfbCursor;
	HRESULT rc=S_OK;
	 	

	if (hfs == NULL || (qfshr = _GLOBALLOCK(hfs)) == NULL)
	{
	    return(E_INVALIDARG);
	}
    
	_ENTERCRITICALSECTION(&qfshr->cs);

	// We need to:
	// 	(1) close all subfiles if any open
	//	(2) close the btree
	//  (3) r/w write free list
	//  (4) r/w write header
	
	RcFlushEveryHf(hfs);
	
	/*
	hsfbCursor=qfshr->hsfbFirst;
	while (hsfbCursor)
	{
	 	HSFB hsfbNext=NULL;
		QSFB qsfb;

		if (!(qsfb = _GLOBALLOCK(hsfbCursor)))
		{
		    rc=E_OUTOFMEMORY;
			exit1:
				_LEAVECRITICALSECTION(&qfshr->cs);
				_GLOBALUNLOCK(hfs);
				return rc;
		}

    	hsfbNext=qsfb->hsfbNext;
	
	 	if ((rc=RcFlushHsfb(hsfbCursor))!=S_OK)
		{
			_GLOBALUNLOCK(hsfbCursor);
			goto exit1;
		}
		_GLOBALUNLOCK(hsfbCursor);
		hsfbCursor=hsfbNext;		
	}
	*/

	if ((rc = RcCloseOrFlushHbt(qfshr->hbt, FALSE)) != S_OK)
	{
		/* out of disk space, internal error, or out of file handles. */
		if (rc != E_HANDLE)
		{
			/* attempt to invalidate FS by clobbering magic number */
			LSeekFid(qfshr->fid, 0L, wSeekSet, NULL);
			qfshr->fsh.wMagic = 0;
			LcbWriteFid(qfshr->fid, &qfshr->fsh, (LONG)sizeof(FSH), NULL);
		}
	}
	else
	{
		if (qfshr->fsh.bFlags & FSH_READWRITE)
		{
			FoSeekFid(qfshr->fid, qfshr->fsh.foFreeList, wSeekSet, NULL);
			FreeListWriteToFid(qfshr->hfl, qfshr->fid, NULL);
		
			if (LSeekFid(qfshr->fid, 0L, wSeekSet, &errb) == 0L)
			{
    			LcbWriteFid(qfshr->fid, &qfshr->fsh, (LONG)sizeof(FSH), &errb);
			}

			FidFlush(qfshr->fid);
		}
	}
	
	_LEAVECRITICALSECTION(&qfshr->cs);	
	_GLOBALUNLOCK(hfs);
	return rc;
}


/***************************************************************************
 *
 *	@doc	INTERNAL API
 *
 *	@func	HRESULT PASCAL FAR | RcDestroyFileSysFm |
 *		Deletes a closed file system (removes it from the disk)
 *
 *  @parm	FM | fmFileName |
 *		Name of file to destroy	(FM is same as LPSTR)
 *
 *	@rdesc	Returns S_OK if deleted
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR EXPORT_API RcDestroyFileSysFm(FM fm)
{
#ifdef MOSMAP // {
	// Disable function
	return ERR_NOTSUPPORTED;
#else // } {
    HRESULT   errb;
	FSH fsh;
	FID fid = FidOpenFm(fm, wReadOnly, &errb);


	if (fid == fidNil)
	    return errb;

	if (LcbReadFid (fid, &fsh, (LONG)sizeof(FSH), &errb) != (LONG)sizeof(FSH))
	{
		RcCloseFid(fid);
		return E_FILEINVALID;
	}

	if (fsh.wMagic != wFileSysMagic)
	{
		RcCloseFid(fid);
		return E_FILEINVALID;
	}

	/* REVIEW: unlink all tmp files for open files? assert count == 0? */

	RcCloseFid(fid); /* I'm not checking this return code out of boredom */

	return (RcUnlinkFm( fm) );
#endif //}
}

#define MAGIC_FSFILEFIND 0x22334455

/***************************************************************************
 *
 *	@doc	INTERNAL API
 *
 *	@func	HRESULT PASCAL FAR | RcFindFirstFile |
 *		Finds the first file equal to or after the given filename.  This function
 *		will always find a filename unless the given search filename is past all
 *		files in the file system.
 *
 *  @parm	LPCSTR | szFileName |
 *		Name of file to look for.  OK to use partial filenames, since the 
 *		first file equal to or after the given filename in the directory
 *		will be found.
 *
 *	@parm 	LPFSFILEFIND |lpfsfilefind|
 *		This structure will be filled with information like file length, 
 *		permission attributes, and file name.  It will also be passed to
 *		RcFindNextFile to get the next filename.
 *
 *	@rdesc	Returns S_OK if successful.
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR EXPORT_API RcFindFirstFile(HFS hfs, LPCSTR szFilename, FSFILEFIND * pfind)
{
 	QFSHR  	qfshr;
	HRESULT rc = S_OK;
	KEY key;
	BTPOS btpos;
	FILE_REC fr;
	
 	if ((szFilename==NULL) || (pfind==NULL) || (hfs == NULL) || ((qfshr = _GLOBALLOCK(hfs)) == NULL))
	    return E_INVALIDARG;	    
	
	key = NewKeyFromSz(szFilename);	
	
	_ENTERCRITICALSECTION(&qfshr->cs);
	
	RcLookupByKeyAux(qfshr->hbt, key, &btpos, &fr, FALSE);
	if (btpos.bk == bkNil)
	{	rc=E_NOTEXIST;
		goto exit1;
	}

	GetFrData(&fr);
	pfind->btpos=btpos;
	pfind->foSize=fr.foSize;
	pfind->foStart=fr.foStart;
	pfind->bFlags=fr.bFlags;
	pfind->hfs=hfs;
	pfind->magic=MAGIC_FSFILEFIND;
	
	RcLookupByPos( qfshr->hbt, &btpos, (KEY)pfind->szFilename, 256, &fr );
	//GetFrData(&fr);
	
	{	DWORD dwLen;
		int iOffset;
		LPSTR szCursor;
		
		dwLen=FoFromSz(pfind->szFilename).dwOffset;
		iOffset=LenSzFo(pfind->szFilename);
		szCursor=pfind->szFilename;
		while (dwLen--)
		{	*szCursor=*(szCursor+iOffset);
			szCursor++;
		}
		*szCursor=0x00;
	}
exit1:
	_LEAVECRITICALSECTION(&qfshr->cs);	
	DisposeMemory((LPSTR)key);
	_GLOBALUNLOCK(hfs);
	return rc;
}

/***************************************************************************
 *
 *	@doc	INTERNAL API
 *
 *	@func	HRESULT PASCAL FAR | RcFindNextFile |
 *		Finds the next file in the file system directory. 
 *
 *	@parm 	LPFSFILEFIND |lpfsfilefind|
 *		This structure will be filled with information like file length, 
 *		permission attributes, and file name.  It must have already been filled
 *		by RcFindFirstFile before calling this function.
 *
 *	@rdesc	Returns S_OK if successful
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR EXPORT_API RcFindNextFile(FSFILEFIND * pfind)
{
	QFSHR  	qfshr;
	HRESULT rc = S_OK;
	BTPOS btNewPos;
	FILE_REC fr;
	
	if ((!pfind) || (pfind->magic!=MAGIC_FSFILEFIND))
		return E_INVALIDARG;

	if ((pfind->hfs == NULL) || ((qfshr = _GLOBALLOCK(pfind->hfs)) == NULL))
	    return E_INVALIDARG;	    
	
	_ENTERCRITICALSECTION(&qfshr->cs);
	
	if (RcNextPos( qfshr->hbt, &pfind->btpos, &btNewPos )==E_NOTEXIST)
	{	
		rc=E_NOTEXIST;
		goto exit1;
	}

	pfind->btpos=btNewPos;

	RcLookupByPos( qfshr->hbt, &pfind->btpos, (KEY)pfind->szFilename, 256, &fr );
	GetFrData(&fr);
	
	pfind->foSize=fr.foSize;
	pfind->bFlags=fr.bFlags;
	
	{	LPSTR szCursor;
		DWORD dwLen;
		int iOffset;
		
		dwLen=FoFromSz(pfind->szFilename).dwOffset;
		iOffset=LenSzFo(pfind->szFilename);
		szCursor=pfind->szFilename;
		while (dwLen--)
		{	*szCursor=*(szCursor+iOffset);
			szCursor++;
		}
		*szCursor=0x00;
	}

exit1:
	_LEAVECRITICALSECTION(&qfshr->cs);	
	_GLOBALUNLOCK(pfind->hfs);
	return rc;
}






/***************************************************************************
 *
 *	@doc	PRIVATE
 *
 *	@func	HFREELIST PASCAL FAR | FreeListInitFromFid |
 *		Initialize a freelist structure from a fid image.  Fid image is
 *		always in Intel byte ordering format.
 *
 *	@parm	FID | fid |
 *		File id
 *
 *	@parm	PHRESULT | lpErrb |
 *		Error code return - S_OK or E_OUTOFMEMORY
 *
 *	@rdesc	Returns handle to a FREELIST, otherwise NULL if error.
 *
 ***************************************************************************/

PUBLIC HFREELIST PASCAL FAR EXPORT_API FreeListInitFromFid( FID fid, PHRESULT lpErrb )
{
 	FREELISTHDR freehdr;

	QFREELIST qFreeList;
	HFREELIST hFreeList = NULL;
	WORD wMaxBlocks;
	WORD wNumBlocks;
	DWORD dwLostBytes;

	assert(fid!=fidNil);

	if (LcbReadFid(fid, &freehdr, sizeof(FREELISTHDR), lpErrb)!=sizeof(FREELISTHDR))
	{
	 	return NULL;
	}
	
	wMaxBlocks = freehdr.wMaxBlocks;
	wNumBlocks = freehdr.wNumBlocks;
	dwLostBytes = freehdr.dwLostBytes;
		
	//wMaxBlocks = qFreeListMem->flh.wMaxBlocks;
	//wNumBlocks = qFreeListMem->flh.wNumBlocks;

	// Mac-ify
	wMaxBlocks = SWAPWORD(wMaxBlocks);
	wNumBlocks = SWAPWORD(wNumBlocks);
	dwLostBytes = SWAPLONG(dwLostBytes);
	
	assert( wMaxBlocks );
	
	if (!(hFreeList=_GLOBALALLOC(GMEM_ZEROINIT| GMEM_MOVEABLE,
		sizeof(FREEITEM)*wMaxBlocks+sizeof(FREELISTHDR))))
	{	
		SetErrCode(lpErrb,E_OUTOFMEMORY);
		return NULL;
	}

	if (!(qFreeList=_GLOBALLOCK(hFreeList)))
	{	
		SetErrCode(lpErrb,E_OUTOFMEMORY);
		goto exit1;
	}

	qFreeList->flh.wMaxBlocks=wMaxBlocks;
	qFreeList->flh.wNumBlocks=wNumBlocks;
	qFreeList->flh.dwLostBytes=dwLostBytes;

	LcbReadFid( fid, qFreeList->afreeitem, sizeof(FREEITEM) * wMaxBlocks, lpErrb);
	
#ifdef _BIG_E	
	{
		QFREEITEM qCurrent = qFreeList->afreeitem;
		WORD wBlock;
	
		for (wBlock=0;wBlock<wNumBlocks;wBlock++)
		{
	 	 	qCurrent->foStart.dwOffset = SWAPLONG(qCurrent->foStart.dwOffset);
			qCurrent->foStart.dwHigh = SWAPLONG(qCurrent->foStart.dwHigh);
			qCurrent->foBlock.dwOffset = SWAPLONG(qCurrent->foBlock.dwOffset);
			qCurrent->foBlock.dwHigh = SWAPLONG(qCurrent->foBlock.dwHigh);	
		}
	}
#endif // _BIG_E
	
	_GLOBALUNLOCK(hFreeList);

	return hFreeList;

	exit1:
		_GLOBALFREE(hFreeList);
		return NULL;
}

/***************************************************************************
 *
 *	@doc	PRIVATE
 *
 *	@func	HRESULT PASCAL FAR | FreeListWriteToFid |
 *		Write to fid with freelist data.  Call FreeListSize first
 *		to make sure the space is large enough.  Memory image will always
 *		be in Intel byte ordering format.
 *
 *	@parm	HFREELIST | hFreeList |
 *		List to retrieve
 *
 *	@parm	FID | fid |
 *		FID to contain free list data
 *
 *	@parm	PHRESULT | lpErrb |
 *		Error return
 *
 *	@rdesc	Number of bytes written
 *
 ***************************************************************************/

PUBLIC LONG	PASCAL FAR EXPORT_API FreeListWriteToFid( HFREELIST hFreeList, FID fid, PHRESULT lpErrb )
{
	QFREELIST qFreeList;
	WORD wMaxBlocks;
	WORD wNumBlocks;
	DWORD dwLostBytes;
	LONG lcbSize;
	LONG lcbWritten=0L;

	assert(fid!=fidNil);
	assert(hFreeList);
	
	if (!(qFreeList = _GLOBALLOCK(hFreeList)))
	{	SetErrCode(lpErrb, E_OUTOFMEMORY);
		goto exit0;
	}
	
	wMaxBlocks=qFreeList->flh.wMaxBlocks;
	wNumBlocks=qFreeList->flh.wNumBlocks;
	dwLostBytes=qFreeList->flh.dwLostBytes;
	
	lcbSize = sizeof(FREELISTHDR) + wMaxBlocks * sizeof(FREEITEM);

#ifdef _BIG_E	
	{
		QFREEITEM qCurrent;
		WORD wBlock;
		HANDLE hMem;
		QFREELIST qFreeListMem;
	
		if (!(hMem = _GLOBALALLOC(GMEM_MOVEABLE, lcbSize)))
		{
		 	SetErrCode(lpErrb, E_OUTOFMEMORY);
			goto exit0;
		}

		qFreeListMem = (QFREELIST)_GLOBALLOCK(hMem);
		qCurrent = qFreeListMem->afreeitem;
		
		qFreeListMem->flh.wNumBlocks = SWAPWORD( qFreeList->flh.wNumBlocks );
		qFreeListMem->flh.wMaxBlocks = SWAPWORD( qFreeList->flh.wMaxBlocks );
		qFreeListMem->flh.dwLostBytes = SWAPLONG( qFreeList->flh.dwLostBytes );

		
		for (wBlock=0;wBlock<wNumBlocks;wBlock++)
		{
	 	 	qCurrent->foStart.dwOffset = SWAPLONG(qCurrent->foStart.dwOffset);
			qCurrent->foStart.dwHigh = SWAPLONG(qCurrent->foStart.dwHigh);
			qCurrent->foBlock.dwOffset = SWAPLONG(qCurrent->foBlock.dwOffset);
			qCurrent->foBlock.dwHigh = SWAPLONG(qCurrent->foBlock.dwHigh);
		}

		lcbWritten=LcbWriteFid(fid, qFreeListMem, lcbSize, lpErrb);

		_GLOBALUNLOCK(hMem);
		_GLOBALFREE(hMem);
	}
#else
		lcbWritten=LcbWriteFid(fid, qFreeList, lcbSize, lpErrb);
#endif // _BIG_E
	
	_GLOBALUNLOCK(hFreeList);

	exit0:
		return lcbWritten;
 	
}