path: root/nss/lib/dbm/src/dirent.c

#ifdef OS2

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include <dirent.h>
#include <errno.h>

/*#ifndef __EMX__
#include <libx.h>
#endif */

#define INCL_DOSFILEMGR
#define INCL_DOSERRORS
#include <os2.h>

#if OS2 >= 2
#define FFBUF FILEFINDBUF3
#define Word ULONG
/*
   * LS20 recommends a request count of 100, but according to the
   * APAR text it does not lead to missing files, just to funny
   * numbers of returned entries.
   *
   * LS30 HPFS386 requires a count greater than 2, or some files
   * are missing (those starting with a character less that '.').
   *
   * Novell loses entries which overflow the buffer. In previous
   * versions of dirent2, this could have lead to missing files
   * when the average length of 100 directory entries was 40 bytes
   * or more (quite unlikely for files on a Novell server).
   *
   * Conclusion: Make sure that the entries all fit into the buffer
   * and that the buffer is large enough for more than 2 entries
   * (each entry is at most 300 bytes long). And ignore the LS20
   * effect.
   */
#define Count 25
#define BufSz (25 * (sizeof(FILEFINDBUF3) + 1))
#else
#define FFBUF FILEFINDBUF
#define Word USHORT
#define BufSz 1024
#define Count 3
#endif

#if defined(__IBMC__) || defined(__IBMCPP__)
#define error(rc) _doserrno = rc, errno = EOS2ERR
#elif defined(MICROSOFT)
#define error(rc) _doserrno = rc, errno = 255
#else
#define error(rc) errno = 255
#endif

struct _dirdescr {
    HDIR handle;               /* DosFindFirst handle */
    char fstype;               /* filesystem type */
    Word count;                /* valid entries in <ffbuf> */
    long number;               /* absolute number of next entry */
    int index;                 /* relative number of next entry */
    FFBUF *next;               /* pointer to next entry */
    char name[MAXPATHLEN + 3]; /* directory name */
    unsigned attrmask;         /* attribute mask for seekdir */
    struct dirent entry;       /* buffer for directory entry */
    BYTE ffbuf[BufSz];
};

/*
 * Return first char of filesystem type, or 0 if unknown.
 */
static char
getFSType(const char *path)
{
    static char cache[1 + 26];
    char drive[3], info[512];
    Word unit, infolen;
    char r;

    if (isalpha(path[0]) && path[1] == ':') {
        unit = toupper(path[0]) - '@';
        path += 2;
    } else {
        ULONG driveMap;
#if OS2 >= 2
        if (DosQueryCurrentDisk(&unit, &driveMap))
#else
        if (DosQCurDisk(&unit, &driveMap))
#endif
            return 0;
    }

    if ((path[0] == '\\' || path[0] == '/') &&
        (path[1] == '\\' || path[1] == '/'))
        return 0;

    if (cache[unit])
        return cache[unit];

    drive[0] = '@' + unit;
    drive[1] = ':';
    drive[2] = '\0';
    infolen = sizeof info;
#if OS2 >= 2
    if (DosQueryFSAttach(drive, 0, FSAIL_QUERYNAME, (PVOID)info, &infolen))
        return 0;
    if (infolen >= sizeof(FSQBUFFER2)) {
        FSQBUFFER2 *p = (FSQBUFFER2 *)info;
        r = p->szFSDName[p->cbName];
    } else
#else
    if (DosQFSAttach((PSZ)drive, 0, FSAIL_QUERYNAME, (PVOID)info, &infolen, 0))
        return 0;
    if (infolen >= 9) {
        char *p = info + sizeof(USHORT);
        p += sizeof(USHORT) + *(USHORT *)p + 1 + sizeof(USHORT);
        r = *p;
    } else
#endif
        r = 0;
    return cache[unit] = r;
}

char *
abs_path(const char *name, char *buffer, int len)
{
    char buf[4];
    if (isalpha(name[0]) && name[1] == ':' && name[2] == '\0') {
        buf[0] = name[0];
        buf[1] = name[1];
        buf[2] = '.';
        buf[3] = '\0';
        name = buf;
    }
#if OS2 >= 2
    if (DosQueryPathInfo((PSZ)name, FIL_QUERYFULLNAME, buffer, len))
#else
    if (DosQPathInfo((PSZ)name, FIL_QUERYFULLNAME, (PBYTE)buffer, len, 0L))
#endif
        return NULL;
    return buffer;
}

