Raw.java

/*
 * Copyright 2010 Srikanth Reddy Lingala  
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 * http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, 
 * software distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
package net.lingala.zip4j.util;

import java.io.DataInput;
import java.io.IOException;

import net.lingala.zip4j.exception.ZipException;

public class Raw {

    public static long readLongLittleEndian(byte[] array, int pos) {
        long temp = 0;
        temp |= array[pos + 7] & 0xff;
        temp <<= 8;
        temp |= array[pos + 6] & 0xff;
        temp <<= 8;
        temp |= array[pos + 5] & 0xff;
        temp <<= 8;
        temp |= array[pos + 4] & 0xff;
        temp <<= 8;
        temp |= array[pos + 3] & 0xff;
        temp <<= 8;
        temp |= array[pos + 2] & 0xff;
        temp <<= 8;
        temp |= array[pos + 1] & 0xff;
        temp <<= 8;
        temp |= array[pos] & 0xff;
        return temp;
    }

    public static int readLeInt(DataInput di, byte[] b) throws ZipException {
        try {
            di.readFully(b, 0, 4);
        } catch (IOException e) {
            throw new ZipException(e);
        }
        return ((b[0] & 0xff) | (b[1] & 0xff) << 8)
                | ((b[2] & 0xff) | (b[3] & 0xff) << 8) << 16;
    }

    public static int readShortLittleEndian(byte[] b, int off) {
        return (b[off] & 0xff) | (b[off + 1] & 0xff) << 8;
    }

    public static final short readShortBigEndian(byte[] array, int pos) {
        short temp = 0;
        temp |= array[pos] & 0xff;
        temp <<= 8;
        temp |= array[pos + 1] & 0xff;
        return temp;
    }

    public static int readIntLittleEndian(byte[] b, int off) {
        return ((b[off] & 0xff) | (b[off + 1] & 0xff) << 8)
                | ((b[off + 2] & 0xff) | (b[off + 3] & 0xff) << 8) << 16;
    }

    public static byte[] toByteArray(int in, int outSize) {
        byte[] out = new byte[outSize];
        byte[] intArray = toByteArray(in);
        for (int i = 0; i < intArray.length && i < outSize; i++) {
            out[i] = intArray[i];
        }
        return out;
    }

    public static byte[] toByteArray(int in) {
        byte[] out = new byte[4];

        out[0] = (byte) in;
        out[1] = (byte) (in >> 8);
        out[2] = (byte) (in >> 16);
        out[3] = (byte) (in >> 24);

        return out;
    }

    public static final void writeShortLittleEndian(byte[] array, int pos,
            short value) {
        array[pos + 1] = (byte) (value >>> 8);
        array[pos] = (byte) (value & 0xFF);

    }

    public static final void writeIntLittleEndian(byte[] array, int pos,
            int value) {
        array[pos + 3] = (byte) (value >>> 24);
        array[pos + 2] = (byte) (value >>> 16);
        array[pos + 1] = (byte) (value >>> 8);
        array[pos] = (byte) (value & 0xFF);

    }

    public static void writeLongLittleEndian(byte[] array, int pos, long value) {
        array[pos + 7] = (byte) (value >>> 56);
        array[pos + 6] = (byte) (value >>> 48);
        array[pos + 5] = (byte) (value >>> 40);
        array[pos + 4] = (byte) (value >>> 32);
        array[pos + 3] = (byte) (value >>> 24);
        array[pos + 2] = (byte) (value >>> 16);
        array[pos + 1] = (byte) (value >>> 8);
        array[pos] = (byte) (value & 0xFF);
    }

    public static byte bitArrayToByte(int[] bitArray) throws ZipException {
        if (bitArray == null) {
            throw new ZipException(
                    "bit array is null, cannot calculate byte from bits");
        }

        if (bitArray.length != 8) {
            throw new ZipException(
                    "invalid bit array length, cannot calculate byte");
        }

        if (!checkBits(bitArray)) {
            throw new ZipException(
                    "invalid bits provided, bits contain other values than 0 or 1");
        }

        int retNum = 0;
        for (int i = 0; i < bitArray.length; i++) {
            retNum += Math.pow(2, i) * bitArray[i];
        }

        return (byte) retNum;
    }

    private static boolean checkBits(int[] bitArray) {
        for (int i = 0; i < bitArray.length; i++) {
            if (bitArray[i] != 0 && bitArray[i] != 1) {
                return false;
            }
        }
        return true;
    }

    public static void prepareBuffAESIVBytes(byte[] buff, int nonce, int length) {
        buff[0] = (byte) nonce;
        buff[1] = (byte) (nonce >> 8);
        buff[2] = (byte) (nonce >> 16);
        buff[3] = (byte) (nonce >> 24);
        buff[4] = 0;
        buff[5] = 0;
        buff[6] = 0;
        buff[7] = 0;
        buff[8] = 0;
        buff[9] = 0;
        buff[10] = 0;
        buff[11] = 0;
        buff[12] = 0;
        buff[13] = 0;
        buff[14] = 0;
        buff[15] = 0;
    }

    /**
     * Converts a char array to byte array
     *
     * @param charArray
     * @return byte array representation of the input char array
     */
    public static byte[] convertCharArrayToByteArray(char[] charArray) {
        if (charArray == null) {
            throw new NullPointerException();
        }

        byte[] bytes = new byte[charArray.length];
        for (int i = 0; i < charArray.length; i++) {
            bytes[i] = (byte) charArray[i];
        }
        return bytes;
    }
}