2 * OS/2 support routines for PhysicsFS.
4 * Please see the file LICENSE.txt in the source's root directory.
6 * This file written by Ryan C. Gordon.
9 #define __PHYSICSFS_INTERNAL__
10 #include "physfs_platforms.h"
12 #ifdef PHYSFS_PLATFORM_OS2
14 #define INCL_DOSSEMAPHORES
15 #define INCL_DOSDATETIME
16 #define INCL_DOSFILEMGR
17 #define INCL_DOSMODULEMGR
18 #define INCL_DOSERRORS
19 #define INCL_DOSPROCESS
20 #define INCL_DOSDEVICES
21 #define INCL_DOSDEVIOCTL
32 #include "physfs_internal.h"
34 const char *__PHYSFS_platformDirSeparator = "\\";
37 static const char *get_os2_error_string(APIRET rc)
41 case NO_ERROR: return(NULL); /* not an error. */
42 case ERROR_INTERRUPT: return(NULL); /* not an error. */
43 case ERROR_TIMEOUT: return(NULL); /* not an error. */
44 case ERROR_NOT_ENOUGH_MEMORY: return(ERR_OUT_OF_MEMORY);
45 case ERROR_FILE_NOT_FOUND: return(ERR_NO_SUCH_FILE);
46 case ERROR_PATH_NOT_FOUND: return(ERR_NO_SUCH_PATH);
47 case ERROR_ACCESS_DENIED: return(ERR_ACCESS_DENIED);
48 case ERROR_NOT_DOS_DISK: return(ERR_NOT_A_DOS_DISK);
49 case ERROR_SHARING_VIOLATION: return(ERR_SHARING_VIOLATION);
50 case ERROR_CANNOT_MAKE: return(ERR_CANNOT_MAKE);
51 case ERROR_DEVICE_IN_USE: return(ERR_DEV_IN_USE);
52 case ERROR_OPEN_FAILED: return(ERR_OPEN_FAILED);
53 case ERROR_DISK_FULL: return(ERR_DISK_FULL);
54 case ERROR_PIPE_BUSY: return(ERR_PIPE_BUSY);
55 case ERROR_SHARING_BUFFER_EXCEEDED: return(ERR_SHARING_BUF_EXCEEDED);
56 case ERROR_FILENAME_EXCED_RANGE: return(ERR_BAD_FILENAME);
57 case ERROR_META_EXPANSION_TOO_LONG: return(ERR_BAD_FILENAME);
58 case ERROR_TOO_MANY_HANDLES: return(ERR_TOO_MANY_HANDLES);
59 case ERROR_TOO_MANY_OPEN_FILES: return(ERR_TOO_MANY_HANDLES);
60 case ERROR_NO_MORE_SEARCH_HANDLES: return(ERR_TOO_MANY_HANDLES);
61 case ERROR_SEEK_ON_DEVICE: return(ERR_SEEK_ERROR);
62 case ERROR_NEGATIVE_SEEK: return(ERR_SEEK_OUT_OF_RANGE);
63 /*!!! FIXME: Where did this go? case ERROR_DEL_CURRENT_DIRECTORY: return(ERR_DEL_CWD);*/
64 case ERROR_WRITE_PROTECT: return(ERR_WRITE_PROTECT_ERROR);
65 case ERROR_WRITE_FAULT: return(ERR_WRITE_FAULT);
66 case ERROR_LOCK_VIOLATION: return(ERR_LOCK_VIOLATION);
67 case ERROR_GEN_FAILURE: return(ERR_GEN_FAILURE);
68 case ERROR_UNCERTAIN_MEDIA: return(ERR_UNCERTAIN_MEDIA);
69 case ERROR_PROTECTION_VIOLATION: return(ERR_PROT_VIOLATION);
70 case ERROR_BROKEN_PIPE: return(ERR_BROKEN_PIPE);
72 case ERROR_INVALID_PARAMETER:
73 case ERROR_INVALID_NAME:
74 case ERROR_INVALID_DRIVE:
75 case ERROR_INVALID_HANDLE:
76 case ERROR_INVALID_FUNCTION:
77 case ERROR_INVALID_LEVEL:
78 case ERROR_INVALID_CATEGORY:
79 case ERROR_DUPLICATE_NAME:
80 case ERROR_BUFFER_OVERFLOW:
81 case ERROR_BAD_LENGTH:
82 case ERROR_BAD_DRIVER_LEVEL:
83 case ERROR_DIRECT_ACCESS_HANDLE:
85 return(ERR_PHYSFS_BAD_OS_CALL);
87 default: return(ERR_OS2_GENERIC);
91 } /* get_os2_error_string */
94 static APIRET os2err(APIRET retval)
97 const char *err = get_os2_error_string(retval);
98 if (err == ERR_OS2_GENERIC)
100 snprintf(buf, sizeof (buf), ERR_OS2_GENERIC, (int) retval);
105 __PHYSFS_setError(err);
111 /* (be gentle, this function isn't very robust.) */
112 static void cvt_path_to_correct_case(char *buf)
114 char *fname = buf + 3; /* point to first element. */
115 char *ptr = strchr(fname, '\\'); /* find end of first element. */
117 buf[0] = toupper(buf[0]); /* capitalize drive letter. */
120 * Go through each path element, and enumerate its parent dir until
121 * a case-insensitive match is found. If one is (and it SHOULD be)
122 * then overwrite the original element with the correct case.
123 * If there's an error, or the path has vanished for some reason, it
124 * won't hurt to have the original case, so we just keep going.
126 while (fname != NULL)
128 char spec[CCHMAXPATH];
130 HDIR hdir = HDIR_CREATE;
134 *(fname - 1) = '\0'; /* isolate parent dir string. */
136 strcpy(spec, buf); /* copy isolated parent dir... */
137 strcat(spec, "\\*.*"); /* ...and add wildcard search spec. */
139 if (ptr != NULL) /* isolate element to find (fname is the start). */
142 rc = DosFindFirst(spec, &hdir, FILE_DIRECTORY,
143 &fb, sizeof (fb), &count, FIL_STANDARD);
146 while (count == 1) /* while still entries to enumerate... */
148 if (__PHYSFS_stricmpASCII(fb.achName, fname) == 0)
150 strcpy(fname, fb.achName);
151 break; /* there it is. Overwrite and stop searching. */
154 DosFindNext(hdir, &fb, sizeof (fb), &count);
159 *(fname - 1) = '\\'; /* unisolate parent dir. */
160 fname = ptr; /* point to next element. */
163 *ptr = '\\'; /* unisolate element. */
164 ptr = strchr(++fname, '\\'); /* find next element. */
167 } /* cvt_file_to_correct_case */
170 static char *baseDir = NULL;
172 int __PHYSFS_platformInit(void)
174 char buf[CCHMAXPATH];
180 assert(baseDir == NULL);
181 BAIL_IF_MACRO(os2err(DosGetInfoBlocks(&ptib, &ppib)) != NO_ERROR, NULL, 0);
182 rc = DosQueryModuleName(ppib->pib_hmte, sizeof (buf), (PCHAR) buf);
183 BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, 0);
185 /* chop off filename, leave path. */
186 for (len = strlen(buf) - 1; len >= 0; len--)
188 if (buf[len] == '\\')
195 assert(len > 0); /* should have been a "x:\\" on the front on string. */
197 /* The string is capitalized! Figure out the REAL case... */
198 cvt_path_to_correct_case(buf);
200 baseDir = (char *) allocator.Malloc(len + 1);
201 BAIL_IF_MACRO(baseDir == NULL, ERR_OUT_OF_MEMORY, 0);
202 strcpy(baseDir, buf);
203 return(1); /* success. */
204 } /* __PHYSFS_platformInit */
207 int __PHYSFS_platformDeinit(void)
209 assert(baseDir != NULL);
210 allocator.Free(baseDir);
212 return(1); /* success. */
213 } /* __PHYSFS_platformDeinit */
216 static int disc_is_inserted(ULONG drive)
220 DosError(FERR_DISABLEHARDERR | FERR_DISABLEEXCEPTION);
221 rc = DosQueryFSInfo(drive + 1, FSIL_VOLSER, buf, sizeof (buf));
222 DosError(FERR_ENABLEHARDERR | FERR_ENABLEEXCEPTION);
223 return(rc == NO_ERROR);
224 } /* is_cdrom_inserted */
227 /* looks like "CD01" in ASCII (littleendian)...used for an ioctl. */
228 #define CD01 0x31304443
230 static int is_cdrom_drive(ULONG drive)
232 PHYSFS_uint32 param, data;
235 HFILE hfile = NULLHANDLE;
236 char drivename[3] = { 'A' + drive, ':', '\0' };
238 rc = DosOpen(drivename, &hfile, &ul1, 0, 0,
239 OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
240 OPEN_FLAGS_DASD | OPEN_FLAGS_FAIL_ON_ERROR |
241 OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE, NULL);
242 BAIL_IF_MACRO(rc != NO_ERROR, NULL, 0);
245 param = PHYSFS_swapULE32(CD01);
246 ul1 = ul2 = sizeof (PHYSFS_uint32);
247 rc = DosDevIOCtl(hfile, IOCTL_CDROMDISK, CDROMDISK_GETDRIVER,
248 ¶m, sizeof (param), &ul1, &data, sizeof (data), &ul2);
251 return((rc == NO_ERROR) && (PHYSFS_swapULE32(data) == CD01));
252 } /* is_cdrom_drive */
255 void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
260 APIRET rc = DosQueryCurrentDisk(&dummy, &drivemap);
261 if (os2err(rc) != NO_ERROR)
264 for (i = 0, bit = 1; i < 26; i++, bit <<= 1)
266 if (drivemap & bit) /* this logical drive exists. */
268 if ((is_cdrom_drive(i)) && (disc_is_inserted(i)))
270 char drive[4] = "x:\\";
271 drive[0] = ('A' + i);
276 } /* __PHYSFS_platformDetectAvailableCDs */
279 char *__PHYSFS_platformCalcBaseDir(const char *argv0)
281 char *retval = (char *) allocator.Malloc(strlen(baseDir) + 1);
282 BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
283 strcpy(retval, baseDir); /* calculated at init time. */
285 } /* __PHYSFS_platformCalcBaseDir */
288 char *__PHYSFS_platformGetUserName(void)
290 return(NULL); /* (*shrug*) */
291 } /* __PHYSFS_platformGetUserName */
294 char *__PHYSFS_platformGetUserDir(void)
296 return(__PHYSFS_platformCalcBaseDir(NULL));
297 } /* __PHYSFS_platformGetUserDir */
300 int __PHYSFS_platformExists(const char *fname)
303 APIRET rc = DosQueryPathInfo(fname, FIL_STANDARD, &fs, sizeof (fs));
304 return(os2err(rc) == NO_ERROR);
305 } /* __PHYSFS_platformExists */
308 int __PHYSFS_platformIsSymLink(const char *fname)
310 return(0); /* no symlinks in OS/2. */
311 } /* __PHYSFS_platformIsSymlink */
314 int __PHYSFS_platformIsDirectory(const char *fname)
317 APIRET rc = DosQueryPathInfo(fname, FIL_STANDARD, &fs, sizeof (fs));
318 BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, 0)
319 return((fs.attrFile & FILE_DIRECTORY) != 0);
320 } /* __PHYSFS_platformIsDirectory */
323 /* !!! FIXME: can we lose the malloc here? */
324 char *__PHYSFS_platformCvtToDependent(const char *prepend,
328 int len = ((prepend) ? strlen(prepend) : 0) +
329 ((append) ? strlen(append) : 0) +
331 char *retval = allocator.Malloc(len);
334 BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
337 strcpy(retval, prepend);
341 strcat(retval, dirName);
344 strcat(retval, append);
346 for (p = strchr(retval, '/'); p != NULL; p = strchr(p + 1, '/'))
350 } /* __PHYSFS_platformCvtToDependent */
353 void __PHYSFS_platformEnumerateFiles(const char *dirname,
355 PHYSFS_EnumFilesCallback callback,
359 char spec[CCHMAXPATH];
361 HDIR hdir = HDIR_CREATE;
365 if (strlen(dirname) > sizeof (spec) - 5)
367 __PHYSFS_setError(ERR_BAD_FILENAME);
371 strcpy(spec, dirname);
372 strcat(spec, (spec[strlen(spec) - 1] != '\\') ? "\\*.*" : "*.*");
374 rc = DosFindFirst(spec, &hdir,
375 FILE_DIRECTORY | FILE_ARCHIVED |
376 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM,
377 &fb, sizeof (fb), &count, FIL_STANDARD);
379 if (os2err(rc) != NO_ERROR)
384 if ((strcmp(fb.achName, ".") != 0) && (strcmp(fb.achName, "..") != 0))
385 callback(callbackdata, origdir, fb.achName);
387 DosFindNext(hdir, &fb, sizeof (fb), &count);
391 } /* __PHYSFS_platformEnumerateFiles */
394 char *__PHYSFS_platformCurrentDir(void)
403 rc = DosQueryCurrentDisk(¤tDisk, &dummy);
404 BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, NULL);
406 /* The first call just tells us how much space we need for the string. */
407 rc = DosQueryCurrentDir(currentDisk, &byte, &pathSize);
408 pathSize++; /* Add space for null terminator. */
409 retval = (char *) allocator.Malloc(pathSize + 3); /* plus "x:\\" */
410 BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
412 /* Actually get the string this time. */
413 rc = DosQueryCurrentDir(currentDisk, (PBYTE) (retval + 3), &pathSize);
414 if (os2err(rc) != NO_ERROR)
416 allocator.Free(retval);
420 retval[0] = ('A' + (currentDisk - 1));
424 } /* __PHYSFS_platformCurrentDir */
427 char *__PHYSFS_platformRealPath(const char *path)
429 char buf[CCHMAXPATH];
431 APIRET rc = DosQueryPathInfo(path, FIL_QUERYFULLNAME, buf, sizeof (buf));
432 BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, NULL);
433 retval = (char *) allocator.Malloc(strlen(buf) + 1);
434 BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
437 } /* __PHYSFS_platformRealPath */
440 int __PHYSFS_platformMkDir(const char *path)
442 return(os2err(DosCreateDir(path, NULL)) == NO_ERROR);
443 } /* __PHYSFS_platformMkDir */
446 void *__PHYSFS_platformOpenRead(const char *filename)
448 ULONG actionTaken = 0;
449 HFILE hfile = NULLHANDLE;
452 * File must be opened SHARE_DENYWRITE and ACCESS_READONLY, otherwise
453 * DosQueryFileInfo() will fail if we try to get a file length, etc.
455 os2err(DosOpen(filename, &hfile, &actionTaken, 0, FILE_NORMAL,
456 OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
457 OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_LOCALITY |
458 OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE |
459 OPEN_ACCESS_READONLY, NULL));
461 return((void *) hfile);
462 } /* __PHYSFS_platformOpenRead */
465 void *__PHYSFS_platformOpenWrite(const char *filename)
467 ULONG actionTaken = 0;
468 HFILE hfile = NULLHANDLE;
471 * File must be opened SHARE_DENYWRITE and ACCESS_READWRITE, otherwise
472 * DosQueryFileInfo() will fail if we try to get a file length, etc.
474 os2err(DosOpen(filename, &hfile, &actionTaken, 0, FILE_NORMAL,
475 OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
476 OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_LOCALITY |
477 OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE |
478 OPEN_ACCESS_READWRITE, NULL));
480 return((void *) hfile);
481 } /* __PHYSFS_platformOpenWrite */
484 void *__PHYSFS_platformOpenAppend(const char *filename)
487 HFILE hfile = NULLHANDLE;
491 * File must be opened SHARE_DENYWRITE and ACCESS_READWRITE, otherwise
492 * DosQueryFileInfo() will fail if we try to get a file length, etc.
494 rc = os2err(DosOpen(filename, &hfile, &dummy, 0, FILE_NORMAL,
495 OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
496 OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_LOCALITY |
497 OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE |
498 OPEN_ACCESS_READWRITE, NULL));
502 if (os2err(DosSetFilePtr(hfile, 0, FILE_END, &dummy)) != NO_ERROR)
509 return((void *) hfile);
510 } /* __PHYSFS_platformOpenAppend */
513 PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
514 PHYSFS_uint32 size, PHYSFS_uint32 count)
516 HFILE hfile = (HFILE) opaque;
517 PHYSFS_sint64 retval;
520 for (retval = 0; retval < count; retval++)
522 os2err(DosRead(hfile, buffer, size, &br));
525 DosSetFilePtr(hfile, -br, FILE_CURRENT, &br); /* try to cleanup. */
529 buffer = (void *) ( ((char *) buffer) + size );
533 } /* __PHYSFS_platformRead */
536 PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
537 PHYSFS_uint32 size, PHYSFS_uint32 count)
539 HFILE hfile = (HFILE) opaque;
540 PHYSFS_sint64 retval;
543 for (retval = 0; retval < count; retval++)
545 os2err(DosWrite(hfile, buffer, size, &bw));
548 DosSetFilePtr(hfile, -bw, FILE_CURRENT, &bw); /* try to cleanup. */
552 buffer = (void *) ( ((char *) buffer) + size );
556 } /* __PHYSFS_platformWrite */
559 int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
562 HFILE hfile = (HFILE) opaque;
563 LONG dist = (LONG) pos;
565 /* hooray for 32-bit filesystem limits! :) */
566 BAIL_IF_MACRO((PHYSFS_uint64) dist != pos, ERR_SEEK_OUT_OF_RANGE, 0);
568 return(os2err(DosSetFilePtr(hfile, dist, FILE_BEGIN, &dummy)) == NO_ERROR);
569 } /* __PHYSFS_platformSeek */
572 PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
575 HFILE hfile = (HFILE) opaque;
576 APIRET rc = os2err(DosSetFilePtr(hfile, 0, FILE_CURRENT, &pos));
577 BAIL_IF_MACRO(rc != NO_ERROR, NULL, -1);
578 return((PHYSFS_sint64) pos);
579 } /* __PHYSFS_platformTell */
582 PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
585 HFILE hfile = (HFILE) opaque;
586 APIRET rc = DosQueryFileInfo(hfile, FIL_STANDARD, &fs, sizeof (fs));
587 BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, -1);
588 return((PHYSFS_sint64) fs.cbFile);
589 } /* __PHYSFS_platformFileLength */
592 int __PHYSFS_platformEOF(void *opaque)
594 PHYSFS_sint64 len, pos;
596 len = __PHYSFS_platformFileLength(opaque);
597 BAIL_IF_MACRO(len == -1, NULL, 1); /* (*shrug*) */
598 pos = __PHYSFS_platformTell(opaque);
599 BAIL_IF_MACRO(pos == -1, NULL, 1); /* (*shrug*) */
602 } /* __PHYSFS_platformEOF */
605 int __PHYSFS_platformFlush(void *opaque)
607 return(os2err(DosResetBuffer((HFILE) opaque)) == NO_ERROR);
608 } /* __PHYSFS_platformFlush */
611 int __PHYSFS_platformClose(void *opaque)
613 return(os2err(DosClose((HFILE) opaque)) == NO_ERROR);
614 } /* __PHYSFS_platformClose */
617 int __PHYSFS_platformDelete(const char *path)
619 if (__PHYSFS_platformIsDirectory(path))
620 return(os2err(DosDeleteDir(path)) == NO_ERROR);
622 return(os2err(DosDelete(path)) == NO_ERROR);
623 } /* __PHYSFS_platformDelete */
626 PHYSFS_sint64 __PHYSFS_platformGetLastModTime(const char *fname)
628 PHYSFS_sint64 retval;
631 APIRET rc = DosQueryPathInfo(fname, FIL_STANDARD, &fs, sizeof (fs));
632 BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, -1);
634 /* Convert to a format that mktime() can grok... */
635 tm.tm_sec = ((PHYSFS_uint32) fs.ftimeLastWrite.twosecs) * 2;
636 tm.tm_min = fs.ftimeLastWrite.minutes;
637 tm.tm_hour = fs.ftimeLastWrite.hours;
638 tm.tm_mday = fs.fdateLastWrite.day;
639 tm.tm_mon = fs.fdateLastWrite.month;
640 tm.tm_year = ((PHYSFS_uint32) fs.fdateLastWrite.year) + 80;
641 tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/;
645 /* Convert to a format PhysicsFS can grok... */
646 retval = (PHYSFS_sint64) mktime(&tm);
647 BAIL_IF_MACRO(retval == -1, strerror(errno), -1);
649 } /* __PHYSFS_platformGetLastModTime */
652 PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
658 * Allegedly, this API never fails, but we'll punt and return a
659 * default value (zero might as well do) if it does.
661 BAIL_IF_MACRO(os2err(DosGetInfoBlocks(&ptib, &ppib)) != NO_ERROR, 0, 0);
662 return((PHYSFS_uint64) ptib->tib_ordinal);
663 } /* __PHYSFS_platformGetThreadID */
666 void *__PHYSFS_platformCreateMutex(void)
668 HMTX hmtx = NULLHANDLE;
669 os2err(DosCreateMutexSem(NULL, &hmtx, 0, 0));
670 return((void *) hmtx);
671 } /* __PHYSFS_platformCreateMutex */
674 void __PHYSFS_platformDestroyMutex(void *mutex)
676 DosCloseMutexSem((HMTX) mutex);
677 } /* __PHYSFS_platformDestroyMutex */
680 int __PHYSFS_platformGrabMutex(void *mutex)
682 /* Do _NOT_ call os2err() (which sets the physfs error msg) in here! */
683 return(DosRequestMutexSem((HMTX) mutex, SEM_INDEFINITE_WAIT) == NO_ERROR);
684 } /* __PHYSFS_platformGrabMutex */
687 void __PHYSFS_platformReleaseMutex(void *mutex)
689 DosReleaseMutexSem((HMTX) mutex);
690 } /* __PHYSFS_platformReleaseMutex */
693 /* !!! FIXME: Don't use C runtime for allocators? */
694 int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
696 return(0); /* just use malloc() and friends. */
697 } /* __PHYSFS_platformSetDefaultAllocator */
699 #endif /* PHYSFS_PLATFORM_OS2 */
701 /* end of os2.c ... */