/*
* Descent 3
* Copyright (C) 2024 Parallax Software
*
* This program 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
/*
* $Logfile: /DescentIII/Main/ddio_win/winfile.cpp $
* $Revision: 27 $
* $Date: 10/22/99 1:23p $
* $Author: Kevin $
*
* File operations not covered properly in ANSI C
*
* $Log: /DescentIII/Main/ddio_win/winfile.cpp $
*
* 27 10/22/99 1:23p Kevin
* Made ddio_GetCDDrive return null if the cd isn't found
*
* 26 7/12/99 6:44p Jeff
* added directory lock file API functions
*
* 25 6/24/99 2:04p Kevin
* Fixed bug with 2 CD rom drives & ddio_GetCDDrive
*
* 24 3/19/99 1:53p Kevin
* Fixed a bug with ddio_GetCDDrive
*
* 23 2/09/99 4:46p Jeff
* removed int3 in CopyFileTime
*
* 22 2/04/99 11:19a Kevin
* Added function to find a CD drive letter based on it's volume name
*
* 21 12/08/98 12:17p Jeff
* added 3 functions (similar to ddio_FindFiles) for finding directories
* in a path
*
* 20 11/19/98 5:40p Kevin
* Demo system
*
* 19 10/16/98 11:55a Kevin
* Made dlls loadable in a hog
*
* 18 10/08/98 4:23p Kevin
* Changed code to comply with memory library usage. Always use mem_malloc
* , mem_free and mem_strdup
*
* 17 8/19/98 2:18p Jeff
* changed ddio_CleanPath
*
* 16 8/16/98 2:04p Matt
* Fixed super-stupid bug
*
* 15 8/15/98 3:42p Matt
* Added new function, ddio_GetFullPath()
*
* 14 7/29/98 5:38p Jeff
* added ddio functions to get parent path, and to clean a path name into
* the real path
*
* 13 7/28/98 6:05p Jeff
* added functions to get root directories (aka drives in windows/dos)
*
* 12 6/01/98 10:34a Matt
* If can't copy file time, wait half a second and try again.
*
* 11 5/26/98 7:35p Jason
* took out filetime int 3
*
* 10 4/06/98 1:24p Samir
* support NULL arguments to ddio_SpltPath.
*
* 9 3/19/98 3:18p Samir
* enforce constant char* arguments when needed. done in CFILE and bitmap
* libraries as well as ddio.
*
* 8 2/20/98 3:37p Jason
* fixed error message to print out before subsequent file operations
* happen
*
* 7 2/17/98 9:40p Jason
* print out error number for copy file time
*
* 6 2/16/98 11:08a Jason
* fixed copyfiletime bug
*
* 5 2/16/98 1:48a Matt
* Added some additional error checking
*
* 4 9/10/97 12:06p Samir
* FIxed FindFile functions.
*
* 3 8/15/97 6:31p Samir
* Added findfile functions.
*
* 2 7/17/97 3:00p Jason
* took out int3 on copy file time
*
* 10 6/11/97 2:39p Samir
* Fixed bools
*
* 9 5/06/97 4:27p Samir
* Added ddio_MakePath
*
* 8 5/06/97 12:35p Samir
* Impllemented DirectoryExists and Save/Restore Working paths.
*
* 7 4/25/97 6:16p Jason
* added ddio_Deletefile function
*
* 6 4/03/97 4:34p Jason
* added CopyFileTime to the cfile, ddio libs
*
* 5 3/14/97 6:52p Samir
* Fixed jeremy bugs.
*
* 4 3/14/97 6:53 PM Jeremy
* added implementation of ddio_GetFileLength, ddio_SplitPath
*
* 3 3/14/97 6:38p Samir
* Added ddio_FileDiff
*
* 2 3/13/97 11:09a Samir
* Moved file stuff from gameos to ddio library
*
* 1 3/13/97 11:01a Samir
* Moved from gameos library
*
* $NoKeywords: $
*/
#include "ddio.h"
#include "ddio_win.h"
#include "pserror.h"
#include "mem.h"
#define WIN32_LEAN_AND_MEAN
#include
#include
#include
#include
#include
#include
#include
// ---------------------------------------------------------------------------
// File operations
// creates a directory or folder on disk
bool ddio_CreateDir(const char *path) { return (CreateDirectory(path, NULL)) ? true : false; }
// destroys a directory
bool ddio_RemoveDir(const char *path) { return (RemoveDirectory(path)) ? true : false; }
// retrieve the current working folder where file operation will occur.
void ddio_GetWorkingDir(char *path, int len) { GetCurrentDirectory(len, path); }
bool ddio_SetWorkingDir(const char *path) { return (SetCurrentDirectory(path)) ? true : false; }
bool ddio_FileDiff(const char *path1, const char *path2) {
struct _stat abuf, bbuf;
if (_stat(path1, &abuf))
Int3(); // error getting stat info
if (_stat(path2, &bbuf))
Int3(); // error getting stat info
if ((abuf.st_size != bbuf.st_size) || (abuf.st_mtime != bbuf.st_mtime))
return true;
return false;
}
// get a file's length
int ddio_GetFileLength(FILE *filePtr) { return (filelength(fileno(filePtr))); }
// Split a pathname into its component parts
void ddio_SplitPath(const char *srcPath, char *path, char *filename, char *ext) {
char drivename[_MAX_DRIVE], dirname[_MAX_DIR];
_splitpath(srcPath, drivename, dirname, filename, ext);
if (path)
sprintf(path, "%s%s", drivename, dirname);
}
void ddio_CopyFileTime(char *destname, const char *srcname) {
HANDLE desthandle, srchandle;
FILETIME a, b, c;
bool first_time = 1;
try_again:;
desthandle = CreateFile(destname, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
srchandle = CreateFile(srcname, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (desthandle == INVALID_HANDLE_VALUE || srchandle == INVALID_HANDLE_VALUE) {
mprintf((0, "Couldn't copy file time for %s! Error=%d\n", destname, GetLastError()));
if (desthandle != INVALID_HANDLE_VALUE)
CloseHandle(desthandle);
if (srchandle != INVALID_HANDLE_VALUE)
CloseHandle(srchandle);
if (first_time) {
first_time = 0;
Sleep(500);
goto try_again;
}
// JEFF: This Int3 has become really annoying...all we do is blow by it anyway
// removed for sanity.
//@@Int3(); //Let Matt know if you hit this!
return;
}
GetFileTime(srchandle, &a, &b, &c);
SetFileTime(desthandle, &a, &b, &c);
CloseHandle(desthandle);
CloseHandle(srchandle);
}
// deletes a file. Returns 1 if successful, 0 on failure
int ddio_DeleteFile(const char *name) { return (DeleteFile(name)); }
// Save/Restore the current working directory
static char SavedWorkingDir[_MAX_DIR];
void ddio_SaveWorkingDir(void) { GetCurrentDirectory(_MAX_DIR, SavedWorkingDir); }
void ddio_RestoreWorkingDir(void) { SetCurrentDirectory(SavedWorkingDir); }
// Checks if a directory exists (returns 1 if it does, 0 if not)
// This pathname is *RELATIVE* not fully qualified
bool ddio_DirExists(const char *path) {
BOOL res;
ddio_SaveWorkingDir();
res = SetCurrentDirectory(path);
ddio_RestoreWorkingDir();
return (res) ? true : false;
}
// Constructs a path in the local file system's syntax
// newPath: stores the constructed path
// absolutePathHeader: absolute path on which the sub directories will be appended
// (specified in local file system syntax)
// takes a variable number of subdirectories which will be concatenated on to the path
// the last argument in the list of sub dirs *MUST* be NULL to terminate the list
void ddio_MakePath(char *newPath, const char *absolutePathHeader, const char *subDir, ...) {
const char delimiter = '\\';
va_list args;
char *currentDir = NULL;
int pathLength = 0;
assert(newPath);
assert(absolutePathHeader);
assert(subDir);
if (newPath != absolutePathHeader) {
strcpy(newPath, absolutePathHeader);
}
// Add the first sub directory
pathLength = strlen(newPath);
if (newPath[pathLength - 1] != delimiter) {
newPath[pathLength] = delimiter; // add the delimiter
newPath[pathLength + 1] = 0; // terminate the string
}
strcat(newPath, subDir);
// Add the additional subdirectories
va_start(args, subDir);
while ((currentDir = va_arg(args, char *)) != NULL) {
pathLength = strlen(newPath);
if (newPath[pathLength - 1] != delimiter) {
newPath[pathLength] = delimiter; // add the delimiter
newPath[pathLength + 1] = 0; // terminate the string
}
strcat(newPath, currentDir);
}
va_end(args);
}
bool ddio_GetTempFileName(const char *basedir, const char *prefix, char *filename) {
if (!GetTempFileName(basedir, prefix, 0, filename))
return false;
else
return true;
}
// These functions allow one to find a file
// You use FindFileStart by giving it a wildcard (like *.*, *.txt, u??.*, whatever). It returns
// a filename in namebuf.
// Use FindNextFile to get the next file found with the wildcard given in FindFileStart.
// Use FindFileClose to end your search.
static HANDLE hFindFile = INVALID_HANDLE_VALUE;
static WIN32_FIND_DATA FindFileData;
bool ddio_FindFileStart(const char *wildcard, char *namebuf) {
if (hFindFile != INVALID_HANDLE_VALUE)
ddio_FindFileClose();
hFindFile = FindFirstFile(wildcard, &FindFileData);
if (hFindFile != INVALID_HANDLE_VALUE) {
strcpy(namebuf, FindFileData.cFileName);
return true;
} else {
namebuf[0] = 0;
return false;
}
}
bool ddio_FindNextFile(char *namebuf) {
if (!hFindFile)
return false;
if (FindNextFile(hFindFile, &FindFileData)) {
strcpy(namebuf, FindFileData.cFileName);
return true;
} else {
namebuf[0] = 0;
return false;
}
}
void ddio_FindFileClose() {
if (hFindFile != INVALID_HANDLE_VALUE)
FindClose(hFindFile);
hFindFile = INVALID_HANDLE_VALUE;
}
static HANDLE hFindDir = INVALID_HANDLE_VALUE;
static WIN32_FIND_DATA FindDirData;
bool ddio_FindDirStart(const char *wildcard, char *namebuf) {
if (hFindDir != INVALID_HANDLE_VALUE)
ddio_FindDirClose();
hFindDir = FindFirstFile(wildcard, &FindDirData);
if (hFindDir != INVALID_HANDLE_VALUE) {
if (FindDirData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
strcpy(namebuf, FindDirData.cFileName);
return true;
} else {
return ddio_FindNextDir(namebuf);
}
} else {
namebuf[0] = 0;
return false;
}
}
bool ddio_FindNextDir(char *namebuf) {
if (!hFindDir)
return false;
bool done = false;
bool found = false;
while (!done) {
if (FindNextFile(hFindDir, &FindDirData)) {
if (FindDirData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
strcpy(namebuf, FindDirData.cFileName);
done = true;
found = true;
}
} else {
namebuf[0] = '\0';
done = true;
}
}
return found;
}
void ddio_FindDirClose() {
if (hFindDir != INVALID_HANDLE_VALUE)
FindClose(hFindDir);
hFindDir = INVALID_HANDLE_VALUE;
}
// pass in a pathname (could be from ddio_SplitPath), root_path will have the drive name.
void ddio_GetRootFromPath(const char *srcPath, char *root_path) {
assert(root_path);
assert(srcPath);
// the first char should be drive letter, second char should be a :
if ((isalpha(srcPath[0])) && (srcPath[1] == ':')) {
// everything is ok
strncpy(root_path, srcPath, 2);
root_path[2] = '\0';
} else {
// invalid path (no root)
root_path[0] = '\0';
}
}
// retrieve root names, free up roots array (allocated with malloc) after use
int ddio_GetFileSysRoots(char **roots, int max_roots) {
char buffer[100];
int ret = GetLogicalDriveStrings(100, buffer);
if (ret == 0) {
// there was an error
return 0;
}
if (ret > 100) {
// we didn't have enough space
return 0;
}
int count = 0;
bool done = false;
char *strptr = buffer;
char *string;
int strsize;
while ((count < max_roots) && (!done)) {
if (*strptr != 0) {
strsize = strlen(strptr);
string = roots[count] = (char *)mem_malloc(strsize);
if (!string)
break;
// remove the trailing \ from windows
strncpy(string, strptr, strsize - 1);
string[strsize - 1] = '\0';
strptr += (strsize + 1);
count++;
} else
done = true;
}
return count;
}
// given a path, it cleans it up (if the path is c:\windows\..\dos it would make it c:\dos)
// srcPath is the original path
// dest is the finished cleaned path.
// dest should be at least _MAX_PATH in size
void ddio_CleanPath(char *dest, const char *srcPath) {
strcpy(dest, srcPath);
// break the path into directories
char **directories;
int dirs;
int path_length;
// make sure the path ends with a \ for sanity
path_length = strlen(dest);
if (dest[path_length - 1] != '\\') {
dest[path_length] = '\\';
dest[path_length + 1] = '\0';
path_length++;
}
// now divide the full path into seperate NULL terminated strings,counting the number
// of directories in the process
dirs = 0;
char *strptr = dest;
while (*strptr != '\0') {
if (*strptr == '\\') {
*strptr = '\0';
dirs++;
}
strptr++;
}
// check to make sure we have a directory, if we don't then return the original path given
if (dirs == 0) {
strcpy(dest, srcPath);
return;
}
// allocate the memory needed for the seperate strings of each directory
directories = (char **)mem_malloc(sizeof(char *) * dirs);
if (!directories) {
strcpy(dest, srcPath);
return;
}
// now get all the directories, and place into the individual strings
strptr = dest;
int count = 0;
while (count < dirs) {
directories[count] = mem_strdup(strptr);
strptr += strlen(strptr) + 1;
count++;
}
// now the fun part, figure out the correct order of the directories
int *dir_order;
dir_order = (int *)mem_malloc(sizeof(int) * dirs);
if (!dir_order) {
strcpy(dest, srcPath);
return;
}
for (count = 0; count < dirs; count++)
dir_order[count] = -1; // a -1 means the end of the sequence
// now build the order based on the indicies
int curr_index = 0;
for (count = 0; count < dirs; count++) {
if (!stricmp(directories[count], "..")) {
// we have to back up a directory
curr_index--; // back up
if (curr_index < 0)
curr_index = 0; // can't go further than root
dir_order[curr_index] = -1; // invalidate current slot
} else if (stricmp(directories[count], ".")) {
// we have a normal directory, add it's index
dir_order[curr_index] = count;
curr_index++;
}
}
// now rebuild the correct path for use, when we hit -1, we're done
dest[0] = '\0';
for (count = 0; count < dirs; count++) {
if (dir_order[count] == -1)
break;
else {
strcat(dest, directories[dir_order[count]]);
strcat(dest, "\\");
}
}
// now remove trailing \ char
path_length = strlen(dest);
if ((path_length > 0) && (dest[path_length - 1] == '\\'))
dest[path_length - 1] = '\0';
// free up all the allocated memory and we're done
for (count = 0; count < dirs; count++) {
if (directories[count])
mem_free(directories[count]);
}
if (directories)
mem_free(directories);
if (dir_order)
mem_free(dir_order);
}
// given a path (with no filename), it will return the parent path
// srcPath is the source given path
// dest is where the parent path will be placed
// returns true on success
// dest should be at least _MAX_PATH in length
bool ddio_GetParentPath(char *dest, const char *srcPath) {
assert(srcPath);
assert(dest);
#define PARENT_DELIM ".."
int spath_len = strlen(srcPath);
char *temp;
temp = (char *)mem_malloc(spath_len + strlen(PARENT_DELIM) + 3);
if (!temp) {
return false;
}
ddio_MakePath(temp, srcPath, PARENT_DELIM, NULL);
ddio_CleanPath(dest, temp);
mem_free(temp);
return true;
}
// Finds a full path from a relative path
// Parameters: full_path - filled in with the fully-specified path. Buffer must be at least _MAX_PATH bytes long
// rel_path - a path specification, either relative or absolute
// Returns TRUE if successful, FALSE if an error
bool ddio_GetFullPath(char *full_path, const char *rel_path) {
char old_path[_MAX_PATH];
ddio_GetWorkingDir(old_path, sizeof(old_path)); // save old directory
if (!ddio_SetWorkingDir(rel_path)) // try switching to new directory
return 0; // couldn't switch, so return error
ddio_GetWorkingDir(full_path, _MAX_PATH); // get path from the OS
ddio_SetWorkingDir(old_path); // now restore old path
return 1;
}
// Renames file
// Returns true on success or false on an error
bool ddio_RenameFile(char *oldfile, char *newfile) {
int rcode = rename(oldfile, newfile);
if (!rcode)
return true;
else
return false;
}
// Give a volume label to look for, and if it's found returns a path
// If it isn't found, return NULL (used to return "")
const char *ddio_GetCDDrive(const char *vol) {
#define MAX_FSTYPE_LEN 30
static char drivepath[10];
unsigned long volflags;
int i;
char volume[_MAX_PATH];
char fsname[MAX_FSTYPE_LEN] = "";
unsigned long serial;
unsigned long component;
strcpy(drivepath, "c:\\");
for (i = 1; i <= 26; i++) {
if (DRIVE_CDROM == GetDriveType(drivepath)) {
// Get the drive volume name
volume[0] = 0;
if (!GetVolumeInformation(drivepath, volume, _MAX_PATH, &serial, &component, &volflags, fsname, MAX_FSTYPE_LEN)) {
mprintf((0, "Call to GetVolumeInformation() failed. Last error = %d\n", GetLastError()));
}
if (strcmpi(volume, vol) == 0) {
return drivepath;
}
}
drivepath[0]++;
}
drivepath[0] = 0;
return NULL; // drivepath;
}
// Checks to see if a lock file is located in the specified directory.
// Parameters:
// dir Directory for which the lock file should be checked
// Returns:
// 1 Lock file doesn't exist
// 2 Lock file was in a directory, but it belonged to a process that no longer
// exists, so a lock file _can_ be made in the directory.
// 3 Lock file for this process already exists
// 0 Lock file currently exists in directory
// -1 Illegal directory
// -2 There is a lock file in the directory, but it is in an illegal format
int ddio_CheckLockFile(const char *dir) {
DWORD curr_pid = GetCurrentProcessId();
char old_directory[_MAX_PATH];
ddio_GetWorkingDir(old_directory, _MAX_PATH);
if (!ddio_SetWorkingDir(dir))
return -1;
bool found_lock_file_in_dir = false;
FILE *file;
chmod(".lock", _S_IREAD | _S_IWRITE);
file = fopen(".lock", "rb");
if (!file) {
// File exists, but couldn't open it
if (errno == EACCES) {
ddio_SetWorkingDir(old_directory);
return -2;
}
found_lock_file_in_dir = false;
} else {
found_lock_file_in_dir = true;
// check the file, see if it is a lock file
char c;
c = fgetc(file);
if (c != 'L') {
fclose(file);
ddio_SetWorkingDir(old_directory);
return -2;
}
c = fgetc(file);
if (c != 'O') {
fclose(file);
ddio_SetWorkingDir(old_directory);
return -2;
}
c = fgetc(file);
if (c != 'C') {
fclose(file);
ddio_SetWorkingDir(old_directory);
return -2;
}
c = fgetc(file);
if (c != 'K') {
fclose(file);
ddio_SetWorkingDir(old_directory);
return -2;
}
// it appears to be a lock file, check the pid
DWORD f_pid;
fread(&f_pid, sizeof(DWORD), 1, file);
fclose(file);
// check the file id in the file, compared to our pid
if (f_pid == curr_pid) {
// lock file already exists for the current process
ddio_SetWorkingDir(old_directory);
return 3;
}
HANDLE proc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, f_pid);
if (proc) {
DWORD obj_ret = WaitForSingleObject(proc, 0);
CloseHandle(proc);
if (obj_ret == WAIT_TIMEOUT) {
// this process exists still
ddio_SetWorkingDir(old_directory);
return 0;
}
}
// the process no longer exists, we can create a lock file if needed
// we'll delete the useless one now
ddio_DeleteFile(".lock");
}
ddio_SetWorkingDir(old_directory);
return (found_lock_file_in_dir) ? 2 : 1;
}
// Creates a lock file in the specified directory
// Parameters:
// dir Directory for which the lock file should be created in
// Returns:
// 1 Lock file created
// 2 Lock file created (there was a lock file in that directory, but it belonged
// to a process that no longer exists)
// 3 Lock file for this process already exists
// 0 Lock file not created, a lock file currently exists in the directory
// -1 Illegal directory
// -2 There is a lock file in the directory, but it is in an illegal format
// -3 Unable to create lock file
int ddio_CreateLockFile(const char *dir) {
int result = ddio_CheckLockFile(dir);
switch (result) {
case 0:
case -1:
case -2:
case 3:
return result;
};
DWORD curr_pid = GetCurrentProcessId();
char old_directory[_MAX_PATH];
ddio_GetWorkingDir(old_directory, _MAX_PATH);
if (!ddio_SetWorkingDir(dir))
return -1;
FILE *file;
file = fopen(".lock", "wb");
if (!file) {
ddio_SetWorkingDir(old_directory);
return -3;
}
fputc('L', file);
fputc('O', file);
fputc('C', file);
fputc('K', file);
fwrite(&curr_pid, sizeof(DWORD), 1, file);
fclose(file);
ddio_SetWorkingDir(old_directory);
// at this point result will either be 1 or 2 from checking the lock file
// either way, a lock file has been created
return result;
}
// Deletes a lock file (for the current process) in the specified directory
// Parameters:
// dir Directory for which the lock file should be deleted from
// Returns:
// 1 Lock file deleted
// 0 Lock file not deleted, the lock file in the directory does not belong to our
// process
// -1 Illegal directory
// -2 A lock file exists in the directory, but wasn't deleted...illegal format
// -3 Unable to delete file
int ddio_DeleteLockFile(const char *dir) {
DWORD curr_pid = GetCurrentProcessId();
char old_directory[_MAX_PATH];
ddio_GetWorkingDir(old_directory, _MAX_PATH);
if (!ddio_SetWorkingDir(dir))
return -1;
FILE *file;
chmod(".lock", _S_IREAD | _S_IWRITE);
file = fopen(".lock", "rb");
if (!file)
return 1;
// check the file, see if it is a lock file
char c;
c = fgetc(file);
if (c != 'L') {
fclose(file);
ddio_SetWorkingDir(old_directory);
return -2;
}
c = fgetc(file);
if (c != 'O') {
fclose(file);
ddio_SetWorkingDir(old_directory);
return -2;
}
c = fgetc(file);
if (c != 'C') {
fclose(file);
ddio_SetWorkingDir(old_directory);
return -2;
}
c = fgetc(file);
if (c != 'K') {
fclose(file);
ddio_SetWorkingDir(old_directory);
return -2;
}
// it appears to be a lock file, check the pid
DWORD f_pid;
fread(&f_pid, sizeof(DWORD), 1, file);
fclose(file);
// check the file id in the file, compared to our pid
if (f_pid != curr_pid) {
// it doesn't belong to
ddio_SetWorkingDir(old_directory);
return 0;
}
// the lock file in the directory belongs to us!
if (!ddio_DeleteFile(".lock")) {
ddio_SetWorkingDir(old_directory);
return -3;
}
ddio_SetWorkingDir(old_directory);
return 1;
}