content: /*
  * 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 
  * 
  * https://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;
  	}
  }
  