/** * Flushes a file state to disk. * * @param env pointer to Java environment * @param thiz pointer to object receiving the message * @param fd handle of file to be flushed * @param metadata if true also flush metadata, otherwise just flush data is possible. * @return zero on success and -1 on failure * * Method: fflushImpl * Signature: (JZ)I */ JNIEXPORT jint JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_fflushImpl (JNIEnv * env, jobject thiz, jlong fd, jboolean metadata) { PORT_ACCESS_FROM_ENV (env); return (jint) hyfile_sync ((IDATA) fd); }
JNIEXPORT void JNICALL Java_java_util_zip_Deflater_setDictionaryImpl (JNIEnv * env, jobject recv, jbyteArray dict, int off, int len, jlong handle) { PORT_ACCESS_FROM_ENV (env); int err = 0; char *dBytes; JCLZipStream *stream = (JCLZipStream *) ((IDATA) handle); dBytes = jclmem_allocate_memory (env, len); if (dBytes == NULL) { throwNewOutOfMemoryError (env, ""); return; } (*env)->GetByteArrayRegion (env, dict, off, len, (jbyte *) dBytes); err = deflateSetDictionary (stream->stream, (Bytef *) dBytes, len); if (err != Z_OK) { jclmem_free_memory (env, dBytes); THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException); return; } stream->dict = (U_8*) dBytes; }
/** * Closes the given file handle * * @param env pointer to Java environment * @param thiz pointer to object receiving the message * @param fd handle of file to be closed * @return zero on success and -1 on failure * * Class: org_apache_harmony_luni_platform_OSFileSystem * Method: closeImpl * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_closeImpl (JNIEnv * env, jobject thiz, jlong fd) { PORT_ACCESS_FROM_ENV (env); return (jint) hyfile_close ((IDATA) fd); }
JNIEXPORT void JNICALL Java_java_util_zip_Deflater_setInputImpl (JNIEnv * env, jobject recv, jbyteArray buf, jint off, jint len, jlong handle) { PORT_ACCESS_FROM_ENV (env); jbyte *in; JCLZipStream *stream; stream = (JCLZipStream *) ((IDATA) handle); if (stream->inaddr != NULL) /*Input has already been provided, free the old buffer */ jclmem_free_memory (env, stream->inaddr); stream->inaddr = jclmem_allocate_memory (env, len); if (stream->inaddr == NULL) { throwNewOutOfMemoryError (env, ""); return; } in = ((*env)->GetPrimitiveArrayCritical (env, buf, 0)); if (in == NULL) { throwNewOutOfMemoryError(env, ""); return; } memcpy (stream->inaddr, (in + off), len); ((*env)->ReleasePrimitiveArrayCritical (env, buf, in, JNI_ABORT)); stream->stream->next_in = (Bytef *) stream->inaddr; stream->stream->avail_in = len; return; }
/* * Answers the number of remaining chars in the stdin. * * Class: org_apache_harmony_luni_platform_OSFileSystem * Method: ttyAvailableImpl * Signature: ()J */ JNIEXPORT jlong JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_ttyAvailableImpl (JNIEnv *env, jobject thiz) { PORT_ACCESS_FROM_ENV (env); return (jlong)hytty_available(); }
BOOLEAN GetInfo (JNIEnv * jenv, PSID sid, LPSTR* ppName, LPSTR* ppDomain) { PORT_ACCESS_FROM_ENV (jenv); DWORD dwNameSize = 0; DWORD dwDomainNameSize = 0; SID_NAME_USE snu; if( !LookupAccountSid(NULL, sid, NULL, &dwNameSize, NULL, &dwDomainNameSize, &snu)) { if( ERROR_INSUFFICIENT_BUFFER != GetLastError() ) { return FALSE; } } *ppName = (LPSTR)hymem_allocate_memory(dwNameSize); if( NULL == ppName ) { return FALSE; } *ppDomain = (LPSTR)hymem_allocate_memory(dwDomainNameSize); if( NULL == ppName ) { DWORD err = GetLastError(); hymem_free_memory(*ppName); SetLastError(err); return FALSE; } if( !LookupAccountSid(NULL, sid, *ppName, &dwNameSize, *ppDomain, &dwDomainNameSize, &snu)) { DWORD err = GetLastError(); hymem_free_memory(*ppName); hymem_free_memory(*ppDomain); SetLastError(err); return FALSE; } return TRUE; }
JNIEXPORT void JNICALL Java_org_apache_harmony_luni_platform_OSMemory_free (JNIEnv * env, jobject thiz, jlong address) { PORT_ACCESS_FROM_ENV (env); hymem_free_memory ((void *) ((IDATA) address)); }
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; } } }
/* * Class: org_apache_harmony_luni_platform_OSFileSystem * Method: truncateImpl * Signature: (JJ)I */ JNIEXPORT jint JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_truncateImpl (JNIEnv * env, jobject thiz, jlong fd, jlong size) { PORT_ACCESS_FROM_ENV (env); return (jint)hyfile_set_length((IDATA)fd, (I_64)size); }
/* * Class: org_apache_harmony_luni_platform_OSFileSystem * Method: writeDirectImpl * Signature: (JJI)J */ JNIEXPORT jlong JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_writeDirectImpl (JNIEnv * env, jobject thiz, jlong fd, jlong buf, jint offset, jint nbytes) { PORT_ACCESS_FROM_ENV (env); return (jlong) hyfile_write ((IDATA) fd, (const void *) ((IDATA)(buf+offset)), (IDATA) nbytes); }
void setDefaultServerSocketOptions (JNIEnv * env, hysocket_t socketP) { PORT_ACCESS_FROM_ENV (env); BOOLEAN value = TRUE; hysock_setopt_bool (socketP, HY_SOL_SOCKET, HY_SO_REUSEADDR, &value); }
/** * 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); } } }
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; }
/* Create a new stream . This stream cannot be used until it has been properly initialized. */ JNIEXPORT jlong JNICALL Java_java_util_zip_Deflater_createStream (JNIEnv * env, jobject recv, jint level, jint strategy, 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; jstream->stream = stream; jstream->dict = NULL; jstream->inaddr = NULL; /*Unable to find official doc that this is the way to avoid zlib header use. However doc in zipsup.c claims it is so */ if (noHeader) wbits = wbits / -1; err = deflateInit2 (stream, level, Z_DEFLATED, /*Only supported ZLIB method */ wbits, /*Window bits to use. 15 is fastest but consumes the most memory */ 9, /*Memory allocation for internal compression state. 9 uses the most. */ strategy); if (err != Z_OK) { THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException); return -1; } return (jlong) ((IDATA) jstream); }
/* * Reads the number of bytes from stdin. * * Class: org_apache_harmony_luni_platform_OSFileSystem * Method: ttyReadImpl * Signature: ([BII)J */ JNIEXPORT jlong JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_ttyReadImpl (JNIEnv *env, jobject thiz, jbyteArray byteArray, jint offset, jint nbytes) { PORT_ACCESS_FROM_ENV (env); jboolean isCopy; jbyte *bytes = (*env)->GetByteArrayElements(env, byteArray, &isCopy); jlong result; result = (jlong) hytty_get_chars((char *)(bytes + offset), (IDATA) nbytes); (*env)->ReleaseByteArrayElements (env, byteArray, bytes, 0); return result; }
JNIEXPORT jlong JNICALL Java_org_apache_harmony_luni_platform_OSMemory_malloc (JNIEnv * env, jobject thiz, jlong size) { PORT_ACCESS_FROM_ENV (env); void *address = hymem_allocate_memory ((UDATA) size); if (address == NULL) { throwNewOutOfMemoryError(env, "Insufficient memory available."); } return (jlong) ((IDATA) address); }
JNIEXPORT void JNICALL Java_java_util_zip_Deflater_endImpl (JNIEnv * env, jobject recv, jlong handle) { PORT_ACCESS_FROM_ENV (env); JCLZipStream *stream; stream = (JCLZipStream *) ((IDATA) handle); deflateEnd (stream->stream); if (stream->inaddr != NULL) 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_ZipFile_ntvinit (JNIEnv * env, jclass cls) { PORT_ACCESS_FROM_ENV (env); jmethodID mid; jfieldID descriptorFID; jclass javaClass; jclass weakJavaClass; JCLZipFileLink *zipfileHandles; javaClass = (*env)->FindClass (env, "java/util/zip/ZipEntry"); weakJavaClass = (*env)->NewWeakGlobalRef (env, javaClass); if (!weakJavaClass) return; mid = ((*env)-> GetMethodID (env, javaClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;[BJJJJIJJ)V")); if (!mid) return; JCL_CACHE_SET (env, CLS_java_util_zip_ZipEntry, weakJavaClass); JCL_CACHE_SET (env, MID_java_util_zip_ZipEntry_init, mid); descriptorFID = (*env)->GetFieldID (env, cls, "descriptor", "J"); if (!descriptorFID) return; JCL_CACHE_SET (env, FID_java_util_zip_ZipFile_descriptor, descriptorFID); javaClass = (*env)->FindClass (env, "java/util/zip/ZipFile$ZFEnum"); if (!javaClass) return; descriptorFID = (*env)->GetFieldID (env, javaClass, "nextEntryPointer", "J"); if (!descriptorFID) return; JCL_CACHE_SET (env, FID_java_util_zip_ZipFile_nextEntryPointer, descriptorFID); zipfileHandles = jclmem_allocate_memory (env, sizeof (JCLZipFileLink)); if (!zipfileHandles) return; zipfileHandles->last = NULL; zipfileHandles->next = NULL; JCL_CACHE_SET (env, zipfile_handles, zipfileHandles); }
/* * Class: org_apache_harmony_luni_platform_OSFileSystem * Method: writeImpl * Signature: (J[BII)J */ JNIEXPORT jlong JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_writeImpl (JNIEnv * env, jobject thiz, jlong fd, jbyteArray byteArray, jint offset, jint nbytes) { PORT_ACCESS_FROM_ENV (env); jboolean isCopy; jbyte *bytes = (*env)->GetByteArrayElements (env, byteArray, &isCopy); jlong result; result = (jlong) hyfile_write ((IDATA) fd, (void *) (bytes + offset), (IDATA) nbytes); if(result == -1 && hyerror_last_error_number() == HYPORT_ERROR_FILE_LOCKED){ throwNewExceptionByName(env, "java/io/IOException", netLookupErrorString(env, HYPORT_ERROR_FILE_LOCKED)); } (*env)->ReleaseByteArrayElements (env, byteArray, bytes, JNI_ABORT); return result; }
JNIEXPORT jbyteArray JNICALL Java_org_apache_harmony_luni_platform_Environment_getEnvByName (JNIEnv *env, jclass obj, jbyteArray name){ DWORD dwRet,dwErr; LPTSTR envvalue; jsize len = 0; const DWORD BUFSIZE = 1024; jbyteArray byteArray = NULL; char *envname; PORT_ACCESS_FROM_ENV(env); len = (*env)->GetArrayLength(env, name); envname = (char *)hymem_allocate_memory(len+1); (*env)->GetByteArrayRegion(env, name, 0, len,(jbyte *)envname); envname[len] = 0; envvalue = (LPTSTR)hymem_allocate_memory(BUFSIZE*sizeof(TCHAR)); dwRet = GetEnvironmentVariable(envname, envvalue, BUFSIZE); if(0 == dwRet) { dwErr = GetLastError(); if( ERROR_ENVVAR_NOT_FOUND == dwErr ){ goto free_resource; } } else if(BUFSIZE < dwRet) { envvalue = (LPTSTR)hymem_reallocate_memory(envvalue, dwRet*sizeof(TCHAR)); if(NULL == envvalue){ goto free_resource; } dwRet = GetEnvironmentVariable((LPCSTR)envname, envvalue, dwRet); if(!dwRet){ goto free_resource; } } byteArray = (*env)->NewByteArray(env,dwRet); (*env)->SetByteArrayRegion(env,byteArray, 0, dwRet, (jbyte *)envvalue); free_resource: hymem_free_memory(envname); hymem_free_memory(envvalue); return byteArray; }
JNIEXPORT jlong JNICALL Java_java_util_zip_ZipFile_00024ZFEnum_resetZip (JNIEnv * env, jobject recv, jlong descriptor) { PORT_ACCESS_FROM_ENV (env); IDATA nextEntryPointer; JCLZipFile *jclZipFile = (JCLZipFile *) (IDATA) descriptor; if (jclZipFile == (void *) -1) { throwNewIllegalStateException (env, ""); return 0; } zip_resetZipFile (privatePortLibrary, &(jclZipFile->hyZipFile), &nextEntryPointer); return nextEntryPointer; }
/* * Class: org_apache_harmony_luni_platform_OSFileSystem * Method: openImpl * Signature: ([BI)J */ JNIEXPORT jlong JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_openImpl (JNIEnv * env, jobject obj, jbyteArray path, jint jflags){ PORT_ACCESS_FROM_ENV (env); I_32 flags = 0; I_32 mode = 0; IDATA portFD; jsize length; char pathCopy[HyMaxPath]; switch(jflags){ case org_apache_harmony_luni_platform_IFileSystem_O_RDONLY: flags = HyOpenRead; mode = 0; break; case org_apache_harmony_luni_platform_IFileSystem_O_WRONLY: flags = HyOpenCreate | HyOpenWrite | HyOpenTruncate; mode = 0666; break; case org_apache_harmony_luni_platform_IFileSystem_O_RDWR: flags = HyOpenRead | HyOpenWrite | HyOpenCreate; mode = 0666; break; case org_apache_harmony_luni_platform_IFileSystem_O_APPEND: flags = HyOpenWrite | HyOpenCreate | HyOpenAppend; mode = 0666; break; case org_apache_harmony_luni_platform_IFileSystem_O_RDWRSYNC: flags = HyOpenRead | HyOpenWrite | HyOpenCreate | HyOpenSync; mode = 0666; break; } length = (*env)->GetArrayLength (env, path); length = length < HyMaxPath - 1 ? length : HyMaxPath - 1; ((*env)->GetByteArrayRegion (env, path, 0, length, (jbyte *)pathCopy)); pathCopy[length] = '\0'; ioh_convertToPlatform (pathCopy); portFD = hyfile_open (pathCopy, flags, mode); return (jlong)portFD; }
/** * Answer 1 if the path is hidden, 0 otherwise even in fail cases. */ I_32 getPlatformIsHidden (JNIEnv * env, char *path) { PORT_ACCESS_FROM_ENV (env); /* Answer true if the file exists and starts with a period */ I_32 length = strlen (path), index, existsResult; existsResult = hyfile_attr (path); if (existsResult < 0) return 0; if (length == 0) return 0; for (index = length; index >= 0; index--) { if (path[index] == '.' && (index > 0 && path[index - 1] == '/')) return 1; } return 0; }
/** * This DLL is being loaded, do any initialization required. * This may be called more than once. */ JNIEXPORT jint JNICALL JNI_OnLoad (JavaVM * vm, void *reserved) { JniIDCache *idCache; 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) { PORT_ACCESS_FROM_ENV (env); if (HY_VMLS_FNTBL (env)-> HYVMLSAllocKeys (env, keyInitCountPtr, jclIdCache, NULL)) { goto fail; } /* This allocate must actually be done by hymem_allocate_memory. */ idCache = (JniIDCache *) hymem_allocate_memory (sizeof (JniIDCache)); if (!idCache) goto fail2; memset (idCache, 0, sizeof (JniIDCache)); HY_VMLS_SET (env, *jclIdCache, idCache); /* Attach to the common library */ if (JNI_OK != ClearLibAttach (env)) { goto fail2; } return JNI_VERSION_1_2; } fail2: HY_VMLS_FNTBL (env)->HYVMLSFreeKeys (env, keyInitCountPtr, jclIdCache, NULL); fail: return 0; }
createZipEntry (JNIEnv * env, VMIZipFile * zipFile, VMIZipEntry * zipEntry) #endif { PORT_ACCESS_FROM_ENV (env); #ifdef HY_ZIP_API VMI_ACCESS_FROM_ENV(env); #endif /* HY_ZIP_API */ jclass javaClass; jobject java_ZipEntry, extra, entryName; jmethodID mid; #ifdef HY_ZIP_API VMIZipFunctionTable *zipFuncs = (*VMI)->GetZipFunctions(VMI); #endif /* HY_ZIP_API */ /* Build a new ZipEntry from the C struct */ entryName = ((*env)->NewStringUTF (env, (const char*)zipEntry->filename)); if (((*env)->ExceptionCheck (env))) return NULL; extra = NULL; if (zipEntry->extraFieldLength > 0) { #ifndef HY_ZIP_API zip_getZipEntryExtraField (PORTLIB, zipFile, zipEntry, NULL, #else /* HY_ZIP_API */ 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; }
/** * Seeks a file descriptor to a given file position. * * @param env pointer to Java environment * @param thiz pointer to object receiving the message * @param fd handle of file to be seeked * @param offset distance of movement in bytes relative to whence arg * @param whence enum value indicating from where the offset is relative * The valid values are defined in fsconstants.h. * @return the new file position from the beginning of the file, in bytes; * or -1 if a problem occurs. */ JNIEXPORT jlong JNICALL Java_org_apache_harmony_luni_platform_OSFileSystem_seekImpl (JNIEnv * env, jobject thiz, jlong fd, jlong offset, jint whence) { PORT_ACCESS_FROM_ENV (env); I_32 hywhence = 0; /* The HY PPL equivalent of our whence arg.*/ /* Convert whence argument */ switch (whence) { case org_apache_harmony_luni_platform_IFileSystem_SEEK_SET: hywhence = HySeekSet; break; case org_apache_harmony_luni_platform_IFileSystem_SEEK_CUR: hywhence = HySeekCur; break; case org_apache_harmony_luni_platform_IFileSystem_SEEK_END: hywhence = HySeekEnd; break; default: return -1; } return (jlong) hyfile_seek ((IDATA) fd, (IDATA) offset, hywhence); }
LPVOID QueryInfo (JNIEnv * jenv, HANDLE hToken, TOKEN_INFORMATION_CLASS klass) { PORT_ACCESS_FROM_ENV (jenv); DWORD dwSize; LPVOID pData = NULL; if( !GetTokenInformation(hToken, klass, NULL, 0, &dwSize) ) { DWORD dwErr = GetLastError(); if( ERROR_INSUFFICIENT_BUFFER != dwErr ) { return NULL; } } pData = hymem_allocate_memory(dwSize); if( !GetTokenInformation(hToken, klass, pData, dwSize, &dwSize) ) { DWORD dwErr = GetLastError(); hymem_free_memory(pData); SetLastError(dwErr); return NULL; } return pData; }
JNIEXPORT jbyteArray JNICALL Java_java_util_zip_ZipFile_inflateEntryImpl2 (JNIEnv * env, jobject recv, jlong descriptor, jstring entryName) { PORT_ACCESS_FROM_ENV (env); I_32 retval; HyZipFile *zipFile; HyZipEntry zipEntry; const char *entryCopy; jbyteArray buf; JCLZipFile *jclZipFile = (JCLZipFile *) (IDATA) descriptor; /* Build the zipFile */ if (jclZipFile == (void *) -1) { throwNewIllegalStateException (env, ""); return NULL; } zipFile = &(jclZipFile->hyZipFile); entryCopy = (*env)->GetStringUTFChars (env, entryName, NULL); if (entryCopy == NULL) return NULL; zip_initZipEntry (privatePortLibrary, &zipEntry); retval = zip_getZipEntry (privatePortLibrary, zipFile, &zipEntry, entryCopy, TRUE); (*env)->ReleaseStringUTFChars (env, entryName, entryCopy); if (retval) { zip_freeZipEntry (privatePortLibrary, &zipEntry); if (retval == ZIP_ERR_OUT_OF_MEMORY) throwNewOutOfMemoryError (env, ""); return NULL; } buf = (*env)->NewByteArray (env, zipEntry.uncompressedSize); if (!buf) { throwNewOutOfMemoryError (env, ""); return NULL; } retval = zip_getZipEntryData (privatePortLibrary, zipFile, &zipEntry, NULL, zipEntry.uncompressedSize); if (retval == 0) (*env)->SetByteArrayRegion (env, buf, 0, zipEntry.uncompressedSize, zipEntry.data); zip_freeZipEntry (privatePortLibrary, &zipEntry); if (!retval) return buf; if (retval == ZIP_ERR_OUT_OF_MEMORY) throwNewOutOfMemoryError (env, ""); else throwJavaZIOException (env, ""); return NULL; }
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; }