1 /*
   2  * Copyright (c) 1995, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.util.zip;
  27 
  28 import java.io.Closeable;
  29 import java.io.InputStream;
  30 import java.io.IOException;
  31 import java.io.EOFException;
  32 import java.io.File;
  33 import java.io.RandomAccessFile;
  34 import java.nio.charset.Charset;
  35 import java.nio.charset.StandardCharsets;
  36 import java.nio.file.attribute.BasicFileAttributes;
  37 import java.nio.file.Path;
  38 import java.nio.file.Files;
  39 
  40 import java.util.ArrayDeque;
  41 import java.util.ArrayList;
  42 import java.util.Arrays;
  43 import java.util.Deque;
  44 import java.util.Enumeration;
  45 import java.util.HashMap;
  46 import java.util.Iterator;
  47 import java.util.Map;
  48 import java.util.Objects;
  49 import java.util.NoSuchElementException;
  50 import java.util.Spliterator;
  51 import java.util.Spliterators;
  52 import java.util.WeakHashMap;
  53 import java.util.stream.Stream;
  54 import java.util.stream.StreamSupport;
  55 import jdk.internal.misc.JavaUtilZipFileAccess;
  56 import jdk.internal.misc.SharedSecrets;
  57 
  58 import static java.util.zip.ZipConstants.*;
  59 import static java.util.zip.ZipConstants64.*;
  60 import static java.util.zip.ZipUtils.*;
  61 
  62 /**
  63  * This class is used to read entries from a zip file.
  64  *
  65  * <p> Unless otherwise noted, passing a {@code null} argument to a constructor
  66  * or method in this class will cause a {@link NullPointerException} to be
  67  * thrown.
  68  *
  69  * @author      David Connelly
  70  */
  71 public
  72 class ZipFile implements ZipConstants, Closeable {
  73 
  74     private final String name;     // zip file name
  75     private volatile boolean closeRequested = false;
  76     private Source zsrc;
  77     private ZipCoder zc;
  78 
  79     private static final int STORED = ZipEntry.STORED;
  80     private static final int DEFLATED = ZipEntry.DEFLATED;
  81 
  82     /**
  83      * Mode flag to open a zip file for reading.
  84      */
  85     public static final int OPEN_READ = 0x1;
  86 
  87     /**
  88      * Mode flag to open a zip file and mark it for deletion.  The file will be
  89      * deleted some time between the moment that it is opened and the moment
  90      * that it is closed, but its contents will remain accessible via the
  91      * {@code ZipFile} object until either the close method is invoked or the
  92      * virtual machine exits.
  93      */
  94     public static final int OPEN_DELETE = 0x4;
  95 
  96     /**
  97      * Opens a zip file for reading.
  98      *
  99      * <p>First, if there is a security manager, its {@code checkRead}
 100      * method is called with the {@code name} argument as its argument
 101      * to ensure the read is allowed.
 102      *
 103      * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to
 104      * decode the entry names and comments.
 105      *
 106      * @param name the name of the zip file
 107      * @throws ZipException if a ZIP format error has occurred
 108      * @throws IOException if an I/O error has occurred
 109      * @throws SecurityException if a security manager exists and its
 110      *         {@code checkRead} method doesn't allow read access to the file.
 111      *
 112      * @see SecurityManager#checkRead(java.lang.String)
 113      */
 114     public ZipFile(String name) throws IOException {
 115         this(new File(name), OPEN_READ);
 116     }
 117 
 118     /**
 119      * Opens a new {@code ZipFile} to read from the specified
 120      * {@code File} object in the specified mode.  The mode argument
 121      * must be either {@code OPEN_READ} or {@code OPEN_READ | OPEN_DELETE}.
 122      *
 123      * <p>First, if there is a security manager, its {@code checkRead}
 124      * method is called with the {@code name} argument as its argument to
 125      * ensure the read is allowed.
 126      *
 127      * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to
 128      * decode the entry names and comments
 129      *
 130      * @param file the ZIP file to be opened for reading
 131      * @param mode the mode in which the file is to be opened
 132      * @throws ZipException if a ZIP format error has occurred
 133      * @throws IOException if an I/O error has occurred
 134      * @throws SecurityException if a security manager exists and
 135      *         its {@code checkRead} method
 136      *         doesn't allow read access to the file,
 137      *         or its {@code checkDelete} method doesn't allow deleting
 138      *         the file when the {@code OPEN_DELETE} flag is set.
 139      * @throws IllegalArgumentException if the {@code mode} argument is invalid
 140      * @see SecurityManager#checkRead(java.lang.String)
 141      * @since 1.3
 142      */
 143     public ZipFile(File file, int mode) throws IOException {
 144         this(file, mode, StandardCharsets.UTF_8);
 145     }
 146 
 147     /**
 148      * Opens a ZIP file for reading given the specified File object.
 149      *
 150      * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to
 151      * decode the entry names and comments.
 152      *
 153      * @param file the ZIP file to be opened for reading
 154      * @throws ZipException if a ZIP format error has occurred
 155      * @throws IOException if an I/O error has occurred
 156      */
 157     public ZipFile(File file) throws ZipException, IOException {
 158         this(file, OPEN_READ);
 159     }
 160 
 161     /**
 162      * Opens a new {@code ZipFile} to read from the specified
 163      * {@code File} object in the specified mode.  The mode argument
 164      * must be either {@code OPEN_READ} or {@code OPEN_READ | OPEN_DELETE}.
 165      *
 166      * <p>First, if there is a security manager, its {@code checkRead}
 167      * method is called with the {@code name} argument as its argument to
 168      * ensure the read is allowed.
 169      *
 170      * @param file the ZIP file to be opened for reading
 171      * @param mode the mode in which the file is to be opened
 172      * @param charset
 173      *        the {@linkplain java.nio.charset.Charset charset} to
 174      *        be used to decode the ZIP entry name and comment that are not
 175      *        encoded by using UTF-8 encoding (indicated by entry's general
 176      *        purpose flag).
 177      *
 178      * @throws ZipException if a ZIP format error has occurred
 179      * @throws IOException if an I/O error has occurred
 180      *
 181      * @throws SecurityException
 182      *         if a security manager exists and its {@code checkRead}
 183      *         method doesn't allow read access to the file,or its
 184      *         {@code checkDelete} method doesn't allow deleting the
 185      *         file when the {@code OPEN_DELETE} flag is set
 186      *
 187      * @throws IllegalArgumentException if the {@code mode} argument is invalid
 188      *
 189      * @see SecurityManager#checkRead(java.lang.String)
 190      *
 191      * @since 1.7
 192      */
 193     public ZipFile(File file, int mode, Charset charset) throws IOException
 194     {
 195         if (((mode & OPEN_READ) == 0) ||
 196             ((mode & ~(OPEN_READ | OPEN_DELETE)) != 0)) {
 197             throw new IllegalArgumentException("Illegal mode: 0x"+
 198                                                Integer.toHexString(mode));
 199         }
 200         String name = file.getPath();
 201         SecurityManager sm = System.getSecurityManager();
 202         if (sm != null) {
 203             sm.checkRead(name);
 204             if ((mode & OPEN_DELETE) != 0) {
 205                 sm.checkDelete(name);
 206             }
 207         }
 208         Objects.requireNonNull(charset, "charset");
 209         this.zc = ZipCoder.get(charset);
 210         this.name = name;
 211         long t0 = System.nanoTime();
 212         this.zsrc = Source.get(file, (mode & OPEN_DELETE) != 0);
 213         sun.misc.PerfCounter.getZipFileOpenTime().addElapsedTimeFrom(t0);
 214         sun.misc.PerfCounter.getZipFileCount().increment();
 215     }
 216 
 217     /**
 218      * Opens a zip file for reading.
 219      *
 220      * <p>First, if there is a security manager, its {@code checkRead}
 221      * method is called with the {@code name} argument as its argument
 222      * to ensure the read is allowed.
 223      *
 224      * @param name the name of the zip file
 225      * @param charset
 226      *        the {@linkplain java.nio.charset.Charset charset} to
 227      *        be used to decode the ZIP entry name and comment that are not
 228      *        encoded by using UTF-8 encoding (indicated by entry's general
 229      *        purpose flag).
 230      *
 231      * @throws ZipException if a ZIP format error has occurred
 232      * @throws IOException if an I/O error has occurred
 233      * @throws SecurityException
 234      *         if a security manager exists and its {@code checkRead}
 235      *         method doesn't allow read access to the file
 236      *
 237      * @see SecurityManager#checkRead(java.lang.String)
 238      *
 239      * @since 1.7
 240      */
 241     public ZipFile(String name, Charset charset) throws IOException
 242     {
 243         this(new File(name), OPEN_READ, charset);
 244     }
 245 
 246     /**
 247      * Opens a ZIP file for reading given the specified File object.
 248      *
 249      * @param file the ZIP file to be opened for reading
 250      * @param charset
 251      *        The {@linkplain java.nio.charset.Charset charset} to be
 252      *        used to decode the ZIP entry name and comment (ignored if
 253      *        the <a href="package-summary.html#lang_encoding"> language
 254      *        encoding bit</a> of the ZIP entry's general purpose bit
 255      *        flag is set).
 256      *
 257      * @throws ZipException if a ZIP format error has occurred
 258      * @throws IOException if an I/O error has occurred
 259      *
 260      * @since 1.7
 261      */
 262     public ZipFile(File file, Charset charset) throws IOException
 263     {
 264         this(file, OPEN_READ, charset);
 265     }
 266 
 267     /**
 268      * Returns the zip file comment, or null if none.
 269      *
 270      * @return the comment string for the zip file, or null if none
 271      *
 272      * @throws IllegalStateException if the zip file has been closed
 273      *
 274      * Since 1.7
 275      */
 276     public String getComment() {
 277         synchronized (this) {
 278             ensureOpen();
 279             if (zsrc.comment == null) {
 280                 return null;
 281             }
 282             return zc.toString(zsrc.comment);
 283         }
 284     }
 285 
 286     /**
 287      * Returns the zip file entry for the specified name, or null
 288      * if not found.
 289      *
 290      * @param name the name of the entry
 291      * @return the zip file entry, or null if not found
 292      * @throws IllegalStateException if the zip file has been closed
 293      */
 294     public ZipEntry getEntry(String name) {
 295 
 296         Objects.requireNonNull(name, "name");
 297         synchronized (this) {
 298             ensureOpen();
 299             int pos = zsrc.getEntryPos(zc.getBytes(name), true);
 300             if (pos != -1) {
 301                 return getZipEntry(name, pos);
 302             }
 303         }
 304         return null;
 305     }
 306 
 307     // The outstanding inputstreams that need to be closed,
 308     // mapped to the inflater objects they use.
 309     private final Map<InputStream, Inflater> streams = new WeakHashMap<>();
 310 
 311     /**
 312      * Returns an input stream for reading the contents of the specified
 313      * zip file entry.
 314      * <p>
 315      * Closing this ZIP file will, in turn, close all input streams that
 316      * have been returned by invocations of this method.
 317      *
 318      * @param entry the zip file entry
 319      * @return the input stream for reading the contents of the specified
 320      * zip file entry.
 321      * @throws ZipException if a ZIP format error has occurred
 322      * @throws IOException if an I/O error has occurred
 323      * @throws IllegalStateException if the zip file has been closed
 324      */
 325     public InputStream getInputStream(ZipEntry entry) throws IOException {
 326         return getInputStream(entry, null);
 327     }
 328 
 329     /**
 330      * Returns an input stream for reading the contents of the specified
 331      * zip file entry.
 332      * <p>
 333      * Closing this ZIP file will, in turn, close all input streams that
 334      * have been returned by invocations of this method.
 335      *
 336      * @param entry the zip file entry
 337      * @param zipCryption instance of ZipCryption
 338      * @return the input stream for reading the contents of the specified
 339      * zip file entry.
 340      * @throws ZipException if a ZIP format error has occurred
 341      * @throws IOException if an I/O error has occurred
 342      * @throws IllegalStateException if the zip file has been closed
 343      */
 344     public InputStream getInputStream(ZipEntry entry, ZipCryption zipCryption)
 345                                                             throws IOException {
 346         Objects.requireNonNull(entry, "entry");
 347 
 348         if ((entry.flag & 1) == 1) {
 349             Objects.requireNonNull(entry, "Passphrase is required");
 350             zipCryption.reset();
 351         }
 352 
 353         int pos = -1;
 354         ZipFileInputStream in = null;
 355         synchronized (this) {
 356             ensureOpen();
 357             if (!zc.isUTF8() && (entry.flag & EFS) != 0) {
 358                 pos = zsrc.getEntryPos(zc.getBytesUTF8(entry.name), false);
 359             } else {
 360                 pos = zsrc.getEntryPos(zc.getBytes(entry.name), false);
 361             }
 362             if (pos == -1) {
 363                 return null;
 364             }
 365             in = new ZipFileInputStream(zsrc.cen, pos, zipCryption);
 366             switch (CENHOW(zsrc.cen, pos)) {
 367             case STORED:
 368                 if((entry.flag & 1) == 1) {
 369                    byte[] encryptionHeader =
 370                                 new byte[zipCryption.getEncryptionHeaderSize()];
 371                    in.readRaw(encryptionHeader, 0, encryptionHeader.length);
 372                    zipCryption.decryptBytes(encryptionHeader);
 373 
 374                    if (!zipCryption.isValid(entry, encryptionHeader)) {
 375                        throw new ZipException("possibly incorrect passphrase");
 376                    }
 377                 }
 378                 synchronized (streams) {
 379                     streams.put(in, null);
 380                 }
 381                 return in;
 382             case DEFLATED:
 383                 // Inflater likes a bit of slack
 384                 // MORE: Compute good size for inflater stream:
 385                 long size = CENLEN(zsrc.cen, pos) + 2;
 386                 if (size > 65536) {
 387                     size = 8192;
 388                 }
 389                 if (size <= 0) {
 390                     size = 4096;
 391                 }
 392                 Inflater inf = getInflater();
 393 
 394                 if((entry.flag & 1) == 1) {
 395                    byte[] encryptionHeader =
 396                                 new byte[zipCryption.getEncryptionHeaderSize()];
 397                    in.readRaw(encryptionHeader, 0, encryptionHeader.length);
 398                    zipCryption.decryptBytes(encryptionHeader);
 399 
 400                    if (!zipCryption.isValid(entry, encryptionHeader)) {
 401                        throw new ZipException("possibly incorrect passphrase");
 402                    }
 403                 }
 404 
 405                 InputStream is = new ZipFileInflaterInputStream(in, inf, (int)size);
 406                 synchronized (streams) {
 407                     streams.put(is, inf);
 408                 }
 409                 return is;
 410             default:
 411                 throw new ZipException("invalid compression method");
 412             }
 413         }
 414     }
 415 
 416     private class ZipFileInflaterInputStream extends InflaterInputStream {
 417         private volatile boolean closeRequested = false;
 418         private boolean eof = false;
 419         private final ZipFileInputStream zfin;
 420 
 421         ZipFileInflaterInputStream(ZipFileInputStream zfin, Inflater inf,
 422                 int size) {
 423             super(zfin, inf, size);
 424             this.zfin = zfin;
 425         }
 426 
 427         public void close() throws IOException {
 428             if (closeRequested)
 429                 return;
 430             closeRequested = true;
 431 
 432             super.close();
 433             Inflater inf;
 434             synchronized (streams) {
 435                 inf = streams.remove(this);
 436             }
 437             if (inf != null) {
 438                 releaseInflater(inf);
 439             }
 440         }
 441 
 442         // Override fill() method to provide an extra "dummy" byte
 443         // at the end of the input stream. This is required when
 444         // using the "nowrap" Inflater option.
 445         protected void fill() throws IOException {
 446             if (eof) {
 447                 throw new EOFException("Unexpected end of ZLIB input stream");
 448             }
 449             len = in.read(buf, 0, buf.length);
 450             if (len == -1) {
 451                 buf[0] = 0;
 452                 len = 1;
 453                 eof = true;
 454             }
 455             inf.setInput(buf, 0, len);
 456         }
 457 
 458         public int available() throws IOException {
 459             if (closeRequested)
 460                 return 0;
 461             long avail = zfin.size() - inf.getBytesWritten();
 462             return (avail > (long) Integer.MAX_VALUE ?
 463                     Integer.MAX_VALUE : (int) avail);
 464         }
 465 
 466         protected void finalize() throws Throwable {
 467             close();
 468         }
 469     }
 470 
 471     /*
 472      * Gets an inflater from the list of available inflaters or allocates
 473      * a new one.
 474      */
 475     private Inflater getInflater() {
 476         Inflater inf;
 477         synchronized (inflaterCache) {
 478             while ((inf = inflaterCache.poll()) != null) {
 479                 if (!inf.ended()) {
 480                     return inf;
 481                 }
 482             }
 483         }
 484         return new Inflater(true);
 485     }
 486 
 487     /*
 488      * Releases the specified inflater to the list of available inflaters.
 489      */
 490     private void releaseInflater(Inflater inf) {
 491         if (!inf.ended()) {
 492             inf.reset();
 493             synchronized (inflaterCache) {
 494                 inflaterCache.add(inf);
 495             }
 496         }
 497     }
 498 
 499     // List of available Inflater objects for decompression
 500     private final Deque<Inflater> inflaterCache = new ArrayDeque<>();
 501 
 502     /**
 503      * Returns the path name of the ZIP file.
 504      * @return the path name of the ZIP file
 505      */
 506     public String getName() {
 507         return name;
 508     }
 509 
 510     private class ZipEntryIterator implements Enumeration<ZipEntry>, Iterator<ZipEntry> {
 511         private int i = 0;
 512 
 513         public ZipEntryIterator() {
 514             ensureOpen();
 515         }
 516 
 517         public boolean hasMoreElements() {
 518             return hasNext();
 519         }
 520 
 521         public boolean hasNext() {
 522             synchronized (ZipFile.this) {
 523                 ensureOpen();
 524                 return i < zsrc.total;
 525             }
 526         }
 527 
 528         public ZipEntry nextElement() {
 529             return next();
 530         }
 531 
 532         public ZipEntry next() {
 533             synchronized (ZipFile.this) {
 534                 ensureOpen();
 535                 if (i >= zsrc.total) {
 536                     throw new NoSuchElementException();
 537                 }
 538                 // each "entry" has 3 ints in table entries
 539                 return getZipEntry(null, zsrc.getEntryPos(i++ * 3));
 540             }
 541         }
 542 
 543         public Iterator<ZipEntry> asIterator() {
 544             return this;
 545         }
 546     }
 547 
 548     /**
 549      * Returns an enumeration of the ZIP file entries.
 550      * @return an enumeration of the ZIP file entries
 551      * @throws IllegalStateException if the zip file has been closed
 552      */
 553     public Enumeration<? extends ZipEntry> entries() {
 554         return new ZipEntryIterator();
 555     }
 556 
 557     /**
 558      * Returns an ordered {@code Stream} over the ZIP file entries.
 559      * Entries appear in the {@code Stream} in the order they appear in
 560      * the central directory of the ZIP file.
 561      *
 562      * @return an ordered {@code Stream} of entries in this ZIP file
 563      * @throws IllegalStateException if the zip file has been closed
 564      * @since 1.8
 565      */
 566     public Stream<? extends ZipEntry> stream() {
 567         return StreamSupport.stream(Spliterators.spliterator(
 568                 new ZipEntryIterator(), size(),
 569                 Spliterator.ORDERED | Spliterator.DISTINCT |
 570                         Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
 571     }
 572 
 573     /* Checks ensureOpen() before invoke this method */
 574     private ZipEntry getZipEntry(String name, int pos) {
 575         byte[] cen = zsrc.cen;
 576         ZipEntry e = new ZipEntry();
 577         int nlen = CENNAM(cen, pos);
 578         int elen = CENEXT(cen, pos);
 579         int clen = CENCOM(cen, pos);
 580         e.flag = CENFLG(cen, pos);  // get the flag first
 581         if (name != null) {
 582             e.name = name;
 583         } else {
 584             if (!zc.isUTF8() && (e.flag & EFS) != 0) {
 585                 e.name = zc.toStringUTF8(cen, pos + CENHDR, nlen);
 586             } else {
 587                 e.name = zc.toString(cen, pos + CENHDR, nlen);
 588             }
 589         }
 590         e.xdostime = CENTIM(cen, pos);
 591         e.crc = CENCRC(cen, pos);
 592         e.size = CENLEN(cen, pos);
 593         e.csize = CENSIZ(cen, pos);
 594         e.method = CENHOW(cen, pos);
 595         if (elen != 0) {
 596             e.setExtra0(Arrays.copyOfRange(cen, pos + CENHDR + nlen,
 597                                            pos + CENHDR + nlen + elen), true);
 598         }
 599         if (clen != 0) {
 600             if (!zc.isUTF8() && (e.flag & EFS) != 0) {
 601                 e.comment = zc.toStringUTF8(cen, pos + CENHDR + nlen + elen, clen);
 602             } else {
 603                 e.comment = zc.toString(cen, pos + CENHDR + nlen + elen, clen);
 604             }
 605         }
 606         return e;
 607     }
 608 
 609     /**
 610      * Returns the number of entries in the ZIP file.
 611      *
 612      * @return the number of entries in the ZIP file
 613      * @throws IllegalStateException if the zip file has been closed
 614      */
 615     public int size() {
 616         synchronized (this) {
 617             ensureOpen();
 618             return zsrc.total;
 619         }
 620     }
 621 
 622     /**
 623      * Closes the ZIP file.
 624      * <p> Closing this ZIP file will close all of the input streams
 625      * previously returned by invocations of the {@link #getInputStream
 626      * getInputStream} method.
 627      *
 628      * @throws IOException if an I/O error has occurred
 629      */
 630     public void close() throws IOException {
 631         if (closeRequested) {
 632             return;
 633         }
 634         closeRequested = true;
 635 
 636         synchronized (this) {
 637             // Close streams, release their inflaters
 638             synchronized (streams) {
 639                 if (!streams.isEmpty()) {
 640                     Map<InputStream, Inflater> copy = new HashMap<>(streams);
 641                     streams.clear();
 642                     for (Map.Entry<InputStream, Inflater> e : copy.entrySet()) {
 643                         e.getKey().close();
 644                         Inflater inf = e.getValue();
 645                         if (inf != null) {
 646                             inf.end();
 647                         }
 648                     }
 649                 }
 650             }
 651             // Release cached inflaters
 652             synchronized (inflaterCache) {
 653                 Inflater inf;
 654                 while ((inf = inflaterCache.poll()) != null) {
 655                     inf.end();
 656                 }
 657             }
 658             // Release zip src
 659             if (zsrc != null) {
 660                 Source.close(zsrc);
 661                 zsrc = null;
 662             }
 663         }
 664     }
 665 
 666     /**
 667      * Ensures that the system resources held by this ZipFile object are
 668      * released when there are no more references to it.
 669      *
 670      * <p>
 671      * Since the time when GC would invoke this method is undetermined,
 672      * it is strongly recommended that applications invoke the {@code close}
 673      * method as soon they have finished accessing this {@code ZipFile}.
 674      * This will prevent holding up system resources for an undetermined
 675      * length of time.
 676      *
 677      * @throws IOException if an I/O error has occurred
 678      * @see    java.util.zip.ZipFile#close()
 679      */
 680     protected void finalize() throws IOException {
 681         close();
 682     }
 683 
 684     private void ensureOpen() {
 685         if (closeRequested) {
 686             throw new IllegalStateException("zip file closed");
 687         }
 688         if (zsrc == null) {
 689             throw new IllegalStateException("The object is not initialized.");
 690         }
 691     }
 692 
 693     private void ensureOpenOrZipException() throws IOException {
 694         if (closeRequested) {
 695             throw new ZipException("ZipFile closed");
 696         }
 697     }
 698 
 699     /*
 700      * Inner class implementing the input stream used to read a
 701      * (possibly compressed) zip file entry.
 702      */
 703    private class ZipFileInputStream extends InputStream {
 704         private volatile boolean closeRequested = false;
 705         private   long pos;     // current position within entry data
 706         protected long rem;     // number of remaining bytes within entry
 707         protected long size;    // uncompressed size of this entry
 708         private ZipCryption zipCryption; // ZIP encrypt/decrypt engine
 709 
 710         ZipFileInputStream(byte[] cen, int cenpos, ZipCryption zipCryption)
 711                                                             throws IOException {
 712             rem = CENSIZ(cen, cenpos);
 713             size = CENLEN(cen, cenpos);
 714             pos = CENOFF(cen, cenpos);
 715             // zip64
 716             if (rem == ZIP64_MAGICVAL || size == ZIP64_MAGICVAL ||
 717                 pos == ZIP64_MAGICVAL) {
 718                 checkZIP64(cen, cenpos);
 719             }
 720             // negative for lazy initialization, see getDataOffset();
 721             pos = - (pos + ZipFile.this.zsrc.locpos);
 722             this.zipCryption = zipCryption;
 723         }
 724 
 725         private void checkZIP64(byte[] cen, int cenpos) throws IOException {
 726             int off = cenpos + CENHDR + CENNAM(cen, cenpos);
 727             int end = off + CENEXT(cen, cenpos);
 728             while (off + 4 < end) {
 729                 int tag = get16(cen, off);
 730                 int sz = get16(cen, off + 2);
 731                 off += 4;
 732                 if (off + sz > end)         // invalid data
 733                     break;
 734                 if (tag == EXTID_ZIP64) {
 735                     if (size == ZIP64_MAGICVAL) {
 736                         if (sz < 8 || (off + 8) > end)
 737                             break;
 738                         size = get64(cen, off);
 739                         sz -= 8;
 740                         off += 8;
 741                     }
 742                     if (rem == ZIP64_MAGICVAL) {
 743                         if (sz < 8 || (off + 8) > end)
 744                             break;
 745                         rem = get64(cen, off);
 746                         sz -= 8;
 747                         off += 8;
 748                     }
 749                     if (pos == ZIP64_MAGICVAL) {
 750                         if (sz < 8 || (off + 8) > end)
 751                             break;
 752                         pos = get64(cen, off);
 753                         sz -= 8;
 754                         off += 8;
 755                     }
 756                     break;
 757                 }
 758                 off += sz;
 759             }
 760         }
 761 
 762        /* The Zip file spec explicitly allows the LOC extra data size to
 763         * be different from the CEN extra data size. Since we cannot trust
 764         * the CEN extra data size, we need to read the LOC to determine
 765         * the entry data offset.
 766         */
 767         private long initDataOffset() throws IOException {
 768             if (pos <= 0) {
 769                 byte[] loc = new byte[LOCHDR];
 770                 pos = -pos;
 771                 int len = ZipFile.this.zsrc.readFullyAt(loc, 0, loc.length, pos);
 772                 if (len != LOCHDR) {
 773                     throw new ZipException("ZipFile error reading zip file");
 774                 }
 775                 if (LOCSIG(loc) != LOCSIG) {
 776                     throw new ZipException("ZipFile invalid LOC header (bad signature)");
 777                 }
 778                 pos += LOCHDR + LOCNAM(loc) + LOCEXT(loc);
 779             }
 780             return pos;
 781         }
 782 
 783         public int read(byte b[], int off, int len) throws IOException {
 784             len = readRaw(b, off, len);
 785 
 786             if (zipCryption != null) {
 787                 zipCryption.decryptBytes(b, off, len);
 788             }
 789 
 790             return len;
 791         }
 792 
 793         public int readRaw(byte b[], int off, int len) throws IOException {
 794             synchronized (ZipFile.this) {
 795                 ensureOpenOrZipException();
 796                 initDataOffset();
 797                 if (rem == 0) {
 798                     return -1;
 799                 }
 800                 if (len > rem) {
 801                     len = (int) rem;
 802                 }
 803                 if (len <= 0) {
 804                     return 0;
 805                 }
 806                 len = ZipFile.this.zsrc.readAt(b, off, len, pos);
 807                 if (len > 0) {
 808                     pos += len;
 809                     rem -= len;
 810                 }
 811             }
 812             if (rem == 0) {
 813                 close();
 814             }
 815             return len;
 816         }
 817 
 818         public int read() throws IOException {
 819             byte[] b = new byte[1];
 820             if (read(b, 0, 1) == 1) {
 821                 return b[0] & 0xff;
 822             } else {
 823                 return -1;
 824             }
 825         }
 826 
 827         public long skip(long n) throws IOException {
 828             synchronized (ZipFile.this) {
 829                 ensureOpenOrZipException();
 830                 initDataOffset();
 831                 if (n > rem) {
 832                     n = rem;
 833                 }
 834                 pos += n;
 835                 rem -= n;
 836             }
 837             if (rem == 0) {
 838                 close();
 839             }
 840             return n;
 841         }
 842 
 843         public int available() {
 844             return rem > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) rem;
 845         }
 846 
 847         public long size() {
 848             return size;
 849         }
 850 
 851         public void close() {
 852             if (closeRequested) {
 853                 return;
 854             }
 855             closeRequested = true;
 856             rem = 0;
 857             synchronized (streams) {
 858                 streams.remove(this);
 859             }
 860         }
 861 
 862         protected void finalize() {
 863             close();
 864         }
 865     }
 866 
 867     static {
 868         SharedSecrets.setJavaUtilZipFileAccess(
 869             new JavaUtilZipFileAccess() {
 870                 public boolean startsWithLocHeader(ZipFile zip) {
 871                     return zip.zsrc.startsWithLoc;
 872                 }
 873                 public String[] getMetaInfEntryNames(ZipFile zip) {
 874                     return zip.getMetaInfEntryNames();
 875                 }
 876              }
 877         );
 878     }
 879 
 880     /*
 881      * Returns an array of strings representing the names of all entries
 882      * that begin with "META-INF/" (case ignored). This method is used
 883      * in JarFile, via SharedSecrets, as an optimization when looking up
 884      * manifest and signature file entries. Returns null if no entries
 885      * were found.
 886      */
 887     private String[] getMetaInfEntryNames() {
 888         synchronized (this) {
 889             ensureOpen();
 890             if (zsrc.metanames.size() == 0) {
 891                 return null;
 892             }
 893             String[] names = new String[zsrc.metanames.size()];
 894             byte[] cen = zsrc.cen;
 895             for (int i = 0; i < names.length; i++) {
 896                 int pos = zsrc.metanames.get(i);
 897                 names[i] = new String(cen, pos + CENHDR,  CENNAM(cen, pos),
 898                                       StandardCharsets.UTF_8);
 899             }
 900             return names;
 901         }
 902     }
 903 
 904     private static class Source {
 905         private final Key key;               // the key in files
 906         private int refs = 1;
 907 
 908         private RandomAccessFile zfile;      // zfile of the underlying zip file
 909         private byte[] cen;                  // CEN & ENDHDR
 910         private long locpos;                 // position of first LOC header (usually 0)
 911         private byte[] comment;              // zip file comment
 912                                              // list of meta entries in META-INF dir
 913         private ArrayList<Integer> metanames = new ArrayList<>();
 914         private final boolean startsWithLoc; // true, if zip file starts with LOCSIG (usually true)
 915 
 916         // A Hashmap for all entries.
 917         //
 918         // A cen entry of Zip/JAR file. As we have one for every entry in every active Zip/JAR,
 919         // We might have a lot of these in a typical system. In order to save space we don't
 920         // keep the name in memory, but merely remember a 32 bit {@code hash} value of the
 921         // entry name and its offset {@code pos} in the central directory hdeader.
 922         //
 923         // private static class Entry {
 924         //     int hash;       // 32 bit hashcode on name
 925         //     int next;       // hash chain: index into entries
 926         //     int pos;        // Offset of central directory file header
 927         // }
 928         // private Entry[] entries;             // array of hashed cen entry
 929         //
 930         // To reduce the total size of entries further, we use a int[] here to store 3 "int"
 931         // {@code hash}, {@code next and {@code "pos for each entry. The entry can then be
 932         // referred by their index of their positions in the {@code entries}.
 933         //
 934         private int[] entries;                  // array of hashed cen entry
 935         private int addEntry(int index, int hash, int next, int pos) {
 936             entries[index++] = hash;
 937             entries[index++] = next;
 938             entries[index++] = pos;
 939             return index;
 940         }
 941         private int getEntryHash(int index) { return entries[index]; }
 942         private int getEntryNext(int index) { return entries[index + 1]; }
 943         private int getEntryPos(int index)  { return entries[index + 2]; }
 944         private static final int ZIP_ENDCHAIN  = -1;
 945         private int total;                   // total number of entries
 946         private int[] table;                 // Hash chain heads: indexes into entries
 947         private int tablelen;                // number of hash heads
 948 
 949         private static class Key {
 950             BasicFileAttributes attrs;
 951             File file;
 952 
 953             public Key(File file, BasicFileAttributes attrs) {
 954                 this.attrs = attrs;
 955                 this.file = file;
 956             }
 957 
 958             public int hashCode() {
 959                 long t = attrs.lastModifiedTime().toMillis();
 960                 return ((int)(t ^ (t >>> 32))) + file.hashCode();
 961             }
 962 
 963             public boolean equals(Object obj) {
 964                 if (obj instanceof Key) {
 965                     Key key = (Key)obj;
 966                     if (!attrs.lastModifiedTime().equals(key.attrs.lastModifiedTime())) {
 967                         return false;
 968                     }
 969                     Object fk = attrs.fileKey();
 970                     if (fk != null) {
 971                         return  fk.equals(key.attrs.fileKey());
 972                     } else {
 973                         return file.equals(key.file);
 974                     }
 975                 }
 976                 return false;
 977             }
 978         }
 979         private static final HashMap<Key, Source> files = new HashMap<>();
 980 
 981 
 982         public static Source get(File file, boolean toDelete) throws IOException {
 983             Key key = new Key(file,
 984                               Files.readAttributes(file.toPath(), BasicFileAttributes.class));
 985             Source src = null;
 986             synchronized (files) {
 987                 src = files.get(key);
 988                 if (src != null) {
 989                     src.refs++;
 990                     return src;
 991                 }
 992             }
 993             src = new Source(key, toDelete);
 994 
 995             synchronized (files) {
 996                 if (files.containsKey(key)) {    // someone else put in first
 997                     src.close();                 // close the newly created one
 998                     src = files.get(key);
 999                     src.refs++;
1000                     return src;
1001                 }
1002                 files.put(key, src);
1003                 return src;
1004             }
1005         }
1006 
1007         private static void close(Source src) throws IOException {
1008             synchronized (files) {
1009                 if (--src.refs == 0) {
1010                     files.remove(src.key);
1011                     src.close();
1012                 }
1013             }
1014         }
1015 
1016         private Source(Key key, boolean toDelete) throws IOException {
1017             this.key = key;
1018             this.zfile = new RandomAccessFile(key.file, "r");
1019             if (toDelete) {
1020                 key.file.delete();
1021             }
1022             try {
1023                 initCEN(-1);
1024                 byte[] buf = new byte[4];
1025                 readFullyAt(buf, 0, 4, 0);
1026                 this.startsWithLoc = (LOCSIG(buf) == LOCSIG);
1027             } catch (IOException x) {
1028                 try {
1029                     this.zfile.close();
1030                 } catch (IOException xx) {}
1031                 throw x;
1032             }
1033         }
1034 
1035         private void close() throws IOException {
1036             zfile.close();
1037             zfile = null;
1038             cen = null;
1039             entries = null;
1040             table = null;
1041             metanames = null;
1042         }
1043 
1044         private static final int BUF_SIZE = 8192;
1045         private final int readFullyAt(byte[] buf, int off, int len, long pos)
1046             throws IOException
1047         {
1048             synchronized(zfile) {
1049                 zfile.seek(pos);
1050                 int N = len;
1051                 while (N > 0) {
1052                     int n = Math.min(BUF_SIZE, N);
1053                     zfile.readFully(buf, off, n);
1054                     off += n;
1055                     N -= n;
1056                 }
1057                 return len;
1058             }
1059         }
1060 
1061         private final int readAt(byte[] buf, int off, int len, long pos)
1062             throws IOException
1063         {
1064             synchronized(zfile) {
1065                 zfile.seek(pos);
1066                 return zfile.read(buf, off, len);
1067             }
1068         }
1069 
1070         private static final int hashN(byte[] a, int off, int len) {
1071             int h = 1;
1072             while (len-- > 0) {
1073                 h = 31 * h + a[off++];
1074             }
1075             return h;
1076         }
1077 
1078         private static final int hash_append(int hash, byte b) {
1079             return hash * 31 + b;
1080         }
1081 
1082         private static class End {
1083             int  centot;     // 4 bytes
1084             long cenlen;     // 4 bytes
1085             long cenoff;     // 4 bytes
1086             long endpos;     // 4 bytes
1087         }
1088 
1089         /*
1090          * Searches for end of central directory (END) header. The contents of
1091          * the END header will be read and placed in endbuf. Returns the file
1092          * position of the END header, otherwise returns -1 if the END header
1093          * was not found or an error occurred.
1094          */
1095         private End findEND() throws IOException {
1096             long ziplen = zfile.length();
1097             if (ziplen <= 0)
1098                 zerror("zip file is empty");
1099             End end = new End();
1100             byte[] buf = new byte[READBLOCKSZ];
1101             long minHDR = (ziplen - END_MAXLEN) > 0 ? ziplen - END_MAXLEN : 0;
1102             long minPos = minHDR - (buf.length - ENDHDR);
1103             for (long pos = ziplen - buf.length; pos >= minPos; pos -= (buf.length - ENDHDR)) {
1104                 int off = 0;
1105                 if (pos < 0) {
1106                     // Pretend there are some NUL bytes before start of file
1107                     off = (int)-pos;
1108                     Arrays.fill(buf, 0, off, (byte)0);
1109                 }
1110                 int len = buf.length - off;
1111                 if (readFullyAt(buf, off, len, pos + off) != len ) {
1112                     zerror("zip END header not found");
1113                 }
1114                 // Now scan the block backwards for END header signature
1115                 for (int i = buf.length - ENDHDR; i >= 0; i--) {
1116                     if (buf[i+0] == (byte)'P'    &&
1117                         buf[i+1] == (byte)'K'    &&
1118                         buf[i+2] == (byte)'\005' &&
1119                         buf[i+3] == (byte)'\006') {
1120                         // Found ENDSIG header
1121                         byte[] endbuf = Arrays.copyOfRange(buf, i, i + ENDHDR);
1122                         end.centot = ENDTOT(endbuf);
1123                         end.cenlen = ENDSIZ(endbuf);
1124                         end.cenoff = ENDOFF(endbuf);
1125                         end.endpos = pos + i;
1126                         int comlen = ENDCOM(endbuf);
1127                         if (end.endpos + ENDHDR + comlen != ziplen) {
1128                             // ENDSIG matched, however the size of file comment in it does
1129                             // not match the real size. One "common" cause for this problem
1130                             // is some "extra" bytes are padded at the end of the zipfile.
1131                             // Let's do some extra verification, we don't care about the
1132                             // performance in this situation.
1133                             byte[] sbuf = new byte[4];
1134                             long cenpos = end.endpos - end.cenlen;
1135                             long locpos = cenpos - end.cenoff;
1136                             if  (cenpos < 0 ||
1137                                  locpos < 0 ||
1138                                  readFullyAt(sbuf, 0, sbuf.length, cenpos) != 4 ||
1139                                  GETSIG(sbuf) != CENSIG ||
1140                                  readFullyAt(sbuf, 0, sbuf.length, locpos) != 4 ||
1141                                  GETSIG(sbuf) != LOCSIG) {
1142                                 continue;
1143                             }
1144                         }
1145                         if (comlen > 0) {    // this zip file has comlen
1146                             comment = new byte[comlen];
1147                             if (readFullyAt(comment, 0, comlen, end.endpos + ENDHDR) != comlen) {
1148                                 zerror("zip comment read failed");
1149                             }
1150                         }
1151                         if (end.cenlen == ZIP64_MAGICVAL ||
1152                             end.cenoff == ZIP64_MAGICVAL ||
1153                             end.centot == ZIP64_MAGICCOUNT)
1154                         {
1155                             // need to find the zip64 end;
1156                             try {
1157                                 byte[] loc64 = new byte[ZIP64_LOCHDR];
1158                                 if (readFullyAt(loc64, 0, loc64.length, end.endpos - ZIP64_LOCHDR)
1159                                     != loc64.length || GETSIG(loc64) != ZIP64_LOCSIG) {
1160                                     return end;
1161                                 }
1162                                 long end64pos = ZIP64_LOCOFF(loc64);
1163                                 byte[] end64buf = new byte[ZIP64_ENDHDR];
1164                                 if (readFullyAt(end64buf, 0, end64buf.length, end64pos)
1165                                     != end64buf.length || GETSIG(end64buf) != ZIP64_ENDSIG) {
1166                                     return end;
1167                                 }
1168                                 // end64 found, re-calcualte everything.
1169                                 end.cenlen = ZIP64_ENDSIZ(end64buf);
1170                                 end.cenoff = ZIP64_ENDOFF(end64buf);
1171                                 end.centot = (int)ZIP64_ENDTOT(end64buf); // assume total < 2g
1172                                 end.endpos = end64pos;
1173                             } catch (IOException x) {}    // no zip64 loc/end
1174                         }
1175                         return end;
1176                     }
1177                 }
1178             }
1179             zerror("zip END header not found");
1180             return null; //make compiler happy
1181         }
1182 
1183         // Reads zip file central directory.
1184         private void initCEN(int knownTotal) throws IOException {
1185             if (knownTotal == -1) {
1186                 End end = findEND();
1187                 if (end.endpos == 0) {
1188                     locpos = 0;
1189                     total = 0;
1190                     entries  = new int[0];
1191                     cen = null;
1192                     return;         // only END header present
1193                 }
1194                 if (end.cenlen > end.endpos)
1195                     zerror("invalid END header (bad central directory size)");
1196                 long cenpos = end.endpos - end.cenlen;     // position of CEN table
1197                 // Get position of first local file (LOC) header, taking into
1198                 // account that there may be a stub prefixed to the zip file.
1199                 locpos = cenpos - end.cenoff;
1200                 if (locpos < 0) {
1201                     zerror("invalid END header (bad central directory offset)");
1202                 }
1203                 // read in the CEN and END
1204                 cen = new byte[(int)(end.cenlen + ENDHDR)];
1205                 if (readFullyAt(cen, 0, cen.length, cenpos) != end.cenlen + ENDHDR) {
1206                     zerror("read CEN tables failed");
1207                 }
1208                 total = end.centot;
1209             } else {
1210                 total = knownTotal;
1211             }
1212             // hash table for entries
1213             entries  = new int[total * 3];
1214             tablelen = ((total/2) | 1); // Odd -> fewer collisions
1215             table    =  new int[tablelen];
1216             Arrays.fill(table, ZIP_ENDCHAIN);
1217             int idx = 0;
1218             int hash = 0;
1219             int next = -1;
1220 
1221             // list for all meta entries
1222             metanames = new ArrayList<>();
1223 
1224             // Iterate through the entries in the central directory
1225             int i = 0;
1226             int hsh = 0;
1227             int pos = 0;
1228             int limit = cen.length - ENDHDR;
1229             while (pos + CENHDR  <= limit) {
1230                 if (i >= total) {
1231                     // This will only happen if the zip file has an incorrect
1232                     // ENDTOT field, which usually means it contains more than
1233                     // 65535 entries.
1234                     initCEN(countCENHeaders(cen, limit));
1235                     return;
1236                 }
1237                 if (CENSIG(cen, pos) != CENSIG)
1238                     zerror("invalid CEN header (bad signature)");
1239                 int method = CENHOW(cen, pos);
1240                 int nlen   = CENNAM(cen, pos);
1241                 int elen   = CENEXT(cen, pos);
1242                 int clen   = CENCOM(cen, pos);


1243                 if (method != STORED && method != DEFLATED)
1244                     zerror("invalid CEN header (bad compression method: " + method + ")");
1245                 if (pos + CENHDR + nlen > limit)
1246                     zerror("invalid CEN header (bad header size)");
1247                 // Record the CEN offset and the name hash in our hash cell.
1248                 hash = hashN(cen, pos + CENHDR, nlen);
1249                 hsh = (hash & 0x7fffffff) % tablelen;
1250                 next = table[hsh];
1251                 table[hsh] = idx;
1252                 idx = addEntry(idx, hash, next, pos);
1253                 // Adds name to metanames.
1254                 if (isMetaName(cen, pos + CENHDR, nlen)) {
1255                     metanames.add(pos);
1256                 }
1257                 // skip ext and comment
1258                 pos += (CENHDR + nlen + elen + clen);
1259                 i++;
1260             }
1261             total = i;
1262             if (pos + ENDHDR != cen.length) {
1263                 zerror("invalid CEN header (bad header size)");
1264             }
1265         }
1266 
1267         private static void zerror(String msg) throws ZipException {
1268             throw new ZipException(msg);
1269         }
1270 
1271         /*
1272          * Returns the {@code pos} of the zip cen entry corresponding to the
1273          * specified entry name, or -1 if not found.
1274          */
1275         private int getEntryPos(byte[] name, boolean addSlash) {
1276             if (total == 0) {
1277                 return -1;
1278             }
1279             int hsh = hashN(name, 0, name.length);
1280             int idx = table[(hsh & 0x7fffffff) % tablelen];
1281             /*
1282              * This while loop is an optimization where a double lookup
1283              * for name and name+/ is being performed. The name char
1284              * array has enough room at the end to try again with a
1285              * slash appended if the first table lookup does not succeed.
1286              */
1287             while(true) {
1288                 /*
1289                  * Search down the target hash chain for a entry whose
1290                  * 32 bit hash matches the hashed name.
1291                  */
1292                 while (idx != ZIP_ENDCHAIN) {
1293                     if (getEntryHash(idx) == hsh) {
1294                         // The CEN name must match the specfied one
1295                         int pos = getEntryPos(idx);
1296                         if (name.length == CENNAM(cen, pos)) {
1297                             boolean matched = true;
1298                             int nameoff = pos + CENHDR;
1299                             for (int i = 0; i < name.length; i++) {
1300                                 if (name[i] != cen[nameoff++]) {
1301                                     matched = false;
1302                                     break;
1303                                 }
1304                             }
1305                             if (matched) {
1306                                 return pos;
1307                             }
1308                          }
1309                     }
1310                     idx = getEntryNext(idx);
1311                 }
1312                 /* If not addSlash, or slash is already there, we are done */
1313                 if (!addSlash  || name[name.length - 1] == '/') {
1314                      return -1;
1315                 }
1316                 /* Add slash and try once more */
1317                 name = Arrays.copyOf(name, name.length + 1);
1318                 name[name.length - 1] = '/';
1319                 hsh = hash_append(hsh, (byte)'/');
1320                 //idx = table[hsh % tablelen];
1321                 idx = table[(hsh & 0x7fffffff) % tablelen];
1322                 addSlash = false;
1323             }
1324         }
1325 
1326         private static byte[] metainf = new byte[] {
1327             'M', 'E', 'T', 'A', '-', 'I' , 'N', 'F', '/',
1328         };
1329 
1330         /*
1331          * Returns true if the specified entry's name begins with the string
1332          * "META-INF/" irrespective of case.
1333          */
1334         private static boolean isMetaName(byte[] name,  int off, int len) {
1335             if (len < 9 || (name[off] != 'M' && name[off] != 'm')) {  //  sizeof("META-INF/") - 1
1336                 return false;
1337             }
1338             off++;
1339             for (int i = 1; i < metainf.length; i++) {
1340                 byte c = name[off++];
1341                 // Avoid toupper; it's locale-dependent
1342                 if (c >= 'a' && c <= 'z') {
1343                     c += 'A' - 'a';
1344                 }
1345                 if (metainf[i] != c) {
1346                     return false;
1347                 }
1348             }
1349             return true;
1350         }
1351 
1352         /*
1353          * Counts the number of CEN headers in a central directory extending
1354          * from BEG to END.  Might return a bogus answer if the zip file is
1355          * corrupt, but will not crash.
1356          */
1357         static int countCENHeaders(byte[] cen, int end) {
1358             int count = 0;
1359             int pos = 0;
1360             while (pos + CENHDR <= end) {
1361                 count++;
1362                 pos += (CENHDR + CENNAM(cen, pos) + CENEXT(cen, pos) + CENCOM(cen, pos));
1363             }
1364             return count;
1365         }
1366     }
1367 }
--- EOF ---