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