path: root/tandem/tandem.c

/*
  Copyright (c) 1990-2002 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2000-Apr-09 or later
  (the contents of which are also included in zip.h) for terms of use.
  If, for some reason, all these files are missing, the Info-ZIP license
  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
*/
/*
 * routines common to TANDEM (ZIP and UNZIP)
 */

#include "zip.h"   /* This sets up ZIP / UNZIP define */

#include <tal.h>
#include "$system.zsysdefs.zsysc" nolist
#include <cextdecs> nolist
#include "tannsk.h"

static time_t gmt_to_time_t (long long *);

int isatty (fnum)
int fnum;
{
  return 1;
}

/********************/
/* Function in2ex() */
/********************/

#ifdef UNZIP
char *in2ex(__G__ n)
  __GDEF
#else
char *in2ex(n)
#endif
  char *n;              /* internal file name */
/* Convert the zip file name to an external file name, returning the malloc'ed
   string or NULL if not enough memory. */
{
  char *x;              /* external file name buffer */
  char *y;              /* pointer to external buffer */
  char *max;            /* pointer to max end of next file part */
  char *t;              /* pointer to internal - start of substring */
  char *p;              /* pointer to internal - TANDEM delimiter */
  char *e;              /* pointer to internal - DOS extension delimiter */
  char *z;              /* pointer to internal - end of substring */
  int len;              /* length of substring to copy to external name */
  int allow_dollar;     /* $ symbol allowed as next character */

  if ((x = malloc(strlen(n) + 4)) == NULL)  /* + 4 for safety */
    return NULL;

  *x = '\0';

  /* Junk pathname as requested */
#ifdef UNZIP
  if (uO.jflag && (t = strrchr(n, INTERNAL_DELIMITER)) != NULL)
    ++t;
  else
    t = n;
#endif /* UNZIP */
#ifdef ZIP
  if (!pathput)
    t = last(n, INTERNAL_DELIMITER);
  else
    t = n;
#endif /* ZIP */

  allow_dollar = TRUE;

  while (*t != '\0') {  /* File part could be sys, vol, subvol or file */
    if (*t == INTERNAL_DELIMITER) {    /* System, Volume or Subvol Name */
      t++;
      if (*t == INTERNAL_DELIMITER) {  /* System */
        strcat(x, TANDEM_NODE_STR);
        t++;
      }
      else {
        strcat(x, TANDEM_DELIMITER_STR);
        allow_dollar = FALSE;
      }
    }
    /* Work out where end of current external string is */
    y = x + strlen(x);

    /* Work out substring to copy and externalise */
    p = strchr(t, INTERNAL_DELIMITER);
    e = strchr(t, DOS_EXTENSION);
    if (p != NULL) {
      if (e > p)
        e = NULL;
    }

    z = e;
    if (z == NULL)
      z = p;
    if (z == NULL)
      z = t + strlen(t);

    /* can't have Tandem name longer than 8 characters */
    max = y + MAXFILEPARTLEN;

    /* Allow $ symbol as first character in some cases */
    if (*t == '$') {
      if (allow_dollar)
        *y++ = *t++;
      else;
        *t++;
    }

    /* Make sure first real character is alpha */
    if (! isalpha(*t) )
      *y++ = 'A';

    /* Characters left to process */
    len = z - t;

    while ( len > 0 ) {
      if ( isalnum(*t) ) {
        *y++ = toupper(*t++);
        if (y >= max)
          break;
      }
      else
        t++;
      len--;
    }
    *y = '\0';
    t = p;

    if (p == NULL) {
      /* Last part of filename, store pseudo extension if available */
      if (e != NULL) {
        strcat(x, TANDEM_EXTENSION_STR);
        y = x + strlen(x);

        /* no restriction on extension length as its virtual */
        z = e + 1;
        while ( *z != '\0' ) {
          *y++ = toupper(*z++);
        }
        *y = '\0';
      }
      break;
    }
  }

  return x;
}

void zexit(status)
  int status;
{
  /* Exit(>0) creates saveabend files */
  terminate_program (0,0,(short)status,,,);
}

