/*

 * OS/2 support routines for PhysicsFS.

 *

 * Please see the file LICENSE in the source's root directory.

 *

 *  This file written by Ryan C. Gordon.

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif

#if (defined OS2)

#define INCL_DOSSEMAPHORES

#define INCL_DOSDATETIME

#define INCL_DOSFILEMGR

#define INCL_DOSMODULEMGR

#define INCL_DOSERRORS

#define INCL_DOSDEVICES

#include <os2.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <assert.h>

static APIRET os2err(APIRET retval)

{

    const char *err = NULL;

    /*

     * The ones that say "OS/2 reported" are more for PhysicsFS developer

     *  debugging. We give more generic messages for ones that are likely to

     *  fall through to an application.

     */

    switch (retval)

    {

        case NO_ERROR: /* Don't set the PhysicsFS error message for these... */

        case ERROR_INTERRUPT:

        case ERROR_TIMEOUT:

            break;

        case ERROR_NOT_ENOUGH_MEMORY:

            err = ERR_OUT_OF_MEMORY;

            break;

        case ERROR_FILE_NOT_FOUND:

            err = "File not found";

            break;

        case ERROR_PATH_NOT_FOUND:

            err = "Path not found";

            break;

        case ERROR_ACCESS_DENIED:

            err = "Access denied";

            break;

        case ERROR_NOT_DOS_DISK:

            err = "Not a DOS disk";

            break;

        case ERROR_DRIVE_LOCKED:

            err = "Drive is locked";

            break;

        case ERROR_SHARING_VIOLATION:

            err = "Sharing violation";

            break;

        case ERROR_CANNOT_MAKE:

            err = "Cannot make";

            break;

        case ERROR_DEVICE_IN_USE:

            err = "Device already in use";

            break;

        case ERROR_DRIVE_LOCKED:

            err = "Drive is locked";

            break;

        case ERROR_OPEN_FAILED:

            err = "Open failed";

            break;

        case ERROR_DISK_FULL:

            err = "Disk is full";

            break;

        case ERROR_DISK_FULL:

            err = "Pipe busy";

            break;

        case ERROR_SHARING_BUFFER_EXCEEDED:

            err = "Sharing buffer exceeded";

            break;

        case ERROR_FILENAME_EXCED_RANGE:

        case ERROR_META_EXPANSION_TOO_LONG:

            err = "Filename too big";

            break;

        case ERROR_TOO_MANY_HANDLES:

        case ERROR_TOO_OPEN_FILES:

        case ERROR_NO_MORE_SEARCH_HANDLES:

            err = "Too many open handles";

            break;

        case ERROR_SEEK_ON_DEVICE:

            err = "Seek error";  /* Is that what this error means? */

            break;

        case ERROR_NEGATIVE_SEEK:

            err = "Seek past start of file";

            break;

        case ERROR_CURRENT_DIRECTORY:

            err = "Trying to delete current working directory";

            break;

        case ERROR_WRITE_PROTECT:

            err = "Write protect error";

            break;

        case ERROR_WRITE_FAULT:

            err = "Write fault";

            break;

        case ERROR_LOCK_VIOLATION:

            err = "Lock violation";

            break;

        case ERROR_GEN_FAILURE:

            err = "General failure";

            break;

        case ERROR_UNCERTAIN_MEDIA:

            err = "Uncertain media";

            break;

        case ERROR_PROTECTION_VIOLATION:

            err = "Protection violation";

            break;

        case ERROR_INVALID_PARAMETER:

        case ERROR_INVALID_NAME:

        case ERROR_INVALID_DRIVE:

        case ERROR_INVALID_HANDLE:

        case ERROR_INVALID_FUNCTION:

        case ERROR_INVALID_LEVEL:

        case ERROR_INVALID_CATEGORY:

        case ERROR_DUPLICATE_NAME:

        case ERROR_BUFFER_OVERFLOW:

        case ERROR_BAD_LENGTH:

        case ERROR_BAD_DRIVER_LEVEL:

        case ERROR_DIRECT_ACCESS_HANDLE:

            err = "OS/2 reported an invalid parameter to an API function";

            break;

        case ERROR_NO_VOLUME_LABEL:

            err = "OS/2 reported no volume label";

            break;

        case ERROR_NO_MORE_FILES:

            err = "OS/2 reported no more files";

            break;

        case ERROR_MONITORS_NOT_SUPPORTED:

            err = "OS/2 reported monitors not supported";

            break;

        case ERROR_BROKEN_PIPE:

            err = "OS/2 reported a broken pipe";

            break;

        case ERROR_MORE_DATA:

            err = "OS/2 reported \"more data\" (?)";

            break;

        case ERROR_EAS_DIDNT_FIT:

            err = "OS/2 reported Extended Attributes didn't fit";

            break;

        case ERROR_INVALID_EA_NAME:

            err = "OS/2 reported an invalid Extended Attribute name";

            break;

        case ERROR_EA_LIST_INCONSISTENT:

            err = "OS/2 reported an inconsistent Extended Attribute list";

            break;

        case ERROR_EA_VALUE_UNSUPPORTABLE:

            err = "OS/2 reported an unsupportable Extended Attribute value";

            break;

        case ERROR_SEM_OWNER_DIED:

            err = "OS/2 reported that semaphore owner died";

            break;

        case ERROR_TOO_MANY_SEM_REQUESTS:

            err = "OS/2 reported too many semaphore requests";

            break;

        case ERROR_SEM_BUSY:

            err = "OS/2 reported a blocked semaphore";

            break;

        case ERROR_NOT_OWNER:

            err = "OS/2 reported that we used a resource we don't own.";

            break;

        default:

            err = "OS/2 reported back with unrecognized error code";

            break;

    } /* switch */

    if (err != NULL)

        __PHYSFS_setError(err);

    return(retval);

} /* os2err */

