开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
macos.c
资源名称：unzip540.zip　[点击查看]
上传用户：andy_li
上传日期：2007-01-06
资源大小：1019k
文件大小：56k
源码类别：

压缩解压

开发平台：

MultiPlatform

macos.c：源码内容
  1. /*---------------------------------------------------------------------------
  3.   mac.c
  5.   Macintosh-specific routines for use with Info-ZIP's UnZip 5.4 and later.
  7.   Contains:
  8.                     do_wild ()
  9.                     mapattr ()
  10.                     checkdir ()
  11.                     version ()
  12.                     macmkdir ()
  13.                     macopen ()
  14.                     maccreat ()
  15.                     macread ()
  16.                     macwrite ()
  17.                     macclose ()
  18.                     maclseek ()
  19.                     FindNewExtractFolder ()
  20.                     SetFinderInfo ()
  21.                     isMacOSexfield ()
  22.                     makePPClong ()
  23.                     makePPCword ()
  24.                     PrintMacExtraInfo ()
  25.                     GetExtraFieldData ()
  26.                     DecodeMac3ExtraField ()
  27.                     DecodeJLEEextraField ()
  28.                     PrintTextEncoding ()
  29.                     MacGlobalsInit ()
  31.   ---------------------------------------------------------------------------*/
  34. /*****************************************************************************/
  35. /*  Includes                                                                 */
  36. /*****************************************************************************/
  38. #define UNZIP_INTERNAL
  39. #include "unzip.h"
  41. #include <script.h>
  42. #include "pathname.h"
  43. #include "helpers.h"
  44. #include "macstuff.h"
  45. #include "mactime.h"
  47. /*****************************************************************************/
  48. /*  Macros, typedefs                                                         */
  49. /*****************************************************************************/
  51. #define read_only   file_attr   /* for readability only */
  53. #define MKDIR(path)     macmkdir(path)
  56. /*****************************************************************************/
  57. /*  Global Vars                                                              */
  58. /*****************************************************************************/
  60. /*  Note: sizeof() returns the size of this allusion
  61.           13 is current length of "XtraStuf.mac:"      */
  62. extern const char ResourceMark[13]; /* var is initialized in file pathname.c */
  64. Boolean MacUnzip_Noisy;         /* MacUnzip_Noisy is also used by console */
  67. /*****************************************************************************/
  68. /*  Module level Vars                                                        */
  69. /*****************************************************************************/
  71. static int created_dir;        /* used in mapname(), checkdir() */
  72. static int renamed_fullpath;   /* ditto */
  73. static FSSpec CurrentFile;
  74. static MACINFO newExtraField;  /* contains all extra-field data */
  76. static firstcall_of_macopen = true;
  77. static short MacZipMode;
  78. static Boolean UseUT_ExtraField     = false;
  79. static Boolean IgnoreEF_Macfilename = false;
  82. /*****************************************************************************/
  83. /*  Prototypes                                                               */
  84. /*****************************************************************************/
  86. extern char *GetUnZipInfoVersions(void);
  88. static OSErr SetFinderInfo(FSSpec *spec, MACINFO *mi);
  89. static Boolean GetExtraFieldData(short *MacZipMode, MACINFO *mi);
  90. static uch *scanMacOSexfield(uch *ef_ptr, unsigned ef_len,
  91.                              short *MacZipMode);
  92. static Boolean isMacOSexfield(unsigned id, unsigned size, short *MacZipMode);
  93. static void PrintMacExtraInfo(void);
  94. static void DecodeMac3ExtraField(ZCONST uch *buff, MACINFO *mi);
  95. static void DecodeJLEEextraField(ZCONST uch *buff, MACINFO *mi);
  96. static char *PrintTextEncoding(short script);
  97. static void MakeMacOS_String(char *MacOS_Str,
  98.             const char SpcChar1, const char SpcChar2,
  99.             const char SpcChar3, const char SpcChar4);
  102. /*****************************************************************************/
  103. /*  Constants (strings, etc.)                                                */
  104. /*****************************************************************************/
  106. static ZCONST char Far CannotCreateFile[] = "error:  cannot create %sn";
  109. /*****************************************************************************/
  110. /*  Functions                                                                */
  111. /*****************************************************************************/
  113. #ifndef SFX
  115. /**********************/
  116. /* Function do_wild() */   /* for porting:  dir separator; match(ignore_case) */
  117. /**********************/
  119. char *do_wild(__G__ wildspec)
  120.     __GDEF
  121.     char *wildspec;         /* only used first time on a given dir */
  122. {
  123.     static DIR *dir = (DIR *)NULL;
  124.     static char *dirname, *wildname, matchname[FILNAMSIZ];
  125.     static int firstcall=TRUE, have_dirname;
  126.     static unsigned long dirnamelen;
  127.     struct dirent *file;
  129.     /* Even when we're just returning wildspec, we *always* do so in
  130.      * matchname[]--calling routine is allowed to append four characters
  131.      * to the returned string, and wildspec may be a pointer to argv[].
  132.      */
  133.     if (firstcall) {        /* first call:  must initialize everything */
  134.         firstcall = FALSE;
  136.         MacUnzip_Noisy = !uO.qflag;
  138.         if (MacUnzip_Noisy) printf("%s nn", GetUnZipInfoVersions());
  140.         /* break the wildspec into a directory part and a wildcard filename */
  141.         if ((wildname = strrchr(wildspec, ':')) == (char *)NULL) {
  142.             dirname = ":";
  143.             dirnamelen = 1;
  144.             have_dirname = FALSE;
  145.             wildname = wildspec;
  146.         } else {
  147.             ++wildname;     /* point at character after ':' */
  148.             dirnamelen = wildname - wildspec;
  149.             if ((dirname = (char *)malloc(dirnamelen+1)) == (char *)NULL) {
  150.                 Info(slide, 0x201, ((char *)slide,
  151.                   "warning:  cannot allocate wildcard buffersn"));
  152.                 strcpy(matchname, wildspec);
  153.                 return matchname;   /* but maybe filespec was not a wildcard */
  154.             }
  155.             strncpy(dirname, wildspec, dirnamelen);
  156.             dirname[dirnamelen] = '';   /* terminate for strcpy below */
  157.             have_dirname = TRUE;
  158.         }
  160.         if ((dir = opendir(dirname)) != (DIR *)NULL) {
  161.             while ((file = readdir(dir)) != (struct dirent *)NULL) {
  162.                 if (match(file->d_name, wildname, 0)) {  /* 0 == case sens. */
  163.                     if (have_dirname) {
  164.                         strcpy(matchname, dirname);
  165.                         strcpy(matchname+dirnamelen, file->d_name);
  166.                     } else
  167.                         strcpy(matchname, file->d_name);
  168.                     return matchname;
  169.                 }
  170.             }
  171.             /* if we get to here directory is exhausted, so close it */
  172.             closedir(dir);
  173.             dir = (DIR *)NULL;
  174.         }
  176.         /* return the raw wildspec in case that works (e.g., directory not
  177.          * searchable, but filespec was not wild and file is readable) */
  178.         strcpy(matchname, wildspec);
  179.         return matchname;
  180.     }
  182.     /* last time through, might have failed opendir but returned raw wildspec */
  183.     if (dir == (DIR *)NULL) {
  184.         firstcall = TRUE;  /* nothing left to try--reset for new wildspec */
  185.         if (have_dirname)
  186.             free(dirname);
  187.         return (char *)NULL;
  188.     }
  190.     closedir(dir);     /* have read at least one dir entry; nothing left */
  191.     dir = (DIR *)NULL;
  192.     firstcall = TRUE;  /* reset for new wildspec */
  193.     if (have_dirname)
  194.         free(dirname);
  195.     return (char *)NULL;
  197. } /* end function do_wild() */
  199. #endif /* !SFX */
  205. /***************************/
  206. /* Function open_outfile() */
  207. /***************************/
  209. int open_outfile(__G)         /* return 1 if fail */
  210.     __GDEF
  211. {
  212.     short outfd, fDataFork = TRUE;
  213.     OSErr err;
  214.     char CompletePath[NAME_MAX];
  215.     char ArchiveDir[NAME_MAX];
  216.     short CurrentFork;
  217.     unsigned exdirlen;
  219. #ifdef DLL
  220.     if (G.redirect_data)
  221.         return (redirect_outfile(__G) == FALSE);
  222. #endif
  223.     Trace((stderr, "open_outfile:  trying to open (%s) for writingn",
  224.       FnFilter1(G.filename)));
  226.     exdirlen = strlen(uO.exdir);
  228.     if (MacZipMode != UnKnown_EF)
  229.     {
  230.         fDataFork = (newExtraField.flags & EB_M3_FL_DATFRK) ? TRUE : FALSE;
  232.         if (IgnoreEF_Macfilename)  {
  233.             strcpy(ArchiveDir, &G.filename[exdirlen+1]);
  234.             G.filename[exdirlen+1] = '';
  235.             RfDfFilen2Real(ArchiveDir, ArchiveDir, MacZipMode,
  236.                       (newExtraField.flags & EB_M3_FL_DATFRK), &CurrentFork);
  237.             strcat(G.filename, ArchiveDir);
  238.         } else {        /* use the filename from extra-field */
  239.             G.filename[exdirlen+1] = '';
  240.             strcat(G.filename,newExtraField.FullPath);
  241.         }
  242.     }
  243.     else
  244.     {
  245.         if (!uO.aflag) {
  246.          /* unknown type documents */
  247.          /* all files are considered to be of type 'TEXT' and creator 'hscd' */
  248.          /* this is the default type for CDROM ISO-9660 without Apple extensions */
  249.             newExtraField.fpb.hFileInfo.ioFlFndrInfo.fdType    =  'TEXT';
  250.             newExtraField.fpb.hFileInfo.ioFlFndrInfo.fdCreator =  'hscd';
  251.         } else {
  252.          /* unknown text-files defaults to 'TEXT' */
  253.             newExtraField.fpb.hFileInfo.ioFlFndrInfo.fdType    =  'TEXT';
  254.          /* Bare Bones BBEdit */
  255.             newExtraField.fpb.hFileInfo.ioFlFndrInfo.fdCreator =  'R*ch';
  256.         }
  257.     }
  259.     GetCompletePath(CompletePath, G.filename, &CurrentFile, &err);
  260.     printerr("GetCompletePath open_outfile", (err != -43) && (err != 0),
  261.              err, __LINE__, __FILE__, CompletePath);
  263.     if ((outfd = maccreat(G.filename)) != -1) {
  264.         outfd = macopen(CompletePath, (fDataFork) ? 1 : 2);
  265.     }
  267.     if (outfd == -1) {
  268.         G.outfile = (FILE *)NULL;
  269.         Info(slide, 0x401, ((char *)slide, LoadFarString(CannotCreateFile),
  270.           FnFilter1(G.filename)));
  271.         return 1;
  272.     }
  273.     G.outfile = (FILE *)outfd;
  274.     Trace((stderr, "open_outfile:  successfully opened (%s) for writingn",
  275.       FnFilter1(G.filename)));
  277.     return 0;
  279. } /* end function open_outfile() */
  285. /**********************/
  286. /* Function mapattr() */
  287. /**********************/
  289. int mapattr(__G)
  290.     __GDEF
  291. {
  292.     /* only care about read-only bit, so just look at MS-DOS side of attrs */
  293.     G.pInfo->read_only = (unsigned)(G.crec.external_file_attributes & 1);
  294.     return 0;
  296. } /* end function mapattr() */
  302. /************************/
  303. /*  Function mapname()  */
  304. /************************/
  305.                              /* return 0 if no error, 1 if caution (filename */
  306. int mapname(__G__ renamed)   /*  truncated), 2 if warning (skip file because */
  307.     __GDEF                   /*  dir doesn't exist), 3 if error (skip file), */
  308.     int renamed;             /*  or 10 if out of memory (skip file) */
  309. {                            /*  [also IZ_VOL_LABEL, IZ_CREATED_DIR] */
  310.     char pathcomp[FILNAMSIZ];    /* path-component buffer */
  311.     char *pp, *cp=(char *)NULL;  /* character pointers */
  312.     char *lastsemi=(char *)NULL; /* pointer to last semi-colon in pathcomp */
  313.     int quote = FALSE;           /* flags */
  314.     int error = 0;
  315.     register unsigned workch;    /* hold the character being tested */
  318. /*---------------------------------------------------------------------------
  319.     Initialize various pointers and counters and stuff.
  320.   ---------------------------------------------------------------------------*/
  322.     if (G.pInfo->vollabel)
  323.         return IZ_VOL_LABEL;    /* can't set disk volume labels on Macintosh */
  325.     /* can create path as long as not just freshening, or if user told us */
  326.     G.create_dirs = (!uO.fflag || renamed);
  327.     MacZipMode = false;
  329.     created_dir = FALSE;        /* not yet */
  331.     /* user gave full pathname:  don't prepend rootpath */
  332.     renamed_fullpath = (renamed && (*G.filename == '/'));
  334.     if (checkdir(__G__ (char *)NULL, INIT) == 10)
  335.         return 10;              /* initialize path buffer, unless no memory */
  337.     *pathcomp = '';           /* initialize translation buffer */
  338.     pp = pathcomp;              /* point to translation buffer */
  340.     if (uO.jflag)               /* junking directories */
  341.         cp = (char *)strrchr(G.filename, '/');
  342.     if (cp == (char *)NULL) {   /* no '/' or not junking dirs */
  343.         cp = G.filename;        /* point to internal zipfile-member pathname */
  344.         if (renamed_fullpath)
  345.             ++cp;               /* skip over leading '/' */
  346.     } else
  347.         ++cp;                   /* point to start of last component of path */
  349. /*---------------------------------------------------------------------------
  350.     Begin main loop through characters in filename.
  351.   ---------------------------------------------------------------------------*/
  353.     while ((workch = (uch)*cp++) != 0) {
  355.         if (quote) {                 /* if character quoted, */
  356.             *pp++ = (char)workch;    /*  include it literally */
  357.             quote = FALSE;
  358.         } else
  359.             switch (workch) {
  360.             case '/':             /* can assume -j flag not given */
  361.                 *pp = '';
  362.                 if ((error = checkdir(__G__ pathcomp, APPEND_DIR)) > 1)
  363.                     return error;
  364.                 pp = pathcomp;    /* reset conversion buffer for next piece */
  365.                 lastsemi = (char *)NULL;
  366.                                   /* leave directory semi-colons alone */
  367.                 break;
  369.             case ';':             /* VMS version (or DEC-20 attrib?) */
  370.                 lastsemi = pp;         /* keep for now; remove VMS ";##" */
  371.                 *pp++ = (char)workch;  /*  later, if requested */
  372.                 break;
  374.             case '26':          /* control-V quote for special chars */
  375.                 quote = TRUE;     /* set flag for next character */
  376.                 break;
  378.             default:
  379.                 /* allow European characters in filenames: */
  380.                 if (isprint(workch) || (128 <= workch && workch <= 254))
  381.                     *pp++ = (char)workch;
  382.             } /* end switch */
  384.     } /* end while loop */
  386.     *pp = '';                   /* done with pathcomp:  terminate it */
  388.     /* if not saving them, remove VMS version numbers (appended ";###") */
  389.     if (!uO.V_flag && lastsemi) {
  390.         pp = lastsemi + 1;
  391.         while (isdigit((uch)(*pp)))
  392.             ++pp;
  393.         if (*pp == '')          /* only digits between ';' and end:  nuke */
  394.             *lastsemi = '';
  395.     }
  397. /*---------------------------------------------------------------------------
  398.     Report if directory was created (and no file to create:  filename ended
  399.     in '/'), check name to be sure it exists, and combine path and name be-
  400.     fore exiting.
  401.   ---------------------------------------------------------------------------*/
  403.     if (G.filename[strlen(G.filename) - 1] == '/') {
  404.         checkdir(__G__ G.filename, GETPATH);
  405.         if (created_dir) {
  406.             if (QCOND2) {
  407.                 Info(slide, 0, ((char *)slide, "   creating: %sn",
  408.                   G.filename));
  409.             }
  410.             return IZ_CREATED_DIR;   /* set dir time (note trailing '/') */
  411.         }
  412.         return 2;   /* dir existed already; don't look for data to extract */
  413.     }
  415.     if (*pathcomp == '') {
  416.         Info(slide, 1, ((char *)slide, "mapname:  conversion of %s failedn",
  417.           G.filename));
  418.         return 3;
  419.     }
  421.     GetExtraFieldData(&MacZipMode, &newExtraField);
  423.     checkdir(__G__ pathcomp, APPEND_NAME);  /* returns 1 if truncated: care? */
  424.     checkdir(__G__ G.filename, GETPATH);
  426.     return error;
  428. } /* end function mapname() */
  434. /***********************/
  435. /* Function checkdir() */
  436. /***********************/
  438. int checkdir(__G__ pathcomp, flag)
  439.     __GDEF
  440.     char *pathcomp;
  441.     int flag;
  442. /*
  443.  * returns:  1 - (on APPEND_NAME) truncated filename
  444.  *           2 - path doesn't exist, not allowed to create
  445.  *           3 - path doesn't exist, tried to create and failed; or
  446.  *               path exists and is not a directory, but is supposed to be
  447.  *           4 - path is too long
  448.  *          10 - can't allocate memory for filename buffers
  449.  */
  450. {
  451.     static int rootlen = 0;   /* length of rootpath */
  452.     static char *rootpath;    /* user's "extract-to" directory */
  453.     static char *buildpath;   /* full path (so far) to extracted file */
  454.     static char *end;         /* pointer to end of buildpath ('') */
  456. #   define FN_MASK   7
  457. #   define FUNCTION  (flag & FN_MASK)
  460. /*---------------------------------------------------------------------------
  461.     APPEND_DIR:  append the path component to the path being built and check
  462.     for its existence.  If doesn't exist and we are creating directories, do
  463.     so for this one; else signal success or error as appropriate.
  464.   ---------------------------------------------------------------------------*/
  466.     if (FUNCTION == APPEND_DIR) {
  467.         int too_long = FALSE;
  468. #ifdef SHORT_NAMES
  469.         char *old_end = end;
  470. #endif
  472.         Trace((stderr, "appending dir segment [%s]n", pathcomp));
  473.         while ((*end = *pathcomp++) != '')
  474.             ++end;
  475. #ifdef SHORT_NAMES   /* path components restricted to 14 chars, typically */
  476.         if ((end-old_end) > FILENAME_MAX)  /* GRR:  proper constant? */
  477.             *(end = old_end + FILENAME_MAX) = '';
  478. #endif
  480.         /* GRR:  could do better check, see if overrunning buffer as we go:
  481.          * check end-buildpath after each append, set warning variable if
  482.          * within 20 of FILNAMSIZ; then if var set, do careful check when
  483.          * appending.  Clear variable when begin new path. */
  485.         if ((end-buildpath) > FILNAMSIZ-3)  /* need ':', one-char name, '' */
  486.             too_long = TRUE;                /* check if extracting directory? */
  487.         if (stat(buildpath, &G.statbuf)) {  /* path doesn't exist */
  488.             if (!G.create_dirs) { /* told not to create (freshening) */
  489.                 free(buildpath);
  490.                 return 2;         /* path doesn't exist:  nothing to do */
  491.             }
  492.             if (too_long) {
  493.                 Info(slide, 1, ((char *)slide,
  494.                   "checkdir error:  path too long: %sn", buildpath));
  495.                 free(buildpath);
  496.                 return 4;         /* no room for filenames:  fatal */
  497.             }
  498.             if (MKDIR(buildpath) == -1) {   /* create the directory */
  499.                 Info(slide, 1, ((char *)slide,
  500.                   "checkdir error:  cannot create %sn
  501.                  unable to process %s.n", buildpath, G.filename));
  502.                 free(buildpath);
  503.                 return 3;      /* path didn't exist, tried to create, failed */
  504.             }
  505.             created_dir = TRUE;
  506.         } else if (!S_ISDIR(G.statbuf.st_mode)) {
  507.             Info(slide, 1, ((char *)slide,
  508.               "checkdir error:  %s exists but is not directoryn
  509.                  unable to process %s.n", buildpath, G.filename));
  510.             free(buildpath);
  511.             return 3;          /* path existed but wasn't dir */
  512.         }
  513.         if (too_long) {
  514.             Info(slide, 1, ((char *)slide,
  515.               "checkdir error:  path too long: %sn", buildpath));
  516.             free(buildpath);
  517.             return 4;         /* no room for filenames:  fatal */
  518.         }
  519.         *end++ = ':';
  520.         *end = '';
  521.         Trace((stderr, "buildpath now = [%s]n", buildpath));
  522.         return 0;
  524.     } /* end if (FUNCTION == APPEND_DIR) */
  526. /*---------------------------------------------------------------------------
  527.     GETPATH:  copy full path to the string pointed at by pathcomp, and free
  528.     buildpath.
  529.   ---------------------------------------------------------------------------*/
  531.     if (FUNCTION == GETPATH) {
  532.         strcpy(pathcomp, buildpath);
  533.         Trace((stderr, "getting and freeing path [%s]n", pathcomp));
  534.         free(buildpath);
  535.         buildpath = end = (char *)NULL;
  536.         return 0;
  537.     }
  539. /*---------------------------------------------------------------------------
  540.     APPEND_NAME:  assume the path component is the filename; append it and
  541.     return without checking for existence.
  542.   ---------------------------------------------------------------------------*/
  544.     if (FUNCTION == APPEND_NAME) {
  545. #ifdef SHORT_NAMES
  546.         char *old_end = end;
  547. #endif
  549.         Trace((stderr, "appending filename [%s]n", pathcomp));
  550.         while ((*end = *pathcomp++) != '') {
  551.             ++end;
  552. #ifdef SHORT_NAMES  /* truncate name at 14 characters, typically */
  553.             if ((end-old_end) > FILENAME_MAX)      /* GRR:  proper constant? */
  554.                 *(end = old_end + FILENAME_MAX) = '';
  555. #endif
  556.             if ((end-buildpath) >= FILNAMSIZ) {
  557.                 *--end = '';
  558.                 Info(slide, 0x201, ((char *)slide,
  559.                   "checkdir warning:  path too long; truncatingn
  560.                    %sn                -> %sn", G.filename, buildpath));
  561.                 return 1;   /* filename truncated */
  562.             }
  563.         }
  564.         Trace((stderr, "buildpath now = [%s]n", buildpath));
  565.         return 0;  /* could check for existence here, prompt for new name... */
  566.     }
  568. /*---------------------------------------------------------------------------
  569.     INIT:  allocate and initialize buffer space for the file currently being
  570.     extracted.  If file was renamed with an absolute path, don't prepend the
  571.     extract-to path.
  572.   ---------------------------------------------------------------------------*/
  574.     if (FUNCTION == INIT) {
  575.         Trace((stderr, "initializing buildpath to "));
  576.         if ((buildpath = (char *)malloc(strlen(G.filename)+rootlen+2)) ==
  577.             (char *)NULL)
  578.             return 10;
  579.         if ((rootlen > 0) && !renamed_fullpath) {
  580.             strcpy(buildpath, rootpath);
  581.             end = buildpath + rootlen;
  582.         } else {
  583.             end = buildpath;
  584.             if (!renamed_fullpath && !uO.jflag) {
  585.                 *end++ = ':';           /* indicate relative path */
  586.             }
  587.             *end = '';
  588.         }
  589.         Trace((stderr, "[%s]n", buildpath));
  590.         return 0;
  591.     }
  593. /*---------------------------------------------------------------------------
  594.     ROOT:  if appropriate, store the path in rootpath and create it if neces-
  595.     sary; else assume it's a zipfile member and return.  This path segment
  596.     gets used in extracting all members from every zipfile specified on the
  597.     command line.
  598.   ---------------------------------------------------------------------------*/
  600. #if (!defined(SFX) || defined(SFX_EXDIR))
  601.     if (FUNCTION == ROOT) {
  602.         Trace((stderr, "initializing root path to [%s]n", pathcomp));
  603.         if (pathcomp == (char *)NULL) {
  604.             rootlen = 0;
  605.             return 0;
  606.         }
  607.         if ((rootlen = strlen(pathcomp)) > 0) {
  608.             if (pathcomp[rootlen-1] == ':') {
  609.                 pathcomp[--rootlen] = '';     /* strip trailing delimiter */
  610.             }
  611.             if (rootlen > 0 && (stat(pathcomp, &G.statbuf) ||
  612.                 !S_ISDIR(G.statbuf.st_mode)))       /* path does not exist */
  613.             {
  614.                 if (!G.create_dirs /* || iswild(pathcomp) */ ) {
  615.                     rootlen = 0;
  616.                     return 2;   /* skip (or treat as stored file) */
  617.                 }
  618.                 /* create the directory (could add loop here to scan pathcomp
  619.                  * and create more than one level, but why really necessary?) */
  620.                 if (MKDIR(pathcomp) == -1) {
  621.                     Info(slide, 1, ((char *)slide,
  622.                       "checkdir:  cannot create extraction directory: %sn",
  623.                       pathcomp));
  624.                     rootlen = 0;   /* path didn't exist, tried to create, and */
  625.                     return 3;  /* failed:  file exists, or 2+ levels required */
  626.                 }
  627.             }
  628.             if ((rootpath = (char *)malloc(rootlen+2)) == (char *)NULL) {
  629.                 rootlen = 0;
  630.                 return 10;
  631.             }
  632.             strcpy(rootpath, pathcomp);
  633.             rootpath[rootlen++] = ':';
  634.             rootpath[rootlen] = '';
  635.             Trace((stderr, "rootpath now = [%s]n", rootpath));
  636.         }
  637.         return 0;
  638.     }
  639. #endif /* !SFX || SFX_EXDIR */
  641. /*---------------------------------------------------------------------------
  642.     END:  free rootpath, immediately prior to program exit.
  643.   ---------------------------------------------------------------------------*/
  645.     if (FUNCTION == END) {
  646.         Trace((stderr, "freeing rootpathn"));
  647.         if (rootlen > 0) {
  648.             free(rootpath);
  649.             rootlen = 0;
  650.         }
  651.         return 0;
  652.     }
  654.     return 99;  /* should never reach */
  656. } /* end function checkdir() */
  662. /****************************/
  663. /* Function close_outfile() */
  664. /****************************/
  666. void close_outfile(__G)    /* GRR: change to return PK-style warning level */
  667.     __GDEF
  668. {
  669. #ifdef USE_EF_UT_TIME
  670.     iztimes z_utime;
  671.     unsigned eb_izux_flg;
  672. #endif
  673.     HParamBlockRec hpbr;
  674.     OSErr err;
  675.     FSSpec spec;
  676.     char CompletePath[NAME_MAX];
  677.     CInfoPBRec      fpb;
  679.     if (fileno(G.outfile) == 1)
  680.         return;         /* don't attempt to close or set time on stdout */
  682.     err = (OSErr)fclose(G.outfile);
  683.     printerr("macclose FSClose ",err, err, __LINE__, __FILE__, G.filename);
  685.     GetCompletePath(CompletePath, G.filename, &spec, &err);
  686.     printerr("GetCompletePath", err, err, __LINE__, __FILE__, G.filename);
  687.     fpb.hFileInfo.ioNamePtr = spec.name;
  688.     fpb.hFileInfo.ioVRefNum = spec.vRefNum;
  689.     fpb.hFileInfo.ioDirID = spec.parID;
  690.     fpb.hFileInfo.ioFDirIndex = 0;
  692.     hpbr.fileParam.ioNamePtr = spec.name;
  693.     hpbr.fileParam.ioVRefNum = spec.vRefNum;
  694.     hpbr.fileParam.ioDirID = spec.parID;
  695.     hpbr.fileParam.ioFDirIndex = 0;
  697.     err = PBGetCatInfoSync((CInfoPBPtr)&fpb);
  698.     printerr("PBGetCatInfoSync", err, err, __LINE__, __FILE__, G.filename);
  700.     fpb.hFileInfo.ioDirID = spec.parID;
  701.     if ((MacZipMode == UnKnown_EF) || UseUT_ExtraField ) {
  703. #ifdef USE_EF_UT_TIME
  704.         eb_izux_flg = ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0,
  705.                                        G.lrec.last_mod_dos_datetime, &z_utime, NULL);
  706.         if (G.extra_field &&
  707. #ifdef IZ_CHECK_TZ
  708.             G.tz_is_valid &&
  709. #endif
  710.             (eb_izux_flg & EB_UT_FL_MTIME))
  711.             {
  712.             fpb.hFileInfo.ioFlMdDat = UnixFtime2MacFtime(z_utime.mtime);
  713.             fpb.hFileInfo.ioFlCrDat = UnixFtime2MacFtime(z_utime.ctime);
  714.             }
  716. #ifdef DEBUG_TIME
  717.             {
  718.             struct tm *tp = gmtime(&z_utime.ctime);
  719.             printf(
  720.               "close_outfile:  Unix e.f. creat. time = %d/%2d/%2d  %2d:%2d:%2d -> %lu UTCn",
  721.               tp->tm_year, tp->tm_mon+1, tp->tm_mday,
  722.               tp->tm_hour, tp->tm_min, tp->tm_sec, z_utime.ctime);
  723.             tp = gmtime(&z_utime.mtime);
  724.             printf(
  725.               "close_outfile:  Unix e.f. modif. time = %d/%2d/%2d  %2d:%2d:%2d -> %lu UTCn",
  726.               tp->tm_year, tp->tm_mon+1, tp->tm_mday,
  727.               tp->tm_hour, tp->tm_min, tp->tm_sec, z_utime.mtime);
  728.             }
  729. #endif /* DEBUG_TIME */
  732. #else /* !USE_EF_UT_TIME */
  733.         TTrace((stderr, "close_outfile:  using DOS-Datetime ! n",
  734.               z_utime.mtime));
  735.         dtr.year = (((G.lrec.last_mod_dos_datetime >> 25) & 0x7f) + 1980);
  736.         dtr.month = ((G.lrec.last_mod_dos_datetime >> 21) & 0x0f);
  737.         dtr.day = ((G.lrec.last_mod_dos_datetime >> 16) & 0x1f);
  739.         dtr.hour = ((G.lrec.last_mod_dos_datetime >> 11) & 0x1f);
  740.         dtr.minute = ((G.lrec.last_mod_dos_datetime >> 5) & 0x3f);
  741.         dtr.second = ((G.lrec.last_mod_dos_datetime << 1) & 0x3e);
  743.         DateToSeconds(&dtr, (unsigned long *)&fpb.hFileInfo.ioFlMdDat);
  744.         fpb.hFileInfo.ioFlCrDat = fpb.hFileInfo.ioFlMdDat;
  745. #endif /* ?USE_EF_UT_TIME */
  747.         if (err == noErr)
  748.             err = PBSetCatInfoSync((CInfoPBPtr)&fpb);
  749.         if (err != noErr)
  750.             printf("error (%d): cannot set the time for %sn", err, G.filename);
  751.     }
  753.     /* set read-only perms if needed */
  754.     if ((err == noErr) && G.pInfo->read_only) {
  755.         err = PBHSetFLockSync(&hpbr);
  756.         printerr("PBHSetFLockSync",err,err,__LINE__,__FILE__,G.filename);
  757.     }
  759.     /* finally set FinderInfo */
  760.     if (MacZipMode != UnKnown_EF) {
  761.         err = SetFinderInfo(&CurrentFile, &newExtraField);
  762.         printerr("close_outfile SetFinderInfo ", err, err,
  763.                  __LINE__, __FILE__, G.filename);
  764.     }
  766. } /* end function close_outfile() */
  772. #ifndef SFX
  774. /************************/
  775. /*  Function version()  */
  776. /************************/
  778. void version(__G)
  779.     __GDEF
  780. {
  781. #if 0
  782.     char buf[40];
  783. #endif
  785.     sprintf((char *)slide, LoadFarString(CompiledWith),
  787. #ifdef __GNUC__
  788.       "gcc ", __VERSION__,
  789. #else
  790. #  if 0
  791.       "cc ", (sprintf(buf, " version %d", _RELEASE), buf),
  792. #  else
  793. #  ifdef __MWERKS__
  794.       "CodeWarrior C", "",
  795. #  else
  796. #  ifdef THINK_C
  797.       "Think C", "",
  798. #  else
  799. #  ifdef MPW
  800.       "MPW C", "",
  801. #  else
  802.       "unknown compiler", "",
  803. #  endif
  804. #  endif
  805. #  endif
  806. #  endif
  807. #endif
  809.       "MacOS",
  811. #if defined(foobar) || defined(FOOBAR)
  812.       " (Foo BAR)",    /* hardware or OS version */
  813. #else
  814.       "",
  815. #endif /* Foo BAR */
  817. #ifdef __DATE__
  818.       " on ", __DATE__
  819. #else
  820.       "", ""
  821. #endif
  822.     );
  824.     (*G.message)((zvoid *)&G, slide, (ulg)strlen((char *)slide), 0);
  826. } /* end function version() */
  828. #endif /* !SFX */
  834. /***********************/
  835. /* Function macmkdir() */
  836. /***********************/
  838. int macmkdir(char *path)
  839. {
  840.     OSErr err = -1;
  841.     OSErr err_rc;
  842.     char CompletePath[NAME_MAX];
  843.     FSSpec spec;
  844.     Boolean isDirectory = false;
  845.     short CurrentFork;
  846.     unsigned pathlen;
  847.     long dirID;
  849.     GetExtraFieldData(&MacZipMode, &newExtraField);
  851.     if (MacZipMode != UnKnown_EF) {
  852.         RfDfFilen2Real(CompletePath, G.filename, MacZipMode,
  853.                        (newExtraField.flags & EB_M3_FL_NOCHANGE), &CurrentFork);
  854.         if (CurrentFork == ResourceFork)
  855.             /* don't build a 'XtraStuf.mac:' dir  */
  856.             return 0;
  857.     }
  859.     if (!IgnoreEF_Macfilename) {
  860.         pathlen = strlen(path);
  861.         strcpy(path, uO.exdir);
  862.         strcat(path, ":");
  863.         strcat(path, newExtraField.FullPath);
  864.         path[pathlen] = 0x00;
  865.     }
  867.     GetCompletePath(CompletePath, path, &spec, &err);
  868.     printerr("GetCompletePath", (err != -43) && (err != -120) && (err != 0),
  869.              err, __LINE__, __FILE__, path);
  871.     err = FSpGetDirectoryID(&spec, &dirID, &isDirectory);
  872.     printerr("macmkdir FSpGetDirectoryID ", (err != -43) && (err != 0),
  873.              err, __LINE__, __FILE__, path);
  874.     if (err != -43)     /* -43 = file/directory not found  */
  875.         return 0;
  876.     else {
  877.         HParamBlockRec    hpbr;
  879.         hpbr.fileParam.ioCompletion = NULL;
  880.         hpbr.fileParam.ioNamePtr = spec.name;
  881.         hpbr.fileParam.ioVRefNum = spec.vRefNum;
  882.         hpbr.fileParam.ioDirID = spec.parID;
  883.         err = PBDirCreateSync(&hpbr);
  884.         printerr("macmkdir PBDirCreateSync ", err,
  885.                  err, __LINE__, __FILE__, CompletePath);
  887.         if (MacZipMode != UnKnown_EF) {
  888.             err_rc = SetFinderInfo(&spec, &newExtraField);
  889.             printerr("macmkdir SetFinderInfo ", err_rc,
  890.                      err_rc, __LINE__, __FILE__, CompletePath);
  891.         }
  892.     }
  894.     return (int)err;
  895. } /* macmkdir */
  900. /**********************/
  901. /* Function macopen() */
  902. /**********************/
  904. short macopen(char *sz, short nFlags)
  905. {
  906.     OSErr   err;
  907.     char    chPerms = (!nFlags) ? fsRdPerm : fsRdWrPerm;
  908.     short   nFRefNum;
  909.     static char CompletePath[NAME_MAX];
  911.     /* we only need the filespec of the zipfile;
  912.        filespec of the other files (to be extracted) will be
  913.        determined by open_outfile() */
  914.     if (firstcall_of_macopen) {
  915.         GetCompletePath(CompletePath, sz, &CurrentFile, &err);
  916.         printerr("GetCompletePath", (err != -43) && (err != 0),
  917.                  err, __LINE__, __FILE__, sz);
  918.         /* we are working only with pathnames, this can cause big problems
  919.          * on a Mac ...
  920.          */
  921.         if (CheckMountedVolumes(CompletePath) > 1)
  922.             DoWarnUserDupVol(CompletePath);
  923.         firstcall_of_macopen = false;
  924.     }
  926.     if (nFlags > 1) {
  927.         err = HOpenRF(CurrentFile.vRefNum, CurrentFile.parID, CurrentFile.name,
  928.                       chPerms, &nFRefNum);
  929.         printerr("HOpenRF", (err != -43) && (err != 0) && (err != -54),
  930.                  err, __LINE__, __FILE__, sz);
  931.     } else {
  932.         err = HOpen(CurrentFile.vRefNum, CurrentFile.parID, CurrentFile.name,
  933.                     chPerms, &nFRefNum);
  934.         printerr("HOpen", (err != -43) && (err != 0),
  935.                  err, __LINE__, __FILE__, sz);
  936.     }
  938.     if ( err || (nFRefNum == 1) )
  939.         return -1;
  940.     else {
  941.         if ( nFlags )
  942.             SetEOF( nFRefNum, 0 );
  943.         return nFRefNum;
  944.     }
  945. }
  951. /***********************/
  952. /* Function maccreat() */
  953. /***********************/
  955. short maccreat(char *sz)
  956. {
  957.     OSErr   err;
  958.     char scriptTag = newExtraField.fpb.hFileInfo.ioFlXFndrInfo.fdScript;
  960.     sz = sz;
  962.     /* Set fdScript in FXInfo
  963.      * The negative script constants (smSystemScript, smCurrentScript,
  964.      * and smAllScripts) don't make sense on disk.  So only use scriptTag
  965.      * if scriptTag >= smRoman (smRoman is 0).
  966.      * fdScript is valid if high bit is set (see IM-6, page 9-38)
  967.      */
  968.     scriptTag = (scriptTag >= smRoman) ?
  969.                 ((char)scriptTag | (char)0x80) : (smRoman);
  970.     newExtraField.fpb.hFileInfo.ioFlXFndrInfo.fdScript = scriptTag;
  972.     err = FSpCreate(&CurrentFile,
  973.                     newExtraField.fpb.hFileInfo.ioFlFndrInfo.fdCreator,
  974.                     newExtraField.fpb.hFileInfo.ioFlFndrInfo.fdType,
  975.                     newExtraField.fpb.hFileInfo.ioFlXFndrInfo.fdScript);
  976.     err = printerr("FSpCreate maccreat ", (err != -48) && (err != 0),
  977.                    err, __LINE__, __FILE__, G.filename);
  979.     if (err == noErr)
  980.         return noErr;
  981.     else
  982.         return -1;
  983. }
  989. /**********************/
  990. /* Function macread() */
  991. /**********************/
  993. short macread(short nFRefNum, char *pb, unsigned cb)
  994. {
  995.     long    lcb = cb;
  997.     (void)FSRead( nFRefNum, &lcb, pb );
  999.     return (short)lcb;
  1000. }
  1005. /***********************/
  1006. /* Function macwrite() */
  1007. /***********************/
  1009. long macwrite(short nFRefNum, char *pb, unsigned cb)
  1010. {
  1011.     long    lcb = cb;
  1012.     OSErr   err;
  1013.     FILE    *stream;
  1015.     if ( (nFRefNum == 1) || (nFRefNum == 2) )
  1016.         {
  1017.         stream = (nFRefNum == 1 ? stdout : stderr);
  1018.         pb[cb] = '';           /* terminate C-string */
  1019.                                  /* assumes writable buffer (e.g., slide[]) */
  1020.                                  /* with room for one more char at end of buf */
  1021.         MakeMacOS_String( pb, ' ', ' ', ' ', ' ');
  1022.         lcb = fprintf(stream, pb);
  1023.         }
  1024.     else
  1025.         err = FSWrite( nFRefNum, &lcb, pb );
  1028.     if (err != 0)
  1029.         {
  1030.         errno = ERANGE;
  1031.         return -1;
  1032.         }
  1035.     return (long)lcb;
  1036. }
  1042. /***********************/
  1043. /* Function macclose() */
  1044. /***********************/
  1046. short macclose(short nFRefNum)
  1047. {
  1048. OSErr err;
  1050. err = FSClose( nFRefNum );
  1051. printerr("macclose FSClose ",err,err, __LINE__,__FILE__,G.filename);
  1054. return err;
  1055. }
  1061. /***********************/
  1062. /* Function maclseek() */
  1063. /***********************/
  1065. long maclseek(short nFRefNum, long lib, short nMode)
  1066. {
  1067.     ParamBlockRec   pbr;
  1069.     if (nMode == SEEK_SET)
  1070.         nMode = fsFromStart;
  1071.     else if (nMode == SEEK_CUR)
  1072.         nMode = fsFromMark;
  1073.     else if (nMode == SEEK_END)
  1074.         nMode = fsFromLEOF;
  1075.     pbr.ioParam.ioRefNum = nFRefNum;
  1076.     pbr.ioParam.ioPosMode = nMode;
  1077.     pbr.ioParam.ioPosOffset = lib;
  1078.     (void)PBSetFPosSync(&pbr);
  1079.     return pbr.ioParam.ioPosOffset;
  1080. }
  1085. /***********************************/
  1086. /* Function FindNewExtractFolder() */
  1087. /***********************************/
  1089. char *FindNewExtractFolder(char *ExtractPath)
  1090. {
  1091. char buffer[NAME_MAX];
  1092. short count = 0, length = strlen(ExtractPath) - 2;
  1093. OSErr err;
  1094. FSSpec Spec;
  1095. long theDirID;
  1096. Boolean isDirectory;
  1098. for (count = 0; count < 99; count++)
  1099.     {
  1100.     memset(buffer,0,sizeof(buffer));
  1101.     ExtractPath[length] = 0;
  1102.     sprintf(buffer,"%s%d",ExtractPath,count);
  1103.     GetCompletePath(ExtractPath, buffer, &Spec,&err);
  1104.     err = FSpGetDirectoryID(&Spec, &theDirID, &isDirectory);
  1105.     if (err == -43) return ExtractPath;
  1106.     }
  1108. return ExtractPath; /* can't find unique path, defaults to Extract-Folder */
  1109. }
  1113. /* The following functions are dealing with the extra-field handling, only. */
  1115. /****************************/
  1116. /* Function SetFinderInfo() */
  1117. /****************************/
  1119. static OSErr SetFinderInfo(FSSpec *spec, MACINFO *mi)
  1120. {
  1121.     OSErr err;
  1122.     CInfoPBRec      fpb;
  1124.     fpb.hFileInfo.ioNamePtr   = (StringPtr) &(spec->name);
  1125.     fpb.hFileInfo.ioVRefNum   = spec->vRefNum;
  1126.     fpb.hFileInfo.ioDirID     = spec->parID;
  1127.     fpb.hFileInfo.ioFDirIndex = 0;
  1129.     err = PBGetCatInfo(&fpb, false);
  1130.     printerr("PBGetCatInfo SetFinderInfo ", err, err,
  1131.              __LINE__, __FILE__, G.filename);
  1133.     if  ((MacZipMode == JohnnyLee_EF) || (MacZipMode == NewZipMode_EF))
  1134.     {
  1135.         if (!UseUT_ExtraField)  {
  1136.             fpb.hFileInfo.ioFlCrDat = mi->fpb.hFileInfo.ioFlCrDat;
  1137.             fpb.hFileInfo.ioFlMdDat = mi->fpb.hFileInfo.ioFlMdDat;
  1138.         }
  1140.         fpb.hFileInfo.ioFlFndrInfo   = mi->fpb.hFileInfo.ioFlFndrInfo;
  1141.     }
  1143.     if (MacZipMode == NewZipMode_EF)
  1144.     {
  1145.         if (uO.E_flag) PrintMacExtraInfo();
  1147.         fpb.hFileInfo.ioFlXFndrInfo  = mi->fpb.hFileInfo.ioFlXFndrInfo;
  1149.         fpb.hFileInfo.ioFVersNum  = mi->fpb.hFileInfo.ioFVersNum;
  1150.         fpb.hFileInfo.ioACUser    = mi->fpb.hFileInfo.ioACUser;
  1152.         if (!UseUT_ExtraField) {
  1153.             fpb.hFileInfo.ioFlBkDat = mi->fpb.hFileInfo.ioFlBkDat;
  1154. #ifdef USE_EF_UT_TIME
  1155.             if (
  1156. #ifdef IZ_CHECK_TZ
  1157.                 G.tz_is_valid &&
  1158. #endif
  1159.                 !(mi->flags & EB_M3_FL_NOUTC))
  1160.                 {
  1161. #ifdef DEBUG_TIME
  1162.             {
  1163.             printf("nSetFinderInfo:  Mac modif: %lu local -> UTOffset: %d before AdjustForTZmoveMacn",
  1164.               fpb.hFileInfo.ioFlCrDat, mi->Cr_UTCoffs);
  1165.             }
  1166. #endif /* DEBUG_TIME */
  1167.                 fpb.hFileInfo.ioFlCrDat =
  1168.                   AdjustForTZmoveMac(fpb.hFileInfo.ioFlCrDat, mi->Cr_UTCoffs);
  1169.                 fpb.hFileInfo.ioFlMdDat =
  1170.                   AdjustForTZmoveMac(fpb.hFileInfo.ioFlMdDat, mi->Md_UTCoffs);
  1171.                 fpb.hFileInfo.ioFlBkDat =
  1172.                   AdjustForTZmoveMac(fpb.hFileInfo.ioFlBkDat, mi->Bk_UTCoffs);
  1173. #ifdef DEBUG_TIME
  1174.             {
  1175.             printf("SetFinderInfo:  Mac modif: %lu local -> UTOffset: %d after AdjustForTZmoveMacn",
  1176.               fpb.hFileInfo.ioFlCrDat, mi->Cr_UTCoffs);
  1177.             }
  1178. #endif /* DEBUG_TIME */
  1180.                 }
  1181. #endif /* USE_EF_UT_TIME */
  1182.         }
  1184.         if (mi->FinderComment)  {
  1185.             C2PStr(mi->FinderComment);
  1186.             err = FSpDTSetComment(spec, (unsigned char *) mi->FinderComment);
  1187.             printerr("FSpDTSetComment:",err , err,
  1188.                      __LINE__, __FILE__, mi->FullPath);
  1189.         }
  1190.     }
  1192.     /* Restore ioDirID field in pb which was changed by PBGetCatInfo */
  1193.     fpb.hFileInfo.ioDirID = spec->parID;
  1194.     err = PBSetCatInfo(&fpb, false);
  1196.     return err;
  1197. } /* SetFinderInfo() */
  1202. /*
  1203. ** Scan the extra fields in extra_field, and look for a MacOS EF; return a
  1204. ** pointer to that EF, or NULL if it's not there.
  1205. */
  1206. static uch *scanMacOSexfield(uch *ef_ptr, unsigned ef_len,
  1207.                              short *MacZipMode)
  1208. {
  1209.     while (ef_ptr != NULL && ef_len >= EB_HEADSIZE) {
  1210.         unsigned eb_id  = makeword(EB_ID  + ef_ptr);
  1211.         unsigned eb_len = makeword(EB_LEN + ef_ptr);
  1213.         if (eb_len > (ef_len - EB_HEADSIZE)) {
  1214.             Trace((stderr,
  1215.               "scanMacOSexfield: block length %u > rest ef_size %un", eb_len,
  1216.               ef_len - EB_HEADSIZE));
  1217.             break;
  1218.         }
  1220.         if (isMacOSexfield(eb_id, eb_len, MacZipMode)) {
  1221.             return ef_ptr;
  1222.         }
  1224.         ef_ptr += (eb_len + EB_HEADSIZE);
  1225.         ef_len -= (eb_len + EB_HEADSIZE);
  1226.     }
  1228.     return NULL;
  1229. }
  1234. static Boolean isMacOSexfield(unsigned id, unsigned size, short *MacZipMode)
  1235. {
  1236.     switch (id)
  1237.         {
  1238.         case EF_ZIPIT:
  1239.         case EF_ZIPIT2:
  1240.             {               /* we do not support ZipIt's format completly  */
  1241.             Info(slide, 0x221, ((char *)slide,
  1242.               "warning: found %s ZipIt extra field (size %u) -> "
  1243.               "file is probably not usable!!n",
  1244.               (id == EF_ZIPIT2 ? "short": "long", size)));
  1245.             IgnoreEF_Macfilename = true;
  1246.             return false;
  1247.             }
  1249.         case EF_MAC3:
  1250.             {
  1251.             *MacZipMode = NewZipMode_EF;
  1252.             IgnoreEF_Macfilename = false;
  1253.             return true;
  1254.             }
  1256.         case EF_JLMAC:
  1257.             {
  1258.             *MacZipMode = JohnnyLee_EF;
  1259.             IgnoreEF_Macfilename = true;
  1260.             return true;
  1261.             }
  1263.         default:
  1264.             {
  1265.             *MacZipMode = UnKnown_EF;
  1266.             IgnoreEF_Macfilename = true;
  1267.             return false;
  1268.             }
  1269.         }
  1271.     return false;
  1272. }
  1277. /*
  1278. ** Return a unsigned long from a four-byte sequence
  1279. ** in big endian format
  1280. */
  1282. ulg makePPClong(ZCONST uch *sig)
  1283. {
  1284.     return (((ulg)sig[0]) << 24)
  1285.          + (((ulg)sig[1]) << 16)
  1286.          + (((ulg)sig[2]) << 8)
  1287.          +  ((ulg)sig[3]);
  1288. }
  1293. /*
  1294. ** Return a unsigned short from a two-byte sequence
  1295. ** in big endian format
  1296. */
  1298. ush makePPCword(ZCONST uch *b)
  1299. {
  1300.     return (ush)((b[0] << 8) | b[1]);
  1301. }
  1306. /*
  1307. ** Print mac extra-field
  1308. **
  1309. */
  1311. static void PrintMacExtraInfo(void)
  1312. {
  1313. #define MY_FNDRINFO fpb.hFileInfo.ioFlFndrInfo
  1314.     DateTimeRec  MacTime;
  1315.     static ZCONST char space[] = "                                    ";
  1316.     static ZCONST char line[]  = "------------------------------------"
  1317.                                  "------------------------------";
  1319.     printf("nn%s", line);
  1321.     printf("nFullPath      = [%s]", newExtraField.FullPath);
  1322.     printf("nFinderComment = [%s]", newExtraField.FinderComment);
  1323.     printf("nText Encoding Base (Filename)       "%s" n",
  1324.         PrintTextEncoding(newExtraField.fpb.hFileInfo.ioFlXFndrInfo.fdScript));
  1326.     printf("nExtraField Flags :                  %s  0x%x  %4d",
  1327.         sBit2Str(newExtraField.flags), newExtraField.flags,
  1328.         newExtraField.flags);
  1330.     printf("n%sExtra Field is %s", space,
  1331.            (newExtraField.flags & EB_M3_FL_UNCMPR ?
  1332.             "Uncompressed" : "Compressed"));
  1333.     printf("n%sFile Dates are in %u Bit", space,
  1334.            (newExtraField.flags & EB_M3_FL_TIME64 ? 64 : 32));
  1335.     printf("n%sFile UTC time adjustments are %ssupported", space,
  1336.            (newExtraField.flags & EB_M3_FL_NOUTC ? "not " : ""));
  1337.     printf("n%sFile Name is %schanged", space,
  1338.            (newExtraField.flags & EB_M3_FL_NOCHANGE ? "not " : ""));
  1339.     printf("n%sFile is a %sn", space,
  1340.            (newExtraField.flags & EB_M3_FL_DATFRK ?
  1341.             "Datafork" : "Resourcefork"));
  1343.     /* not all type / creator codes are printable */
  1344.     if (isprint((char)(newExtraField.MY_FNDRINFO.fdType >> 24)) &&
  1345.         isprint((char)(newExtraField.MY_FNDRINFO.fdType >> 16)) &&
  1346.         isprint((char)(newExtraField.MY_FNDRINFO.fdType >> 8)) &&
  1347.         isprint((char)newExtraField.MY_FNDRINFO.fdType))
  1348.     {
  1349.         printf("nFile Type =                         [%c%c%c%c]  0x%lx",
  1350.             (char)(newExtraField.MY_FNDRINFO.fdType >> 24),
  1351.             (char)(newExtraField.MY_FNDRINFO.fdType >> 16),
  1352.             (char)(newExtraField.MY_FNDRINFO.fdType >> 8),
  1353.             (char)(newExtraField.MY_FNDRINFO.fdType),
  1354.             newExtraField.MY_FNDRINFO.fdType);
  1355.     }
  1356.     else
  1357.     {
  1358.         printf("nFile Type =                                     0x%lx",
  1359.             newExtraField.MY_FNDRINFO.fdType);
  1360.     }
  1362.     if (isprint((char)(newExtraField.MY_FNDRINFO.fdCreator >> 24)) &&
  1363.         isprint((char)(newExtraField.MY_FNDRINFO.fdCreator >> 16)) &&
  1364.         isprint((char)(newExtraField.MY_FNDRINFO.fdCreator >> 8)) &&
  1365.         isprint((char)newExtraField.MY_FNDRINFO.fdCreator))
  1366.     {
  1367.         printf("nFile Creator =                      [%c%c%c%c]  0x%lx",
  1368.             (char)(newExtraField.MY_FNDRINFO.fdCreator >> 24),
  1369.             (char)(newExtraField.MY_FNDRINFO.fdCreator >> 16),
  1370.             (char)(newExtraField.MY_FNDRINFO.fdCreator >> 8),
  1371.             (char)(newExtraField.MY_FNDRINFO.fdCreator),
  1372.             newExtraField.MY_FNDRINFO.fdCreator);
  1373.     }
  1374.     else
  1375.     {
  1376.         printf("nFile Creator =                                  0x%lx",
  1377.             newExtraField.MY_FNDRINFO.fdCreator);
  1378.     }
  1380.     printf("nnDates (local time of archiving location):");
  1381.     SecondsToDate(newExtraField.fpb.hFileInfo.ioFlCrDat, &MacTime);
  1382.     printf("n    Created  =                      %4d/%2d/%2d %2d:%2d:%2d  ",
  1383.            MacTime.year, MacTime.month, MacTime.day,
  1384.            MacTime.hour, MacTime.minute, MacTime.second);
  1385.     SecondsToDate(newExtraField.fpb.hFileInfo.ioFlMdDat, &MacTime);
  1386.     printf("n    Modified =                      %4d/%2d/%2d %2d:%2d:%2d  ",
  1387.            MacTime.year, MacTime.month, MacTime.day,
  1388.            MacTime.hour, MacTime.minute, MacTime.second);
  1389.     SecondsToDate(newExtraField.fpb.hFileInfo.ioFlBkDat, &MacTime);
  1390.     printf("n    Backup   =                      %4d/%2d/%2d %2d:%2d:%2d  ",
  1391.         MacTime.year, MacTime.month, MacTime.day,
  1392.         MacTime.hour, MacTime.minute, MacTime.second);
  1394.     if (!(newExtraField.flags & EB_M3_FL_NOUTC)) {
  1395.         printf("nGMT Offset of Creation time  =      %4ld sec  %2d h",
  1396.           newExtraField.Cr_UTCoffs, (int)newExtraField.Cr_UTCoffs / (60 * 60));
  1397.         printf("nGMT Offset of Modification time  =  %4ld sec  %2d h",
  1398.           newExtraField.Md_UTCoffs, (int)newExtraField.Md_UTCoffs / (60 * 60));
  1399.         printf("nGMT Offset of Backup time  =        %4ld sec  %2d h",
  1400.           newExtraField.Bk_UTCoffs, (int)newExtraField.Bk_UTCoffs / (60 * 60));
  1401.     }
  1403.     printf("nnFinder Flags :                      %s  0x%x  %4d",
  1404.         sBit2Str(newExtraField.MY_FNDRINFO.fdFlags),
  1405.         newExtraField.MY_FNDRINFO.fdFlags,
  1406.         newExtraField.MY_FNDRINFO.fdFlags);
  1408.     printf("nFinder Icon Position =              X: %4d",
  1409.         newExtraField.MY_FNDRINFO.fdLocation.h);
  1411.     printf("n                                    Y: %4d",
  1412.         newExtraField.MY_FNDRINFO.fdLocation.v);
  1414.     printf("nnText Encoding Base (System/MacZip)  "%s"",
  1415.         PrintTextEncoding(newExtraField.TextEncodingBase));
  1417.     printf("n%s", line);
  1418. #undef MY_FNDRINFO
  1419. }
  1424. /*
  1425. ** Decode mac extra-field and assign the data to the structure
  1426. **
  1427. */
  1429. static Boolean GetExtraFieldData(short *MacZipMode, MACINFO *mi)
  1430. {
  1431. uch *ptr;
  1432. uch *attrbuff  = NULL;
  1433. int  retval = PK_OK;
  1434. Boolean MallocWasUsed = false;
  1436. ptr = scanMacOSexfield(G.extra_field, G.lrec.extra_field_length, MacZipMode);
  1438. /* MacOS is no preemptive OS therefore do some (small) event-handling */
  1439. UserStop();
  1441. if (uO.J_flag) {
  1442.     *MacZipMode = UnKnown_EF;
  1443.     IgnoreEF_Macfilename = true;
  1444.     return false;
  1445. }
  1448. if (ptr != NULL)
  1449. {
  1450.       /*   Collect the data from the extra field buffer. */
  1451.     mi->header    = makeword(ptr);    ptr += 2;
  1452.     mi->data      = makeword(ptr);    ptr += 2;
  1454.     switch (*MacZipMode)
  1455.         {
  1456.         case NewZipMode_EF:
  1457.           {
  1458.             mi->size      =  makelong(ptr); ptr += 4;
  1459.             mi->flags     =  makeword(ptr); ptr += 2;
  1460.             /* Type/Creator are always uncompressed */
  1461.             mi->fpb.hFileInfo.ioFlFndrInfo.fdType    = makePPClong(ptr);
  1462.             ptr += 4;
  1463.             mi->fpb.hFileInfo.ioFlFndrInfo.fdCreator = makePPClong(ptr);
  1464.             ptr += 4;
  1466.             if (!(mi->flags & EB_M3_FL_UNCMPR)) {
  1467.                  /* compressed extra field is not yet tested,
  1468.                     therefore it's currently not used by default */
  1469.                 attrbuff = (uch *)malloc(mi->size);
  1470.                 if (attrbuff == NULL) {
  1471.                     /* No memory to uncompress attributes */
  1472.                     Info(slide, 0x201, ((char *)slide,
  1473.                          "Can't allocate memory to uncompress file "
  1474.                          "attributes.n"));
  1475.                     *MacZipMode = UnKnown_EF;
  1476.                             /* EF-Block is unusable, ignore it */
  1477.                     return false;
  1478.                 }
  1479.                 else MallocWasUsed = true;
  1481.                 retval = memextract(__G__ attrbuff, mi->size, ptr,
  1482.                                     mi->data - EB_MAC3_HLEN);
  1484.                 if (retval != PK_OK) {
  1485.                     /* error uncompressing attributes */
  1486.                     Info(slide, 0x201, ((char *)slide,
  1487.                          "Error uncompressing file attributes.n"));
  1488.                     free(attrbuff);
  1489.                     *MacZipMode = UnKnown_EF;
  1490.                             /* EF-Block unusable, ignore it */
  1491.                     return false;
  1492.                 }
  1493.             } else {            /* file attributes are uncompressed */
  1494.                 attrbuff = ptr;
  1495.             }
  1496.             DecodeMac3ExtraField(attrbuff, mi);
  1497.             if (MallocWasUsed) free(attrbuff);
  1498.             return true;
  1499.             break;
  1500.           }
  1502.         case JohnnyLee_EF:
  1503.           {
  1504.             if (strncmp((char *)ptr, "JLEE", 4) == 0) {
  1505.                 /* Johnny Lee's old MacZip e.f. was found */
  1506.                 attrbuff  = ptr + 4;
  1508.                 DecodeJLEEextraField(attrbuff, mi);
  1509.                 return true;
  1510.             } else {
  1511.                 /* second signature did not match, ignore EF block */
  1512.                 *MacZipMode = UnKnown_EF;
  1513.                 return false;
  1514.             }
  1515.             break;
  1516.           }
  1518.         default:
  1519.           {  /* just to make sure */
  1520.             *MacZipMode = UnKnown_EF;
  1521.             IgnoreEF_Macfilename = true;
  1522.             return false;
  1523.             break;
  1524.           }
  1525.         }
  1526. }  /* if (ptr != NULL)  */
  1528. /* no Mac extra field was found */
  1529. return false;
  1530. }
  1535. /*
  1536. ** Assign the new Mac3 Extra-Field to the structure
  1537. **
  1538. */
  1540. static void DecodeMac3ExtraField(ZCONST uch *buff, MACINFO *mi)
  1541. {               /* extra-field info of the new MacZip implementation */
  1542.                 /* compresssed extra-field starts here (if compressed) */
  1543. mi->fpb.hFileInfo.ioFlFndrInfo.fdFlags      =  makeword(buff); buff += 2;
  1544. mi->fpb.hFileInfo.ioFlFndrInfo.fdLocation.v =  makeword(buff); buff += 2;
  1545. mi->fpb.hFileInfo.ioFlFndrInfo.fdLocation.h =  makeword(buff); buff += 2;
  1546. mi->fpb.hFileInfo.ioFlFndrInfo.fdFldr       =  makeword(buff); buff += 2;
  1548. mi->fpb.hFileInfo.ioFlXFndrInfo.fdIconID    =  makeword(buff); buff += 2;
  1549. mi->fpb.hFileInfo.ioFlXFndrInfo.fdUnused[0] =  makeword(buff); buff += 2;
  1550. mi->fpb.hFileInfo.ioFlXFndrInfo.fdUnused[1] =  makeword(buff); buff += 2;
  1551. mi->fpb.hFileInfo.ioFlXFndrInfo.fdUnused[2] =  makeword(buff); buff += 2;
  1552. mi->fpb.hFileInfo.ioFlXFndrInfo.fdScript    = *buff;           buff += 1;
  1553. mi->fpb.hFileInfo.ioFlXFndrInfo.fdXFlags    = *buff;           buff += 1;
  1554. mi->fpb.hFileInfo.ioFlXFndrInfo.fdComment   =  makeword(buff); buff += 2;
  1555. mi->fpb.hFileInfo.ioFlXFndrInfo.fdPutAway   =  makelong(buff); buff += 4;
  1557. mi->fpb.hFileInfo.ioFVersNum                = *buff;           buff += 1;
  1558. mi->fpb.hFileInfo.ioACUser                  = *buff;           buff += 1;
  1560. if (mi->flags & EB_M3_FL_TIME64) {
  1561.     Info(slide, 0x201, ((char *)slide,
  1562.          "Don't support 64 bit Timevalues; get a newer version of MacZip n"));
  1563.     UseUT_ExtraField = true;
  1564.     buff += 24; /* jump over the date values */
  1565. } else {
  1566.     UseUT_ExtraField = false;
  1567.     mi->fpb.hFileInfo.ioFlCrDat   =  makelong(buff); buff += 4;
  1568.     mi->fpb.hFileInfo.ioFlMdDat   =  makelong(buff); buff += 4;
  1569.     mi->fpb.hFileInfo.ioFlBkDat   =  makelong(buff); buff += 4;
  1570. }
  1572. if (!(mi->flags & EB_M3_FL_NOUTC))  {
  1573.     mi->Cr_UTCoffs =  makelong(buff); buff += 4;
  1574.     mi->Md_UTCoffs =  makelong(buff); buff += 4;
  1575.     mi->Bk_UTCoffs =  makelong(buff); buff += 4;
  1576. }
  1578. /* TextEncodingBase type & values */
  1579. /* (values 0-32 correspond to the Script Codes defined in "Inside Macintosh",
  1580.     Text pages 6-52 and 6-53) */
  1581. mi->TextEncodingBase =  makeword(buff); buff += 2;
  1582. if (mi->TextEncodingBase >= kTextEncodingUnicodeV1_1)  {
  1583.     Info(slide, 0x201, ((char *)slide,
  1584.          "Don't support Unicoded Filenames; get a newer version of MacZipn"));
  1585.     IgnoreEF_Macfilename = true;
  1586. }
  1588. mi->FullPath      = (char *)buff; buff += strlen(mi->FullPath) + 1;
  1589. mi->FinderComment = (char *)buff; buff += strlen(mi->FinderComment) + 1;
  1591. if (uO.i_flag) IgnoreEF_Macfilename = true;
  1593. }
  1598. /*
  1599. ** Assign the new JLEE Extra-Field to the structure
  1600. **
  1601. */
  1603. static void DecodeJLEEextraField(ZCONST uch *buff, MACINFO *mi)
  1604. { /*  extra-field info of Johnny Lee's old MacZip  */
  1605. mi->fpb.hFileInfo.ioFlFndrInfo.fdType       = makePPClong(buff); buff += 4;
  1606. mi->fpb.hFileInfo.ioFlFndrInfo.fdCreator    = makePPClong(buff); buff += 4;
  1607. mi->fpb.hFileInfo.ioFlFndrInfo.fdFlags      = makePPCword(buff); buff += 2;
  1608. mi->fpb.hFileInfo.ioFlFndrInfo.fdLocation.v = makePPCword(buff); buff += 2;
  1609. mi->fpb.hFileInfo.ioFlFndrInfo.fdLocation.h = makePPCword(buff); buff += 2;
  1610. mi->fpb.hFileInfo.ioFlFndrInfo.fdFldr       = makePPCword(buff); buff += 2;
  1612. mi->fpb.hFileInfo.ioFlCrDat                =  makePPClong(buff); buff += 4;
  1613. mi->fpb.hFileInfo.ioFlMdDat                =  makePPClong(buff); buff += 4;
  1614. mi->flags                                  =  makePPClong(buff); buff += 4;
  1616.      /* scriptTag isn't stored in Johnny Lee's ef definiton */
  1617. newExtraField.fpb.hFileInfo.ioFlXFndrInfo.fdScript = smRoman;
  1618. }
  1623. /*
  1624. ** Return char* to describe the text encoding
  1625. **
  1626. */
  1628. static char *PrintTextEncoding(short script)
  1629. {
  1630. char *info;
  1631. static char buffer[14];
  1632. /* TextEncodingBase type & values */
  1633. /* (values 0-32 correspond to the Script Codes defined in
  1634.    Inside Macintosh: Text pages 6-52 and 6-53 */
  1636. switch (script) {               /* Mac OS encodings*/
  1637.     case kTextEncodingMacRoman:         info = "Roman";             break;
  1638.     case kTextEncodingMacJapanese:      info = "Japanese";          break;
  1639.     case kTextEncodingMacChineseTrad:   info = "ChineseTrad";       break;
  1640.     case kTextEncodingMacKorean:        info = "Korean";            break;
  1641.     case kTextEncodingMacArabic:        info = "Arabic";            break;
  1642.     case kTextEncodingMacHebrew:        info = "Hebrew";            break;
  1643.     case kTextEncodingMacGreek:         info = "Greek";             break;
  1644.     case kTextEncodingMacCyrillic:      info = "Cyrillic";          break;
  1645.     case kTextEncodingMacDevanagari:    info = "Devanagari";        break;
  1646.     case kTextEncodingMacGurmukhi:      info = "Gurmukhi";          break;
  1647.     case kTextEncodingMacGujarati:      info = "Gujarati";          break;
  1648.     case kTextEncodingMacOriya:         info = "Oriya";             break;
  1649.     case kTextEncodingMacBengali:       info = "Bengali";           break;
  1650.     case kTextEncodingMacTamil:         info = "Tamil";             break;
  1651.     case kTextEncodingMacTelugu:        info = "Telugu";            break;
  1652.     case kTextEncodingMacKannada:       info = "Kannada";           break;
  1653.     case kTextEncodingMacMalayalam:     info = "Malayalam";         break;
  1654.     case kTextEncodingMacSinhalese:     info = "Sinhalese";         break;
  1655.     case kTextEncodingMacBurmese:       info = "Burmese";           break;
  1656.     case kTextEncodingMacKhmer:         info = "Khmer";             break;
  1657.     case kTextEncodingMacThai:          info = "Thai";              break;
  1658.     case kTextEncodingMacLaotian:       info = "Laotian";           break;
  1659.     case kTextEncodingMacGeorgian:      info = "Georgian";          break;
  1660.     case kTextEncodingMacArmenian:      info = "Armenian";          break;
  1661.     case kTextEncodingMacChineseSimp:   info = "ChineseSimp";       break;
  1662.     case kTextEncodingMacTibetan:       info = "Tibetan";           break;
  1663.     case kTextEncodingMacMongolian:     info = "Mongolian";         break;
  1664.     case kTextEncodingMacEthiopic:      info = "Ethiopic";          break;
  1665.     case kTextEncodingMacCentralEurRoman: info = "CentralEurRoman"; break;
  1666.     case kTextEncodingMacVietnamese:    info = "Vietnamese";        break;
  1667.     case kTextEncodingMacExtArabic:     info = "ExtArabic";         break;
  1669.     case kTextEncodingUnicodeV1_1:      info = "Unicode V 1.1";     break;
  1670.     case kTextEncodingUnicodeV2_0:      info = "Unicode V 2.0";     break;
  1672.     default:  {
  1673.         sprintf(buffer,"Code: 0x%x",(short) script);
  1674.         info = buffer;
  1675.         break;
  1676.         }
  1677.     }
  1679. return info;
  1680. }
  1684. /*
  1685. ** Init Globals
  1686. **
  1687. */
  1689. void   MacGlobalsInit(__GPRO)
  1690. {
  1691. newExtraField.FullPath      = NULL;
  1692. newExtraField.FinderComment = NULL;
  1694. firstcall_of_macopen = true;
  1696. MacZipMode = UnKnown_EF;
  1697. IgnoreEF_Macfilename = true;
  1699. }
  1703. /*
  1704. ** Convert the MacOS-Strings (Filenames/Findercomments) to a most compatible.
  1705. ** These strings will be stored in the public area of the zip-archive.
  1706. ** Every foreign platform (outside macos) will access these strings
  1707. ** for extraction.
  1708. */
  1710. static void MakeMacOS_String(char *MacOS_Str,
  1711.             const char SpcChar1, const char SpcChar2,
  1712.             const char SpcChar3, const char SpcChar4)
  1713. {
  1714.     char *tmpPtr;
  1715.     register uch curch;
  1717.     for (tmpPtr = MacOS_Str; (curch = *tmpPtr) != ''; tmpPtr++)
  1718.     {
  1719.         if (curch == SpcChar1)
  1720.             *tmpPtr = SpcChar2;
  1721.         else
  1722.         if (curch == SpcChar3)
  1723.             *tmpPtr = SpcChar4;
  1724.         else  /* default */
  1725.             if (curch > 127)
  1726.                {
  1727.                    *tmpPtr = (char)ISO8859_1_to_MacRoman[curch - 128];
  1728.                }
  1729.     }  /* end for */
  1730. }