mirrors
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/RAWFILE.CPP

1346 lines
54 KiB
C++
Raw Normal View History

Initial Source Code commit Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
2020-05-27 20:16:20 +01:00
//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/* $Header: /CounterStrike/RAWFILE.CPP 1 3/03/97 10:25a Joe_bostic $ */
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Westwood Library *
* *
* File Name : RAWFILE.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : August 8, 1994 *
* *
* Last Update : August 4, 1996 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* RawFileClass::Bias -- Bias a file with a specific starting position and length. *
* RawFileClass::Close -- Perform a closure of the file. *
* RawFileClass::Create -- Creates an empty file. *
* RawFileClass::Delete -- Deletes the file object from the disk. *
* RawFileClass::Error -- Handles displaying a file error message. *
* RawFileClass::Get_Date_Time -- Gets the date and time the file was last modified. *
* RawFileClass::Is_Available -- Checks to see if the specified file is available to open. *
* RawFileClass::Open -- Assigns name and opens file in one operation. *
* RawFileClass::Open -- Opens the file object with the rights specified. *
* RawFileClass::RawFileClass -- Simple constructor for a file object. *
* RawFileClass::Raw_Seek -- Performs a seek on the unbiased file *
* RawFileClass::Read -- Reads the specified number of bytes into a memory buffer. *
* RawFileClass::Seek -- Reposition the file pointer as indicated. *
* RawFileClass::Set_Date_Time -- Sets the date and time the file was last modified. *
* RawFileClass::Set_Name -- Manually sets the name for a file object. *
* RawFileClass::Size -- Determines size of file (in bytes). *
* RawFileClass::Write -- Writes the specified data to the buffer specified. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <direct.h>
#include <share.h>
#include <stddef.h>
#include "rawfile.h"
#ifndef WIN32
#include <fcntl.h>
#include <io.h>
#include <dos.h>
extern short Hard_Error_Occured;
#endif
/***********************************************************************************************
* RawFileClass::Error -- Handles displaying a file error message. *
* *
* Display an error message as indicated. If it is allowed to retry, then pressing a key *
* will return from this function. Otherwise, it will exit the program with "exit()". *
* *
* INPUT: error -- The error number (same as the DOSERR.H error numbers). *
* *
* canretry -- Can this routine exit normally so that retrying can occur? If this is *
* false, then the program WILL exit in this routine. *
* *
* filename -- Optional filename to report with this error. If no filename is *
* supplied, then no filename is listed in the error message. *
* *
* OUTPUT: none, but this routine might not return at all if the "canretry" parameter is *
* false or the player pressed ESC. *
* *
* WARNINGS: This routine may not return at all. It handles being in text mode as well as *
* if in a graphic mode. *
* *
* HISTORY: *
* 10/17/1994 JLB : Created. *
*=============================================================================================*/
void RawFileClass::Error(int , int , char const * )
{
}
/***********************************************************************************************
* RawFileClass::RawFileClass -- Simple constructor for a file object. *
* *
* This constructor is called when a file object is created with a supplied filename, but *
* not opened at the same time. In this case, an assumption is made that the supplied *
* filename is a constant string. A duplicate of the filename string is not created since *
* it would be wasteful in that case. *
* *
* INPUT: filename -- The filename to assign to this file object. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/17/1994 JLB : Created. *
*=============================================================================================*/
RawFileClass::RawFileClass(char const * filename) :
Rights(0),
BiasStart(0),
BiasLength(-1),
Handle(NULL_HANDLE),
Filename(filename),
Date(0),
Time(0),
Allocated(false)
{
}
/***********************************************************************************************
* RawFileClass::Set_Name -- Manually sets the name for a file object. *
* *
* This routine will set the name for the file object to the name specified. This name is *
* duplicated in free store. This allows the supplied name to be a temporarily constructed *
* text string. Setting the name in this fashion doesn't affect the closed or opened state *
* of the file. *
* *
* INPUT: filename -- The filename to assign to this file object. *
* *
* OUTPUT: Returns with a pointer to the allocated copy of this filename. This pointer is *
* guaranteed to remain valid for the duration of this file object or until the name *
* is changed -- whichever is sooner. *
* *
* WARNINGS: Because of the allocation this routine must perform, memory could become *
* fragmented. *
* *
* HISTORY: *
* 10/17/1994 JLB : Created. *
*=============================================================================================*/
char const * RawFileClass::Set_Name(char const * filename)
{
if (Filename != NULL && Allocated) {
free((char *)Filename);
((char *&)Filename) = 0;
Allocated = false;
}
if (filename == NULL) return(NULL);
Bias(0);
((char *&)Filename) = strdup(filename);
if (Filename == NULL) {
Error(ENOMEM, false, filename);
}
Allocated = true;
return(Filename);
}
/***********************************************************************************************
* RawFileClass::Open -- Assigns name and opens file in one operation. *
* *
* This routine will assign the specified filename to the file object and open it at the *
* same time. If the file object was already open, then it will be closed first. If the *
* file object was previously assigned a filename, then it will be replaced with the new *
* name. Typically, this routine is used when an anonymous file object has been crated and *
* now it needs to be assigned a name and opened. *
* *
* INPUT: filename -- The filename to assign to this file object. *
* *
* rights -- The open file access rights to use. *
* *
* OUTPUT: bool; Was the file opened? The return value of this is moot, since the open file *
* is designed to never return unless it succeeded. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/17/1994 JLB : Created. *
*=============================================================================================*/
int RawFileClass::Open(char const * filename, int rights)
{
Set_Name(filename);
return(Open(rights));
}
/***********************************************************************************************
* RawFileClass::Open -- Opens the file object with the rights specified. *
* *
* This routine is used to open the specified file object with the access rights indicated. *
* This only works if the file has already been assigned a filename. It is guaranteed, by *
* the error handler, that this routine will always return with success. *
* *
* INPUT: rights -- The file access rights to use when opening this file. This is a *
* combination of READ and/or WRITE bit flags. *
* *
* OUTPUT: bool; Was the file opened successfully? This will always return true by reason of *
* the error handler. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/17/1994 JLB : Created. *
*=============================================================================================*/
int RawFileClass::Open(int rights)
{
Close();
/*
** Verify that there is a filename associated with this file object. If not, then this is a
** big error condition.
*/
if (Filename == NULL) {
Error(ENOENT, false);
}
/*
** Record the access rights used for this open call. These rights will be used if the
** file object is duplicated.
*/
Rights = rights;
/*
** Repetitively try to open the file. Abort if a fatal error condition occurs.
*/
for (;;) {
/*
** Try to open the file according to the access rights specified.
*/
#ifndef WIN32
Hard_Error_Occured = 0;
#endif
switch (rights) {
/*
** If the access rights are not recognized, then report this as
** an invalid access code.
*/
default:
errno = EINVAL;
break;
case READ:
#ifdef WIN32
Handle = CreateFile(Filename, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
#else
_dos_open(Filename, O_RDONLY|SH_DENYNO, &Handle);
#endif
break;
case WRITE:
#ifdef WIN32
Handle = CreateFile(Filename, GENERIC_WRITE, 0,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
#else
_dos_creat(Filename, 0, &Handle);
#endif
break;
case READ|WRITE:
#ifdef WIN32
Handle = CreateFile(Filename, GENERIC_READ | GENERIC_WRITE, 0,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
#else
_dos_open(Filename, O_RDWR|O_CREAT|SH_DENYWR, &Handle);
#endif
break;
}
/*
** Biased files must be positioned past the bias start position.
*/
if (BiasStart != 0 || BiasLength != -1) {
Seek(0, SEEK_SET);
}
/*
** If the handle indicates the file is not open, then this is an error condition.
** For the case of the file cannot be found, then allow a retry. All other cases
** are fatal.
*/
if (Handle == NULL_HANDLE) {
#ifdef WIN32
// return(false);
Error(GetLastError(), false, Filename);
// continue;
#else
/*
** If this flag is set, then some hard error occurred. Just assume that the error
** is probably a removed CD-ROM and allow a retry.
*/
if (Hard_Error_Occured) {
Error(Hard_Error_Occured, true, Filename);
} else {
if (errno == ENOENT) {
Error(ENOENT, true, Filename);
} else {
Error(errno, false, Filename);
}
}
continue;
#endif
}
break;
}
return(true);
}
/***********************************************************************************************
* RawFileClass::Is_Available -- Checks to see if the specified file is available to open. *
* *
* This routine will examine the disk system to see if the specified file can be opened *
* or not. Use this routine before opening a file in order to make sure that is available *
* or to perform other necessary actions. *
* *
* INPUT: force -- Should this routine keep retrying until the file becomes available? If *
* in this case it doesn't become available, then the program will abort. *
* *
* OUTPUT: bool; Is the file available to be opened? *
* *
* WARNINGS: Depending on the parameter passed in, this routine may never return. *
* *
* HISTORY: *
* 10/18/1994 JLB : Created. *
*=============================================================================================*/
int RawFileClass::Is_Available(int forced)
{
#ifndef WIN32
bool open_failed;
#endif
if (Filename == NULL) return(false);
/*
** If the file is already open, then is must have already passed the availability check.
** Return true in this case.
*/
if (Is_Open()) return(true);
/*
** If this is a forced check, then go through the normal open channels, since those
** channels ensure that the file must exist.
*/
if (forced) {
RawFileClass::Open(READ);
RawFileClass::Close();
return(true);
}
/*
** Perform a raw open of the file. If this open fails for ANY REASON, including a missing
** CD-ROM, this routine will return a failure condition. In all but the missing file
** condition, go through the normal error recover channels.
*/
for (;;) {
#ifdef WIN32
Handle = CreateFile(Filename, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (Handle == NULL_HANDLE) {
return(false);
}
break;
#else
Hard_Error_Occured = 0;
open_failed = _dos_open(Filename, O_RDONLY|SH_DENYNO, &Handle);
/*
** If DOS reports that everything is just fine except that the file is not present,
** then return with this fact. Any other case will fall through to the error handler
** routine.
*/
if (open_failed && errno == ENOENT) return(false);
/*
** If we got an access error it could be because there is no cd in
** the drive. Call the error handler but allow a continue if it
** returns.
*/
if (open_failed && errno == EACCES) {
Error(errno, true, Filename);
continue;
}
/*
** If the file could not be found, then return with this information. If a more
** serious error occurred, then display the error message and abort.
*/
if (Hard_Error_Occured) {
Error(Hard_Error_Occured, true, Filename);
continue;
} else {
if (open_failed) {
/*
** An unhandled error condition is fatal. Display the error message and then
** abort.
*/
Error(errno, false, Filename);
}
}
if (!open_failed) break;
#endif
}
/*
** Since the file could be opened, then close it and return that the file exists.
*/
#ifdef WIN32
if (!CloseHandle(Handle)) {
Error(GetLastError(), false, Filename);
}
#else
if (_dos_close(Handle)) {
Error(errno, false, Filename);
}
#endif
Handle = NULL_HANDLE;
return(true);
}
/***********************************************************************************************
* RawFileClass::Close -- Perform a closure of the file. *
* *
* Close the file object. In the rare case of an error, handle it as appropriate. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: Some rare error conditions may cause this routine to abort the program. *
* *
* HISTORY: *
* 10/18/1994 JLB : Created. *
*=============================================================================================*/
void RawFileClass::Close(void)
{
/*
** If the file is open, then close it. If the file is already closed, then just return. This
** isn't considered an error condition.
*/
if (Is_Open()) {
#ifdef WIN32
/*
** Try to close the file. If there was an error (who knows what that could be), then
** call the error routine.
*/
if (!CloseHandle(Handle)) {
Error(GetLastError(), false, Filename);
}
#else
for (;;) {
/*
** Close the file. If there was an error in the close operation -- abort.
*/
Hard_Error_Occured = 0;
if (_dos_close(Handle)) {
/*
** By definition, this error can only be a bad file handle. This a fatal condition
** of course, so abort with an error message.
*/
Error(errno, false, Filename);
}
/*
** In the condition (if it is even possible) of a hard error occurring, then
** assume it is the case of missing media. Display an error message and try
** again if indicated.
*/
if (Hard_Error_Occured) {
Error(Hard_Error_Occured, true, Filename);
continue;
}
break;
}
#endif
/*
** At this point the file must have been closed. Mark the file as empty and return.
*/
Handle = NULL_HANDLE;
}
}
/***********************************************************************************************
* RawFileClass::Read -- Reads the specified number of bytes into a memory buffer. *
* *
* This routine will read the specified number of bytes and place the data into the buffer *
* indicated. It is legal to call this routine with a request for more bytes than are in *
* the file. This condition can result in fewer bytes being read than requested. Determine *
* this by examining the return value. *
* *
* INPUT: buffer -- Pointer to the buffer to read data into. If NULL is passed, no read *
* is performed. *
* *
* size -- The number of bytes to read. If NULL is passed, then no read is *
* performed. *
* *
* OUTPUT: Returns with the number of bytes read into the buffer. If this number is less *
* than requested, it indicates that the file has been exhausted. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/18/1994 JLB : Created. *
*=============================================================================================*/
long RawFileClass::Read(void * buffer, long size)
{
long bytesread = 0; // Running count of the number of bytes read into the buffer.
int opened = false; // Was the file opened by this routine?
/*
** If the file isn't opened, open it. This serves as a convenience
** for the programmer.
*/
if (!Is_Open()) {
/*
** The error check here is moot. Open will never return unless it succeeded.
*/
if (!Open(READ)) {
return(0);
}
opened = true;
}
/*
** A biased file has the requested read length limited to the bias length of
** the file.
*/
if (BiasLength != -1) {
int remainder = BiasLength - Seek(0);
size = size < remainder ? size : remainder;
}
#ifdef WIN32
long total = 0;
while (size > 0) {
bytesread = 0;
SetErrorMode(SEM_FAILCRITICALERRORS);
if (!ReadFile(Handle, buffer, size, &(unsigned long&)bytesread, NULL)) {
size -= bytesread;
total += bytesread;
Error(GetLastError(), true, Filename);
SetErrorMode(0);
continue;
}
SetErrorMode(0);
size -= bytesread;
total += bytesread;
if (bytesread == 0) break;
}
bytesread = total;
#else
int readresult;
/*
** Read the file in convenient chunk sizes. When the actual number
** of bytes read does not match the desired, then assume that the file
** is exhausted and bail. This loop was adjusted to take into
** consideration the fact that "read" returns a SIGNED value whereas
** it takes an UNSIGNED value as the byte count.
*/
while (size) {
unsigned desired; // Bytes desired to be read this pass.
unsigned actual; // Actual number of bytes read.
/*
** Break the read request into chunks no bigger than the low level DOS read
** can handle.
*/
desired = size < 32000L ? size : 32000L;
Hard_Error_Occured = 0;
readresult = _dos_read(Handle, buffer, desired, &actual);
/*
** If a hard error occurred, then assume that it is the case of the CD-ROM or
** floppy media having been removed. Display the error and retry as directed.
*/
if (Hard_Error_Occured) {
Error(Hard_Error_Occured, true, Filename);
continue; // Not technically needed, but to be consistent...
} else {
/*
** If negative one is returned from the read operation, then this indicates
** either a bad file number or invalid access. These are fatal conditions, so
** display the error and then abort.
*/
if (readresult != 0) {
Error(errno, false, Filename);
} else {
/*
** No error occurred during the read. Adjust the pointers and size counters and
** loop again if more data is needed to be read.
*/
buffer = (char *)buffer + actual;
bytesread += actual;
size -= actual;
if (actual != desired) break; // No more data?
}
}
}
#endif //WIN32
/*
** Close the file if it was opened by this routine and return
** the actual number of bytes read into the buffer.
*/
if (opened) Close();
return(bytesread);
}
/***********************************************************************************************
* RawFileClass::Write -- Writes the specified data to the buffer specified. *
* *
* This routine will write the data specified to the file. *
* *
* INPUT: buffer -- The buffer that holds the data to write. *
* *
* size -- The number of bytes to write to the file. *
* *
* OUTPUT: Returns with the number of bytes written to the file. This routine catches the *
* case of a disk full condition, so this routine will always return with the number *
* matching the size request. *
* *
* WARNINGS: A fatal file condition could cause this routine to never return. *
* *
* HISTORY: *
* 10/18/1994 JLB : Created. *
*=============================================================================================*/
long RawFileClass::Write(void const * buffer, long size)
{
long bytesread = 0;
int opened = false; // Was the file manually opened?
/*
** Check to open status of the file. If the file is open, then merely write to
** it. Otherwise, open the file for writing and then close the file when the
** output is finished.
*/
if (!Is_Open()) {
if (!Open(WRITE)) {
return(0);
}
opened = true;
}
#ifdef WIN32
if (!WriteFile(Handle, buffer, size, &(unsigned long&)bytesread, NULL)) {
Error(GetLastError(), false, Filename);
}
#else
int writeresult;
/*
** Write the data to the file in chunks no bigger than what the low level DOS write
** can handle.
*/
while (size) {
unsigned desired; // Bytes desired to be write this pass.
unsigned actual; // Actual number of bytes written.
Hard_Error_Occured = 0;
// desired = (unsigned)MIN(size, Transfer_Block_Size());
desired = size;
writeresult = _dos_write(Handle, buffer, desired, &actual);
/*
** If a hard error occurred, then assume it is the case of the media being
** removed. Print the error message an retry as directed.
*/
if (Hard_Error_Occured) {
Error(Hard_Error_Occured, true, Filename);
continue; // Not technically needed, but to be consistent...
} else {
/*
** If negative one is returned by the DOS read, then this indicates a bad file
** handle or invalid access. Either condition is fatal -- display error condition
** and abort.
*/
if (writeresult != 0) {
Error(errno, false, Filename);
} else {
/*
** A successful write occurred. Update pointers and byte counter as appropriate.
*/
buffer = (char *)buffer + actual;
bytesread += actual;
size -= actual;
/*
** If the actual bytes written is less than requested, assume this is a case of
** the disk being full. Consider this a fatal error condition.
*/
if (actual != desired) {
Error(ENOSPC, false, Filename);
}
}
}
}
#endif //WIN32
/*
** Fixup the bias length if necessary.
*/
if (BiasLength != -1) {
if (Raw_Seek(0) > BiasStart+BiasLength) {
BiasLength = Raw_Seek(0) - BiasStart;
}
}
/*
** If this routine had to open the file, then close it before returning.
*/
if (opened) {
Close();
}
/*
** Return with the number of bytes written. This will always be the number of bytes
** requested, since the case of the disk being full is caught by this routine.
*/
return(bytesread);
}
/***********************************************************************************************
* RawFileClass::Seek -- Reposition the file pointer as indicated. *
* *
* Use this routine to move the filepointer to the position indicated. It can move either *
* relative to current position or absolute from the beginning or ending of the file. This *
* routine will only return if it successfully performed the seek. *
* *
* INPUT: pos -- The position to seek to. This is interpreted as relative to the position *
* indicated by the "dir" parameter. *
* *
* dir -- The relative position to relate the seek to. This can be either SEEK_SET *
* for the beginning of the file, SEEK_CUR for the current position, or *
* SEEK_END for the end of the file. *
* *
* OUTPUT: This routine returns the position that the seek ended up at. *
* *
* WARNINGS: If there was a file error, then this routine might never return. *
* *
* HISTORY: *
* 10/18/1994 JLB : Created. *
*=============================================================================================*/
long RawFileClass::Seek(long pos, int dir)
{
/*
** A file that is biased will have a seek operation modified so that the file appears to
** exist only within the bias range. All bytes outside of this range appear to be
** non-existant.
*/
if (BiasLength != -1) {
switch (dir) {
case SEEK_SET:
if (pos > BiasLength) {
pos = BiasLength;
}
pos += BiasStart;
break;
case SEEK_CUR:
break;
case SEEK_END:
dir = SEEK_SET;
pos += BiasStart + BiasLength;
// pos = (pos <= BiasStart+BiasLength) ? pos : BiasStart+BiasLength;
// pos = (pos >= BiasStart) ? pos : BiasStart;
break;
}
/*
** Perform the modified raw seek into the file.
*/
long newpos = Raw_Seek(pos, dir) - BiasStart;
/*
** Perform a final double check to make sure the file position fits with the bias range.
*/
if (newpos < 0) {
newpos = Raw_Seek(BiasStart, SEEK_SET) - BiasStart;
}
if (newpos > BiasLength) {
newpos = Raw_Seek(BiasStart+BiasLength, SEEK_SET) - BiasStart;
}
return(newpos);
}
/*
** If the file is not biased in any fashion, then the normal seek logic will
** work just fine.
*/
return(Raw_Seek(pos, dir));
}
/***********************************************************************************************
* RawFileClass::Size -- Determines size of file (in bytes). *
* *
* Use this routine to determine the size of the file. The file must exist or this is an *
* error condition. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the number of bytes in the file. *
* *
* WARNINGS: This routine handles error conditions and will not return unless the file *
* exists and can successfully be queried for file length. *
* *
* HISTORY: *
* 10/18/1994 JLB : Created. *
*=============================================================================================*/
long RawFileClass::Size(void)
{
long size = 0;
/*
** A biased file already has its length determined.
*/
if (BiasLength != -1) {
return(BiasLength);
}
/*
** If the file is open, then proceed normally.
*/
if (Is_Open()) {
#ifdef WIN32
size = GetFileSize(Handle, NULL);
/*
** If there was in internal error, then call the error function.
*/
if (size == 0xFFFFFFFF) {
Error(GetLastError(), false, Filename);
}
#else
/*
** Repetitively try to determine the file size until a fatal error condition or success
** is achieved.
*/
for (;;) {
Hard_Error_Occured = 0;
size = filelength(Handle);
/*
** If a hard error occurred, then assume it is the case of removed media. Display an
** error condition and allow retry.
*/
if (Hard_Error_Occured) {
Error(Hard_Error_Occured, true, Filename);
continue;
} else {
if (size == -1) {
Error(errno, false, Filename);
}
}
break;
}
#endif
} else {
/*
** If the file wasn't open, then open the file and call this routine again. Count on
** the fact that the open function must succeed.
*/
if (Open()) {
size = Size();
/*
** Since we needed to open the file we must remember to close the file when the
** size has been determined.
*/
Close();
}
}
BiasLength = size-BiasStart;
return(BiasLength);
}
/***********************************************************************************************
* RawFileClass::Create -- Creates an empty file. *
* *
* This routine will create an empty file from the file object. The file object's filename *
* must already have been assigned before this routine will function. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Was the file successfully created? This routine will always return true. *
* *
* WARNINGS: A fatal error condition could occur with this routine. Especially if the disk *
* is full or a read-only media was selected. *
* *
* HISTORY: *
* 10/18/1994 JLB : Created. *
*=============================================================================================*/
int RawFileClass::Create(void)
{
Close();
if (Open(WRITE)) {
/*
** A biased file must be at least as long as the bias offset. Seeking to the
** appropriate start offset has the effect of lengthening the file to the
** correct length.
*/
if (BiasLength != -1) {
Seek(0, SEEK_SET);
}
Close();
return(true);
}
return(false);
}
/***********************************************************************************************
* RawFileClass::Delete -- Deletes the file object from the disk. *
* *
* This routine will delete the file object from the disk. If the file object doesn't *
* exist, then this routine will return as if it had succeeded (since the effect is the *
* same). *
* *
* INPUT: none *
* *
* OUTPUT: bool; Was the file deleted? If the file was already missing, the this value will *
* be false. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/18/1994 JLB : Created. *
*=============================================================================================*/
int RawFileClass::Delete(void)
{
/*
** If the file was open, then it must be closed first.
*/
Close();
/*
** If there is no filename associated with this object, then this indicates a fatal error
** condition. Report this and abort.
*/
if (!Filename) {
Error(ENOENT, false);
}
/*
** Repetitively try to delete the file if possible. Either return with success, or
** abort the program with an error.
*/
for (;;) {
/*
** If the file is already missing, then return with this fact. No action is necessary.
** This can occur as this section loops if the file exists on a floppy and the floppy
** was removed, the file deleted on another machine, and then the floppy was
** reinserted. Admittedly, this is a rare case, but is handled here.
*/
if (!Is_Available()) {
return(false);
}
#ifdef WIN32
if (!DeleteFile(Filename)) {
Error(GetLastError(), false, Filename);
return(false);
}
#else
Hard_Error_Occured = 0;
if (remove(Filename) == -1) {
/*
** If a hard error occurred, then assume that the media has been removed. Display
** error message and retry as directed.
*/
if (Hard_Error_Occured) {
Error(Hard_Error_Occured, true, Filename);
continue;
}
/*
** If at this point, DOS says the file doesn't exist, then just exit with this
** fact. It should have been caught earlier, but in any case, this is a legal
** condition.
*/
if (errno == ENOENT) break;
/*
** The only way it can reach this point is if DOS indicates that access is denied
** on the file. This occurs when trying to delete a file on a read-only media such
** as a CD-ROM. Report this as a fatal error and then abort.
*/
Error(errno, false, Filename);
}
#endif
break;
}
/*
** DOS reports that the file was successfully deleted. Return with this fact.
*/
return(true);
}
/***********************************************************************************************
* RawFileClass::Get_Date_Time -- Gets the date and time the file was last modified. *
* *
* Use this routine to get the date and time of the file. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the file date and time as a long. *
* Use the YEAR(long), MONTH(),.... *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/14/1995 DRD : Created. *
* 07/13/1996 JLB : Handles win32 method. *
*=============================================================================================*/
unsigned long RawFileClass::Get_Date_Time(void)
{
#ifdef WIN32
BY_HANDLE_FILE_INFORMATION info;
if (GetFileInformationByHandle(Handle, &info)) {
WORD dosdate;
WORD dostime;
FileTimeToDosDateTime(&info.ftLastWriteTime, &dosdate, &dostime);
return((dosdate << 16) | dostime);
}
return(0);
#else
unsigned short time;
unsigned short date;
unsigned long datetime = 0;
//
// If the file is open, then proceed normally.
//
if ( RawFileClass::Is_Open() ) {
if ( _dos_getftime( Handle, &date, &time ) ) {
//
// return 0 indicating error with no date and time
//
return( datetime );
}
} else {
//
// If the file wasn't open, then see if the file exists.
//
if ( RawFileClass::Is_Available() ) {
RawFileClass::Open();
if ( _dos_getftime( Handle, &date, &time ) ) {
RawFileClass::Close();
//
// return 0 indicating error with no date and time
//
return( datetime );
}
RawFileClass::Close();
} else {
//
// return 0 indicating error with no date and time
//
return( datetime );
}
}
//
// combine the date and time as a long
//
datetime = (date << 16) + time;
return( datetime );
#endif
}
/***********************************************************************************************
* RawFileClass::Set_Date_Time -- Sets the date and time the file was last modified. *
* *
* Use this routine to set the date and time of the file. *
* *
* INPUT: the file date and time as a long *
* *
* OUTPUT: successful or not if the file date and time was changed. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/14/1995 DRD : Created. *
* 07/13/1996 JLB : Handles win 32 method *
*=============================================================================================*/
bool RawFileClass::Set_Date_Time(unsigned long datetime)
{
#ifdef WIN32
if (RawFileClass::Is_Open()) {
BY_HANDLE_FILE_INFORMATION info;
if (GetFileInformationByHandle(Handle, &info)) {
FILETIME filetime;
if (DosDateTimeToFileTime((WORD)(datetime >> 16), (WORD)(datetime & 0x0FFFF), &filetime)) {
return(SetFileTime(Handle, &info.ftCreationTime, &filetime, &filetime));
}
}
}
return(false);
#else
unsigned short time;
unsigned short date;
//
// If the file is open, then proceed normally.
//
if ( RawFileClass::Is_Open() ) {
//
// only set the date and time if open for READ only
//
if ( Rights == READ ) {
time = (unsigned short)(datetime & 0xFFFF);
date = (unsigned short)((datetime >> 16) & 0xFFFF);
if ( !_dos_setftime( Handle, date, time ) ) {
//
// return true indicating success
//
return( true );
}
}
} else {
//
// If the file wasn't open, then see if the file exists.
//
if ( RawFileClass::Is_Available() ) {
RawFileClass::Open();
time = (unsigned short)(datetime & 0xFFFF);
date = (unsigned short)((datetime >> 16) & 0xFFFF);
if ( !_dos_setftime( Handle, date, time ) ) {
RawFileClass::Close();
//
// return true indicating success
//
return( true );
}
RawFileClass::Close();
}
}
//
// return false indicating error
//
return( false );
#endif
}
/***********************************************************************************************
* RawFileClass::Bias -- Bias a file with a specific starting position and length. *
* *
* This will bias a file by giving it an artificial starting position and length. By *
* using this routine, it is possible to 'fool' the file into ignoring a header and *
* trailing extra data. An example of this would be a file inside of a mixfile. *
* *
* INPUT: start -- The starting offset that will now be considered the start of the *
* file. *
* *
* length -- The forced length of the file. For files that are opened for write, *
* this serves as the artificial constraint on the file's length. For *
* files opened for read, this limits the usable file size. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/02/1996 JLB : Created. *
*=============================================================================================*/
void RawFileClass::Bias(int start, int length)
{
if (start == 0) {
BiasStart = 0;
BiasLength = -1;
return;
}
BiasLength = RawFileClass::Size();
BiasStart += start;
if (length != -1) {
BiasLength = BiasLength < length ? BiasLength : length;
}
BiasLength = BiasLength > 0 ? BiasLength : 0;
/*
** Move the current file offset to a legal position if necessary and the
** file was open.
*/
if (Is_Open()) {
RawFileClass::Seek(0, SEEK_SET);
}
}
/***********************************************************************************************
* RawFileClass::Raw_Seek -- Performs a seek on the unbiased file *
* *
* This will perform a seek on the file as if it were unbiased. This is in spite of any *
* bias setting the file may have. The ability to perform a raw seek in this fasion is *
* necessary to maintain the bias ability. *
* *
* INPUT: pos -- The position to seek the file relative to the "dir" parameter. *
* *
* dir -- The origin of the seek operation. *
* *
* OUTPUT: Returns with the new position of the seek operation. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/04/1996 JLB : Created. *
*=============================================================================================*/
long RawFileClass::Raw_Seek(long pos, int dir)
{
/*
** If the file isn't opened, then this is a fatal error condition.
*/
if (!Is_Open()) {
Error(EBADF, false, Filename);
}
#ifdef WIN32
switch (dir) {
case SEEK_SET:
dir = FILE_BEGIN;
break;
case SEEK_CUR:
dir = FILE_CURRENT;
break;
case SEEK_END:
dir = FILE_END;
break;
}
pos = SetFilePointer(Handle, pos, NULL, dir);
/*
** If there was an error in the seek, then bail with an error condition.
*/
if (pos == 0xFFFFFFFF) {
Error(GetLastError(), false, Filename);
}
#else
/*
** Keep trying to seek until a non-retry condition occurs.
*/
for (;;) {
/*
** Perform the low level seek on the file.
*/
Hard_Error_Occured = 0;
pos = lseek(Handle, pos, dir);
/*
** If a hard error occurred, then assume that it is the case of removed media. Display
** error message and retry.
*/
if (Hard_Error_Occured) {
Error(Hard_Error_Occured, true, Filename);
continue;
} else {
/*
** A negative one indicates a fatal error with the seek operation. Display error
** condition and then abort.
*/
if (pos == -1) {
Error(errno, false, Filename);
}
}
break;
}
#endif
/*
** Return with the new position of the file. This will range between zero and the number of
** bytes the file contains.
*/
return(pos);
}