Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume44/unzip/part11

Internet Message Format | 1994-09-19 | 70.5 KB

From: [e-mail] (Info-ZIP group)
Newsgroups: comp.sources.misc
Subject: v44i076:  unzip - Info-ZIP portable UnZip, version 5.12, Part11/20
Date: 18 Sep 1994 23:15:55 -0500
Organization: Sterling Software
Sender: [e-mail]
Approved: [e-mail]
Message-ID: <35j39r$[e-mail]>
X-Md4-Signature: 4920733f0064af3e6e74920667821d9b

Submitted-by: [e-mail] (Info-ZIP group)
Posting-number: Volume 44, Issue 76
Archive-name: unzip/part11
Environment: UNIX, VMS, OS/2, MS-DOS, MACINTOSH, WIN-NT, LINUX, MINIX, COHERENT, AMIGA?, ATARI TOS, SGI, DEC, Cray, Convex, Amdahl, Sun
Supersedes: unzip50: Volume 31, Issue 104-117

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# Contents:  unzip-5.12/atari/README unzip-5.12/mac/mac.c
#   unzip-5.12/unzip.doc
# Wrapped by kent@sparky on Sat Sep 17 23:33:42 1994
PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
echo If this archive is complete, you will see the following message:
echo '          "shar: End of archive 11 (of 20)."'
if test -f 'unzip-5.12/atari/README' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'unzip-5.12/atari/README'\"
else
  echo shar: Extracting \"'unzip-5.12/atari/README'\" \(2181 characters\)
  sed "s/^X//" >'unzip-5.12/atari/README' <<'END_OF_FILE'
XHere it is...  the UnZip 5.1 port for the Atari ST/TT/Falcon!
X
XThis took me longer than I expected thanks to a difference between the
XMiNT library and most UNIX libraries...  symlinks are 0x16000
Xinstead of 0xa000...  I'm told this isn't even defined in POSIX, so I
Xcan't really complain.  At least we've got a filesystem that can use
Xsymlinks!
X
XThis port requires GNU C and allows you to build an unzip/zipinfo/funzip
Xthat supports long filenames (on appropriate filesystems, thanks to the
XMiNT library), as well as symlinks.  It also does "proper" (ie, DOS-style)
Xtranslation of text-file end-of-line characters.  The programs also build
Xas shared-text binaries, so you can start unzipping several files at once
Xin the background and only a small part of unzip will be duplicated in
Xmemory.
X
XI build unzip with the MiNT library, GNU C 2.5.8 (2.5.7 and lower have a
Xrather sever problem in the optimiser that affects 68000 code only; it
Xadds 68020-only instructions to the 68000 code).  Oh, and I tested it
Xextensively under MiNT's minix filesystem as well as the bogus DOS
Xfilesystem that "normal" Atari partitions have.
X
XThe Makefile won't need any editing if you want to built unzip et al. on
Xa minix filesystem; if you want to install it on a DOS filesystem, use
X"cp" instead of "ln" for zipinfo.  [Or, to save disk space, make a script/
Xcommand-file which invokes "unzip -Z ...". --CN]  This is such a good
Xidea that I'm annoyed that Greg thought of it and I didn't...  ;-)  If
Xyou're using a shell worth your while, you can alias zipinfo to
X'unzip -Z' and then forget all about this paragraph.
X
XIf you want to compile this using Turbo C (aka Pure C in North America)
Xyou're on your own...  That's ok, I'll make a nice binary version of
Xunzip available as soon as the official 5.1 version is released (give or
Xtake a few days).
X
XEnjoy!  Cave Newt should be given kudos for keeping this monster easy to
Xport...  ;-)  [Hah!  But thanks anyway. :-) --CN]
X
XPLEASE email me to tell me if you've uploaded the source or binary
Xversions of Unzip 5.x to any BBS systems or commercial online systems so
Xwe can update the Where file!
X
X-Chris-
[e-mail]
END_OF_FILE
  if test 2181 -ne `wc -c <'unzip-5.12/atari/README'`; then
    echo shar: \"'unzip-5.12/atari/README'\" unpacked with wrong size!
  fi
  # end of 'unzip-5.12/atari/README'
fi
if test -f 'unzip-5.12/mac/mac.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'unzip-5.12/mac/mac.c'\"
else
  echo shar: Extracting \"'unzip-5.12/mac/mac.c'\" \(31814 characters\)
  sed "s/^X//" >'unzip-5.12/mac/mac.c' <<'END_OF_FILE'