/************************/
/*  Function zputc()    */
/************************/

#ifdef putc
#  undef putc
#endif

int zputc(ch, fptr)
  int ch;
  FILE *fptr;
{
  int err;
  err = putc(ch,fptr);
  fflush(fptr);
  return err;
}
#define putc zputc

#ifdef LICENSED
_tal _priv short FILE_CHANGELABEL_ (
 short,          /* IN */
 short,          /* IN */
 const short _far *    /* IN */
 );

_c _callable int changelabel OF((short, const short *, const short *));

_c _callable int changelabel(fnum, modtime, actime)
  short fnum;
  const short *modtime;
  const short *actime;
{
  int err;

  err = FILE_CHANGELABEL_(fnum, 16, modtime);
  if (!err)
    err = FILE_CHANGELABEL_(fnum, 17, actime);
  return err;
}

int islicensed(void)
{
  #define plist_items 1
  #define plist_size 10

  short myphandle[ZSYS_VAL_PHANDLE_WLEN];
  short licensetag[plist_items] = {37};
  short licensed[plist_size];
  short maxlen = plist_size;
  short items = plist_items;
  short resultlen[1], err;

  err = PROCESSHANDLE_NULLIT_(myphandle);

  if (!err)
    err = PROCESS_GETINFO_(myphandle);

  if (!err)
    err = PROCESS_GETINFOLIST_(/*cpu*/,
                               /*pin*/,
                               /*nodename*/,
                               /*nodenamelen*/,
                               myphandle,
                               licensetag,
                               items,
                               licensed,
                               maxlen,
                               resultlen
                              );

  if (err != 0)
    return 0;
  else
    return licensed[0];
}
#endif /* LICENSED */

int utime(file, time)
  const char *file;
  const ztimbuf *time;
{
#ifdef LICENSED
  int result, err;
  union timestamp_ov {
    long long fulltime;
    short wordtime[4];
  };
  union timestamp_ov lasttime, opentime;
  struct tm *modt, *opent;
  short datetime[8], errormask[1];
  short len, fnum, access, exclus, options;
  char fname[FILENAME_MAX + 1];
  short extension;
  char ext[EXTENSION_MAX + 1];

  if (islicensed() ) {
    /* Attempt to update file label */
    modt = gmtime( &time->modtime );

    datetime[0] = modt->tm_year + 1900;
    datetime[1] = modt->tm_mon + 1;
    datetime[2] = modt->tm_mday;
    datetime[3] = modt->tm_hour;
    datetime[4] = modt->tm_min;
    datetime[5] = modt->tm_sec;
    datetime[6] = datetime[7] = 0;
    errormask[0] = 0;
    lasttime.fulltime = COMPUTETIMESTAMP (datetime, errormask);

    opent = gmtime( &time->actime );

    datetime[0] = opent->tm_year + 1900;
    datetime[1] = opent->tm_mon + 1;
    datetime[2] = opent->tm_mday;
    datetime[3] = opent->tm_hour;
    datetime[4] = opent->tm_min;
    datetime[5] = opent->tm_sec;
    datetime[6] = datetime[7] = 0;
    errormask[0] = 0;
    opentime.fulltime = COMPUTETIMESTAMP (datetime, errormask);

    /* Remove any (pseudo) file extension */
    extension = parsename (file,fname,ext);
    len = strlen(fname);

    access = NSK_WRONLY;
    exclus = NSK_SHARED;
    options = NSK_NOUPDATEOPENTIME;

    extension = parsename (file,fname,ext);
    len = strlen(fname);

    err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
    result = changelabel(fnum,lasttime.wordtime,opentime.wordtime);
    err = FILE_CLOSE_(fnum);
    return result;
  }
  return -1;
#else  /* !LICENSED */
  return 0;             /* "no error", to suppress annoying failure messages */
#endif  /* ?LICENSED */
}

/* TANDEM version of chmod() function */

