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

/*****************************************************************************
 *                                                                           *
 * FID.C                                                                     *
 *                                                                           *
 * Copyright (C) Microsoft Corporation 1989 - 1994.                          *
 * All Rights reserved.                                                      *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * Module Intent                                                             *
 *                                                                           *
 * Low level file access layer, Windows version.                             *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * Current Owner: UNDONE                                                     *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * Released by Development:	                                               *
 *                                                                           *
 *****************************************************************************/

/*****************************************************************************
 *
 * Revision History:
 *       -- Mar 92      adapted from WinHelp FID.C, DAVIDJES
 *			9/26/95     davej	Autodoc'd
 *          3/05/97     erinfox Change errors to HRESULTS
 *****************************************************************************/

/*****************************************************************************
 *
 * Issues:
 * How to communicate super large (> DWORD) seeks over MOS.  See FoSeekFid
 *
 *****************************************************************************/

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

#include <mvopsys.h>
#include <iterror.h>

#ifdef _32BIT
#define	FP_OFF
#endif

#include <direct.h>
#include <orkin.h>
#include <misc.h>
#include <wrapstor.h>
#include <_mvutil.h>

#ifdef MOSMAP
#include <mapfile.h>
#endif

#ifndef _MAC
#include <dos.h>	/* for FP_OFF macros and file attribute constants */
#endif

#include <io.h>	 /* for tell() and eof() */
#include <errno.h>		          /* this is for chsize() */


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

#define UCBMAXRW		((WORD)0xFFFE)
#define LCBSIZESEG	((ULONG)0x10000)

/***************************************************************************
 *
 *		                           Macros
 *
 ***************************************************************************/

#define _WOpenMode(w) (_rgwOpenMode[ (w) & wRWMask ] | \
			_rgwShare[ ((w) & wShareMask) >> wShareShift ] )


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

HRESULT	PASCAL FAR RcMapDOSErrorW(WORD);

/***************************************************************************
 *
 *		                  Public Functions
 *
 ***************************************************************************/

/***************************************************************************
 * @doc	INTERNAL
 *
 *	@func BOOL PASCAL FAR | FidFlush |
 *
 *	@parm	FID |fid|
 *
 *	@rdesc TRUE if file flushed OK, FALSE if could not flush.
 *
 ***************************************************************************/

// Fill in non-win-32

PUBLIC BOOL PASCAL FAR FidFlush(FID fid)
{
 	BOOL bSuccess=TRUE;
#ifdef _WIN32
	bSuccess=FlushFileBuffers(fid);
#else
    Need code here
#endif
#ifdef _DEBUGMVFS
	DPF2("FidFlush: fid %ld, returned %d\n", (LONG)fid, bSuccess);
#endif
	return bSuccess;
}

/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	FID PASCAL FAR | FidCreateFm |
 *		Create a file
 *
 *  @parm	FM | fm |
 *		the file moniker
 *
 *  @parm	WORD | wOpenMode |
 *		read/write/share mode
 *
 *  @parm	WORD | wPerm |
 *		file permissions
 *
 *  @parm	PHRESULT | phr |
 *		Error return
 *
 *	@rdesc	fidNil on failure, valid fid otherwise
 *
 ***************************************************************************/

