    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
    020import static org.apache.commons.compress.archivers.zip.ZipConstants.WORD;
    021
    022import java.io.Serializable;
    023
    024import org.apache.commons.compress.utils.ByteUtils;
    025
    026/**
    027 * Utility class that represents a four byte integer with conversion
    028 * rules for the little endian byte order of ZIP files.
    029 * @Immutable
    030 */
    031public final class ZipLong implements Cloneable, Serializable {
    032    private static final long serialVersionUID = 1L;
    033
    034    /** Central File Header Signature */
    035    public static final ZipLong CFH_SIG = new ZipLong(0X02014B50L);
    036
    037    /** Local File Header Signature */
    038    public static final ZipLong LFH_SIG = new ZipLong(0X04034B50L);
    039
    040    /**
    041     * Data Descriptor signature.
    042     *
    043     * <p>Actually, PKWARE uses this as marker for split/spanned
    044     * archives and other archivers have started to use it as Data
    045     * Descriptor signature (as well).</p>
    046     * @since 1.1
    047     */
    048    public static final ZipLong DD_SIG = new ZipLong(0X08074B50L);
    049
    050    /**
    051     * Value stored in size and similar fields if ZIP64 extensions are
    052     * used.
    053     * @since 1.3
    054     */
    055    static final ZipLong ZIP64_MAGIC = new ZipLong(ZipConstants.ZIP64_MAGIC);
    056
    057    /**
    058     * Marks ZIP archives that were supposed to be split or spanned
    059     * but only needed a single segment in then end (so are actually
    060     * neither split nor spanned).
    061     *
    062     * <p>This is the "PK00" prefix found in some archives.</p>
    063     * @since 1.5
    064     */
    065    public static final ZipLong SINGLE_SEGMENT_SPLIT_MARKER =
    066        new ZipLong(0X30304B50L);
    067
    068    /**
    069     * Archive extra data record signature.
    070     * @since 1.5
    071     */
    072    public static final ZipLong AED_SIG = new ZipLong(0X08064B50L);
    073
    074    /**
    075     * Get value as four bytes in big endian byte order.
    076     * @param value the value to convert
    077     * @return value as four bytes in big endian byte order
    078     */
    079    public static byte[] getBytes(final long value) {
    080        final byte[] result = new byte[WORD];
    081        putLong(value, result, 0);
    082        return result;
    083    }
    084
    085    /**
    086     * Helper method to get the value as a Java long from a four-byte array
    087     * @param bytes the array of bytes
    088     * @return the corresponding Java long value
    089     */
    090    public static long getValue(final byte[] bytes) {
    091        return getValue(bytes, 0);
    092    }
    093
    094    /**
    095     * Helper method to get the value as a Java long from four bytes starting at given array offset
    096     * @param bytes the array of bytes
    097     * @param offset the offset to start
    098     * @return the corresponding Java long value
    099     */
    100    public static long getValue(final byte[] bytes, final int offset) {
    101        return ByteUtils.fromLittleEndian(bytes, offset, 4);
    102    }
    103
    104    /**
    105     * put the value as four bytes in big endian byte order.
    106     * @param value the Java long to convert to bytes
    107     * @param buf the output buffer
    108     * @param  offset
    109     *         The offset within the output buffer of the first byte to be written.
    110     *         must be non-negative and no larger than {@code buf.length-4}
    111     */
    112
    113    public static void putLong(final long value, final byte[] buf, final int offset) {
    114        ByteUtils.toLittleEndian(buf, value, offset, 4);
    115    }
    116
    117    private final long value;
    118
    119    /**
    120     * Create instance from bytes.
    121     * @param bytes the bytes to store as a ZipLong
    122     */
    123    public ZipLong (final byte[] bytes) {
    124        this(bytes, 0);
    125    }
    126
    127    /**
    128     * Create instance from the four bytes starting at offset.
    129     * @param bytes the bytes to store as a ZipLong
    130     * @param offset the offset to start
    131     */
    132    public ZipLong (final byte[] bytes, final int offset) {
    133        value = ZipLong.getValue(bytes, offset);
    134    }
    135
    136    /**
    137     * create instance from a java int.
    138     * @param value the int to store as a ZipLong
    139     * @since 1.15
    140     */
    141    public ZipLong(final int value) {
    142        this.value = value;
    143    }
    144
    145    /**
    146     * Create instance from a number.
    147     * @param value the long to store as a ZipLong
    148     */
    149    public ZipLong(final long value) {
    150        this.value = value;
    151    }
    152
    153    @Override
    154    public Object clone() {
    155        try {
    156            return super.clone();
    157        } catch (final CloneNotSupportedException cnfe) {
    158            // impossible
    159            throw new IllegalStateException(cnfe); //NOSONAR
    160        }
    161    }
    162
    163    /**
    164     * Override to make two instances with same value equal.
    165     * @param o an object to compare
    166     * @return true if the objects are equal
    167     */
    168    @Override
    169    public boolean equals(final Object o) {
    170        if (!(o instanceof ZipLong)) {
    171            return false;
    172        }
    173        return value == ((ZipLong) o).getValue();
    174    }
    175
    176    /**
    177     * Get value as four bytes in big endian byte order.
    178     * @return value as four bytes in big endian order
    179     */
    180    public byte[] getBytes() {
    181        return ZipLong.getBytes(value);
    182    }
    183
    184    /**
    185     * Get value as a (signed) java int
    186     * @return value as int
    187     * @since 1.15
    188     */
    189    public int getIntValue() { return (int)value;}
    190
    191    /**
    192     * Get value as Java long.
    193     * @return value as a long
    194     */
    195    public long getValue() {
    196        return value;
    197    }
    198
    199    /**
    200     * Override to make two instances with same value equal.
    201     * @return the value stored in the ZipLong
    202     */
    203    @Override
    204    public int hashCode() {
    205        return (int) value;
    206    }
    207
    208    public void putLong(final byte[] buf, final int offset) {
    209        putLong(value, buf, offset);
    210    }
    211
    212    @Override
    213    public String toString() {
    214        return "ZipLong value: " + value;
    215    }
    216}