home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c019 / 2.ddi / SOURCE / FILEIO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-10  |  65.1 KB  |  2,503 lines
  1. /*
  2.  
  3.  Copyright (C) 1990-1993 Mark Adler, Richard B. Wales, Jean-loup Gailly,
  4.  Kai Uwe Rommel and Igor Mandrichenko.
  5.  Permission is granted to any individual or institution to use, copy, or
  6.  redistribute this software so long as all of the original files are included,
  7.  that it is not sold for profit, and that this copyright notice is retained.
  8.  
  9. */
  10.  
  11. /*
  12.  *  fileio.c by Mark Adler.
  13.  *
  14.  *  This file has become a big mess over time, and will be split in the
  15.  *  next version, one file per operating system.
  16.  */
  17.  
  18. #include "zip.h"
  19.  
  20. #include <time.h>
  21.  
  22. #ifdef WIN32
  23. #  include <sys/utime.h>
  24. #  include <windows.h> /* for findfirst/findnext */
  25.    char *GetLongPathEA OF((char *name));
  26. #endif
  27.  
  28. #ifdef MACOS
  29. #  define EXDEV 1
  30. #endif
  31.  
  32. #ifdef OSF
  33. #  define EXDEV 18    /* avoid a bug in the DEC OSF/1 header files. */
  34. #else
  35. #  include <errno.h>
  36. #endif
  37.  
  38. #ifdef MINIX
  39. #  ifdef S_IWRITE
  40. #    undef S_IWRITE
  41. #  endif /* S_IWRITE */
  42. #  define S_IWRITE S_IWUSR
  43. #endif /* S_IWUSR */
  44.  
  45. #ifdef ATARI_ST
  46. #  undef MSDOS
  47. #endif
  48.  
  49. #if defined(MSDOS) && !defined(__GO32__)
  50. #  include <io.h>
  51. #  ifdef __TURBOC__
  52. #    include <dir.h>
  53. #  else /* !__TURBOC__ */
  54. #    if !defined(__EMX__) && !defined(__WATCOMC__)
  55. #      include <direct.h>
  56. #    endif
  57. #  endif /* ?__TURBOC__ */
  58. #  define link rename
  59. #  if defined(OS2) || defined(WIN32)
  60. #    define MATCH shmatch
  61. #  else
  62. #    define MATCH dosmatch
  63. #  endif
  64. #else /* !MSDOS */
  65.    extern int errno;    /* error number from system functions */
  66. #  ifdef TOPS20
  67. #    define PATH_START '<'
  68. #    define PATH_END   '>'
  69. #    define link rename
  70. #  endif
  71. #  ifdef VMS
  72. #    define PATH_START '['
  73. #    define PATH_END ']'
  74. #    define RMDIR
  75. #    define link rename
  76. #    include "VMSmunch.h"
  77. #  endif /* VMS */
  78. #  ifdef MACOS
  79. #    define link rename
  80. #    define mktemp tmpnam
  81. #  endif
  82. #  define MATCH shmatch
  83. #endif /* ?MSDOS */
  84.  
  85. #ifdef ATARI_ST
  86. #  define MSDOS 1
  87. #endif
  88.  
  89. #ifdef UTS
  90. #  define RMDIR
  91. #endif /* UTS */
  92.  
  93. #ifdef AMIGA
  94. #  define link rename
  95. #  define utime FileDate
  96. #  ifdef __SASC_60
  97. #    include <dos.h>               /* SAS/C 6.x , pulled by wild() */
  98. #    include <sys/dir.h>
  99. #    define direct dirent
  100. #    define disk_not_mounted 0  
  101. #  else
  102. #    define dirent direct
  103. #  endif
  104. #  ifdef MODERN
  105. #    include <clib/exec_protos.h>
  106. #    include <clib/dos_protos.h>
  107. #  endif
  108. #  ifdef AZTEC_C
  109. #    include <pragmas/exec_lib.h>
  110. #    include <pragmas/dos_lib.h>
  111. #  endif
  112. #endif 
  113.  
  114. #ifdef __human68k__
  115. #  include <jctype.h>
  116. #  define link rename
  117. #endif
  118.  
  119. /* Extra malloc() space in names for cutpath() */
  120. #if (defined(VMS) || defined(TOPS20))
  121. #  define PAD 5         /* may have to change .FOO] to ]FOO.DIR;1 */
  122. #else
  123. #  define PAD 0
  124. #  define PATH_END '/'
  125. #endif
  126.  
  127.  
  128. #ifdef VMS
  129. #  include <descrip.h>
  130. #  include <rms.h>
  131. #endif
  132.  
  133. /* For directory access. */
  134.  
  135. #ifndef UTIL
  136.  
  137. #ifdef __human68k__
  138. #include <sys/dos.h>
  139. #endif
  140.  
  141. #if defined(SYSV) || defined(__GO32__) || defined(__386BSD__) || defined(__human68k__)
  142. /* use readdir() */
  143. #  include <dirent.h>
  144. #  define dstrm DIR
  145. #  define direct dirent
  146. #else /* !SYSV && !__GO32__ && !__386BSD__ && !__human68k__*/
  147.  
  148. #ifdef DIRENT                   /* use getdents() */
  149. #ifndef TOPS20
  150. #  if defined(MINIX) || defined(OSF)
  151. #    include <dirent.h>
  152. #  else /* !MINIX */
  153. #    include <sys/dirent.h>
  154. #  endif /* ?MINIX */
  155. #  define direct dirent
  156. #  ifdef MINIX
  157.      int getdents OF((int, char *, unsigned));
  158. #  else /* !MINIX */
  159.      int getdents OF((int, char *, int));
  160. #  endif /* ?MINIX */
  161. #  define DBSZ 4096     /* This has to be bigger than a directory block */
  162.    typedef struct {     /* directory stream buffer */
  163.      int f;             /* file descriptor for the directory "file" */
  164.      char *p;           /* pointer to next entry in buffer */
  165.      char *q;           /* pointer after end of buffer contents */
  166.      char b[DBSZ];              /* buffer */
  167.    } dstrm;
  168.  
  169. #else /* TOPS20 */
  170. #  define TRUE 1
  171. #  define FALSE 0
  172. #  define O_RDONLY (0)
  173. #  define O_T20_WILD (1<<18)
  174. #  include <monsym.h>    /* Get amazing monsym() macro */
  175.    extern int jsys(), fstat();
  176.    extern char *getcwd();
  177.    extern int _gtjfn(), _rljfn();
  178. #  define JSYS_CLASS    0070000000000
  179. #  define FLD(val,mask) (((unsigned)(val)*((mask)&(-(mask))))&(mask))
  180. #  define _DEFJS(name,class) (FLD(class, JSYS_CLASS) | (monsym(name)&0777777))
  181. #  define JFNS  _DEFJS("JFNS%", 1)
  182. #  define GNJFN _DEFJS("GNJFN%", 0)
  183.    static int wfopen(), wfnext(), strlower(), strupper();
  184.    static char *wfname();
  185.    typedef struct {
  186.      int  wfjfn;
  187.      int  more;
  188.    } dstrm;
  189. #endif /* ?TOPS20 */
  190.  
  191. #else /* !DIRENT */             /* use opendir(), etc. */
  192. #  if defined(CONVEX) || defined(ultrix)
  193. #    include <dirent.h>
  194. #    ifdef direct
  195. #      undef direct /* ultrix 4.2, at least if !__POSIX */
  196. #    endif
  197. #    define direct dirent
  198. #  endif /* CONVEX || ultrix */
  199. #  ifdef NDIR
  200. #    include "ndir.h"           /* for HPUX */
  201. #  else /* !NDIR */
  202. #    ifdef MSDOS
  203. #     ifdef OS2
  204. #      include "os2zip.h"
  205. #     else /* !OS2 */
  206. #      ifdef WIN32
  207. #        include "ntzip.h"
  208. #      endif
  209. #      ifndef ATARI_ST
  210. #        include <dos.h>
  211. #      endif
  212. #      ifdef __TURBOC__
  213. #        define FATTR (hidden_files ? FA_HIDDEN+FA_SYSTEM+FA_DIREC : FA_DIREC)
  214. #        define FFIRST(n,d,a)   findfirst(n,(struct ffblk *)d,a)
  215. #        define FNEXT(d)        findnext((struct ffblk *)d)
  216. #      else /* !__TURBOC__ */
  217. #        define FATTR (hidden_files ? _A_HIDDEN+_A_SYSTEM+_A_SUBDIR :_A_SUBDIR)
  218. #        define FA_LABEL _A_VOLID
  219. #        define FFIRST(n,d,a)   _dos_findfirst(n,a,(struct find_t *)d)
  220. #        define FNEXT(d)        _dos_findnext((struct find_t *)d)
  221. #      endif /* ?__TURBOC__ */
  222.        typedef struct direct {
  223.          char   reserved [21];
  224.          char   ff_attrib;
  225.          short  ff_ftime;
  226.          short  ff_fdate;
  227.          long   size;
  228. #      ifndef WIN32
  229.          char d_name[13];
  230.          int d_first;
  231. #      else
  232.          char d_name[MAX_PATH];
  233.          int d_first;
  234.          HANDLE d_hFindFile;
  235. #      endif /* WIN32 */
  236.        } DIR;
  237.        typedef DIR ff_dir;
  238. #      define ff_name d_name /* ff_name is used by DJGPP */
  239. #     endif /* ?OS2 */
  240. #    else /* !MSDOS */
  241. #      ifdef VMS
  242. #        include <ssdef.h>
  243.          typedef struct direct {
  244.              int d_wild;                /* flag for wildcard vs. non-wild */
  245.              struct FAB fab;
  246.              struct NAM nam;
  247.              char d_qualwildname[NAM$C_MAXRSS + 1];
  248.              char d_name[NAM$C_MAXRSS + 1];
  249.          } DIR;
  250. #      else /* !VMS */
  251. #        ifdef MACOS
  252.            typedef struct direct {
  253.              int d_wild;                /* flag for wildcard vs. non-wild */
  254.              char *d_name;
  255.           } DIR;
  256. #        endif
  257. #        if defined(M_XENIX) || defined(SYSNDIR)
  258. #          include <sys/ndir.h>
  259. #        else /* !M_XENIX */
  260. #          ifndef AZTEC_C
  261. #            include <sys/dir.h>
  262. #          endif
  263. #        endif /* ?M_XENIX */
  264. #        ifdef NODIR                    /* for AT&T 3B1 + Amiga non SAS */
  265. #          define dirent direct
  266.            typedef FILE DIR;
  267. #        endif /* NODIR */
  268. #      endif /* ?VMS */
  269. #    endif /* ?MSDOS */
  270. #  endif /* ?NDIR */
  271. #  define dstrm DIR
  272. #  if defined(MSDOS) && !defined(OS2)
  273. #    ifndef __GO32__
  274.        DIR *opendir OF((const char *));
  275.        struct direct *readdir OF((DIR *));
  276. #    endif
  277. #    ifndef WIN32
  278.        char *getVolumeLabel OF((int drive, ulg *vtime, ulg *vmode));
  279. #    endif
  280. #  endif
  281. #endif /* ?DIRENT */
  282. #endif /* ?SYSV */
  283. #endif /* !UTIL */
  284.  
  285. #ifdef __GO32__
  286.    typedef struct ffblk ff_dir;
  287. #  define FFIRST(n,d,a)   findfirst(n,(struct ffblk *)d,a)
  288. #endif
  289.  
  290. #define MSDOS_DIR_ATTR 0x10
  291.  
  292. /* Library functions not in (most) header files */
  293.  
  294. #ifdef TOPS20
  295.    extern int stat(), chmod(), toupper(), tolower();
  296. #endif
  297.  
  298. #if defined(__IBMC__) || defined(__WATCOMC__)
  299. #  define NO_MKTEMP
  300. #endif
  301. char *mktemp OF((char *));
  302.  
  303. #ifdef __GO32__
  304. #  include <dos.h>
  305. #else
  306.   /* int link OF((const char *, const char *)); */
  307.   /* int unlink OF((const char *)); */
  308.   /* int chmod OF((const char *, int)); */
  309.   /* For many targets, chmod is already defined by sys/stat.h, and second
  310.    * parameter is an unsigned long.
  311.    */
  312. #endif
  313.  
  314.  
  315. #ifndef UTIL    /* the companion #endif is a bit of ways down ... */
  316.  
  317. #if !defined(__TURBOC__) && !defined(WIN32) && !defined(sgi)
  318.    int utime OF((char *, time_t *));
  319. #endif
  320. #ifndef MSDOS
  321.    /* int open OF((char *, int, ...)); */
  322.    /* int close OF((int)); */
  323. #  ifndef RMDIR
  324.      /* int rmdir OF((const char *)); */
  325. #  endif /* !RMDIR */
  326. #endif /* !MSDOS */
  327.  
  328.  
  329. /* Local globals (kinda like "military intelligence" or "broadcast quality") */
  330. local struct stat zipstatb;
  331. local int zipstate = -1;
  332. /* -1 unknown, 0 old zip file exists, 1 new zip file */
  333.  
  334. local char *label = NULL;
  335. local ulg label_time = 0;
  336. local ulg label_mode = 0;
  337.  
  338. #ifdef VMS
  339.   typedef int statime;
  340. #else /* !VMS */
  341.   typedef time_t statime;
  342. #endif /* ?VMS */
  343.  
  344. /* Local functions */
  345. #ifdef PROTO
  346. #  ifdef VMS
  347.      local void vms_wild(char *, dstrm *);
  348. #  endif /* VMS */
  349. #  ifdef DIRENT
  350.      local dstrm *opend(char *);
  351.      local void closed(dstrm *);
  352. #  endif /* DIRENT */
  353.    local char *readd(dstrm *);
  354.    local int fqcmp(const voidp *, const voidp *);
  355.    local int fqcmpz(const voidp *, const voidp *);
  356.    local char *last(char *);
  357.    local char *msname(char *);
  358. #  ifdef VMS
  359.      local char *strlower(char *);
  360.      local char *strupper(char *);
  361. #  endif /* VMS */
  362.    local int newname(char *, int);
  363.    local void inctime(struct tm *);
  364.    local ulg unix2dostime(statime *);
  365. #  if !defined(__TURBOC__) && !defined(OS2) && !defined(__GO32__)
  366.      local int cmptime(struct tm *, struct tm *);
  367.      local time_t invlocal(struct tm *);
  368. #  endif /* !__TURBOC__ */
  369. #endif /* PROTO */
  370.  
  371.  
  372. #if defined(MSDOS) && !defined(OS2) && !defined(__GO32__)
  373. dstrm *opendir(n)
  374. const char *n;                /* directory to open */
  375. /* Start searching for files in the MSDOS directory n */
  376. {
  377.   dstrm *d;             /* malloc'd return value */
  378.   char *p;              /* malloc'd temporary string */
  379.  
  380.   if ((d = (dstrm *)malloc(sizeof(dstrm))) == NULL ||
  381.       (p = malloc(strlen(n) + 5)) == NULL) {
  382.     if (d != NULL) free((void *) d);
  383.     return NULL;
  384.   }
  385.   strcat(strcpy(p, n), "/");
  386.   strcat(p, "*.*"); /* don't use strcat in one step, TOPS20 is confused */
  387.  
  388. #ifdef WIN32
  389.   {
  390.     WIN32_FIND_DATA fd;
  391.     DWORD dwAttr;
  392.  
  393.     if ( INVALID_HANDLE_VALUE == (d->d_hFindFile = FindFirstFile(p, &fd)))
  394.     {
  395.       free((voidp *)p);
  396.       return NULL;
  397.     }
  398.     strcpy(d->d_name, fd.cFileName);
  399.  
  400.     if (-1 != (dwAttr = GetFileAttributes(fd.cFileName)))
  401.     {
  402.       if (!hidden_files &&
  403.          (FILE_ATTRIBUTE_SYSTEM == (dwAttr & FILE_ATTRIBUTE_SYSTEM) ||
  404.           FILE_ATTRIBUTE_HIDDEN == (dwAttr & FILE_ATTRIBUTE_HIDDEN)))
  405.       {
  406.           free ((voidp *)p);
  407.           d->d_first = 0;
  408.           return d;
  409.       }
  410.     }
  411.   }
  412. #else
  413.   if (FFIRST(p, d, FATTR))
  414.   {
  415.     free((voidp *)p);
  416.     return NULL;
  417.   }
  418.   free((voidp *)p);
  419. #endif
  420.   d->d_first = 1;
  421.   return d;
  422. }
  423.  
  424. struct direct *readdir(d)
  425. dstrm *d;               /* directory stream to read from */
  426. /* Return pointer to first or next directory entry, or NULL if end. */
  427. {
  428.   if (d->d_first)
  429.     d->d_first = 0;
  430.   else
  431. #ifdef WIN32
  432.   {
  433.     WIN32_FIND_DATA fd;
  434.     DWORD dwAttr;
  435.  
  436.     if (!FindNextFile(d->d_hFindFile, &fd))
  437.         return NULL;
  438.  
  439.     strcpy(d->d_name, fd.cFileName);
  440.  
  441.     if (!hidden_files &&
  442.        (-1 != (dwAttr = GetFileAttributes(fd.cFileName))) &&
  443.        (FILE_ATTRIBUTE_SYSTEM == (dwAttr & FILE_ATTRIBUTE_SYSTEM) ||
  444.         FILE_ATTRIBUTE_HIDDEN == (dwAttr & FILE_ATTRIBUTE_HIDDEN)))
  445.     {
  446.         return (readdir(d));
  447.     }
  448.   }
  449. #else /* !WIN32 */
  450.     if (FNEXT(d))
  451.       return NULL;
  452. #endif
  453.   return (struct direct *)d;
  454.  
  455. }
  456. #ifdef WIN32
  457. void closedir(d)
  458. dstrm *d;
  459. {
  460.         FindClose(d->d_hFindFile);
  461.         free(d);
  462. }
  463. #else
  464. #  define closedir free
  465. #endif
  466.  
  467. #endif /* MSDOS && !OS2 && !__GO32__ */
  468.  
  469.  
  470. #ifdef VMS
  471.  
  472. /*---------------------------------------------------------------------------
  473.  
  474.     _vms_findfirst() and _vms_findnext(), based on public-domain DECUS C
  475.     fwild() and fnext() routines (originally written by Martin Minow, poss-
  476.     ibly modified by Jerry Leichter for bintnxvms.c), were written by Greg
  477.     Roelofs and are still in the public domain.  Routines approximate the
  478.     behavior of MS-DOS (MSC and Turbo C) findfirst and findnext functions.
  479.  
  480.   ---------------------------------------------------------------------------*/
  481.  
  482. static char wild_version_part[10]="\0";
  483.  
  484. local void vms_wild(p, d)
  485. char *p;
  486. dstrm *d;
  487. {
  488.   /*
  489.    * Do wildcard setup
  490.    */
  491.   /* set up the FAB and NAM blocks. */
  492.   d->fab = cc$rms_fab;             /* initialize fab */
  493.   d->nam = cc$rms_nam;             /* initialize nam */
  494.  
  495.   d->fab.fab$l_nam = &d->nam;           /* fab -> nam */
  496.   d->fab.fab$l_fna = p;                 /* argument wild name */
  497.   d->fab.fab$b_fns = strlen(p);         /* length */
  498.  
  499.   d->nam.nam$l_esa = d->d_qualwildname; /* qualified wild name */
  500.   d->nam.nam$b_ess = NAM$C_MAXRSS;      /* max length */
  501.   d->nam.nam$l_rsa = d->d_name;         /* matching file name */
  502.   d->nam.nam$b_rss = NAM$C_MAXRSS;      /* max length */
  503.  
  504.   /* parse the file name */
  505.   if (sys$parse(&d->fab) != RMS$_NORMAL)
  506.     return;
  507.   /* Does this replace d->fab.fab$l_fna with a new string in its own space?
  508.      I sure hope so, since p is free'ed before this routine returns. */
  509.  
  510.   /* have qualified wild name (i.e., disk:[dir.subdir]*.*); null-terminate
  511.    * and set wild-flag */
  512.   d->d_qualwildname[d->nam.nam$b_esl] = '\0';
  513.   d->d_wild = (d->nam.nam$l_fnb & NAM$M_WILDCARD)? 1 : 0;   /* not used... */
  514. #ifdef DEBUG
  515.   fprintf(mesg, "  incoming wildname:  %s\n", p);
  516.   fprintf(mesg, "  qualified wildname:  %s\n", d->d_qualwildname);
  517. #endif /* DEBUG */
  518. }
  519.  
  520. dstrm *opendir(n)
  521. char *n;                /* directory to open */
  522. /* Start searching for files in the VMS directory n */
  523. {
  524.   char *c;              /* scans VMS path */
  525.   dstrm *d;             /* malloc'd return value */
  526.   int m;                /* length of name */
  527.   char *p;              /* malloc'd temporary string */
  528.  
  529.   if ((d = (dstrm *)malloc(sizeof(dstrm))) == NULL ||
  530.       (p = malloc((m = strlen(n)) + 4)) == NULL)
  531.     return NULL;
  532.   /* Directory may be in form "[DIR.SUB1.SUB2]" or "[DIR.SUB1]SUB2.DIR;1".
  533.      If latter, convert to former. */
  534.   if (m > 0  &&  *(c = strcpy(p,n)+m-1) != ']')
  535.   {
  536.     while (--c > p  &&  *c != ';')
  537.       ;
  538.     if (c-p < 5  ||  strncmp(c-4, ".DIR", 4))
  539.     {
  540.       free((voidp *)d);  free((voidp *)p);
  541.       return NULL;
  542.     }
  543.     c -= 3;
  544.     *c-- = '\0';        /* terminate at "DIR;#" */
  545.     *c = ']';           /* "." --> "]" */
  546.     while (c > p  &&  *--c != ']')
  547.       ;
  548.     *c = '.';           /* "]" --> "." */
  549.   }
  550.   strcat(p, "*.*");
  551.   strcat(p, wild_version_part);
  552.   vms_wild(p, d);       /* set up wildcard */
  553.   free((voidp *)p);
  554.   return d;
  555. }
  556.  
  557. struct direct *readdir(d)
  558. dstrm *d;               /* directory stream to read from */
  559. /* Return pointer to first or next directory entry, or NULL if end. */
  560. {
  561.   int r;                /* return code */
  562.  
  563.   do {
  564.     d->fab.fab$w_ifi = 0;       /* internal file index:  what does this do? */
  565.  
  566.     /* get next match to possible wildcard */
  567.     if ((r = sys$search(&d->fab)) == RMS$_NORMAL)
  568.     {
  569.         d->d_name[d->nam.nam$b_rsl] = '\0';   /* null terminate */
  570.         return (struct direct *)d;   /* OK */
  571.     }
  572.   } while (r == RMS$_PRV);
  573.   return NULL;
  574. }
  575. #  define closedir free
  576. #endif /* VMS */
  577.  
  578.  
  579. #ifdef NODIR                    /* for AT&T 3B1 */
  580. /*
  581. **  Apparently originally by Rich Salz.
  582. **  Cleaned up and modified by James W. Birdsall.
  583. */
  584.  
  585. #  define opendir(path) fopen(path, "r")
  586.  
  587. struct direct *readdir(dirp)
  588. DIR *dirp;
  589. {
  590.   static struct direct entry;
  591.  
  592.   if (dirp == NULL) 
  593.     return NULL;
  594.   for (;;)
  595.     if (fread (&entry, sizeof (struct direct), 1, dirp) == 0) 
  596.       return NULL;
  597.     else if (entry.d_ino) 
  598.       return (&entry);
  599. } /* end of readdir() */
  600.  
  601. #  define closedir(dirp) fclose(dirp)
  602. #endif /* NODIR */
  603.  
  604.  
  605. #ifdef DIRENT
  606. # ifdef TOPS20
  607. local dstrm *opend(n)
  608. char *n;                /* directory name to open */
  609. /* Open the directory *n, returning a pointer to an allocated dstrm, or
  610.    NULL if error. */
  611. {
  612.     dstrm *d;             /* pointer to malloc'ed directory stream */
  613.     char    *c;                         /* scans TOPS20 path */
  614.     int     m;                          /* length of name */
  615.     char    *p;                         /* temp string */
  616.  
  617.     if (((d = (dstrm *)malloc(sizeof(dstrm))) == NULL) ||
  618.         ((p = (char *)malloc((m = strlen(n)) + 4)) == NULL)) {
  619.             return NULL;
  620.     }
  621.  
  622. /* Directory may be in form "<DIR.SUB1.SUB2>" or "<DIR.SUB1>SUB2.DIRECTORY".
  623. ** If latter, convert to former. */
  624.  
  625.     if ((m > 0)  &&  (*(c = strcpy(p,n) + m-1) != '>')) {
  626.         c -= 10;
  627.         *c-- = '\0';        /* terminate at "DIRECTORY.1" */
  628.         *c = '>';           /* "." --> ">" */
  629.         while ((c > p)  &&  (*--c != '>'));
  630.         *c = '.';           /* ">" --> "." */
  631.     }
  632.     strcat(p, "*.*");
  633.     if ((d->wfjfn = wfopen(p)) == 0) {
  634.         free((voidp *)d);
  635.         free((voidp *)p);
  636.         return NULL;
  637.     }
  638.     free((voidp *)p);
  639.     d->more = TRUE;
  640.     return (d);
  641. }
  642. #else /* !TOPS20 */
  643.  
  644. local dstrm *opend(n)
  645. char *n;                /* directory name to open */
  646. /* Open the directory *n, returning a pointer to an allocated dstrm, or
  647.    NULL if error. */
  648. {
  649.     dstrm *d;             /* pointer to malloc'ed directory stream */
  650.  
  651.   if ((d = (dstrm *)malloc(sizeof(dstrm))) == NULL)
  652.     return NULL;
  653.   if ((d->f = open(n, 0, 0)) < 0)               /* open directory */
  654.     return NULL;
  655.   d->p = d->q = d->b;                           /* buffer is empty */
  656.   return d;
  657. }
  658. # endif /* ?TOPS20 */
  659. #else /* !DIRENT */
  660. #  define opend opendir                         /* just use opendir() */
  661. #endif /* ?DIRENT */
  662.  
  663.  
  664. local char *readd(d)
  665. dstrm *d;               /* directory stream to read from */
  666. /* Return a pointer to the next name in the directory stream d, or NULL if
  667.    no more entries or an error occurs. */
  668. {
  669. #ifdef TOPS20
  670.   char    *p;
  671.   if ((d->more == FALSE) || ((p = wfname(d->wfjfn)) == NULL)) {
  672.       return NULL;
  673.   }
  674.   if (wfnext(d->wfjfn) == 0) {
  675.       d->more = FALSE;
  676.   }
  677.   return p;
  678.  
  679. #else /* !TOPS20 */
  680.   struct direct *e;     /* directory entry read */
  681.  
  682. # ifdef DIRENT
  683.   int n;                /* number of entries read by getdents */
  684.  
  685.   if (d->p >= d->q)                             /* if empty, fill buffer */
  686.     if ((n = getdents(d->f, d->b, DBSZ)) <= 0)
  687.       return NULL;
  688.     else
  689.       d->q = n + (d->p = d->b);
  690.   e = (struct direct *)(d->p);                  /* point to entry */
  691.   d->p += ((struct direct *)(d->p))->d_reclen;  /* advance */
  692.   return e->d_name;                             /* return name */
  693. # else /* !DIRENT */
  694.   e = readdir(d);
  695.   return e == NULL ? (char *)NULL : e->d_name;
  696. # endif /* ?DIRENT */
  697. #endif /* ?TOPS20 */
  698. }
  699.  
  700.  
  701. #ifdef DIRENT
  702. local void closed(d)
  703. dstrm *d;               /* directory stream to close */
  704. /* Close the directory stream */
  705. {
  706. #ifndef TOPS20
  707.   close(d->f);
  708. #endif
  709.   free((voidp *)d);
  710. }
  711. #else /* !DIRENT */
  712. #  define closed closedir
  713. #endif /* ?DIRENT */
  714.  
  715. #ifdef TOPS20
  716. /* Wildcard filename routines */
  717.  
  718. /* WFOPEN - open wild card filename
  719. **      Returns wild JFN for filespec, 0 if failure.
  720. */
  721. static int
  722. wfopen(name)
  723. char *name;
  724. {
  725.     return (_gtjfn(name, (O_RDONLY | O_T20_WILD)));
  726. }
  727.  
  728. /* WFNAME - Return filename for wild JFN
  729. **      Returns pointer to dynamically allocated filename string
  730. */
  731. static char *
  732. wfname(jfn)
  733. int jfn;
  734. {
  735.     char *fp, fname[200];
  736.     int ablock[5];
  737.  
  738.     ablock[1] = (int) (fname - 1);
  739.     ablock[2] = jfn & 0777777;  /* jfn, no flags */
  740.     ablock[3] = 0111110000001;  /* DEV+DIR+NAME+TYPE+GEN, punctuate */
  741.     if (!jsys(JFNS, ablock))
  742.         return NULL;            /* something bad happened */
  743.     if ((fp = (char *)malloc(strlen(fname) + 1)) == NULL) {
  744.         return NULL;
  745.     }
  746.     strcpy(fp, fname);          /* copy the file name here */
  747.     return fp;
  748. }
  749.  
  750. /* WFNEXT - Make wild JFN point to next real file
  751. **      Returns success or failure (not JFN)
  752. */
  753. static int
  754. wfnext(jfn)
  755. int jfn;
  756. {
  757.     int ablock[5];
  758.  
  759.     ablock[1] = jfn;            /* save jfn and flags */
  760.     return jsys(GNJFN, ablock);
  761. }
  762. #endif /* TOPS20 */
  763.   
  764.  
  765. #ifdef __human68k__
  766. int wild(w)
  767. char *w;
  768. {
  769.   struct _filbuf inf;
  770.   int r;
  771.   extern int _hupair;
  772.   char name[FNMAX];
  773.   char *p;
  774.  
  775.   if (_hupair)
  776.     return procname(w);         /* if argv's passed hupair, don't glob */
  777.   strcpy(name, w);
  778.   _toslash(name);
  779.   if ((p = strrchr(name, '/')) == NULL && (p = strrchr(name, ':')) == NULL)
  780.     p = name;
  781.   else
  782.     p++;
  783.   if (_dos_files (&inf, w, 0xff) < 0)
  784.     return ZE_MISS;
  785.   do {
  786.     strcpy(p, inf.name);
  787.     r = procname(name);
  788.     if (r != ZE_OK)
  789.       return r;
  790.   } while (_dos_nfiles(&inf) >= 0);
  791.  
  792.   return ZE_OK;
  793. }
  794. #endif
  795.  
  796. #if defined(MSDOS) && !defined(OS2) && !defined(WIN32)
  797.  
  798. char *getVolumeLabel(drive, vtime, vmode)
  799.   int drive;  /* drive name: 'A' .. 'Z' or '\0' for current drive */
  800.   ulg *vtime; /* volume label creation time (DOS format) */
  801.   ulg *vmode; /* volume label file mode */
  802.  
  803. /* If a volume label exists for the given drive, return its name and
  804.    set its time and mode. The returned name must be static data. */
  805. {
  806.   static char vol[14];
  807.   ff_dir d;
  808.  
  809.   if (drive) {
  810.     vol[0] = (char)drive;
  811.     strcpy(vol+1, ":/");
  812.   } else {
  813.     strcpy(vol, "/");
  814.   }
  815.   strcat(vol, "*.*");
  816.   if (FFIRST(vol, &d, FA_LABEL) == 0) {
  817.     strncpy(vol, d.ff_name, sizeof(vol)-1);
  818.     *vtime = ((ulg)d.ff_fdate << 16) | ((ulg)d.ff_ftime & 0xffff);
  819.     *vmode = (ulg)d.ff_attrib;
  820.     return vol;
  821.   }
  822.   return NULL;
  823. }
  824.  
  825. #endif /*  MSDOS && !OS2 && !WIN32 */
  826.  
  827. #if defined(MSDOS) || defined(OS2)
  828.  
  829. int wild(w)
  830. char *w;                /* path/pattern to match */
  831. /* If not in exclude mode, expand the pattern based on the contents of the
  832.    file system.  Return an error code in the ZE_ class. */
  833. {
  834. # ifndef __GO32__
  835.   char *a;              /* alloc'ed space for name */
  836.   dstrm *d;             /* stream for reading directory */
  837.   char *e;              /* name found in directory */
  838.   int f;                /* true if there was a match */
  839.   char *n;              /* constructed name from directory */
  840.   char *p;              /* path */
  841.   char *q;              /* name */
  842.   int r;                /* temporary variable */
  843.   char v[5];            /* space for device current directory */
  844. # endif /* __GO32__ */
  845.  
  846. # ifndef WIN32
  847.   if (volume_label == 1) {
  848.     volume_label = 2;
  849.     label = getVolumeLabel(w[1] == ':' ? to_up(w[0]) : '\0',
  850.                            &label_time, &label_mode);
  851.     if (label != NULL) {
  852.        newname(label, 0);
  853.     }
  854.     if (w[1] == ':' && w[2] == '\0') return ZE_OK;
  855.     /* "zip -$ foo a:" can be used to force drive name */
  856.   }
  857. # endif
  858. # ifdef __GO32__
  859.   return procname(w); /* expansion already done by DJGPP */
  860. # else
  861.   /* Allocate and copy pattern */
  862.   if ((p = a = malloc(strlen(w) + 1)) == NULL)
  863.     return ZE_MEM;
  864.   strcpy(p, w);
  865.  
  866.   /* Normalize path delimiter as '/'. */
  867.   for (q = p; *q; q++)                  /* use / consistently */
  868.     if (*q == '\\')
  869.       *q = '/';
  870.  
  871.   /* Only name can have special matching characters */
  872.   if ((q = isshexp(p)) != NULL &&
  873.       (strrchr(q, '/') != NULL || strrchr(q, ':') != NULL))
  874.   {
  875.     free((voidp *)a);
  876.     return ZE_PARMS;
  877.   }
  878.  
  879.   /* Separate path and name into p and q */
  880.   if ((q = strrchr(p, '/')) != NULL && (q == p || q[-1] != ':'))
  881.   {
  882.     *q++ = 0;                           /* path/name -> path, name */
  883.     if (*p == 0)                        /* path is just / */
  884.       p = strcpy(v, "/.");
  885.   }
  886.   else if ((q = strrchr(p, ':')) != NULL)
  887.   {                                     /* has device and no or root path */
  888.     *q++ = 0;
  889.     p = strcat(strcpy(v, p), ":");      /* copy device as path */
  890.     if (*q == '/')                      /* -> device:/., name */
  891.     {
  892.       strcat(p, "/");
  893.       q++;
  894.     }
  895.     strcat(p, ".");
  896.   }
  897.   else                                  /* no path or device */
  898.   {
  899.     q = p;
  900.     p = strcpy(v, ".");
  901.   }
  902.   /* I can't understand Mark's code so I am adding a hack here to get
  903.    * "zip -r foo ." to work. Allow the dubious "zip -r foo .." but
  904.    * reject "zip -rm foo ..".
  905.    */
  906.   if (recurse && (strcmp(q, ".") == 0 ||  strcmp(q, "..") == 0)) {
  907.      if (dispose && strcmp(q, "..") == 0)
  908.         err(ZE_PARMS, "cannot remove parent directory");
  909.      return procname(p);
  910.   }
  911.  
  912.   /* Search that level for matching names */
  913.   if ((d = opend(p)) == NULL)
  914.   {
  915.     free((voidp *)a);
  916.     return ZE_MISS;
  917.   }
  918.   if ((r = strlen(p)) > 1 &&
  919.       (strcmp(p + r - 2, ":.") == 0 || strcmp(p + r - 2, "/.") == 0))
  920.     *(p + r - 1) = 0;
  921.   f = 0;
  922.   while ((e = readd(d)) != NULL) {
  923.     if (strcmp(e, ".") && strcmp(e, "..") && MATCH(q, e))
  924.     {
  925.       f = 1;
  926.       if (strcmp(p, ".") == 0) {                /* path is . */
  927.         r = procname(e);                        /* name is name */
  928.         if (r) {
  929.            f = 0;
  930.            break;
  931.         }
  932.       } else
  933.       {
  934.         if ((n = malloc(strlen(p) + strlen(e) + 2)) == NULL)
  935.         {
  936.           free((voidp *)a);
  937.           closed(d);
  938.           return ZE_MEM;
  939.         }
  940.         n = strcpy(n, p);
  941.         if (n[r = strlen(n) - 1] != '/' && n[r] != ':')
  942.           strcat(n, "/");
  943.         r = procname(strcat(n, e));             /* name is path/name */
  944.         free((voidp *)n);
  945.         if (r) {
  946.           f = 0;
  947.           break;
  948.         }
  949.       }
  950.     }
  951.   }
  952.   closed(d);
  953.  
  954.   /* Done */
  955.   free((voidp *)a);
  956.   return f ? ZE_OK : ZE_MISS;
  957. # endif /* __GO32__ */
  958. }
  959. #endif /* MSDOS || OS2 */
  960.  
  961. #if defined(MSDOS) && !defined(OS2) && !defined(WIN32)
  962. #  if defined(__TURBOC__) || defined(__GO32__) || defined(__BORLANDC__)
  963. #   define GetFileMode(name) bdosptr(0x43, (name), 0)
  964. #  else
  965.     int GetFileMode(char *name)
  966.     {
  967.        unsigned int attr = 0;
  968.        _dos_getfileattr(name, &attr);
  969.        return attr;
  970.     }
  971. #  endif/* __TURBOC__  || __GO32__ */
  972. # endif /* MSDOS && !OS2 */
  973.  
  974. #ifdef __human68k__
  975. #  define GetFileMode(name) (_dos_chmod((name), -1) & 0x3f)
  976. #endif
  977.  
  978. #ifdef AMIGA
  979.  
  980. /* What we have here is a mostly-generic routine using opend()/readd() and */
  981. /* isshexp()/MATCH() to find all the files matching a multi-part filespec  */
  982. /* using the portable pattern syntax.  It shouldn't take too much fiddling */
  983. /* to make it usable for any other platform that has directory hierarchies */
  984. /* but no shell-level pattern matching.  It works for patterns throughout  */
  985. /* the pathname, such as "foo:*.?/source/x*.[ch]".                         */
  986.  
  987. /* whole is a pathname with wildcards, wildtail points somewhere in the  */
  988. /* middle of it.  All wildcards to be expanded must come AFTER wildtail. */
  989.  
  990. local int wild_recurse(whole, wildtail) char *whole; char *wildtail;
  991. {
  992.     dstrm *dir;
  993.     char *subwild, *name, *newwhole = NULL, *glue = NULL, plug = 0, plug2;
  994.     ush newlen, amatch = 0;
  995.     BPTR lok;
  996.     int e = ZE_MISS;
  997.  
  998.     if (!isshexp(wildtail))
  999.         if (lok = Lock(whole, ACCESS_READ)) {       /* p exists? */
  1000.             UnLock(lok);
  1001.             return procname(whole);
  1002.         } else
  1003.             return ZE_MISS;                     /* woops, no wildcards! */
  1004.  
  1005.     /* back up thru path components till existing dir found */
  1006.     do {
  1007.         name = wildtail + strlen(wildtail) - 1;
  1008.         for (;;)
  1009.             if (name-- <= wildtail || *name == '/') {
  1010.                 subwild = name + 1;
  1011.                 plug2 = *subwild;
  1012.                 *subwild = 0;
  1013.                 break;
  1014.             }
  1015.         if (glue)
  1016.             *glue = plug;
  1017.         glue = subwild;
  1018.         plug = plug2;
  1019.         dir = opend(whole);
  1020.     } while (!dir && !disk_not_mounted && subwild > wildtail);
  1021.     wildtail = subwild;                 /* skip past non-wild components */
  1022.  
  1023.     if (subwild = strchr(wildtail + 1, '/')) {
  1024.         /* this "+ 1" dodges the  ^^^ hole left by *glue == 0 */
  1025.         *(subwild++) = 0;               /* wildtail = one component pattern */
  1026.         newlen = strlen(whole) + strlen(subwild) + 32;
  1027.     } else
  1028.         newlen = strlen(whole) + 31;
  1029.     if (!dir || !(newwhole = malloc(newlen))) {
  1030.         if (glue)
  1031.             *glue = plug;
  1032.         e = dir ? ZE_MEM : ZE_MISS;
  1033.         goto ohforgetit;
  1034.     }
  1035.     strcpy(newwhole, whole);
  1036.     newlen = strlen(newwhole);
  1037.     if (glue)
  1038.         *glue = plug;                           /* repair damage to whole */
  1039.     if (!isshexp(wildtail)) {
  1040.         e = ZE_MISS;                            /* non-wild name not found */
  1041.         goto ohforgetit;
  1042.     }
  1043.  
  1044.     while (name = readd(dir)) {
  1045.         if (MATCH(wildtail, name)) {
  1046.             strcpy(newwhole + newlen, name);
  1047.             if (subwild) {
  1048.                 name = newwhole + strlen(newwhole);
  1049.                 *(name++) = '/';
  1050.                 strcpy(name, subwild);
  1051.                 e = wild_recurse(newwhole, name);
  1052.             } else
  1053.                 e = procname(newwhole);
  1054.             newwhole[newlen] = 0;
  1055.             if (e == ZE_OK)
  1056.                 amatch = 1;
  1057.             else if (e != ZE_MISS)
  1058.                 break;
  1059.         }
  1060.     }
  1061.  
  1062.   ohforgetit:
  1063.     if (dir) closed(dir);
  1064.     if (subwild) *--subwild = '/';
  1065.     if (newwhole) free(newwhole);
  1066.     if (e == ZE_MISS && amatch)
  1067.         e = ZE_OK;
  1068.     return e;
  1069. }
  1070.  
  1071. int wild(p) char *p;
  1072. {
  1073.     char *use;
  1074.  
  1075.     /* wild_recurse() can't handle colons in wildcard part: */
  1076.     if (use = strchr(p, ':')) {
  1077.         if (strchr(++use, ':'))
  1078.             return ZE_PARMS;
  1079.     } else
  1080.         use = p;
  1081.  
  1082.     return wild_recurse(p, use);
  1083. }
  1084. #endif /* AMIGA */
  1085.                                           
  1086.  
  1087. #ifdef VMS
  1088. int wild(p)
  1089. char *p;                /* path/pattern to match */
  1090. /* Expand the pattern based on the contents of the file system.  Return an
  1091.    error code in the ZE_ class. */
  1092. {
  1093.   dstrm *d;             /* stream for reading directory */
  1094.   char *e;              /* name found in directory */
  1095.   int f;                /* true if there was a match */
  1096.  
  1097.   /* Search given pattern for matching names */
  1098.   if ((d = (dstrm *)malloc(sizeof(dstrm))) == NULL)
  1099.     return ZE_MEM;
  1100.   vms_wild(p, d);       /* pattern may be more than just directory name */
  1101.  
  1102.   /*
  1103.    * Save version specified by user to use in recursive drops into
  1104.    * subdirectories.
  1105.    */
  1106.   strncpy(wild_version_part,d->nam.nam$l_ver,d->nam.nam$b_ver);
  1107.   wild_version_part[d->nam.nam$b_ver] = 0;
  1108.  
  1109.   f = 0;
  1110.   while ((e = readd(d)) != NULL)        /* "dosmatch" is already built in */
  1111.     if (procname(e) == ZE_OK)
  1112.       f = 1;
  1113.   closed(d);
  1114.  
  1115.   /* Done */
  1116.   return f ? ZE_OK : ZE_MISS;
  1117. }
  1118. #endif /* VMS */
  1119.  
  1120.  
  1121. char *getnam(n)
  1122. char *n;                /* where to put name (must have >=FNMAX+1 bytes) */
  1123. /* Read a space, \n, \r, or \t delimited name from stdin into n, and return
  1124.    n.  If EOF, then return NULL.  Also, if the name read is too big, return
  1125.    NULL. */
  1126. {
  1127.   int c;                /* last character read */
  1128.   char *p;              /* pointer into name area */
  1129.  
  1130.   p = n;
  1131.   while ((c = getchar()) == ' ' || c == '\n' || c == '\r' || c == '\t')
  1132.     ;
  1133.   if (c == EOF)
  1134.     return NULL;
  1135.   do {
  1136.     if (p - n >= FNMAX)
  1137.       return NULL;
  1138.     *p++ = (char)c;
  1139.     c = getchar();
  1140.   } while (c != EOF && c != ' ' && c != '\n' && c != '\r' && c != '\t');
  1141.   *p = 0;
  1142.   return n;
  1143. }
  1144.  
  1145.  
  1146. struct flist far *fexpel(f)
  1147. struct flist far *f;    /* entry to delete */
  1148. /* Delete the entry *f in the doubly-linked found list.  Return pointer to
  1149.    next entry to allow stepping through list. */
  1150. {
  1151.   struct flist far *t;  /* temporary variable */
  1152.  
  1153.   t = f->nxt;
  1154.   *(f->lst) = t;                        /* point last to next, */
  1155.   if (t != NULL)
  1156.     t->lst = f->lst;                    /* and next to last */
  1157.   if (f->name != NULL)                  /* free memory used */
  1158.     free((voidp *)(f->name));
  1159.   if (f->zname != NULL)
  1160.     free((voidp *)(f->zname));
  1161.   farfree((voidp far *)f);
  1162.   fcount--;                             /* decrement count */
  1163.   return t;                             /* return pointer to next */
  1164. }
  1165.  
  1166.  
  1167. local int fqcmp(a, b)
  1168. const voidp *a, *b;           /* pointers to pointers to found entries */
  1169. /* Used by qsort() to compare entries in the found list by name. */
  1170. {
  1171.   return strcmp((*(struct flist far **)a)->name,
  1172.                 (*(struct flist far **)b)->name);
  1173. }
  1174.  
  1175.  
  1176. local int fqcmpz(a, b)
  1177. const voidp *a, *b;           /* pointers to pointers to found entries */
  1178. /* Used by qsort() to compare entries in the found list by zname. */
  1179. {
  1180.   return strcmp((*(struct flist far **)a)->zname,
  1181.                 (*(struct flist far **)b)->zname);
  1182. }
  1183.  
  1184.  
  1185. local char *last(p)
  1186. char *p;                /* sequence of / delimited path components */
  1187. /* Return a pointer to the start of the last path component. For a
  1188.  * directory name terminated by /, the return value is an empty string.
  1189.  */
  1190. {
  1191.   char *t;              /* temporary variable */
  1192.  
  1193.   if ((t = strrchr(p, PATH_END)) != NULL)
  1194.     return t + 1;
  1195.   else
  1196.     return p;
  1197. }
  1198.  
  1199.  
  1200. local char *msname(n)
  1201. char *n;
  1202. /* Reduce all path components to MSDOS upper case 8.3 style names.  Probably
  1203.    should also check for invalid characters, but I don't know which ones
  1204.    those are. */
  1205. {
  1206.   int c;                /* current character */
  1207.   int f;                /* characters in current component */
  1208.   char *p;              /* source pointer */
  1209.   char *q;              /* destination pointer */
  1210.  
  1211.   p = q = n;
  1212.   f = 0;
  1213.   while ((c = (unsigned char)*p++) != 0)
  1214.     if (c == '/')
  1215.     {
  1216.       *q++ = (char)c;
  1217.       f = 0;                            /* new component */
  1218.     }
  1219. #ifdef __human68k__
  1220.     else if (iskanji(c))
  1221.     {
  1222.       if (f == 7 || f == 11)
  1223.         f++;
  1224.       else if (*p != '\0' && f < 12 && f != 8)
  1225.       {
  1226.         *q++ = c;
  1227.         *q++ = *p++;
  1228.         f += 2;
  1229.       }
  1230.     }
  1231. #endif
  1232.     else if (c == '.')
  1233.       if (f < 9)
  1234.       {
  1235.         *q++ = (char)c;
  1236.         f = 9;                          /* now in file type */
  1237.       }
  1238.       else
  1239.         f = 12;                         /* now just excess characters */
  1240.     else
  1241.       if (f < 12 && f != 8)
  1242.       {
  1243.         *q++ = (char)(to_up(c));
  1244.         f++;                            /* do until end of name or type */
  1245.       }
  1246.   *q = 0;
  1247.   return n;
  1248. }
  1249.  
  1250.  
  1251. #ifdef VMS
  1252. local char *strlower(s)
  1253. char *s;                /* string to convert */
  1254. /* Convert all uppercase letters to lowercase in string s */
  1255. {
  1256.   char *p;              /* scans string */
  1257.  
  1258.   for (p = s; *p; p++)
  1259.     if (*p >= 'A' && *p <= 'Z')
  1260.       *p += 'a' - 'A';
  1261.   return s;
  1262. }
  1263.  
  1264. local char *strupper(s)
  1265. char *s;                /* string to convert */
  1266. /* Convert all lowercase letters to uppercase in string s */
  1267. {
  1268.   char *p;              /* scans string */
  1269.  
  1270.   for (p = s; *p; p++)
  1271.     if (*p >= 'a' && *p <= 'z')
  1272.       *p -= 'a' - 'A';
  1273.   return s;
  1274. }
  1275. #endif /* VMS */
  1276.  
  1277. char *ex2in(x, isdir, pdosflag)
  1278. char *x;                /* external file name */
  1279. int isdir;              /* input: x is a directory */
  1280. int *pdosflag;          /* output: force MSDOS file attributes? */
  1281. /* Convert the external file name to a zip file name, returning the malloc'ed
  1282.    string or NULL if not enough memory. */
  1283. {
  1284.   char *n;              /* internal file name (malloc'ed) */
  1285.   char *t;              /* shortened name */
  1286.   int dosflag;
  1287.  
  1288. #ifdef TOPS20
  1289.   int jfn;
  1290.   char *fp, fname[200];
  1291.   int ablock[5];
  1292.  
  1293.   jfn = _gtjfn(x, (O_RDONLY));
  1294.   ablock[1] = (int) (fname - 1);
  1295.   ablock[2] = jfn & 0777777;    /* jfn, no flags */
  1296.   ablock[3] = 0111100000001;    /* DEV+DIR+NAME+TYPE, punctuate */
  1297.   if (!jsys(JFNS, ablock)) {
  1298.       _rljfn(jfn);
  1299.       return NULL;              /* something bad happened */
  1300.   }
  1301.   _rljfn(jfn);
  1302.   if ((fp = (char *)malloc(strlen(fname) + 1)) == NULL) {
  1303.       return NULL;
  1304.   }
  1305.   strcpy(fp, fname);            /* copy the file name here */
  1306.   x = fp;
  1307. #endif /* TOPS20 */
  1308.  
  1309. #if defined(OS2) || defined(WIN32)
  1310.   dosflag = dosify || IsFileSystemFAT(x);
  1311.   if (!dosify && use_longname_ea && (t = GetLongPathEA(x)) != NULL)
  1312.   {
  1313.     x = t;
  1314.     dosflag = 0;
  1315.   }
  1316. #else /* !OS2 */
  1317. # ifdef MSDOS
  1318.   dosflag = 1;
  1319. # else /* !MSDOS */
  1320.   dosflag = dosify; /* default for non-DOS and non-OS/2 */
  1321. # endif /* ?MSDOS */
  1322. #endif /* ?OS2 */
  1323.  
  1324.   /* Find starting point in name before doing malloc */
  1325. #if defined(MSDOS) || defined(__human68k__) /* msdos */
  1326.   t = *x && *(x + 1) == ':' ? x + 2 : x;
  1327.   while (*t == '/' || *t == '\\')
  1328.     t++;
  1329. #else /* !MSDOS */
  1330. #  if (defined(VMS) || defined(TOPS20))
  1331.   t = x;
  1332.   if ((n = strrchr(t, ':')) != NULL)
  1333.     t = n + 1;
  1334.   if (*t == PATH_START && (n = strrchr(t, PATH_END)) != NULL)
  1335.     if ((x = strchr(t, '.')) != NULL && x < n)
  1336.       t = x + 1;
  1337.     else
  1338.       t = n + 1;
  1339. #  else /* !(VMS || TOPS20) */
  1340. #    ifdef AMIGA
  1341.   if ((t = strrchr(x, ':')) != NULL)    /* reject ":" */
  1342.     t++;
  1343.   else
  1344.     t = x;
  1345.   {                                     /* reject "//" */
  1346.     char *tt = t;
  1347.     while (tt = strchr(tt, '/'))
  1348.       while (*++tt == '/')
  1349.         t = tt;
  1350.   }
  1351.   while (*t == '/')             /* reject leading "/" on what's left */
  1352.     t++;
  1353. #    else /* !AMIGA */                      /* unix */
  1354.   for (t = x; *t == '/'; t++)
  1355.     ;
  1356. #    endif /* ?AMIGA */
  1357. #  endif /* ?(VMS || TOPS20) */
  1358. #endif /* ?MSDOS */
  1359.  
  1360.   /* Make changes, if any, to the copied name (leave original intact) */
  1361. #ifdef __human68k__
  1362.   _toslash(t);
  1363. #endif /* !__human68k__ */
  1364. #ifdef MSDOS
  1365.   for (n = t; *n; n++)
  1366.     if (*n == '\\')
  1367.       *n = '/';
  1368. #endif /* MSDOS */
  1369.  
  1370.   if (!pathput)
  1371.     t = last(t);
  1372.  
  1373.   /* Discard directory names with zip -rj */
  1374.   if (*t == '\0')
  1375.     return t;
  1376.  
  1377.   /* Malloc space for internal name and copy it */
  1378.   if ((n = malloc(strlen(t) + 1)) == NULL)
  1379.     return NULL;
  1380.   strcpy(n, t);
  1381.  
  1382. #if (defined(VMS) || defined(TOPS20))
  1383.   if ((t = strrchr(n, PATH_END)) != NULL)
  1384.   {
  1385.     *t = '/';
  1386.     while (--t > n)
  1387.       if (*t == '.')
  1388.         *t = '/';
  1389.   }
  1390.  
  1391.   /* Fix from Greg Roelofs: */
  1392.   /* Get current working directory and strip from n (t now = n) */
  1393.   {
  1394.     char cwd[256], *p, *q;
  1395.     int c;
  1396.  
  1397.     if (getcwd(cwd, 256) && ((p = strchr(cwd, '.')) != NULL))
  1398.     {
  1399.       ++p;
  1400.       if ((q = strrchr(p, PATH_END)) != NULL)
  1401.       {
  1402.         *q = '/';
  1403.         while (--q > p)
  1404.           if (*q == '.')
  1405.             *q = '/';
  1406.  
  1407.         /* strip bogus path parts from n */
  1408.         if (strncmp(n, p, (c=strlen(p))) == 0)
  1409.         {
  1410.           q = n + c;
  1411.           while (*t++ = *q++)
  1412.             ;
  1413.         }
  1414.       }
  1415.     }
  1416.   }
  1417.   strlower(n);
  1418.  
  1419.   if (isdir)
  1420.   {
  1421.     if (strcmp((t=n+strlen(n)-6), ".dir;1"))
  1422.       error("directory not version 1");
  1423.     else
  1424.       strcpy(t, "/");
  1425.   }
  1426. #ifdef VMS
  1427.   else if (!vmsver)
  1428.     if ((t = strrchr(n, ';')) != NULL)
  1429.       *t = 0;
  1430. #endif /* VMS */
  1431.  
  1432.   if ((t = strrchr(n, '.')) != NULL)
  1433.   {
  1434.     if ( t[1] == 0)                /* "filename." -> "filename" */
  1435.       *t = 0;
  1436. #ifdef VMS
  1437.     else if (t[1] == ';')         /* "filename.;vvv" -> "filename;vvv" */
  1438.     {
  1439.       char *f = t+1;
  1440.       while (*t++ = *f++) ;
  1441.     }
  1442. #endif /* VMS */
  1443.   }
  1444. #else
  1445.   if (isdir == 42) return n;      /* avoid warning on unused variable */
  1446. #endif /* ?(VMS || TOPS20) */
  1447.  
  1448.   if (dosify)
  1449.     msname(n);
  1450. #if defined(MSDOS) && !defined(OS2) && !defined(WIN32)
  1451.   else
  1452.     strlwr(n);
  1453. #endif
  1454.   /* Returned malloc'ed name */
  1455.   if (pdosflag) 
  1456.     *pdosflag = dosflag;
  1457.   return n;
  1458. }
  1459.  
  1460.  
  1461. char *in2ex(n)
  1462. char *n;                /* internal file name */
  1463. /* Convert the zip file name to an external file name, returning the malloc'ed
  1464.    string or NULL if not enough memory. */
  1465. {
  1466.   char *x;              /* external file name */
  1467. #if (defined(VMS) || defined(TOPS20))
  1468.   char *t;              /* scans name */
  1469.  
  1470.   if ((t = strrchr(n, '/')) == NULL)
  1471. #endif
  1472.   {
  1473.     if ((x = malloc(strlen(n) + 1 + PAD)) == NULL)
  1474.       return NULL;
  1475.     strcpy(x, n);
  1476.   }
  1477. #if (defined(VMS) || defined(TOPS20))
  1478.   else
  1479.   {
  1480.     if ((x = malloc(strlen(n) + 3 + PAD)) == NULL)
  1481.       return NULL;
  1482.     x[0] = PATH_START;
  1483.     x[1] = '.';
  1484.     strcpy(x + 2, n);
  1485.     *(t = x + 2 + (t - n)) = PATH_END;
  1486.     while (--t > x)
  1487.       if (*t == '/')
  1488.         *t = '.';
  1489.   }
  1490.   strupper(x);
  1491. #endif /* ?(VMS || TOPS20) */
  1492.  
  1493. #if defined(OS2) || defined(WIN32)
  1494.   if ( !IsFileNameValid(x) )
  1495.     ChangeNameForFAT(x);
  1496. #endif /* !OS2 */
  1497.   return x;
  1498. }
  1499.  
  1500.  
  1501. int check_dup()
  1502. /* Sort the found list and remove duplicates.
  1503.    Return an error code in the ZE_ class. */
  1504. {
  1505.   struct flist far *f;          /* steps through found linked list */
  1506.   extent j;                     /* index for s */
  1507.   struct flist far **s;         /* sorted table */
  1508.  
  1509.   /* sort found list, remove duplicates */
  1510.   if (fcount)
  1511.   {
  1512.     if ((s = (struct flist far **)malloc(
  1513.          fcount * sizeof(struct flist far *))) == NULL)
  1514.       return ZE_MEM;
  1515.     for (j = 0, f = found; f != NULL; f = f->nxt)
  1516.       s[j++] = f;
  1517.     qsort((char *)s, fcount, sizeof(struct flist far *), fqcmp);
  1518.     for (j = fcount - 1; j > 0; j--)
  1519.       if (strcmp(s[j - 1]->name, s[j]->name) == 0)
  1520.         fexpel(s[j]);           /* fexpel() changes fcount */
  1521.     qsort((char *)s, fcount, sizeof(struct flist far *), fqcmpz);
  1522.     for (j = 1; j < fcount; j++)
  1523.       if (strcmp(s[j - 1]->zname, s[j]->zname) == 0)
  1524.       {
  1525.         warn("name in zip file repeated: ", s[j]->zname);
  1526.         warn("  first full name: ", s[j - 1]->name);
  1527.         warn(" second full name: ", s[j]->name);
  1528.         return ZE_PARMS;
  1529.       }
  1530.     free((voidp *)s);
  1531.   }
  1532.   return ZE_OK;
  1533. }
  1534.  
  1535. int filter(name)
  1536.   char *name;
  1537.   /* Scan the -i and -x lists for matches to the given name.
  1538.      Return true if the name must be included, false otherwise.
  1539.      Give precedence to -x over -i.
  1540.    */
  1541. {
  1542.    int n;
  1543.    int include = icount ? 0 : 1;
  1544. #ifdef MATCH_LASTNAME_ONLY
  1545.    char *p = last(name);
  1546.    if (*p) name = p;
  1547. #endif
  1548.  
  1549.    if (pcount == 0) return 1;
  1550.  
  1551.    for (n = 0; n < pcount; n++) {
  1552.       if (MATCH(patterns[n].zname, name)) {
  1553.          if (patterns[n].select == 'x') return 0;
  1554.          include = 1;
  1555.       }
  1556.    }
  1557.    return include;
  1558. }
  1559.  
  1560. local int newname(n, isdir)
  1561. char *n;                /* name to add (or exclude) */
  1562. int  isdir;             /* true for a directory */
  1563. /* Add (or exclude) the name of an existing disk file.  Return an error
  1564.    code in the ZE_ class. */
  1565. {
  1566.   char *m;
  1567.   struct flist far *f;  /* where in found, or new found entry */
  1568.   struct zlist far *z;  /* where in zfiles (if found) */
  1569.   int dosflag;
  1570.  
  1571.   /* Search for name in zip file.  If there, mark it, else add to
  1572.      list of new names to do (or remove from that list). */
  1573.   if ((m = ex2in(n, isdir, &dosflag)) == NULL)
  1574.     return ZE_MEM;
  1575.  
  1576.   /* Discard directory names with zip -rj */
  1577.   if (*m == '\0') {
  1578. #ifndef AMIGA
  1579. /* A null string is a legitimate external directory name in AmigaDOS; also,
  1580.  * a command like "zip -r zipfile FOO:" produces an empty internal name.
  1581.  */
  1582.     if (pathput) error("empty name without -j");
  1583. #endif
  1584.     free((voidp *)m);
  1585.     return ZE_OK;
  1586.   }
  1587.   if ((z = zsearch(m)) != NULL) {
  1588.     z->mark = pcount ? filter(m) : 1;
  1589.     if (z->mark == 0) {
  1590.       free((voidp *)m);
  1591.       if (verbose)
  1592.         fprintf(mesg, "zip diagnostic: excluding %s\n", z->name);
  1593.     } else {
  1594.       free((voidp *)(z->name));
  1595.       if ((z->name = malloc(strlen(n) + 1 + PAD)) == NULL)
  1596.         return ZE_MEM;
  1597.       strcpy(z->name, n);
  1598. #ifdef FORCE_NEWNAME
  1599.       free((voidp *)(z->zname));
  1600.       z->zname = m;
  1601. #else
  1602.       /* Better keep the old name. Useful when updating on MSDOS a zip file
  1603.        * made on Unix.
  1604.        */
  1605.       free((voidp *)m);
  1606. #endif
  1607.       z->dosflag = dosflag;
  1608.       if (verbose)
  1609.         fprintf(mesg, "zip diagnostic: including %s\n", z->name);
  1610.     }
  1611.     if (n == label) {
  1612.        label = z->name;
  1613.     }
  1614.   } else if (pcount == 0 || filter(m)) {
  1615.  
  1616.     /* Check that we are not adding the zip file to itself. This
  1617.      * catches cases like "zip -m foo ../dir/foo.zip".
  1618.      */
  1619.     struct stat statb;
  1620.     if (zipstate == -1)
  1621.        zipstate = strcmp(zipfile, "-") != 0 &&
  1622.                    stat(zipfile, &zipstatb) == 0;
  1623.     if (zipstate == 1 && (statb = zipstatb, stat(n, &statb) == 0
  1624.       && zipstatb.st_mode  == statb.st_mode
  1625.       && zipstatb.st_ino   == statb.st_ino
  1626.       && zipstatb.st_dev   == statb.st_dev
  1627.       && zipstatb.st_uid   == statb.st_uid
  1628.       && zipstatb.st_gid   == statb.st_gid
  1629.       && zipstatb.st_size  == statb.st_size
  1630.       && zipstatb.st_mtime == statb.st_mtime
  1631.       && zipstatb.st_ctime == statb.st_ctime))
  1632.       /* Don't compare a_time since we are reading the file */
  1633.          return ZE_OK;
  1634.  
  1635.     /* allocate space and add to list */
  1636.     if ((f = (struct flist far *)farmalloc(sizeof(struct flist))) == NULL ||
  1637.         (f->name = malloc(strlen(n) + 1 + PAD)) == NULL)
  1638.     {
  1639.       if (f != NULL)
  1640.         farfree((voidp far *)f);
  1641.       return ZE_MEM;
  1642.     }
  1643.     strcpy(f->name, n);
  1644.     f->zname = m;
  1645.     f->dosflag = dosflag;
  1646.     *fnxt = f;
  1647.     f->lst = fnxt;
  1648.     f->nxt = NULL;
  1649.     fnxt = &f->nxt;
  1650.     fcount++;
  1651.     if (n == label) {
  1652.       label = f->name;
  1653.     }
  1654.   }
  1655.   return ZE_OK;
  1656. }
  1657.  
  1658.  
  1659. int procname(n)
  1660. char *n;                /* name to process */
  1661. /* Process a name or sh expression to operate on (or exclude).  Return
  1662.    an error code in the ZE_ class. */
  1663. {
  1664. #if (!defined(VMS) && !defined(TOPS20))
  1665.   char *a;              /* path and name for recursion */
  1666. #endif
  1667.   dstrm *d;             /* directory stream from opend() */
  1668.   char *e;              /* pointer to name from readd() */
  1669.   int m;                /* matched flag */
  1670.   char *p;              /* path for recursion */
  1671.   struct stat s;        /* result of stat() */
  1672.   struct zlist far *z;  /* steps through zfiles list */
  1673.  
  1674.   if (strcmp(n, "-") == 0)   /* if compressing stdin */
  1675.     return newname(n, 0);
  1676.   else if (
  1677. #ifdef S_IFLNK          /* if symbolic links exist ... */
  1678.       linkput ? lstat(n, &s) :
  1679. #endif /* S_IFLNK */
  1680.       SSTAT(n, &s)
  1681. #if defined(__TURBOC__) || defined(VMS) || defined(__WATCOMC__)
  1682.        /* For these 3 compilers, stat() succeeds on wild card names! */
  1683.       || isshexp(n)
  1684. #endif
  1685.      )
  1686.   {
  1687.     /* Not a file or directory--search for shell expression in zip file */
  1688.     p = ex2in(n, 0, (int *)NULL);       /* shouldn't affect matching chars */
  1689.     m = 1;
  1690.     for (z = zfiles; z != NULL; z = z->nxt) {
  1691.       if (MATCH(p, z->zname))
  1692.       {
  1693.         z->mark = pcount ? filter(z->zname) : 1;
  1694.         if (verbose)
  1695.             fprintf(mesg, "zip diagnostic: %scluding %s\n",
  1696.                z->mark ? "in" : "ex", z->name);
  1697.         m = 0;
  1698.       }
  1699.     }
  1700.     free((voidp *)p);
  1701.     return m ? ZE_MISS : ZE_OK;
  1702.   }
  1703.  
  1704.   /* Live name--use if file, recurse if directory */
  1705. #ifdef __human68k__
  1706.   _toslash(n);
  1707. #endif
  1708. #ifdef MSDOS
  1709.   for (p = n; *p; p++)          /* use / consistently */
  1710.     if (*p == '\\')
  1711.       *p = '/';
  1712. #endif /* MSDOS */
  1713.   if ((s.st_mode & S_IFDIR) == 0)
  1714.   {
  1715.     /* add or remove name of file */
  1716.     if ((m = newname(n, 0)) != ZE_OK)
  1717.       return m;
  1718.   } else {
  1719. #if defined(VMS) || defined(TOPS20)
  1720.     if (dirnames && (m = newname(n, 1)) != ZE_OK) {
  1721.       return m;
  1722.     }
  1723.     /* recurse into directory */
  1724.     if (recurse && (d = opend(n)) != NULL)
  1725.     {
  1726.       while ((e = readd(d)) != NULL) {
  1727.         if ((m = procname(e)) != ZE_OK)     /* recurse on name */
  1728.         {
  1729.           closed(d);
  1730.           return m;
  1731.         }
  1732.       }
  1733.       closed(d);
  1734.     }
  1735. #else /* (VMS || TOPS20) */
  1736.     /* Add trailing / to the directory name */
  1737.     if ((p = malloc(strlen(n)+2)) == NULL)
  1738.       return ZE_MEM;
  1739.     if (strcmp(n, ".") == 0) {
  1740.       *p = 0;  /* avoid "./" prefix and do not create zip entry */
  1741.     } else {
  1742.       strcpy(p, n);
  1743.       a = p + strlen(p);
  1744. #ifdef AMIGA
  1745.       if (*p && a[-1] != '/' && a[-1] != ':')
  1746. #else
  1747.       if (a[-1] != '/')
  1748. #endif
  1749.         strcpy(a, "/");
  1750.       if (dirnames && (m = newname(p, 1)) != ZE_OK) {
  1751.         free((voidp *)p);
  1752.         return m;
  1753.       }
  1754.     }
  1755.     /* recurse into directory */
  1756.     if (recurse && (d = opend(n)) != NULL)
  1757.     {
  1758.       while ((e = readd(d)) != NULL) {
  1759.         if (strcmp(e, ".") && strcmp(e, ".."))
  1760.         {
  1761.           if ((a = malloc(strlen(p) + strlen(e) + 1)) == NULL)
  1762.           {
  1763.             free((voidp *)p);
  1764.             closed(d);
  1765.             return ZE_MEM;
  1766.           }
  1767.           strcat(strcpy(a, p), e);
  1768.           if ((m = procname(a)) != ZE_OK)   /* recurse on name */
  1769.           {
  1770.             if (m == ZE_MISS)
  1771.               warn("name not matched: ", a);
  1772.             else
  1773.               err(m, a);
  1774.           }
  1775.           free((voidp *)a);
  1776.         }
  1777.       }
  1778.       free((voidp *)p);
  1779.       closed(d);
  1780.     }
  1781. #endif /* ? (VMS || TOPS20) */
  1782.   } /* (s.st_mode & S_IFDIR) == 0) */
  1783.   return ZE_OK;
  1784. }
  1785.  
  1786.  
  1787. #if !defined(CRAY) && !defined(__TURBOC__) && !defined(OS2) /* and ... */
  1788. #if !defined( __GO32__)
  1789.  
  1790. local int cmptime(p, q)
  1791. struct tm *p, *q;       /* times to compare */
  1792. /* Return negative if time p is before time q, positive if after, and
  1793.    zero if the same */
  1794. {
  1795.   int r;                /* temporary variable */
  1796.  
  1797.   if (p == NULL)
  1798.     return -1;
  1799.   else if ((r = p->tm_year - q->tm_year) != 0)
  1800.     return r;
  1801.   else if ((r = p->tm_mon - q->tm_mon) != 0)
  1802.     return r;
  1803.   else if ((r = p->tm_mday - q->tm_mday) != 0)
  1804.     return r;
  1805.   else if ((r = p->tm_hour - q->tm_hour) != 0)
  1806.     return r;
  1807.   else if ((r = p->tm_min - q->tm_min) != 0)
  1808.     return r;
  1809.   else
  1810.     return p->tm_sec - q->tm_sec;
  1811. }
  1812.  
  1813.  
  1814. local time_t invlocal(t)
  1815. struct tm *t;           /* time to convert */
  1816. /* Find inverse of localtime() using bisection.  This routine assumes that
  1817.    time_t is an integer type, either signed or unsigned.  The expectation
  1818.    is that sometime before the year 2038, time_t will be made a 64-bit
  1819.    integer, and this routine will still work. */
  1820. {
  1821.   time_t i;             /* midpoint of current root range */
  1822.   time_t l;             /* lower end of root range */
  1823.   time_t u;             /* upper end of root range */
  1824.  
  1825.   /* Bracket the root [0,largest time_t].  Note: if time_t is a 32-bit signed
  1826.      integer, then the upper bound is GMT 1/19/2038 03:14:07, after which all
  1827.      the Unix systems in the world come to a grinding halt.  Either that, or
  1828.      all those systems will suddenly find themselves transported to December
  1829.      of 1901 ... */
  1830.   l = 0;
  1831.   u = 1;
  1832.   while (u < (u << 1))
  1833.     u = (u << 1) + 1;
  1834.  
  1835.   /* Find the root */
  1836.   while (u - l > 1)
  1837.   {
  1838.     i = l + ((u - l) >> 1);
  1839.     if (cmptime(localtime(&i), t) <= 0)
  1840.       l = i;
  1841.     else
  1842.       u = i;
  1843.   }
  1844.   return l;
  1845. }
  1846. #endif
  1847. #endif
  1848.  
  1849.  
  1850. void stamp(f, d)
  1851. char *f;                /* name of file to change */
  1852. ulg d;                  /* dos-style time to change it to */
  1853. /* Set last updated and accessed time of file f to the DOS time d. */
  1854. {
  1855. #if defined(MACOS)
  1856.   warn("timestamp not implemented yet", "");
  1857. #else
  1858. #ifdef __TURBOC__
  1859.   int h;                /* file handle */
  1860.  
  1861.   if ((h = open(f, 0)) != -1)
  1862.   {
  1863. #ifdef ATARI_ST
  1864.     d = ( d >> 16 ) | ( d << 16 );
  1865. #endif
  1866.     setftime(h, (struct ftime *)&d);
  1867.     close(h);
  1868.   }
  1869. #else /* !__TURBOC__ */
  1870. #ifdef VMS
  1871.   int tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year;
  1872.   char timbuf[24];
  1873.   static char *month[] = {"JAN", "FEB", "MAR", "APR", "MAY", "JUN",
  1874.                           "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
  1875.   struct VMStimbuf {
  1876.       char *actime;           /* VMS revision date, ASCII format */
  1877.       char *modtime;          /* VMS creation date, ASCII format */
  1878.   } ascii_times = {timbuf, timbuf};
  1879.  
  1880.   /* Convert DOS time to ASCII format for VMSmunch */
  1881.   tm_sec = (int)(d << 1) & 0x3e;
  1882.   tm_min = (int)(d >> 5) & 0x3f;
  1883.   tm_hour = (int)(d >> 11) & 0x1f;
  1884.   tm_mday = (int)(d >> 16) & 0x1f;
  1885.   tm_mon = ((int)(d >> 21) & 0xf) - 1;
  1886.   tm_year = ((int)(d >> 25) & 0x7f) + 1980;
  1887.   sprintf(timbuf, "%02d-%3s-%04d %02d:%02d:%02d.00", tm_mday, month[tm_mon],
  1888.     tm_year, tm_hour, tm_min, tm_sec);
  1889.  
  1890.   /* Set updated and accessed times of f */
  1891.   if (VMSmunch(f, SET_TIMES, &ascii_times) != RMS$_NMF)
  1892.     warn("can't set zipfile time: ", f);
  1893.  
  1894. #else /* !VMS */
  1895. #ifdef OS2
  1896.   SetFileTime(f, d);
  1897. #else /* !OS2 */
  1898.   struct tm t;          /* argument for mktime() or invlocal() */
  1899. #if defined(WIN32) || defined(sgi)
  1900.   struct utimbuf u;     /* argument for utime() */
  1901. #else
  1902.   time_t u[2];          /* argument for utime() */
  1903. #endif
  1904. #ifndef __GO32__
  1905.   extern time_t mktime OF((struct tm *));
  1906. #endif
  1907.  
  1908.   /* Convert DOS time to time_t format in u[0] and u[1] */
  1909.   t.tm_sec = (int)(d << 1) & 0x3e;
  1910.   t.tm_min = (int)(d >> 5) & 0x3f;
  1911.   t.tm_hour = (int)(d >> 11) & 0x1f;
  1912.   t.tm_mday = (int)(d >> 16) & 0x1f;
  1913.   t.tm_mon = ((int)(d >> 21) & 0xf) - 1;
  1914.   t.tm_year = ((int)(d >> 25) & 0x7f) + 80;
  1915. #if defined(WIN32) || defined (sgi)
  1916.   u.actime = u.modtime = mktime(&t);
  1917. #else
  1918. # if defined(MSDOS) || defined(OS2) || defined(CRAY)
  1919.   /* mktime() is more reliable than invlocal() because the time range is
  1920.    * wider on MSDOS than on Unix; required for Cray because invlocal assumes
  1921.    * 32-bit ints
  1922.    */
  1923.   u[0] = u[1] = mktime(&t);
  1924. # else
  1925.   u[0] = u[1] = invlocal(&t);
  1926. # endif
  1927. #endif
  1928.  
  1929.   /* Set updated and accessed times of f */
  1930. #if defined(WIN32) || defined(sgi)
  1931.   utime(f, &u);
  1932. #else
  1933.   utime(f, u);
  1934. #endif
  1935. #endif /* ?OS2 */
  1936. #endif /* ?VMS */
  1937. #endif /* ?__TURBOC__ */
  1938. #endif /* ?MACOS */
  1939. }
  1940.  
  1941.  
  1942. local void inctime(s)
  1943. struct tm *s;           /* time to increment in place */
  1944. /* Increment the time structure *s by one second, return the result in
  1945.    place. */
  1946. {
  1947.   int y;                /* temporary variable */
  1948.  
  1949.   /* days in each month, except for February */
  1950.   static int days[] = {31,0,31,30,31,30,31,31,30,31,30,31};
  1951.  
  1952.   /* Set days in February from year (1900 is a leap year, 2000 is not) */
  1953.   y = s->tm_year + 1900;
  1954.   days[1] = y % 4 == 0 && (y % 100 != 0 || y % 400 == 0) ? 29 : 28;
  1955.  
  1956.   /* Increment time with carry */
  1957.   if (s->tm_sec != 59)
  1958.     s->tm_sec++;
  1959.   else if (s->tm_sec = 0, s->tm_min != 59)
  1960.     s->tm_min++;
  1961.   else if (s->tm_min = 0, s->tm_hour != 23)
  1962.     s->tm_hour++;
  1963.   else if (s->tm_hour = 0, s->tm_mday != days[s->tm_mon])
  1964.     s->tm_mday++;
  1965.   else if (s->tm_mday = 1, s->tm_mon != 11)
  1966.     s->tm_mon++;
  1967.   else
  1968.   {
  1969.     s->tm_mon = 0;
  1970.     s->tm_year++;
  1971.   }
  1972. }
  1973.  
  1974.  
  1975. ulg dostime(y, n, d, h, m, s)
  1976. int y;                  /* year */
  1977. int n;                  /* month */
  1978. int d;                  /* day */
  1979. int h;                  /* hour */
  1980. int m;                  /* minute */
  1981. int s;                  /* second */
  1982. /* Convert the date y/n/d and time h:m:s to a four byte DOS date and
  1983.    time (date in high two bytes, time in low two bytes allowing magnitude
  1984.    comparison). */
  1985. {
  1986.   return y < 1980 ? dostime(1980, 1, 1, 0, 0, 0) :
  1987.         (((ulg)y - 1980) << 25) | ((ulg)n << 21) | ((ulg)d << 16) |
  1988.         ((ulg)h << 11) | ((ulg)m << 5) | ((ulg)s >> 1);
  1989. }
  1990.  
  1991.  
  1992. local ulg unix2dostime(t)
  1993. statime *t;             /* unix time to convert */
  1994. /* Return the Unix time t in DOS format, rounded up to the next two
  1995.    second boundary. */
  1996. {
  1997.   struct tm *s;         /* result of localtime() */
  1998.  
  1999.   s = localtime(t);             /* Use local time since MSDOS does */
  2000.   inctime(s);                   /* Add one second to round up */
  2001.   return dostime(s->tm_year + 1900, s->tm_mon + 1, s->tm_mday,
  2002.                  s->tm_hour, s->tm_min, s->tm_sec);
  2003. }
  2004.  
  2005.  
  2006. ulg filetime(f, a, n)
  2007. char *f;                /* name of file to get info on */
  2008. ulg *a;                 /* return value: file attributes */
  2009. long *n;                /* return value: file size */
  2010. /* If file *f does not exist, return 0.  Else, return the file's last
  2011.    modified date and time as an MSDOS date and time.  The date and
  2012.    time is returned in a long with the date most significant to allow
  2013.    unsigned integer comparison of absolute times.  Also, if a is not
  2014.    a NULL pointer, store the file attributes there, with the high two
  2015.    bytes being the Unix attributes, and the low byte being a mapping
  2016.    of that to DOS attributes.  If n is not NULL, store the file size
  2017.    there.
  2018.    If f is "-", use standard input as the file. If f is a device, return
  2019.    a file size of -1 */
  2020. {
  2021.   struct stat s;        /* results of stat() */
  2022.   char name[FNMAX];
  2023.   int len = strlen(f);
  2024.  
  2025.   if (f == label) {
  2026.     if (a != NULL)
  2027.       *a = label_mode;
  2028.     if (n != NULL)
  2029.       *n = -2L; /* convention for a label name */
  2030.     return label_time;  /* does not work for unknown reason */
  2031.   }
  2032.   strcpy(name, f);
  2033.   if (name[len - 1] == '/')
  2034.     name[len - 1] = 0; 
  2035.   /* not all systems allow stat'ing a file with / appended */
  2036.  
  2037.   if (strcmp(f, "-") == 0) {
  2038. #if defined(AMIGA) && !defined(__SASC_60)
  2039.   /* forge stat values for stdin since Amiga has no fstat() */
  2040.     s.st_mode = (S_IREAD|S_IWRITE|S_IFREG); 
  2041.     s.st_size = -1;
  2042.     s.st_mtime = time(&s.st_mtime);
  2043. #else /* !AMIGA */
  2044.     if (fstat(fileno(stdin), &s) != 0)
  2045.       error("fstat(stdin)");
  2046. #endif /* ?AMIGA */
  2047.   } else if ((
  2048. #ifdef S_IFLNK
  2049.              linkput ? lstat(name, &s) :
  2050. #endif
  2051.              SSTAT(name, &s)) != 0)
  2052.              /* Accept about any file kind including directories
  2053.               * (stored with trailing / with -r option)
  2054.               */
  2055.     return 0;
  2056.  
  2057.   if (a != NULL) {
  2058. #if defined(MSDOS) || defined(OS2) || defined(__human68k__)
  2059.     *a = ((ulg)s.st_mode << 16) | (ulg)GetFileMode(name);
  2060. #else
  2061.     *a = ((ulg)s.st_mode << 16) | !(s.st_mode & S_IWRITE);
  2062.     if ((s.st_mode & S_IFDIR) != 0) {
  2063.       *a |= MSDOS_DIR_ATTR;
  2064.     }
  2065. #endif
  2066.   }
  2067.   if (n != NULL)
  2068.     *n = (s.st_mode & S_IFMT) != S_IFREG ? -1L : s.st_size;
  2069.  
  2070. #ifdef OS2
  2071.   return GetFileTime(name);
  2072. #else /* !OS2 */
  2073. #  ifdef VMS
  2074.      return unix2dostime(&s.st_ctime);   /* Use creation time in VMS */
  2075. #  else /* !VMS */
  2076. #    ifdef ATARI_ST
  2077.        return s.st_mtime; /* Turbo C doesn't use UNIX times */
  2078. #    else
  2079. #      ifdef WIN32
  2080.          return GetTheFileTime(name);
  2081. #      else
  2082.          return unix2dostime((statime*)&s.st_mtime);
  2083. #      endif /* WIN32 */
  2084. #    endif
  2085. #  endif /* ?VMS */
  2086. #endif /* ?OS2 */
  2087. }
  2088.  
  2089. #ifdef TOPS20
  2090. #  include <monsym.h>   /* Get amazing monsym() macro */
  2091. #  define       _FBBYV  monsym(".FBBYV")
  2092. #  define         FBBSZ_S       -24     /* Obsolete, replace by FLDGET! */
  2093. #  define         FBBSZ_M       077     /* ditto */
  2094.  
  2095. extern int _gtjfn(), _rljfn(), _gtfdb(), stat();
  2096.  
  2097. int set_extra_field(z)
  2098.   struct zlist *z;
  2099.   /* create extra field and change z->att if desired */
  2100. {
  2101.   int jfn;
  2102.  
  2103.   translate_eol = 0;
  2104.   jfn = _gtjfn(z->name, O_RDONLY);
  2105.   z->att = (((_gtfdb (jfn, _FBBYV) << FBBSZ_S) & FBBSZ_M) != 8) ?
  2106.            ASCII :BINARY;
  2107.   _rljfn(jfn);
  2108.   return 0;
  2109. }
  2110. #else /* !TOPS20 */
  2111. # if !defined(OS2) && !defined(VMS)
  2112.  
  2113. int set_extra_field(z)
  2114.   struct zlist *z;
  2115.   /* create extra field and change z->att if desired */
  2116. {
  2117.   return (int)(z-z);
  2118. }
  2119. # endif /* !OS2 && !VMS */
  2120. #endif /* TOPS20 */
  2121.  
  2122.  
  2123.  
  2124. int issymlnk(a)
  2125. ulg a;                  /* Attributes returned by filetime() */
  2126. /* Return true if the attributes are those of a symbolic link */
  2127. {
  2128. #ifdef S_IFLNK
  2129.   return ((a >> 16) & S_IFMT) == S_IFLNK;
  2130. #else /* !S_IFLNK */
  2131.   return (int)a & 0;    /* avoid warning on unused parameter */
  2132. #endif /* ?S_IFLNK */
  2133. }
  2134.  
  2135.  
  2136. int deletedir(d)
  2137. char *d;                /* directory to delete */
  2138. /* Delete the directory *d if it is empty, do nothing otherwise.
  2139.    Return the result of rmdir(), delete(), or system().
  2140.    For VMS, d must be in format [x.y]z.dir;1  (not [x.y.z]).
  2141.  */
  2142. {
  2143. #if (defined(MACOS) || defined(TOPS20))
  2144.     warn("deletedir not implemented yet", "");
  2145.     return 127;
  2146. #else
  2147. # ifdef RMDIR
  2148.     /* code from Greg Roelofs, who horked it from Mark Edwards (unzip) */
  2149.     int r, len;
  2150.     char *s;              /* malloc'd string for system command */
  2151.  
  2152.     len = strlen(d);
  2153.     if ((s = malloc(len + 34)) == NULL)
  2154.       return 127;
  2155.  
  2156. #  ifdef VMS
  2157.     system(strcat(strcpy(s, "set prot=(o:rwed) "), d));
  2158.     r = delete(d);
  2159. #  else /* !VMS */
  2160.     sprintf(s, "IFS=\" \t\n\" /bin/rmdir %s 2>/dev/null", d);
  2161.     r = system(s);
  2162. #  endif /* ?VMS */
  2163.     free(s);
  2164.     return r;
  2165. # else /* !RMDIR */
  2166.     return rmdir(d);
  2167. # endif /* ?RMDIR */
  2168. #endif /* ? MACOS || TOPS20 */
  2169. }
  2170.  
  2171.  
  2172. #endif /* !UTIL */
  2173.  
  2174. int destroy(f)
  2175. char *f;                /* file to delete */
  2176. /* Delete the file *f, returning non-zero on failure. */
  2177. {
  2178.   return unlink(f);
  2179. }
  2180.  
  2181.  
  2182. int replace(d, s)
  2183. char *d, *s;            /* destination and source file names */
  2184. /* Replace file *d by file *s, removing the old *s.  Return an error code
  2185.    in the ZE_ class. This function need not preserve the file attributes,
  2186.    this will be done by setfileattr() later.
  2187.  */
  2188. {
  2189.   struct stat t;        /* results of stat() */
  2190.   int copy = 0;
  2191.   int d_exists;
  2192.  
  2193. #ifdef VMS
  2194.   /* stat() is broken on VMS remote files (accessed through Decnet).
  2195.    * This patch allows creation of remote zip files, but is not sufficient
  2196.    * to update them or compress remote files */
  2197.   unlink(d);
  2198. #else
  2199.   d_exists = (LSTAT(d, &t) == 0);
  2200.   if (d_exists)
  2201.   {
  2202.     /*
  2203.      * respect existing soft and hard links!
  2204.      */
  2205.     if (t.st_nlink > 1
  2206. # ifdef S_IFLNK
  2207.         || (t.st_mode & S_IFMT) == S_IFLNK
  2208. # endif
  2209.         )
  2210.        copy = 1;
  2211.     else if (unlink(d))
  2212.        return ZE_CREAT;                 /* Can't erase zip file--give up */
  2213.   }
  2214. #endif /* VMS */
  2215.   if (!copy) {
  2216.       if (link(s, d)) {               /* Just move s on top of d */
  2217.           copy = 1;                     /* failed ? */
  2218. #if !defined(VMS) && !defined(ATARI_ST) && !defined(AZTEC_C)
  2219.     /* For VMS & ATARI & AMIGA Aztec assume failure is EXDEV */
  2220.           if (errno != EXDEV
  2221. #  ifdef ENOTSAM
  2222.            && errno != ENOTSAM /* Used at least on Turbo C */
  2223. #  endif
  2224.               ) return ZE_CREAT;
  2225. #endif
  2226.       }
  2227. #ifndef link    /* UNIX link() */
  2228.       /*
  2229.        * Assuming a UNIX link(2), we still have to remove s.
  2230.        * If link has been #defined to rename(), nothing to do.
  2231.        */
  2232.       else {
  2233. # ifdef KEEP_OWNER
  2234.           if (d_exists)
  2235.               /* this will fail if the user isn't priviledged */
  2236.               chown(d, t.st_uid, t.st_gid);
  2237. # endif
  2238.           unlink(s);
  2239.       }
  2240. #endif          /* ?UNIX link() */
  2241.   }
  2242.  
  2243.   if (copy) {
  2244.     FILE *f, *g;      /* source and destination files */
  2245.     int r;            /* temporary variable */
  2246.  
  2247.     if ((f = fopen(s, FOPR)) == NULL) {
  2248.       fprintf(stderr," replace: can't open %s\n", s);
  2249.       return ZE_TEMP;
  2250.     }
  2251.     if ((g = fopen(d, FOPW)) == NULL)
  2252.     {
  2253.       fclose(f);
  2254.       return ZE_CREAT;
  2255.     }
  2256.     r = fcopy(f, g, (ulg)-1L);
  2257.     fclose(f);
  2258.     if (fclose(g) || r != ZE_OK)
  2259.     {
  2260.       unlink(d);
  2261.       return r ? (r == ZE_TEMP ? ZE_WRITE : r) : ZE_WRITE;
  2262.     }
  2263.     unlink(s);
  2264.   }
  2265.   return ZE_OK;
  2266. }
  2267.  
  2268.  
  2269. int getfileattr(f)
  2270. char *f;                /* file path */
  2271. /* Return the file attributes for file f or 0 if failure */
  2272. {
  2273.   struct stat s;
  2274.  
  2275.   return SSTAT(f, &s) == 0 ? s.st_mode : 0;
  2276. }
  2277.  
  2278.  
  2279. int setfileattr(f, a)
  2280. char *f;                /* file path */
  2281. int a;                  /* attributes returned by getfileattr() */
  2282. /* Give the file f the attributes a, return non-zero on failure */
  2283. {
  2284. #if defined(MACOS) || defined(TOPS20)
  2285.   return 0;
  2286. #else
  2287.   return chmod(f, a);
  2288. #endif
  2289. }
  2290.  
  2291.  
  2292. char *tempname(zip)
  2293.   char *zip;              /* path name of zip file to generate temp name for */
  2294.  
  2295. /* Return a temporary file name in its own malloc'ed space, using tempath. */
  2296. {
  2297.   char *t = zip;   /* malloc'ed space for name (use zip to avoid warning) */
  2298.  
  2299.   if (tempath != NULL)
  2300.   {
  2301.     if ((t = malloc(strlen(tempath)+12)) == NULL)
  2302.       return NULL;
  2303.     strcpy(t, tempath);
  2304. #if (!defined(VMS) && !defined(TOPS20))
  2305. #  ifdef AMIGA
  2306.     {
  2307.           char c = t[strlen(t)-1];
  2308.           if (c != '/' && c != ':')
  2309.             strcat(t, "/");
  2310.     }
  2311. #  else /* !AMIGA */
  2312.           
  2313.     if (t[strlen(t)-1] != '/')
  2314.       strcat(t, "/");
  2315. #  endif  /* ?AMIGA */            
  2316. #endif
  2317.   }
  2318.   else
  2319.   {
  2320.     if ((t = malloc(12)) == NULL)
  2321.       return NULL;
  2322.     *t = 0;
  2323.   }
  2324. #ifdef NO_MKTEMP
  2325.   {
  2326.     char *p = t + strlen(t);
  2327.     sprintf(p, "%08lx", (ulg)time(NULL));
  2328.     return t;
  2329.   }
  2330. #else
  2331.   strcat(t, "_ZXXXXXX");
  2332.   return mktemp(t);
  2333. #endif
  2334. }
  2335.  
  2336.  
  2337. int fcopy(f, g, n)
  2338. FILE *f, *g;            /* source and destination files */
  2339. ulg n;                  /* number of bytes to copy or -1 for all */
  2340. /* Copy n bytes from file *f to file *g, or until EOF if n == -1.  Return
  2341.    an error code in the ZE_ class. */
  2342. {
  2343.   char *b;              /* malloc'ed buffer for copying */
  2344.   extent k;             /* result of fread() */
  2345.   ulg m;                /* bytes copied so far */
  2346.  
  2347.   if ((b = malloc(CBSZ)) == NULL)
  2348.     return ZE_MEM;
  2349.   m = 0;
  2350.   while (n == -1L || m < n)
  2351.   {
  2352.     if ((k = fread(b, 1, n == -1 ?
  2353.                    CBSZ : (n - m < CBSZ ? (extent)(n - m) : CBSZ), f)) == 0)
  2354.       if (ferror(f))
  2355.       {
  2356.         free((voidp *)b);
  2357.         return ZE_READ;
  2358.       }
  2359.       else
  2360.         break;
  2361.     if (fwrite(b, 1, k, g) != k)
  2362.     {
  2363.       free((voidp *)b);
  2364.       fprintf(stderr," fcopy: write error\n");
  2365.       return ZE_TEMP;
  2366.     }
  2367.     m += k;
  2368.   }
  2369.   free((voidp *)b);
  2370.   return ZE_OK;
  2371. }
  2372.  
  2373.  
  2374. #ifdef ZMEM
  2375.  
  2376. /************************/
  2377. /*  Function memset()  */
  2378. /************************/
  2379.  
  2380. /*
  2381.  * memset - for systems without it
  2382.  *  bill davidsen - March 1990
  2383.  */
  2384.  
  2385. char *
  2386. memset(buf, init, len)
  2387. register char *buf;     /* buffer loc */
  2388. register int init;      /* initializer */
  2389. register unsigned int len;   /* length of the buffer */
  2390. {
  2391.     char *start;
  2392.  
  2393.     start = buf;
  2394.     while (len--) *(buf++) = init;
  2395.     return(start);
  2396. }
  2397.  
  2398.  
  2399. /************************/
  2400. /*  Function memcpy()  */
  2401. /************************/
  2402.  
  2403. char *
  2404. memcpy(dst,src,len)           /* v2.0f */
  2405. register char *dst, *src;
  2406. register unsigned int len;
  2407. {
  2408.     char *start;
  2409.  
  2410.     start = dst;
  2411.     while (len--)
  2412.         *dst++ = *src++;
  2413.     return(start);
  2414. }
  2415.  
  2416.  
  2417. /************************/
  2418. /*  Function memcmp()  */
  2419. /************************/
  2420.  
  2421. int
  2422. memcmp(b1,b2,len)                     /* jpd@usl.edu -- 11/16/90 */
  2423. register char *b1, *b2;
  2424. register unsigned int len;
  2425. {
  2426.  
  2427.     if (len) do {             /* examine each byte (if any) */
  2428.       if (*b1++ != *b2++)
  2429.         return (*((uch *)b1-1) - *((uch *)b2-1));  /* exit when miscompare */
  2430.        } while (--len);
  2431.  
  2432.     return(0);        /* no miscompares, yield 0 result */
  2433. }
  2434.  
  2435. #endif  /* ZMEM */
  2436.  
  2437. #ifdef TOPS20
  2438.  
  2439. int
  2440. strupper(s)     /* Returns s in uppercase */
  2441. char *s;        /* String to be uppercased */
  2442. {
  2443.     char    *p;
  2444.  
  2445.     p = s;
  2446.     for (; *p; p++)
  2447.         *p = toupper (*p);
  2448. }
  2449.  
  2450. int
  2451. strlower(s)     /* Returns s in lowercase. */
  2452. char *s;        /* String to be lowercased */
  2453. {
  2454.     char    *p;
  2455.  
  2456.     p = s;
  2457.     for (; *p; p++)
  2458.         *p = tolower (*p);
  2459. }
  2460. #endif /* TOPS20 */
  2461.  
  2462. #if defined(__TURBOC__) && !defined(OS2)
  2463.  
  2464. /************************/
  2465. /*  Function fcalloc()  */
  2466. /************************/
  2467.  
  2468. /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
  2469.  * and farmalloc(64K) returns a pointer with an offset of 8, so we
  2470.  * must fix the pointer. Warning: the pointer must be put back to its
  2471.  * original form in order to free it, use fcfree().
  2472.  * For MSC, use halloc instead of this function (see tailor.h).
  2473.  */
  2474. static ush ptr_offset = 0;
  2475.  
  2476. void * fcalloc(items, size)
  2477.     unsigned items; /* number of items */
  2478.     unsigned size;  /* item size */
  2479. {
  2480.     void * buf = farmalloc((ulg)items*size + 16L);
  2481.     if (buf == NULL) return NULL;
  2482.     /* Normalize the pointer to seg:0 */
  2483.     if (ptr_offset == 0) {
  2484.         ptr_offset = (ush)((uch*)buf-0);
  2485.     } else if (ptr_offset != (ush)((uch*)buf-0)) {
  2486.         err(ZE_LOGIC, "inconsistent ptr_offset");
  2487.     }
  2488.     *((ush*)&buf+1) += (ptr_offset + 15) >> 4;
  2489.     *(ush*)&buf = 0;
  2490.     return buf;
  2491. }
  2492.  
  2493. void fcfree(ptr)
  2494.     void *ptr; /* region allocated with fcalloc() */
  2495. {
  2496.     /* Put the pointer back to its original form: */
  2497.     *((ush*)&ptr+1) -= (ptr_offset + 15) >> 4;
  2498.     *(ush*)&ptr = ptr_offset;
  2499.     farfree(ptr);
  2500.  }
  2501.  
  2502. #endif /* __TURBOC__ && !OS2 */
  2503.