falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3928 Commits
16 Branches
14GB
Tree: 7b4507c663
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7b4507c663'
${ noResults }
Carla/data/windows/unzipfx-carla-control/unix/unix.c

1877 lines
61KB
Raw Blame History 

  1. /*

  2.   Copyright (c) 1990-2009 Info-ZIP.  All rights reserved.

  3. 

  4.   See the accompanying file LICENSE, version 2009-Jan-02 or later

  5.   (the contents of which are also included in unzip.h) for terms of use.

  6.   If, for some reason, all these files are missing, the Info-ZIP license

  7.   also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

  8. */

  9. /*---------------------------------------------------------------------------

  10. 

  11.   unix.c

  12. 

  13.   Unix-specific routines for use with Info-ZIP's UnZip 5.41 and later.

  14. 

  15.   Contains:  readdir()

  16.              do_wild()           <-- generic enough to put in fileio.c?

  17.              mapattr()

  18.              mapname()

  19.              checkdir()

  20.              mkdir()

  21.              close_outfile()

  22.              defer_dir_attribs()

  23.              set_direc_attribs()

  24.              stamp_file()

  25.              version()

  26. 

  27.   ---------------------------------------------------------------------------*/

  28. 

  29. 

  30. #define UNZIP_INTERNAL

  31. #include "unzip.h"

  32. 

  33. #ifdef SCO_XENIX

  34. #  define SYSNDIR

  35. #else  /* SCO Unix, AIX, DNIX, TI SysV, Coherent 4.x, ... */

  36. #  if defined(__convexc__) || defined(SYSV) || defined(CRAY) || defined(BSD4_4)

  37. #    define DIRENT

  38. #  endif

  39. #endif

  40. #if defined(_AIX) || defined(__mpexl)

  41. #  define DIRENT

  42. #endif

  43. #ifdef COHERENT

  44. #  if defined(_I386) || (defined(__COHERENT__) && (__COHERENT__ >= 0x420))

  45. #    define DIRENT

  46. #  endif

  47. #endif

  48. 

  49. #ifdef _POSIX_VERSION

  50. #  ifndef DIRENT

  51. #    define DIRENT

  52. #  endif

  53. #endif

  54. 

  55. #ifdef DIRENT

  56. #  include <dirent.h>

  57. #else

  58. #  ifdef SYSV

  59. #    ifdef SYSNDIR

  60. #      include <sys/ndir.h>

  61. #    else

  62. #      include <ndir.h>

  63. #    endif

  64. #  else /* !SYSV */

  65. #    ifndef NO_SYSDIR

  66. #      include <sys/dir.h>

  67. #    endif

  68. #  endif /* ?SYSV */

  69. #  ifndef dirent

  70. #    define dirent direct

  71. #  endif

  72. #endif /* ?DIRENT */

  73. 

  74. #ifdef SET_DIR_ATTRIB

  75. typedef struct uxdirattr {      /* struct for holding unix style directory */

  76.     struct uxdirattr *next;     /*  info until can be sorted and set at end */

  77.     char *fn;                   /* filename of directory */

  78.     union {

  79.         iztimes t3;             /* mtime, atime, ctime */

  80.         ztimbuf t2;             /* modtime, actime */

  81.     } u;

  82.     unsigned perms;             /* same as min_info.file_attr */

  83.     int have_uidgid;            /* flag */

  84.     ulg uidgid[2];

  85.     char fnbuf[1];              /* buffer stub for directory name */

  86. } uxdirattr;

  87. #define UxAtt(d)  ((uxdirattr *)d)    /* typecast shortcut */

  88. #endif /* SET_DIR_ATTRIB */

  89. 

  90. #ifdef ACORN_FTYPE_NFS

  91. /* Acorn bits for NFS filetyping */

  92. typedef struct {

  93.   uch ID[2];

  94.   uch size[2];

  95.   uch ID_2[4];

  96.   uch loadaddr[4];

  97.   uch execaddr[4];

  98.   uch attr[4];

  99. } RO_extra_block;

  100. 

  101. #endif /* ACORN_FTYPE_NFS */

  102. 

  103. /* static int created_dir;      */      /* used in mapname(), checkdir() */

  104. /* static int renamed_fullpath; */      /* ditto */

  105. 

  106. static unsigned filtattr OF((__GPRO__ unsigned perms));

  107. 

  108. 

  109. /*****************************/

  110. /* Strings used multiple     */

  111. /* times in unix.c           */

  112. /*****************************/

  113. 

  114. #ifndef MTS

  115. /* messages of code for setting file/directory attributes */

  116. static ZCONST char CannotSetItemUidGid[] =

  117.   "warning:  cannot set UID %lu and/or GID %lu for %s\n          %s\n";

  118. static ZCONST char CannotSetUidGid[] =

  119.   " (warning) cannot set UID %lu and/or GID %lu\n          %s";

  120. static ZCONST char CannotSetItemTimestamps[] =

  121.   "warning:  cannot set modif./access times for %s\n          %s\n";

  122. static ZCONST char CannotSetTimestamps[] =

  123.   " (warning) cannot set modif./access times\n          %s";

  124. #endif /* !MTS */

  125. 

  126. 

  127. #ifndef SFX

  128. #ifdef NO_DIR                  /* for AT&T 3B1 */

  129. 

  130. #define opendir(path) fopen(path,"r")

  131. #define closedir(dir) fclose(dir)

  132. typedef FILE DIR;

  133. typedef struct zdir {

  134.     FILE *dirhandle;

  135.     struct dirent *entry;

  136. } DIR

  137. DIR *opendir OF((ZCONST char *dirspec));

  138. void closedir OF((DIR *dirp));

  139. struct dirent *readdir OF((DIR *dirp));

  140. 

  141. DIR *opendir(dirspec)

  142.     ZCONST char *dirspec;

  143. {

  144.     DIR *dirp;

  145. 

  146.     if ((dirp = malloc(sizeof(DIR)) != NULL) {

  147.         if ((dirp->dirhandle = fopen(dirspec, "r")) == NULL) {

  148.             free(dirp);

  149.             dirp = NULL;

  150.         }

  151.     }

  152.     return dirp;

  153. }

  154. 

  155. void closedir(dirp)

  156.     DIR *dirp;

  157. {

  158.     fclose(dirp->dirhandle);

  159.     free(dirp);

  160. }

  161. 

  162. /*

  163.  *  Apparently originally by Rich Salz.

  164.  *  Cleaned up and modified by James W. Birdsall.

  165.  */

  166. struct dirent *readdir(dirp)

  167.     DIR *dirp;

  168. {

  169. 

  170.     if (dirp == NULL)

  171.         return NULL;

  172. 

  173.     for (;;)

  174.         if (fread(&(dirp->entry), sizeof (struct dirent), 1,

  175.                   dirp->dirhandle) == 0)

  176.             return (struct dirent *)NULL;

  177.         else if ((dirp->entry).d_ino)

  178.             return &(dirp->entry);

  179. 

  180. } /* end function readdir() */

  181. 

  182. #endif /* NO_DIR */

  183. 

  184. 

  185. /**********************/

  186. /* Function do_wild() */   /* for porting: dir separator; match(ignore_case) */

  187. /**********************/

  188. 

  189. char *do_wild(__G__ wildspec)

  190.     __GDEF

  191.     ZCONST char *wildspec;  /* only used first time on a given dir */

  192. {

  193. /* these statics are now declared in SYSTEM_SPECIFIC_GLOBALS in unxcfg.h:

  194.     static DIR *wild_dir = (DIR *)NULL;

  195.     static ZCONST char *wildname;

  196.     static char *dirname, matchname[FILNAMSIZ];

  197.     static int notfirstcall=FALSE, have_dirname, dirnamelen;

  198. */

  199.     struct dirent *file;

  200. 

  201.     /* Even when we're just returning wildspec, we *always* do so in

  202.      * matchname[]--calling routine is allowed to append four characters

  203.      * to the returned string, and wildspec may be a pointer to argv[].

  204.      */

  205.     if (!G.notfirstcall) {  /* first call:  must initialize everything */

  206.         G.notfirstcall = TRUE;

  207. 

  208.         if (!iswild(wildspec)) {

  209.             strncpy(G.matchname, wildspec, FILNAMSIZ);

  210.             G.matchname[FILNAMSIZ-1] = '\0';

  211.             G.have_dirname = FALSE;

  212.             G.wild_dir = NULL;

  213.             return G.matchname;

  214.         }

  215. 

  216.         /* break the wildspec into a directory part and a wildcard filename */

  217.         if ((G.wildname = (ZCONST char *)strrchr(wildspec, '/')) == NULL) {

  218.             G.dirname = ".";

  219.             G.dirnamelen = 1;

  220.             G.have_dirname = FALSE;

  221.             G.wildname = wildspec;

  222.         } else {

  223.             ++G.wildname;     /* point at character after '/' */

  224.             G.dirnamelen = G.wildname - wildspec;

  225.             if ((G.dirname = (char *)malloc(G.dirnamelen+1)) == (char *)NULL) {

  226.                 Info(slide, 0x201, ((char *)slide,

  227.                   "warning:  cannot allocate wildcard buffers\n"));

  228.                 strncpy(G.matchname, wildspec, FILNAMSIZ);

  229.                 G.matchname[FILNAMSIZ-1] = '\0';

  230.                 return G.matchname; /* but maybe filespec was not a wildcard */

  231.             }

  232.             strncpy(G.dirname, wildspec, G.dirnamelen);

  233.             G.dirname[G.dirnamelen] = '\0';   /* terminate for strcpy below */

  234.             G.have_dirname = TRUE;

  235.         }

  236. 

  237.         if ((G.wild_dir = (zvoid *)opendir(G.dirname)) != (zvoid *)NULL) {

  238.             while ((file = readdir((DIR *)G.wild_dir)) !=

  239.                    (struct dirent *)NULL) {

  240.                 Trace((stderr, "do_wild:  readdir returns %s\n",

  241.                   FnFilter1(file->d_name)));

  242.                 if (file->d_name[0] == '.' && G.wildname[0] != '.')

  243.                     continue; /* Unix:  '*' and '?' do not match leading dot */

  244.                 if (match(file->d_name, G.wildname, 0 WISEP) &&/*0=case sens.*/

  245.                     /* skip "." and ".." directory entries */

  246.                     strcmp(file->d_name, ".") && strcmp(file->d_name, "..")) {

  247.                     Trace((stderr, "do_wild:  match() succeeds\n"));

  248.                     if (G.have_dirname) {

  249.                         strcpy(G.matchname, G.dirname);

  250.                         strcpy(G.matchname+G.dirnamelen, file->d_name);

  251.                     } else

  252.                         strcpy(G.matchname, file->d_name);

  253.                     return G.matchname;

  254.                 }

  255.             }

  256.             /* if we get to here directory is exhausted, so close it */

  257.             closedir((DIR *)G.wild_dir);

  258.             G.wild_dir = (zvoid *)NULL;

  259.         }

  260.         Trace((stderr, "do_wild:  opendir(%s) returns NULL\n",

  261.           FnFilter1(G.dirname)));

  262. 

  263.         /* return the raw wildspec in case that works (e.g., directory not

  264.          * searchable, but filespec was not wild and file is readable) */

  265.         strncpy(G.matchname, wildspec, FILNAMSIZ);

  266.         G.matchname[FILNAMSIZ-1] = '\0';

  267.         return G.matchname;

  268.     }

  269. 

  270.     /* last time through, might have failed opendir but returned raw wildspec */

  271.     if ((DIR *)G.wild_dir == (DIR *)NULL) {

  272.         G.notfirstcall = FALSE; /* nothing left--reset for new wildspec */

  273.         if (G.have_dirname)

  274.             free(G.dirname);

  275.         return (char *)NULL;

  276.     }

  277. 

  278.     /* If we've gotten this far, we've read and matched at least one entry

  279.      * successfully (in a previous call), so dirname has been copied into

  280.      * matchname already.

  281.      */

  282.     while ((file = readdir((DIR *)G.wild_dir)) != (struct dirent *)NULL) {

  283.         Trace((stderr, "do_wild:  readdir returns %s\n",

  284.           FnFilter1(file->d_name)));

  285.         if (file->d_name[0] == '.' && G.wildname[0] != '.')

  286.             continue;   /* Unix:  '*' and '?' do not match leading dot */

  287.         if (match(file->d_name, G.wildname, 0 WISEP)) { /* 0 == case sens. */

  288.             Trace((stderr, "do_wild:  match() succeeds\n"));

  289.             if (G.have_dirname) {

  290.                 /* strcpy(G.matchname, G.dirname); */

  291.                 strcpy(G.matchname+G.dirnamelen, file->d_name);

  292.             } else

  293.                 strcpy(G.matchname, file->d_name);

  294.             return G.matchname;

  295.         }

  296.     }

  297. 

  298.     closedir((DIR *)G.wild_dir);  /* at least one entry read; nothing left */

  299.     G.wild_dir = (zvoid *)NULL;

  300.     G.notfirstcall = FALSE;       /* reset for new wildspec */

  301.     if (G.have_dirname)

  302.         free(G.dirname);

  303.     return (char *)NULL;

  304. 

  305. } /* end function do_wild() */

  306. 

  307. #endif /* !SFX */

  308. 

  309. 

  310. 

  311. 

  312. #ifndef S_ISUID

  313. # define S_ISUID        0004000 /* set user id on execution */

  314. #endif

  315. #ifndef S_ISGID

  316. # define S_ISGID        0002000 /* set group id on execution */

  317. #endif

  318. #ifndef S_ISVTX

  319. # define S_ISVTX        0001000 /* save swapped text even after use */

  320. #endif

  321. 

  322. /************************/

  323. /*  Function filtattr() */

  324. /************************/

  325. /* This is used to clear or keep the SUID and SGID bits on file permissions.

  326.  * It's possible that a file in an archive could have one of these bits set

  327.  * and, unknown to the person unzipping, could allow others to execute the

  328.  * file as the user or group.  The new option -K bypasses this check.

  329.  */

  330. 

  331. static unsigned filtattr(__G__ perms)

  332.     __GDEF

  333.     unsigned perms;

  334. {

  335.     /* keep setuid/setgid/tacky perms? */

  336.     if (!uO.K_flag)

  337.         perms &= ~(S_ISUID | S_ISGID | S_ISVTX);

  338. 

  339.     return (0xffff & perms);

  340. } /* end function filtattr() */

  341. 

  342. 

  343. 

  344. 

  345. 

  346. /**********************/

  347. /* Function mapattr() */

  348. /**********************/

  349. 

  350. int mapattr(__G)

  351.     __GDEF

  352. {

  353.     int r;

  354.     ulg tmp = G.crec.external_file_attributes;

  355. 

  356.     G.pInfo->file_attr = 0;

  357.     /* initialized to 0 for check in "default" branch below... */

  358. 

  359.     switch (G.pInfo->hostnum) {

  360.         case AMIGA_:

  361.             tmp = (unsigned)(tmp>>17 & 7);   /* Amiga RWE bits */

  362.             G.pInfo->file_attr = (unsigned)(tmp<<6 | tmp<<3 | tmp);

  363.             break;

  364.         case THEOS_:

  365.             tmp &= 0xF1FFFFFFL;

  366.             if ((tmp & 0xF0000000L) != 0x40000000L)

  367.                 tmp &= 0x01FFFFFFL;     /* not a dir, mask all ftype bits */

  368.             else

  369.                 tmp &= 0x41FFFFFFL;     /* leave directory bit as set */

  370.             /* fall through! */

  371.         case UNIX_:

  372.         case VMS_:

  373.         case ACORN_:

  374.         case ATARI_:

  375.         case ATHEOS_:

  376.         case BEOS_:

  377.         case QDOS_:

  378.         case TANDEM_:

  379.             r = FALSE;

  380.             G.pInfo->file_attr = (unsigned)(tmp >> 16);

  381.             if (G.pInfo->file_attr == 0 && G.extra_field) {

  382.                 /* Some (non-Info-ZIP) implementations of Zip for Unix and

  383.                  * VMS (and probably others ??) leave 0 in the upper 16-bit

  384.                  * part of the external_file_attributes field. Instead, they

  385.                  * store file permission attributes in some extra field.

  386.                  * As a work-around, we search for the presence of one of

  387.                  * these extra fields and fall back to the MSDOS compatible

  388.                  * part of external_file_attributes if one of the known

  389.                  * e.f. types has been detected.

  390.                  * Later, we might implement extraction of the permission

  391.                  * bits from the VMS extra field. But for now, the work-around

  392.                  * should be sufficient to provide "readable" extracted files.

  393.                  * (For ASI Unix e.f., an experimental remap of the e.f.

  394.                  * mode value IS already provided!)

  395.                  */

  396.                 ush ebID;

  397.                 unsigned ebLen;

  398.                 uch *ef = G.extra_field;

  399.                 unsigned ef_len = G.crec.extra_field_length;

  400. 

  401.                 while (!r && ef_len >= EB_HEADSIZE) {

  402.                     ebID = makeword(ef);

  403.                     ebLen = (unsigned)makeword(ef+EB_LEN);

  404.                     if (ebLen > (ef_len - EB_HEADSIZE))

  405.                         /* discoverd some e.f. inconsistency! */

  406.                         break;

  407.                     switch (ebID) {

  408.                       case EF_ASIUNIX:

  409.                         if (ebLen >= (EB_ASI_MODE+2)) {

  410.                             G.pInfo->file_attr =

  411.                               (unsigned)makeword(ef+(EB_HEADSIZE+EB_ASI_MODE));

  412.                             /* force stop of loop: */

  413.                             ef_len = (ebLen + EB_HEADSIZE);

  414.                             break;

  415.                         }

  416.                         /* else: fall through! */

  417.                       case EF_PKVMS:

  418.                         /* "found nondecypherable e.f. with perm. attr" */

  419.                         r = TRUE;

  420.                       default:

  421.                         break;

  422.                     }

  423.                     ef_len -= (ebLen + EB_HEADSIZE);

  424.                     ef += (ebLen + EB_HEADSIZE);

  425.                 }

  426.             }

  427.             if (!r) {

  428. #ifdef SYMLINKS

  429.                 /* Check if the file is a (POSIX-compatible) symbolic link.

  430.                  * We restrict symlink support to those "made-by" hosts that

  431.                  * are known to support symbolic links.

  432.                  */

  433.                 G.pInfo->symlink = S_ISLNK(G.pInfo->file_attr) &&

  434.                                    SYMLINK_HOST(G.pInfo->hostnum);

  435. #endif

  436.                 return 0;

  437.             }

  438.             /* fall through! */

  439.         /* all remaining cases:  expand MSDOS read-only bit into write perms */

  440.         case FS_FAT_:

  441.             /* PKWARE's PKZip for Unix marks entries as FS_FAT_, but stores the

  442.              * Unix attributes in the upper 16 bits of the external attributes

  443.              * field, just like Info-ZIP's Zip for Unix.  We try to use that

  444.              * value, after a check for consistency with the MSDOS attribute

  445.              * bits (see below).

  446.              */

  447.             G.pInfo->file_attr = (unsigned)(tmp >> 16);

  448.             /* fall through! */

  449.         case FS_HPFS_:

  450.         case FS_NTFS_:

  451.         case MAC_:

  452.         case TOPS20_:

  453.         default:

  454.             /* Ensure that DOS subdir bit is set when the entry's name ends

  455.              * in a '/'.  Some third-party Zip programs fail to set the subdir

  456.              * bit for directory entries.

  457.              */

  458.             if ((tmp & 0x10) == 0) {

  459.                 extent fnlen = strlen(G.filename);

  460.                 if (fnlen > 0 && G.filename[fnlen-1] == '/')

  461.                     tmp |= 0x10;

  462.             }

  463.             /* read-only bit --> write perms; subdir bit --> dir exec bit */

  464.             tmp = !(tmp & 1) << 1  |  (tmp & 0x10) >> 4;

  465.             if ((G.pInfo->file_attr & 0700) == (unsigned)(0400 | tmp<<6)) {

  466.                 /* keep previous G.pInfo->file_attr setting, when its "owner"

  467.                  * part appears to be consistent with DOS attribute flags!

  468.                  */

  469. #ifdef SYMLINKS

  470.                 /* Entries "made by FS_FAT_" could have been zipped on a

  471.                  * system that supports POSIX-style symbolic links.

  472.                  */

  473.                 G.pInfo->symlink = S_ISLNK(G.pInfo->file_attr) &&

  474.                                    (G.pInfo->hostnum == FS_FAT_);

  475. #endif

  476.                 return 0;

  477.             }

  478.             G.pInfo->file_attr = (unsigned)(0444 | tmp<<6 | tmp<<3 | tmp);

  479.             break;

  480.     } /* end switch (host-OS-created-by) */

  481. 

  482.     /* for originating systems with no concept of "group," "other," "system": */

  483.     umask( (int)(tmp=umask(0)) );    /* apply mask to expanded r/w(/x) perms */

  484.     G.pInfo->file_attr &= ~tmp;

  485. 

  486.     return 0;

  487. 

  488. } /* end function mapattr() */

  489. 

  490. 

  491. 

  492. 

  493. 

  494. /************************/

  495. /*  Function mapname()  */

  496. /************************/

  497. 

  498. int mapname(__G__ renamed)

  499.     __GDEF

  500.     int renamed;

  501. /*

  502.  * returns:

  503.  *  MPN_OK          - no problem detected

  504.  *  MPN_INF_TRUNC   - caution (truncated filename)

  505.  *  MPN_INF_SKIP    - info "skip entry" (dir doesn't exist)

  506.  *  MPN_ERR_SKIP    - error -> skip entry

  507.  *  MPN_ERR_TOOLONG - error -> path is too long

  508.  *  MPN_NOMEM       - error (memory allocation failed) -> skip entry

  509.  *  [also MPN_VOL_LABEL, MPN_CREATED_DIR]

  510.  */

  511. {

  512.     char pathcomp[FILNAMSIZ];      /* path-component buffer */

  513.     char *pp, *cp=(char *)NULL;    /* character pointers */

  514.     char *lastsemi=(char *)NULL;   /* pointer to last semi-colon in pathcomp */

  515. #ifdef ACORN_FTYPE_NFS

  516.     char *lastcomma=(char *)NULL;  /* pointer to last comma in pathcomp */

  517.     RO_extra_block *ef_spark;      /* pointer Acorn FTYPE ef block */

  518. #endif

  519.     int killed_ddot = FALSE;       /* is set when skipping "../" pathcomp */

  520.     int error = MPN_OK;

  521.     register unsigned workch;      /* hold the character being tested */

  522. 

  523. 

  524. /*---------------------------------------------------------------------------

  525.     Initialize various pointers and counters and stuff.

  526.   ---------------------------------------------------------------------------*/

  527. 

  528.     if (G.pInfo->vollabel)

  529.         return MPN_VOL_LABEL;   /* can't set disk volume labels in Unix */

  530. 

  531.     /* can create path as long as not just freshening, or if user told us */

  532.     G.create_dirs = (!uO.fflag || renamed);

  533. 

  534.     G.created_dir = FALSE;      /* not yet */

  535. 

  536.     /* user gave full pathname:  don't prepend rootpath */

  537.     G.renamed_fullpath = (renamed && (*G.filename == '/'));

  538. 

  539.     if (checkdir(__G__ (char *)NULL, INIT) == MPN_NOMEM)

  540.         return MPN_NOMEM;       /* initialize path buffer, unless no memory */

  541. 

  542.     *pathcomp = '\0';           /* initialize translation buffer */

  543.     pp = pathcomp;              /* point to translation buffer */

  544.     if (uO.jflag)               /* junking directories */

  545.         cp = (char *)strrchr(G.filename, '/');

  546.     if (cp == (char *)NULL)     /* no '/' or not junking dirs */

  547.         cp = G.filename;        /* point to internal zipfile-member pathname */

  548.     else

  549.         ++cp;                   /* point to start of last component of path */

  550. 

  551. /*---------------------------------------------------------------------------

  552.     Begin main loop through characters in filename.

  553.   ---------------------------------------------------------------------------*/

  554. 

  555.     while ((workch = (uch)*cp++) != 0) {

  556. 

  557.         switch (workch) {

  558.             case '/':             /* can assume -j flag not given */

  559.                 *pp = '\0';

  560.                 if (strcmp(pathcomp, ".") == 0) {

  561.                     /* don't bother appending "./" to the path */

  562.                     *pathcomp = '\0';

  563.                 } else if (!uO.ddotflag && strcmp(pathcomp, "..") == 0) {

  564.                     /* "../" dir traversal detected, skip over it */

  565.                     *pathcomp = '\0';

  566.                     killed_ddot = TRUE;     /* set "show message" flag */

  567.                 }

  568.                 /* when path component is not empty, append it now */

  569.                 if (*pathcomp != '\0' &&

  570.                     ((error = checkdir(__G__ pathcomp, APPEND_DIR))

  571.                      & MPN_MASK) > MPN_INF_TRUNC)

  572.                     return error;

  573.                 pp = pathcomp;    /* reset conversion buffer for next piece */

  574.                 lastsemi = (char *)NULL; /* leave direct. semi-colons alone */

  575.                 break;

  576. 

  577. #ifdef __CYGWIN__   /* Cygwin runs on Win32, apply FAT/NTFS filename rules */

  578.             case ':':         /* drive spec not stored, so no colon allowed */

  579.             case '\\':        /* '\\' may come as normal filename char (not */

  580.             case '<':         /*  dir sep char!) from unix-like file system */

  581.             case '>':         /* no redirection symbols allowed either */

  582.             case '|':         /* no pipe signs allowed */

  583.             case '"':         /* no double quotes allowed */

  584.             case '?':         /* no wildcards allowed */

  585.             case '*':

  586.                 *pp++ = '_';  /* these rules apply equally to FAT and NTFS */

  587.                 break;

  588. #endif

  589. 

  590.             case ';':             /* VMS version (or DEC-20 attrib?) */

  591.                 lastsemi = pp;

  592.                 *pp++ = ';';      /* keep for now; remove VMS ";##" */

  593.                 break;            /*  later, if requested */

  594. 

  595. #ifdef ACORN_FTYPE_NFS

  596.             case ',':             /* NFS filetype extension */

  597.                 lastcomma = pp;

  598.                 *pp++ = ',';      /* keep for now; may need to remove */

  599.                 break;            /*  later, if requested */

  600. #endif

  601. 

  602. #ifdef MTS

  603.             case ' ':             /* change spaces to underscore under */

  604.                 *pp++ = '_';      /*  MTS; leave as spaces under Unix */

  605.                 break;

  606. #endif

  607. 

  608.             default:

  609.                 /* disable control character filter when requested,

  610.                  * else allow 8-bit characters (e.g. UTF-8) in filenames:

  611.                  */

  612.                 if (uO.cflxflag ||

  613.                     (isprint(workch) || (128 <= workch && workch <= 254)))

  614.                     *pp++ = (char)workch;

  615.         } /* end switch */

  616. 

  617.     } /* end while loop */

  618. 

  619.     /* Show warning when stripping insecure "parent dir" path components */

  620.     if (killed_ddot && QCOND2) {

  621.         Info(slide, 0, ((char *)slide,

  622.           "warning:  skipped \"../\" path component(s) in %s\n",

  623.           FnFilter1(G.filename)));

  624.         if (!(error & ~MPN_MASK))

  625.             error = (error & MPN_MASK) | PK_WARN;

  626.     }

  627. 

  628. /*---------------------------------------------------------------------------

  629.     Report if directory was created (and no file to create:  filename ended

  630.     in '/'), check name to be sure it exists, and combine path and name be-

  631.     fore exiting.

  632.   ---------------------------------------------------------------------------*/

  633. 

  634.     if (G.filename[strlen(G.filename) - 1] == '/') {

  635.         checkdir(__G__ G.filename, GETPATH);

  636.         if (G.created_dir) {

  637.             if (QCOND2) {

  638.                 Info(slide, 0, ((char *)slide, "   creating: %s\n",

  639.                   FnFilter1(G.filename)));

  640.             }

  641. #ifndef NO_CHMOD

  642.             /* Filter out security-relevant attributes bits. */

  643.             G.pInfo->file_attr = filtattr(__G__ G.pInfo->file_attr);

  644.             /* When extracting non-UNIX directories or when extracting

  645.              * without UID/GID restoration or SGID preservation, any

  646.              * SGID flag inherited from the parent directory should be

  647.              * maintained to allow files extracted into this new folder

  648.              * to inherit the GID setting from the parent directory.

  649.              */

  650.             if (G.pInfo->hostnum != UNIX_ || !(uO.X_flag || uO.K_flag)) {

  651.                 /* preserve SGID bit when inherited from parent dir */

  652.                 if (!SSTAT(G.filename, &G.statbuf)) {

  653.                     G.pInfo->file_attr |= G.statbuf.st_mode & S_ISGID;

  654.                 } else {

  655.                     perror("Could not read directory attributes");

  656.                 }

  657.             }

  658. 

  659.             /* set approx. dir perms (make sure can still read/write in dir) */

  660.             if (chmod(G.filename, G.pInfo->file_attr | 0700))

  661.                 perror("chmod (directory attributes) error");

  662. #endif

  663.             /* set dir time (note trailing '/') */

  664.             return (error & ~MPN_MASK) | MPN_CREATED_DIR;

  665.         }

  666.         /* dir existed already; don't look for data to extract */

  667.         return (error & ~MPN_MASK) | MPN_INF_SKIP;

  668.     }

  669. 

  670.     *pp = '\0';                   /* done with pathcomp:  terminate it */

  671. 

  672.     /* if not saving them, remove VMS version numbers (appended ";###") */

  673.     if (!uO.V_flag && lastsemi) {

  674.         pp = lastsemi + 1;

  675.         while (isdigit((uch)(*pp)))

  676.             ++pp;

  677.         if (*pp == '\0')          /* only digits between ';' and end:  nuke */

  678.             *lastsemi = '\0';

  679.     }

  680. 

  681.     /* On UNIX (and compatible systems), "." and ".." are reserved for

  682.      * directory navigation and cannot be used as regular file names.

  683.      * These reserved one-dot and two-dot names are mapped to "_" and "__".

  684.      */

  685.     if (strcmp(pathcomp, ".") == 0)

  686.         *pathcomp = '_';

  687.     else if (strcmp(pathcomp, "..") == 0)

  688.         strcpy(pathcomp, "__");

  689. 

  690. #ifdef ACORN_FTYPE_NFS

  691.     /* translate Acorn filetype information if asked to do so */

  692.     if (uO.acorn_nfs_ext &&

  693.         (ef_spark = (RO_extra_block *)

  694.                     getRISCOSexfield(G.extra_field, G.lrec.extra_field_length))

  695.         != (RO_extra_block *)NULL)

  696.     {

  697.         /* file *must* have a RISC OS extra field */

  698.         long ft = (long)makelong(ef_spark->loadaddr);

  699.         /*32-bit*/

  700.         if (lastcomma) {

  701.             pp = lastcomma + 1;

  702.             while (isxdigit((uch)(*pp))) ++pp;

  703.             if (pp == lastcomma+4 && *pp == '\0') *lastcomma='\0'; /* nuke */

  704.         }

  705.         if ((ft & 1<<31)==0) ft=0x000FFD00;

  706.         sprintf(pathcomp+strlen(pathcomp), ",%03x", (int)(ft>>8) & 0xFFF);

  707.     }

  708. #endif /* ACORN_FTYPE_NFS */

  709. 

  710.     if (*pathcomp == '\0') {

  711.         Info(slide, 1, ((char *)slide, "mapname:  conversion of %s failed\n",

  712.           FnFilter1(G.filename)));

  713.         return (error & ~MPN_MASK) | MPN_ERR_SKIP;

  714.     }

  715. 

  716.     checkdir(__G__ pathcomp, APPEND_NAME);  /* returns 1 if truncated: care? */

  717.     checkdir(__G__ G.filename, GETPATH);

  718. 

  719.     return error;

  720. 

  721. } /* end function mapname() */

  722. 

  723. 

  724. 

  725. 

  726. #if 0  /*========== NOTES ==========*/

  727. 

  728.   extract-to dir:      a:path/

  729.   buildpath:           path1/path2/ ...   (NULL-terminated)

  730.   pathcomp:                filename

  731. 

  732.   mapname():

  733.     loop over chars in zipfile member name

  734.       checkdir(path component, COMPONENT | CREATEDIR) --> map as required?

  735.         (d:/tmp/unzip/)                    (disk:[tmp.unzip.)

  736.         (d:/tmp/unzip/jj/)                 (disk:[tmp.unzip.jj.)

  737.         (d:/tmp/unzip/jj/temp/)            (disk:[tmp.unzip.jj.temp.)

  738.     finally add filename itself and check for existence? (could use with rename)

  739.         (d:/tmp/unzip/jj/temp/msg.outdir)  (disk:[tmp.unzip.jj.temp]msg.outdir)

  740.     checkdir(name, GETPATH)     -->  copy path to name and free space

  741. 

  742. #endif /* 0 */

  743. 

  744. 

  745. 

  746. 

  747. /***********************/

  748. /* Function checkdir() */

  749. /***********************/

  750. 

  751. int checkdir(__G__ pathcomp, flag)

  752.     __GDEF

  753.     char *pathcomp;

  754.     int flag;

  755. /*

  756.  * returns:

  757.  *  MPN_OK          - no problem detected

  758.  *  MPN_INF_TRUNC   - (on APPEND_NAME) truncated filename

  759.  *  MPN_INF_SKIP    - path doesn't exist, not allowed to create

  760.  *  MPN_ERR_SKIP    - path doesn't exist, tried to create and failed; or path

  761.  *                    exists and is not a directory, but is supposed to be

  762.  *  MPN_ERR_TOOLONG - path is too long

  763.  *  MPN_NOMEM       - can't allocate memory for filename buffers

  764.  */

  765. {

  766.  /* static int rootlen = 0; */  /* length of rootpath */

  767.  /* static char *rootpath;  */  /* user's "extract-to" directory */

  768.  /* static char *buildpath; */  /* full path (so far) to extracted file */

  769.  /* static char *end;       */  /* pointer to end of buildpath ('\0') */

  770. 

  771. #   define FN_MASK   7

  772. #   define FUNCTION  (flag & FN_MASK)

  773. 

  774. 

  775. 

  776. /*---------------------------------------------------------------------------

  777.     APPEND_DIR:  append the path component to the path being built and check

  778.     for its existence.  If doesn't exist and we are creating directories, do

  779.     so for this one; else signal success or error as appropriate.

  780.   ---------------------------------------------------------------------------*/

  781. 

  782.     if (FUNCTION == APPEND_DIR) {

  783.         int too_long = FALSE;

  784. #ifdef SHORT_NAMES

  785.         char *old_end = end;

  786. #endif

  787. 

  788.         Trace((stderr, "appending dir segment [%s]\n", FnFilter1(pathcomp)));

  789.         while ((*G.end = *pathcomp++) != '\0')

  790.             ++G.end;

  791. #ifdef SHORT_NAMES   /* path components restricted to 14 chars, typically */

  792.         if ((G.end-old_end) > FILENAME_MAX)  /* GRR:  proper constant? */

  793.             *(G.end = old_end + FILENAME_MAX) = '\0';

  794. #endif

  795. 

  796.         /* GRR:  could do better check, see if overrunning buffer as we go:

  797.          * check end-buildpath after each append, set warning variable if

  798.          * within 20 of FILNAMSIZ; then if var set, do careful check when

  799.          * appending.  Clear variable when begin new path. */

  800. 

  801.         /* next check: need to append '/', at least one-char name, '\0' */

  802.         if ((G.end-G.buildpath) > FILNAMSIZ-3)

  803.             too_long = TRUE;                    /* check if extracting dir? */

  804.         if (SSTAT(G.buildpath, &G.statbuf)) {   /* path doesn't exist */

  805.             if (!G.create_dirs) { /* told not to create (freshening) */

  806.                 free(G.buildpath);

  807.                 return MPN_INF_SKIP;    /* path doesn't exist: nothing to do */

  808.             }

  809.             if (too_long) {

  810.                 Info(slide, 1, ((char *)slide,

  811.                   "checkdir error:  path too long: %s\n",

  812.                   FnFilter1(G.buildpath)));

  813.                 free(G.buildpath);

  814.                 /* no room for filenames:  fatal */

  815.                 return MPN_ERR_TOOLONG;

  816.             }

  817.             if (mkdir(G.buildpath, 0777) == -1) {   /* create the directory */

  818.                 Info(slide, 1, ((char *)slide,

  819.                   "checkdir error:  cannot create %s\n\

  820.                  %s\n\

  821.                  unable to process %s.\n",

  822.                   FnFilter2(G.buildpath),

  823.                   strerror(errno),

  824.                   FnFilter1(G.filename)));

  825.                 free(G.buildpath);

  826.                 /* path didn't exist, tried to create, failed */

  827.                 return MPN_ERR_SKIP;

  828.             }

  829.             G.created_dir = TRUE;

  830.         } else if (!S_ISDIR(G.statbuf.st_mode)) {

  831.             Info(slide, 1, ((char *)slide,

  832.               "checkdir error:  %s exists but is not directory\n\

  833.                  unable to process %s.\n",

  834.               FnFilter2(G.buildpath), FnFilter1(G.filename)));

  835.             free(G.buildpath);

  836.             /* path existed but wasn't dir */

  837.             return MPN_ERR_SKIP;

  838.         }

  839.         if (too_long) {

  840.             Info(slide, 1, ((char *)slide,

  841.               "checkdir error:  path too long: %s\n", FnFilter1(G.buildpath)));

  842.             free(G.buildpath);

  843.             /* no room for filenames:  fatal */

  844.             return MPN_ERR_TOOLONG;

  845.         }

  846.         *G.end++ = '/';

  847.         *G.end = '\0';

  848.         Trace((stderr, "buildpath now = [%s]\n", FnFilter1(G.buildpath)));

  849.         return MPN_OK;

  850. 

  851.     } /* end if (FUNCTION == APPEND_DIR) */

  852. 

  853. /*---------------------------------------------------------------------------

  854.     GETPATH:  copy full path to the string pointed at by pathcomp, and free

  855.     G.buildpath.

  856.   ---------------------------------------------------------------------------*/

  857. 

  858.     if (FUNCTION == GETPATH) {

  859.         strcpy(pathcomp, G.buildpath);

  860.         Trace((stderr, "getting and freeing path [%s]\n",

  861.           FnFilter1(pathcomp)));

  862.         free(G.buildpath);

  863.         G.buildpath = G.end = (char *)NULL;

  864.         return MPN_OK;

  865.     }

  866. 

  867. /*---------------------------------------------------------------------------

  868.     APPEND_NAME:  assume the path component is the filename; append it and

  869.     return without checking for existence.

  870.   ---------------------------------------------------------------------------*/

  871. 

  872.     if (FUNCTION == APPEND_NAME) {

  873. #ifdef SHORT_NAMES

  874.         char *old_end = end;

  875. #endif

  876. 

  877.         Trace((stderr, "appending filename [%s]\n", FnFilter1(pathcomp)));

  878.         while ((*G.end = *pathcomp++) != '\0') {

  879.             ++G.end;

  880. #ifdef SHORT_NAMES  /* truncate name at 14 characters, typically */

  881.             if ((G.end-old_end) > FILENAME_MAX)    /* GRR:  proper constant? */

  882.                 *(G.end = old_end + FILENAME_MAX) = '\0';

  883. #endif

  884.             if ((G.end-G.buildpath) >= FILNAMSIZ) {

  885.                 *--G.end = '\0';

  886.                 Info(slide, 0x201, ((char *)slide,

  887.                   "checkdir warning:  path too long; truncating\n\

  888.                    %s\n                -> %s\n",

  889.                   FnFilter1(G.filename), FnFilter2(G.buildpath)));

  890.                 return MPN_INF_TRUNC;   /* filename truncated */

  891.             }

  892.         }

  893.         Trace((stderr, "buildpath now = [%s]\n", FnFilter1(G.buildpath)));

  894.         /* could check for existence here, prompt for new name... */

  895.         return MPN_OK;

  896.     }

  897. 

  898. /*---------------------------------------------------------------------------

  899.     INIT:  allocate and initialize buffer space for the file currently being

  900.     extracted.  If file was renamed with an absolute path, don't prepend the

  901.     extract-to path.

  902.   ---------------------------------------------------------------------------*/

  903. 

  904. /* GRR:  for VMS and TOPS-20, add up to 13 to strlen */

  905. 

  906.     if (FUNCTION == INIT) {

  907.         Trace((stderr, "initializing buildpath to "));

  908. #ifdef ACORN_FTYPE_NFS

  909.         if ((G.buildpath = (char *)malloc(strlen(G.filename)+G.rootlen+

  910.                                           (uO.acorn_nfs_ext ? 5 : 1)))

  911. #else

  912.         if ((G.buildpath = (char *)malloc(strlen(G.filename)+G.rootlen+1))

  913. #endif

  914.             == (char *)NULL)

  915.             return MPN_NOMEM;

  916.         if ((G.rootlen > 0) && !G.renamed_fullpath) {

  917.             strcpy(G.buildpath, G.rootpath);

  918.             G.end = G.buildpath + G.rootlen;

  919.         } else {

  920.             *G.buildpath = '\0';

  921.             G.end = G.buildpath;

  922.         }

  923.         Trace((stderr, "[%s]\n", FnFilter1(G.buildpath)));

  924.         return MPN_OK;

  925.     }

  926. 

  927. /*---------------------------------------------------------------------------

  928.     ROOT:  if appropriate, store the path in rootpath and create it if

  929.     necessary; else assume it's a zipfile member and return.  This path

  930.     segment gets used in extracting all members from every zipfile specified

  931.     on the command line.

  932.   ---------------------------------------------------------------------------*/

  933. 

  934. #if (!defined(SFX) || defined(SFX_EXDIR))

  935.     if (FUNCTION == ROOT) {

  936.         Trace((stderr, "initializing root path to [%s]\n",

  937.           FnFilter1(pathcomp)));

  938.         if (pathcomp == (char *)NULL) {

  939.             G.rootlen = 0;

  940.             return MPN_OK;

  941.         }

  942.         if (G.rootlen > 0)      /* rootpath was already set, nothing to do */

  943.             return MPN_OK;

  944.         if ((G.rootlen = strlen(pathcomp)) > 0) {

  945.             char *tmproot;

  946. 

  947.             if ((tmproot = (char *)malloc(G.rootlen+2)) == (char *)NULL) {

  948.                 G.rootlen = 0;

  949.                 return MPN_NOMEM;

  950.             }

  951.             strcpy(tmproot, pathcomp);

  952.             if (tmproot[G.rootlen-1] == '/') {

  953.                 tmproot[--G.rootlen] = '\0';

  954.             }

  955.             if (G.rootlen > 0 && (SSTAT(tmproot, &G.statbuf) ||

  956.                                   !S_ISDIR(G.statbuf.st_mode)))

  957.             {   /* path does not exist */

  958.                 if (!G.create_dirs /* || iswild(tmproot) */ ) {

  959.                     free(tmproot);

  960.                     G.rootlen = 0;

  961.                     /* skip (or treat as stored file) */

  962.                     return MPN_INF_SKIP;

  963.                 }

  964.                 /* create the directory (could add loop here scanning tmproot

  965.                  * to create more than one level, but why really necessary?) */

  966.                 if (mkdir(tmproot, 0777) == -1) {

  967.                     Info(slide, 1, ((char *)slide,

  968.                       "checkdir:  cannot create extraction directory: %s\n\

  969.            %s\n",

  970.                       FnFilter1(tmproot), strerror(errno)));

  971.                     free(tmproot);

  972.                     G.rootlen = 0;

  973.                     /* path didn't exist, tried to create, and failed: */

  974.                     /* file exists, or 2+ subdir levels required */

  975.                     return MPN_ERR_SKIP;

  976.                 }

  977.             }

  978.             tmproot[G.rootlen++] = '/';

  979.             tmproot[G.rootlen] = '\0';

  980.             if ((G.rootpath = (char *)realloc(tmproot, G.rootlen+1)) == NULL) {

  981.                 free(tmproot);

  982.                 G.rootlen = 0;

  983.                 return MPN_NOMEM;

  984.             }

  985.             Trace((stderr, "rootpath now = [%s]\n", FnFilter1(G.rootpath)));

  986.         }

  987.         return MPN_OK;

  988.     }

  989. #endif /* !SFX || SFX_EXDIR */

  990. 

  991. /*---------------------------------------------------------------------------

  992.     END:  free rootpath, immediately prior to program exit.

  993.   ---------------------------------------------------------------------------*/

  994. 

  995.     if (FUNCTION == END) {

  996.         Trace((stderr, "freeing rootpath\n"));

  997.         if (G.rootlen > 0) {

  998.             free(G.rootpath);

  999.             G.rootlen = 0;

  1000.         }

  1001.         return MPN_OK;

  1002.     }

  1003. 

  1004.     return MPN_INVALID; /* should never reach */

  1005. 

  1006. } /* end function checkdir() */

  1007. 

  1008. 

  1009. 

  1010. 

  1011. 

  1012. #ifdef NO_MKDIR

  1013. 

  1014. /********************/

  1015. /* Function mkdir() */

  1016. /********************/

  1017. 

  1018. int mkdir(path, mode)

  1019.     ZCONST char *path;

  1020.     int mode;   /* ignored */

  1021. /*

  1022.  * returns:   0 - successful

  1023.  *           -1 - failed (errno not set, however)

  1024.  */

  1025. {

  1026.     char command[FILNAMSIZ+40]; /* buffer for system() call */

  1027. 

  1028.     /* GRR 930416:  added single quotes around path to avoid bug with

  1029.      * creating directories with ampersands in name; not yet tested */

  1030.     sprintf(command, "IFS=\" \t\n\" /bin/mkdir '%s' 2>/dev/null", path);

  1031.     if (system(command))

  1032.         return -1;

  1033.     return 0;

  1034. }

  1035. 

  1036. #endif /* NO_MKDIR */

  1037. 

  1038. 

  1039. 

  1040. 

  1041. #if (!defined(MTS) || defined(SET_DIR_ATTRIB))

  1042. static int get_extattribs OF((__GPRO__ iztimes *pzt, ulg z_uidgid[2]));

  1043. 

  1044. static int get_extattribs(__G__ pzt, z_uidgid)

  1045.     __GDEF

  1046.     iztimes *pzt;

  1047.     ulg z_uidgid[2];

  1048. {

  1049. /*---------------------------------------------------------------------------

  1050.     Convert from MSDOS-format local time and date to Unix-format 32-bit GMT

  1051.     time:  adjust base year from 1980 to 1970, do usual conversions from

  1052.     yy/mm/dd hh:mm:ss to elapsed seconds, and account for timezone and day-

  1053.     light savings time differences.  If we have a Unix extra field, however,

  1054.     we're laughing:  both mtime and atime are ours.  On the other hand, we

  1055.     then have to check for restoration of UID/GID.

  1056.   ---------------------------------------------------------------------------*/

  1057.     int have_uidgid_flg;

  1058.     unsigned eb_izux_flg;

  1059. 

  1060.     eb_izux_flg = (G.extra_field ? ef_scan_for_izux(G.extra_field,

  1061.                    G.lrec.extra_field_length, 0, G.lrec.last_mod_dos_datetime,

  1062. #ifdef IZ_CHECK_TZ

  1063.                    (G.tz_is_valid ? pzt : NULL),

  1064. #else

  1065.                    pzt,

  1066. #endif

  1067.                    z_uidgid) : 0);

  1068.     if (eb_izux_flg & EB_UT_FL_MTIME) {

  1069.         TTrace((stderr, "\nget_extattribs:  Unix e.f. modif. time = %ld\n",

  1070.           pzt->mtime));

  1071.     } else {

  1072.         pzt->mtime = dos_to_unix_time(G.lrec.last_mod_dos_datetime);

  1073.     }

  1074.     if (eb_izux_flg & EB_UT_FL_ATIME) {

  1075.         TTrace((stderr, "get_extattribs:  Unix e.f. access time = %ld\n",

  1076.           pzt->atime));

  1077.     } else {

  1078.         pzt->atime = pzt->mtime;

  1079.         TTrace((stderr, "\nget_extattribs:  modification/access times = %ld\n",

  1080.           pzt->mtime));

  1081.     }

  1082. 

  1083.     /* if -X option was specified and we have UID/GID info, restore it */

  1084.     have_uidgid_flg =

  1085. #ifdef RESTORE_UIDGID

  1086.             (uO.X_flag && (eb_izux_flg & EB_UX2_VALID));

  1087. #else

  1088.             0;

  1089. #endif

  1090.     return have_uidgid_flg;

  1091. }

  1092. #endif /* !MTS || SET_DIR_ATTRIB */

  1093. 

  1094. 

  1095. 

  1096. #ifndef MTS

  1097. 

  1098. /****************************/

  1099. /* Function close_outfile() */

  1100. /****************************/

  1101. 

  1102. void close_outfile(__G)    /* GRR: change to return PK-style warning level */

  1103.     __GDEF

  1104. {

  1105.     union {

  1106.         iztimes t3;             /* mtime, atime, ctime */

  1107.         ztimbuf t2;             /* modtime, actime */

  1108.     } zt;

  1109.     ulg z_uidgid[2];

  1110.     int have_uidgid_flg;

  1111. 

  1112.     have_uidgid_flg = get_extattribs(__G__ &(zt.t3), z_uidgid);

  1113. 

  1114. /*---------------------------------------------------------------------------

  1115.     If symbolic links are supported, allocate storage for a symlink control

  1116.     structure, put the uncompressed "data" and other required info in it, and

  1117.     add the structure to the "deferred symlinks" chain.  Since we know it's a

  1118.     symbolic link to start with, we shouldn't have to worry about overflowing

  1119.     unsigned ints with unsigned longs.

  1120.   ---------------------------------------------------------------------------*/

  1121. 

  1122. #ifdef SYMLINKS

  1123.     if (G.symlnk) {

  1124.         extent ucsize = (extent)G.lrec.ucsize;

  1125. # ifdef SET_SYMLINK_ATTRIBS

  1126.         extent attribsize = sizeof(unsigned) +

  1127.                             (have_uidgid_flg ? sizeof(z_uidgid) : 0);

  1128. # else

  1129.         extent attribsize = 0;

  1130. # endif

  1131.         /* size of the symlink entry is the sum of

  1132.          *  (struct size (includes 1st '\0') + 1 additional trailing '\0'),

  1133.          *  system specific attribute data size (might be 0),

  1134.          *  and the lengths of name and link target.

  1135.          */

  1136.         extent slnk_entrysize = (sizeof(slinkentry) + 1) + attribsize +

  1137.                                 ucsize + strlen(G.filename);

  1138.         slinkentry *slnk_entry;

  1139. 

  1140.         if (slnk_entrysize < ucsize) {

  1141.             Info(slide, 0x201, ((char *)slide,

  1142.               "warning:  symbolic link (%s) failed: mem alloc overflow\n",

  1143.               FnFilter1(G.filename)));

  1144.             fclose(G.outfile);

  1145.             return;

  1146.         }

  1147. 

  1148.         if ((slnk_entry = (slinkentry *)malloc(slnk_entrysize)) == NULL) {

  1149.             Info(slide, 0x201, ((char *)slide,

  1150.               "warning:  symbolic link (%s) failed: no mem\n",

  1151.               FnFilter1(G.filename)));

  1152.             fclose(G.outfile);

  1153.             return;

  1154.         }

  1155.         slnk_entry->next = NULL;

  1156.         slnk_entry->targetlen = ucsize;

  1157.         slnk_entry->attriblen = attribsize;

  1158. # ifdef SET_SYMLINK_ATTRIBS

  1159.         memcpy(slnk_entry->buf, &(G.pInfo->file_attr),

  1160.                sizeof(unsigned));

  1161.         if (have_uidgid_flg)

  1162.             memcpy(slnk_entry->buf + 4, z_uidgid, sizeof(z_uidgid));

  1163. # endif

  1164.         slnk_entry->target = slnk_entry->buf + slnk_entry->attriblen;

  1165.         slnk_entry->fname = slnk_entry->target + ucsize + 1;

  1166.         strcpy(slnk_entry->fname, G.filename);

  1167. 

  1168.         /* move back to the start of the file to re-read the "link data" */

  1169.         rewind(G.outfile);

  1170. 

  1171.         if (fread(slnk_entry->target, 1, ucsize, G.outfile) != ucsize)

  1172.         {

  1173.             Info(slide, 0x201, ((char *)slide,

  1174.               "warning:  symbolic link (%s) failed\n",

  1175.               FnFilter1(G.filename)));

  1176.             free(slnk_entry);

  1177.             fclose(G.outfile);

  1178.             return;

  1179.         }

  1180.         fclose(G.outfile);                  /* close "link" file for good... */

  1181.         slnk_entry->target[ucsize] = '\0';

  1182.         if (QCOND2)

  1183.             Info(slide, 0, ((char *)slide, "-> %s ",

  1184.               FnFilter1(slnk_entry->target)));

  1185.         /* add this symlink record to the list of deferred symlinks */

  1186.         if (G.slink_last != NULL)

  1187.             G.slink_last->next = slnk_entry;

  1188.         else

  1189.             G.slink_head = slnk_entry;

  1190.         G.slink_last = slnk_entry;

  1191.         return;

  1192.     }

  1193. #endif /* SYMLINKS */

  1194. 

  1195. #ifdef QLZIP

  1196.     if (G.extra_field) {

  1197.         static void qlfix OF((__GPRO__ uch *ef_ptr, unsigned ef_len));

  1198. 

  1199.         qlfix(__G__ G.extra_field, G.lrec.extra_field_length);

  1200.     }

  1201. #endif

  1202. 

  1203. #if (defined(NO_FCHOWN))

  1204.     fclose(G.outfile);

  1205. #endif

  1206. 

  1207.     /* if -X option was specified and we have UID/GID info, restore it */

  1208.     if (have_uidgid_flg

  1209.         /* check that both uid and gid values fit into their data sizes */

  1210.         && ((ulg)(uid_t)(z_uidgid[0]) == z_uidgid[0])

  1211.         && ((ulg)(gid_t)(z_uidgid[1]) == z_uidgid[1])) {

  1212.         TTrace((stderr, "close_outfile:  restoring Unix UID/GID info\n"));

  1213. #if (defined(NO_FCHOWN))

  1214.         if (chown(G.filename, (uid_t)z_uidgid[0], (gid_t)z_uidgid[1]))

  1215. #else

  1216.         if (fchown(fileno(G.outfile), (uid_t)z_uidgid[0], (gid_t)z_uidgid[1]))

  1217. #endif

  1218.         {

  1219.             if (uO.qflag)

  1220.                 Info(slide, 0x201, ((char *)slide, CannotSetItemUidGid,

  1221.                   z_uidgid[0], z_uidgid[1], FnFilter1(G.filename),

  1222.                   strerror(errno)));

  1223.             else

  1224.                 Info(slide, 0x201, ((char *)slide, CannotSetUidGid,

  1225.                   z_uidgid[0], z_uidgid[1], strerror(errno)));

  1226.         }

  1227.     }

  1228. 

  1229. #if (!defined(NO_FCHOWN) && defined(NO_FCHMOD))

  1230.     fclose(G.outfile);

  1231. #endif

  1232. 

  1233. #if (!defined(NO_FCHOWN) && !defined(NO_FCHMOD))

  1234. /*---------------------------------------------------------------------------

  1235.     Change the file permissions from default ones to those stored in the

  1236.     zipfile.

  1237.   ---------------------------------------------------------------------------*/

  1238. 

  1239.     if (fchmod(fileno(G.outfile), filtattr(__G__ G.pInfo->file_attr)))

  1240.         perror("fchmod (file attributes) error");

  1241. 

  1242.     fclose(G.outfile);

  1243. #endif /* !NO_FCHOWN && !NO_FCHMOD */

  1244. 

  1245.     /* skip restoring time stamps on user's request */

  1246.     if (uO.D_flag <= 1) {

  1247.         /* set the file's access and modification times */

  1248.         if (utime(G.filename, &(zt.t2))) {

  1249.             if (uO.qflag)

  1250.                 Info(slide, 0x201, ((char *)slide, CannotSetItemTimestamps,

  1251.                   FnFilter1(G.filename), strerror(errno)));

  1252.             else

  1253.                 Info(slide, 0x201, ((char *)slide, CannotSetTimestamps,

  1254.                   strerror(errno)));

  1255.         }

  1256.     }

  1257. 

  1258. #if (defined(NO_FCHOWN) || defined(NO_FCHMOD))

  1259. /*---------------------------------------------------------------------------

  1260.     Change the file permissions from default ones to those stored in the

  1261.     zipfile.

  1262.   ---------------------------------------------------------------------------*/

  1263. 

  1264. #ifndef NO_CHMOD

  1265.     if (chmod(G.filename, filtattr(__G__ G.pInfo->file_attr)))

  1266.         perror("chmod (file attributes) error");

  1267. #endif

  1268. #endif /* NO_FCHOWN || NO_FCHMOD */

  1269. 

  1270. } /* end function close_outfile() */

  1271. 

  1272. #endif /* !MTS */

  1273. 

  1274. 

  1275. #if (defined(SYMLINKS) && defined(SET_SYMLINK_ATTRIBS))

  1276. int set_symlnk_attribs(__G__ slnk_entry)

  1277.     __GDEF

  1278.     slinkentry *slnk_entry;

  1279. {

  1280.     if (slnk_entry->attriblen > 0) {

  1281. # if (!defined(NO_LCHOWN))

  1282.       if (slnk_entry->attriblen > sizeof(unsigned)) {

  1283.         ulg *z_uidgid_p = (zvoid *)(slnk_entry->buf + sizeof(unsigned));

  1284.         /* check that both uid and gid values fit into their data sizes */

  1285.         if (((ulg)(uid_t)(z_uidgid_p[0]) == z_uidgid_p[0]) &&

  1286.             ((ulg)(gid_t)(z_uidgid_p[1]) == z_uidgid_p[1])) {

  1287.           TTrace((stderr,

  1288.             "set_symlnk_attribs:  restoring Unix UID/GID info for\n\

  1289.         %s\n",

  1290.             FnFilter1(slnk_entry->fname)));

  1291.           if (lchown(slnk_entry->fname,

  1292.                      (uid_t)z_uidgid_p[0], (gid_t)z_uidgid_p[1]))

  1293.           {

  1294.             Info(slide, 0x201, ((char *)slide, CannotSetItemUidGid,

  1295.               z_uidgid_p[0], z_uidgid_p[1], FnFilter1(slnk_entry->fname),

  1296.               strerror(errno)));

  1297.           }

  1298.         }

  1299.       }

  1300. # endif /* !NO_LCHOWN */

  1301. # if (!defined(NO_LCHMOD))

  1302.       TTrace((stderr,

  1303.         "set_symlnk_attribs:  restoring Unix attributes for\n        %s\n",

  1304.         FnFilter1(slnk_entry->fname)));

  1305.       if (lchmod(slnk_entry->fname,

  1306.                  filtattr(__G__ *(unsigned *)(zvoid *)slnk_entry->buf)))

  1307.           perror("lchmod (file attributes) error");

  1308. # endif /* !NO_LCHMOD */

  1309.     }

  1310.     /* currently, no error propagation... */

  1311.     return PK_OK;

  1312. } /* end function set_symlnk_attribs() */

  1313. #endif /* SYMLINKS && SET_SYMLINK_ATTRIBS */

  1314. 

  1315. 

  1316. #ifdef SET_DIR_ATTRIB

  1317. /* messages of code for setting directory attributes */

  1318. #  ifndef NO_CHMOD

  1319.   static ZCONST char DirlistChmodFailed[] =

  1320.     "warning:  cannot set permissions for %s\n          %s\n";

  1321. #  endif

  1322. 

  1323. 

  1324. int defer_dir_attribs(__G__ pd)

  1325.     __GDEF

  1326.     direntry **pd;

  1327. {

  1328.     uxdirattr *d_entry;

  1329. 

  1330.     d_entry = (uxdirattr *)malloc(sizeof(uxdirattr) + strlen(G.filename));

  1331.     *pd = (direntry *)d_entry;

  1332.     if (d_entry == (uxdirattr *)NULL) {

  1333.         return PK_MEM;

  1334.     }

  1335.     d_entry->fn = d_entry->fnbuf;

  1336.     strcpy(d_entry->fn, G.filename);

  1337. 

  1338.     d_entry->perms = G.pInfo->file_attr;

  1339. 

  1340.     d_entry->have_uidgid = get_extattribs(__G__ &(d_entry->u.t3),

  1341.                                           d_entry->uidgid);

  1342.     return PK_OK;

  1343. } /* end function defer_dir_attribs() */

  1344. 

  1345. 

  1346. int set_direc_attribs(__G__ d)

  1347.     __GDEF

  1348.     direntry *d;

  1349. {

  1350.     int errval = PK_OK;

  1351. 

  1352.     if (UxAtt(d)->have_uidgid &&

  1353.         /* check that both uid and gid values fit into their data sizes */

  1354.         ((ulg)(uid_t)(UxAtt(d)->uidgid[0]) == UxAtt(d)->uidgid[0]) &&

  1355.         ((ulg)(gid_t)(UxAtt(d)->uidgid[1]) == UxAtt(d)->uidgid[1]) &&

  1356.         chown(UxAtt(d)->fn, (uid_t)UxAtt(d)->uidgid[0],

  1357.               (gid_t)UxAtt(d)->uidgid[1]))

  1358.     {

  1359.         Info(slide, 0x201, ((char *)slide, CannotSetItemUidGid,

  1360.           UxAtt(d)->uidgid[0], UxAtt(d)->uidgid[1], FnFilter1(d->fn),

  1361.           strerror(errno)));

  1362.         if (!errval)

  1363.             errval = PK_WARN;

  1364.     }

  1365.     /* Skip restoring directory time stamps on user' request. */

  1366.     if (uO.D_flag <= 0) {

  1367.         /* restore directory timestamps */

  1368.         if (utime(d->fn, &UxAtt(d)->u.t2)) {

  1369.             Info(slide, 0x201, ((char *)slide, CannotSetItemTimestamps,

  1370.               FnFilter1(d->fn), strerror(errno)));

  1371.             if (!errval)

  1372.                 errval = PK_WARN;

  1373.         }

  1374.     }

  1375. #ifndef NO_CHMOD

  1376.     if (chmod(d->fn, UxAtt(d)->perms)) {

  1377.         Info(slide, 0x201, ((char *)slide, DirlistChmodFailed,

  1378.           FnFilter1(d->fn), strerror(errno)));

  1379.         if (!errval)

  1380.             errval = PK_WARN;

  1381.     }

  1382. #endif /* !NO_CHMOD */

  1383.     return errval;

  1384. } /* end function set_direc_attribs() */

  1385. 

  1386. #endif /* SET_DIR_ATTRIB */

  1387. 

  1388. 

  1389. 

  1390. 

  1391. #ifdef TIMESTAMP

  1392. 

  1393. /***************************/

  1394. /*  Function stamp_file()  */

  1395. /***************************/

  1396. 

  1397. int stamp_file(fname, modtime)

  1398.     ZCONST char *fname;

  1399.     time_t modtime;

  1400. {

  1401.     ztimbuf tp;

  1402. 

  1403.     tp.modtime = tp.actime = modtime;

  1404.     return (utime(fname, &tp));

  1405. 

  1406. } /* end function stamp_file() */

  1407. 

  1408. #endif /* TIMESTAMP */

  1409. 

  1410. 

  1411. 

  1412. 

  1413. #ifndef SFX

  1414. 

  1415. /************************/

  1416. /*  Function version()  */

  1417. /************************/

  1418. 

  1419. void version(__G)

  1420.     __GDEF

  1421. {

  1422. #if (defined(__GNUC__) && defined(NX_CURRENT_COMPILER_RELEASE))

  1423.     char cc_namebuf[40];

  1424.     char cc_versbuf[40];

  1425. #else

  1426. #if (defined(__SUNPRO_C))

  1427.     char cc_versbuf[17];

  1428. #else

  1429. #if (defined(__HP_cc) || defined(__IBMC__))

  1430.     char cc_versbuf[25];

  1431. #else

  1432. #if (defined(__DECC_VER))

  1433.     char cc_versbuf[17];

  1434.     int cc_verstyp;

  1435. #else

  1436. #if (defined(CRAY) && defined(_RELEASE))

  1437.     char cc_versbuf[40];

  1438. #endif /* (CRAY && _RELEASE) */

  1439. #endif /* __DECC_VER */

  1440. #endif /* __HP_cc || __IBMC__ */

  1441. #endif /* __SUNPRO_C */

  1442. #endif /* (__GNUC__ && NX_CURRENT_COMPILER_RELEASE) */

  1443. 

  1444. #if ((defined(CRAY) || defined(cray)) && defined(_UNICOS))

  1445.     char os_namebuf[40];

  1446. #else

  1447. #if defined(__NetBSD__)

  1448.     char os_namebuf[40];

  1449. #endif

  1450. #endif

  1451. 

  1452.     /* Pyramid, NeXT have problems with huge macro expansion, too:  no Info() */

  1453.     sprintf((char *)slide, LoadFarString(CompiledWith),

  1454. 

  1455. #ifdef __GNUC__

  1456. #  ifdef NX_CURRENT_COMPILER_RELEASE

  1457.       (sprintf(cc_namebuf, "NeXT DevKit %d.%02d ",

  1458.         NX_CURRENT_COMPILER_RELEASE/100, NX_CURRENT_COMPILER_RELEASE%100),

  1459.        cc_namebuf),

  1460.       (strlen(__VERSION__) > 8)? "(gcc)" :

  1461.         (sprintf(cc_versbuf, "(gcc %s)", __VERSION__), cc_versbuf),

  1462. #  else

  1463.       "gcc ", __VERSION__,

  1464. #  endif

  1465. #else

  1466. #if defined(__SUNPRO_C)

  1467.       "Sun C ", (sprintf(cc_versbuf, "version %x", __SUNPRO_C), cc_versbuf),

  1468. #else

  1469. #if (defined(__HP_cc))

  1470.       "HP C ",

  1471.       (((__HP_cc% 100) == 0) ?

  1472.       (sprintf(cc_versbuf, "version A.%02d.%02d",

  1473.       (__HP_cc/ 10000), ((__HP_cc% 10000)/ 100))) :

  1474.       (sprintf(cc_versbuf, "version A.%02d.%02d.%02d",

  1475.       (__HP_cc/ 10000), ((__HP_cc% 10000)/ 100), (__HP_cc% 100))),

  1476.       cc_versbuf),

  1477. #else

  1478. #if (defined(__DECC_VER))

  1479.       "DEC C ",

  1480.       (sprintf(cc_versbuf, "%c%d.%d-%03d",

  1481.                ((cc_verstyp = (__DECC_VER / 10000) % 10) == 6 ? 'T' :

  1482.                 (cc_verstyp == 8 ? 'S' : 'V')),

  1483.                __DECC_VER / 10000000,

  1484.                (__DECC_VER % 10000000) / 100000, __DECC_VER % 1000),

  1485.                cc_versbuf),

  1486. #else

  1487. #if defined(CRAY) && defined(_RELEASE)

  1488.       "cc ", (sprintf(cc_versbuf, "version %d", _RELEASE), cc_versbuf),

  1489. #else

  1490. #ifdef __IBMC__

  1491.       "IBM C ",

  1492.       (sprintf(cc_versbuf, "version %d.%d.%d",

  1493.                (__IBMC__ / 100), ((__IBMC__ / 10) % 10), (__IBMC__ % 10)),

  1494.                cc_versbuf),

  1495. #else

  1496. #ifdef __VERSION__

  1497. #   ifndef IZ_CC_NAME

  1498. #    define IZ_CC_NAME "cc "

  1499. #   endif

  1500.       IZ_CC_NAME, __VERSION__

  1501. #else

  1502. #   ifndef IZ_CC_NAME

  1503. #    define IZ_CC_NAME "cc"

  1504. #   endif

  1505.       IZ_CC_NAME, "",

  1506. #endif /* ?__VERSION__ */

  1507. #endif /* ?__IBMC__ */

  1508. #endif /* ?(CRAY && _RELEASE) */

  1509. #endif /* ?__DECC_VER */

  1510. #endif /* ?__HP_cc */

  1511. #endif /* ?__SUNPRO_C */

  1512. #endif /* ?__GNUC__ */

  1513. 

  1514. #ifndef IZ_OS_NAME

  1515. #  define IZ_OS_NAME "Unix"

  1516. #endif

  1517.       IZ_OS_NAME,

  1518. 

  1519. #if defined(sgi) || defined(__sgi)

  1520.       " (Silicon Graphics IRIX)",

  1521. #else

  1522. #ifdef sun

  1523. #  ifdef sparc

  1524. #    ifdef __SVR4

  1525.       " (Sun SPARC/Solaris)",

  1526. #    else /* may or may not be SunOS */

  1527.       " (Sun SPARC)",

  1528. #    endif

  1529. #  else

  1530. #  if defined(sun386) || defined(i386)

  1531.       " (Sun 386i)",

  1532. #  else

  1533. #  if defined(mc68020) || defined(__mc68020__)

  1534.       " (Sun 3)",

  1535. #  else /* mc68010 or mc68000:  Sun 2 or earlier */

  1536.       " (Sun 2)",

  1537. #  endif

  1538. #  endif

  1539. #  endif

  1540. #else

  1541. #ifdef __hpux

  1542.       " (HP-UX)",

  1543. #else

  1544. #ifdef __osf__

  1545.       " (DEC OSF/1)",

  1546. #else

  1547. #ifdef _AIX

  1548.       " (IBM AIX)",

  1549. #else

  1550. #ifdef aiws

  1551.       " (IBM RT/AIX)",

  1552. #else

  1553. #if defined(CRAY) || defined(cray)

  1554. #  ifdef _UNICOS

  1555.       (sprintf(os_namebuf, " (Cray UNICOS release %d)", _UNICOS), os_namebuf),

  1556. #  else

  1557.       " (Cray UNICOS)",

  1558. #  endif

  1559. #else

  1560. #if defined(uts) || defined(UTS)

  1561.       " (Amdahl UTS)",

  1562. #else

  1563. #ifdef NeXT

  1564. #  ifdef mc68000

  1565.       " (NeXTStep/black)",

  1566. #  else

  1567.       " (NeXTStep for Intel)",

  1568. #  endif

  1569. #else              /* the next dozen or so are somewhat order-dependent */

  1570. #ifdef LINUX

  1571. #  ifdef __ELF__

  1572.       " (Linux ELF)",

  1573. #  else

  1574.       " (Linux a.out)",

  1575. #  endif

  1576. #else

  1577. #ifdef MINIX

  1578.       " (Minix)",

  1579. #else

  1580. #ifdef M_UNIX

  1581.       " (SCO Unix)",

  1582. #else

  1583. #ifdef M_XENIX

  1584.       " (SCO Xenix)",

  1585. #else

  1586. #ifdef __NetBSD__

  1587. #  ifdef NetBSD0_8

  1588.       (sprintf(os_namebuf, " (NetBSD 0.8%c)", (char)(NetBSD0_8 - 1 + 'A')),

  1589.        os_namebuf),

  1590. #  else

  1591. #  ifdef NetBSD0_9

  1592.       (sprintf(os_namebuf, " (NetBSD 0.9%c)", (char)(NetBSD0_9 - 1 + 'A')),

  1593.        os_namebuf),

  1594. #  else

  1595. #  ifdef NetBSD1_0

  1596.       (sprintf(os_namebuf, " (NetBSD 1.0%c)", (char)(NetBSD1_0 - 1 + 'A')),

  1597.        os_namebuf),

  1598. #  else

  1599.       (BSD4_4 == 0.5)? " (NetBSD before 0.9)" : " (NetBSD 1.1 or later)",

  1600. #  endif

  1601. #  endif

  1602. #  endif

  1603. #else

  1604. #ifdef __FreeBSD__

  1605.       (BSD4_4 == 0.5)? " (FreeBSD 1.x)" : " (FreeBSD 2.0 or later)",

  1606. #else

  1607. #ifdef __bsdi__

  1608.       (BSD4_4 == 0.5)? " (BSD/386 1.0)" : " (BSD/386 1.1 or later)",

  1609. #else

  1610. #ifdef __386BSD__

  1611.       (BSD4_4 == 1)? " (386BSD, post-4.4 release)" : " (386BSD)",

  1612. #else

  1613. #ifdef __CYGWIN__

  1614.       " (Cygwin)",

  1615. #else

  1616. #if defined(i686) || defined(__i686) || defined(__i686__)

  1617.       " (Intel 686)",

  1618. #else

  1619. #if defined(i586) || defined(__i586) || defined(__i586__)

  1620.       " (Intel 586)",

  1621. #else

  1622. #if defined(i486) || defined(__i486) || defined(__i486__)

  1623.       " (Intel 486)",

  1624. #else

  1625. #if defined(i386) || defined(__i386) || defined(__i386__)

  1626.       " (Intel 386)",

  1627. #else

  1628. #ifdef pyr

  1629.       " (Pyramid)",

  1630. #else

  1631. #ifdef ultrix

  1632. #  ifdef mips

  1633.       " (DEC/MIPS)",

  1634. #  else

  1635. #  ifdef vax

  1636.       " (DEC/VAX)",

  1637. #  else /* __alpha? */

  1638.       " (DEC/Alpha)",

  1639. #  endif

  1640. #  endif

  1641. #else

  1642. #ifdef gould

  1643.       " (Gould)",

  1644. #else

  1645. #ifdef MTS

  1646.       " (MTS)",

  1647. #else

  1648. #ifdef __convexc__

  1649.       " (Convex)",

  1650. #else

  1651. #ifdef __QNX__

  1652.       " (QNX 4)",

  1653. #else

  1654. #ifdef __QNXNTO__

  1655.       " (QNX Neutrino)",

  1656. #else

  1657. #ifdef Lynx

  1658.       " (LynxOS)",

  1659. #else

  1660. #ifdef __APPLE__

  1661. #  ifdef __i386__

  1662.       " Mac OS X Intel i32",

  1663. #  else

  1664. #  ifdef __ppc__

  1665.       " Mac OS X PowerPC",

  1666. #  else

  1667. #  ifdef __ppc64__

  1668.       " Mac OS X PowerPC64",

  1669. #  else

  1670.       " Mac OS X",

  1671. #  endif /* __ppc64__ */

  1672. #  endif /* __ppc__ */

  1673. #  endif /* __i386__ */

  1674. #else

  1675.       "",

  1676. #endif /* Apple */

  1677. #endif /* Lynx */

  1678. #endif /* QNX Neutrino */

  1679. #endif /* QNX 4 */

  1680. #endif /* Convex */

  1681. #endif /* MTS */

  1682. #endif /* Gould */

  1683. #endif /* DEC */

  1684. #endif /* Pyramid */

  1685. #endif /* 386 */

  1686. #endif /* 486 */

  1687. #endif /* 586 */

  1688. #endif /* 686 */

  1689. #endif /* Cygwin */

  1690. #endif /* 386BSD */

  1691. #endif /* BSDI BSD/386 */

  1692. #endif /* NetBSD */

  1693. #endif /* FreeBSD */

  1694. #endif /* SCO Xenix */

  1695. #endif /* SCO Unix */

  1696. #endif /* Minix */

  1697. #endif /* Linux */

  1698. #endif /* NeXT */

  1699. #endif /* Amdahl */

  1700. #endif /* Cray */

  1701. #endif /* RT/AIX */

  1702. #endif /* AIX */

  1703. #endif /* OSF/1 */

  1704. #endif /* HP-UX */

  1705. #endif /* Sun */

  1706. #endif /* SGI */

  1707. 

  1708. #ifdef __DATE__

  1709.       " on ", __DATE__

  1710. #else

  1711.       "", ""

  1712. #endif

  1713.     );

  1714. 

  1715.     (*G.message)((zvoid *)&G, slide, (ulg)strlen((char *)slide), 0);

  1716. 

  1717. } /* end function version() */

  1718. 

  1719. #endif /* !SFX */

  1720. 

  1721. 

  1722. 

  1723. 

  1724. #ifdef QLZIP

  1725. 

  1726. struct qdirect  {

  1727.     long            d_length __attribute__ ((packed));  /* file length */

  1728.     unsigned char   d_access __attribute__ ((packed));  /* file access type */

  1729.     unsigned char   d_type __attribute__ ((packed));    /* file type */

  1730.     long            d_datalen __attribute__ ((packed)); /* data length */

  1731.     long            d_reserved __attribute__ ((packed));/* Unused */

  1732.     short           d_szname __attribute__ ((packed));  /* size of name */

  1733.     char            d_name[36] __attribute__ ((packed));/* name area */

  1734.     long            d_update __attribute__ ((packed));  /* last update */

  1735.     long            d_refdate __attribute__ ((packed));

  1736.     long            d_backup __attribute__ ((packed));   /* EOD */

  1737. };

  1738. 

  1739. #define LONGID  "QDOS02"

  1740. #define EXTRALEN (sizeof(struct qdirect) + 8)

  1741. #define JBLONGID    "QZHD"

  1742. #define JBEXTRALEN  (sizeof(jbextra)  - 4 * sizeof(char))

  1743. 

  1744. typedef struct {

  1745.     char        eb_header[4] __attribute__ ((packed));  /* place_holder */

  1746.     char        longid[8] __attribute__ ((packed));

  1747.     struct      qdirect     header __attribute__ ((packed));

  1748. } qdosextra;

  1749. 

  1750. typedef struct {

  1751.     char        eb_header[4];                           /* place_holder */

  1752.     char        longid[4];

  1753.     struct      qdirect     header;

  1754. } jbextra;

  1755. 

  1756. 

  1757. 

  1758. /*  The following two functions SH() and LG() convert big-endian short

  1759.  *  and long numbers into native byte order.  They are some kind of

  1760.  *  counterpart to the generic UnZip's makeword() and makelong() functions.

  1761.  */

  1762. static ush SH(ush val)

  1763. {

  1764.     uch swapbuf[2];

  1765. 

  1766.     swapbuf[1] = (uch)(val & 0xff);

  1767.     swapbuf[0] = (uch)(val >> 8);

  1768.     return (*(ush *)swapbuf);

  1769. }

  1770. 

  1771. 

  1772. 

  1773. static ulg LG(ulg val)

  1774. {

  1775.     /*  convert the big-endian unsigned long number `val' to the machine

  1776.      *  dependent representation

  1777.      */

  1778.     ush swapbuf[2];

  1779. 

  1780.     swapbuf[1] = SH((ush)(val & 0xffff));

  1781.     swapbuf[0] = SH((ush)(val >> 16));

  1782.     return (*(ulg *)swapbuf);

  1783. }

  1784. 

  1785. 

  1786. 

  1787. static void qlfix(__G__ ef_ptr, ef_len)

  1788.     __GDEF

  1789.     uch *ef_ptr;

  1790.     unsigned ef_len;

  1791. {

  1792.     while (ef_len >= EB_HEADSIZE)

  1793.     {

  1794.         unsigned    eb_id  = makeword(EB_ID + ef_ptr);

  1795.         unsigned    eb_len = makeword(EB_LEN + ef_ptr);

  1796. 

  1797.         if (eb_len > (ef_len - EB_HEADSIZE)) {

  1798.             /* discovered some extra field inconsistency! */

  1799.             Trace((stderr,

  1800.               "qlfix: block length %u > rest ef_size %u\n", eb_len,

  1801.               ef_len - EB_HEADSIZE));

  1802.             break;

  1803.         }

  1804. 

  1805.         switch (eb_id) {

  1806.           case EF_QDOS:

  1807.           {

  1808.             struct _ntc_

  1809.             {

  1810.                 long id;

  1811.                 long dlen;

  1812.             } ntc;

  1813.             long dlen = 0;

  1814. 

  1815.             qdosextra   *extra = (qdosextra *)ef_ptr;

  1816.             jbextra     *jbp   = (jbextra   *)ef_ptr;

  1817. 

  1818.             if (!strncmp(extra->longid, LONGID, strlen(LONGID)))

  1819.             {

  1820.                 if (eb_len != EXTRALEN)

  1821.                     if (uO.qflag)

  1822.                         Info(slide, 0x201, ((char *)slide,

  1823.                           "warning:  invalid length in Qdos field for %s\n",

  1824.                           FnFilter1(G.filename)));

  1825.                     else

  1826.                         Info(slide, 0x201, ((char *)slide,

  1827.                           "warning:  invalid length in Qdos field"));

  1828. 

  1829.                 if (extra->header.d_type)

  1830.                 {

  1831.                     dlen = extra->header.d_datalen;

  1832.                 }

  1833.             }

  1834. 

  1835.             if (!strncmp(jbp->longid, JBLONGID, strlen(JBLONGID)))

  1836.             {

  1837.                 if (eb_len != JBEXTRALEN)

  1838.                     if (uO.qflag)

  1839.                         Info(slide, 0x201, ((char *)slide,

  1840.                           "warning:  invalid length in QZ field for %s\n",

  1841.                           FnFilter1(G.filename)));

  1842.                     else

  1843.                         Info(slide, 0x201, ((char *)slide,

  1844.                           "warning:  invalid length in QZ field"));

  1845.                 if (jbp->header.d_type)

  1846.                 {

  1847.                     dlen = jbp->header.d_datalen;

  1848.                 }

  1849.             }

  1850. 

  1851.             if ((long)LG(dlen) > 0)

  1852.             {

  1853.                 zfseeko(G.outfile, -8, SEEK_END);

  1854.                 fread(&ntc, 8, 1, G.outfile);

  1855.                 if (ntc.id != *(long *)"XTcc")

  1856.                 {

  1857.                     ntc.id = *(long *)"XTcc";

  1858.                     ntc.dlen = dlen;

  1859.                     fwrite (&ntc, 8, 1, G.outfile);

  1860.                 }

  1861.                 Info(slide, 0x201, ((char *)slide, "QData = %d", LG(dlen)));

  1862.             }

  1863.             return;     /* finished, cancel further extra field scanning */

  1864.           }

  1865. 

  1866.           default:

  1867.             Trace((stderr,"qlfix: unknown extra field block, ID=%d\n",

  1868.                eb_id));

  1869.         }

  1870. 

  1871.         /* Skip this extra field block */

  1872.         ef_ptr += (eb_len + EB_HEADSIZE);

  1873.         ef_len -= (eb_len + EB_HEADSIZE);

  1874.     }

  1875. }

  1876. #endif /* QLZIP */