int chmod(file, unix_sec)
  const char *file;
  mode_t unix_sec;
{
  FILE *stream;
  struct nsk_sec_type {
    unsigned progid : 1;
    unsigned clear  : 1;
    unsigned null   : 2;
    unsigned read   : 3;
    unsigned write  : 3;
    unsigned execute: 3;
    unsigned purge  : 3;
  };
  union nsk_sec_ov {
    struct nsk_sec_type bit_ov;
    short int_ov;
  };
  union nsk_sec_ov nsk_sec;
  short fnum, err, nsk_sec_int;
  short len, access, exclus, extension, options;
  char fname[FILENAME_MAX + 1];
  char ext[EXTENSION_MAX + 1];

  nsk_sec.bit_ov.progid = 0;
  nsk_sec.bit_ov.clear  = 0;
  nsk_sec.bit_ov.null   = 0;

  /*  4="N", 5="C", 6="U", 7="-"   */

  if (unix_sec & S_IROTH) nsk_sec.bit_ov.read = 4;
  else if (unix_sec & S_IRGRP) nsk_sec.bit_ov.read = 5;
  else if (unix_sec & S_IRUSR) nsk_sec.bit_ov.read = 6;
  else nsk_sec.bit_ov.read = 7;

  if (unix_sec & S_IWOTH) nsk_sec.bit_ov.write = 4;
  else if (unix_sec & S_IWGRP) nsk_sec.bit_ov.write = 5;
  else if (unix_sec & S_IWUSR) nsk_sec.bit_ov.write = 6;
  else nsk_sec.bit_ov.write = 7;

  if (unix_sec & S_IXOTH) nsk_sec.bit_ov.execute = 4;
  else if (unix_sec & S_IXGRP) nsk_sec.bit_ov.execute = 5;
  else if (unix_sec & S_IXUSR) nsk_sec.bit_ov.execute = 6;
  else nsk_sec.bit_ov.execute = 7;

  nsk_sec.bit_ov.purge = nsk_sec.bit_ov.write;

  nsk_sec_int = nsk_sec.int_ov;

  access = NSK_RDONLY;
  exclus = NSK_SHARED;
  options = NSK_NOUPDATEOPENTIME;

  extension = parsename (file,fname,ext);
  len = strlen(fname);

  err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
  err = (SETMODE(fnum, SET_FILE_SECURITY, nsk_sec_int) != CCE);
  err = FILE_CLOSE_(fnum);

  return (err != 0 ? -1 : 0);
}

/* TANDEM version of chown() function */

int chown(file, uid, gid)
  const char *file;
  uid_t uid;
  gid_t gid;
{
  FILE *stream;
  struct nsk_own_type {
    unsigned group  : 8;
    unsigned user   : 8;
  };
  union nsk_own_ov {
    struct nsk_own_type bit_ov;
    short int_ov;
  };
  union nsk_own_ov nsk_own;
  short fnum, err, nsk_own_int;
  short len, access, exclus, extension, options;
  char fname[FILENAME_MAX + 1];
  char ext[EXTENSION_MAX + 1];

  nsk_own.bit_ov.group = gid;
  nsk_own.bit_ov.user  = uid;

  nsk_own_int = nsk_own.int_ov;

  access = NSK_RDONLY;
  exclus = NSK_SHARED;
  options = NSK_NOUPDATEOPENTIME;

  extension = parsename (file,fname,ext);
  len = strlen(fname);

  err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
  err = (SETMODE(fnum, SET_FILE_OWNER, nsk_own_int) != CCE);
  err = FILE_CLOSE_(fnum);
  return (err != 0 ? -1 : 0);
}

/* TANDEM version of getch() - non-echo character reading */
int zgetch(void)
{
  char ch;
  short f, err, count, fnum, rlen;

  rlen = 1;
  f = (short)fileno(stdin);
  fnum = fdtogfn (f);
  #define ECHO_MODE 20
  err = (SETMODE(fnum, ECHO_MODE, 0) != CCE);
  err = (READX(fnum, &ch, rlen, (short *) &count) != CCE);
  err = (SETMODE(fnum, ECHO_MODE, 1) != CCE);

  if (err)
    if (err != 1)
      return EOF;
    else
      ch = 'q';
  else
    if (count == 0)
      ch = '\r';

  return (int)ch;
}

