mirror of
https://github.com/tribes2/engine.git
synced 2026-01-19 19:24:45 +00:00
786 lines
25 KiB
C++
786 lines
25 KiB
C++
//-----------------------------------------------------------------------------
|
|
// V12 Engine
|
|
//
|
|
// Copyright (c) 2001 GarageGames.Com
|
|
// Portions Copyright (c) 2001 by Sierra Online, Inc.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "platformX86UNIX/platformX86UNIX.h"
|
|
#include "core/fileio.h"
|
|
#include "core/tVector.h"
|
|
#include "core/stringTable.h"
|
|
#include "console/console.h"
|
|
|
|
#include <utime.h>
|
|
|
|
/* include sys/param.h for MAXPATHLEN */
|
|
#include <sys/param.h>
|
|
#ifndef MAX_PATH
|
|
#define MAX_PATH MAXPATHLEN
|
|
#endif
|
|
|
|
/* these are for reading directors, getting stats, etc. */
|
|
#include <dirent.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
|
|
extern int x86UNIXOpen(const char *path, int oflag);
|
|
extern int x86UNIXClose(int fd);
|
|
extern ssize_t x86UNIXRead(int fd, void *buf, size_t nbytes);
|
|
extern ssize_t x86UNIXWrite(int fd, const void *buf, size_t nbytes);
|
|
|
|
//-------------------------------------- Helper Functions
|
|
static void forwardslash(char *str)
|
|
{
|
|
while(*str)
|
|
{
|
|
if(*str == '\\')
|
|
*str = '/';
|
|
str++;
|
|
}
|
|
}
|
|
|
|
static void backslash(char *str)
|
|
{
|
|
while(*str)
|
|
{
|
|
if(*str == '/')
|
|
*str = '\\';
|
|
str++;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool dFileDelete(const char * name)
|
|
{
|
|
if(!name || (dStrlen(name) >= MAX_PATH))
|
|
return(false);
|
|
if (remove(name) == -1)
|
|
return(false);
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool dFileTouch(const char * name)
|
|
{
|
|
// change the modified time to the current time (0byte WriteFile fails!)
|
|
return(utime(name, 0) != -1);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructors & Destructor
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// After construction, the currentStatus will be Closed and the capabilities
|
|
// will be 0.
|
|
//-----------------------------------------------------------------------------
|
|
File::File()
|
|
: currentStatus(Closed), capability(0)
|
|
{
|
|
// AssertFatal(sizeof(int) == sizeof(void *), "File::File: cannot cast void* to int");
|
|
|
|
handle = (void *)NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// insert a copy constructor here... (currently disabled)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Destructor
|
|
//-----------------------------------------------------------------------------
|
|
File::~File()
|
|
{
|
|
close();
|
|
handle = (void *)NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Open a file in the mode specified by openMode (Read, Write, or ReadWrite).
|
|
// Truncate the file if the mode is either Write or ReadWrite and truncate is
|
|
// true.
|
|
//
|
|
// Sets capability appropriate to the openMode.
|
|
// Returns the currentStatus of the file.
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::open(const char *filename, const AccessMode openMode)
|
|
{
|
|
static char filebuf[2048];
|
|
dStrcpy(filebuf, filename);
|
|
filename = filebuf;
|
|
|
|
AssertFatal(NULL != filename, "File::open: NULL filename");
|
|
AssertWarn(NULL == handle, "File::open: handle already valid");
|
|
|
|
// Close the file if it was already open...
|
|
if (Closed != currentStatus)
|
|
close();
|
|
|
|
int fd;
|
|
handle = (void *)dRealMalloc(sizeof(int));
|
|
// create the appropriate type of file...
|
|
switch (openMode)
|
|
{
|
|
case Read:
|
|
fd = x86UNIXOpen(filename, O_RDONLY);
|
|
dMemcpy(handle, &fd, sizeof(int));
|
|
// handle = (void *)&x86UNIXOpen(filename, O_RDONLY);
|
|
break;
|
|
case Write:
|
|
fd = x86UNIXOpen(filename, O_WRONLY | O_CREAT);
|
|
dMemcpy(handle, &fd, sizeof(int));
|
|
// handle = (void *)x86UNIXOpen(filename, O_WRONLY | O_CREAT);
|
|
break;
|
|
case ReadWrite:
|
|
fd = x86UNIXOpen(filename, O_RDWR);
|
|
dMemcpy(handle, &fd, sizeof(int));
|
|
// handle = (void *)x86UNIXOpen(filename, O_RDWR);
|
|
break;
|
|
case WriteAppend:
|
|
fd = x86UNIXOpen(filename, O_APPEND);
|
|
dMemcpy(handle, &fd, sizeof(int));
|
|
// handle = (void *)x86UNIXOpen(filename, O_APPEND);
|
|
break;
|
|
default:
|
|
AssertFatal(false, "File::open: bad access mode"); // impossible
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// fprintf(stdout,"fd = %d, handle = %d\n", fd, *((int *)handle));
|
|
#endif
|
|
|
|
if (*((int *)handle) == -1) // handle not created successfully
|
|
return setStatus();
|
|
else
|
|
{
|
|
// successfully created file, so set the file capabilities...
|
|
switch (openMode)
|
|
{
|
|
case Read:
|
|
capability = U32(FileRead);
|
|
break;
|
|
case Write:
|
|
case WriteAppend:
|
|
capability = U32(FileWrite);
|
|
break;
|
|
case ReadWrite:
|
|
capability = U32(FileRead) |
|
|
U32(FileWrite);
|
|
break;
|
|
default:
|
|
AssertFatal(false, "File::open: bad access mode");
|
|
}
|
|
return currentStatus = Ok; // success!
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Get the current position of the file pointer.
|
|
//-----------------------------------------------------------------------------
|
|
U32 File::getPosition() const
|
|
{
|
|
AssertFatal(Closed != currentStatus, "File::getPosition: file closed");
|
|
AssertFatal(NULL != handle, "File::getPosition: invalid file handle");
|
|
|
|
#ifdef DEBUG
|
|
// fprintf(stdout, "handle = %d\n",*((int *)handle));fflush(stdout);
|
|
#endif
|
|
return (U32) lseek(*((int *)handle), 0, SEEK_CUR);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Set the position of the file pointer.
|
|
// Absolute and relative positioning is supported via the absolutePos
|
|
// parameter.
|
|
//
|
|
// If positioning absolutely, position MUST be positive - an IOError results if
|
|
// position is negative.
|
|
// Position can be negative if positioning relatively, however positioning
|
|
// before the start of the file is an IOError.
|
|
//
|
|
// Returns the currentStatus of the file.
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::setPosition(S32 position, bool absolutePos)
|
|
{
|
|
AssertFatal(Closed != currentStatus, "File::setPosition: file closed");
|
|
AssertFatal(NULL != handle, "File::setPosition: invalid file handle");
|
|
|
|
if (Ok != currentStatus && EOS != currentStatus)
|
|
return currentStatus;
|
|
|
|
U32 finalPos;
|
|
switch (absolutePos)
|
|
{
|
|
case true: // absolute position
|
|
AssertFatal(0 <= position, "File::setPosition: negative absolute position");
|
|
|
|
// position beyond EOS is OK
|
|
finalPos = lseek(*((int *)handle), position, SEEK_SET);
|
|
break;
|
|
case false: // relative position
|
|
AssertFatal((getPosition() >= (U32)abs(position) && 0 > position) || 0 <= position, "File::setPosition: negative relative position");
|
|
|
|
// position beyond EOS is OK
|
|
finalPos = lseek(*((int *)handle), position, SEEK_CUR);
|
|
break;
|
|
}
|
|
|
|
if (0xffffffff == finalPos)
|
|
return setStatus(); // unsuccessful
|
|
else if (finalPos >= getSize())
|
|
return currentStatus = EOS; // success, at end of file
|
|
else
|
|
return currentStatus = Ok; // success!
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Get the size of the file in bytes.
|
|
// It is an error to query the file size for a Closed file, or for one with an
|
|
// error status.
|
|
//-----------------------------------------------------------------------------
|
|
U32 File::getSize() const
|
|
{
|
|
AssertWarn(Closed != currentStatus, "File::getSize: file closed");
|
|
AssertFatal(NULL != handle, "File::getSize: invalid file handle");
|
|
|
|
if (Ok == currentStatus || EOS == currentStatus)
|
|
{
|
|
long currentOffset = getPosition(); // keep track of our current position
|
|
long fileSize;
|
|
lseek(*((int *)handle), 0, SEEK_END); // seek to the end of the file
|
|
fileSize = getPosition(); // get the file size
|
|
lseek(*((int *)handle), currentOffset, SEEK_SET); // seek back to our old offset
|
|
return fileSize; // success!
|
|
}
|
|
else
|
|
return 0; // unsuccessful
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Flush the file.
|
|
// It is an error to flush a read-only file.
|
|
// Returns the currentStatus of the file.
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::flush()
|
|
{
|
|
AssertFatal(Closed != currentStatus, "File::flush: file closed");
|
|
AssertFatal(NULL != handle, "File::flush: invalid file handle");
|
|
AssertFatal(true == hasCapability(FileWrite), "File::flush: cannot flush a read-only file");
|
|
|
|
if (fdatasync(*((int *)handle)) == 0)
|
|
return currentStatus = Ok; // success!
|
|
else
|
|
return setStatus(); // unsuccessful
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Close the File.
|
|
//
|
|
// Returns the currentStatus
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::close()
|
|
{
|
|
// check if it's already closed...
|
|
if (Closed == currentStatus)
|
|
return currentStatus;
|
|
|
|
// it's not, so close it...
|
|
if (NULL != handle)
|
|
{
|
|
if (x86UNIXClose(*((int *)handle)) != 0)
|
|
return setStatus(); // unsuccessful
|
|
}
|
|
handle = (void *)NULL;
|
|
return currentStatus = Closed;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Self-explanatory.
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::getStatus() const
|
|
{
|
|
return currentStatus;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets and returns the currentStatus when an error has been encountered.
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::setStatus()
|
|
{
|
|
switch (errno)
|
|
{
|
|
case EINVAL:
|
|
case EBADFD:
|
|
case EIO:
|
|
return currentStatus = IOError;
|
|
default:
|
|
return currentStatus = Ok;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets and returns the currentStatus to status.
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::setStatus(File::Status status)
|
|
{
|
|
return currentStatus = status;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Read from a file.
|
|
// The number of bytes to read is passed in size, the data is returned in src.
|
|
// The number of bytes read is available in bytesRead if a non-Null pointer is
|
|
// provided.
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::read(U32 size, char *dst, U32 *bytesRead)
|
|
{
|
|
#ifdef DEBUG
|
|
// fprintf(stdout,"reading %d bytes\n",size);fflush(stdout);
|
|
#endif
|
|
AssertFatal(Closed != currentStatus, "File::read: file closed");
|
|
AssertFatal(NULL != handle, "File::read: invalid file handle");
|
|
AssertFatal(NULL != dst, "File::read: NULL destination pointer");
|
|
AssertFatal(true == hasCapability(FileRead), "File::read: file lacks capability");
|
|
AssertWarn(0 != size, "File::read: size of zero");
|
|
|
|
/* show stats for this file */
|
|
#ifdef DEBUG
|
|
//struct stat st;
|
|
//fstat(*((int *)handle), &st);
|
|
//fprintf(stdout,"file size = %d\n", st.st_size);
|
|
#endif
|
|
/****************************/
|
|
|
|
if (Ok != currentStatus || 0 == size)
|
|
return currentStatus;
|
|
else
|
|
{
|
|
long lastBytes;
|
|
long *bytes = (NULL == bytesRead) ? &lastBytes : (long *)bytesRead;
|
|
//if ((FILE *)handle == NULL || dst == NULL) {
|
|
//fprintf(stdout, "ack!\n");
|
|
//}
|
|
//fprintf(stdout, "%d-%p\n",strlen(dst),dst);
|
|
//fprintf(stdout, "feof() = %d\n",feof((FILE *)handle));
|
|
//fprintf(stdout, "sizeof(U32) = %d\nsize = %d\n",sizeof(U32), size);
|
|
//fprintf(stdout, "bytesRead = %d\n", *((U32 *)bytes) = x86UNIXRead(fileno((FILE *)handle), dst, size) );
|
|
|
|
// (*((U32 *)bytes)) = fread(dst, sizeof(U32), size, (FILE *)handle);
|
|
//fprintf(stdout, "bytes = %d\n", (*(int *)bytes));fflush(NULL);
|
|
//exit(*((int *)bytes));
|
|
// if (0 != (*((size_t *)bytes) = fread(dst, sizeof(U32), size, (FILE *)handle)) )
|
|
if ( (*((U32 *)bytes) = x86UNIXRead(*((int *)handle), dst, size)) == -1)
|
|
{
|
|
#ifdef DEBUG
|
|
// fprintf(stdout,"unsuccessful: %d\n", *((U32 *)bytes));fflush(stdout);
|
|
#endif
|
|
return setStatus(); // unsuccessful
|
|
} else {
|
|
// dst[*((U32 *)bytes)] = '\0';
|
|
if (*((U32 *)bytes) != size || *((U32 *)bytes) == 0) {
|
|
#ifdef DEBUG
|
|
// fprintf(stdout,"end of stream: %d\n", *((U32 *)bytes));fflush(stdout);
|
|
#endif
|
|
return currentStatus = EOS; // end of stream
|
|
}
|
|
}
|
|
}
|
|
// dst[*bytesRead] = '\0';
|
|
#ifdef DEBUG
|
|
//fprintf(stdout, "We read:\n");
|
|
//fprintf(stdout, "====================================================\n");
|
|
//fprintf(stdout, "%s\n",dst);
|
|
//fprintf(stdout, "====================================================\n");
|
|
//fprintf(stdout,"read ok: %d\n", *bytesRead);fflush(stdout);
|
|
#endif
|
|
return currentStatus = Ok; // successfully read size bytes
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Write to a file.
|
|
// The number of bytes to write is passed in size, the data is passed in src.
|
|
// The number of bytes written is available in bytesWritten if a non-Null
|
|
// pointer is provided.
|
|
//-----------------------------------------------------------------------------
|
|
File::Status File::write(U32 size, const char *src, U32 *bytesWritten)
|
|
{
|
|
AssertFatal(Closed != currentStatus, "File::write: file closed");
|
|
AssertFatal(NULL != handle, "File::write: invalid file handle");
|
|
AssertFatal(NULL != src, "File::write: NULL source pointer");
|
|
AssertFatal(true == hasCapability(FileWrite), "File::write: file lacks capability");
|
|
AssertWarn(0 != size, "File::write: size of zero");
|
|
|
|
if ((Ok != currentStatus && EOS != currentStatus) || 0 == size)
|
|
return currentStatus;
|
|
else
|
|
{
|
|
long lastBytes;
|
|
long *bytes = (NULL == bytesWritten) ? &lastBytes : (long *)bytesWritten;
|
|
if (0 != (*((U32 *)bytes) = x86UNIXWrite(*((int *)handle), src, size)))
|
|
return currentStatus = Ok; // success!
|
|
else
|
|
return setStatus(); // unsuccessful
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Self-explanatory.
|
|
//-----------------------------------------------------------------------------
|
|
bool File::hasCapability(Capability cap) const
|
|
{
|
|
return (0 != (U32(cap) & capability));
|
|
}
|
|
|
|
S32 Platform::compareFileTimes(const FileTime &a, const FileTime &b)
|
|
{
|
|
if(a > b)
|
|
return 1;
|
|
if(a < b)
|
|
return -1;
|
|
if(a > b)
|
|
return 1;
|
|
if(a < b)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static bool recurseDumpPath(const char *path, const char *pattern, Vector<Platform::FileInfo> &fileVector)
|
|
{
|
|
char search[1024];
|
|
|
|
dSprintf(search, sizeof(search), "%s", path, pattern);
|
|
|
|
DIR *directory = opendir(search);
|
|
|
|
if (directory == NULL)
|
|
return false;
|
|
|
|
struct dirent *fEntry;
|
|
fEntry = readdir(directory); // read the first "file" in the directory
|
|
|
|
if (fEntry == NULL)
|
|
return false;
|
|
|
|
do
|
|
{
|
|
char filename[BUFSIZ+1];
|
|
struct stat fStat;
|
|
|
|
dSprintf(filename, sizeof(filename), "%s/%s", search, fEntry->d_name); // "construct" the file name
|
|
stat(filename, &fStat); // get the file stats
|
|
|
|
if ( (fStat.st_mode & S_IFMT) == S_IFDIR )
|
|
{
|
|
// Directory
|
|
// skip . and .. directories
|
|
if (dStrcmp(fEntry->d_name, ".") == 0 || dStrcmp(fEntry->d_name, "..") == 0)
|
|
continue;
|
|
|
|
char child[1024];
|
|
dSprintf(child, sizeof(child), "%s/%s", path, fEntry->d_name);
|
|
recurseDumpPath(child, pattern, fileVector);
|
|
}
|
|
else
|
|
{
|
|
// File
|
|
|
|
// add it to the list
|
|
fileVector.increment();
|
|
Platform::FileInfo& rInfo = fileVector.last();
|
|
|
|
rInfo.pFullPath = StringTable->insert(path);
|
|
rInfo.pFileName = StringTable->insert(fEntry->d_name);
|
|
rInfo.fileSize = fStat.st_size;
|
|
}
|
|
|
|
} while( (fEntry = readdir(directory)) != NULL );
|
|
|
|
closedir(directory);
|
|
return true;
|
|
}
|
|
|
|
//static bool _recurseDumpPath(const char* in_pBasePath,
|
|
// const char* in_pCurPath,
|
|
// Vector<Platform::FileInfo>& out_rFileVector)
|
|
//{
|
|
// char buf[1024];
|
|
// char curPath[1024];
|
|
// char basePath[1024];
|
|
// char scratchBuf[1024];
|
|
//
|
|
// if(in_pCurPath)
|
|
// dStrcpy(curPath, in_pCurPath);
|
|
// else
|
|
// curPath[0] = 0;
|
|
//
|
|
// dStrcpy(basePath, in_pBasePath);
|
|
// in_pBasePath = basePath;
|
|
//
|
|
//
|
|
// if (curPath[0] != '\0')
|
|
// dSprintf(buf, sizeof(buf), "%s/%s", basePath, curPath);
|
|
// else
|
|
// dSprintf(buf, sizeof(buf), "%s", basePath);
|
|
//
|
|
//
|
|
// backslash(buf);
|
|
// DIR *directory = opendir(buf); // open the directory
|
|
//
|
|
// if (directory == (DIR *)NULL)
|
|
// return false;
|
|
//
|
|
// struct dirent *fEntry;
|
|
// fEntry = readdir(directory); // read the first "file" in the directory
|
|
//
|
|
// while (fEntry != (struct dirent *)NULL) {
|
|
// char filename[BUFSIZ+1];
|
|
// struct stat fStat;
|
|
//
|
|
// dSprintf(filename, sizeof(filename), "%s/%s", buf, fEntry->d_name); // "construct" the file name
|
|
// stat(filename, &fStat); // get the file stats
|
|
//
|
|
// /* we AND the st_mode and S_IFMT to get the type of file */
|
|
// if ( (fStat.st_mode & S_IFMT) == S_IFDIR ) {
|
|
// // Directory
|
|
// if (filename[0] != '.') {
|
|
// scratchBuf[0] = '\0';
|
|
// if (curPath[0] != '\0') {
|
|
// dStrcpy(scratchBuf, curPath);
|
|
// dStrcat(scratchBuf, "/");
|
|
// }
|
|
// dStrcat(scratchBuf, filename);
|
|
//
|
|
// _recurseDumpPath(basePath, scratchBuf, out_rFileVector);
|
|
// }
|
|
// } else {
|
|
// // File
|
|
// out_rFileVector.increment();
|
|
// Platform::FileInfo& rInfo = out_rFileVector.last();
|
|
//
|
|
// if (curPath[0] != '\0') {
|
|
// dSprintf(scratchBuf, sizeof(scratchBuf), "%s/%s", basePath, curPath);
|
|
// rInfo.pFullPath = StringTable->insert(scratchBuf);
|
|
// rInfo.pVirtPath = StringTable->insert(curPath);
|
|
// } else {
|
|
// rInfo.pFullPath = StringTable->insert(basePath);
|
|
// rInfo.pVirtPath = NULL;
|
|
// }
|
|
// rInfo.pFileName = StringTable->insert(filename);
|
|
// rInfo.fileSize = fStat.st_size;
|
|
// }
|
|
//
|
|
// if ( (fEntry = readdir(directory)) == (struct dirent *)NULL) {
|
|
// closedir(directory);
|
|
// fEntry = (struct dirent *)NULL;
|
|
// }
|
|
// }
|
|
//
|
|
// return true;
|
|
//}
|
|
|
|
//--------------------------------------
|
|
|
|
bool Platform::getFileTimes(const char *filePath, FileTime *createTime, FileTime *modifyTime)
|
|
{
|
|
struct stat fStat;
|
|
|
|
if (stat(filePath, &fStat) == -1)
|
|
return false;
|
|
|
|
if(createTime)
|
|
{
|
|
// no where does SysV/BSD UNIX keep a record of a file's
|
|
// creation time. instead of creation time I'll just use
|
|
// changed time for now.
|
|
createTime = (FileTime *)&fStat.st_ctime;
|
|
}
|
|
if(modifyTime)
|
|
{
|
|
modifyTime = (FileTime *)&fStat.st_mtime;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------
|
|
bool Platform::createPath(const char *file)
|
|
{
|
|
char pathbuf[1024];
|
|
const char *dir;
|
|
pathbuf[0] = 0;
|
|
U32 pathLen = 0;
|
|
|
|
while((dir = dStrchr(file, '/')) != NULL)
|
|
{
|
|
dStrncpy(pathbuf + pathLen, file, dir - file);
|
|
pathbuf[pathLen + dir-file] = 0;
|
|
bool ret = mkdir(pathbuf, 0666);
|
|
pathLen += dir - file;
|
|
pathbuf[pathLen++] = '/';
|
|
file = dir + 1;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* this will be a pain and it's not being used so we are leaving it out, for now :-D
|
|
- rjp
|
|
*/
|
|
/***************************************************************************************
|
|
bool Platform::cdFileExists(const char *filePath, const char *volumeName, S32 serialNum)
|
|
{
|
|
if (!filePath || !filePath[0])
|
|
return true;
|
|
|
|
//first find the CD device...
|
|
char fileBuf[256];
|
|
char drivesBuf[256];
|
|
S32 length = GetLogicalDriveStrings(256, drivesBuf);
|
|
char *drivePtr = drivesBuf;
|
|
while (S32(drivePtr - drivesBuf) < length)
|
|
{
|
|
char driveVolume[256], driveFileSystem[256];
|
|
U32 driveSerial, driveFNLength, driveFlags;
|
|
if ((dStricmp(drivePtr, "A:\\") != 0 && dStricmp(drivePtr, "B:\\") != 0) &&
|
|
GetVolumeInformation((const char*)drivePtr, &driveVolume[0], (unsigned long)255,
|
|
(unsigned long*)&driveSerial, (unsigned long*)&driveFNLength,
|
|
(unsigned long*)&driveFlags, &driveFileSystem[0], (unsigned long)255))
|
|
{
|
|
#if defined (DEBUG) || defined (INTERNAL_RELEASE)
|
|
Con::printf("Found Drive: %s, vol: %s, serial: %d", drivePtr, driveVolume, driveSerial);
|
|
#endif
|
|
//see if the volume and serial number match
|
|
if (!dStricmp(volumeName, driveVolume) && (!serialNum || (serialNum == driveSerial)))
|
|
{
|
|
//see if the file exists on this volume
|
|
if(dStrlen(drivePtr) == 3 && drivePtr[2] == '\\' && filePath[0] == '\\')
|
|
dSprintf(fileBuf, sizeof(fileBuf), "%s%s", drivePtr, filePath + 1);
|
|
else
|
|
dSprintf(fileBuf, sizeof(fileBuf), "%s%s", drivePtr, filePath);
|
|
#if defined (DEBUG) || defined (INTERNAL_RELEASE)
|
|
Con::printf("Looking for file: %s on %s", fileBuf, driveVolume);
|
|
#endif
|
|
WIN32_FIND_DATA findData;
|
|
HANDLE h = FindFirstFile(fileBuf, &findData);
|
|
if(h != INVALID_HANDLE_VALUE)
|
|
{
|
|
FindClose(h);
|
|
return true;
|
|
}
|
|
FindClose(h);
|
|
}
|
|
}
|
|
|
|
//check the next drive
|
|
drivePtr += dStrlen(drivePtr) + 1;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
***************************************************************************************/
|
|
|
|
//--------------------------------------
|
|
bool Platform::dumpPath(const char *path, Vector<Platform::FileInfo> &fileVector)
|
|
{
|
|
return recurseDumpPath(path, "*", fileVector);
|
|
}
|
|
|
|
//--------------------------------------
|
|
StringTableEntry Platform::getWorkingDirectory()
|
|
{
|
|
static StringTableEntry cwd = NULL;
|
|
|
|
if (!cwd)
|
|
{
|
|
char cwd_buf[2048];
|
|
getcwd(cwd_buf, 2047);
|
|
cwd = StringTable->insert(cwd_buf);
|
|
}
|
|
return cwd;
|
|
}
|
|
|
|
//--------------------------------------
|
|
bool Platform::isFile(const char *pFilePath)
|
|
{
|
|
if (!pFilePath || !*pFilePath)
|
|
return false;
|
|
// Get file info
|
|
struct stat fStat;
|
|
if (stat(pFilePath, &fStat) < 0)
|
|
return false;
|
|
|
|
// if the file is a "regular file" then true
|
|
if ( (fStat.st_mode & S_IFMT) == S_IFREG)
|
|
return true;
|
|
// must be some other file (directory, device, etc.)
|
|
return false;
|
|
}
|
|
|
|
|
|
//--------------------------------------
|
|
bool Platform::isDirectory(const char *pDirPath)
|
|
{
|
|
if (!pDirPath || !*pDirPath)
|
|
return false;
|
|
|
|
// Get file info
|
|
struct stat fStat;
|
|
if (stat(pDirPath, &fStat) < 0)
|
|
return false;
|
|
|
|
// if the file is a Directory then true
|
|
if ( (fStat.st_mode & S_IFMT) == S_IFDIR)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------
|
|
bool Platform::isSubDirectory(const char *pParent, const char *pDir)
|
|
{
|
|
if (!pParent || !*pDir)
|
|
return false;
|
|
|
|
// this is somewhat of a brute force method but we need to be 100% sure
|
|
// that the user cannot enter things like ../dir or /dir etc,...
|
|
DIR *directory;
|
|
|
|
directory = opendir(pParent);
|
|
if (directory == NULL)
|
|
return false;
|
|
|
|
struct dirent *fEntry;
|
|
fEntry = readdir(directory);
|
|
if ( fEntry == NULL )
|
|
return false;
|
|
|
|
do
|
|
{
|
|
char dirBuf[MAXPATHLEN];
|
|
struct stat fStat;
|
|
|
|
dSprintf(dirBuf, sizeof(dirBuf), "%s/%s", pParent, fEntry->d_name);
|
|
if (stat(dirBuf, &fStat) < 0)
|
|
return false;
|
|
// if it is a directory...
|
|
if ( (fStat.st_mode & S_IFMT) == S_IFDIR)
|
|
{
|
|
// and the names match
|
|
if (dStrcmp(pDir, fEntry->d_name ) == 0)
|
|
{
|
|
// then we have a real sub directory
|
|
closedir(directory);
|
|
return true;
|
|
}
|
|
}
|
|
} while( (fEntry = readdir(directory)) != NULL );
|
|
|
|
closedir(directory);
|
|
return false;
|
|
}
|