static char *baseDir = NULL;

int __PHYSFS_platformInit(void)

{

    char buf[CCHMAXPATH];

    APIRET rc;

    TIB tib;

    PIB pib;

    assert(baseDir == NULL);

    BAIL_IF_MACRO(os2err(DosGetInfoBlocks(&tib, &pib)) != NO_ERROR, NULL, 0);

    rc = DosQueryModuleName(pib.pib_hmte, sizeof (buf), (PCHAR) buf);

    BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, 0);

    baseDir = (char *) malloc(strlen(buf) + 1);

    BAIL_IF_MACRO(baseDir == NULL, ERR_OUT_OF_MEMORY, 0);

    strcpy(baseDir);

    return(1);  /* success. */

} /* __PHYSFS_platformInit */

int __PHYSFS_platformDeinit(void)

{

    assert(baseDir != NULL);

    free(baseDir);

    baseDir = NULL;

    return(1);  /* success. */

} /* __PHYSFS_platformDeinit */

static int disc_is_inserted(ULONG drive)

{

    int rc;

    char buf[20];

    DosError(FERR_DISABLEHARDERR | FERR_DISABLEEXCEPTION);

    rc = DosQueryFSInfo(drive + 1, FSIL_VOLSER, buf, sizeof (buf));

    DosError(FERR_ENABLEHARDERR | FERR_ENABLEEXCEPTION);

    return(rc == NO_ERROR);

} /* is_cdrom_inserted */

static int is_cdrom_drive(ULONG drive)

{

    PHYSFS_uint16 cmd = (((drive & 0xFF) << 8) | 0);

    BIOSPARAMETERBLOCK bpb;

    ULONG ul1, ul2;

    APIRET rc;

    rc = DosDevIOCtl((HFILE) -1, IOCTL_DISK,

                     DSK_GETDEVICEPARAMS,

                     &cmd, sizeof (cmd), &ul1,

                     &bpb, sizeof (bpb), &u2);

    /*

     * !!! FIXME: Note that this tells us that the media is REMOVABLE...

     * !!! FIXME:  but it might not be a CD-ROM...check driver name?

     */

    return((rc == NO_ERROR) && ((DiskData.fsDeviceAttr & 0x0001) == 0));

} /* is_cdrom_drive */

char **__PHYSFS_platformDetectAvailableCDs(void)

{

    ULONG dummy;

    ULONG drivemap;

    ULONG i, bit;

    APIRET rc;

    char **retval;

    PHYSFS_uint32 cd_count = 0;

    retval = (char **) malloc(sizeof (char *));

    BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);

    *retval = NULL;

    rc = DosQueryCurrentDisk(&dummy, &drivemap);

    BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, retval);

    /* !!! FIXME: the a, b, and c drives are almost certainly NOT cdroms... */

    for (i = 0, bit = 1; i < 26; i++, bit << 1)

    {

        if (drivemap & bit)  /* this logical drive exists. */

        {

            if ((is_cdrom_drive(i)) && (disc_is_inserted(i)))

            {

                char **tmp = realloc(retval, sizeof (char *) * (cd_count + 1));

                if (tmp)

                {

                    char *str = (char *) malloc(4);

                    retval = tmp;

                    retval[cd_count - 1] = str;

                    if (str)

                    {

                        str[0] = ('A' + i);

                        str[1] = ':';

                        str[2] = '\\';

                        str[3] = '\0';

                        cd_count++;

                    } /* if */

                } /* if */

            } /* if */

        } /* if */

    } /* for */

    return(retval);

} /* __PHYSFS_platformDetectAvailableCDs */

char *__PHYSFS_platformCalcBaseDir(const char *argv0)

{

    char *retval = (char *) malloc(strlen(baseDir) + 1);

    BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);

    strcpy(retval, baseDir); /* calculated at init time. */

    return(retval);

} /* __PHYSFS_platformCalcBaseDir */

char *__PHYSFS_platformGetUserName(void)

{

    return(NULL);  /* (*shrug*) */

} /* __PHYSFS_platformGetUserName */

char *__PHYSFS_platformGetUserDir(void)

{

    return(__PHYSFS_platformCalcBaseDir(NULL));

} /* __PHYSFS_platformGetUserDir */

int __PHYSFS_platformStricmp(const char *x, const char *y)

