    001/*
    002 *  Licensed to the Apache Software Foundation (ASF) under one or more
    003 *  contributor license agreements.  See the NOTICE file distributed with
    004 *  this work for additional information regarding copyright ownership.
    005 *  The ASF licenses this file to You under the Apache License, Version 2.0
    006 *  (the "License"); you may not use this file except in compliance with
    007 *  the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 *  Unless required by applicable law or agreed to in writing, software
    012 *  distributed under the License is distributed on an "AS IS" BASIS,
    013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 *  See the License for the specific language governing permissions and
    015 *  limitations under the License.
    016 *
    017 */
    018package org.apache.commons.compress.archivers.zip;
    019
    020/**
    021 * Parser/encoder for the "general purpose bit" field in ZIP's local
    022 * file and central directory headers.
    023 *
    024 * @since 1.1
    025 * @NotThreadSafe
    026 */
    027public final class GeneralPurposeBit implements Cloneable {
    028
    029    /**
    030     * Indicates that the file is encrypted.
    031     */
    032    private static final int ENCRYPTION_FLAG = 1 << 0;
    033
    034    /**
    035     * Indicates the size of the sliding dictionary used by the compression method 6 (imploding).
    036     * <ul>
    037     *   <li>0: 4096 bytes</li>
    038     *   <li>1: 8192 bytes</li>
    039     * </ul>
    040     */
    041    private static final int SLIDING_DICTIONARY_SIZE_FLAG = 1 << 1;
    042
    043    /**
    044     * Indicates the number of Shannon-Fano trees used by the compression method 6 (imploding).
    045     * <ul>
    046     *   <li>0: 2 trees (lengths, distances)</li>
    047     *   <li>1: 3 trees (literals, lengths, distances)</li>
    048     * </ul>
    049     */
    050    private static final int NUMBER_OF_SHANNON_FANO_TREES_FLAG = 1 << 2;
    051
    052    /**
    053     * Indicates that a data descriptor stored after the file contents
    054     * will hold CRC and size information.
    055     */
    056    private static final int DATA_DESCRIPTOR_FLAG = 1 << 3;
    057
    058    /**
    059     * Indicates strong encryption.
    060     */
    061    private static final int STRONG_ENCRYPTION_FLAG = 1 << 6;
    062
    063    /**
    064     * Indicates that file names are written in UTF-8.
    065     *
    066     * <p>The only reason this is public is that {@link
    067     * ZipArchiveOutputStream#EFS_FLAG} was public in Apache Commons
    068     * Compress 1.0 and we needed a substitute for it.</p>
    069     */
    070    public static final int UFT8_NAMES_FLAG = 1 << 11;
    071
    072    /**
    073     * Parses the supported flags from the given archive data.
    074     *
    075     * @param data local file header or a central directory entry.
    076     * @param offset offset at which the general purpose bit starts
    077     * @return parsed flags
    078     */
    079    public static GeneralPurposeBit parse(final byte[] data, final int offset) {
    080        final int generalPurposeFlag = ZipShort.getValue(data, offset);
    081        final GeneralPurposeBit b = new GeneralPurposeBit();
    082        b.useDataDescriptor((generalPurposeFlag & DATA_DESCRIPTOR_FLAG) != 0);
    083        b.useUTF8ForNames((generalPurposeFlag & UFT8_NAMES_FLAG) != 0);
    084        b.useStrongEncryption((generalPurposeFlag & STRONG_ENCRYPTION_FLAG) != 0);
    085        b.useEncryption((generalPurposeFlag & ENCRYPTION_FLAG) != 0);
    086        b.slidingDictionarySize = (generalPurposeFlag & SLIDING_DICTIONARY_SIZE_FLAG) != 0 ? 8192 : 4096;
    087        b.numberOfShannonFanoTrees = (generalPurposeFlag & NUMBER_OF_SHANNON_FANO_TREES_FLAG) != 0 ? 3 : 2;
    088        return b;
    089    }
    090    private boolean languageEncodingFlag;
    091    private boolean dataDescriptorFlag;
    092    private boolean encryptionFlag;
    093    private boolean strongEncryptionFlag;
    094    private int slidingDictionarySize;
    095
    096    private int numberOfShannonFanoTrees;
    097
    098    public GeneralPurposeBit() {
    099    }
    100
    101    @Override
    102    public Object clone() {
    103        try {
    104            return super.clone();
    105        } catch (final CloneNotSupportedException ex) {
    106            // impossible
    107            throw new IllegalStateException("GeneralPurposeBit is not Cloneable?", ex); //NOSONAR
    108        }
    109    }
    110
    111    /**
    112     * Encodes the set bits in a form suitable for ZIP archives.
    113     * @return the encoded general purpose bits
    114     */
    115    public byte[] encode() {
    116        final byte[] result = new byte[2];
    117        encode(result, 0);
    118        return result;
    119    }
    120
    121    /**
    122     * Encodes the set bits in a form suitable for ZIP archives.
    123     *
    124     * @param buf the output buffer
    125     * @param  offset
    126     *         The offset within the output buffer of the first byte to be written.
    127     *         must be non-negative and no larger than {@code buf.length-2}
    128     */
    129    public void encode(final byte[] buf, final int offset) {
    130                ZipShort.putShort((dataDescriptorFlag ? DATA_DESCRIPTOR_FLAG : 0)
    131                        |
    132                        (languageEncodingFlag ? UFT8_NAMES_FLAG : 0)
    133                        |
    134                        (encryptionFlag ? ENCRYPTION_FLAG : 0)
    135                        |
    136                        (strongEncryptionFlag ? STRONG_ENCRYPTION_FLAG : 0)
    137                        , buf, offset);
    138    }
    139
    140    @Override
    141    public boolean equals(final Object o) {
    142        if (!(o instanceof GeneralPurposeBit)) {
    143            return false;
    144        }
    145        final GeneralPurposeBit g = (GeneralPurposeBit) o;
    146        return g.encryptionFlag == encryptionFlag
    147            && g.strongEncryptionFlag == strongEncryptionFlag
    148            && g.languageEncodingFlag == languageEncodingFlag
    149            && g.dataDescriptorFlag == dataDescriptorFlag;
    150    }
    151
    152    /**
    153     * Returns the number of trees used by the compression method 6 (imploding).
    154     */
    155    int getNumberOfShannonFanoTrees() {
    156        return numberOfShannonFanoTrees;
    157    }
    158
    159    /**
    160     * Returns the sliding dictionary size used by the compression method 6 (imploding).
    161     */
    162    int getSlidingDictionarySize() {
    163        return slidingDictionarySize;
    164    }
    165
    166    @Override
    167    public int hashCode() {
    168        return 3 * (7 * (13 * (17 * (encryptionFlag ? 1 : 0)
    169                               + (strongEncryptionFlag ? 1 : 0))
    170                         + (languageEncodingFlag ? 1 : 0))
    171                    + (dataDescriptorFlag ? 1 : 0));
    172    }
    173
    174    /**
    175     * whether the current entry will use the data descriptor to store
    176     * CRC and size information.
    177     * @param b whether the current entry will use the data descriptor to store
    178     * CRC and size information
    179     */
    180    public void useDataDescriptor(final boolean b) {
    181        dataDescriptorFlag = b;
    182    }
    183
    184    /**
    185     * whether the current entry will be encrypted.
    186     * @param b whether the current entry will be encrypted
    187     */
    188    public void useEncryption(final boolean b) {
    189        encryptionFlag = b;
    190    }
    191
    192    /**
    193     * whether the current entry uses the data descriptor to store CRC
    194     * and size information.
    195     * @return whether the current entry uses the data descriptor to store CRC
    196     * and size information
    197     */
    198    public boolean usesDataDescriptor() {
    199        return dataDescriptorFlag;
    200    }
    201
    202
    203    /**
    204     * whether the current entry is encrypted.
    205     * @return whether the current entry is encrypted
    206     */
    207    public boolean usesEncryption() {
    208        return encryptionFlag;
    209    }
    210
    211    /**
    212     * whether the current entry is encrypted using strong encryption.
    213     * @return whether the current entry is encrypted using strong encryption
    214     */
    215    public boolean usesStrongEncryption() {
    216        return encryptionFlag && strongEncryptionFlag;
    217    }
    218
    219    /**
    220     * whether the current entry will be encrypted  using strong encryption.
    221     * @param b whether the current entry will be encrypted  using strong encryption
    222     */
    223    public void useStrongEncryption(final boolean b) {
    224        strongEncryptionFlag = b;
    225        if (b) {
    226            useEncryption(true);
    227        }
    228    }
    229
    230    /**
    231     * whether the current entry uses UTF8 for file name and comment.
    232     * @return whether the current entry uses UTF8 for file name and comment.
    233     */
    234    public boolean usesUTF8ForNames() {
    235        return languageEncodingFlag;
    236    }
    237
    238    /**
    239     * whether the current entry will use UTF8 for file name and comment.
    240     * @param b whether the current entry will use UTF8 for file name and comment.
    241     */
    242    public void useUTF8ForNames(final boolean b) {
    243        languageEncodingFlag = b;
    244    }
    245}