/**
* 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;
}
