home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 9 Archive / 09-Archive.zip / zip21.zip / amiga / amigazip.c < prev    next >
C/C++ Source or Header  |  1996-04-05  |  15KB  |  521 lines
  1. /*
  2.  
  3.  Copyright (C) 1990-1996 Mark Adler, Richard B. Wales, Jean-loup Gailly,
  4.  Kai Uwe Rommel, Onno van der Linden, Igor Mandrichenko, Paul Kienitz and
  5.  John Bush.
  6.  Permission is granted to any individual or institution to use, copy, or
  7.  redistribute this software so long as all of the original files are included,
  8.  that it is not sold for profit, and that this copyright notice is retained.
  9.  
  10. */
  11.  
  12. #include "zip.h"
  13. #include "amiga/amiga.h"
  14.  
  15. #include <time.h>
  16.  
  17. #define MATCH shmatch
  18. #define utime FileDate
  19.  
  20. #ifdef __SASC_60
  21. #  include <dos.h>               /* SAS/C 6.x , pulled by wild() */
  22. #endif
  23. #ifdef MODERN
  24. #  include <clib/dos_protos.h>
  25. #endif
  26.  
  27.  
  28. #define PAD 0
  29. #define PATH_END '/'
  30. #define ONENAMELEN 30
  31.  
  32. #ifndef UTIL    /* the companion #endif is a bit of ways down ... */
  33.  
  34. /* Local globals (kinda like "military intelligence" or "broadcast quality") */
  35.  
  36. extern char *label;             /* still declared in fileio.c */
  37. local ulg label_time = 0;
  38. local ulg label_mode = 0;
  39. local time_t label_utim = 0;
  40.  
  41. /* Local functions */
  42. local char *readd OF((DIR *));
  43. local int wild_recurse OF((char *, char *));
  44.  
  45.  
  46. #define opend opendir
  47.  
  48. local char *readd(d)
  49. DIR *d;                 /* directory stream to read from */
  50. /* Return a pointer to the next name in the directory stream d, or NULL if
  51.    no more entries or an error occurs. */
  52. {
  53.   struct dirent *e = readdir(d);
  54.   return e == NULL ? (char *) NULL : e->d_name;
  55. }
  56.  
  57.  
  58. /* What we have here is a mostly-generic routine using opendir()/readd() and */
  59. /* isshexp()/MATCH() to find all the files matching a multi-part filespec  */
  60. /* using the portable pattern syntax.  It shouldn't take too much fiddling */
  61. /* to make it usable for any other platform that has directory hierarchies */
  62. /* but no shell-level pattern matching.  It works for patterns throughout  */
  63. /* the pathname, such as "foo:*.?/source/x*.[ch]".                         */
  64.  
  65. #define ONENAMELEN 30
  66. /* the length of one filename component on the Amiga */
  67.  
  68. /* whole is a pathname with wildcards, wildtail points somewhere in the  */
  69. /* middle of it.  All wildcards to be expanded must come AFTER wildtail. */
  70.  
  71. local int wild_recurse(whole, wildtail) char *whole; char *wildtail;
  72. {
  73.     DIR *dir;
  74.     char *subwild, *name, *newwhole = NULL, *glue = NULL, plug = 0, plug2;
  75.     ush newlen, amatch = 0;
  76.     BPTR lok;
  77.     int e = ZE_MISS;
  78.  
  79.     if (!isshexp(wildtail))
  80.         if (lok = Lock(whole, ACCESS_READ)) {       /* p exists? */
  81.             UnLock(lok);
  82.             return procname(whole);
  83.         } else
  84.             return ZE_MISS;                     /* woops, no wildcards! */
  85.  
  86.     /* back up thru path components till existing dir found */
  87.     do {
  88.         name = wildtail + strlen(wildtail) - 1;
  89.         for (;;)
  90.             if (name-- <= wildtail || *name == PATH_END) {
  91.                 subwild = name + 1;
  92.                 plug2 = *subwild;
  93.                 *subwild = 0;
  94.                 break;
  95.             }
  96.         if (glue)
  97.             *glue = plug;
  98.         glue = subwild;
  99.         plug = plug2;
  100.         dir = opendir(whole);
  101.     } while (!dir && !disk_not_mounted && subwild > wildtail);
  102.     wildtail = subwild;                 /* skip past non-wild components */
  103.  
  104.     if (subwild = strchr(wildtail + 1, PATH_END)) {
  105.         /* this "+ 1" dodges the  ^^^ hole left by *glue == 0 */
  106.         *(subwild++) = 0;               /* wildtail = one component pattern */
  107.         newlen = strlen(whole) + strlen(subwild) + ONENAMELEN + 2;
  108.     } else
  109.         newlen = strlen(whole) + ONENAMELEN + 1;
  110.     if (!dir || !(newwhole = malloc(newlen))) {
  111.         if (glue)
  112.             *glue = plug;
  113.  
  114.         e = dir ? ZE_MEM : ZE_MISS;
  115.         goto ohforgetit;
  116.     }
  117.     strcpy(newwhole, whole);
  118.     newlen = strlen(newwhole);
  119.     if (glue)
  120.         *glue = plug;                           /* repair damage to whole */
  121.     if (!isshexp(wildtail)) {
  122.         e = ZE_MISS;                            /* non-wild name not found */
  123.         goto ohforgetit;
  124.     }
  125.  
  126.     while (name = readd(dir)) {
  127.         if (MATCH(wildtail, name)) {
  128.             strcpy(newwhole + newlen, name);
  129.             if (subwild) {
  130.                 name = newwhole + strlen(newwhole);
  131.                 *(name++) = PATH_END;
  132.                 strcpy(name, subwild);
  133.                 e = wild_recurse(newwhole, name);
  134.             } else
  135.                 e = procname(newwhole);
  136.             newwhole[newlen] = 0;
  137.             if (e == ZE_OK)
  138.                 amatch = 1;
  139.             else if (e != ZE_MISS)
  140.                 break;
  141.         }
  142.     }
  143.  
  144.   ohforgetit:
  145.     if (dir) closedir(dir);
  146.     if (subwild) *--subwild = PATH_END;
  147.     if (newwhole) free(newwhole);
  148.     if (e == ZE_MISS && amatch)
  149.         e = ZE_OK;
  150.     return e;
  151. }
  152.  
  153. int wild(p) char *p;
  154. {
  155.     char *use;
  156.  
  157.     /* special handling of stdin request */
  158.     if (strcmp(p, "-") == 0)    /* if compressing stdin */
  159.         return newname(p, 0);
  160.  
  161.     /* wild_recurse() can't handle colons in wildcard part: */
  162.     if (use = strchr(p, ':')) {
  163.         if (strchr(++use, ':'))
  164.             return ZE_PARMS;
  165.     } else
  166.         use = p;
  167.  
  168.     return wild_recurse(p, use);
  169. }
  170.  
  171.  
  172. int procname(n)
  173. char *n;                /* name to process */
  174. /* Process a name or sh expression to operate on (or exclude).  Return
  175.    an error code in the ZE_ class. */
  176. {
  177.   char *a;              /* path and name for recursion */
  178.   DIR *d;               /* directory stream from opendir() */
  179.   char *e;              /* pointer to name from readd() */
  180.   int m;                /* matched flag */
  181.   char *p;              /* path for recursion */
  182.   struct stat s;        /* result of stat() */
  183.   struct zlist far *z;  /* steps through zfiles list */
  184.  
  185.   if (strcmp(n, "-") == 0)   /* if compressing stdin */
  186.     return newname(n, 0);
  187.   else if (LSSTAT(n, &s))
  188.   {
  189.     /* Not a file or directory--search for shell expression in zip file */
  190.     p = ex2in(n, 0, (int *)NULL);       /* shouldn't affect matching chars */
  191.     m = 1;
  192.     for (z = zfiles; z != NULL; z = z->nxt) {
  193.       if (MATCH(p, z->zname))
  194.       {
  195.         z->mark = pcount ? filter(z->zname) : 1;
  196.         if (verbose)
  197.             fprintf(mesg, "zip diagnostic: %scluding %s\n",
  198.                z->mark ? "in" : "ex", z->name);
  199.         m = 0;
  200.       }
  201.     }
  202.     free((zvoid *)p);
  203.     return m ? ZE_MISS : ZE_OK;
  204.   }
  205.  
  206.   /* Live name--use if file, recurse if directory */
  207.   if ((s.st_mode & S_IFDIR) == 0)
  208.   {
  209.     /* add or remove name of file */
  210.     if ((m = newname(n, 0)) != ZE_OK)
  211.       return m;
  212.   } else {
  213.     /* Add trailing / to the directory name */
  214.     if ((p = malloc(strlen(n)+2)) == NULL)
  215.       return ZE_MEM;
  216.     strcpy(p, n);
  217.     a = p + strlen(p);
  218.     if (*p && a[-1] != '/' && a[-1] != ':')
  219.       strcpy(a, "/");
  220.     if (dirnames && (m = newname(p, 1)) != ZE_OK) {
  221.       free((zvoid *)p);
  222.       return m;
  223.     }
  224.     /* recurse into directory */
  225.     if (recurse && (d = opendir(n)) != NULL)
  226.     {
  227.       while ((e = readd(d)) != NULL) {
  228.         if ((a = malloc(strlen(p) + strlen(e) + 1)) == NULL)
  229.         {
  230.           closedir(d);
  231.           free((zvoid *)p);
  232.           return ZE_MEM;
  233.         }
  234.         strcat(strcpy(a, p), e);
  235.         if ((m = procname(a)) != ZE_OK)   /* recurse on name */
  236.         {
  237.           if (m == ZE_MISS)
  238.             zipwarn("name not matched: ", a);
  239.           else
  240.             ziperr(m, a);
  241.         }
  242.         free((zvoid *)a);
  243.       }
  244.       closedir(d);
  245.     }
  246.     free((zvoid *)p);
  247.   } /* (s.st_mode & S_IFDIR) == 0) */
  248.   return ZE_OK;
  249. }
  250.  
  251. char *ex2in(x, isdir, pdosflag)
  252. char *x;                /* external file name */
  253. int isdir;              /* input: x is a directory */
  254. int *pdosflag;          /* output: force MSDOS file attributes? */
  255. /* Convert the external file name to a zip file name, returning the malloc'ed
  256.    string or NULL if not enough memory. */
  257. {
  258.   char *n;              /* internal file name (malloc'ed) */
  259.   char *t;              /* shortened name */
  260.   int dosflag;
  261.  
  262.   dosflag = dosify;     /* default for non-DOS and non-OS/2 */
  263.  
  264.   /* Find starting point in name before doing malloc */
  265.   if ((t = strrchr(x, ':')) != NULL)    /* reject ":" */
  266.     t++;
  267.   else
  268.     t = x;
  269.   {                                     /* reject "//" */
  270.     char *tt = t;
  271.     while (tt = strchr(tt, '/'))
  272.       while (*++tt == '/')
  273.         t = tt;
  274.   }
  275.   while (*t == '/')             /* reject leading "/" on what's left */
  276.     t++;
  277.  
  278.   if (!pathput)
  279.     t = last(t, PATH_END);
  280.  
  281.   /* Malloc space for internal name and copy it */
  282.   if ((n = malloc(strlen(t) + 1)) == NULL)
  283.     return NULL;
  284.   strcpy(n, t);
  285.  
  286.   if (dosify)
  287.     msname(n);
  288.   /* Returned malloc'ed name */
  289.   if (pdosflag)
  290.     *pdosflag = dosflag;
  291.   return n;
  292. }
  293.  
  294. char *in2ex(n)
  295. char *n;                /* internal file name */
  296. /* Convert the zip file name to an external file name, returning the malloc'ed
  297.    string or NULL if not enough memory. */
  298. {
  299.   char *x;              /* external file name */
  300.  
  301.   if ((x = malloc(strlen(n) + 1 + PAD)) == NULL)
  302.       return NULL;
  303.   strcpy(x, n);
  304.   return x;
  305. }
  306.  
  307. void stamp(f, d)
  308. char *f;                /* name of file to change */
  309. ulg d;                  /* dos-style time to change it to */
  310. /* Set last updated and accessed time of file f to the DOS time d. */
  311. {
  312.   time_t u[2];          /* argument for utime() */
  313.  
  314.   /* Convert DOS time to time_t format in u */
  315.   u[0] = u[1] = dos2unixtime(d);
  316.  
  317.   /* Set updated and accessed times of f */
  318.   utime(f, u);
  319. }
  320.  
  321. ulg filetime(f, a, n, t)
  322. char *f;                /* name of file to get info on */
  323. ulg *a;                 /* return value: file attributes */
  324. long *n;                /* return value: file size */
  325. ztimbuf *t;             /* return value: access and modification time */
  326. /* If file *f does not exist, return 0.  Else, return the file's last
  327.    modified date and time as an MSDOS date and time.  The date and
  328.    time is returned in a long with the date most significant to allow
  329.    unsigned integer comparison of absolute times.  Also, if a is not
  330.    a NULL pointer, store the file attributes there, with the high two
  331.    bytes being the Unix attributes, and the low byte being a mapping
  332.    of that to DOS attributes.  If n is not NULL, store the file size
  333.    there.  If t is not NULL, the file's access and modification time
  334.    are stored there as UNIX time_t values.
  335.    If f is "-", use standard input as the file. If f is a device, return
  336.    a file size of -1 */
  337. {
  338.   struct stat s;        /* results of stat() */
  339.   char name[FNMAX];
  340.   int len = strlen(f);
  341.  
  342.   if (f == label) {
  343.     if (a != NULL)
  344.       *a = label_mode;
  345.     if (n != NULL)
  346.       *n = -2L; /* convention for a label name */
  347.     if (t != NULL)
  348.       t->actime = t->modtime = label_utim;
  349.     return label_time;
  350.   }
  351.   strcpy(name, f);
  352.   if (name[len - 1] == '/')
  353.     name[len - 1] = '\0';
  354.   /* not all systems allow stat'ing a file with / appended */
  355.  
  356.   if (strcmp(f, "-") == 0) {
  357. #ifndef __SASC_60
  358.   /* forge stat values for stdin since Amiga has no fstat() */
  359.     s.st_mode = (S_IREAD|S_IWRITE|S_IFREG);
  360.     s.st_size = -1;
  361.     s.st_mtime = time(&s.st_mtime);
  362. #else
  363.     if (fstat(fileno(stdin), &s) != 0)
  364.       error("fstat(stdin)");
  365. #endif
  366.   } else if (SSTAT(name, &s) != 0)
  367.              /* Accept about any file kind including directories
  368.               * (stored with trailing / with -r option)
  369.               */
  370.     return 0;
  371.  
  372.   if (a != NULL) {
  373.     *a = ((ulg)s.st_mode << 16) | !(s.st_mode & S_IWRITE);
  374.     if ((s.st_mode & S_IFDIR) != 0) {
  375.       *a |= MSDOS_DIR_ATTR;
  376.     }
  377.   }
  378.   if (n != NULL)
  379.     *n = (s.st_mode & S_IFMT) == S_IFREG ? s.st_size : -1L;
  380.   if (t != NULL) {
  381.     t->actime = s.st_atime;
  382.     t->modtime = s.st_mtime;
  383.   }
  384.  
  385.    return unix2dostime(&s.st_mtime);
  386. }
  387.  
  388. int set_extra_field(z, z_utim)
  389.   struct zlist far *z;
  390.   ztimbuf *z_utim;
  391.   /* create extra field and change z->att if desired */
  392. {
  393. #ifdef USE_EF_UX_TIME
  394.   if ((z->extra = (char *)malloc(EB_HEADSIZE+EB_UX_MINLEN)) == NULL)
  395.     return ZE_MEM;
  396.  
  397.   z->extra[0]  = 'U';
  398.   z->extra[1]  = 'X';
  399.   z->extra[2]  = EB_UX_MINLEN;          /* length of data part of e.f. */
  400.   z->extra[3]  = 0;
  401.   z->extra[4]  = (char)(z_utim->actime);
  402.   z->extra[5]  = (char)(z_utim->actime >> 8);
  403.   z->extra[6]  = (char)(z_utim->actime >> 16);
  404.   z->extra[7]  = (char)(z_utim->actime >> 24);
  405.   z->extra[8]  = (char)(z_utim->modtime);
  406.   z->extra[9]  = (char)(z_utim->modtime >> 8);
  407.   z->extra[10] = (char)(z_utim->modtime >> 16);
  408.   z->extra[11] = (char)(z_utim->modtime >> 24);
  409.  
  410.   z->cext = z->ext = (EB_HEADSIZE+EB_UX_MINLEN);
  411.   z->cextra = z->extra;
  412.  
  413.   return ZE_OK;
  414. #else /* !USE_EF_UX_TIME */
  415.   return (int)(z-z);
  416. #endif /* ?USE_EF_UX_TIME */
  417. }
  418.  
  419. int deletedir(d)
  420. char *d;                /* directory to delete */
  421. /* Delete the directory *d if it is empty, do nothing otherwise.
  422.    Return the result of rmdir(), delete(), or system().
  423.    For VMS, d must be in format [x.y]z.dir;1  (not [x.y.z]).
  424.  */
  425. {
  426.     return rmdir(d);
  427. }
  428.  
  429. /******************************/
  430. /*  Function version_local()  */
  431. /******************************/
  432.  
  433.  
  434. /* NOTE:  the following include depends upon the environment
  435.  *        variable $Workbench to be set correctly.  (Set by
  436.  *        default, by kickstart during startup)
  437.  */
  438. int WBversion = (int)
  439. #include "ENV:Workbench"
  440. ;
  441.  
  442. void version_local()
  443. {
  444.    static const char CompiledWith[] = "Compiled with %s%s for %s%s%s%s.\n\n";
  445.  
  446. /* Define buffers. */
  447.  
  448.    char buf1[16];  /* compiler name */
  449.    char buf2[16];  /* revstamp */
  450.    char buf3[16];  /* OS */
  451.    char buf4[16];  /* Date */
  452. /*   char buf5[16];  /* Time */
  453.  
  454. /* format "with" name strings */
  455.  
  456. #ifdef AMIGA
  457. # ifdef __SASC
  458.    strcpy(buf1,"SAS/C ");
  459. # else
  460. #  ifdef LATTICE
  461.     strcpy(buf1,"Lattice C ");
  462. #  else
  463. #   ifdef AZTEC_C
  464.      strcpy(buf1,"Manx Aztec C ");
  465. #   else
  466.      strcpy(buf1,"UNKNOWN ");
  467. #   endif
  468. #  endif
  469. # endif
  470. /* "under" */
  471.   sprintf(buf3,"AmigaDOS v%d",WBversion);
  472. #else
  473.   strcpy(buf1,"Unknown compiler ");
  474.   strcpy(buf3,"Unknown OS");
  475. #endif
  476.  
  477. /* Define revision, date, and time strings.
  478.  * NOTE:  Do not calculate run time, be sure to use time compiled.
  479.  * Pass these strings via your makefile if undefined.
  480.  */
  481.  
  482. #if defined(__VERSION__) && defined(__REVISION__)
  483.   sprintf(buf2,"version %d.%d",__VERSION__,__REVISION__);
  484. #else
  485. # ifdef __VERSION__
  486.   sprintf(buf2,"version %d",__VERSION__);
  487. # else
  488.   sprintf(buf2,"unknown version");
  489. # endif
  490. #endif
  491.  
  492. #ifdef __DATE__
  493.   sprintf(buf4," on %s",__DATE__);
  494. #else
  495.   strcpy(buf4," unknown date");
  496. #endif
  497.  
  498. /******
  499. #ifdef __TIME__
  500.   sprintf(buf5," at %s",__TIME__);
  501. #else
  502.   strcpy(buf5," unknown time");
  503. #endif
  504. ******/
  505.  
  506. /* Print strings using "CompiledWith" mask defined in unzip.c (used by all).
  507.  *  ("Compiled with %s%s under %s%s%s%s.")
  508.  */
  509.  
  510.    printf(CompiledWith,
  511.      buf1,
  512.      buf2,
  513.      buf3,
  514.      buf4,
  515.      /* buf5, */ "",
  516.      "" );  /* buf6 not used */
  517.  
  518. } /* end function version_local() */
  519.  
  520. #endif /* !UTIL */
  521.