X/*---------------------------------------------------------------------------
X
X  mac.c
X
X  Macintosh-specific routines for use with Info-ZIP's UnZip 5.1 and later.
X
X  This source file incorporates the contents of what was formerly macfile.c,
X  which supported commands (such as mkdir()) not available directly on the
X  Mac, and which also determined whether HFS (Hierarchical File System) or
X  MFS (Macintosh File System) was in use.
X
X  Contains:  do_wild()
X             mapattr()
X             mapname()
X             checkdir()
X             close_outfile()
X             version()
X             IsHFSDisk()
X             MacFSTest()
X             macmkdir()
X             ResolveMacVol()
X             macopen()
X             macfopen()
X             maccreat()
X             macread()
X             macwrite()
X             macclose()
X             maclseek()
X
X  ---------------------------------------------------------------------------*/
X
X
X
X#include "unzip.h"
X
X#ifdef MACOS
X#ifndef FSFCBLen
X#  define FSFCBLen  (*(short *)0x3F6)
X#endif
X
X#define read_only   file_attr   /* for readability only */
X
Xstatic short wAppVRefNum;
Xstatic long lAppDirID;
Xint HFSFlag;            /* set if disk has hierarchical file system */
X
Xstatic int created_dir;        /* used in mapname(), checkdir() */
Xstatic int renamed_fullpath;   /* ditto */
X
X#define MKDIR(path)     macmkdir(path, gnVRefNum, glDirID)
X
X
X
X
X
X/**********************/
X/* Function do_wild() */   /* for porting:  dir separator; match(ignore_case) */
X/**********************/
X
Xchar *do_wild(wildspec)
X    char *wildspec;         /* only used first time on a given dir */
X{
X    static DIR *dir = NULL;
X    static char *dirname, *wildname, matchname[FILNAMSIZ];
X    static int firstcall=TRUE, have_dirname, dirnamelen;
X    struct direct *file;
X
X
X    /* Even when we're just returning wildspec, we *always* do so in
X     * matchname[]--calling routine is allowed to append four characters
X     * to the returned string, and wildspec may be a pointer to argv[].
X     */
X    if (firstcall) {        /* first call:  must initialize everything */
X        firstcall = FALSE;
X
X        /* break the wildspec into a directory part and a wildcard filename */
X        if ((wildname = strrchr(wildspec, ':')) == NULL) {
X            dirname = ":";
X            dirnamelen = 1;
X            have_dirname = FALSE;
X            wildname = wildspec;
X        } else {
X            ++wildname;     /* point at character after ':' */
X            dirnamelen = wildname - wildspec;
X            if ((dirname = (char *)malloc(dirnamelen+1)) == NULL) {
X                fprintf(stderr, "warning:  can't allocate wildcard buffers\n");
X                strcpy(matchname, wildspec);
X                return matchname;   /* but maybe filespec was not a wildcard */
X            }
X            strncpy(dirname, wildspec, dirnamelen);
X            dirname[dirnamelen] = '\0';
X            have_dirname = TRUE;
X        }
X
X        if ((dir = opendir(dirname)) != NULL) {
X            while ((file = readdir(dir)) != NULL) {
X                if (match(file->d_name, wildname, 0)) {  /* 0 == case sens. */
X                    if (have_dirname) {
X                        strcpy(matchname, dirname);
X                        strcpy(matchname+dirnamelen, file->d_name);
X                    } else
X                        strcpy(matchname, file->d_name);
X                    return matchname;
X                }
X            }
X            /* if we get to here directory is exhausted, so close it */
X            closedir(dir);
X            dir = NULL;
X        }
X
X        /* return the raw wildspec in case that works (e.g., directory not
X         * searchable, but filespec was not wild and file is readable) */
X        strcpy(matchname, wildspec);
X        return matchname;
X    }
X
X    /* last time through, might have failed opendir but returned raw wildspec */
X    if (dir == NULL) {
X        firstcall = TRUE;  /* nothing left to try--reset for new wildspec */
X        if (have_dirname)
X            free(dirname);
X        return (char *)NULL;
X    }
X
X#ifndef THINK_C            /* Think C only matches one at most (for now) */
X    /* If we've gotten this far, we've read and matched at least one entry
X     * successfully (in a previous call), so dirname has been copied into
X     * matchname already.
X     */
X    while ((file = readdir(dir)) != NULL)
X        if (match(file->d_name, wildname, 0)) {   /* 0 == don't ignore case */
X            if (have_dirname) {
X                /* strcpy(matchname, dirname); */
X                strcpy(matchname+dirnamelen, file->d_name);
X            } else
X                strcpy(matchname, file->d_name);
X            return matchname;
X        }
X#endif
X
X    closedir(dir);     /* have read at least one dir entry; nothing left */
X    dir = NULL;
X    firstcall = TRUE;  /* reset for new wildspec */
X    if (have_dirname)
X        free(dirname);
X    return (char *)NULL;
X
X} /* end function do_wild() */
X
X
X
X
X
X/**********************/
X/* Function mapattr() */
X/**********************/
X
Xint mapattr()
X{
X    /* only care about read-only bit, so just look at MS-DOS side of attrs */
X    pInfo->read_only = (unsigned)(crec.external_file_attributes & 1);
X    return 0;
X
X} /* end function mapattr() */
X
X
X
X
X
X/************************/
X/*  Function mapname()  */
X/************************/
X
Xint mapname(renamed)  /* return 0 if no error, 1 if caution (filename trunc), */
X    int renamed;      /* 2 if warning (skip file because dir doesn't exist), */
X{                     /* 3 if error (skip file), 10 if no memory (skip file) */
X    char pathcomp[FILNAMSIZ];   /* path-component buffer */
X    char *pp, *cp=NULL;         /* character pointers */
X    char *lastsemi = NULL;      /* pointer to last semi-colon in pathcomp */
X    int quote = FALSE;          /* flags */
X    int error = 0;
X    register unsigned workch;   /* hold the character being tested */
X
X
X/*---------------------------------------------------------------------------
X    Initialize various pointers and counters and stuff.
X  ---------------------------------------------------------------------------*/
X
X    /* can create path as long as not just freshening, or if user told us */
X    create_dirs = (!fflag || renamed);
X
X    created_dir = FALSE;        /* not yet */
X
X    /* user gave full pathname:  don't prepend rootpath */
X    renamed_fullpath = (renamed && (*filename == '/'));
X
X    if (checkdir((char *)NULL, INIT) == 10)
X        return 10;              /* initialize path buffer, unless no memory */
X
X    pp = pathcomp;              /* point to translation buffer */
X    if (!(renamed_fullpath || jflag))
X        *pp++ = ':';
X    *pp = '\0';
X
X    if (jflag)                  /* junking directories */
X        cp = (char *)strrchr(filename, '/');
X    if (cp == NULL)             /* no '/' or not junking dirs */
X        cp = filename;          /* point to internal zipfile-member pathname */
X    else
X        ++cp;                   /* point to start of last component of path */
X
X/*---------------------------------------------------------------------------
X    Begin main loop through characters in filename.
X  ---------------------------------------------------------------------------*/
X
X    while ((workch = (uch)*cp++) != 0) {
X
X        if (quote) {                 /* if character quoted, */
X            *pp++ = (char)workch;    /*  include it literally */
X            quote = FALSE;
X        } else
X            switch (workch) {
X            case '/':             /* can assume -j flag not given */
X                *pp = '\0';
X                if ((error = checkdir(pathcomp, APPEND_DIR)) > 1)
X                    return error;
X                pp = pathcomp;    /* reset conversion buffer for next piece */
X                lastsemi = NULL;  /* leave directory semi-colons alone */
X                break;
X
X            case ';':             /* VMS version (or DEC-20 attrib?) */
X                lastsemi = pp;         /* keep for now; remove VMS ";##" */
X                *pp++ = (char)workch;  /*  later, if requested */
X                break;
X
X            case '\026':          /* control-V quote for special chars */
X                quote = TRUE;     /* set flag for next character */
X                break;
X
X            default:
X                /* allow European characters in filenames: */
X                if (isprint(workch) || (128 <= workch && workch <= 254))
X                    *pp++ = (char)workch;
X            } /* end switch */
X
X    } /* end while loop */
X
X    *pp = '\0';                   /* done with pathcomp:  terminate it */
X
X    /* if not saving them, remove with VMS version numbers (appended ";###") */
X    if (!V_flag && lastsemi) {
X        pp = lastsemi + 1;
X        while (isdigit((uch)(*pp)))
X            ++pp;
X        if (*pp == '\0')          /* only digits between ';' and end:  nuke */
X            *lastsemi = '\0';
X    }
X
X/*---------------------------------------------------------------------------
X    Report if directory was created (and no file to create:  filename ended
X    in '/'), check name to be sure it exists, and combine path and name be-
X    fore exiting.
X  ---------------------------------------------------------------------------*/
X
X    if (filename[strlen(filename) - 1] == '/') {
X        checkdir(filename, GETPATH);
X        if (created_dir && QCOND2) {
X            fprintf(stdout, "   creating: %s\n", filename);
X            return IZ_CREATED_DIR;   /* set dir time (note trailing '/') */
X        }
X        return 2;   /* dir existed already; don't look for data to extract */
X    }
X
X    if (*pathcomp == '\0') {
X        fprintf(stderr, "mapname:  conversion of %s failed\n", filename);
X        return 3;
X    }
X
X    checkdir(pathcomp, APPEND_NAME);   /* returns 1 if truncated:  care? */
X    checkdir(filename, GETPATH);
X
X    return error;
X
X} /* end function mapname() */
X
X
X
X
X
X/***********************/
X/* Function checkdir() */
X/***********************/
X
Xint checkdir(pathcomp, flag)
X    char *pathcomp;
X    int flag;
X/*
X * returns:  1 - (on APPEND_NAME) truncated filename
X *           2 - path doesn't exist, not allowed to create
X *           3 - path doesn't exist, tried to create and failed; or
X *               path exists and is not a directory, but is supposed to be
X *           4 - path is too long
X *          10 - can't allocate memory for filename buffers
X */
X{
X    static int rootlen = 0;   /* length of rootpath */
X    static char *rootpath;    /* user's "extract-to" directory */
X    static char *buildpath;   /* full path (so far) to extracted file */
X    static char *end;         /* pointer to end of buildpath ('\0') */
X
X#   define FN_MASK   7
X#   define FUNCTION  (flag & FN_MASK)
X
X
X
X/*---------------------------------------------------------------------------
X    APPEND_DIR:  append the path component to the path being built and check
X    for its existence.  If doesn't exist and we are creating directories, do
X    so for this one; else signal success or error as appropriate.
X  ---------------------------------------------------------------------------*/
X
X    if (FUNCTION == APPEND_DIR) {
X        int too_long = FALSE;
X#ifdef SHORT_NAMES
X        char *old_end = end;
X#endif
X
X        Trace((stderr, "appending dir segment [%s]\n", pathcomp));
X        while ((*end = *pathcomp++) != '\0')
X            ++end;
X#ifdef SHORT_NAMES   /* path components restricted to 14 chars, typically */
X        if ((end-old_end) > FILENAME_MAX)  /* GRR:  proper constant? */
X            *(end = old_end + FILENAME_MAX) = '\0';
X#endif
X
X        /* GRR:  could do better check, see if overrunning buffer as we go:
X         * check end-buildpath after each append, set warning variable if
X         * within 20 of FILNAMSIZ; then if var set, do careful check when
X         * appending.  Clear variable when begin new path. */
X
X        if ((end-buildpath) > FILNAMSIZ-3)  /* need ':', one-char name, '\0' */
X            too_long = TRUE;                /* check if extracting directory? */
X        if (stat(buildpath, &statbuf)) {    /* path doesn't exist */
X            if (!create_dirs) {   /* told not to create (freshening) */
X                free(buildpath);
X                return 2;         /* path doesn't exist:  nothing to do */
X            }
X            if (too_long) {
X                fprintf(stderr, "checkdir error:  path too long: %s\n",
X                  buildpath);
X                fflush(stderr);
X                free(buildpath);
X                return 4;         /* no room for filenames:  fatal */
X            }
X            if (MKDIR(buildpath) == -1) {   /* create the directory */
X                fprintf(stderr, "checkdir error:  can't create %s\n\
X                 unable to process %s.\n", buildpath, filename);
X                fflush(stderr);
X                free(buildpath);
X                return 3;      /* path didn't exist, tried to create, failed */
X            }
X            created_dir = TRUE;
X        } else if (!S_ISDIR(statbuf.st_mode)) {
X            fprintf(stderr, "checkdir error:  %s exists but is not directory\n\
X                 unable to process %s.\n", buildpath, filename);
X            fflush(stderr);
X            free(buildpath);
X            return 3;          /* path existed but wasn't dir */
X        }
X        if (too_long) {
X            fprintf(stderr, "checkdir error:  path too long: %s\n", buildpath);
X            fflush(stderr);
X            free(buildpath);
X            return 4;         /* no room for filenames:  fatal */
X        }
X        *end++ = ':';
X        *end = '\0';
X        Trace((stderr, "buildpath now = [%s]\n", buildpath));
X        return 0;
X
X    } /* end if (FUNCTION == APPEND_DIR) */
X
X/*---------------------------------------------------------------------------
X    GETPATH:  copy full path to the string pointed at by pathcomp, and free
X    buildpath.
X  ---------------------------------------------------------------------------*/
X
X    if (FUNCTION == GETPATH) {
X        strcpy(pathcomp, buildpath);
X        Trace((stderr, "getting and freeing path [%s]\n", pathcomp));
X        free(buildpath);
X        buildpath = end = NULL;
X        return 0;
X    }
X
X/*---------------------------------------------------------------------------
X    APPEND_NAME:  assume the path component is the filename; append it and
X    return without checking for existence.
X  ---------------------------------------------------------------------------*/
X
X    if (FUNCTION == APPEND_NAME) {
X#ifdef SHORT_NAMES
X        char *old_end = end;
X#endif
X
X        Trace((stderr, "appending filename [%s]\n", pathcomp));
X        while ((*end = *pathcomp++) != '\0') {
X            ++end;
X#ifdef SHORT_NAMES  /* truncate name at 14 characters, typically */
X            if ((end-old_end) > FILENAME_MAX)      /* GRR:  proper constant? */
X                *(end = old_end + FILENAME_MAX) = '\0';
X#endif
X            if ((end-buildpath) >= FILNAMSIZ) {
X                *--end = '\0';
X                fprintf(stderr, "checkdir warning:  path too long; truncating\n\
Xcheckdir warning:  path too long; truncating\n\
X                   %s\n                -> %s\n", filename, buildpath);
X                fflush(stderr);
X                return 1;   /* filename truncated */
X            }
X        }
X        Trace((stderr, "buildpath now = [%s]\n", buildpath));
X        return 0;  /* could check for existence here, prompt for new name... */
X    }
X
X/*---------------------------------------------------------------------------
X    INIT:  allocate and initialize buffer space for the file currently being
X    extracted.  If file was renamed with an absolute path, don't prepend the
X    extract-to path.
X  ---------------------------------------------------------------------------*/
X
X    if (FUNCTION == INIT) {
X        Trace((stderr, "initializing buildpath to "));
X        if ((buildpath = (char *)malloc(strlen(filename)+rootlen+2)) == NULL)
X            return 10;
X        if ((rootlen > 0) && !renamed_fullpath) {
X            strcpy(buildpath, rootpath);
X            end = buildpath + rootlen;
X        } else {
X            *buildpath = '\0';
X            end = buildpath;
X        }
X        Trace((stderr, "[%s]\n", buildpath));
X        return 0;
X    }
X
X/*---------------------------------------------------------------------------
X    ROOT:  if appropriate, store the path in rootpath and create it if neces-
X    sary; else assume it's a zipfile member and return.  This path segment
X    gets used in extracting all members from every zipfile specified on the
X    command line.
X  ---------------------------------------------------------------------------*/
X
X#if (!defined(SFX) || defined(SFX_EXDIR))
X    if (FUNCTION == ROOT) {
X        Trace((stderr, "initializing root path to [%s]\n", pathcomp));
X        if (pathcomp == NULL) {
X            rootlen = 0;
X            return 0;
X        }
X        if ((rootlen = strlen(pathcomp)) > 0) {
X            int had_trailing_pathsep=FALSE;
X
X            if (pathcomp[rootlen-1] == ':') {
X                pathcomp[--rootlen] = '\0';
X                had_trailing_pathsep = TRUE;
X            }
X            if (rootlen > 0 && (stat(pathcomp, &statbuf) ||
X                !S_ISDIR(statbuf.st_mode)))          /* path does not exist */
X            {
X                if (!create_dirs                     /* || iswild(pathcomp) */
X#ifdef OLD_EXDIR
X                                 || !had_trailing_pathsep
X#endif
X                                                         ) {
X                    rootlen = 0;
X                    return 2;   /* treat as stored file */
X                }
X                /* create the directory (could add loop here to scan pathcomp
X                 * and create more than one level, but why really necessary?) */
X                if (MKDIR(pathcomp) == -1) {
X                    fprintf(stderr,
X                      "checkdir:  can't create extraction directory: %s\n",
X                      pathcomp);
X                    fflush(stderr);
X                    rootlen = 0;   /* path didn't exist, tried to create, and */
X                    return 3;  /* failed:  file exists, or 2+ levels required */
X                }
X            }
X            if ((rootpath = (char *)malloc(rootlen+2)) == NULL) {
X                rootlen = 0;
X                return 10;
X            }
X            strcpy(rootpath, pathcomp);
X            rootpath[rootlen++] = ':';
X            rootpath[rootlen] = '\0';
X        }
X        Trace((stderr, "rootpath now = [%s]\n", rootpath));
X        return 0;
X    }
X#endif /* !SFX || SFX_EXDIR */
X
X/*---------------------------------------------------------------------------
X    END:  free rootpath, immediately prior to program exit.
X  ---------------------------------------------------------------------------*/
X
X    if (FUNCTION == END) {
X        Trace((stderr, "freeing rootpath\n"));
X        if (rootlen > 0)
X            free(rootpath);
X        return 0;
X    }
X
X    return 99;  /* should never reach */
X
X} /* end function checkdir() */
X
X
X
X
X
X/****************************/
X/* Function close_outfile() */
X/****************************/
X
Xvoid close_outfile()
X{
X    long m_time;
X    DateTimeRec dtr;
X    ParamBlockRec pbr;
X    HParamBlockRec hpbr;
X    OSErr err;
X
X
X    if (fileno(outfile) == 1)   /* don't attempt to close or set time on stdout */
X        return;
X
X    fclose(outfile);
X
X    /*
X     * Macintosh bases all file modification times on the number of seconds
X     * elapsed since Jan 1, 1904, 00:00:00.  Therefore, to maintain
X     * compatibility with MS-DOS archives, which date from Jan 1, 1980,
X     * with NO relation to GMT, the following conversions must be made:
X     *      the Year (yr) must be incremented by 1980;
X     *      and converted to seconds using the Mac routine Date2Secs(),
X     *      almost similar in complexity to the Unix version :-)
X     *                                     J. Lee
X     */
X
X    dtr.year = (((lrec.last_mod_file_date >> 9) & 0x7f) + 1980);
X    dtr.month = ((lrec.last_mod_file_date >> 5) & 0x0f);
X    dtr.day = (lrec.last_mod_file_date & 0x1f);
X
X    dtr.hour = ((lrec.last_mod_file_time >> 11) & 0x1f);
X    dtr.minute = ((lrec.last_mod_file_time >> 5) & 0x3f);
X    dtr.second = ((lrec.last_mod_file_time & 0x1f) * 2);
X
X    Date2Secs(&dtr, (unsigned long *)&m_time);
X    c2pstr(filename);
X    if (HFSFlag) {
X        hpbr.fileParam.ioNamePtr = (StringPtr)filename;
X        hpbr.fileParam.ioVRefNum = gnVRefNum;
X        hpbr.fileParam.ioDirID = glDirID;
X        hpbr.fileParam.ioFDirIndex = 0;
X        err = PBHGetFInfo(&hpbr, 0L);
X        hpbr.fileParam.ioFlMdDat = m_time;
X        if ( !fMacZipped )
X            hpbr.fileParam.ioFlCrDat = m_time;
X        hpbr.fileParam.ioDirID = glDirID;
X        if (err == noErr)
X            err = PBHSetFInfo(&hpbr, 0L);
X        if (err != noErr)
X            printf("error:  can't set the time for %s\n", filename);
X    } else {
X        pbr.fileParam.ioNamePtr = (StringPtr)filename;
X        pbr.fileParam.ioVRefNum = pbr.fileParam.ioFVersNum =
X          pbr.fileParam.ioFDirIndex = 0;
X        err = PBGetFInfo(&pbr, 0L);
X        pbr.fileParam.ioFlMdDat = pbr.fileParam.ioFlCrDat = m_time;
X        if (err == noErr)
X            err = PBSetFInfo(&pbr, 0L);
X        if (err != noErr)
X            printf("error:  can't set the time for %s\n", filename);
X    }
X
X    /* set read-only perms if needed */
X    if ((err == noErr) && pInfo->read_only) {
X        if (HFSFlag) {
X            hpbr.fileParam.ioNamePtr = (StringPtr)filename;
X            hpbr.fileParam.ioVRefNum = gnVRefNum;
X            hpbr.fileParam.ioDirID = glDirID;
X            err = PBHSetFLock(&hpbr, 0);
X        } else
X            err = SetFLock((ConstStr255Param)filename, 0);
X    }
X    p2cstr(filename);
X
X} /* end function close_outfile() */
X
X
X
X
X
X#ifndef SFX
X
X/************************/
X/*  Function version()  */
X/************************/
X
Xvoid version()
X{
X    extern char Far  CompiledWith[];
X#if 0
X    char buf[40];
X#endif
X
X    printf(LoadFarString(CompiledWith),
X
X#ifdef __GNUC__
X      "gcc ", __VERSION__,
X#else
X#  if 0
X      "cc ", (sprintf(buf, " version %d", _RELEASE), buf),
X#  else
X#  ifdef THINK_C
X      "Think C", "",
X#  else
X#  ifdef MPW
X      "MPW C", "",
X#  else
X      "unknown compiler", "",
X#  endif
X#  endif
X#  endif
X#endif
X
X      "MacOS",
X
X#if defined(foobar) || defined(FOOBAR)
X      " (Foo BAR)",    /* hardware or OS version */
X#else
X      "",
X#endif /* Foo BAR */
X
X#ifdef __DATE__
X      " on ", __DATE__
X#else
X      "", ""
X#endif
X      );
X
X} /* end function version() */
X
X#endif /* !SFX */
X
X
X
X
X
X/************************/
X/* Function IsHFSDisk() */
X/************************/
X
Xstatic int IsHFSDisk(short wRefNum)
X{
X    /* get info about the specified volume */
X    if (HFSFlag == true) {
X        HParamBlockRec    hpbr;
X        Str255 temp;
X        short wErr;
X
X        hpbr.volumeParam.ioCompletion = 0;
X        hpbr.volumeParam.ioNamePtr = temp;
X        hpbr.volumeParam.ioVRefNum = wRefNum;
X        hpbr.volumeParam.ioVolIndex = 0;
X        wErr = PBHGetVInfo(&hpbr, 0);
X
X        if (wErr == noErr && hpbr.volumeParam.ioVFSID == 0
X            && hpbr.volumeParam.ioVSigWord == 0x4244) {
X                return true;
X        }
X    }
X
X    return false;
X} /* IsHFSDisk */
X
X
X
X
X
X/************************/
X/* Function MacFSTest() */
X/************************/
X
Xvoid MacFSTest(int vRefNum)
X{
X    Str255 st;
X
X    /* is this machine running HFS file system? */
X    if (FSFCBLen <= 0) {
X        HFSFlag = false;
X    }
X    else
X    {
X        HFSFlag = true;
X    }
X
X    /* get the file's volume reference number and directory ID */
X    if (HFSFlag == true) {
X        WDPBRec    wdpb;
X        OSErr err = noErr;
X
X        if (vRefNum != 0) {
X            wdpb.ioCompletion = false;
X            wdpb.ioNamePtr = st;
X            wdpb.ioWDIndex = 0;
X            wdpb.ioVRefNum = vRefNum;
X            err = PBHGetVol(&wdpb, false);
X
X            if (err == noErr) {
X                wAppVRefNum = wdpb.ioWDVRefNum;
X                lAppDirID = wdpb.ioWDDirID;
X            }
X        }
X
X        /* is the disk we're using formatted for HFS? */
X        HFSFlag = IsHFSDisk(wAppVRefNum);
X    }
X
X    return;
X} /* mactest */
X
X
X
X
X
X/***********************/
X/* Function macmkdir() */
X/***********************/
X
Xint macmkdir(char *path, short nVRefNum, long lDirID)
X{
X    OSErr    err = -1;
X
X    if (path != 0 && strlen(path)<256 && HFSFlag == true) {
X        HParamBlockRec    hpbr;
X        Str255    st;
X
X        c2pstr(path);
X        if ((nVRefNum == 0) && (lDirID == 0))
X        {
X            hpbr.fileParam.ioNamePtr = st;
X            hpbr.fileParam.ioCompletion = NULL;
X            err = PBHGetVol((WDPBPtr)&hpbr, false);
X            nVRefNum = hpbr.wdParam.ioWDVRefNum;
X            lDirID = hpbr.wdParam.ioWDDirID;
X        }
X        else
X        {
X            err = noErr;
X        }
X        if (err == noErr) {
X            hpbr.fileParam.ioCompletion = NULL;
X            hpbr.fileParam.ioVRefNum = nVRefNum;
X            hpbr.fileParam.ioDirID = lDirID;
X            hpbr.fileParam.ioNamePtr = (StringPtr)path;
X            err = PBDirCreate(&hpbr, false);
X        }
X        p2cstr(path);
X    }
X
X    return (int)err;
X} /* macmkdir */
X
X
X
X
X
X/****************************/
X/* Function ResolveMacVol() */
X/****************************/
X
Xvoid ResolveMacVol(short nVRefNum, short *pnVRefNum, long *plDirID, StringPtr pst)
X{
X    if (HFSFlag)
X    {
X        WDPBRec  wdpbr;
X        Str255   st;
X        OSErr    err;
X
X        wdpbr.ioCompletion = (ProcPtr)NULL;
X        wdpbr.ioNamePtr = st;
X        wdpbr.ioVRefNum = nVRefNum;
X        wdpbr.ioWDIndex = 0;
X        wdpbr.ioWDProcID = 0;
X        wdpbr.ioWDVRefNum = 0;
X        err = PBGetWDInfo( &wdpbr, false );
X        if ( err == noErr )
X        {
X            if (pnVRefNum)
X                *pnVRefNum = wdpbr.ioWDVRefNum;
X            if (plDirID)
X                *plDirID = wdpbr.ioWDDirID;
X            if (pst)
X                BlockMove( st, pst, st[0]+1 );
X        }
X    }
X    else
X    {
X        if (pnVRefNum)
X            *pnVRefNum = nVRefNum;
X        if (plDirID)
X            *plDirID = 0;
X        if (pst)
X            *pst = 0;
X    }
X}
X
X
X
X
X
X/**********************/
X/* Function macopen() */
X/**********************/
X
Xshort macopen(char *sz, short nFlags, short nVRefNum, long lDirID)
X{
X    OSErr   err;
X    Str255  st;
X    char    chPerms = (!nFlags) ? fsRdPerm : fsRdWrPerm;
X    short   nFRefNum;
X
X    c2pstr( sz );
X    BlockMove( sz, st, sz[0]+1 );
X    p2cstr( sz );
X    if (HFSFlag)
X    {
X        if (nFlags > 1)
X            err = HOpenRF( nVRefNum, lDirID, st, chPerms, &nFRefNum);
X        else
X            err = HOpen( nVRefNum, lDirID, st, chPerms, &nFRefNum);
X    }
X    else
X    {
X        /*
X         * Have to use PBxxx style calls since the high level
X         * versions don't support specifying permissions
X         */
X        ParamBlockRec    pbr;
X
X        pbr.ioParam.ioNamePtr = st;
X        pbr.ioParam.ioVRefNum = gnVRefNum;
X        pbr.ioParam.ioVersNum = 0;
X        pbr.ioParam.ioPermssn = chPerms;
X        pbr.ioParam.ioMisc = 0;
X        if (nFlags >1)
X            err = PBOpenRF( &pbr, false );
X        else
X            err = PBOpen( &pbr, false );
X        nFRefNum = pbr.ioParam.ioRefNum;
X    }
X    if ( err || (nFRefNum == 1) )
X        return -1;
X    else {
X        if ( nFlags )
X            SetEOF( nFRefNum, 0 );
X        return nFRefNum;
X    }
X}
X
X
X
X
X
X/***********************/
X/* Function macfopen() */
X/***********************/
X
XFILE *macfopen(char *filename, char *mode, short nVRefNum, long lDirID)
X    {
X        short outfd, fDataFork=TRUE;
X        MACINFO mi;
X        OSErr err;
X
X        fMacZipped = FALSE;
X        c2pstr(filename);
X        if (extra_field &&
X            (lrec.extra_field_length > sizeof(MACINFOMIN)) &&
X            (lrec.extra_field_length <= sizeof(MACINFO))) {
X            BlockMove(extra_field, &mi, lrec.extra_field_length);
X            if ((makeword((uch *)&mi.header) == 1992) &&
X                (makeword((uch *)&mi.data) ==
X                    lrec.extra_field_length-sizeof(ZIP_EXTRA_HEADER)) &&
X                (mi.signature == 'JLEE')) {
X                gostCreator = mi.finfo.fdCreator;
X                gostType = mi.finfo.fdType;
X                fDataFork = (mi.flags & 1) ? TRUE : FALSE;
X                fMacZipped = true;
X                /* If it was Zipped w/Mac version, the filename has either */
X                /* a 'd' or 'r' appended.  Remove the d/r when unzipping */
X                filename[0]-=1;
X            }
X        }
X        if (!fMacZipped) {
X            if (!aflag)
X                gostType = gostCreator = '\?\?\?\?';
X            else {
X                gostCreator = CREATOR;
X                gostType = 'TEXT';
X            }
X        }
X        p2cstr(filename);
X
X        if ((outfd = creat(filename, 0)) != -1) {
X            if (fMacZipped) {
X                c2pstr(filename);
X                if (HFSFlag) {
X                    HParamBlockRec   hpbr;
X
X                    hpbr.fileParam.ioNamePtr = (StringPtr)filename;
X                    hpbr.fileParam.ioVRefNum = gnVRefNum;
X                    hpbr.fileParam.ioDirID = glDirID;
X                    hpbr.fileParam.ioFlFndrInfo = mi.finfo;
X                    hpbr.fileParam.ioFlCrDat = mi.lCrDat;
X                    hpbr.fileParam.ioFlMdDat = mi.lMdDat;
X                    err = PBHSetFInfo(&hpbr, 0);
X                } else {
X                    err = SetFInfo((StringPtr)filename , 0, &mi.finfo);
X                }
X                p2cstr(filename);
X            }
X            outfd = open(filename, (fDataFork) ? 1 : 2);
X        }
X
X        if (outfd == -1)
X            return NULL;
X        else
X            return (FILE *)outfd;
X    }
X
X
X
X
X
X/***********************/
X/* Function maccreat() */
X/***********************/
X
Xshort maccreat(char *sz, short nVRefNum, long lDirID, OSType ostCreator, OSType ostType)
X{
X    OSErr   err;
X    Str255  st;
X    FInfo   fi;
X
X    c2pstr( sz );
X    BlockMove( sz, st, sz[0]+1 );
X    p2cstr( sz );
X    if (HFSFlag)
X    {
X        err = HGetFInfo( nVRefNum, lDirID, st, &fi );
X        if (err == fnfErr)
X            err = HCreate( nVRefNum, lDirID, st, ostCreator, ostType );
X        else if (err == noErr)
X        {
X            fi.fdCreator = ostCreator;
X            fi.fdType = ostType;
X            err = HSetFInfo( nVRefNum, lDirID, st, &fi );
X        }
X    }
X    else
X    {
X        err = GetFInfo( st, nVRefNum, &fi );
X        if (err == fnfErr)
X            err = Create( st, nVRefNum, ostCreator, ostType );
X        else if (err == noErr)
X        {
X            fi.fdCreator = ostCreator;
X            fi.fdType = ostType;
X            err = SetFInfo( st, nVRefNum, &fi );
X        }
X    }
X    if (err == noErr)
X        return noErr;
X    else
X        return -1;
X}
X
X
X
X
X
X/**********************/
X/* Function macread() */
X/**********************/
X
Xshort macread(short nFRefNum, char *pb, unsigned cb)
X{
X    long    lcb = cb;
X
X    (void)FSRead( nFRefNum, &lcb, pb );
X
X    return (short)lcb;
X}
X
X
X
X
X
X/***********************/
X/* Function macwrite() */
X/***********************/
X
Xlong macwrite(short nFRefNum, char *pb, unsigned cb)
X{
X    long    lcb = cb;
X
X#ifdef THINK_C
X    if ( (nFRefNum == 1) )
X        screenDump( pb, lcb );
X    else
X#endif
X        (void)FSWrite( nFRefNum, &lcb, pb );
X
X    return (long)lcb;
X}
X
X
X
X
X
X/***********************/
X/* Function macclose() */
X/***********************/
X
Xshort macclose(short nFRefNum)
X{
X    return FSClose( nFRefNum );
X}
X
X
X
X
X
X/***********************/
X/* Function maclseek() */
X/***********************/
X
Xlong maclseek(short nFRefNum, long lib, short nMode)
X{
X    ParamBlockRec   pbr;
X
X    if (nMode == SEEK_SET)
X        nMode = fsFromStart;
X    else if (nMode == SEEK_CUR)
X        nMode = fsFromMark;
X    else if (nMode == SEEK_END)
X        nMode = fsFromLEOF;
X    pbr.ioParam.ioRefNum = nFRefNum;
X    pbr.ioParam.ioPosMode = nMode;
X    pbr.ioParam.ioPosOffset = lib;
X    (void)PBSetFPos(&pbr, 0);
X    return pbr.ioParam.ioPosOffset;
X}
X
X#endif /* MACOS */
END_OF_FILE
  if test 31814 -ne `wc -c <'unzip-5.12/mac/mac.c'`; then
    echo shar: \"'unzip-5.12/mac/mac.c'\" unpacked with wrong size!
  fi
  # end of 'unzip-5.12/mac/mac.c'
