/*
* Class: sun_dc_pr_PathStroker
* Method: cInitialize
* Signature: (Lsun/dc/path/PathConsumer;)V
*/
JNIEXPORT void JNICALL Java_sun_dc_pr_PathStroker_cInitialize
(JNIEnv *env, jobject obj, jobject out)
{
jclass cls;
jfieldID fid;
jmethodID mid;
PathStroker cdata;
doeE cenv = doeE_make();
doeE_setPCtxt(cenv, env);
cdata = (PathStroker)doeMem_malloc(cenv, sizeof(PathStrokerData));
if (doeError_occurred(cenv)) {
CJError_throw(cenv);
return;
}
(*env)->SetLongField(env, obj, fidCData, ptr_to_jlong(cdata));
/* __________________________
* the c environment variable
*/
cdata->env = cenv;
/* Register the data for disposal */
Disposer_AddRecord(env, obj, PathStroker_DisposeOps, ptr_to_jlong(cdata));
/* __________________________________
* the corresponding CJ path consumer
* (always created so as to be able to deal with any type of
* incoming out path consumers)
*/
cdata->cjout = CJPathConsumer_create(cenv, out);
if (doeError_occurred(cenv)) {
CJError_throw(cenv);
return;
}
/* ________________________________________________
* determines if "out" has a native implementation.
*/
cls = (*env)->GetObjectClass(env, out);
mid = (*env)->GetMethodID(env, cls, "getCPathConsumer", "()J");
cdata->cout = (dcPathConsumer)
jlong_to_ptr((*env)->CallLongMethod(env, out, mid));
/* ________________________
* the actual c PathStroker
*/
if (cdata->cout) {
cdata->stroker = dcPathStroker_create(cenv, cdata->cout);
} else {
cdata->stroker = dcPathStroker_create(cenv, (dcPathConsumer)cdata->cjout);
}
if (doeError_occurred(cenv)) {
CJError_throw(cenv);
return;
}
}
void set_native_handle(JNIEnv *env, jclass_type_t type, jobject obj, void *handle)
{
switch (type) {
case JCLASS_DATAOBJECT:
return (*env)->SetLongField(env, obj, jc_dataobject.fid.native, ptr_to_jlong(handle));
case JCLASS_NODE:
return (*env)->SetLongField(env, obj, jc_node.fid.native, ptr_to_jlong(handle));
case JCLASS_ATTRIBUTE:
return (*env)->SetLongField(env, obj, jc_attribute.fid.native, ptr_to_jlong(handle));
case JCLASS_HANDLE:
return (*env)->SetLongField(env, obj, jc_handle.fid.native, ptr_to_jlong(handle));
case JCLASS_INTERFACE:
return (*env)->SetLongField(env, obj, jc_interface.fid.native, ptr_to_jlong(handle));
}
}
JNIEXPORT jlong JNICALL
Java_java_util_zip_Inflater_init(JNIEnv *env, jclass cls, jboolean nowrap)
{
z_stream *strm = calloc(1, sizeof(z_stream));
if (strm == NULL) {
JNU_ThrowOutOfMemoryError(env, 0);
return jlong_zero;
} else {
const char *msg;
int ret = inflateInit2(strm, nowrap ? -MAX_WBITS : MAX_WBITS);
switch (ret) {
case Z_OK:
return ptr_to_jlong(strm);
case Z_MEM_ERROR:
free(strm);
JNU_ThrowOutOfMemoryError(env, 0);
return jlong_zero;
default:
msg = ((strm->msg != NULL) ? strm->msg :
(ret == Z_VERSION_ERROR) ?
"zlib returned Z_VERSION_ERROR: "
"compile time and runtime zlib implementations differ" :
(ret == Z_STREAM_ERROR) ?
"inflateInit2 returned Z_STREAM_ERROR" :
"unknown error initializing zlib library");
free(strm);
JNU_ThrowInternalError(env, msg);
return jlong_zero;
}
}
}
static pathData *
MakeSpanData(JNIEnv *env, jobject sr)
{
pathData *pd = (pathData *) JNU_GetLongFieldAsPtr(env, sr, pSpanDataID);
if (pd != NULL) {
JNU_ThrowInternalError(env, "private data already initialized");
return NULL;
}
pd = calloc(1, sizeof(pathData));
if (pd == NULL) {
JNU_ThrowOutOfMemoryError(env, "private data");
} else {
/* Initialize Ductus object header */
pd->consumer = &dcShapeSpanIteratorClass;
/* Initialize ShapeSpanIterator fields */
pd->first = 1;
(*env)->SetLongField(env, sr, pSpanDataID, ptr_to_jlong(pd));
}
return pd;
}
SocketStreamHandle::SocketStreamHandle(const KURL& url, Page* page,
SocketStreamHandleClient* client)
: SocketStreamHandleBase(url, client)
{
String host = url.host();
bool ssl = url.protocolIs("wss");
int port = url.hasPort() ? url.port() : (ssl ? 443 : 80);
JNIEnv* env = WebCore_GetJavaEnv();
static jmethodID mid = env->GetStaticMethodID(
GetSocketStreamHandleClass(env),
"fwkCreate",
"(Ljava/lang/String;IZLcom/sun/webkit/WebPage;J)"
"Lcom/sun/webkit/network/SocketStreamHandle;");
ASSERT(mid);
m_ref = JLObject(env->CallStaticObjectMethod(
GetSocketStreamHandleClass(env),
mid,
(jstring) host.toJavaString(env),
port,
bool_to_jbool(ssl),
(jobject) WebPage::jobjectFromPage(page),
ptr_to_jlong(this)));
CheckAndClearException(env);
}
JNIEXPORT jlong JNICALL
Java_java_util_zip_Inflater_init(JNIEnv *env, jclass cls, jboolean nowrap)
{
z_stream *strm = calloc(1, sizeof(z_stream));
if (strm == 0) {
JNU_ThrowOutOfMemoryError(env, 0);
return jlong_zero;
} else {
char *msg;
switch (inflateInit2(strm, nowrap ? -MAX_WBITS : MAX_WBITS)) {
case Z_OK:
return ptr_to_jlong(strm);
case Z_MEM_ERROR:
free(strm);
JNU_ThrowOutOfMemoryError(env, 0);
return jlong_zero;
default:
msg = strm->msg;
free(strm);
JNU_ThrowInternalError(env, msg);
return jlong_zero;
}
}
}
JNIEXPORT jlong JNICALL
Java_java_util_zip_ZipFile_getNextEntry(JNIEnv *env, jclass cls, jlong zfile,
jint n)
{
jzentry *ze = ZIP_GetNextEntry(jlong_to_ptr(zfile), n);
return ptr_to_jlong(ze);
}
/**
* Returns a pointer (as a jlong) to the native GLXGraphicsConfigInfo
* associated with the given OGLSDOps. This method can be called from
* shared code to retrieve the native GraphicsConfig data in a platform-
* independent manner.
*/
jlong
OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo)
{
GLXSDOps *glxsdo;
if (oglsdo == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"OGLSD_GetNativeConfigInfo: ops are null");
return 0L;
}
glxsdo = (GLXSDOps *)oglsdo->privOps;
if (glxsdo == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"OGLSD_GetNativeConfigInfo: glx ops are null");
return 0L;
}
if (glxsdo->configData == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"OGLSD_GetNativeConfigInfo: config data is null");
return 0L;
}
return ptr_to_jlong(glxsdo->configData->glxInfo);
}
JNIEXPORT jlong JNICALL
Java_java_util_zip_ZipFile_open(JNIEnv *env, jclass cls, jstring name, jint mode)
{
const char *path = JNU_GetStringPlatformChars(env, name, 0);
jlong result = 0;
int flag = 0;
if (mode & OPEN_READ) flag |= O_RDONLY;
if (mode & OPEN_DELETE) flag |= JVM_O_DELETE;
if (path != 0) {
char *msg;
jzfile *zip = ZIP_Open_Generic(path, &msg, flag);
JNU_ReleaseStringPlatformChars(env, name, path);
if (zip != 0) {
result = ptr_to_jlong(zip);
} else if (msg != 0) {
ThrowZipException(env, msg);
} else if (errno == ENOMEM) {
JNU_ThrowOutOfMemoryError(env, 0);
} else {
ThrowZipException(env, "error in opening zip file");
}
}
return result;
}
/*
* Class: sun_awt_shell_Win32ShellFolder2
* Method: getStandardViewButton0
* Signature: (I)[I
*/
JNIEXPORT jintArray JNICALL Java_sun_awt_shell_Win32ShellFolder2_getStandardViewButton0
(JNIEnv* env, jclass cls, jint iconIndex)
{
jintArray result = NULL;
// Create a toolbar
HWND hWndToolbar = ::CreateWindowEx(0, TOOLBARCLASSNAME, NULL,
0, 0, 0, 0, 0,
NULL, NULL, NULL, NULL);
if (hWndToolbar != NULL) {
SendMessage(hWndToolbar, TB_LOADIMAGES, (WPARAM)IDB_VIEW_SMALL_COLOR, (LPARAM)HINST_COMMCTRL);
HIMAGELIST hImageList = (HIMAGELIST) SendMessage(hWndToolbar, TB_GETIMAGELIST, 0, 0);
if (hImageList != NULL) {
HICON hIcon = ImageList_GetIcon(hImageList, iconIndex, ILD_TRANSPARENT);
if (hIcon != NULL) {
result = Java_sun_awt_shell_Win32ShellFolder2_getIconBits(env, cls, ptr_to_jlong(hIcon), 16);
DestroyIcon(hIcon);
}
ImageList_Destroy(hImageList);
}
DestroyWindow(hWndToolbar);
}
return result;
}
JNIEXPORT jlong JNICALL
Java_java_util_zip_Deflater_init(JNIEnv *env, jclass cls, jint level,
jint strategy, jboolean nowrap)
{
z_stream *strm = calloc(1, sizeof(z_stream));
if (strm == 0) {
JNU_ThrowOutOfMemoryError(env, 0);
return jlong_zero;
} else {
char *msg;
switch (deflateInit2(strm, level, Z_DEFLATED,
nowrap ? -MAX_WBITS : MAX_WBITS,
DEF_MEM_LEVEL, strategy)) {
case Z_OK:
return ptr_to_jlong(strm);
case Z_MEM_ERROR:
free(strm);
JNU_ThrowOutOfMemoryError(env, 0);
return jlong_zero;
case Z_STREAM_ERROR:
free(strm);
JNU_ThrowIllegalArgumentException(env, 0);
return jlong_zero;
default:
msg = strm->msg;
free(strm);
JNU_ThrowInternalError(env, msg);
return jlong_zero;
}
}
}
JNIEXPORT jlong JNICALL
Java_java_util_zip_ZipFile_getEntry(JNIEnv *env, jclass cls, jlong zfile,
jstring name, jboolean addSlash)
{
#define MAXNAME 1024
jzfile *zip = jlong_to_ptr(zfile);
jsize slen = (*env)->GetStringLength(env, name);
jsize ulen = (*env)->GetStringUTFLength(env, name);
char buf[MAXNAME+2], *path;
jzentry *ze;
if (ulen > MAXNAME) {
path = malloc(ulen + 2);
if (path == 0) {
JNU_ThrowOutOfMemoryError(env, 0);
return 0;
}
} else {
path = buf;
}
(*env)->GetStringUTFRegion(env, name, 0, slen, path);
path[ulen] = '\0';
if (addSlash == JNI_FALSE) {
ze = ZIP_GetEntry(zip, path, 0);
} else {
ze = ZIP_GetEntry(zip, path, (jint)ulen);
}
if (path != buf) {
free(path);
}
return ptr_to_jlong(ze);
}
JNIEXPORT jlong JNICALL
Java_sun_java2d_opengl_GLXGraphicsConfig_initNativeSharedContext
(JNIEnv *env, jobject glxsd)
{
GLXCtxInfo *sharedCtxInfo;
OGLContext *oglc;
J2dTraceLn(J2D_TRACE_INFO,
"in GLXGraphicsConfig_initNativeSharedContext");
if (sharedContext == NULL || sharedConfigInfo == NULL) {
J2dTraceLn(J2D_TRACE_ERROR, "shared context not yet inited");
return 0L;
}
sharedCtxInfo = (GLXCtxInfo *)sharedContext->ctxInfo;
oglc = GLXGC_InitOGLContext(env, sharedConfigInfo,
sharedCtxInfo->context, JNI_TRUE);
if (oglc == NULL) {
J2dTraceLn(J2D_TRACE_ERROR, "could not create native shared context");
return 0L;
}
return ptr_to_jlong(oglc);
}
JNIEXPORT jlong JNICALL
Java_java_lang_ProcessImpl_openForAtomicAppend(JNIEnv *env, jclass ignored, jstring path)
{
const DWORD access = (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA);
const DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
const DWORD disposition = OPEN_ALWAYS;
const DWORD flagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
HANDLE h;
WCHAR *pathbuf = getPath(env, path);
if (pathbuf == NULL) {
/* Exception already pending */
return -1;
}
h = CreateFileW(
pathbuf, /* Wide char path name */
access, /* Read and/or write permission */
sharing, /* File sharing flags */
NULL, /* Security attributes */
disposition, /* creation disposition */
flagsAndAttributes, /* flags and attributes */
NULL);
free(pathbuf);
if (h == INVALID_HANDLE_VALUE) {
JNU_ThrowIOExceptionWithLastError(env, "CreateFileW");
}
return ptr_to_jlong(h);
}
/*
* Class: com_sun_media_jfxmediaimpl_NativeVideoBuffer
* Method: nativeConvertToFormat
* Signature: (JI)J
*/
JNIEXPORT jlong JNICALL Java_com_sun_media_jfxmediaimpl_NativeVideoBuffer_nativeConvertToFormat
(JNIEnv *env, jobject obj, jlong nativeHandle, jint newFormat)
{
CVideoFrame *frame = (CVideoFrame*)jlong_to_ptr(nativeHandle);
if (frame) {
return ptr_to_jlong(frame->ConvertToFormat((CVideoFrame::FrameType)newFormat));
}
return 0;
}
/*
* Add the given pkcs11Implementation object to the list of present modules.
* Attach the given data to the entry. If the given pkcs11Implementation is
* already in the lsit, just override its old module data with the new one.
* None of the arguments can be NULL. If one of the arguments is NULL, this
* function does nothing.
*/
void putModuleEntry(JNIEnv *env, jobject pkcs11Implementation, ModuleData *moduleData) {
if (pkcs11Implementation == NULL_PTR) {
return ;
}
if (moduleData == NULL) {
return ;
}
(*env)->SetLongField(env, pkcs11Implementation, pNativeDataID, ptr_to_jlong(moduleData));
}
JNIEXPORT jlong JNICALL
Java_sun_font_NullFontScaler_getNullScalerContext
(JNIEnv *env, jclass scalerClass) {
if (theNullScalerContext == NULL) {
theNullScalerContext = malloc(1);
}
return ptr_to_jlong(theNullScalerContext);
}
/**
* This is the implementation of the general DisposeFunc defined in
* SurfaceData.h and used by the Disposer mechanism. It first flushes all
* native OpenGL resources and then frees any memory allocated within the
* native OGLSDOps structure.
*/
void
OGLSD_Dispose(JNIEnv *env, SurfaceDataOps *ops)
{
OGLSDOps *oglsdo = (OGLSDOps *)ops;
jlong pConfigInfo = OGLSD_GetNativeConfigInfo(oglsdo);
JNU_CallStaticMethodByName(env, NULL, "sun/java2d/opengl/OGLSurfaceData",
"dispose", "(JJ)V",
ptr_to_jlong(ops), pConfigInfo);
}
void
D3DSD_Dispose(JNIEnv *env, SurfaceDataOps *ops)
{
D3DSDOps *d3dsdo = (D3DSDOps *)ops;
RETURN_IF_NULL(d3dsdo);
JNU_CallStaticMethodByName(env, NULL, "sun/java2d/d3d/D3DSurfaceData",
"dispose", "(J)V",
ptr_to_jlong(ops));
}
JNIEXPORT void JNICALL
SurfaceData_SetOps(JNIEnv *env, jobject sData, SurfaceDataOps *ops)
{
if (JNU_GetLongFieldAsPtr(env, sData, pDataID) == NULL) {
JNU_SetLongFieldFromPtr(env, sData, pDataID, ops);
/* Register the data for disposal */
Disposer_AddRecord(env, sData,
SurfaceData_DisposeOps,
ptr_to_jlong(ops));
} else {
JNU_ThrowInternalError(env, "Attempting to set SurfaceData ops twice");
}
}
void PopupMenuJava::createPopupMenuJava(Page* page)
{
JNIEnv* env = WebCore_GetJavaEnv();
static jmethodID mid = env->GetStaticMethodID(getJPopupMenuClass(),
"fwkCreatePopupMenu", "(J)Lcom/sun/webkit/PopupMenu;");
ASSERT(mid);
JLObject jPopupMenu(env->CallStaticObjectMethod(getJPopupMenuClass(), mid, ptr_to_jlong(this)));
ASSERT(jPopupMenu);
CheckAndClearException(env);
m_popup = jPopupMenu;
}
/*
* Class: sun_java2d_d3d_D3DSurfaceData
* Method: getNativeResourceNative
* Signature: (JI)J
*/
JNIEXPORT jlong JNICALL
Java_sun_java2d_d3d_D3DSurfaceData_getNativeResourceNative
(JNIEnv *env, jclass d3sdc, jlong pData, jint resType)
{
D3DSDOps *d3dsdo;
J2dTraceLn(J2D_TRACE_INFO, "D3DSurfaceData_getNativeResourceNative")
RETURN_STATUS_IF_NULL(d3dsdo = (D3DSDOps *)jlong_to_ptr(pData), 0L);
if (resType == D3D_DEVICE_RESOURCE) {
HRESULT res;
D3DPipelineManager *pMgr;
D3DContext *pCtx;
RETURN_STATUS_IF_NULL(pMgr = D3DPipelineManager::GetInstance(), 0L);
if (FAILED(res = pMgr->GetD3DContext(d3dsdo->adapter, &pCtx))) {
D3DRQ_MarkLostIfNeeded(res, d3dsdo);
return 0L;
}
return ptr_to_jlong(pCtx->Get3DDevice());
}
RETURN_STATUS_IF_NULL(d3dsdo->pResource, 0L);
if (resType == RT_PLAIN || resType == RT_TEXTURE) {
return ptr_to_jlong(d3dsdo->pResource->GetSurface());
}
if (resType == TEXTURE) {
return ptr_to_jlong(d3dsdo->pResource->GetTexture());
}
if (resType == FLIP_BACKBUFFER) {
return ptr_to_jlong(d3dsdo->pResource->GetSwapChain());
}
return 0L;
}
JNIEXPORT jlong JNICALL
Java_java_util_zip_ZipFile_open(JNIEnv *env, jclass cls, jstring name,
jint mode, jlong lastModified,
jboolean usemmap)
{
const char *path = JNU_GetStringPlatformChars(env, name, 0);
char *msg = 0;
jlong result = 0;
int flag = 0;
jzfile *zip = 0;
if (mode & OPEN_READ) flag |= O_RDONLY;
if (mode & OPEN_DELETE) flag |= JVM_O_DELETE;
if (path != 0) {
zip = ZIP_Get_From_Cache(path, &msg, lastModified);
if (zip == 0 && msg == 0) {
ZFILE zfd = 0;
#ifdef WIN32
zfd = winFileHandleOpen(env, name, flag);
if (zfd == -1) {
/* Exception already pending. */
goto finally;
}
#else
zfd = JVM_Open(path, flag, 0);
if (zfd < 0) {
throwFileNotFoundException(env, name);
goto finally;
}
#endif
zip = ZIP_Put_In_Cache0(path, zfd, &msg, lastModified, usemmap);
}
if (zip != 0) {
result = ptr_to_jlong(zip);
} else if (msg != 0) {
ThrowZipException(env, msg);
free(msg);
} else if (errno == ENOMEM) {
JNU_ThrowOutOfMemoryError(env, 0);
} else {
ThrowZipException(env, "error in opening zip file");
}
finally:
JNU_ReleaseStringPlatformChars(env, name, path);
}
return result;
}
/*
* Class: sun_awt_shell_Win32ShellFolder2
* Method: getIconResource
* Signature: (Ljava/lang/String;IIIZ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_shell_Win32ShellFolder2_getIconResource
(JNIEnv* env, jclass cls, jstring libName, jint iconID,
jint cxDesired, jint cyDesired, jboolean useVGAColors)
{
const char *pLibName = env->GetStringUTFChars(libName, NULL);
JNU_CHECK_EXCEPTION_RETURN(env, 0);
HINSTANCE libHandle = (HINSTANCE)JDK_LoadSystemLibrary(pLibName);
if (libHandle != NULL) {
UINT fuLoad = (useVGAColors && !IS_WINXP) ? LR_VGACOLOR : 0;
return ptr_to_jlong(LoadImage(libHandle, MAKEINTRESOURCE(iconID),
IMAGE_ICON, cxDesired, cyDesired,
fuLoad));
}
return 0;
}
void Watchdog::initTimer()
{
JSC_GETJAVAENV_CHKRET(env);
static jmethodID mid = env->GetStaticMethodID(
GetWatchdogTimerClass(env),
"fwkCreate",
"(J)Lcom/sun/webkit/WatchdogTimer;");
ASSERT(mid);
m_timer = JLObject(env->CallStaticObjectMethod(
GetWatchdogTimerClass(env),
mid,
ptr_to_jlong(timerDidFireAddress())));
CheckAndClearException(env);
}
JNIEXPORT jlong JNICALL
Java_sun_java2d_opengl_GLXContext_initNativeContext(JNIEnv *env, jobject glxc,
jlong aData)
{
AwtGraphicsConfigDataPtr configData =
(AwtGraphicsConfigDataPtr)jlong_to_ptr(aData);
GLXCtxInfo *sharedInfo = (GLXCtxInfo *)sharedContext->ctxInfo;
OGLContext *oglc;
J2dTraceLn(J2D_TRACE_INFO, "in GLXContext_initNativeContext");
oglc = GLXGC_InitOGLContext(env, configData->glxInfo,
sharedInfo->context, JNI_TRUE);
return ptr_to_jlong(oglc);
}
/*
* Class: sun_font_FreetypeFontScaler
* Method: getLayoutTableCacheNative
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL
Java_sun_font_FreetypeFontScaler_getLayoutTableCacheNative(
JNIEnv *env, jobject scaler, jlong pScaler) {
FTScalerInfo *scalerInfo = (FTScalerInfo*) jlong_to_ptr(pScaler);
if (scalerInfo == NULL) {
invalidateJavaScaler(env, scaler, scalerInfo);
return 0L;
}
// init layout table cache in font
// we're assuming the font is a file font and moreover it is Truetype font
// otherwise we shouldn't be able to get here...
if (scalerInfo->layoutTables == NULL) {
scalerInfo->layoutTables = newLayoutTableCache();
}
return ptr_to_jlong(scalerInfo->layoutTables);
}
void AwtCursor::Dispose()
{
delete[] mask;
delete[] cols;
if (custom) {
::DestroyIcon(hCursor);
}
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jobject localObj = env->NewLocalRef(jCursor);
if (localObj != NULL) {
setPData(localObj, ptr_to_jlong(NULL));
env->DeleteLocalRef(localObj);
}
env->DeleteWeakGlobalRef(jCursor);
AwtObject::Dispose();
}
jobject java_object_new(JNIEnv *env, jclass_type_t type, void *native_obj)
{
jobject obj;
jclass cls;
jfieldID fid;
// Create object without calling constructor.
// The constructor would call into native methods to create a new native data object.
switch (type) {
case JCLASS_DATAOBJECT:
fid = jc_dataobject.fid.native;
cls = jc_dataobject.cls;
break;
case JCLASS_NODE:
fid = jc_node.fid.native;
cls = jc_node.cls;
break;
case JCLASS_ATTRIBUTE:
fid = jc_attribute.fid.native;
cls = jc_attribute.cls;
break;
case JCLASS_HANDLE:
fid = jc_handle.fid.native;
cls = jc_handle.cls;
break;
case JCLASS_INTERFACE:
fid = jc_interface.fid.native;
cls = jc_interface.cls;
break;
default:
return NULL;
}
obj = (*env)->AllocObject(env, cls);
if (!obj)
return NULL;
(*env)->SetLongField(env, obj, fid, ptr_to_jlong(native_obj));
return obj;
}
JNIEXPORT jlong JNICALL Java_sun_security_pkcs11_Secmod_nssGetLibraryHandle
(JNIEnv *env, jclass thisClass, jstring jLibName)
{
void *hModule;
const char *libName = (*env)->GetStringUTFChars(env, jLibName, NULL);
if (libName == NULL) {
return 0L;
}
// look up existing handle only, do not load
#if defined(AIX)
hModule = dlopen(libName, RTLD_LAZY);
#else
hModule = dlopen(libName, RTLD_NOLOAD);
#endif
dprintf2("-handle for %s: %u\n", libName, hModule);
(*env)->ReleaseStringUTFChars(env, jLibName, libName);
return ptr_to_jlong(hModule);
}
