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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
jarfile.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：23k
源码类别：

CA认证

开发平台：

WINDOWS

jarfile.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. /*
  35.  *  JARFILE
  36.  *
  37.  *  Parsing of a Jar file
  38.  */
  40. #define JAR_SIZE 256
  42. #include "jar.h"
  44. #include "jarint.h"
  45. #include "jarfile.h"
  47. /* commercial compression */
  48. #include "jzlib.h"
  50. #ifdef XP_UNIX
  51. #include "sys/stat.h"
  52. #endif
  55. /* extracting */
  57. static int jar_guess_jar (char *filename, JAR_FILE fp);
  59. static int jar_inflate_memory 
  60.    (unsigned int method, long *length, long expected_out_len, char ZHUGEP **data);
  62. static int jar_physical_extraction 
  63.    (JAR_FILE fp, char *outpath, long offset, long length);
  65. static int jar_physical_inflate
  66.    (JAR_FILE fp, char *outpath, long offset, 
  67.          long length, unsigned int method);
  69. static int jar_verify_extract 
  70.    (JAR *jar, char *path, char *physical_path);
  72. static JAR_Physical *jar_get_physical (JAR *jar, char *pathname);
  74. static int jar_extract_manifests (JAR *jar, jarArch format, JAR_FILE fp);
  76. static int jar_extract_mf (JAR *jar, jarArch format, JAR_FILE fp, char *ext);
  79. /* indexing */
  81. static int jar_gen_index (JAR *jar, jarArch format, JAR_FILE fp);
  83. static int jar_listtar (JAR *jar, JAR_FILE fp);
  85. static int jar_listzip (JAR *jar, JAR_FILE fp);
  88. /* conversions */
  90. static int dosdate (char *date, char *s);
  92. static int dostime (char *time, char *s);
  94. static unsigned int xtoint (unsigned char *ii);
  96. static unsigned long xtolong (unsigned char *ll);
  98. static long atoo (char *s);
  100. /*
  101.  *  J A R _ p a s s _ a r c h i v e
  102.  *
  103.  *  For use by naive clients. Slam an entire archive file
  104.  *  into this function. We extract manifests, parse, index
  105.  *  the archive file, and do whatever nastiness.
  106.  *
  107.  */
  109. int JAR_pass_archive
  110.     (JAR *jar, jarArch format, char *filename, const char *url)
  111.   {
  112.   JAR_FILE fp;
  113.   int status = 0;
  115.   if (filename == NULL)
  116.     return JAR_ERR_GENERAL;
  118.   if ((fp = JAR_FOPEN (filename, "rb")) != NULL)
  119.     {
  120.     if (format == jarArchGuess)
  121.       format = (jarArch)jar_guess_jar (filename, fp);
  123.     jar->format = format;
  124.     jar->url = url ? PORT_Strdup (url) : NULL;
  125.     jar->filename = PORT_Strdup (filename);
  127.     status = jar_gen_index (jar, format, fp);
  129.     if (status == 0)
  130.       status = jar_extract_manifests (jar, format, fp);
  132.     JAR_FCLOSE (fp);
  134.     if (status < 0)
  135.       return status;
  137.     /* people were expecting it this way */
  138.     return jar->valid;
  139.     }
  140.   else
  141.     {
  142.     /* file not found */
  143.     return JAR_ERR_FNF;
  144.     }
  145.   }
  147. /*
  148.  *  J A R _ p a s s _ a r c h i v e _ u n v e r i f i e d
  149.  *
  150.  * Same as JAR_pass_archive, but doesn't parse signatures.
  151.  *
  152.  */
  153. int JAR_pass_archive_unverified
  154.         (JAR *jar, jarArch format, char *filename, const char *url)
  155. {
  156.         JAR_FILE fp;
  157.         int status = 0;
  159.         if (filename == NULL) {
  160.                 return JAR_ERR_GENERAL;
  161.         }
  163.         if ((fp = JAR_FOPEN (filename, "rb")) != NULL) {
  164.                 if (format == jarArchGuess) {
  165.                         format = (jarArch)jar_guess_jar (filename, fp);
  166.                 }
  168.                 jar->format = format;
  169.                 jar->url = url ? PORT_Strdup (url) : NULL;
  170.                 jar->filename = PORT_Strdup (filename);
  172.                 status = jar_gen_index (jar, format, fp);
  174.                 if (status == 0) {
  175.                         status = jar_extract_mf(jar, format, fp, "mf");
  176.                 }
  178.                 JAR_FCLOSE (fp);
  180.                 if (status < 0) {
  181.                         return status;
  182.                 }
  184.                 /* people were expecting it this way */
  185.                 return jar->valid;
  186.         } else {
  187.                 /* file not found */
  188.                 return JAR_ERR_FNF;
  189.         }
  190. }
  192. /*
  193.  *  J A R _ v e r i f i e d _ e x t r a c t
  194.  *
  195.  *  Optimization: keep a file descriptor open
  196.  *  inside the JAR structure, so we don't have to
  197.  *  open the file 25 times to run java. 
  198.  *
  199.  */
  201. int JAR_verified_extract
  202.     (JAR *jar, char *path, char *outpath)
  203.   {
  204.   int status;
  206.   status = JAR_extract (jar, path, outpath);
  208.   if (status >= 0)
  209.     return jar_verify_extract (jar, path, outpath);
  210.   else
  211.     return status;
  212.   }
  214. int JAR_extract
  215.     (JAR *jar, char *path, char *outpath)
  216.   {
  217.   int result;
  219.   JAR_FILE fp;
  220.   JAR_Physical *phy;
  222.   if (jar->fp == NULL && jar->filename)
  223.     {
  224.     jar->fp = (FILE*)JAR_FOPEN (jar->filename, "rb");
  225.     }
  227.   if (jar->fp == NULL)
  228.     {
  229.     /* file not found */
  230.     return JAR_ERR_FNF;
  231.     }
  233.   phy = jar_get_physical (jar, path);
  235.   if (phy)
  236.     {
  237.     if (phy->compression != 0 && phy->compression != 8)
  238.       {
  239.       /* unsupported compression method */
  240.       result = JAR_ERR_CORRUPT;
  241.       }
  243.     if (phy->compression == 0)
  244.       {
  245.       result = jar_physical_extraction 
  246.          ((PRFileDesc*)jar->fp, outpath, phy->offset, phy->length);
  247.       }
  248.     else
  249.       {
  250.       result = jar_physical_inflate 
  251.          ((PRFileDesc*)jar->fp, outpath, phy->offset, phy->length, 
  252.             (unsigned int) phy->compression);
  253.       }
  255. #ifdef XP_UNIX
  256.     if (phy->mode)
  257.       chmod (outpath, 0400 | (mode_t) phy->mode);
  258. #endif
  259.     }
  260.   else
  261.     {
  262.     /* pathname not found in archive */
  263.     result = JAR_ERR_PNF;
  264.     }
  266.   return result;
  267.   }
  269. /* 
  270.  *  p h y s i c a l _ e x t r a c t i o n
  271.  *
  272.  *  This needs to be done in chunks of say 32k, instead of
  273.  *  in one bulk calloc. (Necessary under Win16 platform.)
  274.  *  This is done for uncompressed entries only.
  275.  *
  276.  */
  278. #define CHUNK 32768
  280. static int jar_physical_extraction 
  281.      (JAR_FILE fp, char *outpath, long offset, long length)
  282.   {
  283.   JAR_FILE out;
  285.   char *buffer;
  286.   long at, chunk;
  288.   int status = 0;
  290.   buffer = (char *) PORT_ZAlloc (CHUNK);
  292.   if (buffer == NULL)
  293.     return JAR_ERR_MEMORY;
  295.   if ((out = JAR_FOPEN (outpath, "wb")) != NULL)
  296.     {
  297.     at = 0;
  299.     JAR_FSEEK (fp, offset, (PRSeekWhence)0);
  301.     while (at < length)
  302.       {
  303.       chunk = (at + CHUNK <= length) ? CHUNK : length - at;
  305.       if (JAR_FREAD (fp, buffer, chunk) != chunk)
  306.         {
  307.         status = JAR_ERR_DISK;
  308.         break;
  309.         }
  311.       at += chunk;
  313.       if (JAR_FWRITE (out, buffer, chunk) < chunk)
  314.         {
  315.         /* most likely a disk full error */
  316.         status = JAR_ERR_DISK;
  317.         break;
  318.         }
  319.       }
  320.     JAR_FCLOSE (out);
  321.     }
  322.   else
  323.     {
  324.     /* error opening output file */
  325.     status = JAR_ERR_DISK;
  326.     }
  328.   PORT_Free (buffer);
  329.   return status;
  330.   }
  332. /*
  333.  *  j a r _ p h y s i c a l _ i n f l a t e
  334.  *
  335.  *  Inflate a range of bytes in a file, writing the inflated
  336.  *  result to "outpath". Chunk based.
  337.  *
  338.  */
  340. /* input and output chunks differ, assume 4x compression */
  342. #define ICHUNK 8192
  343. #define OCHUNK 32768
  345. static int jar_physical_inflate
  346.      (JAR_FILE fp, char *outpath, long offset, 
  347.           long length, unsigned int method)
  348.   {
  349.   z_stream zs;
  351.   JAR_FILE out;
  353.   long at, chunk;
  354.   char *inbuf, *outbuf;
  356.   int status = 0;
  358.   unsigned long prev_total, ochunk, tin;
  360.   if ((inbuf = (char *) PORT_ZAlloc (ICHUNK)) == NULL)
  361.     return JAR_ERR_MEMORY;
  363.   if ((outbuf = (char *) PORT_ZAlloc (OCHUNK)) == NULL)
  364.     {
  365.     PORT_Free (inbuf);
  366.     return JAR_ERR_MEMORY;
  367.     }
  369.   PORT_Memset (&zs, 0, sizeof (zs));
  370.   status = inflateInit2 (&zs, -MAX_WBITS);
  372.   if (status != Z_OK)
  373.     return JAR_ERR_GENERAL;
  375.   if ((out = JAR_FOPEN (outpath, "wb")) != NULL)
  376.     {
  377.     at = 0;
  379.     JAR_FSEEK (fp, offset, (PRSeekWhence)0);
  381.     while (at < length)
  382.       {
  383.       chunk = (at + ICHUNK <= length) ? ICHUNK : length - at;
  385.       if (JAR_FREAD (fp, inbuf, chunk) != chunk)
  386.         {
  387.         /* incomplete read */
  388.         return JAR_ERR_CORRUPT;
  389.         }
  391.       at += chunk;
  393.       zs.next_in = (Bytef *) inbuf;
  394.       zs.avail_in = chunk;
  395.       zs.avail_out = OCHUNK;
  397.       tin = zs.total_in;
  399.       while ((zs.total_in - tin < chunk) || (zs.avail_out == 0))
  400.         {
  401.         prev_total = zs.total_out;
  403.         zs.next_out = (Bytef *) outbuf;
  404.         zs.avail_out = OCHUNK;
  406.         status = inflate (&zs, Z_NO_FLUSH);
  408.         if (status != Z_OK && status != Z_STREAM_END)
  409.           {
  410.           /* error during decompression */
  411.           return JAR_ERR_CORRUPT;
  412.           }
  414. ochunk = zs.total_out - prev_total;
  416.         if (JAR_FWRITE (out, outbuf, ochunk) < ochunk)
  417.           {
  418.           /* most likely a disk full error */
  419.           status = JAR_ERR_DISK;
  420.           break;
  421.           }
  423.         if (status == Z_STREAM_END)
  424.           break;
  425.         }
  426.       }
  428.     JAR_FCLOSE (out);
  429.     status = inflateEnd (&zs);
  430.     }
  431.   else
  432.     {
  433.     /* error opening output file */
  434.     status = JAR_ERR_DISK;
  435.     }
  437.   PORT_Free (inbuf);
  438.   PORT_Free (outbuf);
  440.   return status;
  441.   }
  443. /*
  444.  *  j a r _ i n f l a t e _ m e m o r y
  445.  *
  446.  *  Call zlib to inflate the given memory chunk. It is re-XP_ALLOC'd, 
  447.  *  and thus appears to operate inplace to the caller.
  448.  *
  449.  */
  451. static int jar_inflate_memory 
  452.      (unsigned int method, long *length, long expected_out_len, char ZHUGEP **data)
  453.   {
  454.   int status;
  455.   z_stream zs;
  457.   long insz, outsz;
  459.   char *inbuf, *outbuf;
  461.   inbuf =  *data;
  462.   insz = *length;
  464.   outsz = expected_out_len;
  465.   outbuf = (char*)PORT_ZAlloc (outsz);
  467.   if (outbuf == NULL)
  468.     return JAR_ERR_MEMORY;
  470.   PORT_Memset (&zs, 0, sizeof (zs));
  472.   status = inflateInit2 (&zs, -MAX_WBITS);
  474.   if (status < 0)
  475.     {
  476.     /* error initializing zlib stream */
  477.     return JAR_ERR_GENERAL;
  478.     }
  480.   zs.next_in = (Bytef *) inbuf;
  481.   zs.next_out = (Bytef *) outbuf;
  483.   zs.avail_in = insz;
  484.   zs.avail_out = outsz;
  486.   status = inflate (&zs, Z_FINISH);
  488.   if (status != Z_OK && status != Z_STREAM_END)
  489.     {
  490.     /* error during deflation */
  491.     return JAR_ERR_GENERAL; 
  492.     }
  494.   status = inflateEnd (&zs);
  496.   if (status != Z_OK)
  497.     {
  498.     /* error during deflation */
  499.     return JAR_ERR_GENERAL;
  500.     }
  502.   PORT_Free (*data);
  504.   *data = outbuf;
  505.   *length = zs.total_out;
  507.   return 0;
  508.   }
  510. /*
  511.  *  v e r i f y _ e x t r a c t
  512.  *
  513.  *  Validate signature on the freshly extracted file.
  514.  *
  515.  */
  517. static int jar_verify_extract (JAR *jar, char *path, char *physical_path)
  518.   {
  519.   int status;
  520.   JAR_Digest dig;
  522.   PORT_Memset (&dig, 0, sizeof (JAR_Digest));
  523.   status = JAR_digest_file (physical_path, &dig);
  525.   if (!status)
  526.     status = JAR_verify_digest (jar, path, &dig);
  528.   return status;
  529.   }
  531. /*
  532.  *  g e t _ p h y s i c a l
  533.  *
  534.  *  Let's get physical.
  535.  *  Obtains the offset and length of this file in the jar file.
  536.  *
  537.  */
  539. static JAR_Physical *jar_get_physical (JAR *jar, char *pathname)
  540.   {
  541.   JAR_Item *it;
  543.   JAR_Physical *phy;
  545.   ZZLink *link;
  546.   ZZList *list;
  548.   list = jar->phy;
  550.   if (ZZ_ListEmpty (list))
  551.     return NULL;
  553.   for (link = ZZ_ListHead (list);
  554.        !ZZ_ListIterDone (list, link);
  555.        link = link->next)
  556.     {
  557.     it = link->thing;
  558.     if (it->type == jarTypePhy 
  559.           && it->pathname && !PORT_Strcmp (it->pathname, pathname))
  560.       {
  561.       phy = (JAR_Physical *) it->data;
  562.       return phy;
  563.       }
  564.     }
  566.   return NULL;
  567.   }
  569. /*
  570.  *  j a r _ e x t r a c t _ m a n i f e s t s
  571.  *
  572.  *  Extract the manifest files and parse them,
  573.  *  from an open archive file whose contents are known.
  574.  *
  575.  */
  577. static int jar_extract_manifests (JAR *jar, jarArch format, JAR_FILE fp)
  578.   {
  579.   int status;
  581.   if (format != jarArchZip && format != jarArchTar)
  582.     return JAR_ERR_CORRUPT;
  584.   if ((status = jar_extract_mf (jar, format, fp, "mf")) < 0)
  585.     return status;
  587.   if ((status = jar_extract_mf (jar, format, fp, "sf")) < 0)
  588.     return status;
  590.   if ((status = jar_extract_mf (jar, format, fp, "rsa")) < 0)
  591.     return status;
  593.   if ((status = jar_extract_mf (jar, format, fp, "dsa")) < 0)
  594.     return status;
  596.   return 0;
  597.   }
  599. /*
  600.  *  j a r _ e x t r a c t _ m f
  601.  *
  602.  *  Extracts manifest files based on an extension, which 
  603.  *  should be .MF, .SF, .RSA, etc. Order of the files is now no 
  604.  *  longer important when zipping jar files.
  605.  *
  606.  */
  608. static int jar_extract_mf (JAR *jar, jarArch format, JAR_FILE fp, char *ext)
  609.   {
  610.   JAR_Item *it;
  612.   JAR_Physical *phy;
  614.   ZZLink *link;
  615.   ZZList *list;
  617.   char *fn, *e;
  618.   char ZHUGEP *manifest;
  620.   long length;
  621.   int status, ret = 0, num;
  623.   list = jar->phy;
  625.   if (ZZ_ListEmpty (list))
  626.     return JAR_ERR_PNF;
  628.   for (link = ZZ_ListHead (list);
  629.        !ZZ_ListIterDone (list, link);
  630.        link = link->next)
  631.     {
  632.     it = link->thing;
  633.     if (it->type == jarTypePhy 
  634.           && !PORT_Strncmp (it->pathname, "META-INF", 8))
  635.       {
  636.       phy = (JAR_Physical *) it->data;
  638.       if (PORT_Strlen (it->pathname) < 8)
  639.         continue;
  641.       fn = it->pathname + 8;
  642.       if (*fn == '/' || *fn == '\') fn++;
  644.       if (*fn == 0)
  645.         {
  646.         /* just a directory entry */
  647.         continue;
  648.         }
  650.       /* skip to extension */
  651.       for (e = fn; *e && *e != '.'; e++)
  652.         /* yip */ ;
  654.       /* and skip dot */
  655.       if (*e == '.') e++;
  657.       if (PORT_Strcasecmp (ext, e))
  658.         {
  659.         /* not the right extension */
  660.         continue;
  661.         }
  663.       if (phy->length == 0)
  664.         {
  665.         /* manifest files cannot be zero length! */
  666.         return JAR_ERR_CORRUPT;
  667.         }
  669.       /* Read in the manifest and parse it */
  670.       /* FIX? Does this break on win16 for very very large manifest files? */
  672. #ifdef XP_WIN16
  673.       PORT_Assert( phy->length+1 < 0xFFFF );
  674. #endif
  676.       manifest = (char ZHUGEP *) PORT_ZAlloc (phy->length + 1);
  677.       if (manifest)
  678.         {
  679.         JAR_FSEEK (fp, phy->offset, (PRSeekWhence)0);
  680.         num = JAR_FREAD (fp, manifest, phy->length);
  682.         if (num != phy->length)
  683.           {
  684.           /* corrupt archive file */
  685.           return JAR_ERR_CORRUPT;
  686.           }
  688.         if (phy->compression == 8)
  689.           {
  690.           length = phy->length;
  692.           status = jar_inflate_memory ((unsigned int) phy->compression, &length,  phy->uncompressed_length, &manifest);
  694.           if (status < 0)
  695.             return status;
  696.           }
  697.         else if (phy->compression)
  698.           {
  699.           /* unsupported compression method */
  700.           return JAR_ERR_CORRUPT;
  701.           }
  702.         else
  703.           length = phy->length;
  705.         status = JAR_parse_manifest 
  706.            (jar, manifest, length, it->pathname, "url");
  708.         PORT_Free (manifest);
  710.         if (status < 0 && ret == 0) ret = status;
  711.         }
  712.       else
  713.         return JAR_ERR_MEMORY;
  714.       }
  715.     else if (it->type == jarTypePhy)
  716.       {
  717.       /* ordinary file */
  718.       }
  719.     }
  721.   return ret;
  722.   }
  724. /*
  725.  *  j a r _ g e n _ i n d e x
  726.  *
  727.  *  Generate an index for the various types of
  728.  *  known archive files. Right now .ZIP and .TAR
  729.  *
  730.  */
  732. static int jar_gen_index (JAR *jar, jarArch format, JAR_FILE fp)
  733.   {
  734.   int result = JAR_ERR_CORRUPT;
  735.   JAR_FSEEK (fp, 0, (PRSeekWhence)0);
  737.   switch (format)
  738.     {
  739.     case jarArchZip:
  740.       result = jar_listzip (jar, fp);
  741.       break;
  743.     case jarArchTar:
  744.       result = jar_listtar (jar, fp);
  745.       break;
  746.     }
  748.   JAR_FSEEK (fp, 0, (PRSeekWhence)0);
  749.   return result;
  750.   }
  753. /*
  754.  *  j a r _ l i s t z i p
  755.  *
  756.  *  List the physical contents of a Phil Katz 
  757.  *  style .ZIP file into the JAR linked list.
  758.  *
  759.  */
  761. static int jar_listzip (JAR *jar, JAR_FILE fp)
  762.   {
  763.   int err = 0;
  765.   long pos = 0L;
  766.   char filename [JAR_SIZE];
  768.   char date [9], time [9];
  769.   char sig [4];
  771.   unsigned int compression;
  772.   unsigned int filename_len, extra_len;
  774.   struct ZipLocal *Local;
  775.   struct ZipCentral *Central;
  776.   struct ZipEnd *End;
  778.   /* phy things */
  780.   ZZLink  *ent;
  781.   JAR_Item *it;
  782.   JAR_Physical *phy;
  784.   Local = (struct ZipLocal *) PORT_ZAlloc (30);
  785.   Central = (struct ZipCentral *) PORT_ZAlloc (46);
  786.   End = (struct ZipEnd *) PORT_ZAlloc (22);
  788.   if (!Local || !Central || !End)
  789.     {
  790.     /* out of memory */
  791.     err = JAR_ERR_MEMORY;
  792.     goto loser;
  793.     }
  795.   while (1)
  796.     {
  797.     JAR_FSEEK (fp, pos, (PRSeekWhence)0);
  799.     if (JAR_FREAD (fp, (char *) sig, 4) != 4)
  800.       {
  801.       /* zip file ends prematurely */
  802.       err = JAR_ERR_CORRUPT;
  803.       goto loser;
  804.       }
  806.     JAR_FSEEK (fp, pos, (PRSeekWhence)0);
  808.     if (xtolong ((unsigned char *)sig) == LSIG)
  809.       {
  810.       JAR_FREAD (fp, (char *) Local, 30);
  812.       filename_len = xtoint ((unsigned char *) Local->filename_len);
  813.       extra_len = xtoint ((unsigned char *) Local->extrafield_len);
  815.       if (filename_len >= JAR_SIZE)
  816.         {
  817.         /* corrupt zip file */
  818.         err = JAR_ERR_CORRUPT;
  819.         goto loser;
  820.         }
  822.       if (JAR_FREAD (fp, filename, filename_len) != filename_len)
  823.         {
  824.         /* truncated archive file */
  825.         err = JAR_ERR_CORRUPT;
  826.         goto loser;
  827.         }
  829.       filename [filename_len] = 0;
  831.       /* Add this to our jar chain */
  833.       phy = (JAR_Physical *) PORT_ZAlloc (sizeof (JAR_Physical));
  835.       if (phy == NULL)
  836.         {
  837.         err = JAR_ERR_MEMORY;
  838.         goto loser;
  839.         }
  841.       /* We will index any file that comes our way, but when it comes
  842.          to actually extraction, compression must be 0 or 8 */
  844.       compression = xtoint ((unsigned char *) Local->method);
  845.       phy->compression = compression >= 0 && 
  846.               compression <= 255 ? compression : 222;
  848.       phy->offset = pos + 30 + filename_len + extra_len;
  849.       phy->length = xtolong ((unsigned char *) Local->size);
  850.       phy->uncompressed_length = xtolong((unsigned char *) Local->orglen);
  852.       dosdate (date, Local->date);
  853.       dostime (time, Local->time);
  855.       it = (JAR_Item*)PORT_ZAlloc (sizeof (JAR_Item));
  856.       if (it == NULL)
  857.         {
  858.         err = JAR_ERR_MEMORY;
  859.         goto loser;
  860.         }
  862.       it->pathname = PORT_Strdup (filename);
  864.       it->type = jarTypePhy;
  866.       it->data = (unsigned char *) phy;
  867.       it->size = sizeof (JAR_Physical);
  869.       ent = ZZ_NewLink (it);
  871.       if (ent == NULL)
  872.         {
  873.         err = JAR_ERR_MEMORY;
  874.         goto loser;
  875.         }
  877.       ZZ_AppendLink (jar->phy, ent);
  878.  
  879.       pos = phy->offset + phy->length;
  880.       }
  881.     else if (xtolong ( (unsigned char *)sig) == CSIG)
  882.       {
  883.       if (JAR_FREAD (fp, (char *) Central, 46) != 46)
  884.         {
  885.         /* apparently truncated archive */
  886.         err = JAR_ERR_CORRUPT;
  887.         goto loser;
  888.         }
  890. #ifdef XP_UNIX
  891.       /* with unix we need to locate any bits from 
  892.          the protection mask in the external attributes. */
  893.         {
  894.         unsigned int attr;
  896.         /* determined empirically */
  897.         attr = Central->external_attributes [2];
  899.         if (attr)
  900.           {
  901.           /* we have to read the filename, again */
  903.           filename_len = xtoint ((unsigned char *) Central->filename_len);
  905.           if (filename_len >= JAR_SIZE)
  906.             {
  907.             /* corrupt in central directory */
  908.             err = JAR_ERR_CORRUPT;
  909.             goto loser;
  910.             }
  912.           if (JAR_FREAD (fp, filename, filename_len) != filename_len)
  913.             {
  914.             /* truncated in central directory */
  915.             err = JAR_ERR_CORRUPT;
  916.             goto loser;
  917.             }
  919.           filename [filename_len] = 0;
  921.           /* look up this name again */
  922.           phy = jar_get_physical (jar, filename);
  924.           if (phy)
  925.             {
  926.             /* always allow access by self */
  927.             phy->mode = 0400 | attr;
  928.             }
  929.           }
  930.         }
  931. #endif
  933.       pos += 46 + xtoint ( (unsigned char *)Central->filename_len)
  934.                 + xtoint ( (unsigned char *)Central->commentfield_len)
  935.                 + xtoint ( (unsigned char *)Central->extrafield_len);
  936.       }
  937.     else if (xtolong ( (unsigned char *)sig) == ESIG)
  938.       {
  939.       if (JAR_FREAD (fp, (char *) End, 22) != 22)
  940.         {
  941.         err = JAR_ERR_CORRUPT;
  942.         goto loser;
  943.         }
  944.       else
  945.         break;
  946.       }
  947.     else
  948.       {
  949.       /* garbage in archive */
  950.       err = JAR_ERR_CORRUPT;
  951.       goto loser;
  952.       }
  953.     }
  955. loser:
  957.   if (Local) PORT_Free (Local);
  958.   if (Central) PORT_Free (Central);
  959.   if (End) PORT_Free (End);
  961.   return err;
  962.   }
  964. /*
  965.  *  j a r _ l i s t t a r
  966.  *
  967.  *  List the physical contents of a Unix 
  968.  *  .tar file into the JAR linked list.
  969.  *
  970.  */
  972. static int jar_listtar (JAR *jar, JAR_FILE fp)
  973.   {
  974.   long pos = 0L;
  976.   long sz, mode;
  977.   time_t when;
  978.   union TarEntry tarball;
  980.   char *s;
  982.   /* phy things */
  984.   ZZLink  *ent;
  985.   JAR_Item *it;
  986.   JAR_Physical *phy;
  988.   while (1)
  989.     {
  990.     JAR_FSEEK (fp, pos, (PRSeekWhence)0);
  992.     if (JAR_FREAD (fp, (char *) &tarball, 512) < 512)
  993.       break;
  995.     if (!*tarball.val.filename)
  996.       break;
  998.     when = atoo (tarball.val.time);
  999.     sz = atoo (tarball.val.size);
  1000.     mode = atoo (tarball.val.mode);
  1003.     /* Tag the end of filename */
  1005.     s = tarball.val.filename;
  1006.     while (*s && *s != ' ') s++;
  1007.     *s = 0;
  1010.     /* Add to our linked list */
  1012.     phy = (JAR_Physical *) PORT_ZAlloc (sizeof (JAR_Physical));
  1014.     if (phy == NULL)
  1015.       return JAR_ERR_MEMORY;
  1017.     phy->compression = 0;
  1018.     phy->offset = pos + 512;
  1019.     phy->length = sz;
  1021.     ADDITEM (jar->phy, jarTypePhy, 
  1022.        tarball.val.filename, phy, sizeof (JAR_Physical));
  1025.     /* Advance to next file entry */
  1027.     sz += 511;
  1028.     sz = (sz / 512) * 512;
  1030.     pos += sz + 512;
  1031.     }
  1033.   return 0;
  1034.   }
  1036. /*
  1037.  *  d o s d a t e
  1038.  *
  1039.  *  Not used right now, but keep it in here because
  1040.  *  it will be needed. 
  1041.  *
  1042.  */
  1044. static int dosdate (char *date, char *s)
  1045.   {
  1046.   int num = xtoint ( (unsigned char *)s);
  1048.   PR_snprintf (date, 9, "%02d-%02d-%02d",
  1049.      ((num >> 5) & 0x0F), (num & 0x1F), ((num >> 9) + 80));
  1051.   return 0;
  1052.   }
  1054. /*
  1055.  *  d o s t i m e
  1056.  *
  1057.  *  Not used right now, but keep it in here because
  1058.  *  it will be needed. 
  1059.  *
  1060.  */
  1062. static int dostime (char *time, char *s)
  1063.   {
  1064.   int num = xtoint ( (unsigned char *)s);
  1066.   PR_snprintf (time, 6, "%02d:%02d",
  1067.      ((num >> 11) & 0x1F), ((num >> 5) & 0x3F));
  1069.   return 0;
  1070.   }
  1072. /*
  1073.  *  x t o i n t
  1074.  *
  1075.  *  Converts a two byte ugly endianed integer
  1076.  *  to our platform's integer.
  1077.  *
  1078.  */
  1080. static unsigned int xtoint (unsigned char *ii)
  1081.   {
  1082.   return (int) (ii [0]) | ((int) ii [1] << 8);
  1083.   }
  1085. /*
  1086.  *  x t o l o n g
  1087.  *
  1088.  *  Converts a four byte ugly endianed integer
  1089.  *  to our platform's integer.
  1090.  *
  1091.  */
  1093. static unsigned long xtolong (unsigned char *ll)
  1094.   {
  1095.   unsigned long ret;
  1097.   ret =  (
  1098.          (((unsigned long) ll [0]) <<  0) |
  1099.          (((unsigned long) ll [1]) <<  8) |
  1100.          (((unsigned long) ll [2]) << 16) |
  1101.          (((unsigned long) ll [3]) << 24)
  1102.          );
  1104.   return ret;
  1105.   }
  1107. /*
  1108.  *  a t o o
  1109.  *
  1110.  *  Ascii octal to decimal.
  1111.  *  Used for integer encoding inside tar files.
  1112.  *
  1113.  */
  1115. static long atoo (char *s)
  1116.   {
  1117.   long num = 0L;
  1119.   while (*s == ' ') s++;
  1121.   while (*s >= '0' && *s <= '7')
  1122.     {
  1123.     num <<= 3;
  1124.     num += *s++ - '0';
  1125.     }
  1127.   return num;
  1128.   }
  1130. /*
  1131.  *  g u e s s _ j a r
  1132.  *
  1133.  *  Try to guess what kind of JAR file this is.
  1134.  *  Maybe tar, maybe zip. Look in the file for magic
  1135.  *  or at its filename.
  1136.  *
  1137.  */
  1139. static int jar_guess_jar (char *filename, JAR_FILE fp)
  1140.   {
  1141.   char *ext;
  1143.   ext = filename + PORT_Strlen (filename) - 4;
  1145.   if (!PORT_Strcmp (ext, ".tar"))
  1146.     return jarArchTar;
  1148.   return jarArchZip;
  1149.   }