DIR *
openxdir(const char *path, unsigned att_mask)
{
    DIR *dir;
    char name[MAXPATHLEN + 3];
    Word rc;

    dir = malloc(sizeof(DIR));
    if (dir == NULL) {
        errno = ENOMEM;
        return NULL;
    }

    strncpy(name, path, MAXPATHLEN);
    name[MAXPATHLEN] = '\0';
    switch (name[strlen(name) - 1]) {
        default:
            strcat(name, "\\");
        case '\\':
        case '/':
        case ':':;
    }
    strcat(name, ".");
    if (!abs_path(name, dir->name, MAXPATHLEN + 1))
        strcpy(dir->name, name);
    if (dir->name[strlen(dir->name) - 1] == '\\')
        strcat(dir->name, "*");
    else
        strcat(dir->name, "\\*");

    dir->fstype = getFSType(dir->name);
    dir->attrmask = att_mask | A_DIR;

    dir->handle = HDIR_CREATE;
    dir->count = 100;
#if OS2 >= 2
    rc = DosFindFirst(dir->name, &dir->handle, dir->attrmask,
                      dir->ffbuf, sizeof dir->ffbuf, &dir->count, FIL_STANDARD);
#else
    rc = DosFindFirst((PSZ)dir->name, &dir->handle, dir->attrmask,
                      (PFILEFINDBUF)dir->ffbuf, sizeof dir->ffbuf, &dir->count, 0);
#endif
    switch (rc) {
        default:
            free(dir);
            error(rc);
            return NULL;
        case NO_ERROR:
        case ERROR_NO_MORE_FILES:;
    }

    dir->number = 0;
    dir->index = 0;
    dir->next = (FFBUF *)dir->ffbuf;

    return (DIR *)dir;
}

DIR *
opendir(const char *pathname)
{
    return openxdir(pathname, 0);
}

struct dirent *
readdir(DIR *dir)
{
    static int dummy_ino = 2;

    if (dir->index == dir->count) {
        Word rc;
        dir->count = 100;
#if OS2 >= 2
        rc = DosFindNext(dir->handle, dir->ffbuf,
                         sizeof dir->ffbuf, &dir->count);
#else
        rc = DosFindNext(dir->handle, (PFILEFINDBUF)dir->ffbuf,
                         sizeof dir->ffbuf, &dir->count);
#endif
        if (rc) {
            error(rc);
            return NULL;
        }

        dir->index = 0;
        dir->next = (FFBUF *)dir->ffbuf;
    }

    if (dir->index == dir->count)
        return NULL;

    memcpy(dir->entry.d_name, dir->next->achName, dir->next->cchName);
    dir->entry.d_name[dir->next->cchName] = '\0';
    dir->entry.d_ino = dummy_ino++;
    dir->entry.d_reclen = dir->next->cchName;
    dir->entry.d_namlen = dir->next->cchName;
    dir->entry.d_size = dir->next->cbFile;
    dir->entry.d_attribute = dir->next->attrFile;
    dir->entry.d_time = *(USHORT *)&dir->next->ftimeLastWrite;
    dir->entry.d_date = *(USHORT *)&dir->next->fdateLastWrite;

    switch (dir->fstype) {
        case 'F': /* FAT */
        case 'C': /* CDFS */
            if (dir->next->attrFile & FILE_DIRECTORY)
                strupr(dir->entry.d_name);
            else
                strlwr(dir->entry.d_name);
    }

#if OS2 >= 2
    dir->next = (FFBUF *)((BYTE *)dir->next + dir->next->oNextEntryOffset);
#else
    dir->next = (FFBUF *)((BYTE *)dir->next->achName + dir->next->cchName + 1);
#endif
    ++dir->number;
    ++dir->index;

    return &dir->entry;
}

long
telldir(DIR *dir)
{
    return dir->number;
}

void
seekdir(DIR *dir, long off)
{
    if (dir->number > off) {
        char name[MAXPATHLEN + 2];
        Word rc;

        DosFindClose(dir->handle);

        strcpy(name, dir->name);
        strcat(name, "*");

        dir->handle = HDIR_CREATE;
        dir->count = 32767;
#if OS2 >= 2
        rc = DosFindFirst(name, &dir->handle, dir->attrmask,
                          dir->ffbuf, sizeof dir->ffbuf, &dir->count, FIL_STANDARD);
#else
        rc = DosFindFirst((PSZ)name, &dir->handle, dir->attrmask,
                          (PFILEFINDBUF)dir->ffbuf, sizeof dir->ffbuf, &dir->count, 0);
#endif
        switch (rc) {
            default:
                error(rc);
                return;
            case NO_ERROR:
            case ERROR_NO_MORE_FILES:;
        }

        dir->number = 0;
        dir->index = 0;
        dir->next = (FFBUF *)dir->ffbuf;
    }

    while (dir->number < off && readdir(dir))
        ;
}

void
closedir(DIR *dir)
{
    DosFindClose(dir->handle);
    free(dir);
}

/*****************************************************************************/

#ifdef TEST

main(int argc, char **argv)
{
    int i;
    DIR *dir;
    struct dirent *ep;

    for (i = 1; i < argc; ++i) {
        dir = opendir(argv[i]);
        if (!dir)
            continue;
        while (ep = readdir(dir))
            if (strchr("\\/:", argv[i][strlen(argv[i]) - 1]))
                printf("%s%s\n", argv[i], ep->d_name);
            else
                printf("%s/%s\n", argv[i], ep->d_name);
        closedir(dir);
    }

    return 0;
}

#endif

#endif /* OS2 */