short parsename(srce, fname, ext)
  const char *srce;
  char *fname;
  char *ext;
{
  /* As a way of supporting DOS extensions from Tandem we look for a space
     separated extension string after the Guardian filename
     e.g. ZIP ZIPFILE "$DATA4.TESTING.INVOICE TXT"
  */

  char *fstart;
  char *fptr;
  short extension = 0;

  *fname = *ext = '\0';  /* set to null string */

  fstart = (char *) srce;

  if ((fptr = strrchr(fstart, TANDEM_EXTENSION)) != NULL) {
    extension = 1;

    fptr++;
    strncat(ext, fptr, _min(EXTENSION_MAX, strlen(fptr)));

    fptr = strchr(fstart, TANDEM_EXTENSION);  /* End of filename */
    strncat(fname, fstart, _min(FILENAME_MAX, (fptr - fstart)));
  }
  else {
    /* just copy string */
    strncat(fname, srce, _min(FILENAME_MAX, strlen(srce)));
  }

  return extension;
}

static time_t gmt_to_time_t (gmt)
  long long *gmt;
{
  #define GMT_TO_LCT 0
  #define GMT_TO_LST 1

  struct tm temp_tm;
  short  date_time[8];
  long   julian_dayno;
  long long lct, lst, itime;
  short  err[1], type;

  type = GMT_TO_LCT;
  lct = CONVERTTIMESTAMP(*gmt, type,, err);

  if (!err[0]) {
    type = GMT_TO_LST;
    lst = CONVERTTIMESTAMP(*gmt, type,, err);
  }

  itime = (err[0] ? *gmt : lct);
  /* If we have no DST in force then make sure we give it a value,
     else mktime screws up if we set the isdst flag to -1 */
  temp_tm.tm_isdst = (err[0] ? 0 : ((lct == lst) ? 0 : 1));

  julian_dayno = INTERPRETTIMESTAMP(itime, date_time);

  temp_tm.tm_sec   = date_time[5];
  temp_tm.tm_min   = date_time[4];
  temp_tm.tm_hour  = date_time[3];
  temp_tm.tm_mday  = date_time[2];
  temp_tm.tm_mon   = date_time[1] - 1;     /* C's so sad */
  temp_tm.tm_year  = date_time[0] - 1900;  /* it's almost funny */

  return (mktime(&temp_tm));
}

/* TANDEM version of stat() function */
int stat(n, s)
  const char *n;
  struct stat *s;
{
  #define ilist_items 26
  #define klist_items 4
  #define slist_items 3
  #define ulist_items 1
  #define flist_size 100

  short err, i, extension;
  char fname[FILENAME_MAX + 1];
  short fnamelen;
  char ext[EXTENSION_MAX + 1];

                         /* #0  #1  #2  #3  #4  #5  #6  #7  #8  #9 */
  short ilist[ilist_items]={56,144, 54,142, 58, 62, 60, 41, 42, 44,
                            50, 51, 52, 61, 63, 66, 67, 70, 72, 73,
                            74, 75, 76, 77, 78, 79                 };
  short ilen[ilist_items] ={ 4,  4,  4,  2,  1,  2,  1,  1,  1,  1,
                             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
                             1,  1,  1,  1,  1,  1                 };
  short ioff[ilist_items];

                         /* #0  #1  #2  #3  #4  #5  #6  #7  #8  #9 */
  short klist[klist_items]={45, 46, 68, 69                         };
  short klen[klist_items] ={ 1,  1,  1,  1                         };
  short koff[klist_items];

                         /* #0  #1  #2  #3  #4  #5  #6  #7  #8  #9 */
  short slist[slist_items]={43, 80, 90                             };
  short slen[slist_items] ={ 1,  1,  1                             };
  short soff[slist_items];

