mirror of
https://github.com/MariaDB/server.git
synced 2025-07-27 18:02:13 +03:00
Import changeset
This commit is contained in:
tim@threads.polyesthetic.msg
294
bdb/libdb_java/java_locked.c
Normal file
294
bdb/libdb_java/java_locked.c
Normal file
@ -0,0 +1,294 @@
|
||||
/*-
|
||||
* See the file LICENSE for redistribution information.
|
||||
*
|
||||
* Copyright (c) 1997, 1998, 1999, 2000
|
||||
* Sleepycat Software. All rights reserved.
|
||||
*/
|
||||
#include "db_config.h"
|
||||
|
||||
#ifndef lint
|
||||
static const char revid[] = "$Id: java_locked.c,v 11.11 2000/10/25 19:54:55 dda Exp $";
|
||||
#endif /* not lint */
|
||||
|
||||
#include <jni.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "db.h"
|
||||
#include "java_util.h"
|
||||
|
||||
/****************************************************************
|
||||
*
|
||||
* Implementation of class LockedDBT
|
||||
*
|
||||
*/
|
||||
int
|
||||
jdbt_lock(JDBT *jdbt, JNIEnv *jnienv, jobject obj, OpKind kind)
|
||||
{
|
||||
DBT *dbt;
|
||||
|
||||
jdbt->obj_ = obj;
|
||||
jdbt->do_realloc_ = 0;
|
||||
jdbt->kind_ = kind;
|
||||
jdbt->java_array_len_= 0;
|
||||
jdbt->java_data_ = 0;
|
||||
jdbt->before_data_ = 0;
|
||||
jdbt->has_error_ = 0;
|
||||
jdbt->dbt = (DBT_JAVAINFO *)get_private_dbobj(jnienv, name_DBT, obj);
|
||||
|
||||
if (!verify_non_null(jnienv, jdbt->dbt)) {
|
||||
jdbt->has_error_ = 1;
|
||||
return (EINVAL);
|
||||
}
|
||||
dbt = &jdbt->dbt->dbt;
|
||||
|
||||
if (kind == outOp &&
|
||||
(dbt->flags & (DB_DBT_USERMEM | DB_DBT_MALLOC | DB_DBT_REALLOC)) == 0) {
|
||||
report_exception(jnienv,
|
||||
"Dbt.flags must be set to Db.DB_DBT_USERMEM, "
|
||||
"Db.DB_DBT_MALLOC or Db.DB_DBT_REALLOC",
|
||||
0, 0);
|
||||
jdbt->has_error_ = 1;
|
||||
return (EINVAL);
|
||||
}
|
||||
|
||||
/* If this is requested to be realloc, we cannot use the
|
||||
* underlying realloc, because the array we will pass in
|
||||
* is not allocated by us, but the Java VM, so it cannot
|
||||
* be successfully realloced. We simulate the reallocation,
|
||||
* by using USERMEM and reallocating the java array when a
|
||||
* ENOMEM error occurs. We change the flags during the operation,
|
||||
* and they are reset when the operation completes (in the
|
||||
* LockedDBT destructor.
|
||||
*/
|
||||
if ((dbt->flags & DB_DBT_REALLOC) != 0) {
|
||||
dbt->flags &= ~DB_DBT_REALLOC;
|
||||
dbt->flags |= DB_DBT_USERMEM;
|
||||
jdbt->do_realloc_ = 1;
|
||||
}
|
||||
|
||||
if ((dbt->flags & DB_DBT_USERMEM) || kind != outOp) {
|
||||
|
||||
/* If writing with DB_DBT_USERMEM/REALLOC
|
||||
* or it's a set (or get/set) operation,
|
||||
* then the data should point to a java array.
|
||||
* Note that outOp means data is coming out of the database
|
||||
* (it's a get). inOp means data is going into the database
|
||||
* (either a put, or a key input).
|
||||
*/
|
||||
if (!jdbt->dbt->array_) {
|
||||
report_exception(jnienv, "Dbt.data is null", 0, 0);
|
||||
jdbt->has_error_ = 1;
|
||||
return (EINVAL);
|
||||
}
|
||||
|
||||
/* Verify other parameters */
|
||||
jdbt->java_array_len_ = (*jnienv)->GetArrayLength(jnienv, jdbt->dbt->array_);
|
||||
if (jdbt->dbt->offset_ < 0 ) {
|
||||
report_exception(jnienv, "Dbt.offset illegal", 0, 0);
|
||||
jdbt->has_error_ = 1;
|
||||
return (EINVAL);
|
||||
}
|
||||
if (dbt->ulen + jdbt->dbt->offset_ > jdbt->java_array_len_) {
|
||||
report_exception(jnienv,
|
||||
"Dbt.ulen + Dbt.offset greater than array length", 0, 0);
|
||||
jdbt->has_error_ = 1;
|
||||
return (EINVAL);
|
||||
}
|
||||
|
||||
jdbt->java_data_ = (*jnienv)->GetByteArrayElements(jnienv, jdbt->dbt->array_,
|
||||
(jboolean *)0);
|
||||
dbt->data = jdbt->before_data_ = jdbt->java_data_ + jdbt->dbt->offset_;
|
||||
}
|
||||
else {
|
||||
|
||||
/* If writing with DB_DBT_MALLOC, then the data is
|
||||
* allocated by DB.
|
||||
*/
|
||||
dbt->data = jdbt->before_data_ = 0;
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* The LockedDBT destructor is called when the java handler returns
|
||||
* to the user, since that's when the LockedDBT objects go out of scope.
|
||||
* Since it is thus called after any call to the underlying database,
|
||||
* it copies any information from temporary structures back to user
|
||||
* accessible arrays, and of course must free memory and remove references.
|
||||
*/
|
||||
void
|
||||
jdbt_unlock(JDBT *jdbt, JNIEnv *jnienv)
|
||||
{
|
||||
DBT *dbt;
|
||||
|
||||
dbt = &jdbt->dbt->dbt;
|
||||
|
||||
/* Fix up the flags if we changed them. */
|
||||
if (jdbt->do_realloc_) {
|
||||
dbt->flags &= ~DB_DBT_USERMEM;
|
||||
dbt->flags |= DB_DBT_REALLOC;
|
||||
}
|
||||
|
||||
if ((dbt->flags & (DB_DBT_USERMEM | DB_DBT_REALLOC)) ||
|
||||
jdbt->kind_ == inOp) {
|
||||
|
||||
/* If writing with DB_DBT_USERMEM/REALLOC or it's a set
|
||||
* (or get/set) operation, then the data may be already in
|
||||
* the java array, in which case, we just need to release it.
|
||||
* If DB didn't put it in the array (indicated by the
|
||||
* dbt->data changing), we need to do that
|
||||
*/
|
||||
if (jdbt->before_data_ != jdbt->java_data_) {
|
||||
(*jnienv)->SetByteArrayRegion(jnienv,
|
||||
jdbt->dbt->array_,
|
||||
jdbt->dbt->offset_,
|
||||
dbt->ulen,
|
||||
jdbt->before_data_);
|
||||
}
|
||||
(*jnienv)->ReleaseByteArrayElements(jnienv, jdbt->dbt->array_, jdbt->java_data_, 0);
|
||||
dbt->data = 0;
|
||||
}
|
||||
if ((dbt->flags & DB_DBT_MALLOC) && jdbt->kind_ != inOp) {
|
||||
|
||||
/* If writing with DB_DBT_MALLOC, then the data was allocated
|
||||
* by DB. If dbt->data is zero, it means an error occurred
|
||||
* (and should have been already reported).
|
||||
*/
|
||||
if (dbt->data) {
|
||||
|
||||
/* Release any old references. */
|
||||
dbjit_release(jdbt->dbt, jnienv);
|
||||
|
||||
/* In the case of SET_RANGE, the key is inOutOp
|
||||
* and when not found, its data will be left as
|
||||
* its original value. Only copy and free it
|
||||
* here if it has been allocated by DB
|
||||
* (dbt->data has changed).
|
||||
*/
|
||||
if (dbt->data != jdbt->before_data_) {
|
||||
jdbt->dbt->array_ = (jbyteArray)
|
||||
NEW_GLOBAL_REF(jnienv,
|
||||
(*jnienv)->NewByteArray(jnienv,
|
||||
dbt->size));
|
||||
jdbt->dbt->offset_ = 0;
|
||||
(*jnienv)->SetByteArrayRegion(jnienv,
|
||||
jdbt->dbt->array_, 0, dbt->size,
|
||||
(jbyte *)dbt->data);
|
||||
free(dbt->data);
|
||||
dbt->data = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Realloc the java array to receive data if the DBT was marked
|
||||
* for realloc, and the last operation set the size field to an
|
||||
* amount greater than ulen.
|
||||
*/
|
||||
int jdbt_realloc(JDBT *jdbt, JNIEnv *jnienv)
|
||||
{
|
||||
DBT *dbt;
|
||||
|
||||
dbt = &jdbt->dbt->dbt;
|
||||
|
||||
if (!jdbt->do_realloc_ || jdbt->has_error_ || dbt->size <= dbt->ulen)
|
||||
return (0);
|
||||
|
||||
(*jnienv)->ReleaseByteArrayElements(jnienv, jdbt->dbt->array_, jdbt->java_data_, 0);
|
||||
dbjit_release(jdbt->dbt, jnienv);
|
||||
|
||||
/* We allocate a new array of the needed size.
|
||||
* We'll set the offset to 0, as the old offset
|
||||
* really doesn't make any sense.
|
||||
*/
|
||||
jdbt->java_array_len_ = dbt->ulen = dbt->size;
|
||||
jdbt->dbt->offset_ = 0;
|
||||
jdbt->dbt->array_ = (jbyteArray)
|
||||
NEW_GLOBAL_REF(jnienv, (*jnienv)->NewByteArray(jnienv, dbt->size));
|
||||
|
||||
jdbt->java_data_ = (*jnienv)->GetByteArrayElements(jnienv,
|
||||
jdbt->dbt->array_,
|
||||
(jboolean *)0);
|
||||
dbt->data = jdbt->before_data_ = jdbt->java_data_;
|
||||
return (1);
|
||||
}
|
||||
|
||||
/****************************************************************
|
||||
*
|
||||
* Implementation of class JSTR
|
||||
*
|
||||
*/
|
||||
int
|
||||
jstr_lock(JSTR *js, JNIEnv *jnienv, jstring jstr)
|
||||
{
|
||||
js->jstr_ = jstr;
|
||||
|
||||
if (jstr == 0)
|
||||
js->string = 0;
|
||||
else
|
||||
js->string = (*jnienv)->GetStringUTFChars(jnienv, jstr,
|
||||
(jboolean *)0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
void jstr_unlock(JSTR *js, JNIEnv *jnienv)
|
||||
{
|
||||
if (js->jstr_)
|
||||
(*jnienv)->ReleaseStringUTFChars(jnienv, js->jstr_, js->string);
|
||||
}
|
||||
|
||||
/****************************************************************
|
||||
*
|
||||
* Implementation of class JSTRARRAY
|
||||
*
|
||||
*/
|
||||
int
|
||||
jstrarray_lock(JSTRARRAY *jsa, JNIEnv *jnienv, jobjectArray arr)
|
||||
{
|
||||
int i;
|
||||
|
||||
jsa->arr_ = arr;
|
||||
jsa->array = 0;
|
||||
|
||||
if (arr != 0) {
|
||||
int count = (*jnienv)->GetArrayLength(jnienv, arr);
|
||||
const char **new_array =
|
||||
(const char **)malloc((sizeof(const char *))*(count+1));
|
||||
for (i=0; i<count; i++) {
|
||||
jstring jstr = (jstring)(*jnienv)->GetObjectArrayElement(jnienv, arr, i);
|
||||
if (jstr == 0) {
|
||||
/*
|
||||
* An embedded null in the string array
|
||||
* is treated as an endpoint.
|
||||
*/
|
||||
new_array[i] = 0;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
new_array[i] =
|
||||
(*jnienv)->GetStringUTFChars(jnienv, jstr, (jboolean *)0);
|
||||
}
|
||||
}
|
||||
new_array[count] = 0;
|
||||
jsa->array = new_array;
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
||||
void jstrarray_unlock(JSTRARRAY *jsa, JNIEnv *jnienv)
|
||||
{
|
||||
int i;
|
||||
jstring jstr;
|
||||
|
||||
if (jsa->arr_) {
|
||||
int count = (*jnienv)->GetArrayLength(jnienv, jsa->arr_);
|
||||
for (i=0; i<count; i++) {
|
||||
if (jsa->array[i] == 0)
|
||||
break;
|
||||
jstr = (jstring)(*jnienv)->GetObjectArrayElement(jnienv, jsa->arr_, i);
|
||||
(*jnienv)->ReleaseStringUTFChars(jnienv, jstr, jsa->array[i]);
|
||||
}
|
||||
free((void*)jsa->array);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user