    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 filenames 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    private boolean languageEncodingFlag = false;
    073    private boolean dataDescriptorFlag = false;
    074    private boolean encryptionFlag = false;
    075    private boolean strongEncryptionFlag = false;
    076    private int slidingDictionarySize;
    077    private int numberOfShannonFanoTrees;
    078
    079    public GeneralPurposeBit() {
    080    }
    081
    082    /**
    083     * whether the current entry uses UTF8 for file name and comment.
    084     * @return whether the current entry uses UTF8 for file name and comment.
    085     */
    086    public boolean usesUTF8ForNames() {
    087        return languageEncodingFlag;
    088    }
    089
    090    /**
    091     * whether the current entry will use UTF8 for file name and comment.
    092     * @param b whether the current entry will use UTF8 for file name and comment.
    093     */
    094    public void useUTF8ForNames(final boolean b) {
    095        languageEncodingFlag = b;
    096    }
    097
    098    /**
    099     * whether the current entry uses the data descriptor to store CRC
    100     * and size information.
    101     * @return whether the current entry uses the data descriptor to store CRC
    102     * and size information
    103     */
    104    public boolean usesDataDescriptor() {
    105        return dataDescriptorFlag;
    106    }
    107
    108    /**
    109     * whether the current entry will use the data descriptor to store
    110     * CRC and size information.
    111     * @param b whether the current entry will use the data descriptor to store
    112     * CRC and size information
    113     */
    114    public void useDataDescriptor(final boolean b) {
    115        dataDescriptorFlag = b;
    116    }
    117
    118    /**
    119     * whether the current entry is encrypted.
    120     * @return whether the current entry is encrypted
    121     */
    122    public boolean usesEncryption() {
    123        return encryptionFlag;
    124    }
    125
    126    /**
    127     * whether the current entry will be encrypted.
    128     * @param b whether the current entry will be encrypted
    129     */
    130    public void useEncryption(final boolean b) {
    131        encryptionFlag = b;
    132    }
    133
    134    /**
    135     * whether the current entry is encrypted using strong encryption.
    136     * @return whether the current entry is encrypted using strong encryption
    137     */
    138    public boolean usesStrongEncryption() {
    139        return encryptionFlag && strongEncryptionFlag;
    140    }
    141
    142    /**
    143     * whether the current entry will be encrypted  using strong encryption.
    144     * @param b whether the current entry will be encrypted  using strong encryption
    145     */
    146    public void useStrongEncryption(final boolean b) {
    147        strongEncryptionFlag = b;
    148        if (b) {
    149            useEncryption(true);
    150        }
    151    }
    152
    153    /**
    154     * Returns the sliding dictionary size used by the compression method 6 (imploding).
    155     */
    156    int getSlidingDictionarySize() {
    157        return slidingDictionarySize;
    158    }
    159
    160    /**
    161     * Returns the number of trees used by the compression method 6 (imploding).
    162     */
    163    int getNumberOfShannonFanoTrees() {
    164        return numberOfShannonFanoTrees;
    165    }
    166
    167    /**
    168     * Encodes the set bits in a form suitable for ZIP archives.
    169     * @return the encoded general purpose bits
    170     */
    171    public byte[] encode() {
    172        final byte[] result = new byte[2];
    173        encode(result, 0);
    174        return result;
    175    }
    176
    177
    178    /**
    179     * Encodes the set bits in a form suitable for ZIP archives.
    180     *
    181     * @param buf the output buffer
    182     * @param  offset
    183     *         The offset within the output buffer of the first byte to be written.
    184     *         must be non-negative and no larger than <tt>buf.length-2</tt>
    185     */
    186    public void encode(final byte[] buf, final int offset) {
    187                ZipShort.putShort((dataDescriptorFlag ? DATA_DESCRIPTOR_FLAG : 0)
    188                        |
    189                        (languageEncodingFlag ? UFT8_NAMES_FLAG : 0)
    190                        |
    191                        (encryptionFlag ? ENCRYPTION_FLAG : 0)
    192                        |
    193                        (strongEncryptionFlag ? STRONG_ENCRYPTION_FLAG : 0)
    194                        , buf, offset);
    195    }
    196
    197    /**
    198     * Parses the supported flags from the given archive data.
    199     *
    200     * @param data local file header or a central directory entry.
    201     * @param offset offset at which the general purpose bit starts
    202     * @return parsed flags
    203     */
    204    public static GeneralPurposeBit parse(final byte[] data, final int offset) {
    205        final int generalPurposeFlag = ZipShort.getValue(data, offset);
    206        final GeneralPurposeBit b = new GeneralPurposeBit();
    207        b.useDataDescriptor((generalPurposeFlag & DATA_DESCRIPTOR_FLAG) != 0);
    208        b.useUTF8ForNames((generalPurposeFlag & UFT8_NAMES_FLAG) != 0);
    209        b.useStrongEncryption((generalPurposeFlag & STRONG_ENCRYPTION_FLAG) != 0);
    210        b.useEncryption((generalPurposeFlag & ENCRYPTION_FLAG) != 0);
    211        b.slidingDictionarySize = (generalPurposeFlag & SLIDING_DICTIONARY_SIZE_FLAG) != 0 ? 8192 : 4096;
    212        b.numberOfShannonFanoTrees = (generalPurposeFlag & NUMBER_OF_SHANNON_FANO_TREES_FLAG) != 0 ? 3 : 2;
    213        return b;
    214    }
    215
    216    @Override
    217    public int hashCode() {
    218        return 3 * (7 * (13 * (17 * (encryptionFlag ? 1 : 0)
    219                               + (strongEncryptionFlag ? 1 : 0))
    220                         + (languageEncodingFlag ? 1 : 0))
    221                    + (dataDescriptorFlag ? 1 : 0));
    222    }
    223
    224    @Override
    225    public boolean equals(final Object o) {
    226        if (!(o instanceof GeneralPurposeBit)) {
    227            return false;
    228        }
    229        final GeneralPurposeBit g = (GeneralPurposeBit) o;
    230        return g.encryptionFlag == encryptionFlag
    231            && g.strongEncryptionFlag == strongEncryptionFlag
    232            && g.languageEncodingFlag == languageEncodingFlag
    233            && g.dataDescriptorFlag == dataDescriptorFlag;
    234    }
    235
    236    @Override
    237    public Object clone() {
    238        try {
    239            return super.clone();
    240        } catch (final CloneNotSupportedException ex) {
    241            // impossible
    242            throw new RuntimeException("GeneralPurposeBit is not Cloneable?", ex);
    243        }
    244    }
    245}