JNIEXPORT jint JNICALL
Java_java_util_zip_ZipFile_openZipImpl (JNIEnv * env, jobject recv,
jbyteArray zipName)
{
VMI_ACCESS_FROM_ENV (env);
PORT_ACCESS_FROM_ENV (env);
I_32 retval;
JCLZipFile *jclZipFile;
JCLZipFileLink *zipfileHandles;
jsize length;
char pathCopy[HyMaxPath];
HyZipCachePool *zipCachePool;
jclZipFile = jclmem_allocate_memory (env, sizeof (*jclZipFile));
if (!jclZipFile)
return 3;
length = (*env)->GetArrayLength (env, zipName);
length = length < HyMaxPath - 1 ? length : HyMaxPath - 1;
((*env)->GetByteArrayRegion (env, zipName, 0, length, pathCopy));
pathCopy[length++] = '\0';
ioh_convertToPlatform (pathCopy);
/* Open the zip file (caching will be managed automatically by zipsup) */
zipCachePool = (*VMI)->GetZipCachePool (VMI);
retval =
zip_openZipFile (privatePortLibrary, pathCopy, &(jclZipFile->hyZipFile),
zipCachePool);
if (retval)
{
jclmem_free_memory (env, jclZipFile); /* free on fail */
if (retval == ZIP_ERR_FILE_OPEN_ERROR)
return 1;
else
return 2;
}
/* Add the zipFile we just allocated to the list of zip files -- we will
* free this on UnLoad if its not already free'd.
*/
zipfileHandles = JCL_CACHE_GET (env, zipfile_handles);
jclZipFile->last = (JCLZipFile *) zipfileHandles;
jclZipFile->next = zipfileHandles->next;
if (zipfileHandles->next != NULL)
zipfileHandles->next->last = jclZipFile;
zipfileHandles->next = jclZipFile;
(*env)->SetLongField (env, recv,
JCL_CACHE_GET (env,
FID_java_util_zip_ZipFile_descriptor),
((IDATA) jclZipFile));
return 0;
}
JNIEXPORT jint JNICALL
Java_java_util_zip_Deflater_deflateImpl (JNIEnv * env, jobject recv,
jbyteArray buf, int off, int len,
jlong handle, int flushParm)
{
jbyte *out;
JCLZipStream *stream;
jint err = 0;
jint sin, sout, inBytes = 0;
/* We need to get the number of bytes already read */
inBytes =
((*env)->
GetIntField (env, recv,
JCL_CACHE_GET (env, FID_java_util_zip_Deflater_inRead)));
stream = (JCLZipStream *) ((IDATA) handle);
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 = deflate (stream->stream, flushParm);
((*env)->ReleasePrimitiveArrayCritical (env, buf, out, 0));
if (err != Z_OK) {
if (err == Z_MEM_ERROR) {
throwNewOutOfMemoryError(env, "");
return 0;
}
if (err == Z_STREAM_END)
{
((*env)->
SetBooleanField (env, recv,
JCL_CACHE_GET (env,
FID_java_util_zip_Deflater_finished),
JNI_TRUE));
return stream->stream->total_out - sout;
}
}
if (flushParm != Z_FINISH)
{
/* Need to update the number of input bytes read. */
((*env)->
SetIntField (env, recv,
JCL_CACHE_GET (env, FID_java_util_zip_Deflater_inRead),
(jint) stream->stream->total_in - sin + inBytes));
}
return stream->stream->total_out - sout;
}
JNIEXPORT void JNICALL
Java_java_util_zip_ZipFile_closeZipImpl (JNIEnv * env, jobject recv)
{
PORT_ACCESS_FROM_ENV (env);
I_32 retval = 0;
JCLZipFile *jclZipFile;
jfieldID descriptorFID =
JCL_CACHE_GET (env, FID_java_util_zip_ZipFile_descriptor);
jclZipFile = (JCLZipFile *) (IDATA) (*env)->GetLongField (env, recv, descriptorFID);
if (jclZipFile != (void *) -1)
{
retval =
zip_closeZipFile (privatePortLibrary, &(jclZipFile->hyZipFile));
(*env)->SetLongField (env, recv, descriptorFID, -1);
/* Free the zip struct */
if (jclZipFile->last != NULL)
jclZipFile->last->next = jclZipFile->next;
if (jclZipFile->next != NULL)
jclZipFile->next->last = jclZipFile->last;
jclmem_free_memory (env, jclZipFile);
if (retval)
{
throwJavaZIOException (env, "");
return;
}
}
}
/**
* This DLL is being unloaded, do any clean up required.
* This may be called more than once!!
*/
JNIEXPORT void JNICALL
JNI_OnUnload (JavaVM * vm, void *reserved)
{
JNIEnv *env;
void *keyInitCountPtr = GLOBAL_DATA (keyInitCount);
void **jclIdCache = GLOBAL_DATA (JCL_ID_CACHE);
if ((*vm)->GetEnv (vm, (void **) &env, JNI_VERSION_1_2) == JNI_OK)
{
JniIDCache *idCache = (JniIDCache *) HY_VMLS_GET (env, *jclIdCache);
if (idCache)
{
JCLZipFileLink *zipfileHandles;
JCLZipFile *jclZipFile;
PORT_ACCESS_FROM_ENV (env);
#ifdef HY_ZIP_API
VMI_ACCESS_FROM_ENV(env);
VMIZipFunctionTable *zipFuncs = (*VMI)->GetZipFunctions(VMI);
#endif /* HY_ZIP_API */
/* Detach from the common library */
ClearLibDetach (env);
/* Close and free the HyZipFile handles */
zipfileHandles = JCL_CACHE_GET (env, zipfile_handles);
if (zipfileHandles != NULL)
{
jclZipFile = zipfileHandles->next;
while (jclZipFile != NULL)
{
JCLZipFile *next = jclZipFile->next;
#ifndef HY_ZIP_API
zip_closeZipFile (PORTLIB, &jclZipFile->hyZipFile);
#else /* HY_ZIP_API */
zipFuncs->zip_closeZipFile (VMI, &jclZipFile->hyZipFile);
#endif /* HY_ZIP_API */
jclmem_free_memory (env, jclZipFile);
jclZipFile = next;
}
MUTEX_DESTROY (zipfileHandles->mutex);
jclmem_free_memory (env, zipfileHandles);
}
/* Free any global references */
freeReferences (env);
/* Free VMLS keys */
idCache = (JniIDCache *) HY_VMLS_GET (env, *jclIdCache);
HY_VMLS_FNTBL (env)->HYVMLSFreeKeys (env, keyInitCountPtr,
jclIdCache, NULL);
hymem_free_memory (idCache);
}
}
}
/**
* @internal
*/
static void
freeReferences (JNIEnv * env)
{
jclass classRef;
/* clean up class references */
classRef = JCL_CACHE_GET (env, CLS_java_util_zip_ZipEntry);
if (classRef)
(*env)->DeleteGlobalRef (env, classRef);
}
JNIEXPORT jobject JNICALL
Java_java_util_zip_ZipFile_00024ZFEnum_getNextEntry (JNIEnv * env,
jobject recv,
jlong descriptor,
jlong nextEntry)
{
PORT_ACCESS_FROM_ENV (env);
I_32 retval;
HyZipFile *zipFile;
HyZipEntry zipEntry;
jobject java_ZipEntry, extra;
jclass javaClass;
jmethodID mid;
jstring entryName = NULL;
IDATA nextEntryPointer;
JCLZipFile *jclZipFile = (JCLZipFile *) (IDATA) descriptor;
if (jclZipFile == (void *) -1)
{
throwNewIllegalStateException (env, "");
return NULL;
}
zipFile = &(jclZipFile->hyZipFile);
zip_initZipEntry (PORTLIB, &zipEntry);
nextEntryPointer = (IDATA) nextEntry;
retval =
zip_getNextZipEntry (PORTLIB, zipFile, &zipEntry, &nextEntryPointer);
if (retval)
{
if (retval != ZIP_ERR_NO_MORE_ENTRIES)
{
char buf[40];
sprintf (buf, "Error %d getting next zip entry", retval);
throwNewInternalError (env, buf);
}
return (jobject) NULL;
}
/* Build a new ZipEntry from the C struct */
entryName = ((*env)->NewStringUTF (env, zipEntry.filename));
if (((*env)->ExceptionCheck (env)))
return NULL;
extra = NULL;
if (zipEntry.extraFieldLength > 0)
{
zip_getZipEntryExtraField (PORTLIB, zipFile, &zipEntry, NULL,
zipEntry.extraFieldLength);
extra = ((*env)->NewByteArray (env, zipEntry.extraFieldLength));
if (((*env)->ExceptionCheck (env)))
{
/* free the extraField entry */
zip_freeZipEntry (PORTLIB, &zipEntry);
return NULL;
}
((*env)->
SetByteArrayRegion (env, extra, 0, zipEntry.extraFieldLength,
zipEntry.extraField));
jclmem_free_memory (env, zipEntry.extraField);
zipEntry.extraField = NULL;
}
javaClass = JCL_CACHE_GET (env, CLS_java_util_zip_ZipEntry);
javaClass = (*env)->NewLocalRef(env, javaClass);
if (javaClass == NULL) {
return NULL;
}
mid = JCL_CACHE_GET (env, MID_java_util_zip_ZipEntry_init);
java_ZipEntry = ((*env)->NewObject (env, javaClass, mid, entryName, NULL, /* comment */
extra,
(jlong) zipEntry.lastModTime,
(jlong) zipEntry.uncompressedSize,
(jlong) zipEntry.compressedSize,
(jlong) zipEntry.crc32,
zipEntry.compressionMethod,
(jlong) zipEntry.lastModDate,
(jlong) zipEntry.dataPointer));
zip_freeZipEntry (PORTLIB, &zipEntry);
(*env)->SetLongField (env, recv,
JCL_CACHE_GET (env,
FID_java_util_zip_ZipFile_nextEntryPointer),
nextEntryPointer);
return java_ZipEntry;
}
JNIEXPORT jobject JNICALL
Java_java_util_zip_ZipFile_getEntryImpl (JNIEnv * env, jobject recv,
jlong zipPointer, jstring entryName)
{
PORT_ACCESS_FROM_ENV (env);
I_32 retval;
HyZipFile *zipFile;
HyZipEntry zipEntry;
jobject java_ZipEntry, extra;
jclass entryClass;
jmethodID mid;
const char *entryCopy;
JCLZipFile *jclZipFile = (JCLZipFile *) (IDATA) zipPointer;
if (jclZipFile == (void *) -1)
{
throwNewIllegalStateException (env, "");
return NULL;
}
zipFile = &(jclZipFile->hyZipFile);
entryCopy = (*env)->GetStringUTFChars (env, entryName, NULL);
if (entryCopy == NULL)
return (jobject) NULL;
zip_initZipEntry (PORTLIB, &zipEntry);
retval = zip_getZipEntry (PORTLIB, zipFile, &zipEntry, entryCopy, TRUE);
(*env)->ReleaseStringUTFChars (env, entryName, entryCopy);
if (retval)
{
zip_freeZipEntry (PORTLIB, &zipEntry);
return (jobject) NULL;
}
extra = NULL;
if (zipEntry.extraFieldLength > 0)
{
zip_getZipEntryExtraField (PORTLIB, zipFile, &zipEntry, NULL,
zipEntry.extraFieldLength);
if (zipEntry.extraField == NULL)
{
zip_freeZipEntry (PORTLIB, &zipEntry);
return (jobject) NULL;
}
extra = ((*env)->NewByteArray (env, zipEntry.extraFieldLength));
if (((*env)->ExceptionCheck (env)))
{
zip_freeZipEntry (PORTLIB, &zipEntry);
return (jobject) NULL;
}
((*env)->
SetByteArrayRegion (env, extra, 0, zipEntry.extraFieldLength,
zipEntry.extraField));
}
entryClass = JCL_CACHE_GET (env, CLS_java_util_zip_ZipEntry);
entryClass = (*env)->NewLocalRef(env, entryClass);
if (entryClass == NULL) {
zip_freeZipEntry (PORTLIB, &zipEntry);
return (jobject) NULL;
}
mid = JCL_CACHE_GET (env, MID_java_util_zip_ZipEntry_init);
/* Build a new ZipEntry from the C struct */
java_ZipEntry = ((*env)->NewObject (env, entryClass, mid, entryName, NULL,
extra,
(jlong) zipEntry.lastModTime,
(jlong) zipEntry.uncompressedSize,
(jlong) zipEntry.compressedSize,
(jlong) zipEntry.crc32,
zipEntry.compressionMethod,
(jlong) zipEntry.lastModDate,
(jlong) zipEntry.dataPointer));
zip_freeZipEntry (PORTLIB, &zipEntry);
return java_ZipEntry;
}
zipFuncs->zip_getZipEntryExtraField (VMI, zipFile, zipEntry, NULL,
#endif /* HY_ZIP_API */
zipEntry->extraFieldLength);
if (zipEntry->extraField == NULL)
return NULL;
extra = ((*env)->NewByteArray (env, zipEntry->extraFieldLength));
if (((*env)->ExceptionCheck (env)))
return NULL;
((*env)->
SetByteArrayRegion (env, extra, 0, zipEntry->extraFieldLength,
(jbyte*)zipEntry->extraField));
jclmem_free_memory (env, zipEntry->extraField);
zipEntry->extraField = NULL;
}
javaClass = JCL_CACHE_GET (env, CLS_java_util_zip_ZipEntry);
mid = JCL_CACHE_GET (env, MID_java_util_zip_ZipEntry_init);
java_ZipEntry = ((*env)->NewObject (env, javaClass, mid, entryName, NULL,
extra,
(jlong) zipEntry->lastModTime,
(jlong) zipEntry->uncompressedSize,
(jlong) zipEntry->compressedSize,
(jlong) zipEntry->crc32,
zipEntry->compressionMethod,
(jlong) zipEntry->lastModDate,
(jlong) zipEntry->dataPointer));
return java_ZipEntry;
}
JNIEXPORT jarray JNICALL
Java_java_util_jar_JarFile_getMetaEntriesImpl (JNIEnv * env, jobject recv,
