libcore/archive/src/main/native/java_util_zip_Inflater.c - platform/dalvik - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "hy2sie.h"
 #include "zip.h"

 #include "zlib.h"
 #include <memory.h>
 #define jclmem_allocate_memory(env, byteCount) sieb_malloc(env, byteCount)
 #define jclmem_free_memory(env, pointer) sieb_free(env, pointer)

 #include <fcntl.h>

 void throwNewDataFormatException (JNIEnv * env, const char *message);

 void zfree PROTOTYPE ((void *opaque, void *address));
 void *zalloc PROTOTYPE ((void *opaque, U_32 items, U_32 size));


 static struct {
     jfieldID inRead;
     jfieldID finished;
     jfieldID needsDictionary;
 } gCachedFields;


 /* Create a new stream . This stream cannot be used until it has been properly initialized. */
 JNIEXPORT jlong JNICALL
 Java_java_util_zip_Inflater_createStream (JNIEnv * env, jobject recv,
                                           jboolean noHeader)
 {
   PORT_ACCESS_FROM_ENV (env);

   JCLZipStream *jstream;
   z_stream *stream;
   int err = 0;
   int wbits = 15;               /*Use MAX for fastest */
 #ifdef HY_ZIP_API
   VMI_ACCESS_FROM_ENV (env);
   VMIZipFunctionTable *zipFuncs;
   zipFuncs = (*VMI)->GetZipFunctions(VMI);
 #endif

   /*Allocate mem for wrapped struct */
   jstream = jclmem_allocate_memory (env, sizeof (JCLZipStream));
   if (jstream == NULL)
     {
       throwNewOutOfMemoryError (env, "");
       return -1;
     }

   /*Allocate the z_stream */
   stream = jclmem_allocate_memory (env, sizeof (z_stream));
   if (stream == NULL)
     {
       jclmem_free_memory (env, jstream);
       throwNewOutOfMemoryError (env, "");
       return -1;
     }
   stream->opaque = (void *) privatePortLibrary;
   stream->zalloc = zalloc;
   stream->zfree = zfree;
   stream->adler = 1;
   jstream->stream = stream;
   jstream->dict = NULL;
   jstream->inaddr = NULL;
   jstream->inCap = 0;

   /*
    * In the range 8..15 for checked, or -8..-15 for unchecked inflate. Unchecked
    * is appropriate for formats like zip that do their own validity checking.
    */
   if (noHeader)
     wbits = wbits / -1;
   err = inflateInit2 (stream, wbits);   /*Window bits to use. 15 is fastest but consumes the most memory */

   if (err != Z_OK)
     {
       jclmem_free_memory (env, stream);
       jclmem_free_memory (env, jstream);
       THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException);
       return -1;
     }

   return (jlong) ((IDATA) jstream);
 }

 JNIEXPORT void JNICALL
 Java_java_util_zip_Inflater_setInputImpl (JNIEnv * env, jobject recv,
                                           jbyteArray buf, jint off, jint len,
                                           jlong handle)
 {
   PORT_ACCESS_FROM_ENV (env);

   JCLZipStream *stream = (JCLZipStream *) ((IDATA) handle);
   if (stream->inaddr != NULL) {
     /* Input has already been provided, free the old buffer. */
     jclmem_free_memory (env, stream->inaddr);
   }
   U_8* baseAddr = jclmem_allocate_memory (env, len);
   if (baseAddr == NULL) {
     throwNewOutOfMemoryError (env, "");
     return;
   }
   stream->inaddr = baseAddr;
   stream->stream->next_in = (Bytef *) baseAddr;
   stream->stream->avail_in = len;
   (*env)->GetByteArrayRegion(env, buf, off, len, (jbyte*) baseAddr);
 }

 JNIEXPORT jint JNICALL
 Java_java_util_zip_Inflater_setFileInputImpl (JNIEnv * env, jobject recv,
         jobject javaFileDescriptor, jlong off, jint len, jlong handle)
 {
     PORT_ACCESS_FROM_ENV (env);

     U_8 * baseAddr;
     JCLZipStream * stream = (JCLZipStream *) ((IDATA) handle);

     if (stream->inCap < len) {
         // No input buffer as yet (or one that is too small).
         jclmem_free_memory(env, stream->inaddr);
         baseAddr = jclmem_allocate_memory(env, len);
         if (baseAddr == NULL)
         {
             throwNewOutOfMemoryError(env, "");
             return -1;
         }
         stream->inaddr = baseAddr;
     }
     stream->stream->next_in = (Bytef *) stream->inaddr;
     stream->stream->avail_in = len;

     int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
     lseek(fd, off, SEEK_SET);
     int cnt = read(fd, stream->inaddr, len);

     return cnt;
 }

 JNIEXPORT jint JNICALL
 Java_java_util_zip_Inflater_inflateImpl (JNIEnv * env, jobject recv,
                                          jbyteArray buf, int off, int len,
                                          jlong handle)
 {
   jbyte *out;
   JCLZipStream *stream = (JCLZipStream *) ((IDATA) handle);
   jint err = 0;
   jfieldID fid = 0, fid2 = 0;
   jint sin, sout, inBytes = 0;

   /* We need to get the number of bytes already read */
   fid = gCachedFields.inRead;
   inBytes = ((*env)->GetIntField (env, recv, fid));

   stream->stream->avail_out = len;
   sin = stream->stream->total_in;
   sout = stream->stream->total_out;
   out = ((*env)->GetPrimitiveArrayCritical (env, buf, 0));
   if (out == NULL) {
     throwNewOutOfMemoryError(env, "");
     return -1;
   }
   stream->stream->next_out = (Bytef *) out + off;
   err = inflate (stream->stream, Z_SYNC_FLUSH);
   ((*env)->ReleasePrimitiveArrayCritical (env, buf, out, 0));

   if (err != Z_OK)
     {
       if(err == Z_STREAM_ERROR) {
           return 0;
       }
       if (err == Z_STREAM_END || err == Z_NEED_DICT)
         {
           ((*env)->SetIntField (env, recv, fid, (jint) stream->stream->total_in - sin + inBytes));      /* Update inRead */
           if (err == Z_STREAM_END)
             fid2 = gCachedFields.finished;
           else
             fid2 = gCachedFields.needsDictionary;

           ((*env)->SetBooleanField (env, recv, fid2, JNI_TRUE));
           return stream->stream->total_out - sout;
         }
       else
         {
           THROW_ZIP_EXCEPTION(env, err, DataFormatException);
           return -1;
         }
     }

   /* Need to update the number of input bytes read. Is there a better way
    * (Maybe global the fid then delete when end is called)?
    */
   ((*env)->
    SetIntField (env, recv, fid,
                 (jint) stream->stream->total_in - sin + inBytes));

   return stream->stream->total_out - sout;
 }

 JNIEXPORT jint JNICALL
 Java_java_util_zip_Inflater_getAdlerImpl (JNIEnv * env, jobject recv,
                                           jlong handle)
 {
   JCLZipStream *stream;

   stream = (JCLZipStream *) ((IDATA) handle);

   return stream->stream->adler;
 }

 JNIEXPORT void JNICALL
 Java_java_util_zip_Inflater_endImpl (JNIEnv * env, jobject recv, jlong handle)
 {
   PORT_ACCESS_FROM_ENV (env);
   JCLZipStream *stream;

   stream = (JCLZipStream *) ((IDATA) handle);
   inflateEnd (stream->stream);
   if (stream->inaddr != NULL)   /*Input has been provided, free the buffer */
     jclmem_free_memory (env, stream->inaddr);
   if (stream->dict != NULL)
     jclmem_free_memory (env, stream->dict);
   jclmem_free_memory (env, stream->stream);
   jclmem_free_memory (env, stream);
 }

 JNIEXPORT void JNICALL
 Java_java_util_zip_Inflater_setDictionaryImpl (JNIEnv * env, jobject recv,
                                                jbyteArray dict, int off,
                                                int len, jlong handle)
 {
   PORT_ACCESS_FROM_ENV (env);
   int err = 0;
   U_8 *dBytes;
   JCLZipStream *stream = (JCLZipStream *) ((IDATA) handle);

   dBytes = jclmem_allocate_memory (env, len);
   if (dBytes == NULL)
     {
       throwNewOutOfMemoryError (env, "");
       return;
     }
   (*env)->GetByteArrayRegion (env, dict, off, len, (mcSignednessBull)dBytes);
   err = inflateSetDictionary (stream->stream, (Bytef *) dBytes, len);
   if (err != Z_OK)
     {
       jclmem_free_memory (env, dBytes);
       THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException);
       return;
     }
   stream->dict = dBytes;
 }

 JNIEXPORT void JNICALL
 Java_java_util_zip_Inflater_resetImpl (JNIEnv * env, jobject recv,
                                        jlong handle)
 {
   JCLZipStream *stream;
   int err = 0;
   stream = (JCLZipStream *) ((IDATA) handle);

   err = inflateReset (stream->stream);
   if (err != Z_OK)
     {
       THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException);
       return;
     }
 }

 /**
   * Throw java.util.zip.DataFormatException
   */
 void
 throwNewDataFormatException (JNIEnv * env, const char *message)
 {
   jniThrowException(env, "java/util/zip/DataFormatException", message);
 }

 JNIEXPORT jlong JNICALL
 Java_java_util_zip_Inflater_getTotalOutImpl (JNIEnv * env, jobject recv,
                                              jlong handle)
 {
   JCLZipStream *stream;

   stream = (JCLZipStream *) ((IDATA) handle);
   return stream->stream->total_out;

 }

 JNIEXPORT jlong JNICALL
 Java_java_util_zip_Inflater_getTotalInImpl (JNIEnv * env, jobject recv,
                                             jlong handle)
 {
   JCLZipStream *stream;

   stream = (JCLZipStream *) ((IDATA) handle);
   return stream->stream->total_in;
 }

 JNIEXPORT void JNICALL
 Java_java_util_zip_Inflater_oneTimeInitialization (JNIEnv * env, jclass clazz)
 {
     memset(&gCachedFields, 0, sizeof(gCachedFields));
     gCachedFields.inRead = (*env)->GetFieldID (env, clazz, "inRead", "I");
     gCachedFields.finished = (*env)->GetFieldID (env, clazz, "finished", "Z");
     gCachedFields.needsDictionary = (*env)->GetFieldID (env, clazz, "needsDictionary", "Z");
 }

 /*
  * JNI registration
  */
 static JNINativeMethod gMethods[] = {
     /* name, signature, funcPtr */
     { "createStream", "(Z)J",     Java_java_util_zip_Inflater_createStream },
     { "setInputImpl", "([BIIJ)V",     Java_java_util_zip_Inflater_setInputImpl },
     { "setFileInputImpl", "(Ljava/io/FileDescriptor;JIJ)I",     Java_java_util_zip_Inflater_setFileInputImpl },
     { "inflateImpl", "([BIIJ)I",     Java_java_util_zip_Inflater_inflateImpl },
     { "getAdlerImpl", "(J)I",     Java_java_util_zip_Inflater_getAdlerImpl },
     { "endImpl", "(J)V",     Java_java_util_zip_Inflater_endImpl },
     { "setDictionaryImpl", "([BIIJ)V",     Java_java_util_zip_Inflater_setDictionaryImpl },
     { "resetImpl", "(J)V",     Java_java_util_zip_Inflater_resetImpl },
     { "getTotalOutImpl", "(J)J",     Java_java_util_zip_Inflater_getTotalOutImpl },
     { "getTotalInImpl", "(J)J",     Java_java_util_zip_Inflater_getTotalInImpl },
     { "oneTimeInitialization", "()V",     Java_java_util_zip_Inflater_oneTimeInitialization },
 };
 int register_java_util_zip_Inflater(JNIEnv* env)
 {
     return jniRegisterNativeMethods(env, "java/util/zip/Inflater",
                 gMethods, NELEM(gMethods));
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "hy2sie.h"
	#include "zip.h"

	#include "zlib.h"
	#include <memory.h>
	#define jclmem_allocate_memory(env, byteCount) sieb_malloc(env, byteCount)
	#define jclmem_free_memory(env, pointer) sieb_free(env, pointer)

	#include <fcntl.h>

	void throwNewDataFormatException (JNIEnv * env, const char *message);

	void zfree PROTOTYPE ((void opaque, void address));
	void zalloc PROTOTYPE ((void opaque, U_32 items, U_32 size));


	static struct {
	jfieldID inRead;
	jfieldID finished;
	jfieldID needsDictionary;
	} gCachedFields;



	/* Create a new stream . This stream cannot be used until it has been properly initialized. */
	JNIEXPORT jlong JNICALL
	Java_java_util_zip_Inflater_createStream (JNIEnv * env, jobject recv,
	jboolean noHeader)
	{
	PORT_ACCESS_FROM_ENV (env);

	JCLZipStream *jstream;
	z_stream *stream;
	int err = 0;
	int wbits = 15; /Use MAX for fastest /
	#ifdef HY_ZIP_API
	VMI_ACCESS_FROM_ENV (env);
	VMIZipFunctionTable *zipFuncs;
	zipFuncs = (*VMI)->GetZipFunctions(VMI);
	#endif

	/Allocate mem for wrapped struct /
	jstream = jclmem_allocate_memory (env, sizeof (JCLZipStream));
	if (jstream == NULL)
	{
	throwNewOutOfMemoryError (env, "");
	return -1;
	}

	/Allocate the z_stream /
	stream = jclmem_allocate_memory (env, sizeof (z_stream));
	if (stream == NULL)
	{
	jclmem_free_memory (env, jstream);
	throwNewOutOfMemoryError (env, "");
	return -1;
	}
	stream->opaque = (void *) privatePortLibrary;
	stream->zalloc = zalloc;
	stream->zfree = zfree;
	stream->adler = 1;
	jstream->stream = stream;
	jstream->dict = NULL;
	jstream->inaddr = NULL;
	jstream->inCap = 0;

	/*
	* In the range 8..15 for checked, or -8..-15 for unchecked inflate. Unchecked
	* is appropriate for formats like zip that do their own validity checking.
	*/
	if (noHeader)
	wbits = wbits / -1;
	err = inflateInit2 (stream, wbits); /Window bits to use. 15 is fastest but consumes the most memory /

	if (err != Z_OK)
	{
	jclmem_free_memory (env, stream);
	jclmem_free_memory (env, jstream);
	THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException);
	return -1;
	}

	return (jlong) ((IDATA) jstream);
	}

	JNIEXPORT void JNICALL
	Java_java_util_zip_Inflater_setInputImpl (JNIEnv * env, jobject recv,
	jbyteArray buf, jint off, jint len,
	jlong handle)
	{
	PORT_ACCESS_FROM_ENV (env);

	JCLZipStream stream = (JCLZipStream ) ((IDATA) handle);
	if (stream->inaddr != NULL) {
	/* Input has already been provided, free the old buffer. */
	jclmem_free_memory (env, stream->inaddr);
	}
	U_8* baseAddr = jclmem_allocate_memory (env, len);
	if (baseAddr == NULL) {
	throwNewOutOfMemoryError (env, "");
	return;
	}
	stream->inaddr = baseAddr;
	stream->stream->next_in = (Bytef *) baseAddr;
	stream->stream->avail_in = len;
	(env)->GetByteArrayRegion(env, buf, off, len, (jbyte) baseAddr);
	}

	JNIEXPORT jint JNICALL
	Java_java_util_zip_Inflater_setFileInputImpl (JNIEnv * env, jobject recv,
	jobject javaFileDescriptor, jlong off, jint len, jlong handle)
	{
	PORT_ACCESS_FROM_ENV (env);

	U_8 * baseAddr;
	JCLZipStream * stream = (JCLZipStream *) ((IDATA) handle);

	if (stream->inCap < len) {
	// No input buffer as yet (or one that is too small).
	jclmem_free_memory(env, stream->inaddr);
	baseAddr = jclmem_allocate_memory(env, len);
	if (baseAddr == NULL)
	{
	throwNewOutOfMemoryError(env, "");
	return -1;
	}
	stream->inaddr = baseAddr;
	}
	stream->stream->next_in = (Bytef *) stream->inaddr;
	stream->stream->avail_in = len;

	int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
	lseek(fd, off, SEEK_SET);
	int cnt = read(fd, stream->inaddr, len);

	return cnt;
	}

	JNIEXPORT jint JNICALL
	Java_java_util_zip_Inflater_inflateImpl (JNIEnv * env, jobject recv,
	jbyteArray buf, int off, int len,
	jlong handle)
	{
	jbyte *out;
	JCLZipStream stream = (JCLZipStream ) ((IDATA) handle);
	jint err = 0;
	jfieldID fid = 0, fid2 = 0;
	jint sin, sout, inBytes = 0;

	/* We need to get the number of bytes already read */
	fid = gCachedFields.inRead;
	inBytes = ((*env)->GetIntField (env, recv, fid));

	stream->stream->avail_out = len;
	sin = stream->stream->total_in;
	sout = stream->stream->total_out;
	out = ((*env)->GetPrimitiveArrayCritical (env, buf, 0));
	if (out == NULL) {
	throwNewOutOfMemoryError(env, "");
	return -1;
	}
	stream->stream->next_out = (Bytef *) out + off;
	err = inflate (stream->stream, Z_SYNC_FLUSH);
	((*env)->ReleasePrimitiveArrayCritical (env, buf, out, 0));

	if (err != Z_OK)
	{
	if(err == Z_STREAM_ERROR) {
	return 0;
	}
	if (err == Z_STREAM_END \|\| err == Z_NEED_DICT)
	{
	((env)->SetIntField (env, recv, fid, (jint) stream->stream->total_in - sin + inBytes)); / Update inRead */
	if (err == Z_STREAM_END)
	fid2 = gCachedFields.finished;
	else
	fid2 = gCachedFields.needsDictionary;

	((*env)->SetBooleanField (env, recv, fid2, JNI_TRUE));
	return stream->stream->total_out - sout;
	}
	else
	{
	THROW_ZIP_EXCEPTION(env, err, DataFormatException);
	return -1;
	}
	}

	/* Need to update the number of input bytes read. Is there a better way
	* (Maybe global the fid then delete when end is called)?
	*/
	((*env)->
	SetIntField (env, recv, fid,
	(jint) stream->stream->total_in - sin + inBytes));

	return stream->stream->total_out - sout;
	}

	JNIEXPORT jint JNICALL
	Java_java_util_zip_Inflater_getAdlerImpl (JNIEnv * env, jobject recv,
	jlong handle)
	{
	JCLZipStream *stream;

	stream = (JCLZipStream *) ((IDATA) handle);

	return stream->stream->adler;
	}

	JNIEXPORT void JNICALL
	Java_java_util_zip_Inflater_endImpl (JNIEnv * env, jobject recv, jlong handle)
	{
	PORT_ACCESS_FROM_ENV (env);
	JCLZipStream *stream;

	stream = (JCLZipStream *) ((IDATA) handle);
	inflateEnd (stream->stream);
	if (stream->inaddr != NULL) /Input has been provided, free the buffer /
	jclmem_free_memory (env, stream->inaddr);
	if (stream->dict != NULL)
	jclmem_free_memory (env, stream->dict);
	jclmem_free_memory (env, stream->stream);
	jclmem_free_memory (env, stream);
	}

	JNIEXPORT void JNICALL
	Java_java_util_zip_Inflater_setDictionaryImpl (JNIEnv * env, jobject recv,
	jbyteArray dict, int off,
	int len, jlong handle)
	{
	PORT_ACCESS_FROM_ENV (env);
	int err = 0;
	U_8 *dBytes;
	JCLZipStream stream = (JCLZipStream ) ((IDATA) handle);

	dBytes = jclmem_allocate_memory (env, len);
	if (dBytes == NULL)
	{
	throwNewOutOfMemoryError (env, "");
	return;
	}
	(*env)->GetByteArrayRegion (env, dict, off, len, (mcSignednessBull)dBytes);
	err = inflateSetDictionary (stream->stream, (Bytef *) dBytes, len);
	if (err != Z_OK)
	{
	jclmem_free_memory (env, dBytes);
	THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException);
	return;
	}
	stream->dict = dBytes;
	}

	JNIEXPORT void JNICALL
	Java_java_util_zip_Inflater_resetImpl (JNIEnv * env, jobject recv,
	jlong handle)
	{
	JCLZipStream *stream;
	int err = 0;
	stream = (JCLZipStream *) ((IDATA) handle);

	err = inflateReset (stream->stream);
	if (err != Z_OK)
	{
	THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException);
	return;
	}
	}

	/**
	* Throw java.util.zip.DataFormatException
	*/
	void
	throwNewDataFormatException (JNIEnv * env, const char *message)
	{
	jniThrowException(env, "java/util/zip/DataFormatException", message);
	}

	JNIEXPORT jlong JNICALL
	Java_java_util_zip_Inflater_getTotalOutImpl (JNIEnv * env, jobject recv,
	jlong handle)
	{
	JCLZipStream *stream;

	stream = (JCLZipStream *) ((IDATA) handle);
	return stream->stream->total_out;

	}

	JNIEXPORT jlong JNICALL
	Java_java_util_zip_Inflater_getTotalInImpl (JNIEnv * env, jobject recv,
	jlong handle)
	{
	JCLZipStream *stream;

	stream = (JCLZipStream *) ((IDATA) handle);
	return stream->stream->total_in;
	}

	JNIEXPORT void JNICALL
	Java_java_util_zip_Inflater_oneTimeInitialization (JNIEnv * env, jclass clazz)
	{
	memset(&gCachedFields, 0, sizeof(gCachedFields));
	gCachedFields.inRead = (*env)->GetFieldID (env, clazz, "inRead", "I");
	gCachedFields.finished = (*env)->GetFieldID (env, clazz, "finished", "Z");
	gCachedFields.needsDictionary = (*env)->GetFieldID (env, clazz, "needsDictionary", "Z");
	}

	/*
	* JNI registration
	*/
	static JNINativeMethod gMethods[] = {
	/* name, signature, funcPtr */
	{ "createStream", "(Z)J", Java_java_util_zip_Inflater_createStream },
	{ "setInputImpl", "([BIIJ)V", Java_java_util_zip_Inflater_setInputImpl },
	{ "setFileInputImpl", "(Ljava/io/FileDescriptor;JIJ)I", Java_java_util_zip_Inflater_setFileInputImpl },
	{ "inflateImpl", "([BIIJ)I", Java_java_util_zip_Inflater_inflateImpl },
	{ "getAdlerImpl", "(J)I", Java_java_util_zip_Inflater_getAdlerImpl },
	{ "endImpl", "(J)V", Java_java_util_zip_Inflater_endImpl },
	{ "setDictionaryImpl", "([BIIJ)V", Java_java_util_zip_Inflater_setDictionaryImpl },
	{ "resetImpl", "(J)V", Java_java_util_zip_Inflater_resetImpl },
	{ "getTotalOutImpl", "(J)J", Java_java_util_zip_Inflater_getTotalOutImpl },
	{ "getTotalInImpl", "(J)J", Java_java_util_zip_Inflater_getTotalInImpl },
	{ "oneTimeInitialization", "()V", Java_java_util_zip_Inflater_oneTimeInitialization },
	};
	int register_java_util_zip_Inflater(JNIEnv* env)
	{
	return jniRegisterNativeMethods(env, "java/util/zip/Inflater",
	gMethods, NELEM(gMethods));
	}