                         /* #0  #1  #2  #3  #4  #5  #6  #7  #8  #9 */
  short ulist[ulist_items]={65                                     };
  short ulen[ulist_items] ={ 1                                     };
  short uoff[ulist_items];

  short flist[flist_size];
  short extra[2];
  short *rlen=&extra[0];
  short *err_item=&extra[1];
  unsigned short *fowner;
  unsigned short *fprogid;
  char *fsec;

  nsk_stat_ov *nsk_ov;
  nsk_file_attrs *nsk_attr;

  short end, count, kind, level, options, searchid;
  short info[5];

  /* Initialise stat structure */
  s->st_dev = _S_GUARDIANOBJECT;
  s->st_ino = 0;
  s->st_nlink = 0;
  s->st_rdev = 0;
  s->st_uid = s->st_gid = 0;
  s->st_size = 0;
  s->st_atime = s->st_ctime = s->st_mtime = 0;
  s->st_reserved[0] = 0;
  s->st_reserved[1] = 0;
  s->st_reserved[2] = 0;
  nsk_ov = (nsk_stat_ov *)&s->st_reserved[0];
  nsk_attr = (nsk_file_attrs *)&nsk_ov->ov.nsk_ef_region;

  /* Check to see if name contains a (pseudo) file extension */
  extension = parsename (n,fname,ext);

  fnamelen = strlen(fname);

  options = 3; /* Allow Subvols and Templates */
  err = FILENAME_SCAN_( fname,
                        fnamelen,
                        &count,
                        &kind,
                        &level,
                        options
                      );

  /* allow kind == 2 (DEFINE names) */
  if (err != 0) return -1;

  if (kind == 1 || (kind == 0 && level < 2)) {
    /* Pattern, Subvol Name or One part Filename - lets see if it exists */
    err = FILENAME_FINDSTART_ ( &searchid,
                                fname,
                                fnamelen,
                                ,
                                DISK_DEVICE
                              );

    if (err != 0) {
      end = FILENAME_FINDFINISH_ ( searchid );
      return -1;
    }

    err = FILENAME_FINDNEXT_ ( searchid,
                               fname,
                               FILENAME_MAX,
                               &fnamelen,
                               info
                              );
    end = FILENAME_FINDFINISH_ ( searchid );

    if (err != 0)
      return -1;  /* Non existing template, subvol or file */

    if (kind == 1 || info[2] == -1) {
      s->st_mode = S_IFDIR;    /* Its an existing template or directory */
      return 0;
    }

    /* Must be a real file so drop to code below to get info on it */
  }

  err = FILE_GETINFOLISTBYNAME_( fname,
                                 fnamelen,
                                 ilist,
                                 ilist_items,
                                 flist,
                                 flist_size,
                                 rlen,
                                 err_item
                               );
  if (err != 0) return -1;

  ioff[0] = 0;

  /*  Build up table of offets into result list */
  for (i=1; i < ilist_items; i++)
    ioff[i] = ioff[i-1] + ilen[i-1];

  /* Set up main stat fields */

  /* Setup timestamps */
  s->st_atime = gmt_to_time_t ((long long *)&flist[ioff[0]]);
  s->st_mtime = s->st_ctime = gmt_to_time_t ((long long *)&flist[ioff[1]]);
  nsk_ov->ov.creation_time = gmt_to_time_t ((long long *)&flist[ioff[2]]);

  s->st_size = *(off_t *)&flist[ioff[3]];

  fowner = (unsigned short *)&flist[ioff[4]];
  s->st_uid = *fowner & 0x00ff;
  s->st_gid = *fowner >> 8;

  /* Note that Purge security (fsec[3]) in NSK has no relevance to stat() */
  fsec = (char *)&flist[ioff[5]];
  fprogid = (unsigned short *)&flist[ioff[6]];

