    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one
    003 * or more contributor license agreements.  See the NOTICE file
    004 * distributed with this work for additional information
    005 * regarding copyright ownership.  The ASF licenses this file
    006 * to you under the Apache License, Version 2.0 (the
    007 * "License"); you may not use this file except in compliance
    008 * with the License.  You may obtain a copy of the License at
    009 *
    010 * http://www.apache.org/licenses/LICENSE-2.0
    011 *
    012 * Unless required by applicable law or agreed to in writing,
    013 * software distributed under the License is distributed on an
    014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    015 * KIND, either express or implied.  See the License for the
    016 * specific language governing permissions and limitations
    017 * under the License.
    018 */
    019package org.apache.commons.compress.archivers.zip;
    020
    021import static org.apache.commons.compress.archivers.zip.ZipConstants.SHORT;
    022import static org.apache.commons.compress.archivers.zip.ZipConstants.WORD;
    023
    024import java.nio.charset.Charset;
    025import java.util.zip.CRC32;
    026import java.util.zip.ZipException;
    027
    028/**
    029 * Adds Unix file permission and UID/GID fields as well as symbolic
    030 * link handling.
    031 *
    032 * <p>This class uses the ASi extra field in the format:</p>
    033 * <pre>
    034 *         Value         Size            Description
    035 *         -----         ----            -----------
    036 * (Unix3) 0x756e        Short           tag for this extra block type
    037 *         TSize         Short           total data size for this block
    038 *         CRC           Long            CRC-32 of the remaining data
    039 *         Mode          Short           file permissions
    040 *         SizDev        Long            symlink'd size OR major/minor dev num
    041 *         UID           Short           user ID
    042 *         GID           Short           group ID
    043 *         (var.)        variable        symbolic link file name
    044 * </pre>
    045 * <p>taken from appnote.iz (Info-ZIP note, 981119) found at <a
    046 * href="ftp://ftp.uu.net/pub/archiving/zip/doc/">ftp://ftp.uu.net/pub/archiving/zip/doc/</a></p>
    047 *
    048 * <p>Short is two bytes and Long is four bytes in big endian byte and
    049 * word order, device numbers are currently not supported.</p>
    050 * @NotThreadSafe
    051 *
    052 * <p>Since the documentation this class is based upon doesn't mention
    053 * the character encoding of the file name at all, it is assumed that
    054 * it uses the current platform's default encoding.</p>
    055 */
    056public class AsiExtraField implements ZipExtraField, UnixStat, Cloneable {
    057
    058    private static final ZipShort HEADER_ID = new ZipShort(0x756E);
    059    private static final int      MIN_SIZE = WORD + SHORT + WORD + SHORT + SHORT;
    060
    061    /**
    062     * Standard Unix stat(2) file mode.
    063     */
    064    private int mode;
    065    /**
    066     * User ID.
    067     */
    068    private int uid;
    069    /**
    070     * Group ID.
    071     */
    072    private int gid;
    073    /**
    074     * File this entry points to, if it is a symbolic link.
    075     *
    076     * <p>empty string - if entry is not a symbolic link.</p>
    077     */
    078    private String link = "";
    079    /**
    080     * Is this an entry for a directory?
    081     */
    082    private boolean dirFlag;
    083
    084    /**
    085     * Instance used to calculate checksums.
    086     */
    087    private CRC32 crc = new CRC32();
    088
    089    /** Constructor for AsiExtraField. */
    090    public AsiExtraField() {
    091    }
    092
    093    @Override
    094    public Object clone() {
    095        try {
    096            final AsiExtraField cloned = (AsiExtraField) super.clone();
    097            cloned.crc = new CRC32();
    098            return cloned;
    099        } catch (final CloneNotSupportedException cnfe) {
    100            // impossible
    101            throw new UnsupportedOperationException(cnfe); //NOSONAR
    102        }
    103    }
    104
    105    /**
    106     * Delegate to local file data.
    107     * @return the local file data
    108     */
    109    @Override
    110    public byte[] getCentralDirectoryData() {
    111        return getLocalFileDataData();
    112    }
    113
    114    /**
    115     * Delegate to local file data.
    116     * @return the centralDirectory length
    117     */
    118    @Override
    119    public ZipShort getCentralDirectoryLength() {
    120        return getLocalFileDataLength();
    121    }
    122
    123    /**
    124     * Gets the group id.
    125     * @return the group id
    126     */
    127    public int getGroupId() {
    128        return gid;
    129    }
    130
    131    /**
    132     * The Header-ID.
    133     * @return the value for the header id for this extrafield
    134     */
    135    @Override
    136    public ZipShort getHeaderId() {
    137        return HEADER_ID;
    138    }
    139
    140    /**
    141     * Name of linked file
    142     *
    143     * @return name of the file this entry links to if it is a
    144     *         symbolic link, the empty string otherwise.
    145     */
    146    public String getLinkedFile() {
    147        return link;
    148    }
    149
    150    /**
    151     * The actual data to put into local file data - without Header-ID
    152     * or length specifier.
    153     * @return get the data
    154     */
    155    @Override
    156    public byte[] getLocalFileDataData() {
    157        // CRC will be added later
    158        final byte[] data = new byte[getLocalFileDataLength().getValue() - WORD];
    159        System.arraycopy(ZipShort.getBytes(getMode()), 0, data, 0, 2);
    160
    161        final byte[] linkArray = getLinkedFile().getBytes(Charset.defaultCharset()); // Uses default charset - see class Javadoc
    162        // CheckStyle:MagicNumber OFF
    163        System.arraycopy(ZipLong.getBytes(linkArray.length), 0, data, 2, WORD);
    164
    165        System.arraycopy(ZipShort.getBytes(getUserId()), 0, data, 6, 2);
    166        System.arraycopy(ZipShort.getBytes(getGroupId()), 0, data, 8, 2);
    167
    168        System.arraycopy(linkArray, 0, data, 10, linkArray.length);
    169        // CheckStyle:MagicNumber ON
    170
    171        crc.reset();
    172        crc.update(data);
    173        final long checksum = crc.getValue();
    174
    175        final byte[] result = new byte[data.length + WORD];
    176        System.arraycopy(ZipLong.getBytes(checksum), 0, result, 0, WORD);
    177        System.arraycopy(data, 0, result, WORD, data.length);
    178        return result;
    179    }
    180
    181    /**
    182     * Length of the extra field in the local file data - without
    183     * Header-ID or length specifier.
    184     * @return a {@code ZipShort} for the length of the data of this extra field
    185     */
    186    @Override
    187    public ZipShort getLocalFileDataLength() {
    188        // @formatter:off
    189        return new ZipShort(WORD      // CRC
    190                          + 2         // Mode
    191                          + WORD      // SizDev
    192                          + 2         // UID
    193                          + 2         // GID
    194                          + getLinkedFile().getBytes(Charset.defaultCharset()).length);
    195                          // Uses default charset - see class Javadoc
    196        // @formatter:on
    197    }
    198
    199    /**
    200     * File mode of this file.
    201     * @return the file mode
    202     */
    203    public int getMode() {
    204        return mode;
    205    }
    206
    207    /**
    208     * Gets the file mode for given permissions with the correct file type.
    209     * @param mode the mode
    210     * @return the type with the mode
    211     */
    212    protected int getMode(final int mode) {
    213        int type = FILE_FLAG;
    214        if (isLink()) {
    215            type = LINK_FLAG;
    216        } else if (isDirectory()) {
    217            type = DIR_FLAG;
    218        }
    219        return type | mode & PERM_MASK;
    220    }
    221
    222    /**
    223     * Gets the user id.
    224     * @return the user id
    225     */
    226    public int getUserId() {
    227        return uid;
    228    }
    229
    230    /**
    231     * Is this entry a directory?
    232     * @return true if this entry is a directory
    233     */
    234    public boolean isDirectory() {
    235        return dirFlag && !isLink();
    236    }
    237
    238    /**
    239     * Is this entry a symbolic link?
    240     * @return true if this is a symbolic link
    241     */
    242    public boolean isLink() {
    243        return !getLinkedFile().isEmpty();
    244    }
    245
    246    /**
    247     * Doesn't do anything special since this class always uses the
    248     * same data in central directory and local file data.
    249     */
    250    @Override
    251    public void parseFromCentralDirectoryData(final byte[] buffer, final int offset,
    252                                              final int length)
    253        throws ZipException {
    254        parseFromLocalFileData(buffer, offset, length);
    255    }
    256
    257    /**
    258     * Populate data from this array as if it was in local file data.
    259     * @param data an array of bytes
    260     * @param offset the start offset
    261     * @param length the number of bytes in the array from offset
    262     * @throws ZipException on error
    263     */
    264    @Override
    265    public void parseFromLocalFileData(final byte[] data, final int offset, final int length)
    266        throws ZipException {
    267        if (length < MIN_SIZE) {
    268            throw new ZipException("The length is too short, only "
    269                    + length + " bytes, expected at least " + MIN_SIZE);
    270        }
    271
    272        final long givenChecksum = ZipLong.getValue(data, offset);
    273        final byte[] tmp = new byte[length - WORD];
    274        System.arraycopy(data, offset + WORD, tmp, 0, length - WORD);
    275        crc.reset();
    276        crc.update(tmp);
    277        final long realChecksum = crc.getValue();
    278        if (givenChecksum != realChecksum) {
    279            throw new ZipException("Bad CRC checksum, expected "
    280                                   + Long.toHexString(givenChecksum)
    281                                   + " instead of "
    282                                   + Long.toHexString(realChecksum));
    283        }
    284
    285        final int newMode = ZipShort.getValue(tmp, 0);
    286        // CheckStyle:MagicNumber OFF
    287        final int linkArrayLength = (int) ZipLong.getValue(tmp, 2);
    288        if (linkArrayLength < 0 || linkArrayLength > tmp.length - 10) {
    289            throw new ZipException("Bad symbolic link name length " + linkArrayLength
    290                + " in ASI extra field");
    291        }
    292        uid = ZipShort.getValue(tmp, 6);
    293        gid = ZipShort.getValue(tmp, 8);
    294        if (linkArrayLength == 0) {
    295            link = "";
    296        } else {
    297            final byte[] linkArray = new byte[linkArrayLength];
    298            System.arraycopy(tmp, 10, linkArray, 0, linkArrayLength);
    299            link = new String(linkArray, Charset.defaultCharset()); // Uses default charset - see class Javadoc
    300        }
    301        // CheckStyle:MagicNumber ON
    302        setDirectory((newMode & DIR_FLAG) != 0);
    303        setMode(newMode);
    304    }
    305
    306    /**
    307     * Indicate whether this entry is a directory.
    308     * @param dirFlag if true, this entry is a directory
    309     */
    310    public void setDirectory(final boolean dirFlag) {
    311        this.dirFlag = dirFlag;
    312        mode = getMode(mode);
    313    }
    314
    315    /**
    316     * Sets the group id.
    317     * @param gid the group id
    318     */
    319    public void setGroupId(final int gid) {
    320        this.gid = gid;
    321    }
    322
    323    /**
    324     * Indicate that this entry is a symbolic link to the given file name.
    325     *
    326     * @param name Name of the file this entry links to, empty String
    327     *             if it is not a symbolic link.
    328     */
    329    public void setLinkedFile(final String name) {
    330        link = name;
    331        mode = getMode(mode);
    332    }
    333
    334    /**
    335     * File mode of this file.
    336     * @param mode the file mode
    337     */
    338    public void setMode(final int mode) {
    339        this.mode = getMode(mode);
    340    }
    341
    342    /**
    343     * Sets the user id.
    344     * @param uid the user id
    345     */
    346    public void setUserId(final int uid) {
    347        this.uid = uid;
    348    }
    349}