gzipinputstream.java

手机邮箱撒的方式方式方式的

    		if (this.status == GZipInputStream.EXPECTING_CHECK){
    			//System.out.println(this.allPocessed + " data check");
    			
    			this.status=GZipInputStream.FINISHED;
    			
    			this.allPocessed=(this.allPocessed+this.outEnd-this.lastEnd) & 4294967295L;
    			if (this.hash){
    		    	// lastEnd -> End in CRC32 einbeziehen
    				this.crc32=ZipHelper.crc32(this.crc32Table, this.crc32, myOutBuff, this.lastEnd, this.outEnd-this.lastEnd);
    			}
    			
    			// skip till next byte boundary, read CRC , isize
    			popSmallBuffer(this.smallCodeBuffer[1]&7);
    			int cCrc=popSmallBuffer(8)|(popSmallBuffer(8)<<8)|(popSmallBuffer(8)<<16)|(popSmallBuffer(8)<<24);
    			int iSize=popSmallBuffer(8)|(popSmallBuffer(8)<<8)|(popSmallBuffer(8)<<16)|(popSmallBuffer(8)<<24);
    			
    			this.vaildData=(iSize==this.allPocessed);
    			if (this.hash){
    				this.vaildData &= (this.crc32==cCrc);
    			}
    			
    			if (!this.vaildData){
    				//ERROR: the data check (size & hash) are wrong
    				throw new IOException("2");
    			}
    			
    		}
    		
    	}
    	
    	// refresh the checksum at once
    	if (this.status!=GZipInputStream.FINISHED){
	    	this.allPocessed=(this.allPocessed+this.outEnd-this.lastEnd) & 4294967295L;
	    	if (this.hash){
		    	// lastEnd -> End in CRC32 einbeziehen
	    		this.crc32 = ZipHelper.crc32(this.crc32Table, this.crc32, myOutBuff, this.lastEnd, this.outEnd-this.lastEnd);
	    	}
    	}
    	
    }
    
    private void processHeader () throws IOException{
    	int val;
    	
		int HLIT; // number of miniHuff fragments
		int HDIST;// number of distance codes (should somehow lead to the same)
		int HCLEN;// number of length codes

		int[] distHuffCode=new int[30];
		int[] distHuffData=new int[30];
		byte[] distHuffCodeLength=new byte[30];
		
		int[] huffmanCode=new int[286];				// this contains the codes according to the huffman tree/mapping
		int[] huffmanData=new int[286];				// this contains the data referring to the code.
		byte[] huffmanCodeLength=new byte[286];
		
		this.BFINAL= (popSmallBuffer(1)==1);
	
		this.BTYPE=popSmallBuffer(2);
		
		if (this.BTYPE==3){
			throw new IllegalArgumentException();
		} else if (this.BTYPE==1){
			//System.out.println(this.allPocessed +  ": fixed tree");
			
			ZipHelper.genFixedTree(huffmanCode, huffmanCodeLength, distHuffCode, distHuffCodeLength);
			for (int i = 0; i < 286; i++) {
				huffmanData[i]=i;
			}
			for (int i = 0; i < 30; i++) {
				distHuffData[i]=i;
			}
			
			// convert literal table to tree
			ZipHelper.convertTable2Tree(huffmanCode, huffmanCodeLength, huffmanData, this.huffmanTree);
			
	    	// convert distance table to tree
			ZipHelper.convertTable2Tree(distHuffCode, distHuffCodeLength, distHuffData, this.distHuffTree);
			
		} else if(this.BTYPE==2) {
			//System.out.println(this.allPocessed + ": dynamic tree");
			
			// read/parse the length codes
			
			HLIT=popSmallBuffer(5);
				HDIST=popSmallBuffer(5);
			HCLEN=popSmallBuffer(4);
			
			// miniTree
			int[] miniHuffData=     { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
			int[] seq={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
			
			byte[] miniHuffCodeLength=new byte[19];
			int[] miniHuffCode=new int[19];
			
			// read the miniHuffCodeLength
			for (int i = 0; i < HCLEN+4; i++) {
				miniHuffCodeLength[ miniHuffData[i] ]=(byte) popSmallBuffer(3);
			}
			
			ZipHelper.genHuffTree(miniHuffCode, miniHuffCodeLength);
			ZipHelper.revHuffTree(miniHuffCode, miniHuffCodeLength);

			short[] miniTree = new short[19*4];
	    	ZipHelper.convertTable2Tree(miniHuffCode, miniHuffCodeLength, seq, miniTree);
	    	
			// parse the length code for the normal Tree and the distance Tree using the miniTree
			for (int i = 0; i < huffmanCodeLength.length; i++) {
				huffmanCodeLength[i]=0;
			}
			for (int i = 0; i < distHuffCodeLength.length; i++) {
				distHuffCodeLength[i]=0;
			}
			byte lastVal=0;
			for (int j = 0; j < HLIT + 257 + HDIST +1;) {
				
				if (this.smallCodeBuffer[1]<15){
					refillSmallCodeBuffer( true);
				}
				val=ZipHelper.deHuffNext(this.smallCodeBuffer, miniTree);
				
				// data
				if (val<16){
					lastVal=(byte)val;
					val=1;
				} else{
				// repeat code
					if (val==16){
						val=popSmallBuffer(2)+3;
					} else if (val==17){
						lastVal=0;
						val=popSmallBuffer(3)+3;
					} else if (val==18){
						lastVal=0;
						val=popSmallBuffer(7)+11;
					}
				}
				// fill the value in
				for (int k = 0; k < val; k++,j++) {
					if (j<HLIT + 257){
						huffmanCodeLength[j]=lastVal;
					} else {
						distHuffCodeLength[j-(HLIT + 257)]=lastVal;
					}
				}
				
			}
			
			// final tree:		 fill this.huffmanCode this.huffmanData
			ZipHelper.genHuffTree(huffmanCode, huffmanCodeLength);
			for (int i = 0; i < huffmanData.length; i++) {
				huffmanData[i]=i;
			}
			// converting literal table to tree
			ZipHelper.revHuffTree(huffmanCode, huffmanCodeLength);
			ZipHelper.convertTable2Tree(huffmanCode, huffmanCodeLength, huffmanData, this.huffmanTree);
			
			// Distance Tree
	    	// distHuffData for non fixed distance tree
			// this.distHuffCodeLength is read together with this.huffmanCodeLength
	    	for (int j = 0; j < distHuffCode.length; j++) {
	    		distHuffData[j]=j;
			}
	    	ZipHelper.genHuffTree(distHuffCode, distHuffCodeLength);
	    	ZipHelper.revHuffTree(distHuffCode, distHuffCodeLength);
	    	ZipHelper.convertTable2Tree(distHuffCode, distHuffCodeLength, distHuffData, this.distHuffTree);
	    	
		} else{
			// just skip bits up to the next boundary
			popSmallBuffer(this.smallCodeBuffer[1]&7); //&7 == %8
			
			// read and check the header 
			this.B0len=popSmallBuffer(8)|popSmallBuffer(8)<<8;
			if (this.smallCodeBuffer[1]<15){
				refillSmallCodeBuffer( true);
			}
			if (this.B0len + (popSmallBuffer(8)|popSmallBuffer(8)<<8) != 0xffff){
				//Error:  the header for the uncompressed is wrong;
				throw new IOException("3");
				
			}
			
			// clear the buffer
			while(this.smallCodeBuffer[1]!=0 && this.B0len>0){
				val = popSmallBuffer(8);
				this.window[this.pProcessed]=(byte)val;
				this.pProcessed=(this.pProcessed +1) & 32767; // == % (1<<15);
				
				this.outBuff[this.outEnd]=(byte)val;
				this.outEnd++;
				
				this.B0len--;
			}
			
		}
		
		this.status=GZipInputStream.EXPECTING_DATA;
		
		distHuffCode=null;
		distHuffData=null;
		distHuffCodeLength=null;
		
		huffmanCodeLength=null;
		huffmanCode=null;
		huffmanData=null;
	} 
    
    /**
     * Checks if the current status is valid
     * 
     * @return -1 if the stream is finished, 1 if the current data is valid, 0 if not
     * @throws IOException
     */
    public int validData() throws IOException{
    	inflate();
    	if (this.status!=GZipInputStream.FINISHED){
    		return -1;
    	}  else {
    		if (this.vaildData){
    			return 1;
    		} else {
    			return 0;
    		}
    	}
    }
    
    private int popSmallBuffer(long len) throws IOException{
    	
    	if (len==0) return 0;
    	
		if (this.smallCodeBuffer[1]<len){
			refillSmallCodeBuffer( true);
		}
		
    	int ret= (int) (this.smallCodeBuffer[0] & ((1<<len)-1));
		this.smallCodeBuffer[0]>>>=len;
		this.smallCodeBuffer[1]-=len;
    	
		return ret;    	
    	
    }
    /**
     * This function refills the smallCodeBuffer with data from the input
     * stream.
     *
     */
    byte[] tmpRef = new byte[8]; // just one allocation

    /** 
     *  Refill mini internal buffer used for internal decoding. 
     *  Only (nearly) function that reads input.
     * 
     * @param canBlock If true check if datas are available
     * @return true if any pending data are in buffer
     * @throws java.io.IOException
     */
    private boolean refillSmallCodeBuffer( boolean canBlock) throws IOException{
    	// (re)fill this.smallBuffer reading this.inStream
    	if (this.inStreamEnded==false){
	    	
	    	int wanted=(int)(BL-this.smallCodeBuffer[1]/8-1);
	    	int count = 0;
                int avail = 9999;
                if ( canBlock || ((avail=this.inStream.available()) >= wanted) ) 
                    count= this.inStream.read(this.tmpRef,0,wanted);
	    	
	    	if (count == -1){
	    		this.inStreamEnded=true;
	    	}
	    	
			for (int i = 0; i < count; i++) {
					this.smallCodeBuffer[0]&= ~( (long)0xff << this.smallCodeBuffer[1]);
					if (this.tmpRef[i]<0){
						this.smallCodeBuffer[0]|= (long)(this.tmpRef[i]+256) << this.smallCodeBuffer[1];
					}else{
						this.smallCodeBuffer[0]|= (long)this.tmpRef[i] << this.smallCodeBuffer[1];
					}
					this.smallCodeBuffer[1]+=8;
			}
//            return avail > 8 + count;
              return avail > 0;
    	}
        return false; // Stream closed
    }
    
    /**
     * This function fills the buffer and returns the amount of 
     * avialable data. Therefore it will always return the buffer
     * size that was given to the constructor.
     */
    public int available() throws IOException {
//    	if ((this.outEnd-this.outStart)<this.outBuff.length-300){
//    		inflate();
//    	}
        // Alf - inflate only when needed
    	if (this.outEnd==this.outStart){
    		inflate();
    	}
    	return this.outEnd-this.outStart;
    }
    
    public long skip(long n) throws IOException{
    	long skipped=0;
    	byte b[]=new byte[this.buffsize];
    	
		while(skipped<n && this.status != GZipInputStream.FINISHED){
			skipped+=this.read(b);
		}
    	
    	return skipped;
    }
    
	public int read() throws IOException {
    	if ((this.outEnd-this.outStart)==0){
    		inflate();
    	}
    	if(this.outEnd-this.outStart==0 && this.inStreamEnded){
    		// the input stream ended
    		return -1;
		} else {
			return (this.outBuff[this.outStart++] + 256) & 255;
		}
	}
	
    public int read(byte b[]) throws IOException {
    	return read(b, 0, b.length);
    }
    
    /* (non-Javadoc)
     * @see java.io.InputStream#read(byte[], int, int)
     */
    public int read(byte b[], int off, int len) throws IOException  {
 	
    	// inflate as much as possible
//    	if ((this.outEnd-this.outStart)<this.outBuff.length-300){
//  		inflate();
//    	}
        // Alf: Infalte only when needed
    	if (this.outEnd==this.outStart) {
  		inflate();
    	}
    	
    	// we can process just min(b.length, this.avialableBytes) Bytes
    	int av=this.available();
    	int copyBytes= len > av ? av: len;
    	
    	// copy avialable data from the ouputBuffer to 'b'
    	// here ocurred an error once
    	System.arraycopy(this.outBuff, this.outStart, b, off, copyBytes);
    	
    	this.outStart+=copyBytes;
    	
    	// return the number of copied bytes
    	if(copyBytes!=0){
    		return copyBytes;
    	} else {
    		return -1;
    	}
    }
    
}