PUBLIC FID FAR PASCAL FidCreateFm(FM fm, WORD wOpenMode,
    WORD wPerm, PHRESULT phr)
{
#ifdef MOSMAP // {
	// Disable function
	SetErrCode(phr, ERR_NOTSUPPORTED);
	return fidNil;
#else // } {
	FID	fid;
	QAFM qafm;

	if (fm == fmNil)
	{
		SetErrCode(phr, E_INVALIDARG);
		return fidNil;
	}

	qafm = (QAFM)fm;
	//qafm = _GLOBALLOCK((HANDLE)fm);

#ifdef _WIN32
	fid = CreateFile((LPSTR)qafm->rgch,
		((wOpenMode&wRead)?GENERIC_READ:0)|((wOpenMode&wWrite)?GENERIC_WRITE:0),
		((wOpenMode&wShareRead)?FILE_SHARE_READ:0)|((wOpenMode&wShareWrite)?FILE_SHARE_WRITE:0),
		NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	// Note:  Some really cool optimizations can be made by specifying how the file
	// is intended to be used!
#else
	fid =_lcreat((LPSTR)qafm->rgch, _rgwPerm[ (wPerm) & wRWMask ]);
#endif
	if (fid == fidNil)
		SetErrCode(phr, E_FILECREATE);
	//_GLOBALUNLOCK((HANDLE)fm);
#ifdef _DEBUGMVFS
	DPF2("FidCreateFm: fid %ld for '%s'.\n", (LONG)fid, (LPSTR)qafm->rgch);
#endif
	return fid;
#endif //}
}

/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	FID PASCAL FAR | FidOpenFm |
 *		Open a file in binary mode.
 *
 *  @parm	FM | fm |
 *		the file moniker
 *
 *  @parm	WORD | wOpenMode |
 *		read/write/share modes.   Undefined if wRead and wWrite both unset.
 *
 *  @parm	PHRESULT | phr |
 *		Error return
 *
 *	@rdesc	fidNil on failure, else a valid FID.
 *
 ***************************************************************************/
PUBLIC FID FAR PASCAL FidOpenFm(FM fm, WORD wOpenMode, PHRESULT phr)
{
	FID fid;
	QAFM qafm;

	if (fm == fmNil)
	{
		SetErrCode(phr, E_INVALIDARG);
		return fidNil;
	}

	qafm = (QAFM)fm;
	//qafm = _GLOBALLOCK((HANDLE)fm);

#ifdef MOSMAP // {
	// Open File Mapping, or get ref to existing one
	if ((fid = (HFILE)MosOpenMapFile((LPSTR)qafm->rgch)) == fidNil)
		SetErrCode(phr, ERR_FAILED);
#else // } {

#ifdef _WIN32
	if ((fid = CreateFile((LPSTR)qafm->rgch,
		((wOpenMode&wRead)?GENERIC_READ:0)|((wOpenMode&wWrite)?GENERIC_WRITE:0),
		((wOpenMode&wShareRead)?FILE_SHARE_READ:0)|((wOpenMode&wShareWrite)?FILE_SHARE_WRITE:0),
		NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == fidNil)
#else
	if ((fid = _lopen((LPSTR)qafm->rgch, _WOpenMode(wOpenMode))) == fidNil)
#endif // _WIN32
		SetErrCode(phr, RcGetDOSError());
#endif //}

	//_GLOBALUNLOCK((HANDLE)fm);
#ifdef _DEBUGMVFS
	DPF2("FidOpenFm: fid %ld for '%s'.\n", (LONG)fid, (LPSTR)qafm->rgch);
#endif
	return fid;
}

/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	LONG PASCAL FAR | LcbReadFid |
 *		Read data from a file.
 *
 *  @parm	FID | fid |
 *		valid FID of an open file
 *
 *  @parm	QV | qv |
 *		pointer to user's buffer assumed huge enough for data
 *
 *  @parm	LONG | lcb |
 *		count of bytes to read (must be less than 2147483648)
 *
 *  @parm	PHRESULT | phr |
 *		Error return
 *
 *	@rdesc	count of bytes actually read or -1 on error
 *
 ***************************************************************************/
PUBLIC LONG FAR PASCAL LcbReadFid(FID fid, QV qv, LONG lcb, PHRESULT phr)
{
	LONG    lcbTotalRead = (LONG)0;
#ifdef MOSMAP // {
	// Read map file
	lcbTotalRead = MosReadMapFile((LPVOID)fid, qv, lcb) ;
	if (lcbTotalRead == -1)
#else // } {
#ifdef _WIN32
   
   if (!ReadFile(fid, qv, lcb, &lcbTotalRead, NULL))
   	SetErrCode(phr, RcGetDOSError());
   	
#else
	BYTE	HUGE *hpb = (BYTE HUGE *)qv;
	WORD 	ucb, ucbRead;

	do {
		ucb = (WORD)min(lcb, UCBMAXRW);
		ucb = (WORD)min((ULONG) ucb, LCBSIZESEG - (ULONG) FP_OFF(hpb));
		ucbRead = _lread(fid, hpb, ucb);

		if (ucbRead == (WORD)-1)
		{
			if (!lcbTotalRead)
			{
				lcbTotalRead = (LONG)-1;
			}
			break;
		}
		else
		{
			lcbTotalRead += ucbRead;
			lcb -= ucbRead;
			hpb += ucbRead;
		}
	} while (lcb > 0 && ucb == ucbRead);

	if (ucbRead == (WORD)-1)
		SetErrCode(phr, ERR_CANTREAD);

#endif
#endif //}
#ifdef _DEBUGMVFS
	DPF2("LcbReadFid: fid %ld returned %ld bytes.\n", (LONG)fid, lcbTotalRead);
#endif
	return lcbTotalRead;
}


/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	LONG PASCAL FAR | LcbWriteid |
 *		Write data to a file.
 *
 *  @parm	FID | fid |
 *		valid FID of an open file
 *
 *  @parm	QV | qv |
 *		pointer to user's buffer assumed huge enough for data
 *
 *  @parm	LONG | lcb |
 *		count of bytes to read (must be less than 2147483648)
 *
 *  @parm	PHRESULT | phr |
 *		Error return
 *
 *	@rdesc	count of bytes actually read or -1 on error
 *
 ***************************************************************************/
PUBLIC LONG FAR PASCAL LcbWriteFid(FID fid, QV qv, LONG	lcb, PHRESULT phr)
{
	LONG    lcbTotalWrote = (LONG)0;

#ifdef MOSMAP // {
	// Disable function
	SetErrCode(phr, ERR_NOTSUPPORTED);
	return 0;
#else // } {
#ifdef _WIN32
	if (!WriteFile(fid, qv, lcb, &lcbTotalWrote, NULL))
	   	SetErrCode(phr, RcGetDOSError());

#else
	BYTE	HUGE *hpb = (BYTE HUGE *)qv;
	WORD	ucb, ucbWrote;
	
	if (lcb == 0L)
	{
		phr->err = S_OK;
		return 0L;
	}

	do
		{
		ucb = (WORD)min(lcb, (ULONG) UCBMAXRW);
		ucb = (WORD)min((ULONG) ucb, LCBSIZESEG - (WORD) FP_OFF(hpb));
		ucbWrote = _lwrite(fid, hpb, ucb);

		if (ucbWrote == (WORD)-1)
		{
			if (!lcbTotalWrote)
				lcbTotalWrote = -1L;
			break;
		}
		else
		{
			lcbTotalWrote += ucbWrote;
			lcb -= ucbWrote;
			hpb += ucbWrote;
		}
	} while (lcb > 0 && ucb == ucbWrote);

	if (ucb != ucbWrote)
	{
    	if (ucbWrote == (WORD)-1L) 
    		SetErrCode (phr, RcGetDOSError());
    	else
    		SetErrCode (phr, E_DISKFULL);
	}
#endif
#endif // }
#ifdef _DEBUGMVFS
	DPF2("LcbWriteFid: fid %ld wrote %ld bytes.\n", (LONG)fid, lcbTotalWrote);
#endif
	return lcbTotalWrote;

}

/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	HRESULT PASCAL FAR | RcCloseFid |
 *		Close a file.
 *
 *  @parm	FID | fid |
 *		valid FID of an open file
 *
 *	@rdesc	rcSuccess or something else
 *
 ***************************************************************************/
PUBLIC HRESULT FAR PASCAL RcCloseFid(FID fid)
{
#ifdef MOSMAP // {
	if (MosCloseMapFile((LPVOID)fid) == HFILE_ERROR)
	{
#else // } {
#ifdef _WIN32
	if (!CloseHandle(fid))		
	{
#else
	if (_lclose( fid) == (HFILE)-1 )
	{
#endif
#endif //}
#ifdef _DEBUGMVFS
		DPF2("RcCloseFid: fid %ld was NOT closed(%d).\n", (LONG)fid, 0);
#endif
		return E_FILECLOSE;
	}
#ifdef _DEBUGMVFS
	DPF2("RcCloseFid: fid %ld was closed(%d).\n", (LONG)fid, 1);
#endif
	return S_OK;
}

/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	LONG PASCAL FAR | LTellFid |
 *		Return current file position in an open file.
 *
 *  @parm	FID | fid |
 *		valid FID of an open file
 *
 *  @parm	PHRESULT | phr |
 *		Error return
 *
 *	@rdesc	offset from beginning of file in bytes; -1L on error.
 *
 ***************************************************************************/
LONG FAR PASCAL LTellFid(FID fid, PHRESULT phr)
{
	LONG l;

#ifdef MOSMAP // {
	l = MosSeekMapFile((LPVOID)fid, 0L, 1) ;
#else // } {
#ifdef _WIN32
    DWORD dwHigh = 0L;
	l = SetFilePointer(fid, 0L, &dwHigh, FILE_CURRENT);
	// OK, just plain no support for +4gig files here...
	if ((l==(LONG)-1L) || (dwHigh))
		SetErrCode(phr, E_FILESEEK);
#else
	l = _llseek(fid, 0L, 1);
#endif
#endif //}
	if ( l == (LONG)-1L )
		SetErrCode(phr, E_FILESEEK);
#ifdef _DEBUGMVFS
	DPF2("LTellFid: fid %ld is at %ld\n", (LONG)fid, l);
#endif
	return l;
}

/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	LONG PASCAL FAR | LSeekFid |
 *		Move file pointer to a specified location.  It is an error
 *		to seek before beginning of file, but not to seek past end
 *		of file.
 *
 *  @parm	FID | fid |
 *		valid FID of an open file
 *
 *  @parm	LONG | lPos |
 *		offset from origin
 *
 *  @parm	WORD | wOrg |
 *		one of: wSeekSet: beginning of file, wSeekCur: current file pos,
 *		wSeekEnd: end of file
 *
 *  @parm	PHRESULT | phr |
 *		Error return
 *
 *	@rdesc	offset in bytes from beginning of file or -1L on error
 *
 ***************************************************************************/

PUBLIC LONG FAR PASCAL LSeekFid(FID fid, LONG lPos, WORD wOrg, PHRESULT phr)
{
	LONG l;
#ifdef MOSMAP // {
	l = MosSeekMapFile((LPVOID)fid, lPos, wOrg) ;
#else // } {
#ifdef _WIN32
    DWORD dwHigh = 0L;
	l = SetFilePointer(fid, lPos, &dwHigh, wOrg);
	// OK, just plain no support for +4gig files here...
	if ((l!=lPos) || (dwHigh))
		SetErrCode(phr, E_FILESEEK);
#else
	l = _llseek(fid, lPos, wOrg);
	if (l == (LONG)-1L)
		SetErrCode(phr, E_FILESEEK);
#endif
#endif //}
#ifdef _DEBUGMVFS
	DPF2("LSeekFid: fid %ld is at %ld\n", (LONG)fid, l);
#endif
	return l;
}


/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	FILEOFFSET PASCAL FAR | FoSeekFid |
 *		Move file pointer to a specified location.  It is an error
 *		to seek before beginning of file, but not to seek past end
 *		of file.  This function is meant to handle offsets larger than 4
 *		gigabytes.
 *
 *  @parm	FID | fid |
 *		valid FID of an open file
 *
 *  @parm	FILEOFFSET | foPos |
 *		offset from origin
 *
 *  @parm	WORD | wOrg |
 *		one of: wSeekSet: beginning of file, wSeekCur: current file pos,
 *		wSeekEnd: end of file
 *
 *  @parm	PHRESULT | phr |
 *		Error return
 *
 *	@rdesc	offset in bytes from beginning of file or -1L on error
 *
 ***************************************************************************/
PUBLIC FILEOFFSET FAR PASCAL FoSeekFid(FID fid, FILEOFFSET foPos, WORD wOrg, PHRESULT phr)
{
	DWORD dw;
	DWORD dwHigh=0L;
	FILEOFFSET foSeeked;

#ifdef MOSMAP // {
	SetErrCode(phr,ERR_NOTSUPPORTED);
	return -1L;
	//l = MosSeekMapFile((LPVOID)fid, lPos, wOrg) ;
#else // } {
#ifdef _WIN32
	dwHigh=(LONG)foPos.dwHigh;
	dw = SetFilePointer((HANDLE)fid, foPos.dwOffset, &dwHigh, wOrg);	
#else // not really supported for 16-bit
	dw = (DWORD)_llseek(fid, foPos.dwOffset, wOrg);
#endif
#endif //}
	foSeeked.dwOffset=dw;
	foSeeked.dwHigh=dwHigh;
	if (dw == (LONG)-1L)
	{
		if (GetLastError()!=NO_ERROR)
			SetErrCode(phr, E_FILESEEK);
		else
			*phr = S_OK;
	}
#ifdef _DEBUGMVFS
	DPF2("FoSeekFid: fid %ld is at %ld\n", (LONG)fid, foPos.dwOffset);
#endif
	return foSeeked;
}


#if 0
#if !defined ( _WIN32 )
/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	BOOL PASCAL FAR | FEofFid |
 *		Tells ye if ye're at the end of the file.
 *
 *  @parm	FID | fid |
 *		valid FID of an open file
 *
 *	@rdesc	TRUE if at EOF, FALSE if not or error has occurred (?)
 *
 ***************************************************************************/
PUBLIC BOOL PASCAL FAR FEofFid(FID fid)
{
	WORD wT;

	if (( wT = eof( fid) ) == (WORD)-1 )
		SetErrCode(RcGetDOSError());
	else
		SetErrCode(rcSuccess);

	return (BOOL)(wT == 1);
}
#endif // !defined ( _WIN32 )
#endif

PUBLIC HRESULT PASCAL FAR RcGetDOSError (void)
{

#ifdef _WIN32
	//  NT does not support errno in the multi threaded environment.

	switch( GetLastError() )
	{
    	case  NO_ERROR:
    		return  S_OK;

    	case  ERROR_ACCESS_DENIED:
    		return  E_NOPERMISSION;
        
    	case  ERROR_INVALID_HANDLE:
    		return  E_HANDLE;

    	case  ERROR_HANDLE_DISK_FULL:
    	case  ERROR_DISK_FULL:
    		return  E_DISKFULL;

    	default:
    		return  E_INVALIDARG;
	}
#else
	switch (errno) {
		case EACCES:
			return E_NOPERMISSION;
			break;

		case EBADF:
			return E_INVALIDARG;
			break;

		case ENOSPC:
			return E_DISKFULL;
			break;

		default:
			return E_INVALIDARG;
			break;
	}
#endif // _WIN32
}


/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	HRESULT PASCAL FAR | RcChSizeFid |
 *		Change the size of a file
 *
 *  @parm	FID | fid |
 *		valid FID of an open file
 *
 *  @parm	LONG | lcb |
 *		New size of file
 *
 *	@rdesc	Returns S_OK if all OK, else the error.
 *
 ***************************************************************************/
PUBLIC HRESULT PASCAL FAR RcChSizeFid(FID fid, LONG lcb)
{
#if !defined ( _WIN32 )
	if (chsize( fid, lcb) == -1 )
		return RcGetDOSError();
	else
#endif // !defined ( _WIN32 )
	return S_OK;
}


/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	HRESULT PASCAL FAR | RcUnlinkFm |
 *		Delete a DOS file given the filename
 *
 *  @parm	FM | fm |
 *		Name of file to remove.  (An FM is the same as an LPSTR).
 *
 *	@rdesc	Returns S_OK if all OK, else the error.
 *
 ***************************************************************************/
PUBLIC HRESULT PASCAL FAR EXPORT_API RcUnlinkFm(FM fm)
{
#ifdef MOSMAP // {
	// Disable function
	return ERR_NOTSUPPORTED;
#else // } {
	QAFM qafm = (QAFM)fm;
	//QAFM qafm = _GLOBALLOCK((HANDLE)fm);
	OFSTRUCT ofStruct;
	int fRet = S_OK;

	if (OpenFile((LPSTR)qafm->rgch, &ofStruct, OF_DELETE) == HFILE_ERROR)
		 fRet = E_FILEDELETE;
	//_GLOBALUNLOCK((HANDLE)fm);
	return fRet;
#endif // }
}


#ifdef _IT_FULL_CRT  // {
#ifndef _MAC // {
/* This function was previously present in dlgopen.c. It has been brought */
/* here as it is making INT21 call. */
/***************************************************************************
 *
 *	@doc	INTERNAL
 *
 *	@func	BOOL PASCAL FAR | FDriveOk |
 *		Cheks if the drive specified with thwe file name is OK.
 *
 *  @parm	LPSTR | szFile |
 *		Name of file
 *
 *	@rdesc	TRUE if drive is OK.
 *
 ***************************************************************************/
PUBLIC BOOL PASCAL FAR EXPORT_API FDriveOk(LPSTR szFile)
/* -- Check if drive is valid */
	{
	 // the static variables here are static only because we are in a DLL
	 // and need to pass a near pointer to them to a C Run-Time routine.
	 // These should be Locally-Alloc'd so they don't waste space in
	 // our data segment.

	static int	 wDiskCur;    
	int	 wDisk;

	wDiskCur = _getdrive();

	/* change to new disk if specified */
	if ((wDisk = (int)((*szFile & 0xdf) - ('A' - 1))) != wDiskCur) {
		if (_chdrive (wDisk) == (int)-1)
			return FALSE;
	}
	return TRUE;
}
#endif // } _MAC
#endif // }