{

    int ux, uy;

    do

    {

        ux = toupper((int) *x);

        uy = toupper((int) *y);

        if (ux > uy)

            return(1);

        else if (ux < uy)

            return(-1);

        x++;

        y++;

    } while ((ux) && (uy));

    return(0);

} /* __PHYSFS_platformStricmp */

int __PHYSFS_platformExists(const char *fname)

{

    FILESTATUS3 fs;

    APIRET rc = DosQueryPathInfo(fname, FIL_STANDARD, &fs, sizeof (fs));

    return(os2err(rc) == NO_ERROR);

} /* __PHYSFS_platformExists */

int __PHYSFS_platformIsSymLink(const char *fname)

{

    return(0);  /* no symlinks in OS/2. */

} /* __PHYSFS_platformIsSymlink */

int __PHYSFS_platformIsDirectory(const char *fname)

{

    FILESTATUS3 fs;

    APIRET rc = DosQueryPathInfo(fname, FIL_STANDARD, &fs, sizeof (fs));

    BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, 0)

    return((fs.attrFile & FILE_DIRECTORY) != 0);

} /* __PHYSFS_platformIsDirectory */

char *__PHYSFS_platformCvtToDependent(const char *prepend,

                                      const char *dirName,

                                      const char *append)

{

    int len = ((prepend) ? strlen(prepend) : 0) +

              ((append) ? strlen(append) : 0) +

              strlen(dirName) + 1;

    char *retval = malloc(len);

    char *p;

    BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);

    if (prepend)

        strcpy(retval, prepend);

    else

        retval[0] = '\0';

    strcat(retval, dirName);

    if (append)

        strcat(retval, append);

    for (p = strchr(retval, '/'); p != NULL; p = strchr(p + 1, '/'))

        *p = '\\';

    return(retval);

} /* __PHYSFS_platformCvtToDependent */

LinkedStringList *__PHYSFS_platformEnumerateFiles(const char *dirname,

                                                  int omitSymLinks)

{

    char spec[CCHMAXPATH];

    LinkedStringList *retval = NULL, *p = NULL;

    FINDFILEBUF3 fb;

    HDIR hdir = HDIR_CREATE;

    ULONG count = 1;

    APIRET rc;

    BAIL_IF_MACRO(strlen(dirname) > sizeof (spec) - 4, ERR_OS_ERROR, NULL);

    strcpy(spec, dname)

    strcat(spec, "*.*");

    rc = DosFindFirst(spec, &hdir,

                      FILE_DIRECTORY | FILE_ARCHIVED |

                      FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM,

                      &fb, sizeof (fb), &count, FIL_STANDARD)

    BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, 0);

    while (count == 1)

    {

        if (strcmp(fb.achName, ".") == 0)

            continue;

        if (strcmp(fb.achName, "..") == 0)

            continue;

        retval = __PHYSFS_addToLinkedStringList(retval, &p, fb.achName, -1);

        DosFindNext(hdir, &fb, sizeof (fb), &count);

    } /* while */

    DosFindClose(hdir);

    return(retval);

} /* __PHYSFS_platformEnumerateFiles */

char *__PHYSFS_platformCurrentDir(void)

{

    char *retval;

    ULONG currentDisk;

    ULONG dummy;

    ULONG pathSize = 0;

    APIRET rc;

    BYTE byte;

    rc = DosQueryCurrentDisk(&currentDisk, &dummy);

    BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, NULL);

    /* The first call just tells us how much space we need for the string. */

    rc = DosQueryCurrentDir(currentDisk, &byte, &pathSize);

    pathSize++; /* Add space for null terminator. */

    retval = (char *) malloc(pathSize + 3);  /* plus "x:\\" */

    BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);

    /* Actually get the string this time. */

    rc = DosQueryCurrentDir(currentDisk, (PBYTE) (retval + 3), &pathSize);

    if (os2err(rc) != NO_ERROR)

    {

        free(retval);

        return(NULL);

    } /* if */

    retval[0] = ('A' + (currentDisk - 1));

    retval[1] = ':';

    retval[2] = '\\';

    return(retval);

} /* __PHYSFS_platformCurrentDir */

char *__PHYSFS_platformRealPath(const char *path)

{

    char buf[CCHMAXPATH];

    char *retval;

    APIRET rc = DosQueryPathInfo(fname, FIL_QUERYFULLNAME, buf, sizeof (buf));

    BAIL_IF_MACRO(os2err(rc) != NO_ERROR, NULL, NULL);

    retval = (char *) malloc(strlen(buf) + 1);

    BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);

    strcpy(retval, buf);

    return(retval);

} /* __PHYSFS_platformRealPath */

int __PHYSFS_platformMkDir(const char *path)

{

    return(os2err(DosCreateDir(path, NULL)) == NO_ERROR);

} /* __PHYSFS_platformMkDir */

void *__PHYSFS_platformOpenRead(const char *filename)

{

    ULONG actionTaken = 0;

    HFILE hfile = NULLHANDLE;

    /*

     * File must be opened SHARE_DENYWRITE and ACCESS_READONLY, otherwise

     *  DosQueryFileInfo() will fail if we try to get a file length, etc.

     */

    os2err(DosOpen(filename, &hfile, &actionTaken, 0, FILE_NORMAL,

                   OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,