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