able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/wow16/mmsystem/mmio.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1962 lines
63 KiB
C
Raw Permalink Blame History

/* mmio.c
*
* Basic MMIO functions.
*
* Implementation notes:
*
* The "current disk offset" is the disk offset (i.e. the location
* in the disk file) that the next MMIOM_READ or MMIOM_WRITE will
* read from or write to. The I/O procedure maintains the
* <lDiskOffset> field of the file's MMIO structure so that
* <lDiskOffset> is equal to the current disk offset.
*
* The "current buffered offset" is the disk offset that the next
* mmioRead() or mmioWrite() call would read from or write to.
* The current buffered offset is defined as
*
* <lBufOffset> + (<pchNext> - <pchBuffer>)
*
* since <lBufOffset> is the disk offset of the start of the buffer
* and <pchNext> corresponds to the current buffered offset.
*
* If the file is unbuffered, then <pchBuffer>, <pchNext>,
* <pchEndRead> and <pchEndWrite> will always be NULL, and
* <lBufOffset> will always be considered the "current buffered
* offset", i.e. mmioRead() and mmioWrite() will read/write
* at this offset.
*
*
* Except right at the beginning of mmioOpen(), the MMIO_ALLOCBUF
* flag is set if and only if the pchBuffer field points to a block
* of global memory that MMIO has allocated.
*/
#include <windows.h>
#include "mmsystem.h"
#include "mmioi.h"
#include "mmsysi.h"
/* The I/O procedure map is a linked list of IOProcMPEntry structures.
* The head of the list, <gIOProcMapHead> is a pointer node to the last
* entry registered. The first few elements of the list are the predefined
* global IO procedures below -- these all have <hTask> equal to NULL so
* that no task can unregister them.
*/
static LRESULT CALLBACK mmioDOSIOProc(LPSTR, UINT, LPARAM, LPARAM);
static LRESULT CALLBACK mmioMEMIOProc(LPSTR, UINT, LPARAM, LPARAM);
static IOProcMapEntry gIOProcMaps[] = {
FOURCC_DOS, mmioDOSIOProc, NULL, STATICIOPROC, &gIOProcMaps[1],
FOURCC_MEM, mmioMEMIOProc, NULL, STATICIOPROC, NULL,
};
IOProcMapEntry NEAR * gIOProcMapHead = gIOProcMaps;
/* private prototypes */
static LONG NEAR PASCAL mmioDiskIO(PMMIO pmmio, UINT wMsg, HPSTR pch, LONG cch);
static UINT NEAR PASCAL mmioExpandMemFile(PMMIO pmmio, LONG lExpand);
/* @doc INTERNAL
@func LPMMIOPROC | FindIOProc | This function locates previously installed
IO procedure.
*/
static LPMMIOPROC PASCAL NEAR
FindIOProc(FOURCC fccIOProc, HTASK htask)
{
IOProcMapEntry *pEnt; // an entry in linked list
/* walk through the linked list, first looking for an entry with
* identifier <fccIOProc> that was added by the current task, then
* looking for global entries.
*/
for (pEnt = gIOProcMapHead; pEnt; pEnt = pEnt->pNext)
if ((pEnt->fccIOProc == fccIOProc) && (pEnt->hTask == htask))
return pEnt->pIOProc;
for (pEnt = gIOProcMapHead; pEnt; pEnt = pEnt->pNext)
if (!pEnt->hTask && (pEnt->fccIOProc == fccIOProc))
return pEnt->pIOProc;
return NULL;
}
/* @doc INTERNAL
@func LPMMIOPROC | RemoveIOProc | This function removes previously installed
IO procedure.
*/
static LPMMIOPROC PASCAL NEAR
RemoveIOProc(FOURCC fccIOProc, HTASK htask)
{
IOProcMapEntry *pEnt; // an entry in linked list
IOProcMapEntry *pEntPrev; // the entry before <pEnt>
/* walk through the linked list, looking for an entry with
* identifier <fccIOProc> that was added by the current task
*/
for (pEntPrev = NULL, pEnt = gIOProcMapHead; pEnt; pEntPrev = pEnt, pEnt = pEnt->pNext)
if ((pEnt->fccIOProc == fccIOProc) && (pEnt->hTask == htask)) {
LPMMIOPROC pIOProc;
if (pEnt->wFlags & STATICIOPROC)
return NULL;
pIOProc = pEnt->pIOProc;
if (pEntPrev)
pEntPrev->pNext = pEnt->pNext;
else
gIOProcMapHead = pEnt->pNext;
FreeHandle((HMMIO) pEnt);
return pIOProc;
}
return NULL;
}
/* @doc INTERNAL
@func void | SetIOProc | This function sets the physical IO procedure
based on either the file name or the parameters within the
<p lpmmioinfo> structure passed.
@parm LPCSTR | szFilename | Specifies a far pointer to a string
containing the filename of the file to open. If no I/O procedure is
@parm LPMMIOINFO | lpmmioinfo | Specifies a far pointer to an
<t MMIOINFO> structure containing extra parameters used by
<f SetIOProc> in determining the IO procedure to use. The
<e MMIOINFO.pIOProc> element is set to the procedure found.
@rdesc Nothing.
*/
static void NEAR PASCAL
SetIOProc(LPCSTR szFileName, LPMMIOINFO lpmmio)
{
/* If the IOProc is not given, see if the file name implies that
* <szFileName> is either a RIFF compound file or some kind of
* other registered storage system -- look for the last CFSEPCHAR in
* the name, e.g. '+' in "foo.bnd+bar.hlp+blorg.dib", and figure
* that the IOProc ID is the extension of the compound file name,
* e.g. the extension of "foo.bnd+bar.hlp", i.e. 'HLP '.
*
* Alternatively, if <szFileName> is NULL, then assume that
* <lpmmio->adwInfo[0]> is a DOS file handle.
*/
if (lpmmio->pIOProc == NULL)
{
if (lpmmio->fccIOProc == NULL)
{
if (szFileName != NULL)
{
LPSTR pch;
/* see if <szFileName> contains CFSEPCHAR */
if ((pch = fstrrchr(szFileName, CFSEPCHAR)) != NULL)
{
/* find the extension that precedes CFSEPCHAR,
* e.g. "hlp" in "foo.bnd+bar.hlp+blorg.dib"
*/
while ((pch > szFileName) && (*pch != '.') && (*pch != ':') && (*pch != '\\'))
pch--;
if (*pch == '.')
{
char aszFour[sizeof(FOURCC)+1];
int i;
for (i = 0, pch++; i < sizeof(FOURCC); i++)
if (*pch == CFSEPCHAR)
aszFour[i] = (char)0;
else
aszFour[i] = *pch++;
aszFour[sizeof(FOURCC)] = (char)0;
lpmmio->fccIOProc = mmioStringToFOURCC(aszFour, MMIO_TOUPPER);
}
}
}
/* if the caller didn't specify an IOProc, and the code above
* didn't determine an IOProc ID, then the default is the DOS
* IOProc.
*/
if (lpmmio->fccIOProc == NULL)
lpmmio->fccIOProc = FOURCC_DOS;
}
/* unless an IOProc address is specified explicitly, look up the
* IOProc in the global IOProc ID-to-address table -- the default
* is 'DOS' since we'll assume that custom storage system I/O
* procedures would have been installed
*/
lpmmio->pIOProc = FindIOProc(lpmmio->fccIOProc, lpmmio->htask ? lpmmio->htask : GetCurrentTask());
if (lpmmio->pIOProc == NULL)
lpmmio->pIOProc = mmioDOSIOProc;
}
}
/* @doc EXTERNAL
@api UINT | mmioRename | This function renames the specified file.
@parm LPCSTR | szFilename | Specifies a far pointer to a string
containing the filename of the file to rename.
@parm LPCSTR | szNewFileName | Specifies a far pointer to a string
containing the new filename.
@parm LPMMIOINFO | lpmmioinfo | Specifies a far pointer to an
<t MMIOINFO> structure containing extra parameters used by
<f mmioRename>.
If <p lpmmioinfo> is not NULL, all unused fields of the
<t MMIOINFO> structure it references must be set to zero, including the
reserved fields.
@parm DWORD | dwRenameFlags | Specifies option flags for the rename
operation. This should be set to zero.
@rdesc The return value is zero if the file was renamed. Otherwise, the
return value is an error code returned from <f mmioRename> or from the I/O
procedure.
*/
UINT WINAPI
mmioRename(LPCSTR szFileName, LPCSTR szNewFileName, LPMMIOINFO lpmmioinfo, DWORD dwRenameFlags)
{
PMMIO pmmio;
UINT uReturn;
V_FLAGS(dwRenameFlags, 0, mmioRename, MMSYSERR_INVALFLAG);
V_RPOINTER0(lpmmioinfo, sizeof(MMIOINFO), MMSYSERR_INVALPARAM);
if ((pmmio = PH(NewHandle(TYPE_MMIO, sizeof(MMIOINFO)))) == NULL)
return MMIOERR_OUTOFMEMORY;
if (lpmmioinfo) {
V_CALLBACK0((FARPROC)lpmmioinfo->pIOProc, MMSYSERR_INVALPARAM);
*pmmio = *lpmmioinfo;
}
SetIOProc(szFileName, pmmio);
uReturn = (UINT)(DWORD) (pmmio->pIOProc((LPSTR) pmmio, MMIOM_RENAME, (LPARAM) szFileName, (LPARAM) szNewFileName));
FreeHandle((HLOCAL)pmmio);
return uReturn;
}
/* @doc EXTERNAL
@api HMMIO | mmioOpen | This function opens a file for unbuffered
or buffered I/O. The file can be a DOS file, a memory file, or an
element of a custom storage system.
@parm LPSTR | szFilename | Specifies a far pointer to a string
containing the filename of the file to open. If no I/O procedure is
specified to open the file, then the filename determines how the file
is opened, as follows:
-- If the filename does not contain "+", then it is assumed
to be the name of a DOS file.
-- If the filename is of the form "foo.ext+bar", then the
extension "EXT " is assumed to identify an installed I/O procedure
which is called to perform I/O on the file (see <f mmioInstallIOProc>).
-- If the filename is NULL and no I/O procedure is given, then
<e MMIOINFO.adwInfo[0]> is assumed to be the DOS file handle
of a currently open file.
The filename should not be longer than 128 bytes, including the
terminating NULL.
When opening a memory file, set <p szFilename> to NULL.
@parm LPMMIOINFO | lpmmioinfo | Specifies a far pointer to an
<t MMIOINFO> structure containing extra parameters used by
<f mmioOpen>. Unless you are opening a memory file, specifying the
size of a buffer for buffered I/O, or specifying an uninstalled I/O
procedure to open a file, this parameter should be NULL.
If <p lpmmioinfo> is not NULL, all unused fields of the
<t MMIOINFO> structure it references must be set to zero, including the
reserved fields.
@parm DWORD | dwOpenFlags | Specifies option flags for the open
operation. The MMIO_READ, MMIO_WRITE, and MMIO_READWRITE flags are
mutually exclusive--only one should be specified. The MMIO_COMPAT,
MMIO_EXCLUSIVE, MMIO_DENYWRITE, MMIO_DENYREAD, and MMIO_DENYNONE flags
are DOS file-sharing flags, and can only be used after the DOS
command SHARE has been executed.
@flag MMIO_READ | Opens the file for reading only. This is the
default, if MMIO_WRITE and MMIO_READWRITE are not specified.
@flag MMIO_WRITE | Opens the file for writing. You should not
read from a file opened in this mode.
@flag MMIO_READWRITE | Opens the file for both reading and writing.
@flag MMIO_CREATE | Creates a new file.
If the file already exists, it is truncated to zero length.
For memory files, MMIO_CREATE indicates the end of the file
is initially at the start of the buffer.
@flag MMIO_DELETE | Deletes a file. If this flag is specified,
<p szFilename> should not be NULL. The return
value will be TRUE (cast to HMMIO) if the file was deleted
successfully, FALSE otherwise. Do not call <f mmioClose>
for a file that has been deleted. If this flag is specified,
all other file opening flags are ignored.
@flag MMIO_PARSE | Creates a fully qualified filename from the path
specified in <p szFileName>. The fully qualified filename is
placed back into <p szFileName>. The return value
will be TRUE (cast to HMMIO) if the qualification was
successful, FALSE otherwise. The file is not opened, and the function
does not return a valid MMIO file handle, so do not attempt to
close the file. If this flag is specified, all other file
opening flags are ignored.
@flag MMIO_EXIST | Determines whether the specified file exists
and creates a fully qualified filename from the path
specified in <p szFileName>. The fully qualified filename is
placed back into <p szFileName>. The return value
will be TRUE (cast to HMMIO) if the qualification was
successful and the file exists, FALSE otherwise. The file is
not opened, and the function does not return a valid MMIO file
handle, so do not attempt to close the file.
@flag MMIO_ALLOCBUF | Opens a file for buffered I/O.
To allocate a buffer larger or smaller than the default
buffer size (8K), set the <e MMIOINFO.cchBuffer> field of the
<t MMIOINFO> structure to the desired buffer size. If
<e MMIOINFO.cchBuffer> is zero, then the default buffer size
is used. If you are providing your own I/O buffer, then the
MMIO_ALLOCBUF flag should not be used.
@flag MMIO_COMPAT | Opens the file with compatibility mode,
allowing any process on a given machine to open the file
any number of times. <f mmioOpen> fails if the file has
been opened with any of the other sharing modes.
@flag MMIO_EXCLUSIVE | Opens the file with exclusive mode,
denying other processes both read and write access to the file.
<f mmioOpen> fails if the file has been opened in any other
mode for read or write access, even by the current process.
@flag MMIO_DENYWRITE | Opens the file and denies other
processes write access to the file. <f mmioOpen> fails
if the file has been opened in compatibility or for write
access by any other process.
@flag MMIO_DENYREAD | Opens the file and denies other
processes read access to the file. <f mmioOpen> fails if the
file has been opened in compatibility mode or for read access
by any other process.
@flag MMIO_DENYNONE | Opens the file without denying other
processes read or write access to the file. <f mmioOpen>
fails if the file has been opened in compatibility mode
by any other process.
@flag MMIO_GETTEMP | Creates a temporary filename, optionally
using the parameters passed in <p szFileName> to determine
the temporary name. For example, you can specify "C:F" to
create a temporary file residing on drive C, starting with
letter "F". The resulting filename is placed in the buffer
pointed to by <p szFileName>. The return value will be TRUE
(cast to HMMIO) if the temporary filename was created successfully,
FALSE otherwise. The file is
not opened, and the function does not return a valid MMIO file
handle, so do not attempt to close the file.
This flag overrides all other flags.
@rdesc The return value is a handle to the opened file. This handle
is not a DOS file handle--do not use it with any file I/O functions
other than MMIO functions.
If the file cannot be opened, the return value is NULL. If
<p lpmmioinfo> is not NULL, then its <e MMIOINFO.wErrorRet> field
will contain extended error information returned by the I/O
procedure.
@comm If <p lpmmioinfo> references an <t MMIOINFO> structure, set
up the fields as described below. All unused fields must be set to
zero, including reserved fields.
-- To request that a file be opened with an installed I/O
procedure, set the <e MMIOINFO.fccIOProc> field
to the four-character code of the I/O procedure,
and set the <e MMIOINFO.pIOProc> field to NULL.
-- To request that a file be opened with an uninstalled I/O procedure,
set the <e MMIOINFO.pIOProc> field to
point to the I/O procedure, and set <e MMIOINFO.fccIOProc> to NULL.
-- To request that <f mmioOpen> determine which I/O procedure to use
to open the file based on the filename contained in <p szFilename>,
set both <e MMIOINFO.fccIOProc> and <e MMIOINFO.pIOProc> to NULL.
This is the default behavior if no <t MMIOINFO> structure is specified.
-- To open a memory file using an internally allocated and managed
buffer, set the <e MMIOINFO.pchBuffer> field to NULL,
<e MMIOINFO.fccIOProc> to FOURCC_MEM,
<e MMIOINFO.cchBuffer> to the initial size of the buffer, and
<e MMIOINFO.adwInfo[0]> to the incremental expansion size of the
buffer. This memory file will automatically be expanded in increments of
<e MMIOINFO.adwInfo[0]> bytes when necessary. Specify the MMIO_CREATE
flag for the <p dwOpenFlags> parameter to initially set the end of
the file to be the beginning of the buffer.
-- To open a memory file using a caller-supplied buffer, set
the <e MMIOINFO.pchBuffer> field to point to the memory buffer,
<e MMIOINFO.fccIOProc> to FOURCC_MEM,
<e MMIOINFO.cchBuffer> to the size of the buffer, and
<e MMIOINFO.adwInfo[0]> to the incremental expansion size of the
buffer. The expansion size in <e MMIOINFO.adwInfo[0]> should only
be non-zero if <e MMIOINFO.pchBuffer> is a pointer obtained by calling
<f GlobalAlloc> and <f GlobalLock>, since <f GlobalReAlloc> will be called to
expand the buffer. In particular, if <e MMIOINFO.pchBuffer> points to a
local or global array, a block of memory in the local heap, or a block
of memory allocated by <f GlobalDosAlloc>, <e MMIOINFO.adwInfo[0]> must
be zero.
Specify the MMIO_CREATE flag for the <p dwOpenFlags> parameter to
initially set the end of the file to be the beginning of the buffer;
otherwise, the entire block of memory will be considered readable.
-- To use a currently open DOS file handle with MMIO, set the
<e MMIOINFO.fccIOProc> field to FOURCC_DOS,
<e MMIOINFO.pchBuffer> to NULL, and <e MMIOINFO.adwInfo[0]> to the
DOS file handle. Note that offsets within the file will be relative to
the beginning of the file, and will not depend on the DOS file position
at the time <f mmioOpen> is called; the initial MMIO offset will be the same
as the DOS offset when <f mmioOpen> is called.
Later, to close the MMIO file handle without closing the DOS
file handle, pass the MMIO_FHOPEN flag to <f mmioClose>.
You must call <f mmioClose> to close a file opened with <f mmioOpen>.
Open files are not automatically closed when an application exits.
@xref mmioClose
*/
/* these are the changes to mmioOpen() to support compound files... */
/* @doc CFDOC
@api HMMIO | mmioOpen | ...The file can be a DOS file, a memory file,
an element of a RIFF compound file...
@parm LPSTR | szFilename | ...
-- If <p szFilename> is of the form "foo+bar", then <f mmioOpen>
opens the compound file element named "bar" that is stored inside
the RIFF compound file named "foo".
-- If <p szFilename> is of the form "foo.ext+bar", then the
extension "ext" is assumed to identify the installed I/O procedure
(see <f mmioInstallIOProc>). The extension "bnd", and any extensions
that have not been installed, are assumed to refer to a RIFF compound
file.
@parm LPMMIOINFO | lpmmioinfo | ...
@parm DWORD | dwOpenFlags | ...
@rdesc ...
@comm ...
The following I/O procedure identifiers (type FOURCC) are predefined:
...
FOURCC_BND: <p szFilename> is assumed to be the name of
a RIFF compound file element, and <p adwInfo[0]> should
contain the HMMCF of the compound file. Alternatively,
<p szFilename> can include the name of the compound file
(e.g. "foo.bnd+bar.dib" as described above), and <p adwInfo[0]>
should be NULL, to automatically open the compound file.
...
The easy way to open an element of a RIFF compound file: just
include the name of the compound file in <p szFilename> preceded
by a "+" as described above. For example, opening
"c:\data\bar.bnd+blorg.dib" opens the compound file element
named "blorg.dib" in the compound file "c:\data\bar.bnd".
<p lpmmioinfo> can be null in this case -- set <p dwOpenFlags>
as described above. You can use this same method to open an
element of a custom storage system, if the file extension of the
compound file ("bnd" in the above example) corresponds to an
installed I/O procedure -- see <f mmioInstallIOProc> for details.
To open an element of a RIFF compound file that was opened using
<f mmioCFAccess> or <f mmioCFOpen>: set <p szFilename>
to be the name of the compound file element; set <p fccIOProc>
to FOURCC_BND; set <p adwInfo[0]> to the HMMCF of the open compound
file; set <p dwOpenFlags> and <p cchBuffer> as described above;
set all other fields of <p lpmmioinfo> to zero.
...
*/
HMMIO WINAPI
mmioOpen(LPSTR szFileName, LPMMIOINFO lpmmioinfo, DWORD dwOpenFlags)
{
PMMIO pmmio; // MMIO status block
HPSTR hpBuffer;
UINT w;
V_FLAGS(dwOpenFlags, MMIO_OPEN_VALID, mmioOpen, NULL);
V_WPOINTER0(lpmmioinfo, sizeof(MMIOINFO), NULL);
if (lpmmioinfo) {
lpmmioinfo->wErrorRet = 0;
V_CALLBACK0((FARPROC)lpmmioinfo->pIOProc, NULL);
}
/* allocate MMIO status information block */
if ((pmmio = PH(NewHandle(TYPE_MMIO, sizeof(MMIOINFO)))) == NULL)
{
if (lpmmioinfo)
lpmmioinfo->wErrorRet = MMIOERR_OUTOFMEMORY;
return NULL;
}
/* if user supplied <lpmmioinfo>, copy it to <pmmio> */
if (lpmmioinfo != NULL)
*pmmio = *lpmmioinfo;
/* <dwOpenFlags> always takes precedence over contents of <pmmio> */
pmmio->dwFlags = dwOpenFlags;
pmmio->hmmio = HP(pmmio);
/* MMIO_ALLOCBUF in the flags means that the user wants a buffer
* allocated for buffered I/O, but after this point it means that
* a buffer *was* allocated, so turn off the flag until the buffer
* is actually allocated (which is done by mmioSetBuffer() below)
*/
if (pmmio->dwFlags & MMIO_ALLOCBUF)
{
/* if a buffer size is not specified, use the default */
if (pmmio->cchBuffer == 0)
pmmio->cchBuffer = MMIO_DEFAULTBUFFER;
pmmio->dwFlags &= ~MMIO_ALLOCBUF;
}
/* Set the pIOProc function as determined by the file name or the
* parameters in the pmmio structure.
*/
SetIOProc(szFileName, pmmio);
/* The pmmio structure hasn't been set up for buffering, so we must
* explicitly make sure that pchBuffer is NULL.
*/
hpBuffer = pmmio->pchBuffer;
pmmio->pchBuffer = NULL;
/* set up buffered I/O however the user requested it */
if (w = mmioSetBuffer(HP(pmmio), hpBuffer, pmmio->cchBuffer, 0))
{
if (lpmmioinfo)
lpmmioinfo->wErrorRet = w;
FreeHandle(HP(pmmio));
return NULL;
}
/* let the I/O procedure open/delete/qualify the file */
w = (UINT)(DWORD) (pmmio->pIOProc((LPSTR) pmmio, MMIOM_OPEN, (LPARAM) szFileName, (LPARAM) 0));
/* If this is non-zero, return it to the user */
if (w != 0)
{
if (lpmmioinfo != NULL)
lpmmioinfo->wErrorRet = w;
FreeHandle(HP(pmmio));
return NULL;
}
if (pmmio->dwFlags & (MMIO_DELETE | MMIO_PARSE | MMIO_EXIST | MMIO_GETTEMP))
{
/* if the file is being deleted/parsed/name gotten, exit
* QUICKLY because the file handle (or whatever) in <pmmio>
* is not valid.
*/
mmioSetBuffer(HP(pmmio), NULL, 0L, 0);
FreeHandle(HP(pmmio));
return (HMMIO) TRUE;
}
/* the initial "current buffered offset" will be equal to the initial
* "current disk offset"
*/
pmmio->lBufOffset = pmmio->lDiskOffset;
return HP(pmmio);
}
/* @doc EXTERNAL
@api UINT | mmioClose | This function closes a file opened with
<f mmioOpen>.
@parm HMMIO | hmmio | Specifies the file handle of the file to
close.
@parm UINT | wFlags | Specifies options for the close operation.
@flag MMIO_FHOPEN | If the file was opened by passing the DOS
file handle of an already-opened file to <f mmioOpen>, then
using this flag tells <f mmioClose> to close the MMIO file
handle, but not the DOS file handle.
@rdesc The return value is zero if the function is successful.
Otherwise, the return value is an error code, either from
<f mmioFlush> or from the I/O procedure. The error code can be
one of the following codes:
@flag MMIOERR_CANNOTWRITE | The contents of the buffer could
not be written to disk.
@xref mmioOpen mmioFlush
*/
UINT WINAPI
mmioClose(HMMIO hmmio, UINT wFlags)
{
UINT w;
V_HANDLE(hmmio, TYPE_MMIO, MMSYSERR_INVALHANDLE);
if (mmioFlush(hmmio, 0) != 0) {
DebugErr(DBF_WARNING, "MMIO File flush failed during close.\r\n");
PH(hmmio)->dwFlags &= ~MMIO_DIRTY;
}
if ((w = (UINT)(DWORD) PH(hmmio)->pIOProc((LPSTR)PH(hmmio), MMIOM_CLOSE, (LPARAM)(DWORD) wFlags, (LPARAM) 0)) != 0)
return w;
/* free the buffer if necessary */
mmioSetBuffer(hmmio, NULL, 0L, 0);
FreeHandle(hmmio);
return 0;
}
/* @doc EXTERNAL
@api LONG | mmioRead | This function reads a specified number of
bytes from a file opened with <f mmioOpen>.
@parm HMMIO | hmmio | Specifies the file handle of the file to be
read.
@parm HPSTR | pch | Specifies a huge pointer to a buffer to contain
the data read from the file.
@parm LONG | cch | Specifies the number of bytes to read from the
file.
@rdesc The return value is the number of bytes actually read. If the
end of the file has been reached and no more bytes can be read, the
return value is zero. If there is an error reading from the file, the
return value is -1.
@xref mmioWrite
*/
LONG WINAPI
mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
{
LONG lTotalBytesRead = 0L; // total no. bytes read
LONG lBytes; // no. bytes that can be read
V_HANDLE(hmmio, TYPE_MMIO, -1);
V_WPOINTER(pch, cch, -1);
while (TRUE)
{
/* calculate the number of bytes that can be read */
lBytes = PH(hmmio)->pchEndRead - PH(hmmio)->pchNext;
/* can only read at most <cch> bytes from buffer */
if (lBytes > cch)
lBytes = cch;
if (lBytes > 0)
{
/* this is where some performance improvements can
* be made, especially for small reads... should
* special-case cases when segment boundaries are
* not crossed (or maybe MemCopy() should do that)
*/
MemCopy(pch, PH(hmmio)->pchNext, lBytes);
PH(hmmio)->pchNext += lBytes;
pch += lBytes;
cch -= lBytes;
lTotalBytesRead += lBytes;
}
/* cannot do MMIOM_READ from memory files */
if (PH(hmmio)->fccIOProc == FOURCC_MEM)
return lTotalBytesRead;
if (cch == 0) // no more to read?
return lTotalBytesRead;
/* we need to read beyond this buffer; if we have at least
* another bufferful to read, just call the I/O procedure
*/
if (cch > PH(hmmio)->cchBuffer)
break;
/* read the next bufferful and loop around */
if (mmioAdvance(hmmio, NULL, MMIO_READ) != 0)
return -1;
/* if mmioAdvance() couldn't read any more data, we must be
* at the end of the file
*/
if (PH(hmmio)->pchNext == PH(hmmio)->pchEndRead)
return lTotalBytesRead;
}
/* flush and empty the I/O buffer and manipulate <lBufOffset>
* directly to change the current file position
*/
if (mmioFlush(hmmio, MMIO_EMPTYBUF) != 0)
return -1;
/* call the I/O procedure to do the rest of the reading */
lBytes = mmioDiskIO(PH(hmmio), MMIOM_READ, pch, cch);
PH(hmmio)->lBufOffset = PH(hmmio)->lDiskOffset;
return (lBytes == -1L) ? -1L : lTotalBytesRead + lBytes;
}
/* @doc EXTERNAL
@api LONG | mmioWrite | This function writes a specified number of
bytes to a file opened with <f mmioOpen>.
@parm HMMIO | hmmio | Specifies the file handle of the file.
@parm char _huge* | pch | Specifies a huge pointer to the buffer to be
written to the file.
@parm LONG | cch | Specifies the number of bytes to write to the
file.
@rdesc The return value is the number of bytes actually written. If
there is an error writing to the file, the return value is -1.
@comm The current file position is incremented by the number of
bytes written.
@xref mmioRead
*/
LONG WINAPI
mmioWrite(HMMIO hmmio, const char _huge* pch, LONG cch)
{
LONG lTotalBytesWritten = 0L; // total no. bytes written
LONG lBytes; // no. bytes that can be written
V_HANDLE(hmmio, TYPE_MMIO, -1);
V_RPOINTER(pch, cch, -1);
while (TRUE)
{
/* calculate the number of bytes that can be written */
lBytes = PH(hmmio)->pchEndWrite - PH(hmmio)->pchNext;
if ((cch > lBytes) && (PH(hmmio)->fccIOProc == FOURCC_MEM))
{
/* this is a memory file -- expand it */
if (mmioExpandMemFile(PH(hmmio), cch - lBytes) != 0)
return -1; // cannot expand
lBytes = PH(hmmio)->pchEndWrite - PH(hmmio)->pchNext;
}
/* can only write at most <cch> bytes into the buffer */
if (lBytes > cch)
lBytes = cch;
/* this is where some performance improvements can
* be made, especially for small writes... should
* special-case cases when segment boundaries are
* not crossed (or maybe MemCopy() should do that)
*/
if (lBytes > 0)
{
MemCopy(PH(hmmio)->pchNext, pch, lBytes);
PH(hmmio)->dwFlags |= MMIO_DIRTY;
PH(hmmio)->pchNext += lBytes;
pch += lBytes;
cch -= lBytes;
lTotalBytesWritten += lBytes;
}
/* validate <pchEndRead>, i.e. re-enforce the invariant that
* <pchEndRead> points past the last valid byte in the buffer
*/
if (PH(hmmio)->pchEndRead < PH(hmmio)->pchNext)
PH(hmmio)->pchEndRead = PH(hmmio)->pchNext;
if (cch == 0) // no more to write?
return lTotalBytesWritten;
/* we need to read beyond this buffer; if we have at least
* another bufferful to read, just call the I/O procedure
*/
if (cch > PH(hmmio)->cchBuffer)
break;
/* write this buffer (if needed) and read the next
* bufferful (if needed)
*/
if (mmioAdvance(hmmio, NULL, MMIO_WRITE) != 0)
return -1;
}
/* we should never need to do MMIOM_WRITE with memory files */
/* flush and empty the I/O buffer and manipulate <lBufOffset>
* directly to change the current file position
*/
if (mmioFlush(hmmio, MMIO_EMPTYBUF) != 0)
return -1;
/* call the I/O procedure to do the rest of the writing */
lBytes = mmioDiskIO(PH(hmmio), MMIOM_WRITE, (HPSTR)pch, cch);
PH(hmmio)->lBufOffset = PH(hmmio)->lDiskOffset;
return (lBytes == -1L) ? -1L : lTotalBytesWritten + lBytes;
}
/* @doc EXTERNAL
@api LONG | mmioSeek | This function changes the current file
position in a file opened with <f mmioOpen>. The current file
position is the location in the file where data is read or written.
@parm HMMIO | hmmio | Specifies the file handle of the file to seek
in.
@parm LONG | lOffset | Specifies an offset to change the file position.
@parm int | iOrigin | Specifies how the offset specified by
<p lOffset> is interpreted. Contains one of the following flags:
@flag SEEK_SET | Seeks to <p lOffset> bytes from the beginning
of the file.
@flag SEEK_CUR | Seeks to <p lOffset> bytes from the current
file position.
@flag SEEK_END | Seeks to <p lOffset> bytes from the end
of the file.
@rdesc The return value is the new file position in bytes, relative
to the beginning of the file. If there is an error, the return value
is -1.
@comm Seeking to an invalid location in the file, such as past the
end of the file, may not cause <f mmioSeek> to return an error,
but may cause subsequent I/O operations on the file to fail.
To locate the end of a file, call <f mmioSeek> with <p lOffset>
set to zero and <p iOrigin> set to SEEK_END.
*/
LONG WINAPI
mmioSeek(HMMIO hmmio, LONG lOffset, int iOrigin)
{
LONG lCurOffset; // disk offset of <pchNext>
LONG lEndBufOffset; // disk offset of end of buffer
LONG lNewOffset; // new disk offset
V_HANDLE(hmmio, TYPE_MMIO, -1);
/* careful! all this buffer pointer manipulation is fine, but keep
* in mind that buffering may be disabled (in which case <pchEndRead>
* and <pchBuffer> will both be NULL, so the buffer will appear to
* be zero bytes in size)
*/
/* <PH(hmmio)->lBufOffset> is the disk offset of the start of the start
* of the buffer; determine <lCurOffset>, the offset of <pchNext>,
* and <lEndBufOffset>, the offset of the end of the valid part
* of the buffer
*/
lCurOffset = PH(hmmio)->lBufOffset +
(PH(hmmio)->pchNext - PH(hmmio)->pchBuffer);
lEndBufOffset = PH(hmmio)->lBufOffset +
(PH(hmmio)->pchEndRead - PH(hmmio)->pchBuffer);
/* determine <lNewOffset>, the offset to seek to */
switch (iOrigin)
{
case SEEK_SET: // seek relative to start of file
lNewOffset = lOffset;
break;
case SEEK_CUR: // seek relative to current location
lNewOffset = lCurOffset + lOffset;
break;
case SEEK_END: // seek relative to end of file
if (PH(hmmio)->fccIOProc == FOURCC_MEM)
lNewOffset = lEndBufOffset - lOffset;
else
{
LONG lEndFileOffset;
/* find out where the end of the file is */
if ((lEndFileOffset = (LONG) PH(hmmio)->pIOProc((LPSTR) PH(hmmio),
MMIOM_SEEK, (LPARAM) 0, (LPARAM) SEEK_END)) == -1)
return -1;
lNewOffset = lEndFileOffset - lOffset;
}
break;
default:
return -1;
}
if ((lNewOffset >= PH(hmmio)->lBufOffset) && (lNewOffset <= lEndBufOffset))
{
/* seeking within the valid part of the buffer
* (possibly including seeking to <lEndBufOffset>)
*/
PH(hmmio)->pchNext = PH(hmmio)->pchBuffer +
(lNewOffset - PH(hmmio)->lBufOffset);
}
else
{
/* seeking outside the buffer */
if (PH(hmmio)->fccIOProc == FOURCC_MEM)
return -1; // can't seek outside mem. file buffer
if (mmioFlush(hmmio, 0) != 0)
return -1;
/* the current "buffered file position" (same as <lDiskOffset>
* for unbuffered files) equals <lBufOffset> +
* (<pchNext> - <pchBuffer>); we'll move the current buffered
* file position (and empty the buffer, since it becomes
* invalid when <lBufOffset> changes) as follows...
*/
PH(hmmio)->lBufOffset = lNewOffset;
PH(hmmio)->pchNext = PH(hmmio)->pchEndRead = PH(hmmio)->pchBuffer;
/* don't need to actually seek right now, since the next
* MMIOM_READ or MMIOM_WRITE will have to seek anyway
*/
}
return lNewOffset;
}
/* @doc EXTERNAL
@api UINT | mmioGetInfo | This function retrieves information
about a file opened with <f mmioOpen>. This information allows the
caller to directly access the I/O buffer, if the file is opened
for buffered I/O.
@parm HMMIO | hmmio | Specifies the file handle of the file.
@parm LPMMIOINFO | lpmmioinfo | Specifies a far pointer to a
caller-allocated <t MMIOINFO> structure that <f mmioGetInfo>
fills with information about the file. See the <t MMIOINFO> structure
and the <f mmioOpen> function for information about the fields in
this structure.
@parm UINT | wFlags | Is not used and should be set to zero.
@rdesc The return value is zero if the function is successful.
@comm To directly access the I/O buffer of a file opened for
buffered I/O, use the following fields of the <t MMIOINFO> structure
filled by <f mmioGetInfo>:
-- The <e MMIOINFO.pchNext> field points to the next byte in the
buffer that can be read or written. When you read or write, increment
<e MMIOINFO.pchNext> by the number of bytes read or written.
-- The <e MMIOINFO.pchEndRead> field points to one byte past the
last valid byte in the buffer that can be read.
-- The <e MMIOINFO.pchEndWrite> field points to one byte past the
last location in the buffer that can be written.
Once you read or write to the buffer and modify
<e MMIOINFO.pchNext>, do not call any MMIO function except
<f mmioAdvance> until you call <f mmioSetInfo>. Call <f mmioSetInfo>
when you are finished directly accessing the buffer.
When you reach the end of the buffer specified by
<e MMIOINFO.pchEndRead> or <e MMIOINFO.pchEndWrite>, call
<f mmioAdvance> to fill the buffer from the disk, or write
the buffer to the disk. The <f mmioAdvance> function
will update the <e MMIOINFO.pchNext>, <e MMIOINFO.pchEndRead>, and
<e MMIOINFO.pchEndWrite> fields in the <t MMIOINFO> structure for the
file.
Before calling <f mmioAdvance> or <f mmioSetInfo> to flush a
buffer to disk, set the MMIO_DIRTY flag in the <e MMIOINFO.dwFlags>
field of the <t MMIOINFO> structure for the file. Otherwise, the
buffer will not get written to disk.
Do not decrement <e MMIOINFO.pchNext> or modify any fields in the
<t MMIOINFO> structure other than <e MMIOINFO.pchNext> and
<e MMIOINFO.dwFlags>. Do not set any flags in <e MMIOINFO.dwFlags>
except MMIO_DIRTY.
@xref mmioSetInfo MMIOINFO
*/
UINT WINAPI
mmioGetInfo(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT wFlags)
{
V_HANDLE(hmmio, TYPE_MMIO, MMSYSERR_INVALHANDLE);
V_WPOINTER(lpmmioinfo, sizeof(MMIOINFO), MMSYSERR_INVALPARAM);
V_FLAGS(wFlags, 0, mmioGetInfo, MMSYSERR_INVALFLAG);
*lpmmioinfo = *PH(hmmio);
return 0;
}
/* @doc EXTERNAL
@api UINT | mmioSetInfo | This function updates the information
retrieved by <f mmioGetInfo> about a file opened with <f mmioOpen>.
Use this function to terminate direct buffer access of a file opened
for buffered I/O.
@parm HMMIO | hmmio | Specifies the file handle of the file.
@parm LPMMIOINFO | lpmmioinfo | Specifies a far pointer to an
<t MMIOINFO> structure filled with information with
<f mmioGetInfo>.
@parm UINT | wFlags | Is not used and should be set to zero.
@rdesc The return value is zero if the function is successful.
@comm If you have written to the file I/O buffer, set the
MMIO_DIRTY flag in the <e MMIOINFO.dwFlags> field of the <t MMIOINFO>
structure before calling <f mmioSetInfo> to terminate direct buffer
access. Otherwise, the buffer will not get flushed to disk.
@xref mmioGetInfo MMIOINFO
*/
UINT WINAPI
mmioSetInfo(HMMIO hmmio, const MMIOINFO FAR* lpmmioinfo, UINT wFlags)
{
V_HANDLE(hmmio, TYPE_MMIO, MMSYSERR_INVALHANDLE);
V_RPOINTER(lpmmioinfo, sizeof(MMIOINFO), MMSYSERR_INVALPARAM);
V_WPOINTER0(lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer, MMSYSERR_INVALPARAM);
V_CALLBACK((FARPROC)lpmmioinfo->pIOProc, MMSYSERR_INVALPARAM);
V_FLAGS(wFlags, 0, mmioSetInfo, MMSYSERR_INVALFLAG);
/* copy the relevant information from <lpmmioinfo> back into <hmmio> */
*PH(hmmio) = *lpmmioinfo;
/* validate <pchEndRead>, i.e. re-enforce the invariant that
* <pchEndRead> points past the last valid byte in the buffer
*/
if (PH(hmmio)->pchEndRead < PH(hmmio)->pchNext)
PH(hmmio)->pchEndRead = PH(hmmio)->pchNext;
return 0;
}
/* @doc EXTERNAL
@api UINT | mmioSetBuffer | This function enables or disables
buffered I/O, or changes the buffer or buffer size for a file opened
with <f mmioOpen>.
@parm HMMIO | hmmio | Specifies the file handle of the file.
@parm LPSTR | pchBuffer | Specifies a far pointer to a
caller-supplied buffer to use for buffered I/O. If NULL,
<f mmioSetBuffer> allocates an internal buffer for buffered I/O.
@parm LONG | cchBuffer | Specifies the size of the caller-supplied
buffer, or the size of the buffer for <f mmioSetBuffer> to allocate.
@parm UINT | wFlags | Is not used and should be set to zero.
@rdesc The return value is zero if the function is successful.
Otherwise, the return value specifies an error code. If an error
occurs, the file handle remains valid. The error code can be one
of the following codes:
@flag MMIOERR_CANNOTWRITE | The contents of the old buffer could
not be written to disk, so the operation was aborted.
@flag MMIOERR_OUTOFMEMORY | The new buffer could not be allocated,
probably due to a lack of available memory.
@comm To enable buffering using an internal buffer, set
<p pchBuffer> to NULL and <p cchBuffer> to the desired buffer size.
To supply your own buffer, set <p pchBuffer> to point to the buffer,
and set <p cchBuffer> to the size of the buffer.
To disable buffered I/O, set <p pchBuffer> to NULL and
<p cchBuffer> to zero.
If buffered I/O is already enabled using an internal buffer, you
can reallocate the buffer to a different size by setting
<p pchBuffer> to NULL and <p cchBuffer> to the new buffer size. The
contents of the buffer may be changed after resizing.
*/
UINT WINAPI
mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT wFlags)
{
UINT w;
V_HANDLE(hmmio, TYPE_MMIO, MMSYSERR_INVALHANDLE);
V_WPOINTER0(pchBuffer, cchBuffer, MMSYSERR_INVALPARAM);
V_FLAGS(wFlags, 0, mmioSetBuffer, MMSYSERR_INVALFLAG);
if ((PH(hmmio)->dwFlags & MMIO_ALLOCBUF) &&
(pchBuffer == NULL) && (cchBuffer > 0))
{
/* grow or shrink buffer in-place */
HPSTR pch;
LONG lDeltaNext;
LONG lDeltaEndRead;
/* Since the ALLOCBUF flag is set, we must have a buffer */
/* write the buffer to disk, but don't empty it */
if ((w = mmioFlush(hmmio, 0)) != 0)
return w;
while (TRUE)
{
/* remember where <pchNext> and <pchEndRead> are
* in the buffer
*/
lDeltaNext = PH(hmmio)->pchNext - PH(hmmio)->pchBuffer;
lDeltaEndRead = PH(hmmio)->pchEndRead - PH(hmmio)->pchBuffer;
if (cchBuffer >= lDeltaNext)
break;
/* caller wants to truncate the part of the buffer
* that contains <pchNext> -- handle this by
* emptying the buffer, recalculating <lDeltaNext>
* and <lDeltaEndRead>, and continuing below
*/
if ((w = mmioFlush(hmmio, MMIO_EMPTYBUF)) != 0)
return w;
}
/* reallocate buffer */
pch = GlobalReAllocPtr(PH(hmmio)->pchBuffer, cchBuffer, GMEM_MOVEABLE);
/* If we cannot allocate the new buffer, exit with no
* harm done.
*/
if (pch == NULL)
return MMIOERR_OUTOFMEMORY; // out of memory
/* transfer pointers to new buffer */
PH(hmmio)->cchBuffer = cchBuffer;
PH(hmmio)->pchBuffer = pch;
PH(hmmio)->pchNext = pch + lDeltaNext;
PH(hmmio)->pchEndRead = pch + lDeltaEndRead;
/* <pchEndWrite> always points to the end of the buf. */
PH(hmmio)->pchEndWrite = PH(hmmio)->pchBuffer + cchBuffer;
/* check if the reallocation truncated valid data */
if (lDeltaEndRead > cchBuffer)
PH(hmmio)->pchEndRead = PH(hmmio)->pchEndWrite;
return 0;
}
/* write the buffer to disk and stop using the buffer */
if ((w = mmioFlush(hmmio, MMIO_EMPTYBUF)) != 0)
return w;
if (PH(hmmio)->dwFlags & MMIO_ALLOCBUF)
{
GlobalFreePtr(PH(hmmio)->pchBuffer);
PH(hmmio)->dwFlags &= ~MMIO_ALLOCBUF;
}
/* Initially, no error. */
w = 0;
if ((pchBuffer == NULL) && (cchBuffer > 0))
{
pchBuffer = GlobalAllocPtr(GMEM_MOVEABLE, cchBuffer);
/* If there is an error, change the file to be un-buffered
* and return an error code. The file is still valid.
* (Just for a little extra security.)
*/
if (pchBuffer == NULL) {
w = MMIOERR_OUTOFMEMORY;
cchBuffer = 0L;
} else
PH(hmmio)->dwFlags |= MMIO_ALLOCBUF;
}
/* invariant: <pchEndRead> points past the end of the "valid" portion
* of the buffer, and <pchEndWrite> points past the last byte that
* can be written into; <pchNext> points to the next byte to read
* or write; <lBufOffset> is the current disk offset of the start
* of the buffer, and it will not change
*/
PH(hmmio)->pchBuffer = pchBuffer;
PH(hmmio)->cchBuffer = cchBuffer;
PH(hmmio)->pchNext = PH(hmmio)->pchEndRead = PH(hmmio)->pchBuffer;
PH(hmmio)->pchEndWrite = PH(hmmio)->pchBuffer + cchBuffer;
return w;
}
/* @doc EXTERNAL
@api UINT | mmioFlush | This function writes the I/O buffer of a
file to disk, if the I/O buffer has been written to.
@parm HMMIO | hmmio | Specifies the file handle of a file opened
with <f mmioOpen>.
@parm UINT | wFlags | Is not used and should be set to zero.
@rdesc The return value is zero if the function is successful.
Otherwise, the return value specifies an error code. The error
code can be one of the following codes:
@flag MMIOERR_CANNOTWRITE | The contents of the buffer could
not be written to disk.
@comm Closing a file with <f mmioClose> will automatically flush
its buffer.
If there is insufficient disk space to write the
buffer, <f mmioFlush> will fail, even if the preceding <f mmioWrite>
calls were successful.
*/
UINT WINAPI
mmioFlush(HMMIO hmmio, UINT wFlags)
{
LONG lBytesAsk; // no. bytes to write
LONG lBytesWritten; // no. bytes actually written
V_HANDLE(hmmio, TYPE_MMIO, MMSYSERR_INVALHANDLE);
V_FLAGS(wFlags, MMIO_FLUSH_VALID, mmioFlush, MMSYSERR_INVALFLAG);
if ((PH(hmmio)->fccIOProc == FOURCC_MEM) || (PH(hmmio)->pchBuffer == NULL))
return 0; // cannot flush memory files
/* if the file is unbuffered then the dirty flag should not be set */
if (PH(hmmio)->dwFlags & MMIO_DIRTY)
{
/* figure out how many bytes need to be flushed */
lBytesAsk = PH(hmmio)->pchEndRead - PH(hmmio)->pchBuffer;
/* write the buffer to disk */
lBytesWritten = mmioDiskIO(PH(hmmio), MMIOM_WRITEFLUSH,
PH(hmmio)->pchBuffer, lBytesAsk);
if (lBytesWritten != lBytesAsk)
return MMIOERR_CANNOTWRITE;
PH(hmmio)->dwFlags &= ~MMIO_DIRTY; // buffer is clean now
}
if (wFlags & MMIO_EMPTYBUF)
{
/* empty the I/O buffer, and update <lBufOffset> to reflect
* what the current file position is
*/
PH(hmmio)->lBufOffset += (PH(hmmio)->pchNext - PH(hmmio)->pchBuffer);
PH(hmmio)->pchNext = PH(hmmio)->pchEndRead = PH(hmmio)->pchBuffer;
}
return 0;
}
/* @doc EXTERNAL
@api UINT | mmioAdvance | This function advances the I/O buffer of
a file set up for direct I/O buffer access with <f mmioGetInfo>. If
the file is opened for reading, the I/O buffer is filled from the
disk. If the file is opened for writing and the MMIO_DIRTY flag is
set in the <e MMIOINFO.dwFlags> field of the <t MMIOINFO> structure,
the buffer is written to disk. The <e MMIOINFO.pchNext>,
<e MMIOINFO.pchEndRead>, and <e MMIOINFO.pchEndWrite> fields of the
<t MMIOINFO> structure are updated to reflect the new state of
the I/O buffer.
@parm HMMIO | hmmio | Specifies the file handle for a file opened
with <f mmioOpen>.
@parm LPMMIOINFO | lpmmioinfo | Optionally specifies a far pointer to the
<t MMIOINFO> structure obtained with <f mmioGetInfo>, which is used to
set the current file information, then updated after the buffer is
advanced.
@parm UINT | wFlags | Specifies options for the operation.
Contains exactly one of the following two flags:
@flag MMIO_READ | The buffer is filled from the file.
@flag MMIO_WRITE | The buffer is written to the file.
@rdesc The return value is zero if the operation is successful.
Otherwise, the return value specifies an error code. The error
code can be one of the following codes:
@flag MMIOERR_CANNOTWRITE | The contents of the buffer could
not be written to disk.
@flag MMIOERR_CANNOTREAD | An error occurred while re-filling
the buffer.
@flag MMIOERR_UNBUFFERED | The specified file is not opened
for buffered I/O.
@flag MMIOERR_CANNOTEXPAND | The specified memory file cannot
be expanded, probably because the <e MMIOINFO.adwInfo[0]> field
was set to zero in the initial call to <f mmioOpen>.
@flag MMIOERR_OUTOFMEMORY | There was not enough memory to expand
a memory file for further writing.
@comm If the specified file is opened for writing or for both
reading and writing, the I/O buffer will be flushed to disk before
the next buffer is read. If the I/O buffer cannot be written to disk
because the disk is full, then <f mmioAdvance> will return
MMIOERR_CANNOTWRITE.
If the specified file is only open for writing, the MMIO_WRITE
flag must be specified.
If you have written to the I/O buffer, you must set the MMIO_DIRTY
flag in the <e MMIOINFO.dwFlags> field of the <t MMIOINFO> structure
before calling <f mmioAdvance>. Otherwise, the buffer will not be
written to disk.
If the end of file is reached, <f mmioAdvance> will still return
success, even though no more data can be read. Thus, to check for
the end of the file, it is necessary to see if the
<e MMIOINFO.pchNext> and <e MMIOINFO.pchEndRead> fields of the
<t MMIOINFO> structure are equal after calling <f mmioAdvance>.
@xref mmioGetInfo MMIOINFO
*/
UINT WINAPI
mmioAdvance(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT wFlags)
{
LONG lBytesRead; // bytes actually read
UINT w;
V_HANDLE(hmmio, TYPE_MMIO, MMSYSERR_INVALHANDLE);
V_FLAGS(wFlags, MMIO_ADVANCE_VALID, mmioAdvance, MMSYSERR_INVALFLAG);
if (PH(hmmio)->pchBuffer == NULL)
return MMIOERR_UNBUFFERED;
if (lpmmioinfo != NULL) {
V_WPOINTER(lpmmioinfo, sizeof(MMIOINFO), MMSYSERR_INVALPARAM);
mmioSetInfo(hmmio, lpmmioinfo, 0);
}
if (PH(hmmio)->fccIOProc == FOURCC_MEM)
{
/* this is a memory file:
* -- if the caller is reading, cannot advance
* -- if the caller is writing, then advance by expanding
* the buffer (if possible) if the there is less than
* <adwInfo[0]> bytes left in the buffer
*/
if (!(wFlags & MMIO_WRITE))
return 0;
if ((DWORD)(PH(hmmio)->pchEndWrite - PH(hmmio)->pchNext) >= PH(hmmio)->adwInfo[0])
return 0;
if ((w = mmioExpandMemFile(PH(hmmio), 1L)) != 0)
return w; // out of memory, or whatever
goto GETINFO_AND_EXIT;
}
/* empty the I/O buffer, which will effectively advance the
* buffer by (<pchNext> - <pchBuffer>) bytes
*/
if ((w = mmioFlush(hmmio, MMIO_EMPTYBUF)) != 0)
return w;
/* if MMIO_WRITE bit is not set in wFlags, fill the buffer */
if (!(wFlags & MMIO_WRITE))
{
/* read the next bufferful from the file */
lBytesRead = mmioDiskIO(PH(hmmio), MMIOM_READ,
PH(hmmio)->pchBuffer, PH(hmmio)->cchBuffer);
if (lBytesRead == -1)
return MMIOERR_CANNOTREAD;
/* reading zero bytes should not be treated as an error
* condition -- e.g. open a new file R+W and call
* mmioAdvance(), and MMIOM_READ will return zero bytes
* because the file started off empty
*/
PH(hmmio)->pchEndRead += lBytesRead;
}
GETINFO_AND_EXIT:
/* copy <hmmio> back to <lpmmioinfo> if <lpmmioinfo> is provided */
if (lpmmioinfo != NULL)
mmioGetInfo(hmmio, lpmmioinfo, 0);
return 0;
}
/* @doc EXTERNAL
@api FOURCC | mmioStringToFOURCC | This function converts a
null-terminated string to a four-character code.
@parm LPCSTR | sz | Specifies a far pointer to a null-terminated
string to a four-character code.
@parm UINT | wFlags | Specifies options for the conversion:
@flag MMIO_TOUPPER | Converts all characters to uppercase.
@rdesc The return value is the four character code created from the
given string.
@comm This function does not check to see if the string referenced
by <p sz> follows any conventions regarding which characters to
include in a four-character code. The string is
simply copied to a four-character code and padded with blanks or
truncated to four characters if required.
@xref mmioFOURCC
*/
FOURCC WINAPI
mmioStringToFOURCC(LPCSTR sz, UINT wFlags)
{
FOURCC fcc;
LPSTR pch = (LPSTR) &fcc;
int i;
V_STRING(sz, (UINT)-1, NULL);
V_FLAGS(wFlags, MMIO_FOURCC_VALID, mmioStringToFOURCC, (FOURCC)-1);
for (i = sizeof(FOURCC) - 1; i >= 0; i--)
{
if (!*sz)
*pch = ' ';
else {
*pch = *sz++;
if (wFlags & MMIO_TOUPPER)
*pch = (char)(WORD)(LONG)AnsiUpper((LPSTR)(LONG)*pch);
}
pch++;
}
return fcc;
}
/* @doc EXTERNAL
@api LPMMIOPROC | mmioInstallIOProc | This function installs or
removes a custom I/O procedure. It will also locate an installed I/O
procedure, given its corresponding four-character code.
@parm FOURCC | fccIOProc | Specifies a four-character code
identifying the I/O procedure to install, remove, or locate. All
characters in this four-character code should be uppercase characters.
@parm LPMMIOPROC | pIOProc | Specifies the address of the I/O
procedure to install. To remove or locate an I/O procedure, set this
parameter to NULL.
@parm DWORD | dwFlags | Specifies one of the following flags
indicating whether the I/O procedure is being installed, removed, or
located:
@flag MMIO_INSTALLPROC | Installs the specified I/O procedure.
@flag MMIO_GLOBALPROC | This flag is a modifier to the install flag,
and indicates the I/O procedure should be installed for global
use. This flag is ignored on removal or find.
@flag MMIO_REMOVEPROC | Removes the specified I/O procedure.
@flag MMIO_FINDPROC | Searches for the specified I/O procedure.
@rdesc The return value is the address of the I/O procedure
installed, removed, or located. If there is an error, the return value
is NULL.
@comm If the I/O procedure resides in the application, use
<f MakeProcInstance> to get a procedure-instance address and specify
this address for <p pIOProc>. You don't need to get a procedure-instance
address if the I/O procedure resides in a DLL.
@cb LRESULT FAR PASCAL | IOProc | <f IOProc> is a placeholder for the
application-supplied function name. The actual name must be exported
by including it in a EXPORTS statement in the application's
module-definitions file.
@parm LPSTR | lpmmioinfo | Specifies a far pointer to an
<t MMIOINFO> structure containing information about the open
file. The I/O procedure must maintain the <e MMIOINFO.lDiskOffset>
field in this structure to indicate the file offset to the
next read or write location. The I/O procedure can use the
<e MMIOINFO.adwInfo[]> field to store state information. The
I/O procedure should not modify any other fields of the
<t MMIOINFO> structure.
@parm UINT | wMsg | Specifies a message indicating the
requested I/O operation. Messages that can be received include
<m MMIOM_OPEN>, <m MMIOM_CLOSE>, <m MMIOM_READ>, <m MMIOM_WRITE>,
and <m MMIOM_SEEK>.
@parm LPARAM | lParam1 | Specifies a parameter for the message.
@parm LPARAM | lParam2 | Specifies a parameter for the message.
@rdesc The return value depends on the message specified by
<p wMsg>. If the I/O procedure does not recognize a message, it should
return zero.
@comm The four-character code specified by the
<e MMIOINFO.fccIOProc> field in the <t MMIOINFO> structure
associated with a file identifies a filename extension for a custom
storage system. When an application calls <f mmioOpen> with a
filename such as "foo.xyz!bar", the I/O procedure associated with the
four-character code "XYZ " is called to open the "bar" element of the
file "foo.xyz".
The <f mmioInstallIOProc> function maintains a separate list of
installed I/O procedures for each Windows application. Therefore,
different applications can use the same I/O procedure identifier for
different I/O procedures without conflict. Installing an I/O procedure
globally however enables any process to use the procedure.
If an application calls <f mmioInstallIOProc> more than once to
register the same I/O procedure, then it must call
<f mmioInstallIOProc> to remove the procedure once for each time it
installed the procedure.
<f mmioInstallIOProc> will not prevent an application from
installing two different I/O procedures with the same identifier, or
installing an I/O procedure with one of the predefined identifiers
("DOS ", "MEM "). The most recently installed procedure
takes precedence, and the most recently installed procedure is the
first one to get removed.
When searching for a specified I/O procedure, local procedures are
searched first, then global procedures.
@xref mmioOpen
*/
LPMMIOPROC WINAPI
mmioInstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
{
IOProcMapEntry *pEnt; // an entry in linked list
HTASK hTaskCurrent; // current Windows task handl
V_FLAGS(dwFlags, MMIO_VALIDPROC, mmioInstallIOProc, NULL);
if (fccIOProc == 0L)
return NULL;
hTaskCurrent = GetCurrentTask();
if (dwFlags & MMIO_INSTALLPROC)
{
/* install I/O procedure -- always add at the beginning of
* the list, so it overrides any other I/O procedures
* with the same identifier installed by the same task
*/
V_CALLBACK((FARPROC)pIOProc, NULL);
if ((pEnt = (IOProcMapEntry NEAR *)
NewHandle(TYPE_IOPROC, sizeof(IOProcMapEntry))) == NULL)
return NULL; // out of memory
pEnt->fccIOProc = fccIOProc;
pEnt->pIOProc = pIOProc;
if (dwFlags & MMIO_GLOBALPROC) {
char libname[128];
char aszFour[sizeof(FOURCC)+1];
pEnt->hTask = NULL;
SetHandleOwner(pEnt, NULL);
//
// This is the hack to allow global IO Procs to be truly
// global. That is, if there is a matching 32 bit entry
// in win.ini under [IOProcs] for this fccIOProc will we try
// load the dll. The dll should install its 32 bit
// equivalent IOProc in the dll initialisation routine.
//
*(LPDWORD)&aszFour = (DWORD)fccIOProc;
aszFour[ sizeof(FOURCC) ] = '\0';
if ( GetProfileString( "IOProcs", aszFour, "", libname,
sizeof(libname) ) ) {
LoadLibraryEx32W( libname, 0L, 0L );
}
} else {
pEnt->hTask = hTaskCurrent;
}
pEnt->wFlags = 0;
pEnt->pNext = gIOProcMapHead;
gIOProcMapHead = pEnt;
return pIOProc;
}
if (!pIOProc)
if (dwFlags & MMIO_REMOVEPROC) {
LPMMIOPROC lpmmioproc;
lpmmioproc = RemoveIOProc(fccIOProc, hTaskCurrent);
if (!lpmmioproc)
lpmmioproc = RemoveIOProc(fccIOProc, NULL);
return lpmmioproc;
} else if (dwFlags & MMIO_FINDPROC)
return FindIOProc(fccIOProc, hTaskCurrent);
return NULL; // couldn't find requested I/O procedure
}
/* @doc EXTERNAL
@api LRESULT | mmioSendMessage | This function sends a message to the
I/O procedure associated with the specified file.
@parm HMMIO | hmmio | Specifies the file handle for a file opened
with <f mmioOpen>.
@parm UINT | wMsg | Specifies the message to send to the I/O procedure.
@parm LPARAM | lParam1 | Specifies a parameter for the message.
@parm LPARAM | lParam2 | Specifies a parameter for the message.
@rdesc The return value depends on the message. If the I/O procedure
does not recognize the message, the return value is zero.
@comm Use this function to send custom user-defined messages. Do
not use it to send the <m MMIOM_OPEN>, <m MMIOM_CLOSE>,
<m MMIOM_READ>, <m MMIOM_WRITE>, <m MMIOM_WRITEFLUSH>, or
<m MMIOM_SEEK> messages. Define
custom messages to be greater than or equal to the MMIOM_USER constant.
@xref mmioInstallIOProc
*/
LRESULT WINAPI
mmioSendMessage(HMMIO hmmio, UINT wMsg, LPARAM lParam1, LPARAM lParam2)
{
V_HANDLE(hmmio, TYPE_MMIO, (LRESULT)0);
return PH(hmmio)->pIOProc((LPSTR)PH(hmmio), wMsg, lParam1, lParam2);
}
/* @doc INTERNAL
@api LONG | mmioDiskIO | Perform an unbuffered read or write.
Do not assume where the current disk offset <p lDiskOffset> will be.
@parm PMMIO | pmmio | The open file handle returned by <f mmioOpen>.
@parm UINT | wMsg | MMIOM_READ if <f mmioDiskIO> should read from the disk,
or MMIOM_WRITE if <f mmioDiskIO> should write to the disk.
@parm HPSTR | pch | The buffer to read into or write from.
@parm LONG | cch | The number of bytes to read or write.
<f mmioDiskIO> changes the disk offset to be <p lBufOffset>
and then performs an MMIOM_READ or MMIOM_WRITE operation as
specified by <p wMsg>, <p pch>, and <p cch>.
Note that if the I/O buffer is not empty at this point, this
function may not do what you expect.
Do not call this function for memory files.
*/
static LONG NEAR PASCAL
mmioDiskIO(PMMIO pmmio, UINT wMsg, HPSTR pch, LONG cch)
{
if (pmmio->lDiskOffset != pmmio->lBufOffset)
{
if ((LONG) pmmio->pIOProc((LPSTR) pmmio, MMIOM_SEEK, (LPARAM) pmmio->lBufOffset,
(LPARAM) SEEK_SET) == -1)
return -1;
}
return (LONG) pmmio->pIOProc((LPSTR) pmmio, wMsg, (LPARAM) pch, (LPARAM) cch);
}
/* @doc INTERNAL
@api UINT | mmioExpandMemFile | Assuming that <p pmmio> is a memory file,
expand it by <p lExpand> bytes or <p adwInfo[0]> bytes, whichever
is larger. Do not disturb the contents of the buffer or change
the current file position.
@parm PMMIO | pmmio | The open file handle returned by <f mmioOpen>.
@parm LONG | lExpand | The minimum number of bytes to expand the buffer by.
@rdesc If the function succeeds, zero is returned. If the function fails,
an error code is returned. In particular, MMIOERR_OUTOFMEMORY is
returned if memory reallocation failed.
@comm Only call this function for memory files.
*/
static UINT NEAR PASCAL
mmioExpandMemFile(PMMIO pmmio, LONG lExpand)
{
MMIOMEMINFO * pInfo = (MMIOMEMINFO *) pmmio->adwInfo;
DWORD dwFlagsTemp;
UINT w;
/* make sure buffer can be expanded */
/* Note: we used to check ALLOC_BUF here, we don't now. */
if (pInfo->lExpand == 0)
return MMIOERR_CANNOTEXPAND; // cannot grow file
/* how much should the buffer be expanded by? */
if (lExpand < pInfo->lExpand)
lExpand = pInfo->lExpand;
dwFlagsTemp = pmmio->dwFlags;
pmmio->dwFlags |= MMIO_ALLOCBUF;
w = mmioSetBuffer(HP(pmmio), NULL,
pmmio->cchBuffer + lExpand, 0);
pmmio->dwFlags = dwFlagsTemp;
return w;
}
/************************************************************************/
/*
@doc INTERNAL
@func UINT | lrename |
Renames the specified DOS file.
@parm LPCSTR | lszOrigPath |
Points to the DOS file to rename.
@parm LPCSTR | lszNewPath |
Points to the new name for the file.
@rdesc Returns zero if the file was renamed, else the DOS error code.
*/
#pragma warning(4:4035)
#pragma warning(4:4704)
static UINT PASCAL NEAR lrename(
LPCSTR lszOrigPath,
LPCSTR lszNewPath)
{
_asm {
push ds
lds dx, lszOrigPath ; Original name.
les di, lszNewPath ; New name.
mov ah, 56H ; Rename file.
int 21h ; DOS.
sbb bx,bx ; if error (C) BX=FFFF, (NC) BX=000
and ax,bx ; set ax to zero if no error
pop ds
}
}
/* @doc INTERNAL
@api LRESULT | mmioDOSIOProc | The 'DOS' I/O procedure, which handles I/O
on ordinary DOS files.
@parm LPSTR | lpmmioinfo | A pointer to an MMIOINFO block that
contains information about the open file.
@parm UINT | wMsg | The message that the I/O procedure is being
asked to execute.
@parm LPARAM | lParam1 | Specifies additional message information.
@parm LPARAM | lParam2 | Specifies additional message information.
@rdesc Return value depends on <p wMsg>.
*/
static LRESULT CALLBACK
mmioDOSIOProc(LPSTR lpmmioStr, UINT wMsg, LPARAM lParam1, LPARAM lParam2)
{
PMMIO pmmio = (PMMIO) (UINT) (LONG) lpmmioStr; // only in DLL!
MMIODOSINFO * pInfo = (MMIODOSINFO *) pmmio->adwInfo;
LONG lResult;
OFSTRUCT of;
switch (wMsg)
{
case MMIOM_OPEN:
/* If a temporary file name is to be returned, use the file
* name parameter as a disk followed by a prefix for the name
* to create. The extra info parameter optionally contains a
* sequence number to pass.
*/
if (pmmio->dwFlags & MMIO_GETTEMP) {
V_RPOINTER((LPSTR)lParam1, 4, (LRESULT) MMSYSERR_INVALPARAM);
return (LRESULT)(LONG) (GetTempFileName(*(LPSTR)lParam1,
((LPSTR)lParam1) + 3, (UINT)pmmio->adwInfo[0],
(LPSTR)lParam1) ? 0 : MMIOERR_FILENOTFOUND);
}
/* <lParam1> is either a file name or NULL; if it is
* NULL, then <adwInfo[0]>, which is actually <pInfo->fh>,
* should already contain an open DOS file handle.
* note that the low word of <dwFlags> is equivalent to
* the <wStyle> parameter of OpenFile()
*/
if (lParam1 != 0)
pInfo->fh = OpenFile((LPSTR) lParam1, &of,
LOWORD(pmmio->dwFlags));
if (pInfo->fh == HFILE_ERROR)
return (LRESULT)(LONG) ((pmmio->dwFlags & MMIO_DELETE) ? MMIOERR_CANNOTWRITE : MMIOERR_FILENOTFOUND);
/* if file is being deleted, there's nothing more to do */
if (pmmio->dwFlags & MMIO_DELETE)
return (LRESULT) 0;
/* if file name is being parsed, translate to ansi */
if (pmmio->dwFlags & (MMIO_PARSE | MMIO_EXIST))
{
OemToAnsi(of.szPathName, (LPSTR) lParam1);
return (LRESULT) 0;
}
/* check the current file offset */
pmmio->lDiskOffset = _llseek(pInfo->fh, 0L, SEEK_CUR);
return (LRESULT) 0;
case MMIOM_CLOSE:
/* MMIO_FHOPEN flag means keep the DOS file handle open */
if (!((DWORD)lParam1 & MMIO_FHOPEN) && (_lclose(pInfo->fh) == HFILE_ERROR))
return (LRESULT) MMIOERR_CANNOTCLOSE;
else
return (LRESULT) 0;
case MMIOM_READ:
lResult = _hread(pInfo->fh, (LPVOID)lParam1, (LONG)lParam2);
if (lResult != -1L)
pmmio->lDiskOffset += lResult;
return (LRESULT) lResult;
case MMIOM_WRITE:
case MMIOM_WRITEFLUSH:
lResult = _hwrite(pInfo->fh, (LPVOID)lParam1, (LONG)lParam2);
if (lResult != -1L)
pmmio->lDiskOffset += lResult;
#ifdef DOSCANFLUSH
if (wMsg == MMIOM_WRITEFLUSH)
{
/* Issue hardware flush command */
}
#endif
return (LRESULT) lResult;
case MMIOM_SEEK:
lResult = _llseek(pInfo->fh, (LONG)lParam1, (int)(LONG)lParam2);
if (lResult != -1L)
pmmio->lDiskOffset = lResult;
return (LRESULT) lResult;
case MMIOM_RENAME:
if (lrename((LPCSTR)lParam1, (LPCSTR)lParam2))
return (LRESULT) MMIOERR_FILENOTFOUND;
break;
}
return (LRESULT) 0;
}
/* @doc INTERNAL
@api LRESULT | mmioMEMIOProc | The 'MEM' I/O procedure, which handles I/O
on memory files.
@parm LPSTR | lpmmioinfo | A pointer to an MMIOINFO block that
contains information about the open file.
@parm UINT | wMsg | The message that the I/O procedure is being
asked to execute.
@parm LPARAM | lParam1 | Specifies additional message information.
@parm LPARAM | lParam2 | Specifies additional message information.
@rdesc Return value depends on <p wMsg>.
*/
static LRESULT CALLBACK
mmioMEMIOProc(LPSTR lpmmioStr, UINT wMsg, LPARAM lParam1, LPARAM lParam2)
{
PMMIO pmmio = (PMMIO) (UINT) (LONG) lpmmioStr; // only in DLL!
switch (wMsg)
{
case MMIOM_OPEN:
if (pmmio->dwFlags & ~(MMIO_CREATE | MMIO_READWRITE | MMIO_WRITE | MMIO_EXCLUSIVE | MMIO_DENYWRITE | MMIO_DENYREAD | MMIO_DENYNONE | MMIO_ALLOCBUF))
return (LRESULT) MMSYSERR_INVALFLAG;
/* all the data in the buffer is valid */
if (!(pmmio->dwFlags & MMIO_CREATE))
pmmio->pchEndRead = pmmio->pchEndWrite;
return (LRESULT) 0;
case MMIOM_CLOSE:
/* nothing special to do on close */
return (LRESULT) 0;
case MMIOM_READ:
case MMIOM_WRITE:
case MMIOM_WRITEFLUSH:
case MMIOM_SEEK:
return (LRESULT) -1;
}
return (LRESULT) 0;
}
Reference in a new issue View git blame Copy permalink