rem: if (!linktarget || fread(linktarget, 1, ucsize, G.outfile) != (int)ucsize) {
add: if (!linktarget || fread(linktarget, 1, ucsize, G.outfile) != (size_t)ucsize) {
context: static uch *scanBeOSexfield  OF((const uch *ef_ptr, unsigned ef_len));static int  set_file_attrs( const char *, const unsigned char *, const off_t );static void setBeOSexfield   OF((const char *path, uch *extra_field));#ifdef BEOS_USE_PRINTEXFIELDstatic void printBeOSexfield OF((int isdir, uch *extra_field));#endif#ifdef BEOS_ASSIGN_FILETYPEstatic void assign_MIME( const char * );#endif#ifdef ACORN_FTYPE_NFS/* Acorn bits for NFS filetyping */typedef struct {  uch ID[2];  uch size[2];  uch ID_2[4];  uch loadaddr[4];  uch execaddr[4];  uch attr[4];} RO_extra_block;#endif /* ACORN_FTYPE_NFS */static int created_dir;        /* used in mapname(), checkdir() */static int renamed_fullpath;   /* ditto */#ifndef SFX/**********************//* Function do_wild() */   /* for porting:  dir separator; match(ignore_case) *//**********************/char *do_wild(__G__ wildspec)    __GDEF    ZCONST char *wildspec;  /* only used first time on a given dir */{    static DIR *wild_dir = (DIR *)NULL;    static ZCONST char *wildname;    static char *dirname, matchname[FILNAMSIZ];    static int notfirstcall=FALSE, have_dirname, dirnamelen;    struct dirent *file;    /* Even when we're just returning wildspec, we *always* do so in     * matchname[]--calling routine is allowed to append four characters     * to the returned string, and wildspec may be a pointer to argv[].     */    if (!notfirstcall) {    /* first call:  must initialize everything */        notfirstcall = TRUE;        if (!iswild(wildspec)) {            strcpy(matchname, wildspec);            have_dirname = FALSE;            wild_dir = NULL;            return matchname;        }        /* break the wildspec into a directory part and a wildcard filename */        if ((wildname = strrchr(wildspec, '/')) == (ZCONST char *)NULL) {            dirname = ".";            dirnamelen = 1;            have_dirname = FALSE;            wildname = wildspec;        } else {            ++wildname;     /* point at character after '/' */            dirnamelen = wildname - wildspec;            if ((dirname = (char *)malloc(dirnamelen+1)) == (char *)NULL) {                Info(slide, 0x201, ((char *)slide,                  "warning:  cannot allocate wildcard buffers\n"));                strcpy(matchname, wildspec);                return matchname;   /* but maybe filespec was not a wildcard */            }            strncpy(dirname, wildspec, dirnamelen);            dirname[dirnamelen] = '\0';   /* terminate for strcpy below */            have_dirname = TRUE;        }        if ((wild_dir = opendir(dirname)) != (DIR *)NULL) {            while ((file = readdir(wild_dir)) != (struct dirent *)NULL) {                if (file->d_name[0] == '.' && wildname[0] != '.')                    continue;  /* Unix:  '*' and '?' do not match leading dot */                if (match(file->d_name, wildname, 0)) {  /* 0 == case sens. */                    if (have_dirname) {                        strcpy(matchname, dirname);                        strcpy(matchname+dirnamelen, file->d_name);                    } else                        strcpy(matchname, file->d_name);                    return matchname;                }            }            /* if we get to here directory is exhausted, so close it */            closedir(wild_dir);            wild_dir = (DIR *)NULL;        }        /* return the raw wildspec in case that works (e.g., directory not         * searchable, but filespec was not wild and file is readable) */        strcpy(matchname, wildspec);        return matchname;    }    /* last time through, might have failed opendir but returned raw wildspec */    if (wild_dir == (DIR *)NULL) {        notfirstcall = FALSE; /* nothing left to try--reset for new wildspec */        if (have_dirname)            free(dirname);        return (char *)NULL;    }    /* If we've gotten this far, we've read and matched at least one entry     * successfully (in a previous call), so dirname has been copied into     * matchname already.     */    while ((file = readdir(wild_dir)) != (struct dirent *)NULL) {        if (file->d_name[0] == '.' && wildname[0] != '.')            continue;   /* Unix:  '*' and '?' do not match leading dot */        if (match(file->d_name, wildname, 0)) {   /* 0 == don't ignore case */            if (have_dirname) {                /* strcpy(matchname, dirname); */                strcpy(matchname+dirnamelen, file->d_name);            } else                strcpy(matchname, file->d_name);            return matchname;        }    }    closedir(wild_dir);     /* have read at least one entry; nothing left */    wild_dir = (DIR *)NULL;    notfirstcall = FALSE;   /* reset for new wildspec */    if (have_dirname)        free(dirname);    return (char *)NULL;} /* end function do_wild() */#endif /* !SFX *//**********************//* Function mapattr() *//**********************/int mapattr(__G)    __GDEF{    ulg tmp = G.crec.external_file_attributes;    switch (G.pInfo->hostnum) {        case AMIGA_:            tmp = (unsigned)(tmp>>17 & 7);   /* Amiga RWE bits */            G.pInfo->file_attr = (unsigned)(tmp<<6 | tmp<<3 | tmp);            break;        case THEOS_:            tmp &= 0xF1FFFFFFL;            if ((tmp & 0xF0000000L) != 0x40000000L)                tmp &= 0x01FFFFFFL;     /* not a dir, mask all ftype bits */            else                tmp &= 0x41FFFFFFL;     /* leave directory bit as set */            /* fall through! */        case BEOS_:        case UNIX_:        case VMS_:        case ACORN_:        case ATARI_:        case QDOS_:        case TANDEM_:            G.pInfo->file_attr = (unsigned)(tmp >> 16);            if (G.pInfo->file_attr != 0 || !G.extra_field) {                return 0;            } else {                /* Some (non-Info-ZIP) implementations of Zip for Unix and                   VMS (and probably others ??) leave 0 in the upper 16-bit                   part of the external_file_attributes field. Instead, they                   store file permission attributes in some extra field.                   As a work-around, we search for the presence of one of                   these extra fields and fall back to the MSDOS compatible                   part of external_file_attributes if one of the known                   e.f. types has been detected.                   Later, we might implement extraction of the permission                   bits from the VMS extra field. But for now, the work-around                   should be sufficient to provide "readable" extracted files.                   (For ASI Unix e.f., an experimental remap of the e.f.                   mode value IS already provided!)                 */                ush ebID;                unsigned ebLen;                uch *ef = G.extra_field;                unsigned ef_len = G.crec.extra_field_length;                int r = FALSE;                while (!r && ef_len >= EB_HEADSIZE) {                    ebID = makeword(ef);                    ebLen = (unsigned)makeword(ef+EB_LEN);                    if (ebLen > (ef_len - EB_HEADSIZE))                        /* discoverd some e.f. inconsistency! */                        break;                    switch (ebID) {                      case EF_ASIUNIX:                        if (ebLen >= (EB_ASI_MODE+2)) {                            G.pInfo->file_attr =                              (unsigned)makeword(ef+(EB_HEADSIZE+EB_ASI_MODE));                            /* force stop of loop: */                            ef_len = (ebLen + EB_HEADSIZE);                            break;                        }                        /* else: fall through! */                      case EF_PKVMS:                        /* "found nondecypherable e.f. with perm. attr" */                        r = TRUE;                      default:                        break;                    }                    ef_len -= (ebLen + EB_HEADSIZE);                    ef += (ebLen + EB_HEADSIZE);                }                if (!r)                    return 0;            }            /* fall through! */        /* all remaining cases:  expand MSDOS read-only bit into write perms */        case FS_FAT_:            /* PKWARE's PKZip for Unix marks entries as FS_FAT_, but stores the             * Unix attributes in the upper 16 bits of the external attributes             * field, just like Info-ZIP's Zip for Unix.  We try to use that             * value, after a check for consistency with the MSDOS attribute             * bits (see below).             */            G.pInfo->file_attr = (unsigned)(tmp >> 16);            /* fall through! */        case FS_HPFS_:        case FS_NTFS_:        case MAC_:        case TOPS20_:        default:            /* Ensure that DOS subdir bit is set when the entry's name ends             * in a '/'.  Some third-party Zip programs fail to set the subdir             * bit for directory entries.             */            if ((tmp & 0x10) == 0) {                extent fnlen = strlen(G.filename);                if (fnlen > 0 && G.filename[fnlen-1] == '/')                    tmp |= 0x10;            }            /* read-only bit --> write perms; subdir bit --> dir exec bit */            tmp = !(tmp & 1) << 1  |  (tmp & 0x10) >> 4;            if ((G.pInfo->file_attr & 0700) == (unsigned)(0400 | tmp<<6))                /* keep previous G.pInfo->file_attr setting, when its "owner"                 * part appears to be consistent with DOS attribute flags!                 */                return 0;            G.pInfo->file_attr = (unsigned)(0444 | tmp<<6 | tmp<<3 | tmp);            break;    } /* end switch (host-OS-created-by) */    /* for originating systems with no concept of "group," "other," "system": */    umask( (int)(tmp=umask(0)) );    /* apply mask to expanded r/w(/x) perms */    G.pInfo->file_attr &= ~tmp;    return 0;} /* end function mapattr() *//************************//*  Function mapname()  *//************************/int mapname(__G__ renamed)    __GDEF    int renamed;/* * returns: *  MPN_OK          - no problem detected *  MPN_INF_TRUNC   - caution (truncated filename) *  MPN_INF_SKIP    - info "skip entry" (dir doesn't exist) *  MPN_ERR_SKIP    - error -> skip entry *  MPN_ERR_TOOLONG - error -> path is too long *  MPN_NOMEM       - error (memory allocation failed) -> skip entry *  [also MPN_VOL_LABEL, MPN_CREATED_DIR] */{    char pathcomp[FILNAMSIZ];      /* path-component buffer */    char *pp, *cp=(char *)NULL;    /* character pointers */    char *lastsemi=(char *)NULL;   /* pointer to last semi-colon in pathcomp */#ifdef ACORN_FTYPE_NFS    char *lastcomma=(char *)NULL;  /* pointer to last comma in pathcomp */    RO_extra_block *ef_spark;      /* pointer Acorn FTYPE ef block */#endif    int quote = FALSE;             /* flags */    int killed_ddot = FALSE;       /* is set when skipping "../" pathcomp */    int error = MPN_OK;    register unsigned workch;      /* hold the character being tested *//*---------------------------------------------------------------------------    Initialize various pointers and counters and stuff.  ---------------------------------------------------------------------------*/    if (G.pInfo->vollabel)        return MPN_VOL_LABEL;   /* can't set disk volume labels in BeOS */    /* can create path as long as not just freshening, or if user told us */    G.create_dirs = (!uO.fflag || renamed);    created_dir = FALSE;        /* not yet */    /* user gave full pathname:  don't prepend rootpath */    renamed_fullpath = (renamed && (*G.filename == '/'));    if (checkdir(__G__ (char *)NULL, INIT) == MPN_NOMEM)        return MPN_NOMEM;       /* initialize path buffer, unless no memory */    *pathcomp = '\0';           /* initialize translation buffer */    pp = pathcomp;              /* point to translation buffer */    if (uO.jflag)               /* junking directories */        cp = (char *)strrchr(G.filename, '/');    if (cp == (char *)NULL)     /* no '/' or not junking dirs */        cp = G.filename;        /* point to internal zipfile-member pathname */    else        ++cp;                   /* point to start of last component of path *//*---------------------------------------------------------------------------    Begin main loop through characters in filename.  ---------------------------------------------------------------------------*/    while ((workch = (uch)*cp++) != 0) {        if (quote) {                 /* if character quoted, */            *pp++ = (char)workch;    /*  include it literally */            quote = FALSE;        } else            switch (workch) {            case '/':             /* can assume -j flag not given */                *pp = '\0';                if (((error = checkdir(__G__ pathcomp, APPEND_DIR)) & MPN_MASK)                     > MPN_INF_TRUNC)                    return error;                pp = pathcomp;    /* reset conversion buffer for next piece */                lastsemi = (char *)NULL; /* leave directory semi-colons alone */                break;            case '.':                if (pp == pathcomp) {   /* nothing appended yet... */                    if (*cp == '/') {   /* don't bother appending "./" to */                        ++cp;           /*  the path: skip behind the '/' */                        break;                    } else if (!uO.ddotflag && *cp == '.' && cp[1] == '/') {                        /* "../" dir traversal detected */                        cp += 2;        /*  skip over behind the '/' */                        killed_ddot = TRUE; /*  set "show message" flag */                        break;                    }                }                *pp++ = '.';                break;            case ';':             /* VMS version (or DEC-20 attrib?) */                lastsemi = pp;                *pp++ = ';';      /* keep for now; remove VMS ";##" */                break;            /*  later, if requested */#ifdef ACORN_FTYPE_NFS            case ',':             /* NFS filetype extension */                lastcomma = pp;                *pp++ = ',';      /* keep for now; may need to remove */                break;            /*  later, if requested */#endif            case '\026':          /* control-V quote for special chars */                quote = TRUE;     /* set flag for next character */                break;            default:                /* allow European characters in filenames: */                if (isprint(workch) || (128 <= workch && workch <= 254))                    *pp++ = (char)workch;            } /* end switch */    } /* end while loop */    /* Show warning when stripping insecure "parent dir" path components */    if (killed_ddot && QCOND2) {        Info(slide, 0, ((char *)slide,          "warning:  skipped \"../\" path component(s) in %s\n",          FnFilter1(G.filename)));        if (!(error & ~MPN_MASK))            error = (error & MPN_MASK) | PK_WARN;    }/*---------------------------------------------------------------------------    Report if directory was created (and no file to create:  filename ended    in '/'), check name to be sure it exists, and combine path and name be-    fore exiting.  ---------------------------------------------------------------------------*/    if (G.filename[strlen(G.filename) - 1] == '/') {        checkdir(__G__ G.filename, GETPATH);        if (created_dir) {            if (QCOND2) {                Info(slide, 0, ((char *)slide, "   creating: %s\n",                  FnFilter1(G.filename)));            }            if (!uO.J_flag) {   /* Handle the BeOS extra field if present. */                void *ptr = scanBeOSexfield( G.extra_field,                                             G.lrec.extra_field_length );                if (ptr) {                    setBeOSexfield( G.filename, ptr );                }            }#ifndef NO_CHMOD            /* set approx. dir perms (make sure can still read/write in dir) */            if (chmod(G.filename, (0xffff & G.pInfo->file_attr) | 0700))                perror("chmod (directory attributes) error");#endif            /* set dir time (note trailing '/') */            return (error & ~MPN_MASK) | MPN_CREATED_DIR;        }        /* TODO: should we re-write the BeOS extra field data in case it's */        /* changed?  The answer is yes. [Sept 1999 - cjh]                  */        if (!uO.J_flag) {   /* Handle the BeOS extra field if present. */            void *ptr = scanBeOSexfield( G.extra_field,                                         G.lrec.extra_field_length );            if (ptr) {                setBeOSexfield( G.filename, ptr );            }        }        /* dir existed already; don't look for data to extract */        return (error & ~MPN_MASK) | MPN_INF_SKIP;    }    *pp = '\0';                   /* done with pathcomp:  terminate it */    /* if not saving them, remove VMS version numbers (appended ";###") */    if (!uO.V_flag && lastsemi) {        pp = lastsemi + 1;        while (isdigit((uch)(*pp)))            ++pp;        if (*pp == '\0')          /* only digits between ';' and end:  nuke */            *lastsemi = '\0';    }#ifdef ACORN_FTYPE_NFS    /* translate Acorn filetype information if asked to do so */    if (uO.acorn_nfs_ext &&        (ef_spark = (RO_extra_block *)                    getRISCOSexfield(G.extra_field, G.lrec.extra_field_length))        != (RO_extra_block *)NULL)    {        /* file *must* have a RISC OS extra field */        long ft = (long)makelong((ef_spark->loadaddr);        /*32-bit*/        if (lastcomma) {            pp = lastcomma + 1;            while (isxdigit((uch)(*pp))) ++pp;            if (pp == lastcomma+4 && *pp == '\0') *lastcomma='\0'; /* nuke */        }        if ((ft & 1<<31)==0) ft=0x000FFD00;        sprintf(pathcomp+strlen(pathcomp), ",%03x", (int)(ft>>8) & 0xFFF);    }#endif /* ACORN_FTYPE_NFS */    if (*pathcomp == '\0') {        Info(slide, 1, ((char *)slide, "mapname:  conversion of %s failed\n",          FnFilter1(G.filename)));        return (error & ~MPN_MASK) | MPN_ERR_SKIP;    }    checkdir(__G__ pathcomp, APPEND_NAME);  /* returns 1 if truncated: care? */    checkdir(__G__ G.filename, GETPATH);    return error;} /* end function mapname() *//***********************//* Function checkdir() *//***********************/int checkdir(__G__ pathcomp, flag)    __GDEF    char *pathcomp;    int flag;/* * returns: *  MPN_OK          - no problem detected *  MPN_INF_TRUNC   - (on APPEND_NAME) truncated filename *  MPN_INF_SKIP    - path doesn't exist, not allowed to create *  MPN_ERR_SKIP    - path doesn't exist, tried to create and failed; or path *                    exists and is not a directory, but is supposed to be *  MPN_ERR_TOOLONG - path is too long *  MPN_NOMEM       - can't allocate memory for filename buffers */{    static int rootlen = 0;   /* length of rootpath */    static char *rootpath;    /* user's "extract-to" directory */    static char *buildpath;   /* full path (so far) to extracted file */    static char *end;         /* pointer to end of buildpath ('\0') */#   define FN_MASK   7#   define FUNCTION  (flag & FN_MASK)/*---------------------------------------------------------------------------    APPEND_DIR:  append the path component to the path being built and check    for its existence.  If doesn't exist and we are creating directories, do    so for this one; else signal success or error as appropriate.  ---------------------------------------------------------------------------*/    if (FUNCTION == APPEND_DIR) {        int too_long = FALSE;#ifdef SHORT_NAMES        char *old_end = end;#endif        Trace((stderr, "appending dir segment [%s]\n", FnFilter1(pathcomp)));        while ((*end = *pathcomp++) != '\0')            ++end;#ifdef SHORT_NAMES   /* path components restricted to 14 chars, typically */        if ((end-old_end) > FILENAME_MAX)  /* GRR:  proper constant? */            *(end = old_end + FILENAME_MAX) = '\0';#endif        /* GRR:  could do better check, see if overrunning buffer as we go:         * check end-buildpath after each append, set warning variable if         * within 20 of FILNAMSIZ; then if var set, do careful check when         * appending.  Clear variable when begin new path. */        if ((end-buildpath) > FILNAMSIZ-3)  /* need '/', one-char name, '\0' */            too_long = TRUE;                /* check if extracting directory? */        if (stat(buildpath, &G.statbuf)) {  /* path doesn't exist */            if (!G.create_dirs) { /* told not to create (freshening) */                free(buildpath);                return MPN_INF_SKIP;    /* path doesn't exist: nothing to do */            }            if (too_long) {                Info(slide, 1, ((char *)slide,                  "checkdir error:  path too long: %s\n",                  FnFilter1(buildpath)));                free(buildpath);                /* no room for filenames:  fatal */                return MPN_ERR_TOOLONG;            }            if (mkdir(buildpath, 0777) == -1) {   /* create the directory */                Info(slide, 1, ((char *)slide,                  "checkdir error:  cannot create %s\n\                 unable to process %s.\n",                  FnFilter2(buildpath), FnFilter1(G.filename)));                free(buildpath);                /* path didn't exist, tried to create, failed */                return MPN_ERR_SKIP;            }            created_dir = TRUE;        } else if (!S_ISDIR(G.statbuf.st_mode)) {            Info(slide, 1, ((char *)slide,              "checkdir error:  %s exists but is not directory\n\                 unable to process %s.\n",              FnFilter2(buildpath), FnFilter1(G.filename)));            free(buildpath);            /* path existed but wasn't dir */            return MPN_ERR_SKIP;        }        if (too_long) {            Info(slide, 1, ((char *)slide,              "checkdir error:  path too long: %s\n", FnFilter1(buildpath)));            free(buildpath);            /* no room for filenames:  fatal */            return MPN_ERR_TOOLONG;        }        *end++ = '/';        *end = '\0';        Trace((stderr, "buildpath now = [%s]\n", FnFilter1(buildpath)));        return MPN_OK;    } /* end if (FUNCTION == APPEND_DIR) *//*---------------------------------------------------------------------------    GETPATH:  copy full path to the string pointed at by pathcomp, and free    buildpath.  ---------------------------------------------------------------------------*/    if (FUNCTION == GETPATH) {        strcpy(pathcomp, buildpath);        Trace((stderr, "getting and freeing path [%s]\n",          FnFilter1(pathcomp)));        free(buildpath);        buildpath = end = (char *)NULL;        return MPN_OK;    }/*---------------------------------------------------------------------------    APPEND_NAME:  assume the path component is the filename; append it and    return without checking for existence.  ---------------------------------------------------------------------------*/    if (FUNCTION == APPEND_NAME) {#ifdef SHORT_NAMES        char *old_end = end;#endif        Trace((stderr, "appending filename [%s]\n", FnFilter1(pathcomp)));        while ((*end = *pathcomp++) != '\0') {            ++end;#ifdef SHORT_NAMES  /* truncate name at 14 characters, typically */            if ((end-old_end) > FILENAME_MAX)      /* GRR:  proper constant? */                *(end = old_end + FILENAME_MAX) = '\0';#endif            if ((end-buildpath) >= FILNAMSIZ) {                *--end = '\0';                Info(slide, 0x201, ((char *)slide,                  "checkdir warning:  path too long; truncating\n\                   %s\n                -> %s\n",                  FnFilter1(G.filename), FnFilter2(buildpath)));                return MPN_INF_TRUNC;   /* filename truncated */            }        }        Trace((stderr, "buildpath now = [%s]\n", FnFilter1(buildpath)));        /* could check for existence here, prompt for new name... */        return MPN_OK;    }/*---------------------------------------------------------------------------    INIT:  allocate and initialize buffer space for the file currently being    extracted.  If file was renamed with an absolute path, don't prepend the    extract-to path.  ---------------------------------------------------------------------------*//* GRR:  for VMS and TOPS-20, add up to 13 to strlen */    if (FUNCTION == INIT) {        Trace((stderr, "initializing buildpath to "));#ifdef ACORN_FTYPE_NFS        if ((buildpath = (char *)malloc(strlen(G.filename)+rootlen+                                        (uO.acorn_nfs_ext ? 5 : 1)))#else        if ((buildpath = (char *)malloc(strlen(G.filename)+rootlen+1))#endif            == (char *)NULL)            return MPN_NOMEM;        if ((rootlen > 0) && !renamed_fullpath) {            strcpy(buildpath, rootpath);            end = buildpath + rootlen;        } else {            *buildpath = '\0';            end = buildpath;        }        Trace((stderr, "[%s]\n", FnFilter1(buildpath)));        return MPN_OK;    }/*---------------------------------------------------------------------------    ROOT:  if appropriate, store the path in rootpath and create it if    necessary; else assume it's a zipfile member and return.  This path    segment gets used in extracting all members from every zipfile specified    on the command line.  ---------------------------------------------------------------------------*/#if (!defined(SFX) || defined(SFX_EXDIR))    if (FUNCTION == ROOT) {        Trace((stderr, "initializing root path to [%s]\n",          FnFilter1(pathcomp)));        if (pathcomp == (char *)NULL) {            rootlen = 0;            return MPN_OK;        }        if (rootlen > 0)        /* rootpath was already set, nothing to do */            return MPN_OK;        if ((rootlen = strlen(pathcomp)) > 0) {            char *tmproot;            if ((tmproot = (char *)malloc(rootlen+2)) == (char *)NULL) {                rootlen = 0;                return MPN_NOMEM;            }            strcpy(tmproot, pathcomp);            if (tmproot[rootlen-1] == '/') {                tmproot[--rootlen] = '\0';            }            if (rootlen > 0 && (stat(tmproot, &G.statbuf) ||                                !S_ISDIR(G.statbuf.st_mode)))            {   /* path does not exist */                if (!G.create_dirs /* || iswild(tmproot) */ ) {                    free(tmproot);                    rootlen = 0;                    /* skip (or treat as stored file) */                    return MPN_INF_SKIP;                }                /* create the directory (could add loop here scanning tmproot                 * to create more than one level, but why really necessary?) */                if (mkdir(tmproot, 0777) == -1) {                    Info(slide, 1, ((char *)slide,                      "checkdir:  cannot create extraction directory: %s\n",                      FnFilter1(tmproot)));                    free(tmproot);                    rootlen = 0;                    /* path didn't exist, tried to create, and failed: */                    /* file exists, or 2+ subdir levels required */                    return MPN_ERR_SKIP;                }            }            tmproot[rootlen++] = '/';            tmproot[rootlen] = '\0';            if ((rootpath = (char *)realloc(tmproot, rootlen+1)) == NULL) {                free(tmproot);                rootlen = 0;                return MPN_NOMEM;            }            Trace((stderr, "rootpath now = [%s]\n", FnFilter1(rootpath)));        }        return MPN_OK;    }#endif /* !SFX || SFX_EXDIR *//*---------------------------------------------------------------------------    END:  free rootpath, immediately prior to program exit.  ---------------------------------------------------------------------------*/    if (FUNCTION == END) {        Trace((stderr, "freeing rootpath\n"));        if (rootlen > 0) {            free(rootpath);            rootlen = 0;        }        return MPN_OK;    }    return MPN_INVALID; /* should never reach */} /* end function checkdir() *//****************************//* Function close_outfile() *//****************************/void close_outfile(__G)    /* GRR: change to return PK-style warning level */    __GDEF{    iztimes zt;    ush z_uidgid[2];    unsigned eb_izux_flg;/*---------------------------------------------------------------------------    If symbolic links are supported, allocate a storage area, put the uncom-    pressed "data" in it, and create the link.  Since we know it's a symbolic    link to start with, we shouldn't have to worry about overflowing unsigned    ints with unsigned longs.  ---------------------------------------------------------------------------*/#ifdef SYMLINKS    if (G.symlnk) {        unsigned ucsize = (unsigned)G.lrec.ucsize;        char *linktarget = (char *)malloc((unsigned)G.lrec.ucsize+1);        fclose(G.outfile);                      /* close "data" file... */        G.outfile = fopen(G.filename, FOPR);    /* ...and reopen for reading */        if (!linktarget || fread(linktarget, 1, ucsize, G.outfile) !=                           (int)ucsize)        {            Info(slide, 0x201, ((char *)slide,              "warning:  symbolic link (%s) failed\n", FnFilter1(G.filename)));            if (linktarget)                free(linktarget);            fclose(G.outfile);            return;        }        fclose(G.outfile);                  /* close "data" file for good... */        unlink(G.filename);                 /* ...and delete it */        linktarget[ucsize] = '\0';        if (QCOND2)            Info(slide, 0, ((char *)slide, "-> %s ", FnFilter1(linktarget)));        if (symlink(linktarget, G.filename))  /* create the real link */            perror("symlink error");        if (!uO.J_flag) {            /* Symlinks can have attributes, too. */            void *ptr = scanBeOSexfield( G.extra_field,                                         G.lrec.extra_field_length );            if (ptr) {                setBeOSexfield( G.filename, ptr );            }        }        free(linktarget);        return;                             /* can't set time on symlinks */    }#endif /* SYMLINKS */    fclose(G.outfile);    /* handle the BeOS extra field if present */    if (!uO.J_flag) {        void *ptr = scanBeOSexfield( G.extra_field,                                     G.lrec.extra_field_length );        if (ptr) {            setBeOSexfield( G.filename, ptr );#ifdef BEOS_ASSIGN_FILETYPE        } else {            /* Otherwise, ask the system to try assigning a MIME type. */            assign_MIME( G.filename );#endif        }    }/*---------------------------------------------------------------------------    Change the file permissions from default ones to those stored in the    zipfile.  ---------------------------------------------------------------------------*/#ifndef NO_CHMOD    if (chmod(G.filename, 0xffff & G.pInfo->file_attr))        perror("chmod (file attributes) error");#endif/*---------------------------------------------------------------------------    Convert from MSDOS-format local time and date to Unix-format 32-bit GMT    time:  adjust base year from 1980 to 1970, do usual conversions from    yy/mm/dd hh:mm:ss to elapsed seconds, and account for timezone and day-    light savings time differences.  If we have a Unix extra field, however,    we're laughing:  both mtime and atime are ours.  On the other hand, we    then have to check for restoration of UID/GID.  ---------------------------------------------------------------------------*/    eb_izux_flg = (G.extra_field ? ef_scan_for_izux(G.extra_field,                   G.lrec.extra_field_length, 0, G.lrec.last_mod_dos_datetime,#ifdef IZ_CHECK_TZ                   (G.tz_is_valid ? &zt : NULL),#else                   &zt,#endif                   z_uidgid) : 0);    if (eb_izux_flg & EB_UT_FL_MTIME) {        TTrace((stderr, "\nclose_outfile:  Unix e.f. modif. time = %ld\n",          zt.mtime));    } else {        zt.mtime = dos_to_unix_time(G.lrec.last_mod_dos_datetime);    }    if (eb_izux_flg & EB_UT_FL_ATIME) {        TTrace((stderr, "close_outfile:  Unix e.f. access time = %ld\n",          zt.atime));    } else {        zt.atime = zt.mtime;        TTrace((stderr, "\nclose_outfile:  modification/access times = %ld\n",          zt.mtime));    }    /* if -X option was specified and we have UID/GID info, restore it */    if (uO.X_flag && eb_izux_flg & EB_UX2_VALID) {        TTrace((stderr, "close_outfile:  restoring Unix UID/GID info\n"));        if (chown(G.filename, (uid_t)z_uidgid[0], (gid_t)z_uidgid[1]))        {            if (uO.qflag)                Info(slide, 0x201, ((char *)slide,                  "warning:  cannot set UID %d and/or GID %d for %s\n",                  z_uidgid[0], z_uidgid[1], FnFilter1(G.filename)));            else                Info(slide, 0x201, ((char *)slide,                  " (warning) cannot set UID %d and/or GID %d",                  z_uidgid[0], z_uidgid[1]));        }    }    /* set the file's access and modification times */    if (utime(G.filename, (struct utimbuf *)&zt)) {        if (uO.qflag)            Info(slide, 0x201, ((char *)slide,              "warning:  cannot set time for %s\n", FnFilter1(G.filename)));        else            Info(slide, 0x201, ((char *)slide,              " (warning) cannot set time"));    }} /* end function close_outfile() */#ifdef SET_DIR_ATTRIB/* messages of code for setting directory attributes */static char Far DirlistUidGidFailed[] =  "warning:  cannot set UID %d and/or GID %d for %s\n";static char Far DirlistUtimeFailed[] =  "warning:  cannot set modification, access times for %s\n";#  ifndef NO_CHMOD  static char Far DirlistChmodFailed[] =    "warning:  cannot set permissions for %s\n";#  endifint set_direc_attribs(__G__ d)    __GDEF    dirtime *d;{    int errval = PK_OK;    if (d->have_uidgid &&        chown(d->fn, (uid_t)d->uidgid[0], (gid_t)d->uidgid[1]))    {        Info(slide, 0x201, ((char *)slide,          LoadFarString(DirlistUidGidFailed),          d->uidgid[0], d->uidgid[1], d->fn));        if (!errval)            errval = PK_WARN;    }    if (utime(d->fn, (const struct utimbuf *)&d->u.t2)) {        Info(slide, 0x201, ((char *)slide,          LoadFarString(DirlistUtimeFailed), FnFilter1(d->fn)));        if (!errval)            errval = PK_WARN;    }#ifndef NO_CHMOD    if (chmod(d->fn, 0xffff & d->perms)) {        Info(slide, 0x201, ((char *)slide,          LoadFarString(DirlistChmodFailed), FnFilter1(d->fn)));        /* perror("chmod (file attributes) error"); */        if (!errval)            errval = PK_WARN;    }#endif /* !NO_CHMOD */    return errval;} /* end function set_directory_attributes() */#endif /* SET_DIR_ATTRIB */#ifdef TIMESTAMP/***************************//*  Function stamp_file()  *//***************************/int stamp_file(fname, modtime)    ZCONST char *fname;    time_t modtime;{    struct utimbuf tp;    tp.modtime = tp.actime = modtime;    return (utime(fname, &tp));} /* end function stamp_file() */#endif /* TIMESTAMP */#ifndef SFX/************************//*  Function version()  *//************************/void version(__G)    __GDEF{    sprintf((char *)slide, LoadFarString(CompiledWith),#if defined(__MWERKS__)      "Metrowerks CodeWarrior", "",#elif defined(__GNUC__)      "GNU C ", __VERSION__,#endif      "BeOS ",#ifdef __POWERPC__      "(PowerPC)",#else# ifdef __INTEL__      "(x86)",# else      "(unknown)",   /* someday we may have other architectures... */# endif#endif#ifdef __DATE__      " on ", __DATE__#else      "", ""#endif    );    (*G.message)((zvoid *)&G, slide, (ulg)strlen((char *)slide), 0);} /* end function version() */#endif /* !SFX *//******************************//* Extra field functions      *//******************************//*** Scan the extra fields in extra_field, and look for a BeOS EF; return a** pointer to that EF, or NULL if it's not there.*/static uch *scanBeOSexfield( const uch *ef_ptr, unsigned ef_len ){    while( ef_ptr != NULL && ef_len >= EB_HEADSIZE ) {        unsigned eb_id  = makeword(EB_ID + ef_ptr);        unsigned eb_len = makeword(EB_LEN + ef_ptr);        if (eb_len > (ef_len - EB_HEADSIZE)) {            Trace((stderr,              "scanBeOSexfield: block length %u > rest ef_size %u\n", eb_len,              ef_len - EB_HEADSIZE));            break;        }        if( eb_id == EF_BEOS && eb_len >= EB_BEOS_HLEN ) {            return (uch *)ef_ptr;        }        ef_ptr += (eb_len + EB_HEADSIZE);        ef_len -= (eb_len + EB_HEADSIZE);    }    return NULL;}