コード例 #1
0
ファイル: deflater.c プロジェクト: dennis-xlc/ORDER
/* 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);
}
コード例 #2
0
ファイル: deflater.c プロジェクト: dennis-xlc/ORDER
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;
}
コード例 #3
0
ファイル: deflater.c プロジェクト: dennis-xlc/ORDER
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;
}
コード例 #4
0
ファイル: zip.c プロジェクト: freeVM/freeVM
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;
}
コード例 #5
0
ファイル: zip.c プロジェクト: freeVM/freeVM
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);
}
コード例 #6
0
ファイル: process.c プロジェクト: freeVM/freeVM
/**
  * Create a System Process with the specified
  * environment and arguments 
  */
JNIEXPORT jlongArray JNICALL
Java_org_apache_harmony_luni_internal_process_SystemProcess_createImpl (JNIEnv * env, jclass clazz,
            jobject recv,
            jobjectArray arg1,
            jobjectArray arg2,
            jbyteArray dir)
{
  jbyteArray envString;
  jlongArray pVals = NULL;
  jlong npVals[4];
  char *envArray[256];
  char *command[256];
  int i, retVal;
  IDATA pHandle, inHandle, outHandle, errHandle;
  int envLength, commandLineLength, len;
  char *workingDir = NULL;
  PORT_ACCESS_FROM_ENV (env);

  /* validate sizes */
  commandLineLength = (*env)->GetArrayLength (env, arg1);
  envLength = (*env)->GetArrayLength (env, arg2);
  if (commandLineLength >= 255)
    {
      throwJavaIoIOException(env, "Too many arguments");
      return NULL;
    }
  if (envLength >= 255)
    {
      throwJavaIoIOException(env, "Too many environment arguments");
      return NULL;
    }

  memset (command, 0, sizeof (command));
  memset (envArray, 0, sizeof (envArray));

  /* Get the command string and arguments */
  /* convert java.lang.String into C char* */
  for (i = commandLineLength; --i >= 0;)
    {
      jbyteArray element = (*env)->GetObjectArrayElement (env, arg1, i);
      len = (*env)->GetArrayLength (env, element);
      command[i] = jclmem_allocate_memory (env, len + 1);
      if (command[i] == NULL)
        {
          throwNewOutOfMemoryError (env, "");
          goto failed;
        }
      (*env)->GetByteArrayRegion (env, element, 0, len, (jbyte *)command[i]);
      command[i][len] = 0;
    }
  if (envLength)
    for (i = 0; i < envLength; i++)
      {
        envString = (*env)->GetObjectArrayElement (env, arg2, i);
        len = (*env)->GetArrayLength (env, envString);
        envArray[i] = jclmem_allocate_memory (env, len + 1);
        if (envArray[i] == NULL)
          {
            throwNewOutOfMemoryError (env, "");
            goto failed;
          }
        (*env)->GetByteArrayRegion (env, envString, 0, len, (jbyte *)envArray[i]);
        envArray[i][len] = 0;
      }
  /* NULL terminate for UNIX (does work on windows too; in fact, it doesn't care) */
  command[commandLineLength] = NULL;
  envArray[envLength] = NULL;

  if (dir != NULL)
    {
      jsize dirLength = (*env)->GetArrayLength (env, dir);

      workingDir = jclmem_allocate_memory (env, dirLength + 1);
      if (workingDir)
        {
          (*env)->GetByteArrayRegion (env, dir, 0, dirLength,
            (jbyte *) workingDir);
          workingDir[dirLength] = '\0';
        }
    }

  /*
   *  now call execProgram.  Any non-zero return code 
   *  indicates some kind of failure
   */
   
  retVal = execProgram (env, recv,
      command, commandLineLength, envArray, envLength,
      workingDir, &pHandle, &inHandle, &outHandle,
      &errHandle);

  if (workingDir)
    {
      jclmem_free_memory (env, workingDir);
    }

  if (retVal)
    {
        char errMsg[256];

        /* Failed to exec program */
        
        switch(retVal) {
        case 1001 :
            sprintf(errMsg, "Unable to start program : %s", "fork() failed with errno = EOMEM");
            break;
        case 1002 : 
            sprintf(errMsg, "Unable to start program : %s", "fork() failed with errno = EAGAIN");
            break;
        default:
            sprintf(errMsg, "Unable to start program : %s", "unknown");
            break;
        }

        throwJavaIoIOException(env, errMsg);
        goto failed;
    }

  pVals = (*env)->NewLongArray (env, 4);

  if (pVals)
    {
      npVals[0] = (jlong) pHandle;
      npVals[1] = (jlong) inHandle;
      npVals[2] = (jlong) outHandle;
      npVals[3] = (jlong) errHandle;
      (*env)->SetLongArrayRegion (env, pVals, 0, 4, (jlong *) (&npVals));
    }

failed:

  for (i = 0; i < envLength; i++)
    {
      if (envArray[i])
        jclmem_free_memory (env, envArray[i]);
    }
  for (i = commandLineLength; --i >= 0;)
    {
      if (command[i])
        jclmem_free_memory (env, command[i]);
    }

  return pVals;
}