mirror of
https://github.com/kevinbentley/Descent3.git
synced 2025-01-22 19:55:23 +00:00
365 lines
9.6 KiB
C++
365 lines
9.6 KiB
C++
/*
|
|
* 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 <http://www.gnu.org/licenses/>.
|
|
|
|
--- HISTORICAL COMMENTS FOLLOW ---
|
|
|
|
* $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 its 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 <cstdarg>
|
|
#include <cstdio>
|
|
#include <sys/stat.h>
|
|
#include <io.h>
|
|
#include <fcntl.h>
|
|
|
|
#include "ddio.h"
|
|
#include "log.h"
|
|
#include "mem.h"
|
|
#include "pserror.h"
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// File operations
|
|
|
|
// 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 std::filesystem::path &path1, const std::filesystem::path &path2) {
|
|
struct _stat abuf, bbuf;
|
|
|
|
if (_stat(path1.u8string().c_str(), &abuf))
|
|
Int3(); // error getting stat info
|
|
|
|
if (_stat(path2.u8string().c_str(), &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(const std::filesystem::path &dest, const std::filesystem::path &src) {
|
|
HANDLE desthandle, srchandle;
|
|
FILETIME a, b, c;
|
|
bool first_time = true;
|
|
|
|
try_again:;
|
|
|
|
desthandle = CreateFile(dest.u8string().c_str(), GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
srchandle = CreateFile(src.u8string().c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
if (desthandle == INVALID_HANDLE_VALUE || srchandle == INVALID_HANDLE_VALUE) {
|
|
LOG_WARNING.printf("Couldn't copy file time for %s! Error=%d", dest.u8string().c_str(), GetLastError());
|
|
|
|
if (desthandle != INVALID_HANDLE_VALUE)
|
|
CloseHandle(desthandle);
|
|
|
|
if (srchandle != INVALID_HANDLE_VALUE)
|
|
CloseHandle(srchandle);
|
|
|
|
if (first_time) {
|
|
first_time = false;
|
|
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)); }
|
|
|
|
// 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);
|
|
}
|
|
|
|
// 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] = mem_rmalloc<char>(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;
|
|
}
|
|
|
|
std::vector<std::filesystem::path> ddio_GetSysRoots() {
|
|
std::vector<std::filesystem::path> result = {};
|
|
char buffer[100];
|
|
|
|
int ret = GetLogicalDriveStrings(100, buffer);
|
|
if (ret == 0 || ret > 100) {
|
|
// there was an error
|
|
return result;
|
|
}
|
|
|
|
bool done = false;
|
|
char *strptr = buffer;
|
|
char *string;
|
|
int strsize;
|
|
|
|
while (!done) {
|
|
if (*strptr != 0) {
|
|
strsize = strlen(strptr);
|
|
string = mem_rmalloc<char>(strsize);
|
|
if (!string)
|
|
break;
|
|
// remove the trailing \ from windows
|
|
strncpy(string, strptr, strsize - 1);
|
|
string[strsize - 1] = '\0';
|
|
|
|
strptr += (strsize + 1);
|
|
result.push_back(string);
|
|
mem_free(string);
|
|
} else {
|
|
done = true;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
bool ddio_CheckProcess(int pid) {
|
|
HANDLE proc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (DWORD)pid);
|
|
if (proc) {
|
|
DWORD obj_ret = WaitForSingleObject(proc, 0);
|
|
CloseHandle(proc);
|
|
if (obj_ret == WAIT_TIMEOUT) {
|
|
// this process exists still
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int ddio_GetPID() {
|
|
return GetCurrentProcessId();
|
|
}
|