find_package(Java)
-set(DEFAULT_JAVACFLAGS "-source 1.5 -target 1.5 -Xlint:all,-serial,-cast,-unchecked,-fallthrough,-dep-ann")
+set(DEFAULT_JAVACFLAGS "-source 1.5 -target 1.5 -Xlint:all,-serial,-cast,-unchecked,-fallthrough,-dep-ann,-deprecation")
set(JAVACFLAGS ${DEFAULT_JAVACFLAGS} CACHE STRING
"Java compiler flags (Default: ${DEFAULT_JAVACFLAGS})")
message(STATUS "Java compiler flags = ${JAVACFLAGS}")
/* -*-mode:java; c-basic-offset:2; -*- */
/*
-Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+Copyright (c) 2000-2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
package com.jcraft.jzlib;
-final class Adler32{
+final public class Adler32 implements Checksum {
// largest prime smaller than 65536
static final private int BASE=65521;
// NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
static final private int NMAX=5552;
- long adler32(long adler, byte[] buf, int index, int len){
- if(buf == null){ return 1L; }
+ private long s1=1L;
+ private long s2=0L;
- long s1=adler&0xffff;
- long s2=(adler>>16)&0xffff;
- int k;
+ public void reset(long init){
+ s1=init&0xffff;
+ s2=(init>>16)&0xffff;
+ }
+
+ public void reset(){
+ s1=1L;
+ s2=0L;
+ }
+
+ public long getValue(){
+ return ((s2<<16)|s1);
+ }
+
+ public void update(byte[] buf, int index, int len){
- while(len > 0) {
- k=len<NMAX?len:NMAX;
+ if(len==1){
+ s1+=buf[index++]&0xff; s2+=s1;
+ s1%=BASE;
+ s2%=BASE;
+ return;
+ }
+
+ int len1 = len/NMAX;
+ int len2 = len%NMAX;
+ while(len1-->0) {
+ int k=NMAX;
len-=k;
- while(k>=16){
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- s1+=buf[index++]&0xff; s2+=s1;
- k-=16;
- }
- if(k!=0){
- do{
- s1+=buf[index++]&0xff; s2+=s1;
- }
- while(--k!=0);
+ while(k-->0){
+ s1+=buf[index++]&0xff; s2+=s1;
}
s1%=BASE;
s2%=BASE;
}
- return (s2<<16)|s1;
+
+ int k=len2;
+ len-=k;
+ while(k-->0){
+ s1+=buf[index++]&0xff; s2+=s1;
+ }
+ s1%=BASE;
+ s2%=BASE;
+ }
+
+ public Adler32 copy(){
+ Adler32 foo = new Adler32();
+ foo.s1 = this.s1;
+ foo.s2 = this.s2;
+ return foo;
+ }
+
+ // The following logic has come from zlib.1.2.
+ static long combine(long adler1, long adler2, long len2){
+ long BASEL = (long)BASE;
+ long sum1;
+ long sum2;
+ long rem; // unsigned int
+
+ rem = len2 % BASEL;
+ sum1 = adler1 & 0xffffL;
+ sum2 = rem * sum1;
+ sum2 %= BASEL; // MOD(sum2);
+ sum1 += (adler2 & 0xffffL) + BASEL - 1;
+ sum2 += ((adler1 >> 16) & 0xffffL) + ((adler2 >> 16) & 0xffffL) + BASEL - rem;
+ if (sum1 >= BASEL) sum1 -= BASEL;
+ if (sum1 >= BASEL) sum1 -= BASEL;
+ if (sum2 >= (BASEL << 1)) sum2 -= (BASEL << 1);
+ if (sum2 >= BASEL) sum2 -= BASEL;
+ return sum1 | (sum2 << 16);
}
- /*
+/*
private java.util.zip.Adler32 adler=new java.util.zip.Adler32();
- long adler32(long value, byte[] buf, int index, int len){
- if(value==1) {adler.reset();}
+ public void update(byte[] buf, int index, int len){
if(buf==null) {adler.reset();}
else{adler.update(buf, index, len);}
+ }
+ public void reset(){
+ adler.reset();
+ }
+ public void reset(long init){
+ if(init==1L){
+ adler.reset();
+ }
+ else{
+ System.err.println("unsupported operation");
+ }
+ }
+ public long getValue(){
return adler.getValue();
}
- */
+*/
}
--- /dev/null
+/* -*-mode:java; c-basic-offset:2; -*- */
+/*
+Copyright (c) 2011 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+package com.jcraft.jzlib;
+
+final public class CRC32 implements Checksum {
+
+ /*
+ * The following logic has come from RFC1952.
+ */
+ private int v = 0;
+ private static int[] crc_table = null;
+ static {
+ crc_table = new int[256];
+ for (int n = 0; n < 256; n++) {
+ int c = n;
+ for (int k = 8; --k >= 0; ) {
+ if ((c & 1) != 0)
+ c = 0xedb88320 ^ (c >>> 1);
+ else
+ c = c >>> 1;
+ }
+ crc_table[n] = c;
+ }
+ }
+
+ public void update (byte[] buf, int index, int len) {
+ int c = ~v;
+ while (--len >= 0)
+ c = crc_table[(c^buf[index++])&0xff]^(c >>> 8);
+ v = ~c;
+ }
+
+ public void reset(){
+ v = 0;
+ }
+
+ public void reset(long vv){
+ v = (int)(vv&0xffffffffL);
+ }
+
+ public long getValue(){
+ return (long)(v&0xffffffffL);
+ }
+
+ // The following logic has come from zlib.1.2.
+ private static final int GF2_DIM = 32;
+ static long combine(long crc1, long crc2, long len2){
+ long row;
+ long[] even = new long[GF2_DIM];
+ long[] odd = new long[GF2_DIM];
+
+ // degenerate case (also disallow negative lengths)
+ if (len2 <= 0)
+ return crc1;
+
+ // put operator for one zero bit in odd
+ odd[0] = 0xedb88320L; // CRC-32 polynomial
+ row = 1;
+ for (int n = 1; n < GF2_DIM; n++) {
+ odd[n] = row;
+ row <<= 1;
+ }
+
+ // put operator for two zero bits in even
+ gf2_matrix_square(even, odd);
+
+ // put operator for four zero bits in odd
+ gf2_matrix_square(odd, even);
+
+ // apply len2 zeros to crc1 (first square will put the operator for one
+ // zero byte, eight zero bits, in even)
+ do {
+ // apply zeros operator for this bit of len2
+ gf2_matrix_square(even, odd);
+ if ((len2 & 1)!=0)
+ crc1 = gf2_matrix_times(even, crc1);
+ len2 >>= 1;
+
+ // if no more bits set, then done
+ if (len2 == 0)
+ break;
+
+ // another iteration of the loop with odd and even swapped
+ gf2_matrix_square(odd, even);
+ if ((len2 & 1)!=0)
+ crc1 = gf2_matrix_times(odd, crc1);
+ len2 >>= 1;
+
+ // if no more bits set, then done
+ } while (len2 != 0);
+
+ /* return combined crc */
+ crc1 ^= crc2;
+ return crc1;
+ }
+
+ private static long gf2_matrix_times(long[] mat, long vec){
+ long sum = 0;
+ int index = 0;
+ while (vec!=0) {
+ if ((vec & 1)!=0)
+ sum ^= mat[index];
+ vec >>= 1;
+ index++;
+ }
+ return sum;
+ }
+
+ static final void gf2_matrix_square(long[] square, long[] mat) {
+ for (int n = 0; n < GF2_DIM; n++)
+ square[n] = gf2_matrix_times(mat, mat[n]);
+ }
+
+ /*
+ private java.util.zip.CRC32 crc32 = new java.util.zip.CRC32();
+
+ public void update(byte[] buf, int index, int len){
+ if(buf==null) {crc32.reset();}
+ else{crc32.update(buf, index, len);}
+ }
+ public void reset(){
+ crc32.reset();
+ }
+ public void reset(long init){
+ if(init==0L){
+ crc32.reset();
+ }
+ else{
+ System.err.println("unsupported operation");
+ }
+ }
+ public long getValue(){
+ return crc32.getValue();
+ }
+*/
+ public CRC32 copy(){
+ CRC32 foo = new CRC32();
+ foo.v = this.v;
+ return foo;
+ }
+
+ public static int[] getCRC32Table(){
+ int[] tmp = new int[crc_table.length];
+ System.arraycopy(crc_table, 0, tmp, 0, tmp.length);
+ return tmp;
+ }
+}
ChangeLog of JZlib
====================================================================
-Last modified: Thu Aug 18 16:16:06 UTC 2005
-
-
-Changes since version 1.0.6:
-- change: memory and performance optimizations in the inflate operation.
- Many thanks to Paul Wakefield at platx.org(http://www.platx.org), who
- suggested above improvements.
+Last modified: Mon Feb 20 06:06:07 UTC 2012
+
+
+Changes since version 1.1.0:
+- fixed a bug in DeflaterOutputStream#write() with empty data. 9d4616f
+- fixed a bug in processing unwrapped data with InfalterInputStream. d35db2
+- fixed bugs reported in https://github.com/ymnk/jzlib/pull/5 e4aa20
+ - comments and filename in GZIPHeader must be in ISO-8859-1 encoding
+ - fixing a bug in GZIPHeader#setOS(int os)
+- some refactoring code. e912088 6900f5 614fdf
+- improving the performace of Adler32#update method. 6900f5
+- constructors of Alder32 and CRC32 become public. 30c4cf
+- added ZStream#end() and ZStream#finished(). 6b55e3
+- exposed useful constants for jruby. e17ad1
+- updated pom.xml to delete "souceDirectory"
+ No need to specify sourceDirectory if the project follows maven
+ standard.
+- updated configurations to use sbt 0.11.1
+
+
+Changes since version 1.0.7:
+- supported some new functionalities, which have been introduced since 'zlib' 1.2.
+ - JZlib#{adler32,crc32}_combine,
+ - JZlib can handle gzip file format(RFC1952).
+- added following classes,
+ - DeflaterOutputStream
+ - InflaterInputStream
+ - GZIPOutputStream
+ - GZIPInputStream
+ - Inflater
+ - Deflater
+ - ZStream has been deprecated.
+ Use Inflater and Deflater instead of it.
+ - GZIPHeader
+- re-implemented Z{Input,Output}Stream with {Deflater,Inflater}{I/O}Stream
+ - those classes have been deprecated.
+ Use DeflaterOutputStream and InfaterInputStream instead of them.
+- com/ -> src/main/java/com/
+- some tests under src/test/scala/
+- pom.xml for mvn, and projects/ for sbt.
+
+
+Changes since version 1.0.6:
+- change: memory and performance optimisations in the inflate operation.
- change: added the nowrap argument to Z{Input,Output}?Stream.
-
+
Changes since version 1.0.5:
-- ZInputStream.read(byte[], int, int) method return sometimes zero
+- ZInputStream.read(byte[], int, int) method return sometimes zero
instead of -1 at the end of stream.
- ZOutputStream.end() method should not declare IOException.
- It should be possible to call ZOutputStream.end() method more times
- ZOutputStream.finish() method should not ignore IOException from flush().
Many thanks to Matej Kraus at seznam.cz , who pointed out above problems.
-
+
Changes since version 1.0.4:
- a minor bug fix in ZInputStream
-
+
Changes since version 1.0.3:
- fixed a bug in closing ZOutputStream.
The inflating and deflating processes were not finished successfully.
- added 'finish' and 'end' methods to ZOutputStream.java
- added 'example/test_stream_deflate_inflate.java'
-
+
Changes since version 1.0.2:
- enabled pure Java implementation of adler32 and
commented out the dependency on J2SE in Adler32.java for J2ME users.
-
+
Changes since version 1.0.1:
- fixed a bug in deflating some trivial data, for example,
- large data chunk filled with zero.
+ large data chunk filled with zero.
- added 'version' method to JZlib class.
-
+
Changes since version 1.0.0:
- added ZInputStream and ZOutputStream classes.
- fixed a typo in LICENSE.txt.
-
+
Changes since version 0.0.9:
- fixed a bug in setting a dictionary in the inflation process.
- The license was changed to a BSD style license.
- Z{Input,Output}Stream classes were deleted.
-
-
+
+
Changes since version 0.0.8:
- fixed a bug in handling a preset dictionary in the inflation process.
-
+
Changes since version 0.0.7:
- added methods to control the window size (the size of the history
buffer) and to handle the no-wrap option (no zlib header or check),
which is the undocumented functionality of zlib.
-
+
Changes since version 0.0.6:
- updated InfBlocks.java as zlib did to fix the vulnerability related to
the 'double free'. Of course, JZlib is free from such a vulnerability
like the 'double free', but JZlib had crashed with NullPointerException
- by a specially-crafted block of invalid deflated data.
+ by a specially-crafted block of invalid deflated data.
+
-
Changes since version 0.0.5:
- added 'flush()' method to com.jcraft.jzlib.ZOutputStream.
-- fixed to take care when occurring the buffer overflow in
+- fixed to take care when occurring the buffer overflow in
com.jcraft.jzlib.ZOutputStream.
Many thanks to Tim Bendfelt at cs.wisc.edu , who pointed out above problems.
-
-
+
+
Changes since version 0.0.4:
............................
- fixed a bug in Adler32 class.
- modified ZOutputStream to be extended from OutputStream
instead of FileOutputStream.
- modified ZStream to be changeable wbits. Give wbits value to
- the method 'deflateInit' of ZStream.
+ the method 'deflateInit' of ZStream.
Many thanks to Bryan Keller<keller@neomar.com>, who reported bugs
and made suggestions.
-
+
Changes since version 0.0.3:
............................
- fixed a bug in the compression level 0.
--- /dev/null
+/* -*-mode:java; c-basic-offset:2; -*- */
+/*
+Copyright (c) 2011 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+package com.jcraft.jzlib;
+
+interface Checksum {
+ void update(byte[] buf, int index, int len);
+ void reset();
+ void reset(long init);
+ long getValue();
+ Checksum copy();
+}
/* -*-mode:java; c-basic-offset:2; -*- */
/*
-Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+Copyright (c) 2000-2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
package com.jcraft.jzlib;
public
-final class Deflate{
+final class Deflate implements Cloneable {
static final private int MAX_MEM_LEVEL=9;
static final private int END_BLOCK=256;
- ZStream strm; // pointer back to this zlib stream
+ ZStream strm; // pointer back to this zlib stream
int status; // as the name implies
byte[] pending_buf; // output still pending
int pending_buf_size; // size of pending_buf
int pending_out; // next pending byte to output to the stream
int pending; // nb of bytes in the pending buffer
- int noheader; // suppress zlib header and adler32
+ int wrap = 1;
byte data_type; // UNKNOWN, BINARY or ASCII
byte method; // STORED (for zip only) or DEFLATED
int last_flush; // value of flush param for previous deflate call
// are always zero.
int bi_valid;
- Deflate(){
+ GZIPHeader gheader = null;
+
+ Deflate(ZStream strm){
+ this.strm=strm;
dyn_ltree=new short[HEAP_SIZE*2];
dyn_dtree=new short[(2*D_CODES+1)*2]; // distance tree
bl_tree=new short[(2*BL_CODES+1)*2]; // Huffman tree for bit lengths
if (best_len <= lookahead) return best_len;
return lookahead;
}
+
+ int deflateInit(int level, int bits, int memlevel){
+ return deflateInit(level, Z_DEFLATED, bits, memlevel,
+ Z_DEFAULT_STRATEGY);
+ }
- int deflateInit(ZStream strm, int level, int bits){
- return deflateInit2(strm, level, Z_DEFLATED, bits, DEF_MEM_LEVEL,
+ int deflateInit(int level, int bits){
+ return deflateInit(level, Z_DEFLATED, bits, DEF_MEM_LEVEL,
Z_DEFAULT_STRATEGY);
}
- int deflateInit(ZStream strm, int level){
- return deflateInit(strm, level, MAX_WBITS);
+ int deflateInit(int level){
+ return deflateInit(level, MAX_WBITS);
}
- int deflateInit2(ZStream strm, int level, int method, int windowBits,
- int memLevel, int strategy){
- int noheader = 0;
+ private int deflateInit(int level, int method, int windowBits,
+ int memLevel, int strategy){
+ int wrap = 1;
// byte[] my_version=ZLIB_VERSION;
//
if (level == Z_DEFAULT_COMPRESSION) level = 6;
if (windowBits < 0) { // undocumented feature: suppress zlib header
- noheader = 1;
+ wrap = 0;
windowBits = -windowBits;
}
+ else if(windowBits > 15){
+ wrap = 2;
+ windowBits -= 16;
+ strm.adler=new CRC32();
+ }
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL ||
method != Z_DEFLATED ||
strm.dstate = (Deflate)this;
- this.noheader = noheader;
+ this.wrap = wrap;
w_bits = windowBits;
w_size = 1 << w_bits;
w_mask = w_size - 1;
this.level = level;
-//System.out.println("level="+level);
-
this.strategy = strategy;
this.method = (byte)method;
- return deflateReset(strm);
+ return deflateReset();
}
- int deflateReset(ZStream strm){
+ int deflateReset(){
strm.total_in = strm.total_out = 0;
strm.msg = null; //
strm.data_type = Z_UNKNOWN;
pending = 0;
pending_out = 0;
- if(noheader < 0) {
- noheader = 0; // was set to -1 by deflate(..., Z_FINISH);
+ if(wrap < 0){
+ wrap = -wrap;
}
- status = (noheader!=0) ? BUSY_STATE : INIT_STATE;
- strm.adler=strm._adler.adler32(0, null, 0, 0);
+ status = (wrap==0) ? BUSY_STATE : INIT_STATE;
+ strm.adler.reset();
last_flush = Z_NO_FLUSH;
return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
}
- int deflateParams(ZStream strm, int _level, int _strategy){
+ int deflateParams(int _level, int _strategy){
int err=Z_OK;
if(_level == Z_DEFAULT_COMPRESSION){
return err;
}
- int deflateSetDictionary (ZStream strm, byte[] dictionary, int dictLength){
+ int deflateSetDictionary (byte[] dictionary, int dictLength){
int length = dictLength;
int index=0;
if(dictionary == null || status != INIT_STATE)
return Z_STREAM_ERROR;
- strm.adler=strm._adler.adler32(strm.adler, dictionary, 0, dictLength);
+ strm.adler.update(dictionary, 0, dictLength);
if(length < MIN_MATCH) return Z_OK;
if(length > w_size-MIN_LOOKAHEAD){
return Z_OK;
}
- int deflate(ZStream strm, int flush){
+ int deflate(int flush){
int old_flush;
if(flush>Z_FINISH || flush<0){
return Z_BUF_ERROR;
}
- this.strm = strm; // just in case
old_flush = last_flush;
last_flush = flush;
// Write the zlib header
if(status == INIT_STATE) {
+ if(wrap == 2){
+ getGZIPHeader().put(this);
+ status=BUSY_STATE;
+ strm.adler.reset();
+ }
+ else{
int header = (Z_DEFLATED+((w_bits-8)<<4))<<8;
int level_flags=((level-1)&0xff)>>1;
// Save the adler32 of the preset dictionary:
if(strstart!=0){
- putShortMSB((int)(strm.adler>>>16));
- putShortMSB((int)(strm.adler&0xffff));
+ long adler=strm.adler.getValue();
+ putShortMSB((int)(adler>>>16));
+ putShortMSB((int)(adler&0xffff));
+ }
+ strm.adler.reset();
}
- strm.adler=strm._adler.adler32(0, null, 0, 0);
}
// Flush as much pending output as possible
if(pending != 0) {
strm.flush_pending();
if(strm.avail_out == 0) {
- //System.out.println(" avail_out==0");
// Since avail_out is 0, deflate will be called again with
// more output space, but possibly with both pending and
// avail_in equal to zero. There won't be anything to do,
}
if(flush!=Z_FINISH) return Z_OK;
- if(noheader!=0) return Z_STREAM_END;
+ if(wrap<=0) return Z_STREAM_END;
+
+ if(wrap==2){
+ long adler=strm.adler.getValue();
+ put_byte((byte)(adler&0xff));
+ put_byte((byte)((adler>>8)&0xff));
+ put_byte((byte)((adler>>16)&0xff));
+ put_byte((byte)((adler>>24)&0xff));
+ put_byte((byte)(strm.total_in&0xff));
+ put_byte((byte)((strm.total_in>>8)&0xff));
+ put_byte((byte)((strm.total_in>>16)&0xff));
+ put_byte((byte)((strm.total_in>>24)&0xff));
+
+ getGZIPHeader().setCRC(adler);
+ }
+ else{
+ // Write the zlib trailer (adler32)
+ long adler=strm.adler.getValue();
+ putShortMSB((int)(adler>>>16));
+ putShortMSB((int)(adler&0xffff));
+ }
- // Write the zlib trailer (adler32)
- putShortMSB((int)(strm.adler>>>16));
- putShortMSB((int)(strm.adler&0xffff));
strm.flush_pending();
// If avail_out is zero, the application will call deflate again
// to flush the rest.
- noheader = -1; // write the trailer only once!
+
+ if(wrap > 0) wrap = -wrap; // write the trailer only once!
return pending != 0 ? Z_OK : Z_STREAM_END;
}
+
+ static int deflateCopy(ZStream dest, ZStream src){
+
+ if(src.dstate == null){
+ return Z_STREAM_ERROR;
+ }
+
+ if(src.next_in!=null){
+ dest.next_in = new byte[src.next_in.length];
+ System.arraycopy(src.next_in, 0, dest.next_in, 0, src.next_in.length);
+ }
+ dest.next_in_index = src.next_in_index;
+ dest.avail_in = src.avail_in;
+ dest.total_in = src.total_in;
+
+ if(src.next_out!=null){
+ dest.next_out = new byte[src.next_out.length];
+ System.arraycopy(src.next_out, 0, dest.next_out ,0 , src.next_out.length);
+ }
+
+ dest.next_out_index = src.next_out_index;
+ dest.avail_out = src.avail_out;
+ dest.total_out = src.total_out;
+
+ dest.msg = src.msg;
+ dest.data_type = src.data_type;
+ dest.adler = src.adler.copy();
+
+ try{
+ dest.dstate = (Deflate)src.dstate.clone();
+ dest.dstate.strm = dest;
+ }
+ catch(CloneNotSupportedException e){
+ //
+ }
+ return Z_OK;
+ }
+
+ public Object clone() throws CloneNotSupportedException {
+ Deflate dest = (Deflate)super.clone();
+
+ dest.pending_buf = dup(dest.pending_buf);
+ dest.window = dup(dest.window);
+
+ dest.prev = dup(dest.prev);
+ dest.head = dup(dest.head);
+ dest.dyn_ltree = dup(dest.dyn_ltree);
+ dest.dyn_dtree = dup(dest.dyn_dtree);
+ dest.bl_tree = dup(dest.bl_tree);
+
+ dest.bl_count = dup(dest.bl_count);
+ dest.heap = dup(dest.heap);
+ dest.depth = dup(dest.depth);
+
+ dest.l_desc.dyn_tree = dest.dyn_ltree;
+ dest.d_desc.dyn_tree = dest.dyn_dtree;
+ dest.bl_desc.dyn_tree = dest.bl_tree;
+
+ /*
+ dest.l_desc.stat_desc = StaticTree.static_l_desc;
+ dest.d_desc.stat_desc = StaticTree.static_d_desc;
+ dest.bl_desc.stat_desc = StaticTree.static_bl_desc;
+ */
+
+ if(dest.gheader!=null){
+ dest.gheader = (GZIPHeader)dest.gheader.clone();
+ }
+
+ return dest;
+ }
+
+ private byte[] dup(byte[] buf){
+ byte[] foo = new byte[buf.length];
+ System.arraycopy(buf, 0, foo, 0, foo.length);
+ return foo;
+ }
+ private short[] dup(short[] buf){
+ short[] foo = new short[buf.length];
+ System.arraycopy(buf, 0, foo, 0, foo.length);
+ return foo;
+ }
+ private int[] dup(int[] buf){
+ int[] foo = new int[buf.length];
+ System.arraycopy(buf, 0, foo, 0, foo.length);
+ return foo;
+ }
+
+ synchronized GZIPHeader getGZIPHeader(){
+ if(gheader==null){
+ gheader = new GZIPHeader();
+ }
+ return gheader;
+ }
}
--- /dev/null
+/* -*-mode:java; c-basic-offset:2; -*- */
+/*
+Copyright (c) 2011 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+package com.jcraft.jzlib;
+
+import java.io.UnsupportedEncodingException;
+
+/**
+ * @see "http://www.ietf.org/rfc/rfc1952.txt"
+ */
+public class GZIPHeader implements Cloneable {
+
+ public static final byte OS_MSDOS = (byte) 0x00;
+ public static final byte OS_AMIGA = (byte) 0x01;
+ public static final byte OS_VMS = (byte) 0x02;
+ public static final byte OS_UNIX = (byte) 0x03;
+ public static final byte OS_ATARI = (byte) 0x05;
+ public static final byte OS_OS2 = (byte) 0x06;
+ public static final byte OS_MACOS = (byte) 0x07;
+ public static final byte OS_TOPS20 = (byte) 0x0a;
+ public static final byte OS_WIN32 = (byte) 0x0b;
+ public static final byte OS_VMCMS = (byte) 0x04;
+ public static final byte OS_ZSYSTEM = (byte) 0x08;
+ public static final byte OS_CPM = (byte) 0x09;
+ public static final byte OS_QDOS = (byte) 0x0c;
+ public static final byte OS_RISCOS = (byte) 0x0d;
+ public static final byte OS_UNKNOWN = (byte) 0xff;
+
+ boolean text = false;
+ private boolean fhcrc = false;
+ long time;
+ int xflags;
+ int os = 255;
+ byte[] extra;
+ byte[] name;
+ byte[] comment;
+ int hcrc;
+ long crc;
+ boolean done = false;
+ long mtime = 0;
+
+ public void setModifiedTime(long mtime) {
+ this.mtime = mtime;
+ }
+
+ public long getModifiedTime() {
+ return mtime;
+ }
+
+ public void setOS(int os) {
+ if((0<=os && os <=13) || os==255)
+ this.os=os;
+ else
+ throw new IllegalArgumentException("os: "+os);
+ }
+
+ public int getOS(){
+ return os;
+ }
+
+ public void setName(String name) {
+ try{
+ this.name=name.getBytes("ISO-8859-1");
+ }
+ catch(UnsupportedEncodingException e){
+ throw new IllegalArgumentException("name must be in ISO-8859-1 "+name);
+ }
+ }
+
+ public String getName(){
+ if(name==null) return "";
+ try {
+ return new String(name, "ISO-8859-1");
+ }
+ catch (UnsupportedEncodingException e) {
+ throw new InternalError(e.toString());
+ }
+ }
+
+ public void setComment(String comment) {
+ try{
+ this.comment=comment.getBytes("ISO-8859-1");
+ }
+ catch(UnsupportedEncodingException e){
+ throw new IllegalArgumentException("comment must be in ISO-8859-1 "+name);
+ }
+ }
+
+ public String getComment(){
+ if(comment==null) return "";
+ try {
+ return new String(comment, "ISO-8859-1");
+ }
+ catch (UnsupportedEncodingException e) {
+ throw new InternalError(e.toString());
+ }
+ }
+
+ public void setCRC(long crc){
+ this.crc = crc;
+ }
+
+ public long getCRC(){
+ return crc;
+ }
+
+ void put(Deflate d){
+ int flag = 0;
+ if(text){
+ flag |= 1; // FTEXT
+ }
+ if(fhcrc){
+ flag |= 2; // FHCRC
+ }
+ if(extra!=null){
+ flag |= 4; // FEXTRA
+ }
+ if(name!=null){
+ flag |= 8; // FNAME
+ }
+ if(comment!=null){
+ flag |= 16; // FCOMMENT
+ }
+ int xfl = 0;
+ if(d.level == JZlib.Z_BEST_SPEED){
+ xfl |= 4;
+ }
+ else if (d.level == JZlib.Z_BEST_COMPRESSION){
+ xfl |= 2;
+ }
+
+ d.put_short((short)0x8b1f); // ID1 ID2
+ d.put_byte((byte)8); // CM(Compression Method)
+ d.put_byte((byte)flag);
+ d.put_byte((byte)mtime);
+ d.put_byte((byte)(mtime>>8));
+ d.put_byte((byte)(mtime>>16));
+ d.put_byte((byte)(mtime>>24));
+ d.put_byte((byte)xfl);
+ d.put_byte((byte)os);
+
+ if(extra!=null){
+ d.put_byte((byte)extra.length);
+ d.put_byte((byte)(extra.length>>8));
+ d.put_byte(extra, 0, extra.length);
+ }
+
+ if(name!=null){
+ d.put_byte(name, 0, name.length);
+ d.put_byte((byte)0);
+ }
+
+ if(comment!=null){
+ d.put_byte(comment, 0, comment.length);
+ d.put_byte((byte)0);
+ }
+ }
+
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ GZIPHeader gheader = (GZIPHeader)super.clone();
+ byte[] tmp;
+ if(gheader.extra!=null){
+ tmp=new byte[gheader.extra.length];
+ System.arraycopy(gheader.extra, 0, tmp, 0, tmp.length);
+ gheader.extra = tmp;
+ }
+
+ if(gheader.name!=null){
+ tmp=new byte[gheader.name.length];
+ System.arraycopy(gheader.name, 0, tmp, 0, tmp.length);
+ gheader.name = tmp;
+ }
+
+ if(gheader.comment!=null){
+ tmp=new byte[gheader.comment.length];
+ System.arraycopy(gheader.comment, 0, tmp, 0, tmp.length);
+ gheader.comment = tmp;
+ }
+
+ return gheader;
+ }
+}
/* -*-mode:java; c-basic-offset:2; -*- */
/*
-Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+Copyright (c) 2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
int[] bb=new int[1]; // bit length tree depth
int[] tb=new int[1]; // bit length decoding tree
- InfCodes codes=new InfCodes(); // if CODES, current state
+ int[] bl=new int[1];
+ int[] bd=new int[1];
+
+ int[][] tl=new int[1][];
+ int[][] td=new int[1][];
+ int[] tli=new int[1]; // tl_index
+ int[] tdi=new int[1]; // td_index
+
+ private final InfCodes codes; // if CODES, current state
int last; // true if this block is the last block
int end; // one byte after sliding window
int read; // window read pointer
int write; // window write pointer
- Object checkfn; // check function
- long check; // check on output
+ private boolean check;
+
+ private final InfTree inftree=new InfTree();
- InfTree inftree=new InfTree();
+ private final ZStream z;
- InfBlocks(ZStream z, Object checkfn, int w){
+ InfBlocks(ZStream z, int w){
+ this.z=z;
+ this.codes=new InfCodes(this.z, this);
hufts=new int[MANY*3];
window=new byte[w];
end=w;
- this.checkfn = checkfn;
+ this.check = (z.istate.wrap==0) ? false : true;
mode = TYPE;
- reset(z, null);
+ reset();
}
- void reset(ZStream z, long[] c){
- if(c!=null) c[0]=check;
+ void reset(){
if(mode==BTREE || mode==DTREE){
}
if(mode==CODES){
bitk=0;
bitb=0;
read=write=0;
-
- if(checkfn != null)
- z.adler=check=z._adler.adler32(0L, null, 0, 0);
+ if(check){
+ z.adler.reset();
+ }
}
- int proc(ZStream z, int r){
+ int proc(int r){
int t; // temporary storage
int b; // bit buffer
int k; // bits in bit buffer
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
mode = LENS; // get length of stored block
break;
case 1: // fixed
- {
- int[] bl=new int[1];
- int[] bd=new int[1];
- int[][] tl=new int[1][];
- int[][] td=new int[1][];
-
- InfTree.inflate_trees_fixed(bl, bd, tl, td, z);
- codes.init(bl[0], bd[0], tl[0], 0, td[0], 0, z);
- }
+ InfTree.inflate_trees_fixed(bl, bd, tl, td, z);
+ codes.init(bl[0], bd[0], tl[0], 0, td[0], 0);
{b>>>=(3);k-=(3);}
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
}
break;
case LENS:
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
}
left = (b & 0xffff);
b = k = 0; // dump bits
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
}
if(m==0){
}
if(m==0){
write=q;
- r=inflate_flush(z,r);
+ r=inflate_flush(r);
q=write;m=(int)(q<read?read-q-1:end-q);
if(q==end&&read!=0){
q=0; m=(int)(q<read?read-q-1:end-q);
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
}
}
}
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
}
t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
if(blens==null || blens.length<t){
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
}
index = 0;
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
}
c = c == 16 ? blens[i-1] : 0;
tb[0]=-1;
{
- int[] bl=new int[1];
- int[] bd=new int[1];
- int[] tl=new int[1];
- int[] td=new int[1];
bl[0] = 9; // must be <= 9 for lookahead assumptions
bd[0] = 6; // must be <= 9 for lookahead assumptions
-
t = table;
t = inftree.inflate_trees_dynamic(257 + (t & 0x1f),
1 + ((t >> 5) & 0x1f),
- blens, bl, bd, tl, td, hufts, z);
+ blens, bl, bd, tli, tdi, hufts, z);
if (t != Z_OK){
if (t == Z_DATA_ERROR){
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z,r);
+ return inflate_flush(r);
}
- codes.init(bl[0], bd[0], hufts, tl[0], hufts, td[0], z);
+ codes.init(bl[0], bd[0], hufts, tli[0], hufts, tdi[0]);
}
mode = CODES;
case CODES:
z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- if ((r = codes.proc(this, z, r)) != Z_STREAM_END){
- return inflate_flush(z, r);
+ if ((r = codes.proc(r)) != Z_STREAM_END){
+ return inflate_flush(r);
}
r = Z_OK;
codes.free(z);
mode = DRY;
case DRY:
write=q;
- r=inflate_flush(z, r);
+ r=inflate_flush(r);
q=write; m=(int)(q<read?read-q-1:end-q);
if (read != write){
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z, r);
+ return inflate_flush(r);
}
mode = DONE;
case DONE:
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z, r);
+ return inflate_flush(r);
case BAD:
r = Z_DATA_ERROR;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z, r);
+ return inflate_flush(r);
default:
r = Z_STREAM_ERROR;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
- return inflate_flush(z, r);
+ return inflate_flush(r);
}
}
}
- void free(ZStream z){
- reset(z, null);
+ void free(){
+ reset();
window=null;
hufts=null;
//ZFREE(z, s);
}
// copy as much as possible from the sliding window to the output area
- int inflate_flush(ZStream z, int r){
+ int inflate_flush(int r){
int n;
int p;
int q;
// compute number of bytes to copy as far as end of window
n = (int)((q <= write ? write : end) - q);
- if (n > z.avail_out) n = z.avail_out;
- if (n!=0 && r == Z_BUF_ERROR) r = Z_OK;
+ if(n > z.avail_out) n = z.avail_out;
+ if(n!=0 && r == Z_BUF_ERROR) r = Z_OK;
// update counters
z.avail_out -= n;
z.total_out += n;
// update check information
- if(checkfn != null)
- z.adler=check=z._adler.adler32(check, window, q, n);
+ if(check && n>0){
+ z.adler.update(window, q, n);
+ }
// copy as far as end of window
System.arraycopy(window, q, z.next_out, p, n);
z.total_out += n;
// update check information
- if(checkfn != null)
- z.adler=check=z._adler.adler32(check, window, q, n);
+ if(check && n>0){
+ z.adler.update(window, q, n);
+ }
// copy
System.arraycopy(window, q, z.next_out, p, n);
int[] dtree; // distance tree
int dtree_index; // distance tree
- InfCodes(){
+ private final ZStream z;
+ private final InfBlocks s;
+ InfCodes(ZStream z, InfBlocks s){
+ this.z=z;
+ this.s=s;
}
+
void init(int bl, int bd,
int[] tl, int tl_index,
- int[] td, int td_index, ZStream z){
+ int[] td, int td_index){
mode=START;
lbits=(byte)bl;
dbits=(byte)bd;
tree=null;
}
- int proc(InfBlocks s, ZStream z, int r){
+ int proc(int r){
int j; // temporary storage
int[] t; // temporary pointer
int tindex; // temporary pointer
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
}
n--;
b|=(z.next_in[p++]&0xff)<<k;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
case LENEXT: // i: getting length extra (have base)
j = get;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
}
n--; b|=(z.next_in[p++]&0xff)<<k;
k+=8;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
}
n--; b|=(z.next_in[p++]&0xff)<<k;
k+=8;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
case DISTEXT: // i: getting distance extra
j = get;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
}
n--; b|=(z.next_in[p++]&0xff)<<k;
k+=8;
if(m==0){
if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
if(m==0){
- s.write=q; r=s.inflate_flush(z,r);
+ s.write=q; r=s.inflate_flush(r);
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
}
}
}
if(m==0){
if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
if(m==0){
- s.write=q; r=s.inflate_flush(z,r);
+ s.write=q; r=s.inflate_flush(r);
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
}
}
}
p--; // can always return one
}
- s.write=q; r=s.inflate_flush(z,r);
+ s.write=q; r=s.inflate_flush(r);
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
if (s.read != s.write){
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
}
mode = END;
case END:
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
case BADCODE: // x: got error
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
default:
r = Z_STREAM_ERROR;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
- return s.inflate_flush(z,r);
+ return s.inflate_flush(r);
}
}
}
for(int i=0; i<vsize; i++){v[i]=0;}
for(int i=0; i<BMAX+1; i++){c[i]=0;}
for(int i=0; i<3; i++){r[i]=0;}
-// for(int i=0; i<BMAX; i++){u[i]=0;}
System.arraycopy(c, 0, u, 0, BMAX);
-// for(int i=0; i<BMAX+1; i++){x[i]=0;}
System.arraycopy(c, 0, x, 0, BMAX+1);
}
}
/* -*-mode:java; c-basic-offset:2; -*- */
/*
-Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+Copyright (c) 2000-2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
static final private int DONE=12; // finished check, done
static final private int BAD=13; // got an error--stay here
+ static final private int HEAD=14;
+ static final private int LENGTH=15;
+ static final private int TIME=16;
+ static final private int OS=17;
+ static final private int EXLEN=18;
+ static final private int EXTRA=19;
+ static final private int NAME=20;
+ static final private int COMMENT=21;
+ static final private int HCRC=22;
+ static final private int FLAGS=23;
+
int mode; // current inflate mode
// mode dependent information
int method; // if FLAGS, method byte
// if CHECK, check values to compare
- long[] was=new long[1] ; // computed check value
+ long was = -1; // computed check value
long need; // stream check value
// if BAD, inflateSync's marker bytes count
int marker;
// mode independent information
- int nowrap; // flag for no wrapper
+ int wrap; // flag for no wrapper
int wbits; // log2(window size) (8..15, defaults to 15)
InfBlocks blocks; // current inflate_blocks state
- int inflateReset(ZStream z){
- if(z == null || z.istate == null) return Z_STREAM_ERROR;
+ private final ZStream z;
+
+ private int flags;
+
+ private int need_bytes = -1;
+ private byte[] crcbuf=new byte[4];
+
+ GZIPHeader gheader = null;
+
+ int inflateReset(){
+ if(z == null) return Z_STREAM_ERROR;
z.total_in = z.total_out = 0;
z.msg = null;
- z.istate.mode = z.istate.nowrap!=0 ? BLOCKS : METHOD;
- z.istate.blocks.reset(z, null);
+ this.mode = HEAD;
+ this.need_bytes = -1;
+ this.blocks.reset();
return Z_OK;
}
- int inflateEnd(ZStream z){
- if(blocks != null)
- blocks.free(z);
- blocks=null;
- // ZFREE(z, z->state);
+ int inflateEnd(){
+ if(blocks != null){
+ blocks.free();
+ }
return Z_OK;
}
- int inflateInit(ZStream z, int w){
+ Inflate(ZStream z){
+ this.z=z;
+ }
+
+ int inflateInit(int w){
z.msg = null;
blocks = null;
- // handle undocumented nowrap option (no zlib header or check)
- nowrap = 0;
+ // handle undocumented wrap option (no zlib header or check)
+ wrap = 0;
if(w < 0){
w = - w;
- nowrap = 1;
+ }
+ else {
+ wrap = (w >> 4) + 1;
+ if(w < 48)
+ w &= 15;
}
- // set window size
if(w<8 ||w>15){
- inflateEnd(z);
+ inflateEnd();
return Z_STREAM_ERROR;
}
+ if(blocks != null && wbits != w){
+ blocks.free();
+ blocks=null;
+ }
+
+ // set window size
wbits=w;
- z.istate.blocks=new InfBlocks(z,
- z.istate.nowrap!=0 ? null : this,
- 1<<w);
+ this.blocks=new InfBlocks(z, 1<<w);
// reset state
- inflateReset(z);
+ inflateReset();
+
return Z_OK;
}
- int inflate(ZStream z, int f){
+ int inflate(int f){
+ int hold = 0;
+
int r;
int b;
- if(z == null || z.istate == null || z.next_in == null)
+ if(z == null || z.next_in == null){
+ if(f == Z_FINISH && this.mode==HEAD)
+ return Z_OK;
return Z_STREAM_ERROR;
+ }
+
f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
r = Z_BUF_ERROR;
while (true){
-//System.out.println("mode: "+z.istate.mode);
- switch (z.istate.mode){
- case METHOD:
- if(z.avail_in==0)return r;r=f;
-
- z.avail_in--; z.total_in++;
- if(((z.istate.method = z.next_in[z.next_in_index++])&0xf)!=Z_DEFLATED){
- z.istate.mode = BAD;
- z.msg="unknown compression method";
- z.istate.marker = 5; // can't try inflateSync
+ switch (this.mode){
+ case HEAD:
+ if(wrap==0){
+ this.mode = BLOCKS;
break;
- }
- if((z.istate.method>>4)+8>z.istate.wbits){
- z.istate.mode = BAD;
- z.msg="invalid window size";
- z.istate.marker = 5; // can't try inflateSync
+ }
+
+ try { r=readBytes(2, r, f); }
+ catch(Return e){ return e.r; }
+
+ if((wrap&2)!=0 && this.need == 0x8b1fL) { // gzip header
+ z.adler=new CRC32();
+ checksum(2, this.need);
+
+ if(gheader==null)
+ gheader=new GZIPHeader();
+
+ this.mode = FLAGS;
break;
}
- z.istate.mode=FLAG;
- case FLAG:
- if(z.avail_in==0)return r;r=f;
+ flags = 0;
- z.avail_in--; z.total_in++;
- b = (z.next_in[z.next_in_index++])&0xff;
+ this.method = ((int)this.need)&0xff;
+ b=((int)(this.need>>8))&0xff;
- if((((z.istate.method << 8)+b) % 31)!=0){
- z.istate.mode = BAD;
+ if((wrap&1)==0 || // check if zlib header allowed
+ (((this.method << 8)+b) % 31)!=0){
+ this.mode = BAD;
z.msg = "incorrect header check";
- z.istate.marker = 5; // can't try inflateSync
+ // since zlib 1.2, it is allowted to inflateSync for this case.
+ /*
+ this.marker = 5; // can't try inflateSync
+ */
+ break;
+ }
+
+ if((this.method&0xf)!=Z_DEFLATED){
+ this.mode = BAD;
+ z.msg="unknown compression method";
+ // since zlib 1.2, it is allowted to inflateSync for this case.
+ /*
+ this.marker = 5; // can't try inflateSync
+ */
break;
}
+ if((this.method>>4)+8>this.wbits){
+ this.mode = BAD;
+ z.msg="invalid window size";
+ // since zlib 1.2, it is allowted to inflateSync for this case.
+ /*
+ this.marker = 5; // can't try inflateSync
+ */
+ break;
+ }
+
+ z.adler=new Adler32();
+
if((b&PRESET_DICT)==0){
- z.istate.mode = BLOCKS;
+ this.mode = BLOCKS;
break;
}
- z.istate.mode = DICT4;
+ this.mode = DICT4;
case DICT4:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
- z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
- z.istate.mode=DICT3;
+ this.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
+ this.mode=DICT3;
case DICT3:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
- z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
- z.istate.mode=DICT2;
+ this.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
+ this.mode=DICT2;
case DICT2:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
- z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
- z.istate.mode=DICT1;
+ this.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
+ this.mode=DICT1;
case DICT1:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
- z.istate.need += (z.next_in[z.next_in_index++]&0xffL);
- z.adler = z.istate.need;
- z.istate.mode = DICT0;
+ this.need += (z.next_in[z.next_in_index++]&0xffL);
+ z.adler.reset(this.need);
+ this.mode = DICT0;
return Z_NEED_DICT;
case DICT0:
- z.istate.mode = BAD;
+ this.mode = BAD;
z.msg = "need dictionary";
- z.istate.marker = 0; // can try inflateSync
+ this.marker = 0; // can try inflateSync
return Z_STREAM_ERROR;
case BLOCKS:
-
- r = z.istate.blocks.proc(z, r);
+ r = this.blocks.proc(r);
if(r == Z_DATA_ERROR){
- z.istate.mode = BAD;
- z.istate.marker = 0; // can try inflateSync
+ this.mode = BAD;
+ this.marker = 0; // can try inflateSync
break;
}
if(r == Z_OK){
return r;
}
r = f;
- z.istate.blocks.reset(z, z.istate.was);
- if(z.istate.nowrap!=0){
- z.istate.mode=DONE;
+ this.was=z.adler.getValue();
+ this.blocks.reset();
+ if(this.wrap==0){
+ this.mode=DONE;
break;
}
- z.istate.mode=CHECK4;
+ this.mode=CHECK4;
case CHECK4:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
- z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
- z.istate.mode=CHECK3;
+ this.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
+ this.mode=CHECK3;
case CHECK3:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
- z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
- z.istate.mode = CHECK2;
+ this.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
+ this.mode = CHECK2;
case CHECK2:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
- z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
- z.istate.mode = CHECK1;
+ this.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
+ this.mode = CHECK1;
case CHECK1:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
- z.istate.need+=(z.next_in[z.next_in_index++]&0xffL);
+ this.need+=(z.next_in[z.next_in_index++]&0xffL);
- if(((int)(z.istate.was[0])) != ((int)(z.istate.need))){
- z.istate.mode = BAD;
+ if(flags!=0){ // gzip
+ this.need = ((this.need&0xff000000)>>24 |
+ (this.need&0x00ff0000)>>8 |
+ (this.need&0x0000ff00)<<8 |
+ (this.need&0x0000ffff)<<24)&0xffffffffL;
+ }
+
+ if(((int)(this.was)) != ((int)(this.need))){
z.msg = "incorrect data check";
- z.istate.marker = 5; // can't try inflateSync
+ // chack is delayed
+ /*
+ this.mode = BAD;
+ this.marker = 5; // can't try inflateSync
break;
+ */
+ }
+ else if(flags!=0 && gheader!=null){
+ gheader.crc = this.need;
}
- z.istate.mode = DONE;
+ this.mode = LENGTH;
+ case LENGTH:
+ if (wrap!=0 && flags!=0) {
+
+ try { r=readBytes(4, r, f); }
+ catch(Return e){ return e.r; }
+
+ if(z.msg!=null && z.msg.equals("incorrect data check")){
+ this.mode = BAD;
+ this.marker = 5; // can't try inflateSync
+ break;
+ }
+
+ if (this.need != (z.total_out & 0xffffffffL)) {
+ z.msg = "incorrect length check";
+ this.mode = BAD;
+ break;
+ }
+ z.msg = null;
+ }
+ else {
+ if(z.msg!=null && z.msg.equals("incorrect data check")){
+ this.mode = BAD;
+ this.marker = 5; // can't try inflateSync
+ break;
+ }
+ }
+
+ this.mode = DONE;
case DONE:
return Z_STREAM_END;
case BAD:
return Z_DATA_ERROR;
+
+ case FLAGS:
+
+ try { r=readBytes(2, r, f); }
+ catch(Return e){ return e.r; }
+
+ flags = ((int)this.need)&0xffff;
+
+ if ((flags & 0xff) != Z_DEFLATED) {
+ z.msg = "unknown compression method";
+ this.mode = BAD;
+ break;
+ }
+ if ((flags & 0xe000)!=0) {
+ z.msg = "unknown header flags set";
+ this.mode = BAD;
+ break;
+ }
+
+ if ((flags & 0x0200)!=0){
+ checksum(2, this.need);
+ }
+
+ this.mode = TIME;
+
+ case TIME:
+ try { r=readBytes(4, r, f); }
+ catch(Return e){ return e.r; }
+ if(gheader!=null)
+ gheader.time = this.need;
+ if ((flags & 0x0200)!=0){
+ checksum(4, this.need);
+ }
+ this.mode = OS;
+ case OS:
+ try { r=readBytes(2, r, f); }
+ catch(Return e){ return e.r; }
+ if(gheader!=null){
+ gheader.xflags = ((int)this.need)&0xff;
+ gheader.os = (((int)this.need)>>8)&0xff;
+ }
+ if ((flags & 0x0200)!=0){
+ checksum(2, this.need);
+ }
+ this.mode = EXLEN;
+ case EXLEN:
+ if ((flags & 0x0400)!=0) {
+ try { r=readBytes(2, r, f); }
+ catch(Return e){ return e.r; }
+ if(gheader!=null){
+ gheader.extra = new byte[((int)this.need)&0xffff];
+ }
+ if ((flags & 0x0200)!=0){
+ checksum(2, this.need);
+ }
+ }
+ else if(gheader!=null){
+ gheader.extra=null;
+ }
+ this.mode = EXTRA;
+
+ case EXTRA:
+ if ((flags & 0x0400)!=0) {
+ try {
+ r=readBytes(r, f);
+ if(gheader!=null){
+ byte[] foo = tmp_string.toByteArray();
+ tmp_string=null;
+ if(foo.length == gheader.extra.length){
+ System.arraycopy(foo, 0, gheader.extra, 0, foo.length);
+ }
+ else{
+ z.msg = "bad extra field length";
+ this.mode = BAD;
+ break;
+ }
+ }
+ }
+ catch(Return e){ return e.r; }
+ }
+ else if(gheader!=null){
+ gheader.extra=null;
+ }
+ this.mode = NAME;
+ case NAME:
+ if ((flags & 0x0800)!=0) {
+ try {
+ r=readString(r, f);
+ if(gheader!=null){
+ gheader.name=tmp_string.toByteArray();
+ }
+ tmp_string=null;
+ }
+ catch(Return e){ return e.r; }
+ }
+ else if(gheader!=null){
+ gheader.name=null;
+ }
+ this.mode = COMMENT;
+ case COMMENT:
+ if ((flags & 0x1000)!=0) {
+ try {
+ r=readString(r, f);
+ if(gheader!=null){
+ gheader.comment=tmp_string.toByteArray();
+ }
+ tmp_string=null;
+ }
+ catch(Return e){ return e.r; }
+ }
+ else if(gheader!=null){
+ gheader.comment=null;
+ }
+ this.mode = HCRC;
+ case HCRC:
+ if ((flags & 0x0200)!=0) {
+ try { r=readBytes(2, r, f); }
+ catch(Return e){ return e.r; }
+ if(gheader!=null){
+ gheader.hcrc=(int)(this.need&0xffff);
+ }
+ if(this.need != (z.adler.getValue()&0xffffL)){
+ this.mode = BAD;
+ z.msg = "header crc mismatch";
+ this.marker = 5; // can't try inflateSync
+ break;
+ }
+ }
+ z.adler = new CRC32();
+
+ this.mode = BLOCKS;
+ break;
default:
return Z_STREAM_ERROR;
}
}
}
+ int inflateSetDictionary(byte[] dictionary, int dictLength){
+ if(z==null || (this.mode != DICT0 && this.wrap != 0)){
+ return Z_STREAM_ERROR;
+ }
- int inflateSetDictionary(ZStream z, byte[] dictionary, int dictLength){
int index=0;
int length = dictLength;
- if(z==null || z.istate == null|| z.istate.mode != DICT0)
- return Z_STREAM_ERROR;
- if(z._adler.adler32(1L, dictionary, 0, dictLength)!=z.adler){
- return Z_DATA_ERROR;
+ if(this.mode==DICT0){
+ long adler_need=z.adler.getValue();
+ z.adler.reset();
+ z.adler.update(dictionary, 0, dictLength);
+ if(z.adler.getValue()!=adler_need){
+ return Z_DATA_ERROR;
+ }
}
- z.adler = z._adler.adler32(0, null, 0, 0);
+ z.adler.reset();
- if(length >= (1<<z.istate.wbits)){
- length = (1<<z.istate.wbits)-1;
+ if(length >= (1<<this.wbits)){
+ length = (1<<this.wbits)-1;
index=dictLength - length;
}
- z.istate.blocks.set_dictionary(dictionary, index, length);
- z.istate.mode = BLOCKS;
+ this.blocks.set_dictionary(dictionary, index, length);
+ this.mode = BLOCKS;
return Z_OK;
}
static private byte[] mark = {(byte)0, (byte)0, (byte)0xff, (byte)0xff};
- int inflateSync(ZStream z){
+ int inflateSync(){
int n; // number of bytes to look at
int p; // pointer to bytes
int m; // number of marker bytes found in a row
long r, w; // temporaries to save total_in and total_out
// set up
- if(z == null || z.istate == null)
+ if(z == null)
return Z_STREAM_ERROR;
- if(z.istate.mode != BAD){
- z.istate.mode = BAD;
- z.istate.marker = 0;
+ if(this.mode != BAD){
+ this.mode = BAD;
+ this.marker = 0;
}
if((n=z.avail_in)==0)
return Z_BUF_ERROR;
- p=z.next_in_index;
- m=z.istate.marker;
+ p=z.next_in_index;
+ m=this.marker;
// search
while (n!=0 && m < 4){
if(z.next_in[p] == mark[m]){
z.total_in += p-z.next_in_index;
z.next_in_index = p;
z.avail_in = n;
- z.istate.marker = m;
+ this.marker = m;
// return no joy or set up to restart on a new block
if(m != 4){
return Z_DATA_ERROR;
}
r=z.total_in; w=z.total_out;
- inflateReset(z);
+ inflateReset();
z.total_in=r; z.total_out = w;
- z.istate.mode = BLOCKS;
+ this.mode = BLOCKS;
+
return Z_OK;
}
// but removes the length bytes of the resulting empty stored block. When
// decompressing, PPP checks that at the end of input packet, inflate is
// waiting for these length bytes.
- int inflateSyncPoint(ZStream z){
- if(z == null || z.istate == null || z.istate.blocks == null)
+ int inflateSyncPoint(){
+ if(z == null || this.blocks == null)
return Z_STREAM_ERROR;
- return z.istate.blocks.sync_point();
+ return this.blocks.sync_point();
+ }
+
+ private int readBytes(int n, int r, int f) throws Return{
+ if(need_bytes == -1){
+ need_bytes=n;
+ this.need=0;
+ }
+ while(need_bytes>0){
+ if(z.avail_in==0){ throw new Return(r); }; r=f;
+ z.avail_in--; z.total_in++;
+ this.need = this.need |
+ ((z.next_in[z.next_in_index++]&0xff)<<((n-need_bytes)*8));
+ need_bytes--;
+ }
+ if(n==2){
+ this.need&=0xffffL;
+ }
+ else if(n==4) {
+ this.need&=0xffffffffL;
+ }
+ need_bytes=-1;
+ return r;
+ }
+ class Return extends Exception{
+ int r;
+ Return(int r){this.r=r; }
+ }
+
+ private java.io.ByteArrayOutputStream tmp_string = null;
+ private int readString(int r, int f) throws Return{
+ if(tmp_string == null){
+ tmp_string=new java.io.ByteArrayOutputStream();
+ }
+ int b=0;
+ do {
+ if(z.avail_in==0){ throw new Return(r); }; r=f;
+ z.avail_in--; z.total_in++;
+ b = z.next_in[z.next_in_index];
+ if(b!=0) tmp_string.write(z.next_in, z.next_in_index, 1);
+ z.adler.update(z.next_in, z.next_in_index, 1);
+ z.next_in_index++;
+ }while(b!=0);
+ return r;
+ }
+
+ private int readBytes(int r, int f) throws Return{
+ if(tmp_string == null){
+ tmp_string=new java.io.ByteArrayOutputStream();
+ }
+ int b=0;
+ while(this.need>0){
+ if(z.avail_in==0){ throw new Return(r); }; r=f;
+ z.avail_in--; z.total_in++;
+ b = z.next_in[z.next_in_index];
+ tmp_string.write(z.next_in, z.next_in_index, 1);
+ z.adler.update(z.next_in, z.next_in_index, 1);
+ z.next_in_index++;
+ this.need--;
+ }
+ return r;
+ }
+
+ private void checksum(int n, long v){
+ for(int i=0; i<n; i++){
+ crcbuf[i]=(byte)(v&0xff);
+ v>>=8;
+ }
+ z.adler.update(crcbuf, 0, n);
+ }
+
+ public GZIPHeader getGZIPHeader(){
+ return gheader;
+ }
+
+ boolean inParsingHeader(){
+ switch(mode){
+ case HEAD:
+ case DICT4:
+ case DICT3:
+ case DICT2:
+ case DICT1:
+ case FLAGS:
+ case TIME:
+ case OS:
+ case EXLEN:
+ case EXTRA:
+ case NAME:
+ case COMMENT:
+ case HCRC:
+ return true;
+ default:
+ return false;
+ }
}
}
/* -*-mode:java; c-basic-offset:2; -*- */
/*
-Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+Copyright (c) 2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
package com.jcraft.jzlib;
final public class JZlib{
- private static final String version="1.0.2";
+ private static final String version="1.1.0";
public static String version(){return version;}
+ static final public int MAX_WBITS=15; // 32K LZ77 window
+ static final public int DEF_WBITS=MAX_WBITS;
+
// compression levels
static final public int Z_NO_COMPRESSION=0;
static final public int Z_BEST_SPEED=1;
static final public int Z_MEM_ERROR=-4;
static final public int Z_BUF_ERROR=-5;
static final public int Z_VERSION_ERROR=-6;
+
+ // The three kinds of block type
+ static final public byte Z_BINARY = 0;
+ static final public byte Z_ASCII = 1;
+ static final public byte Z_UNKNOWN = 2;
+
+ public static long adler32_combine(long adler1, long adler2, long len2){
+ return Adler32.combine(adler1, adler2, len2);
+ }
+
+ public static long crc32_combine(long crc1, long crc2, long len2){
+ return CRC32.combine(crc1, crc2, len2);
+ }
}
over to a BSD-style license.
------------------------------------------------------------------------------
-Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+Copyright (c) 2000-2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
http://www.jcraft.com/jzlib/
-Last modified: Fri Feb 14 13:31:26 UTC 2003
+Last modified: Mon Sep 19 15:28:43 UTC 2011
Description
===========
Directories & Files in the Source Tree
======================================
-* com/ has source trees of JZlib.
+* src/main/java has source trees of JZlib.
* example/ has some samples, which demonstrate the usages.
* misc/ has some stuffs. At present, this directory includes
a patch file for MindTerm v.1.2.1, which adds the packet compression
* JZlib does not support gzip file handling supports.
* The performance has not been estimated yet, but it will be not so bad
in deflating/inflating data stream on the low bandwidth network.
-* JZlib is licensed under BSD style license.
+* JZlib is under BSD style license.
* Any invention has not been done in developing JZlib.
So, if zlib is patent free, JZlib is also not covered by any patents.
This is our motivation to hack JZlib.
+Building Jar File
+=================
+Use 'sbt'(https://github.com/harrah/xsbt/wiki),
+ % sbt package
+or
+ % mvn package
+or
+ % cd src/main/java
+ % javac -target 1.5 com/jcraft/jzlib/*.java
+ % jar -cvf jzlib.jar com/jcraft/jzlib/*.class
+
+
A unofficial patch for MindTerm v.1.2.1
=======================================
A unofficial patch file for MindTerm v.1.2.1 has included in 'misc' directory.
========================
JZlib is copyrighted by ymnk, JCraft,Inc. and is licensed through BSD
style license. Read the LICENSE.txt file for the complete license.
-ZInputStream and ZOutputStream classes were contributed by Lapo Luchini.
Credits
int elems; // max number of elements in the tree
int max_length; // max bit length for the codes
- StaticTree(short[] static_tree,
- int[] extra_bits,
- int extra_base,
- int elems,
- int max_length
- ){
+ private StaticTree(short[] static_tree,
+ int[] extra_bits,
+ int extra_base,
+ int elems,
+ int max_length){
this.static_tree=static_tree;
this.extra_bits=extra_bits;
this.extra_base=extra_base;
// the given tree and the field len is set for all tree elements.
// OUT assertion: the field code is set for all tree elements of non
// zero code length.
- static void gen_codes(short[] tree, // the tree to decorate
- int max_code, // largest code with non zero frequency
- short[] bl_count // number of codes at each bit length
- ){
- short[] next_code=new short[MAX_BITS+1]; // next code value for each bit length
+ static short[] next_code=new short[MAX_BITS+1]; // next code value for each bit length
+ synchronized static void gen_codes(short[] tree, // the tree to decorate
+ int max_code, // largest code with non zero frequency
+ short[] bl_count // number of codes at each bit length
+ ){
short code = 0; // running code value
int bits; // bit index
int n; // code index
// The distribution counts are first used to generate the code values
// without bit reversal.
+ next_code[0]=0;
for (bits = 1; bits <= MAX_BITS; bits++) {
next_code[bits] = code = (short)((code + bl_count[bits-1]) << 1);
}
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/*
-Copyright (c) 2001 Lapo Luchini.
+Copyright (c) 2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS
-OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-/*
- * This program is based on zlib-1.1.3, so all credit should go authors
- * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
- * and contributors of zlib.
- */
package com.jcraft.jzlib;
import java.io.*;
+/**
+ * ZInputStream
+ *
+ * @deprecated use DeflaterOutputStream or InflaterInputStream
+ */
+@Deprecated
public class ZInputStream extends FilterInputStream {
- protected ZStream z=new ZStream();
- protected int bufsize=512;
protected int flush=JZlib.Z_NO_FLUSH;
- protected byte[] buf=new byte[bufsize],
- buf1=new byte[1];
protected boolean compress;
-
protected InputStream in=null;
- public ZInputStream(InputStream in) {
+ protected Deflater deflater;
+ protected InflaterInputStream iis;
+
+ public ZInputStream(InputStream in) throws IOException {
this(in, false);
}
- public ZInputStream(InputStream in, boolean nowrap) {
+ public ZInputStream(InputStream in, boolean nowrap) throws IOException {
super(in);
- this.in=in;
- z.inflateInit(nowrap);
+ iis = new InflaterInputStream(in);
compress=false;
- z.next_in=buf;
- z.next_in_index=0;
- z.avail_in=0;
}
- public ZInputStream(InputStream in, int level) {
+ public ZInputStream(InputStream in, int level) throws IOException {
super(in);
this.in=in;
- z.deflateInit(level);
+ deflater = new Deflater();
+ deflater.init(level);
compress=true;
- z.next_in=buf;
- z.next_in_index=0;
- z.avail_in=0;
}
- /*public int available() throws IOException {
- return inf.finished() ? 0 : 1;
- }*/
-
+ private byte[] buf1 = new byte[1];
public int read() throws IOException {
- if(read(buf1, 0, 1)==-1)
- return(-1);
+ if(read(buf1, 0, 1)==-1) return -1;
return(buf1[0]&0xFF);
}
- private boolean nomoreinput=false;
+ private byte[] buf = new byte[512];
public int read(byte[] b, int off, int len) throws IOException {
- if(len==0)
- return(0);
- int err;
- z.next_out=b;
- z.next_out_index=off;
- z.avail_out=len;
- do {
- if((z.avail_in==0)&&(!nomoreinput)) { // if buffer is empty and more input is avaiable, refill it
- z.next_in_index=0;
- z.avail_in=in.read(buf, 0, bufsize);//(bufsize<z.avail_out ? bufsize : z.avail_out));
- if(z.avail_in==-1) {
- z.avail_in=0;
- nomoreinput=true;
- }
+ if(compress){
+ deflater.setOutput(b, off, len);
+ while(true){
+ int datalen = in.read(buf, 0, buf.length);
+ if(datalen == -1) return -1;
+ deflater.setInput(buf, 0, datalen, true);
+ int err = deflater.deflate(flush);
+ if(deflater.next_out_index>0)
+ return deflater.next_out_index;
+ if(err == JZlib.Z_STREAM_END)
+ return 0;
+ if(err == JZlib.Z_STREAM_ERROR ||
+ err == JZlib.Z_DATA_ERROR){
+ throw new ZStreamException("deflating: "+deflater.msg);
+ }
}
- if(compress)
- err=z.deflate(flush);
- else
- err=z.inflate(flush);
- if(nomoreinput&&(err==JZlib.Z_BUF_ERROR))
- return(-1);
- if(err!=JZlib.Z_OK && err!=JZlib.Z_STREAM_END)
- throw new ZStreamException((compress ? "de" : "in")+"flating: "+z.msg);
- if((nomoreinput||err==JZlib.Z_STREAM_END)&&(z.avail_out==len))
- return(-1);
- }
- while(z.avail_out==len&&err==JZlib.Z_OK);
- //System.err.print("("+(len-z.avail_out)+")");
- return(len-z.avail_out);
+ }
+ else{
+ return iis.read(b, off, len);
+ }
}
public long skip(long n) throws IOException {
}
public int getFlushMode() {
- return(flush);
+ return flush;
}
public void setFlushMode(int flush) {
this.flush=flush;
}
- /**
- * Returns the total number of bytes input so far.
- */
public long getTotalIn() {
- return z.total_in;
+ if(compress) return deflater.total_in;
+ else return iis.getTotalIn();
}
- /**
- * Returns the total number of bytes output so far.
- */
public long getTotalOut() {
- return z.total_out;
+ if(compress) return deflater.total_out;
+ else return iis.getTotalOut();
}
public void close() throws IOException{
- in.close();
+ if(compress) deflater.end();
+ else iis.close();
}
}
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/*
-Copyright (c) 2001 Lapo Luchini.
+Copyright (c) 2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS
-OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-/*
- * This program is based on zlib-1.1.3, so all credit should go authors
- * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
- * and contributors of zlib.
- */
package com.jcraft.jzlib;
import java.io.*;
-public class ZOutputStream extends OutputStream {
+/**
+ * ZOutputStream
+ *
+ * @deprecated use DeflaterOutputStream or InflaterInputStream
+ */
+@Deprecated
+public class ZOutputStream extends FilterOutputStream {
- protected ZStream z=new ZStream();
protected int bufsize=512;
protected int flush=JZlib.Z_NO_FLUSH;
- protected byte[] buf=new byte[bufsize],
- buf1=new byte[1];
+ protected byte[] buf=new byte[bufsize];
protected boolean compress;
protected OutputStream out;
+ private boolean end=false;
+
+ private DeflaterOutputStream dos;
+ private Inflater inflater;
- public ZOutputStream(OutputStream out) {
- super();
+ public ZOutputStream(OutputStream out) throws IOException {
+ super(out);
this.out=out;
- z.inflateInit();
+ inflater = new Inflater();
+ inflater.init();
compress=false;
}
- public ZOutputStream(OutputStream out, int level) {
+ public ZOutputStream(OutputStream out, int level) throws IOException {
this(out, level, false);
}
- public ZOutputStream(OutputStream out, int level, boolean nowrap) {
- super();
+
+ public ZOutputStream(OutputStream out, int level, boolean nowrap) throws IOException {
+ super(out);
this.out=out;
- z.deflateInit(level, nowrap);
+ Deflater deflater = new Deflater(level, nowrap);
+ dos = new DeflaterOutputStream(out, deflater);
compress=true;
}
+ private byte[] buf1 = new byte[1];
public void write(int b) throws IOException {
buf1[0]=(byte)b;
write(buf1, 0, 1);
}
public void write(byte b[], int off, int len) throws IOException {
- if(len==0)
+ if(len==0) return;
+ if(compress){
+ dos.write(b, off, len);
+ }
+ else {
+ inflater.setInput(b, off, len, true);
+ int err = JZlib.Z_OK;
+ while(inflater.avail_in>0){
+ inflater.setOutput(buf, 0, buf.length);
+ err = inflater.inflate(flush);
+ if(inflater.next_out_index>0)
+ out.write(buf, 0, inflater.next_out_index);
+ if(err != JZlib.Z_OK)
+ break;
+ }
+ if(err != JZlib.Z_OK)
+ throw new ZStreamException("inflating: "+inflater.msg);
return;
- int err;
- z.next_in=b;
- z.next_in_index=off;
- z.avail_in=len;
- do{
- z.next_out=buf;
- z.next_out_index=0;
- z.avail_out=bufsize;
- if(compress)
- err=z.deflate(flush);
- else
- err=z.inflate(flush);
- if(err!=JZlib.Z_OK)
- throw new ZStreamException((compress?"de":"in")+"flating: "+z.msg);
- out.write(buf, 0, bufsize-z.avail_out);
- }
- while(z.avail_in>0 || z.avail_out==0);
+ }
}
public int getFlushMode() {
- return(flush);
+ return flush;
}
public void setFlushMode(int flush) {
public void finish() throws IOException {
int err;
- do{
- z.next_out=buf;
- z.next_out_index=0;
- z.avail_out=bufsize;
- if(compress){ err=z.deflate(JZlib.Z_FINISH); }
- else{ err=z.inflate(JZlib.Z_FINISH); }
- if(err!=JZlib.Z_STREAM_END && err != JZlib.Z_OK)
- throw new ZStreamException((compress?"de":"in")+"flating: "+z.msg);
- if(bufsize-z.avail_out>0){
- out.write(buf, 0, bufsize-z.avail_out);
+ if(compress){
+ int tmp = flush;
+ int flush = JZlib.Z_FINISH;
+ try{
+ write("".getBytes(), 0, 0);
}
+ finally { flush = tmp; }
+ }
+ else{
+ dos.finish();
}
- while(z.avail_in>0 || z.avail_out==0);
flush();
}
- public void end() {
- if(z==null)
- return;
- if(compress){ z.deflateEnd(); }
- else{ z.inflateEnd(); }
- z.free();
- z=null;
+ public synchronized void end() {
+ if(end) return;
+ if(compress){
+ try { dos.finish(); } catch(Exception e){}
+ }
+ else{
+ inflater.end();
+ }
+ end=true;
}
public void close() throws IOException {
try{
}
}
- /**
- * Returns the total number of bytes input so far.
- */
public long getTotalIn() {
- return z.total_in;
+ if(compress) return dos.getTotalIn();
+ else return inflater.total_in;
}
- /**
- * Returns the total number of bytes output so far.
- */
public long getTotalOut() {
- return z.total_out;
+ if(compress) return dos.getTotalOut();
+ else return inflater.total_out;
}
public void flush() throws IOException {
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/*
-Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+Copyright (c) 2000-2011 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
package com.jcraft.jzlib;
-final public class ZStream{
+/**
+ * ZStream
+ *
+ * @deprecated Not for public use in the future.
+ */
+@Deprecated
+public class ZStream{
static final private int MAX_WBITS=15; // 32K LZ77 window
static final private int DEF_WBITS=MAX_WBITS;
int data_type; // best guess about the data type: ascii or binary
- public long adler;
- Adler32 _adler=new Adler32();
+ Checksum adler;
+
+ public ZStream(){
+ this(new Adler32());
+ }
+
+ public ZStream(Checksum adler){
+ this.adler=adler;
+ }
public int inflateInit(){
return inflateInit(DEF_WBITS);
}
public int inflateInit(int w, boolean nowrap){
- istate=new Inflate();
- return istate.inflateInit(this, nowrap?-w:w);
+ istate=new Inflate(this);
+ return istate.inflateInit(nowrap?-w:w);
}
public int inflate(int f){
if(istate==null) return Z_STREAM_ERROR;
- return istate.inflate(this, f);
+ return istate.inflate(f);
}
public int inflateEnd(){
if(istate==null) return Z_STREAM_ERROR;
- int ret=istate.inflateEnd(this);
- istate = null;
+ int ret=istate.inflateEnd();
+// istate = null;
return ret;
}
public int inflateSync(){
if(istate == null)
return Z_STREAM_ERROR;
- return istate.inflateSync(this);
+ return istate.inflateSync();
+ }
+ public int inflateSyncPoint(){
+ if(istate == null)
+ return Z_STREAM_ERROR;
+ return istate.inflateSyncPoint();
}
public int inflateSetDictionary(byte[] dictionary, int dictLength){
if(istate == null)
return Z_STREAM_ERROR;
- return istate.inflateSetDictionary(this, dictionary, dictLength);
+ return istate.inflateSetDictionary(dictionary, dictLength);
+ }
+ public boolean inflateFinished(){
+ return istate.mode==12 /*DONE*/;
}
public int deflateInit(int level){
public int deflateInit(int level, int bits){
return deflateInit(level, bits, false);
}
+ public int deflateInit(int level, int bits, int memlevel){
+ dstate=new Deflate(this);
+ return dstate.deflateInit(level, bits, memlevel);
+ }
public int deflateInit(int level, int bits, boolean nowrap){
- dstate=new Deflate();
- return dstate.deflateInit(this, level, nowrap?-bits:bits);
+ dstate=new Deflate(this);
+ return dstate.deflateInit(level, nowrap?-bits:bits);
}
public int deflate(int flush){
if(dstate==null){
return Z_STREAM_ERROR;
}
- return dstate.deflate(this, flush);
+ return dstate.deflate(flush);
}
public int deflateEnd(){
if(dstate==null) return Z_STREAM_ERROR;
}
public int deflateParams(int level, int strategy){
if(dstate==null) return Z_STREAM_ERROR;
- return dstate.deflateParams(this, level, strategy);
+ return dstate.deflateParams(level, strategy);
}
public int deflateSetDictionary (byte[] dictionary, int dictLength){
if(dstate == null)
return Z_STREAM_ERROR;
- return dstate.deflateSetDictionary(this, dictionary, dictLength);
+ return dstate.deflateSetDictionary(dictionary, dictLength);
}
// Flush as much pending output as possible. All deflate() output goes
next_out.length<=next_out_index ||
dstate.pending_buf.length<(dstate.pending_out+len) ||
next_out.length<(next_out_index+len)){
- System.out.println(dstate.pending_buf.length+", "+dstate.pending_out+
- ", "+next_out.length+", "+next_out_index+", "+len);
- System.out.println("avail_out="+avail_out);
+ //System.out.println(dstate.pending_buf.length+", "+dstate.pending_out+
+ // ", "+next_out.length+", "+next_out_index+", "+len);
+ //System.out.println("avail_out="+avail_out);
}
System.arraycopy(dstate.pending_buf, dstate.pending_out,
avail_in-=len;
- if(dstate.noheader==0) {
- adler=_adler.adler32(adler, next_in, next_in_index, len);
+ if(dstate.wrap!=0) {
+ adler.update(next_in, next_in_index, len);
}
System.arraycopy(next_in, next_in_index, buf, start, len);
next_in_index += len;
return len;
}
+ public long getAdler(){
+ return adler.getValue();
+ }
+
public void free(){
next_in=null;
next_out=null;
msg=null;
- _adler=null;
}
+
+ public void setOutput(byte[] buf){
+ setOutput(buf, 0, buf.length);
+ }
+
+ public void setOutput(byte[] buf, int off, int len){
+ next_out = buf;
+ next_out_index = off;
+ avail_out = len;
+ }
+
+ public void setInput(byte[] buf){
+ setInput(buf, 0, buf.length, false);
+ }
+
+ public void setInput(byte[] buf, boolean append){
+ setInput(buf, 0, buf.length, append);
+ }
+
+ public void setInput(byte[] buf, int off, int len, boolean append){
+ if(len<=0 && append && next_in!=null) return;
+
+ if(avail_in>0 && append){
+ byte[] tmp = new byte[avail_in+len];
+ System.arraycopy(next_in, next_in_index, tmp, 0, avail_in);
+ System.arraycopy(buf, off, tmp, avail_in, len);
+ next_in=tmp;
+ next_in_index=0;
+ avail_in+=len;
+ }
+ else{
+ next_in=buf;
+ next_in_index=off;
+ avail_in=len;
+ }
+ }
+
+ public byte[] getNextIn(){
+ return next_in;
+ }
+
+ public void setNextIn(byte[] next_in){
+ this.next_in = next_in;
+ }
+
+ public int getNextInIndex(){
+ return next_in_index;
+ }
+
+ public void setNextInIndex(int next_in_index){
+ this.next_in_index = next_in_index;
+ }
+
+ public int getAvailIn(){
+ return avail_in;
+ }
+
+ public void setAvailIn(int avail_in){
+ this.avail_in = avail_in;
+ }
+
+ public byte[] getNextOut(){
+ return next_out;
+ }
+
+ public void setNextOut(byte[] next_out){
+ this.next_out = next_out;
+ }
+
+ public int getNextOutIndex(){
+ return next_out_index;
+ }
+
+ public void setNextOutIndex(int next_out_index){
+ this.next_out_index = next_out_index;
+ }
+
+ public int getAvailOut(){
+ return avail_out;
+
+ }
+
+ public void setAvailOut(int avail_out){
+ this.avail_out = avail_out;
+ }
+
+ public long getTotalOut(){
+ return total_out;
+ }
+
+ public long getTotalIn(){
+ return total_in;
+ }
+
+ public String getMessage(){
+ return msg;
+ }
+
+ /**
+ * Those methods are expected to be override by Inflater and Deflater.
+ * In the future, they will become abstract methods.
+ */
+ public int end(){ return Z_OK; }
+ public boolean finished(){ return false; }
}
projects / tigervnc.git / commitdiff