  s->st_mode = S_IFREG |  /* Regular File */
  /*  Parse Read Flag */
               ((fsec[0] & 0x03) == 0x00 ? S_IROTH : 0) |
               ((fsec[0] & 0x02) == 0x00 ? S_IRGRP : 0) |
               ((fsec[0] & 0x03) != 0x03 ? S_IRUSR : 0) |
  /*  Parse Write Flag */
               ((fsec[1] & 0x03) == 0x00 ? S_IWOTH : 0) |
               ((fsec[1] & 0x02) == 0x00 ? S_IWGRP : 0) |
               ((fsec[1] & 0x03) != 0x03 ? S_IWUSR : 0) |
  /*  Parse Execute Flag */
               ((fsec[2] & 0x03) == 0x00 ? S_IXOTH : 0) |
               ((fsec[2] & 0x02) == 0x00 ? S_IXGRP : 0) |
               ((fsec[2] & 0x03) != 0x03 ? S_IXUSR : 0) |
  /*  Parse Progid */
               (*fprogid == 1 ? (S_ISUID | S_ISGID) : 0) ;

  /* Set up NSK additional stat fields */
  nsk_attr->progid   = (unsigned) flist[ioff[6]];
  nsk_attr->filetype = (unsigned) flist[ioff[7]];
  nsk_attr->filecode = (unsigned) flist[ioff[8]];
  nsk_attr->block    = (unsigned short) flist[ioff[9]];
  nsk_attr->priext   = (unsigned short) flist[ioff[10]];
  nsk_attr->secext   = (unsigned short) flist[ioff[11]];
  nsk_attr->maxext   = (unsigned short) flist[ioff[12]];
  nsk_attr->flags.clearonpurge = (unsigned) flist[ioff[13]];
  nsk_attr->licensed     = (unsigned) flist[ioff[14]];
  nsk_attr->flags.audited      = (unsigned) flist[ioff[15]];
  nsk_attr->flags.acompress    = (unsigned) flist[ioff[16]];
  nsk_attr->flags.refresheof   = (unsigned) flist[ioff[17]];
  nsk_attr->flags.buffered     = (unsigned) (flist[ioff[18]] == 0 ? 1 : 0);
  nsk_attr->flags.verified     = (unsigned) flist[ioff[19]];
  nsk_attr->flags.serial       = (unsigned) flist[ioff[20]];
  nsk_attr->flags.crashopen    = (unsigned) flist[ioff[22]];
  nsk_attr->flags.rollforward  = (unsigned) flist[ioff[23]];
  nsk_attr->flags.broken       = (unsigned) flist[ioff[24]];
  nsk_attr->flags.corrupt      = (unsigned) flist[ioff[25]];
  nsk_attr->fileopen     = (unsigned) flist[ioff[21]];


  if (nsk_attr->filetype == NSK_UNSTRUCTURED) {
    /* extra info for Unstructured files */
    err = FILE_GETINFOLISTBYNAME_( fname,
                                   fnamelen,
                                   ulist,
                                   ulist_items,
                                   flist,
                                   flist_size,
                                   rlen,
                                   err_item
                                 );
    if (err != 0) return -1;

    uoff[0] = 0;

    /*  Build up table of offets into result list */
    for (i=1; i < ulist_items; i++)
      uoff[i] = uoff[i-1] + ulen[i-1];
  }
  else {
    /* extra info for Structured files */
    err = FILE_GETINFOLISTBYNAME_( fname,
                                   fnamelen,
                                   slist,
                                   slist_items,
                                   flist,
                                   flist_size,
                                   rlen,
                                   err_item
                                 );
    if (err != 0) return -1;

    soff[0] = 0;

    /*  Build up table of offets into result list */
    for (i=1; i < slist_items; i++)
      soff[i] = soff[i-1] + slen[i-1];

    nsk_attr->reclen   = (unsigned) flist[soff[0]];
    nsk_attr->flags.secpart   = (unsigned) flist[soff[1]];
    nsk_attr->flags.primpart  = (unsigned)
     ( (flist[soff[2]] > 0 && nsk_attr->flags.secpart == 0) ? 1 : 0 );

    if (nsk_attr->filetype == NSK_KEYSEQUENCED) {
      /* extra info for Key Sequenced files */
      err = FILE_GETINFOLISTBYNAME_( fname,
                                     fnamelen,
                                     klist,
                                     klist_items,
                                     flist,
                                     flist_size,
                                     rlen,
                                     err_item
                                   );
      if (err != 0) return -1;

      koff[0] = 0;

      /*  Build up table of offets into result list */
      for (i=1; i < klist_items; i++)
        koff[i] = koff[i-1] + klen[i-1];

      nsk_attr->keyoff   = (unsigned) flist[koff[0]];
      nsk_attr->keylen   = (unsigned) flist[koff[1]];
      nsk_attr->flags.dcompress = (unsigned) flist[koff[2]];
      nsk_attr->flags.icompress = (unsigned) flist[koff[3]];
    }
  }

