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