fi
if test -f 'unzip-5.12/unzip.doc' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'unzip-5.12/unzip.doc'\"
else
  echo shar: Extracting \"'unzip-5.12/unzip.doc'\" \(33336 characters\)
  sed "s/^X//" >'unzip-5.12/unzip.doc' <<'END_OF_FILE'
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
XNAME
X     unzip - list, test and extract compressed  files  in  a  ZIP
X     archive
X
XSYNOPSIS
X     unzip [-Z] [-cflptuvz[abjnoqsCLV$]] file[.zip] [file(s) ...]
X     [-x xfile(s) ...] [-d exdir]
X
XDESCRIPTION
X     unzip will list, test, or extract files from a ZIP  archive,
X     commonly  found  on  MS-DOS  systems.   The default behavior
X     (with no options) is to extract into the  current  directory
X     (and  subdirectories  below it) all files from the specified
X     ZIP archive.  A  companion  program,  zip(1L),  creates  ZIP
X     archives; both programs are compatible with archives created
X     by PKWARE's PKZIP and PKUNZIP for MS-DOS, but in many  cases
X     the program options or default behaviors differ.
X
XARGUMENTS
X     file[.zip]
X          Path of the ZIP archive(s).  If the file  specification
X          is  a  wildcard,  each matching file is processed in an
X          order determined by the operating system (or file  sys-
X          tem).   Only  the  filename can be a wildcard; the path
X          itself cannot.  Wildcard  expressions  are  similar  to
X          Unix egrep(1) (regular) expressions and may contain:
X
X          *    matches a sequence of 0 or more characters
X
X          ?    matches exactly 1 character
X
X          [...]
X               matches any  single  character  found  inside  the
X               brackets;  ranges  are  specified  by  a beginning
X               character, a hyphen, and an ending character.   If
X               an  exclamation point or a caret (`!' or `^') fol-
X               lows the left bracket, then the range  of  charac-
X               ters within the brackets is complemented (that is,
X               anything except the characters inside the brackets
X               is considered a match).
X
X          (Be sure to quote any character which  might  otherwise
X          be  interpreted  or  modified  by the operating system,
X          particularly under Unix and VMS.)  If  no  matches  are
X          found,  the  specification  is  assumed to be a literal
X          filename; and if that also fails, the  suffix  .zip  is
X          appended.  Note that self-extracting ZIP files are sup-
X          ported, as with any other ZIP archive; just specify the
X          .exe suffix (if any) explicitly.
X
X     [file(s)]
X          An optional list of archive members  to  be  processed,
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 1
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X          separated  by  spaces.   (VMS  versions  compiled  with
X          VMSCLI defined must delimit files with commas  instead.
X          See  -v  in  OPTIONS below.) Regular expressions (wild-
X          cards) may be  used  to  match  multiple  members;  see
X          above.   Again, be sure to quote expressions that would
X          otherwise be expanded or modified by the operating sys-
X          tem.
X
X     [-x xfile(s)]
X          An optional list of archive members to be excluded from
X          processing.   Since wildcard characters match directory
X          separators (`/'), this option may be  used  to  exclude
X          any  files  which  are in subdirectories.  For example,
X          ``unzip foo *.[ch] -x */*'' would extract all C  source
X          files  in the main directory, but none in any subdirec-
X          tories.  Without the -x option, all C source  files  in
X          all directories within the zipfile would be extracted.
X
X     [-d exdir]
X          An optional directory to which to  extract  files.   By
X          default,  all files and subdirectories are recreated in
X          the current directory; the -d option allows  extraction
X          in an arbitrary directory (always assuming one has per-
X          mission to write to the directory).  This  option  need
X          not  appear  at the end of the command line; it is also
X          accepted immediately after the  zipfile  specification,
X          or  between  the file(s) and the -x option.  The option
X          and directory may be  concatenated  without  any  white
X          space between them, but note that this may cause normal
X          shell  behavior  to  be  suppressed.   In   particular,
X          ``-d ~''  (tilde) is expanded by Unix C shells into the
X          name of the  user's  home  directory,  but  ``-d~''  is
X          treated  as a literal subdirectory ``~'' of the current
X          directory.
X
XOPTIONS
X     Note that, in order to support obsolescent hardware, unzip's
X     usage  screen is limited to 22 or 23 lines and should there-
X     fore be considered a reminder  of  the  basic  unzip  syntax
X     rather than an exhaustive list of all possible flags.
X
X     -Z   zipinfo(1L) mode.  If the first option on  the  command
X          line  is  -Z,  the  remaining  options  are taken to be
X          zipinfo(1L) options.  See the appropriate  manual  page
X          for a description of these options.
X
X     -c   extract files to stdout/screen (``CRT'').  This  option
X          is  similar  to  the  -p option except that the name of
X          each file is printed as it is extracted, the -a  option
X          is  allowed,  and  ASCII-EBCDIC conversion is automati-
X          cally performed if appropriate.   This  option  is  not
X          listed in the unzip usage screen.
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 2
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X     -f   freshen existing files, i.e., extract only those  files
X          which  already  exist  on disk and which are newer than
X          the disk  copies.   By  default  unzip  queries  before
X          overwriting,  but the -o option may be used to suppress
X          the queries.  Note that under many  operating  systems,
X          the  TZ  (timezone)  environment  variable  must be set
X          correctly in order for  -f  and  -u  to  work  properly
X          (under Unix the variable is usually set automatically).
X          The reasons for this are somewhat subtle but have to do
X          with  the  differences  between  DOS-format  file times
X          (always local time) and Unix-format  times  (always  in
X          GMT)  and  the necessity to compare the two.  A typical
X          TZ value is ``PST8PDT'' (US Pacific time with automatic
X          adjustment   for  Daylight  Savings  Time  or  ``summer
X          time'').
X
X     -l   list  archive  files  (short   format).    The   names,
X          uncompressed  file  sizes  and  modification  dates and
X          times of the specified files are  printed,  along  with
X          totals  for all files specified.  In addition, the zip-
X          file comment and individual file comments (if any)  are
X          displayed.   If  a file was archived from a single-case
X          file system (for example, the old MS-DOS FAT file  sys-
X          tem)  and the -L option was given, the filename is con-
X          verted to lowercase and is prefixed with a caret (^).
X
X     -p   extract files to pipe (stdout).  Nothing but  the  file
X          data  is  sent  to  stdout,  and  the  files are always
X          extracted in binary format, just as they are stored (no
X          conversions).
X
X     -t   test archive files.  This option extracts  each  speci-
X          fied file in memory and compares the CRC (cyclic redun-
X          dancy check, an enhanced checksum) of the expanded file
X          with the original file's stored CRC value.
X
X     -u   update existing files and create new  ones  if  needed.
X          This  option  performs  the  same  function  as  the -f
X          option, extracting (with query) files which  are  newer
X          than  those with the same name on disk, and in addition
X          it extracts those files which do not already  exist  on
X          disk.   See  -f  above  for  information on setting the
X          timezone properly.
X
X     -v   be verbose or  print  diagnostic  version  info.   This
X          option  has  evolved  and now behaves as both an option
X          and a modifier.  As an  option  it  has  two  purposes:
X          when  a  zipfile is specified with no other options, -v
X          lists archive files verbosely, adding to  the  -l  info
X          the  compression  method,  compressed size, compression
X          ratio and 32-bit CRC.  When  no  zipfile  is  specified
X          (that is, the complete command is simply ``unzip -v''),
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 3
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X          a diagnostic screen is printed.   In  addition  to  the
X          normal  header  with  release  date  and version, unzip
X          lists the home Info-ZIP ftp site and where  to  find  a
X          list of other ftp and non-ftp sites; the target operat-
X          ing system for which it was compiled, as well as  (pos-
X          sibly)  the hardware on which it was compiled, the com-
X          piler and version used, and the compilation  date;  any
X          special  compilation  options  which  might  affect the
X          program's operation (see also  DECRYPTION  below);  and
X          any options stored in environment variables which might
X          do the same (see  ENVIRONMENT  OPTIONS  below).   As  a
X          modifier  it  works  in  conjunction with other options
X          (e.g., -t) to produce more verbose or debugging output;
X          this is not yet fully implemented but will be in future
X          releases.
X
X     -z   display only the archive comment.
X
XMODIFIERS
X     -a   convert text files.  Ordinarily all files are extracted
X          exactly  as they are stored (as ``binary'' files).  The
X          -a option causes files identified by zip as text  files
X          (those  with  the `t' label in zipinfo listings, rather
X          than `b') to be automatically extracted as  such,  con-
X          verting  line  endings,  end-of-file characters and the
X          character set itself as necessary.  (For example,  Unix
X          files  use  line  feeds (LFs) for end-of-line (EOL) and
X          have no end-of-file (EOF) marker; Macintoshes use  car-
X          riage  returns  (CRs)  for  EOLs; and most PC operating
X          systems use CR+LF for EOLs and control-Z for  EOF.   In
X          addition, IBM mainframes and the Michigan Terminal Sys-
X          tem use EBCDIC rather than the more common ASCII  char-
X          acter  set,  and  NT supports Unicode.) Note that zip's
X          identification of text files is by  no  means  perfect;
X          some  ``text''  files  may  actually be binary and vice
X          versa.    unzip   therefore   prints   ``[text]''    or
X          ``[binary]''  as  a  visual  check  for  each  file  it
X          extracts when using the  -a  option.   The  -aa  option
X          forces all files to be extracted as text, regardless of
X          the supposed file type.
X
X     -b   treat all files as binary (no text conversions).   This
X          is a shortcut for ---a.
X
X     -C   match filenames case-insensitively.  unzip's philosophy
X          is ``you get what you ask for'' (this is also responsi-
X          ble for the -L/-U  change;  see  the  relevant  options
X          below).   Because  some  filesystems  are  fully  case-
X          sensitive (notably those under the Unix operating  sys-
X          tem) and because both ZIP archives and unzip itself are
X          portable across platforms, unzip's default behavior  is
X          to  match  both  wildcard  and  literal filenames case-
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 4
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X          sensitively.  That is, specifying ``makefile''  on  the
X          command  line  will  only  match  ``makefile''  in  the
X          archive, not ``Makefile'' or  ``MAKEFILE''  (and  simi-
X          larly  for  wildcard  specifications).  Since this does
X          not  correspond  to  the   behavior   of   many   other
X          operating/file  systems  (for  example, OS/2 HPFS which
X          preserves mixed case but is not sensitive to  it),  the
X          -C  option may be used to force all filename matches to
X          be case-insensitive.  In the example above,  all  three
X          files  would  then match ``makefile'' (or ``make*'', or
X          similar).  The -C option affects files in both the nor-
X          mal file list and the excluded-file list (xlist).
X
X     -j   junk paths.  The archive's directory structure  is  not
X          recreated;  all  files  are deposited in the extraction
X          directory (by default, the current one).
X
X     -L   convert to lowercase any  filename  originating  on  an
X          uppercase-only  operating  system or filesystem.  (This
X          was unzip's default behavior in releases prior to 5.11;
X          the  new  default  behavior  is  identical  to  the old
X          behavior with the -U option, which is now obsolete  and
X          will be removed in a future release.)  Depending on the
X          archiver, files archived under single-case  filesystems
X          (VMS,  old  MS-DOS  FAT,  etc.)  may  be stored as all-
X          uppercase names; this can be ugly or inconvenient  when
X          extracting to a case-preserving filesystem such as OS/2
X          HPFS or a case-sensitive one such as  under  Unix.   By
X          default unzip lists and extracts such filenames exactly
X          as they're stored (excepting truncation, conversion  of
X          unsupported  characters,  etc.); this option causes the
X          names of all files from certain systems to be converted
X          to lowercase.
X
X     -n   never overwrite existing  files.   If  a  file  already
X          exists,  skip  the  extraction  of  that  file  without
X          prompting.  By default unzip queries before  extracting
X          any  file  which already exists; the user may choose to
X          overwrite only the current file, overwrite  all  files,
X          skip extraction of the current file, skip extraction of
X          all existing files, or rename the current file.
X
X     -o   overwrite existing files without prompting.  This is  a
X          dangerous  option,  so  use it with care.  (It is often
X          used with -f, however.)
X
X     -q   perform operations quietly (-qq = even quieter).  Ordi-
X          narily  unzip  prints  the  names  of  the  files  it's
X          extracting or testing, the extraction methods, any file
X          or zipfile comments which may be stored in the archive,
X          and possibly a summary when finished with each archive.
X          The  -q[q] options suppress the printing of some or all
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 5
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X          of these messages.
X
X     -s   [OS/2, NT,  MS-DOS]  convert  spaces  in  filenames  to
X          underscores.   Since  all  PC  operating  systems allow
X          spaces  in  filenames,  unzip   by   default   extracts
X          filenames  with  spaces intact (e.g., ``EA DATA. SF'').
X          This can be awkward, however, since MS-DOS in  particu-
X          lar  does  not  gracefully support spaces in filenames.
X          Conversion of spaces to underscores can  eliminate  the
X          awkwardness in some cases.
X
X     -U   (obsolete; to be removed in  a  future  release)  leave
X          filenames  uppercase if created under MS-DOS, VMS, etc.
X          See -L above.
X
X     -V   retain (VMS) file version numbers.  VMS  files  can  be
X          stored   with   a   version   number,   in  the  format
X          file.ext;##.  By default the  ``;##''  version  numbers
X          are  stripped,  but  this  option  allows  them  to  be
X          retained.  (On filesystems  which  limit  filenames  to
X          particularly  short lengths, the version numbers may be
X          truncated or stripped regardless of this option.)
X
X     -X   [VMS] restore owner/protection info (may require system
X          privileges).    Ordinary  file  attributes  are  always
X          restored, but this option allows UICs to be restored as
X          well.   [The  next  version  of unzip will support Unix
X          UID/GID info as well, and possibly NT permissions.]
X
X     -$   [MS-DOS, OS/2, NT, Amiga] restore the volume  label  if
X          the  extraction medium is removable (e.g., a diskette).
X          Doubling the option  (-$$)  allows  fixed  media  (hard
X          disks)  to  be  labelled  as  well.  By default, volume
X          labels are ignored.
X
XENVIRONMENT OPTIONS
X     unzip's default behavior may be modified via options  placed
X     in  an  environment  variable.   This  can  be done with any
X     option, but it is probably most useful with the -a, -L,  -C,
X     -q, -o, or -n modifiers:  make unzip auto-convert text files
X     by default, make it convert filenames from uppercase systems
X     to  lowercase,  make it match names case-insensitively, make
X     it quieter, or make it always overwrite or  never  overwrite
X     files  as  it extracts them.  For example, to make unzip act
X     as quietly as possible, only reporting errors, one would use
X     one of the following commands:
X
X         UNZIP=-qq; export UNZIP    Unix Bourne shell
X         setenv UNZIP -qq           Unix C shell
X         set UNZIP=-qq              OS/2 or MS-DOS
X         define UNZIP_OPTS "-qq"    VMS (quotes for lowercase)
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 6
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X     Environment options are, in effect, considered  to  be  just
X     like  any  other  command-line options, except that they are
X     effectively the first options on the command line.  To over-
X     ride  an  environment option, one may use the ``minus opera-
X     tor'' to remove it.  For instance, to override  one  of  the
X     quiet-flags in the example above, use the command
X
X         unzip --q[other options] zipfile
X
X     The first hyphen is the normal  switch  character,  and  the
X     second  is  a  minus sign, acting on the q option.  Thus the
X     effect here is to cancel one quantum of quietness.  To  can-
X     cel both quiet flags, two (or more) minuses may be used:
X
X         unzip -t--q zipfile
X         unzip ---qt zipfile
X
X     (the two are equivalent).  This may seem awkward or  confus-
X     ing,  but it is reasonably intuitive:  just ignore the first
X     hyphen and go from there.  It is also  consistent  with  the
X     behavior of Unix nice(1).
X
X     As suggested by the examples  above,  the  default  variable
X     names  are  UNZIP_OPTS  for  VMS  (where  the symbol used to
X     install unzip as a foreign command would otherwise  be  con-
X     fused  with  the  environment  variable),  and UNZIP for all
X     other operating systems.  For  compatibility  with  zip(1L),
X     UNZIPOPT  is  also  accepted (don't ask).  If both UNZIP and
X     UNZIPOPT  are  defined,  however,  UNZIP  takes  precedence.
X     unzip's  diagnostic  option (-v with no zipfile name) can be
X     used to check the values of  all  four  possible  unzip  and
X     zipinfo environment variables.
X
X     The timezone variable (TZ) should be set  according  to  the
X     local  timezone  in  order  for  the  -f  and  -u to operate
X     correctly.  See the description of  -f  above  for  details.
X     This  variable may also be necessary in order for timestamps
X     on extracted files to be set correctly.
X
XDECRYPTION
X     Encrypted archives are fully supported by Info-ZIP software,
X     but due to United States export restrictions, the encryption
X     and decryption sources are not  packaged  with  the  regular
X     unzip  and  zip distributions.  Since the crypt sources were
X     written by Europeans, however, they are freely available  at
X     sites  throughout  the  world; see the file ``Where'' in any
X     Info-ZIP source or binary distribution  for  locations  both
X     inside and outside the US.
X
X     Because of the separate distribution, not all compiled  ver-
X     sions  of  unzip support decryption.  To check a version for
X     crypt  support,  either  attempt  to  test  or  extract   an
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 7
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X     encrypted  archive,  or else check unzip's diagnostic screen
X     (see the -v option above) for ``[decryption]'' as one of the
X     special compilation options.
X
X     There are no runtime options for decryption;  if  a  zipfile
X     member  is  encrypted,  unzip  will  prompt for the password
X     without echoing what is typed.  unzip continues to  use  the
X     same  password  as  long  as it appears to be valid; it does
X     this by testing a 12-byte header.  The correct password will
X     always check out against the header, but there is a 1-in-256
X     chance that an incorrect password will as well.  (This is  a
X     security  feature  of  the  PKWARE  zipfile format; it helps
X     prevent brute-force attacks which  might  otherwise  gain  a
X     large  speed  advantage by testing only the header.)  In the
X     case that an incorrect password is given but it  passes  the
X     header  test  anyway,  either  an incorrect CRC will be gen-
X     erated for the extracted data or else unzip will fail during
X     the  extraction  because the ``decrypted'' bytes do not con-
X     stitute a valid compressed data stream.
X
X     If the first password fails the header check on  some  file,
X     unzip  will prompt for another password, and so on until all
X     files are extracted.  If a password is not known, entering a
X     null  password (that is, just a carriage return) is taken as
X     a signal to skip all further  prompting.   Only  unencrypted
X     files  in  the  archive(s)  will  thereafter  be  extracted.
X     (Actually that's not quite true; older versions  of  zip(1L)
X     and  zipcloak(1L)  allowed  null  passwords, so unzip checks
X     each encrypted file to see if the null password works.  This
X     may  result in ``false positives'' and extraction errors, as
X     noted above.)
X
X     Note that there is presently no  way  to  avoid  interactive
X     decryption.   This  is  another security feature:  plaintext
X     passwords given on the command line or stored in files  con-
X     stitute  a  risk because they may be seen by others.  Future
X     releases may (under protest, with great disapproval) support
X     such shenanigans.
X
XEXAMPLES
X     To  use  unzip  to  extract  all  members  of  the   archive
X     letters.zip  into  the  current directory and subdirectories
X     below it, creating any subdirectories as necessary:
X
X         unzip letters
X
X     To extract all  members  of  letters.zip  into  the  current
X     directory only:
X
X         unzip -j letters
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 8
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X     To test letters.zip, printing only a summary  message  indi-
X     cating whether the archive is OK or not:
X
X         unzip -tq letters
X
X     To test all zipfiles in the current directory, printing only
X     the summaries:
X
X         unzip -tq \*.zip
X
X     (The backslash before the asterisk is only required  if  the
X     shell  expands  wildcards,  as  in Unix; double quotes could
X     have  been  used  instead,  as  in   the   source   examples
X     below.)  To  extract  to  standard  output  all  members  of
X     letters.zip whose names end in .tex, auto-converting to  the
X     local  end-of-line  convention  and  piping  the output into
X     more(1):
X
X         unzip -ca letters \*.tex | more
X
X     To extract the binary file paper1.dvi to standard output and
X     pipe it to a printing program:
X
X         unzip -p articles paper1.dvi | dvips
X
X     To extract all FORTRAN and C source  files--*.f,  *.c,  *.h,
X     and Makefile--into the /tmp directory:
X
X         unzip source.zip "*.[fch]" Makefile -d /tmp
X
X     (the double quotes are necessary only in Unix  and  only  if
X     globbing is turned on).  To extract all FORTRAN and C source
X     files, regardless of case (e.g., both *.c and *.C,  and  any
X     makefile, Makefile, MAKEFILE or similar):
X
X         unzip -C source.zip "*.[fch]" makefile -d /tmp
X
X     To extract any such files but convert any  uppercase  MS-DOS
X     or  VMS  names  to lowercase and convert the line-endings of
X     all of the files to the local standard (without  respect  to
X     any files which might be marked ``binary''):
X
X         unzip -aaCL source.zip "*.[fch]" makefile -d /tmp
X
X     To extract only newer versions of the files already  in  the
X     current  directory,  without  querying (NOTE:  be careful of
X     unzipping in one timezone a zipfile created in  another--ZIP
X     archives  to  date  contain  no  timezone information, and a
X     ``newer'' file from an eastern timezone  may,  in  fact,  be
X     older):
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                 9
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X         unzip -fo sources
X
X     To extract newer  versions  of  the  files  already  in  the
X     current  directory and to create any files not already there
X     (same caveat as previous example):
X
X         unzip -uo sources
X
X     To display a  diagnostic  screen  showing  which  unzip  and
X     zipinfo options are stored in environment variables, whether
X     decryption support was compiled in, the compiler with  which
X     unzip was compiled, etc.:
X
X         unzip -v
X
X     In the last five examples, assume that UNZIP  or  UNZIP_OPTS
X     is set to -q.  To do a singly quiet listing:
X
X         unzip -l file.zip
X
X     To do a doubly quiet listing:
X
X         unzip -ql file.zip
X
X     (Note that the ``.zip'' is generally not necessary.)  To  do
X     a standard listing:
X
X         unzip --ql file.zip
X     or
X         unzip -l-q file.zip
X     or
X         unzip -l--q file.zip       (extra minuses don't hurt)
X
XTIPS
X     The current maintainer, being a lazy  sort,  finds  it  very
X     useful  to  define  a pair of aliases:  tt for ``unzip -tq''
X     and ii for ``unzip -Z'' (or ``zipinfo'').  One may then sim-
X     ply  type ``tt zipfile'' to test an archive, something which
X     is worth making a habit of  doing.   With  luck  unzip  will
X     report  ``No  errors  detected in zipfile.zip,'' after which
X     one may breathe a sigh of relief.
X
X     The maintainer  also  finds  it  useful  to  set  the  UNZIP
X     environment variable to ``-aL'' and is tempted to add ``-C''
X     as well.  His ZIPINFO variable is set to ``-z''.
X
XDIAGNOSTICS
X     The exit status (or error level) approximates the exit codes
X     defined  by PKWARE and takes on the following values, except
X     under VMS:
X
X          0    normal; no errors or warnings detected.
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                10
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X          1    one or more warning errors were  encountered,  but
X               processing  completed  successfully  anyway.  This
X               includes zipfiles where  one  or  more  files  was
X               skipped  due  to unsupported compression method or
X               encryption with an unknown password.
X
X          2    a  generic  error  in  the  zipfile   format   was
X               detected.   Processing may have completed success-
X               fully anyway;  some  broken  zipfiles  created  by
X               other archivers have simple work-arounds.
X
X          3    a severe error in the zipfile format was detected.
X               Processing probably failed immediately.
X
X          4-8  unzip was unable to allocate  memory  for  one  or
X               more buffers.
X
X          9    the specified zipfiles were not found.
X
X          10   invalid options  were  specified  on  the  command
X               line.
X
X          11   no matching files were found.
X
X          50   the disk is (or was) full during extraction.
X
X          51   the end of the ZIP archive was encountered  prema-
X               turely.
X
X     VMS interprets standard Unix (or PC) return values as other,
X     scarier-looking things, so by default unzip always returns 0
X     (which reportedly gets converted into a VMS  status  of  1--
X     i.e., success).  There are two compilation options available
X     to  modify  or  expand   upon   this   behavior:    defining
X     RETURN_CODES results in a human-readable explanation of what
X     the real error status was (but still  with  a  faked  ``suc-
X     cess''  exit  value),  while defining RETURN_SEVERITY causes
X     unzip to exit  with  a  ``real''  VMS  status.   The  latter
X     behavior  will  become the default in future versions unless
X     it is found to conflict with officially defined  VMS  codes.
X     The  current mapping is as follows:   1 (success) for normal
X     exit, 0x7fff0001  for  warning  errors,  and  (0x7fff000?  +
X     16*normal_unzip_exit_status) for all other errors, where the
X     `?' is 2 (error) for unzip values 2 and 9-11, and  4  (fatal
X     error)  for  the  remaining  ones  (3-8, 50, 51).  Check the
X     ``unzip -v''  output  to  see  whether  RETURN_SEVERITY  was
X     defined at compilation time.
X
XBUGS
X     When attempting to extract a corrupted archive, unzip may go
X     into  an  infinite  loop and, if not stopped quickly enough,
X     fill all available disk  space.   Compiling  with  CHECK_EOF
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                11
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X     should fix this problem for all zipfiles, but the option was
X     introduced too late in the testing process to  be  made  the
X     default  behavior.  Future versions will be robust enough to
X     fail gracefully on damaged archives.  Check the ``unzip -v''
X     output  to see whether CHECK_EOF was defined during compila-
X     tion.
X
X     [MS-DOS] When extracting or testing files from an archive on
X     a  defective  floppy  diskette,  if  the  ``Fail'' option is
X     chosen from DOS's ``Abort, Retry, Fail?'' message, unzip may
X     hang   the  system,  requiring  a  reboot.   Instead,  press
X     control-C (or control-Break) to terminate unzip.
X
X     Under DEC Ultrix, unzip will sometimes fail on long zipfiles
X     (bad  CRC, not always reproducible).  This is apparently due
X     either to a hardware bug (cache memory) or an operating sys-
X     tem bug (improper handling of page faults?).
X
X     Dates and times of stored directories are not restored.
X
X     [OS/2] Extended  attributes  for  existing  directories  are
X     never  updated.   This is a limitation of the operating sys-
X     tem; unzip has no way to determine whether the stored attri-
X     butes are newer or older than the existing ones.
X
X     [VMS] When extracting to another directory, only the  [.foo]
X     syntax  is  accepted  for the -d option; the simple Unix foo
X     syntax is silently  ignored  (as  is  the  less  common  VMS
X     foo.dir syntax).
X
X     [VMS] When the file being extracted already exists,  unzip's
X     query  only  allows skipping, overwriting or renaming; there
X     should additionally be a choice for creating a  new  version
X     of  the file.  In fact, the ``overwrite'' choice does create
X     a new  version;  the  old  version  is  not  overwritten  or
X     deleted.
X
XSEE ALSO
X     funzip(1L), zip(1L), zipcloak(1L), zipgrep(1L), zipinfo(1L),
X     zipnote(1L), zipsplit(1L)
X
XAUTHORS
X     The primary Info-ZIP authors  (current  zip-bugs  workgroup)
X     are:   Jean-loup Gailly (Zip); Greg R. Roelofs (UnZip); Mark
X     Adler (decompression, fUnZip); Kai Uwe Rommel  (OS/2);  Igor
X     Mandrichenko  and  Hunter  Goatley (VMS); John Bush and Paul
X     Kienitz (Amiga); Antoine Verheijen (Macintosh);  Chris  Her-
X     borth  (Atari); Henry Gessau (NT); Karl Davis, Sergio Monesi
X     and Evan Shattock (Acorn Archimedes); and Robert Heath (Win-
X     dows).   The  author  of  the original unzip code upon which
X     Info-ZIP's is based was Samuel H. Smith;  Carl  Mascott  did
X     the  first  Unix port; and David P. Kirschbaum organized and
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                12
X
XUNZIP(1L)         MISC. REFERENCE MANUAL PAGES          UNZIP(1L)
X
X     led Info-ZIP in its early days.  The full list of  contribu-
X     tors  to  UnZip  has  grown quite large; please refer to the
X     CONTRIBS file in the UnZip source distribution for  a  rela-
X     tively complete version.
X
XVERSIONS
X     v1.2   15 Mar 89   Samuel H. Smith
X     v2.0    9 Sep 89   Samuel H. Smith
X     v2.x   fall 1989   many Usenet contributors
X     v3.0    1 May 90   Info-ZIP (DPK, consolidator)
X     v3.1   15 Aug 90   Info-ZIP (DPK, consolidator)
X     v4.0    1 Dec 90   Info-ZIP (GRR, maintainer)
X     v4.1   12 May 91   Info-ZIP
X     v4.2   20 Mar 92   Info-ZIP (zip-bugs subgroup, GRR)
X     v5.0   21 Aug 92   Info-ZIP (zip-bugs subgroup, GRR)
X     v5.01  15 Jan 93   Info-ZIP (zip-bugs subgroup, GRR)
X     v5.1    7 Feb 94   Info-ZIP (zip-bugs subgroup, GRR)
X     v5.11   2 Aug 94   Info-ZIP (zip-bugs subgroup, GRR)
X     v5.12  28 Aug 94   Info-ZIP (zip-bugs subgroup, GRR)
X
XInfo-ZIP         Last change: 28 Aug 94 (v5.12)                13
X
END_OF_FILE
  if test 33336 -ne `wc -c <'unzip-5.12/unzip.doc'`; then
    echo shar: \"'unzip-5.12/unzip.doc'\" unpacked with wrong size!
  fi
  # end of 'unzip-5.12/unzip.doc'
fi
echo shar: End of archive 11 \(of 20\).
cp /dev/null ark11isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 20 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still must unpack the following archives:
    echo "        " ${MISSING}
fi
exit 0
exit 0 # Just in case...