  return 0;
}

#ifndef SFX
/* TANDEM Directory processing */

DIR *opendir(const char *dirname)
{
   short i, resolve;
   char sname[FILENAME_MAX + 1];
   short snamelen;
   char fname[FILENAME_MAX + 1];
   short fnamelen;
   char *p;
   short searchid, err, end;
   struct dirent *entry;
   DIR *dirp;
   char ext[EXTENSION_MAX + 1];
   short extension;

   extension = parsename(dirname, sname, ext);
   snamelen = strlen(sname);

   /*  First we work out how detailed the template is...
    *  e.g. If the template is DAVES*.* we want the search result
    *       in the same format
    */

   p = sname;
   i = 0;
   while ((p = strchr(p, TANDEM_DELIMITER)) != NULL){
     i++;
     p++;
   };
   resolve = 2 - i;

   /*  Attempt to start a filename template */
   err = FILENAME_FINDSTART_ ( &searchid,
                               sname,
                               snamelen,
                               resolve,
                               DISK_DEVICE
                             );
   if (err != 0) {
     end = FILENAME_FINDFINISH_(searchid);
     return NULL;
   }

   /* Create DIR structure */
   if ((dirp = malloc(sizeof(DIR))) == NULL ) {
     end = FILENAME_FINDFINISH_(searchid);
     return NULL;
   }
   dirp->D_list = dirp->D_curpos = NULL;
   strcpy(dirp->D_path, dirname);

   while ((err = FILENAME_FINDNEXT_(searchid,
                                    fname,
                                    FILENAME_MAX,
                                    &fnamelen
                                   )
           ) == 0 ){
     /*  Create space for entry */
     if ((entry = malloc (sizeof(struct dirent))) == NULL) {
       end = FILENAME_FINDFINISH_(searchid);
       return NULL;
     }

     /*  Link to last entry */
     if (dirp->D_curpos == NULL)
       dirp->D_list = dirp->D_curpos = entry;  /* First name */
     else {
       dirp->D_curpos->d_next = entry;         /* Link */
       dirp->D_curpos = entry;
     };
     /* Add directory entry */
     *dirp->D_curpos->d_name = '\0';
     strncat(dirp->D_curpos->d_name,fname,fnamelen);
     if (extension) {
       strcat(dirp->D_curpos->d_name,TANDEM_EXTENSION_STR);
       strcat(dirp->D_curpos->d_name,ext);
     };
     dirp->D_curpos->d_next = NULL;
   };

   end = FILENAME_FINDFINISH_(searchid);

   if (err == 1) {  /*  Should return EOF at end of search */
     dirp->D_curpos = dirp->D_list;        /* Set current pos to start */
     return dirp;
   }
   else
     return NULL;
}

struct dirent *readdir(DIR *dirp)
{
   struct dirent *cur;

   cur = dirp->D_curpos;
   dirp->D_curpos = dirp->D_curpos->d_next;
   return cur;
}

void rewinddir(DIR *dirp)
{
   dirp->D_curpos = dirp->D_list;
}

int closedir(DIR *dirp)
{
   struct dirent *node;

   while (dirp->D_list != NULL) {
      node = dirp->D_list;
      dirp->D_list = dirp->D_list->d_next;
      free( node );
   }
   free( dirp );
   return 0;
}

#endif /* !SFX */