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_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;
}
}
}
__private_extern__
jstring newStringPlatform(JNIEnv *env, const char* str)
{
jstring rv = NULL;
CFMutableStringRef csref = CFStringCreateMutable(NULL, 0);
if (csref == NULL) {
JNU_ThrowOutOfMemoryError(env, "native heap");
} else {
CFStringAppendCString(csref, str, kCFStringEncodingUTF8);
CFStringNormalize(csref, kCFStringNormalizationFormC);
int clen = CFStringGetLength(csref);
int ulen = (clen + 1) * 2; // utf16 + zero padding
char* chars = malloc(ulen);
if (chars == NULL) {
CFRelease(csref);
JNU_ThrowOutOfMemoryError(env, "native heap");
} else {
if (CFStringGetCString(csref, chars, ulen, kCFStringEncodingUTF16)) {
rv = (*env)->NewString(env, (jchar*)chars, clen);
}
free(chars);
CFRelease(csref);
}
}
return rv;
}
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;
}
}
}
JNIEXPORT void JNICALL
Java_sun_java2d_opengl_GLXSurfaceData_initOps(JNIEnv *env, jobject glxsd,
jobject peer, jlong aData)
{
#ifndef HEADLESS
GLXSDOps *glxsdo = (GLXSDOps *)malloc(sizeof(GLXSDOps));
if (glxsdo == NULL) {
JNU_ThrowOutOfMemoryError(env, "creating native GLX ops");
return;
}
OGLSDOps *oglsdo = (OGLSDOps *)SurfaceData_InitOps(env, glxsd,
sizeof(OGLSDOps));
if (oglsdo == NULL) {
free(glxsdo);
JNU_ThrowOutOfMemoryError(env, "Initialization of SurfaceData failed.");
return;
}
J2dTraceLn(J2D_TRACE_INFO, "GLXSurfaceData_initOps");
oglsdo->privOps = glxsdo;
oglsdo->sdOps.Lock = OGLSD_Lock;
oglsdo->sdOps.GetRasInfo = OGLSD_GetRasInfo;
oglsdo->sdOps.Unlock = OGLSD_Unlock;
oglsdo->sdOps.Dispose = OGLSD_Dispose;
oglsdo->drawableType = OGLSD_UNDEFINED;
oglsdo->activeBuffer = GL_FRONT;
oglsdo->needsInit = JNI_TRUE;
if (peer != NULL) {
glxsdo->window = JNU_CallMethodByName(env, NULL, peer,
"getContentWindow", "()J").j;
} else {
glxsdo->window = 0;
}
glxsdo->configData = (AwtGraphicsConfigDataPtr)jlong_to_ptr(aData);
if (glxsdo->configData == NULL) {
free(glxsdo);
JNU_ThrowNullPointerException(env,
"Native GraphicsConfig data block missing");
return;
}
if (glxsdo->configData->glxInfo == NULL) {
free(glxsdo);
JNU_ThrowNullPointerException(env, "GLXGraphicsConfigInfo missing");
return;
}
#endif /* HEADLESS */
}
/*
* Class: sun_security_pkcs11_wrapper_PKCS11
* Method: C_VerifyRecover
* Signature: (J[BII[BII)I
* Parametermapping: *PKCS11*
* @param jlong jSessionHandle CK_SESSION_HANDLE hSession
* @param jbyteArray jSignature CK_BYTE_PTR pSignature
* CK_ULONG ulSignatureLen
* @return jbyteArray jData CK_BYTE_PTR pData
* CK_ULONG_PTR pulDataLen
*/
JNIEXPORT jint JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1VerifyRecover
(JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jIn, jint jInOfs, jint jInLen, jbyteArray jOut, jint jOutOfs, jint jOutLen)
{
CK_SESSION_HANDLE ckSessionHandle;
CK_RV rv;
CK_BYTE INBUF[MAX_STACK_BUFFER_LEN];
CK_BYTE OUTBUF[MAX_STACK_BUFFER_LEN];
CK_BYTE_PTR inBufP;
CK_BYTE_PTR outBufP = OUTBUF;
CK_ULONG ckDataLength = MAX_STACK_BUFFER_LEN;
CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
if (ckpFunctions == NULL) { return 0; }
ckSessionHandle = jLongToCKULong(jSessionHandle);
if (jInLen <= MAX_STACK_BUFFER_LEN) {
inBufP = INBUF;
} else {
inBufP = (CK_BYTE_PTR) malloc((size_t)jInLen);
if (inBufP == NULL) {
JNU_ThrowOutOfMemoryError(env, 0);
return 0;
}
}
(*env)->GetByteArrayRegion(env, jIn, jInOfs, jInLen, (jbyte *)inBufP);
if ((*env)->ExceptionCheck(env)) {
if (inBufP != INBUF) { free(inBufP); }
return 0;
}
rv = (*ckpFunctions->C_VerifyRecover)(ckSessionHandle, inBufP, jInLen, outBufP, &ckDataLength);
/* re-alloc larger buffer if it fits into our Java buffer */
if ((rv == CKR_BUFFER_TOO_SMALL) && (ckDataLength <= jIntToCKULong(jOutLen))) {
outBufP = (CK_BYTE_PTR) malloc(ckDataLength);
if (outBufP == NULL) {
if (inBufP != INBUF) { free(inBufP); }
JNU_ThrowOutOfMemoryError(env, 0);
return 0;
}
rv = (*ckpFunctions->C_VerifyRecover)(ckSessionHandle, inBufP, jInLen, outBufP, &ckDataLength);
}
if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
(*env)->SetByteArrayRegion(env, jOut, jOutOfs, ckDataLength, (jbyte *)outBufP);
}
if (inBufP != INBUF) { free(inBufP); }
if (outBufP != OUTBUF) { free(outBufP); }
return ckDataLength;
}
JNIEXPORT void JNICALL
Java_sun_java2d_opengl_WGLSurfaceData_initOps(JNIEnv *env, jobject wglsd,
jlong pConfigInfo,
jobject peer, jlong hwnd)
{
OGLSDOps *oglsdo = (OGLSDOps *)SurfaceData_InitOps(env, wglsd,
sizeof(OGLSDOps));
WGLSDOps *wglsdo = (WGLSDOps *)malloc(sizeof(WGLSDOps));
J2dTraceLn(J2D_TRACE_INFO, "WGLSurfaceData_initOps");
if (wglsdo == NULL) {
JNU_ThrowOutOfMemoryError(env, "creating native wgl ops");
return;
}
if (oglsdo == NULL) {
free(wglsdo);
JNU_ThrowOutOfMemoryError(env, "Initialization of SurfaceData failed.");
return;
}
oglsdo->privOps = wglsdo;
oglsdo->sdOps.Lock = OGLSD_Lock;
oglsdo->sdOps.GetRasInfo = OGLSD_GetRasInfo;
oglsdo->sdOps.Unlock = OGLSD_Unlock;
oglsdo->sdOps.Dispose = OGLSD_Dispose;
oglsdo->drawableType = OGLSD_UNDEFINED;
oglsdo->activeBuffer = GL_FRONT;
oglsdo->needsInit = JNI_TRUE;
if (peer != NULL) {
RECT insets;
AwtComponent_GetInsets(env, peer, &insets);
oglsdo->xOffset = -insets.left;
oglsdo->yOffset = -insets.bottom;
} else {
oglsdo->xOffset = 0;
oglsdo->yOffset = 0;
}
wglsdo->window = (HWND)jlong_to_ptr(hwnd);
wglsdo->configInfo = (WGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
if (wglsdo->configInfo == NULL) {
free(wglsdo);
JNU_ThrowNullPointerException(env, "Config info is null in initOps");
}
}
JNIEXPORT jstring JNICALL
Java_sun_print_Win32PrintService_getPrinterPort(JNIEnv *env,
jobject peer,
jstring printer)
{
if (printer == NULL) {
return NULL;
}
jstring jPort;
LPTSTR printerName = NULL, printerPort = TEXT("LPT1");
LPBYTE buffer = NULL;
DWORD cbBuf = 0;
try {
VERIFY(AwtPrintControl::FindPrinter(NULL, NULL, &cbBuf, NULL, NULL));
buffer = new BYTE[cbBuf];
AwtPrintControl::FindPrinter(printer, buffer, &cbBuf,
&printerName, &printerPort);
} catch (std::bad_alloc&) {
delete [] buffer;
JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
return NULL;
}
if (printerPort == NULL) {
printerPort = TEXT("LPT1");
}
jPort = JNU_NewStringPlatform(env, printerPort);
delete [] buffer;
return jPort;
}
/*
* Class: sun_java2d_loops_GraphicsPrimitiveMgr
* Method: initIDs
* Signature: (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_loops_GraphicsPrimitiveMgr_initIDs
(JNIEnv *env, jclass GPMgr,
jclass GP, jclass ST, jclass CT,
jclass SG2D, jclass Color, jclass AT,
jclass XORComp, jclass AlphaComp,
jclass Path2D, jclass Path2DFloat,
jclass SHints)
{
jfieldID fid;
initAlphaTables();
GraphicsPrimitiveMgr = (*env)->NewGlobalRef(env, GPMgr);
GraphicsPrimitive = (*env)->NewGlobalRef(env, GP);
if (GraphicsPrimitiveMgr == NULL || GraphicsPrimitive == NULL) {
JNU_ThrowOutOfMemoryError(env, "creating global refs");
return;
}
if (!InitPrimTypes(env) ||
!InitSurfaceTypes(env, ST) ||
!InitCompositeTypes(env, CT))
{
return;
}
RegisterID = (*env)->GetStaticMethodID(env, GPMgr,
RegisterName, RegisterSig);
pNativePrimID = (*env)->GetFieldID(env, GP, "pNativePrim", "J");
pixelID = (*env)->GetFieldID(env, SG2D, "pixel", "I");
eargbID = (*env)->GetFieldID(env, SG2D, "eargb", "I");
clipRegionID = (*env)->GetFieldID(env, SG2D, "clipRegion",
"Lsun/java2d/pipe/Region;");
compositeID = (*env)->GetFieldID(env, SG2D, "composite",
"Ljava/awt/Composite;");
lcdTextContrastID =
(*env)->GetFieldID(env, SG2D, "lcdTextContrast", "I");
valueID = (*env)->GetFieldID(env, Color, "value", "I");
xorPixelID = (*env)->GetFieldID(env, XORComp, "xorPixel", "I");
xorColorID = (*env)->GetFieldID(env, XORComp, "xorColor",
"Ljava/awt/Color;");
alphaMaskID = (*env)->GetFieldID(env, XORComp, "alphaMask", "I");
ruleID = (*env)->GetFieldID(env, AlphaComp, "rule", "I");
extraAlphaID = (*env)->GetFieldID(env, AlphaComp, "extraAlpha", "F");
m00ID = (*env)->GetFieldID(env, AT, "m00", "D");
m01ID = (*env)->GetFieldID(env, AT, "m01", "D");
m02ID = (*env)->GetFieldID(env, AT, "m02", "D");
m10ID = (*env)->GetFieldID(env, AT, "m10", "D");
m11ID = (*env)->GetFieldID(env, AT, "m11", "D");
m12ID = (*env)->GetFieldID(env, AT, "m12", "D");
path2DTypesID = (*env)->GetFieldID(env, Path2D, "pointTypes", "[B");
path2DNumTypesID = (*env)->GetFieldID(env, Path2D, "numTypes", "I");
path2DWindingRuleID = (*env)->GetFieldID(env, Path2D, "windingRule", "I");
path2DFloatCoordsID = (*env)->GetFieldID(env, Path2DFloat,
"floatCoords", "[F");
sg2dStrokeHintID = (*env)->GetFieldID(env, SG2D, "strokeHint", "I");
fid = (*env)->GetStaticFieldID(env, SHints, "INTVAL_STROKE_PURE", "I");
sunHints_INTVAL_STROKE_PURE = (*env)->GetStaticIntField(env, SHints, fid);
}
JNIEXPORT void JNICALL
Java_sun_nio_ch_DatagramChannelImpl_initIDs(JNIEnv *env, jclass clazz)
{
clazz = (*env)->FindClass(env, "java/net/InetSocketAddress");
CHECK_NULL(clazz);
isa_class = (*env)->NewGlobalRef(env, clazz);
if (isa_class == NULL) {
JNU_ThrowOutOfMemoryError(env, NULL);
return;
}
isa_ctorID = (*env)->GetMethodID(env, clazz, "<init>",
"(Ljava/net/InetAddress;I)V");
CHECK_NULL(isa_ctorID);
clazz = (*env)->FindClass(env, "sun/nio/ch/DatagramChannelImpl");
CHECK_NULL(clazz);
dci_senderID = (*env)->GetFieldID(env, clazz, "sender",
"Ljava/net/SocketAddress;");
CHECK_NULL(dci_senderID);
dci_senderAddrID = (*env)->GetFieldID(env, clazz,
"cachedSenderInetAddress",
"Ljava/net/InetAddress;");
CHECK_NULL(dci_senderAddrID);
dci_senderPortID = (*env)->GetFieldID(env, clazz,
"cachedSenderPort", "I");
CHECK_NULL(dci_senderPortID);
}
JNIEXPORT jboolean JNICALL
Java_java_nio_MappedByteBuffer_isLoaded0(JNIEnv *env, jobject obj,
jlong address, jlong len)
{
jboolean loaded = JNI_TRUE;
jint pageSize = sysconf(_SC_PAGESIZE);
jint numPages = (len + pageSize - 1) / pageSize;
int result = 0;
int i = 0;
void *a = (void *) jlong_to_ptr(address);
char * vec = (char *)malloc(numPages * sizeof(char));
if (vec == NULL) {
JNU_ThrowOutOfMemoryError(env, NULL);
return JNI_FALSE;
}
result = mincore(a, (size_t)len, vec);
if (result != 0) {
free(vec);
JNU_ThrowIOExceptionWithLastError(env, "mincore failed");
return JNI_FALSE;
}
for (i=0; i<numPages; i++) {
if (vec[i] == 0) {
loaded = JNI_FALSE;
break;
}
}
free(vec);
return loaded;
}
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;
}
static jstring
environmentBlock9x(JNIEnv *env)
{
int i;
jmethodID String_init_ID =
(*env)->GetMethodID(env, JNU_ClassString(env), "<init>", "([B)V");
jbyteArray bytes;
jbyte *blockA = (jbyte *) GetEnvironmentStringsA();
if (blockA == NULL) {
/* Both GetEnvironmentStringsW and GetEnvironmentStringsA
* failed. Out of memory is our best guess. */
JNU_ThrowOutOfMemoryError(env, "GetEnvironmentStrings failed");
return NULL;
}
/* Don't search for "\0\0", since an empty environment block may
legitimately consist of a single "\0". */
for (i = 0; blockA[i];)
while (blockA[i++])
;
if ((bytes = (*env)->NewByteArray(env, i)) == NULL) return NULL;
(*env)->SetByteArrayRegion(env, bytes, 0, i, blockA);
FreeEnvironmentStringsA(blockA);
return (*env)->NewObject(env, JNU_ClassString(env),
String_init_ID, bytes);
}
/*
* Add the given notify encapsulation object to the list of active notify
* objects.
* If notifyEncapsulation is NULL, this function does nothing.
*/
void putNotifyEntry(JNIEnv *env, CK_SESSION_HANDLE hSession, NotifyEncapsulation *notifyEncapsulation) {
NotifyListNode *currentNode, *newNode;
if (notifyEncapsulation == NULL) {
return;
}
newNode = (NotifyListNode *) malloc(sizeof(NotifyListNode));
if (newNode == NULL) {
JNU_ThrowOutOfMemoryError(env, 0);
return;
}
newNode->hSession = hSession;
newNode->notifyEncapsulation = notifyEncapsulation;
newNode->next = NULL;
(*env)->MonitorEnter(env, notifyListLock); /* synchronize access to list */
if (notifyListHead == NULL) {
/* this is the first entry */
notifyListHead = newNode;
} else {
/* go to the last entry; i.e. the first node which's 'next' is NULL.
*/
currentNode = notifyListHead;
while (currentNode->next != NULL) {
currentNode = currentNode->next;
}
currentNode->next = newNode;
}
(*env)->MonitorExit(env, notifyListLock); /* synchronize access to list */
}
/*
* Returns list of page sizes and imageable area.
*/
JNIEXPORT jfloatArray JNICALL
Java_sun_print_CUPSPrinter_getPageSizes(JNIEnv *env,
jobject printObj,
jstring printer)
{
ppd_file_t *ppd;
ppd_option_t *option;
ppd_choice_t *choice;
ppd_size_t *size;
const char *name = (*env)->GetStringUTFChars(env, printer, NULL);
if (name == NULL) {
(*env)->ExceptionClear(env);
JNU_ThrowOutOfMemoryError(env, "Could not create printer name");
return NULL;
}
const char *filename;
int i;
jobjectArray sizeArray = NULL;
jfloat *dims;
// NOTE: cupsGetPPD returns a pointer to a filename of a temporary file.
// unlink() must be called to remove the file after using it.
filename = j2d_cupsGetPPD(name);
(*env)->ReleaseStringUTFChars(env, printer, name);
CHECK_NULL_RETURN(filename, NULL);
if ((ppd = j2d_ppdOpenFile(filename)) == NULL) {
unlink(filename);
DPRINTF("unable to open PPD %s\n", filename)
return NULL;
}
/*
* Class: sun_net_dns_ResolverConfgurationImpl
* Method: loadConfig0
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_sun_net_dns_ResolverConfigurationImpl_loadDNSconfig0(JNIEnv *env, jclass cls)
{
char searchlist[MAX_STR_LEN];
char nameservers[MAX_STR_LEN];
jstring obj;
searchlist[0] = '\0';
nameservers[0] = '\0';
if (loadConfig(searchlist, nameservers) != STS_ERROR) {
/*
* Populate static fields in sun.net.DefaultResolverConfiguration
*/
obj = (*env)->NewStringUTF(env, searchlist);
CHECK_NULL(obj);
(*env)->SetStaticObjectField(env, cls, searchlistID, obj);
obj = (*env)->NewStringUTF(env, nameservers);
CHECK_NULL(obj);
(*env)->SetStaticObjectField(env, cls, nameserversID, obj);
} else {
JNU_ThrowOutOfMemoryError(env, "native memory allocation failed");
}
}
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_java2d_d3d_D3DSurfaceData
* Method: initOps
* Signature: (III)V
*/
JNIEXPORT void
JNICALL Java_sun_java2d_d3d_D3DSurfaceData_initOps
(JNIEnv *env, jobject d3dsd, jint gdiScreen, jint width, jint height)
{
D3DPipelineManager *pMgr;
D3DSDOps *d3dsdo = (D3DSDOps *)SurfaceData_InitOps(env, d3dsd,
sizeof(D3DSDOps));
J2dTraceLn(J2D_TRACE_INFO, "D3DSurfaceData_initOps");
if (d3dsdo == NULL) {
JNU_ThrowOutOfMemoryError(env, "creating native d3d ops");
return;
}
d3dsdo->sdOps.Lock = D3DSD_Lock;
d3dsdo->sdOps.GetRasInfo = D3DSD_GetRasInfo;
d3dsdo->sdOps.Unlock = D3DSD_Unlock;
d3dsdo->sdOps.Dispose = D3DSD_Dispose;
d3dsdo->xoff = 0;
d3dsdo->yoff = 0;
d3dsdo->width = width;
d3dsdo->height = height;
d3dsdo->pResource = NULL;
d3dsdo->adapter =
(pMgr = D3DPipelineManager::GetInstance()) == NULL ?
D3DADAPTER_DEFAULT :
pMgr->GetAdapterOrdinalForScreen(gdiScreen);
}
/*
* Class: sun_tools_attach_LinuxVirtualMachine
* Method: isLinuxThreads
* Signature: ()V
*/
JNIEXPORT jboolean JNICALL Java_sun_tools_attach_LinuxVirtualMachine_isLinuxThreads
(JNIEnv *env, jclass cls)
{
# ifndef _CS_GNU_LIBPTHREAD_VERSION
# define _CS_GNU_LIBPTHREAD_VERSION 3
# endif
size_t n;
char* s;
jboolean res;
n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);
if (n <= 0) {
/* glibc before 2.3.2 only has LinuxThreads */
return JNI_TRUE;
}
s = (char *)malloc(n);
if (s == NULL) {
JNU_ThrowOutOfMemoryError(env, "malloc failed");
return JNI_TRUE;
}
confstr(_CS_GNU_LIBPTHREAD_VERSION, s, n);
/*
* If the LIBPTHREAD version include "NPTL" then we know we
* have the new threads library and not LinuxThreads
*/
res = (jboolean)(strstr(s, "NPTL") == NULL);
free(s);
return res;
}
/*
* Class: sun_security_pkcs11_wrapper_PKCS11
* Method: C_GetOperationState
* Signature: (J)[B
* Parametermapping: *PKCS11*
* @param jlong jSessionHandle CK_SESSION_HANDLE hSession
* @return jbyteArray jState CK_BYTE_PTR pOperationState
* CK_ULONG_PTR pulOperationStateLen
*/
JNIEXPORT jbyteArray JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetOperationState
(JNIEnv *env, jobject obj, jlong jSessionHandle)
{
CK_SESSION_HANDLE ckSessionHandle;
CK_BYTE_PTR ckpState;
CK_ULONG ckStateLength;
jbyteArray jState = NULL;
CK_RV rv;
CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
if (ckpFunctions == NULL) { return NULL; }
ckSessionHandle = jLongToCKULong(jSessionHandle);
rv = (*ckpFunctions->C_GetOperationState)(ckSessionHandle, NULL_PTR, &ckStateLength);
if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return NULL ; }
ckpState = (CK_BYTE_PTR) malloc(ckStateLength);
if (ckpState == NULL) {
JNU_ThrowOutOfMemoryError(env, 0);
return NULL;
}
rv = (*ckpFunctions->C_GetOperationState)(ckSessionHandle, ckpState, &ckStateLength);
if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
jState = ckByteArrayToJByteArray(env, ckpState, ckStateLength);
}
free(ckpState);
return jState ;
}
/*
* Class: sun_nio_ch_sctp_SctpNet
* Method: bindx
* Signature: (I[Ljava/net/InetAddress;IIZ)V
*/
JNIEXPORT void JNICALL Java_sun_nio_ch_sctp_SctpNet_bindx
(JNIEnv *env, jclass klass, jint fd, jobjectArray addrs, jint port,
jint addrsLength, jboolean add, jboolean preferIPv6) {
SOCKETADDRESS *sap, *tmpSap;
int i, sa_len = sizeof(SOCKETADDRESS);
jobject ia;
if (addrsLength < 1)
return;
if ((sap = calloc(addrsLength, sa_len)) == NULL) {
JNU_ThrowOutOfMemoryError(env, "heap allocation failure");
return;
}
tmpSap = sap;
for (i = 0; i < addrsLength; i++) {
ia = (*env)->GetObjectArrayElement(env, addrs, i);
if (NET_InetAddressToSockaddr(env, ia, port, (struct sockaddr*)tmpSap,
&sa_len, preferIPv6) != 0) {
free(sap);
return;
}
tmpSap++;
}
if (nio_sctp_bindx(fd, (void *)sap, addrsLength, add ? SCTP_BINDX_ADD_ADDR :
SCTP_BINDX_REM_ADDR) != 0) {
handleSocketError(env, errno);
}
free(sap);
}
// this should be called from XRobotPeer constructor
JNIEXPORT void JNICALL
Java_sun_awt_X11_XRobotPeer_setup (JNIEnv * env, jclass cls, jint numberOfButtons, jintArray buttonDownMasks)
{
int32_t xtestAvailable;
jint *tmp;
int i;
DTRACE_PRINTLN("RobotPeer: setup()");
num_buttons = numberOfButtons;
tmp = (*env)->GetIntArrayElements(env, buttonDownMasks, JNI_FALSE);
masks = (jint *)malloc(sizeof(jint) * num_buttons);
if (masks == (jint *) NULL) {
JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2), NULL);
(*env)->ReleaseIntArrayElements(env, buttonDownMasks, tmp, 0);
return;
}
for (i = 0; i < num_buttons; i++) {
masks[i] = tmp[i];
}
(*env)->ReleaseIntArrayElements(env, buttonDownMasks, tmp, 0);
AWT_LOCK();
xtestAvailable = isXTestAvailable();
DTRACE_PRINTLN1("RobotPeer: XTest available = %d", xtestAvailable);
if (!xtestAvailable) {
JNU_ThrowByName(env, "java/awt/AWTException", "java.awt.Robot requires your X server support the XTEST extension version 2.2");
}
AWT_UNLOCK();
}
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);
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDrawPoly
* Signature: (IJII[I[IIZ)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawPoly
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint transx, jint transy,
jintArray xcoordsArray, jintArray ycoordsArray, jint npoints,
jboolean isclosed)
{
#ifndef HEADLESS
XPoint pTmp[POLYTEMPSIZE], *points;
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (JNU_IsNull(env, xcoordsArray) || JNU_IsNull(env, ycoordsArray)) {
JNU_ThrowNullPointerException(env, "coordinate array");
return;
}
if ((*env)->GetArrayLength(env, ycoordsArray) < npoints ||
(*env)->GetArrayLength(env, xcoordsArray) < npoints)
{
JNU_ThrowArrayIndexOutOfBoundsException(env, "coordinate array");
return;
}
if (npoints < 2) {
return;
}
points = transformPoints(env, xcoordsArray, ycoordsArray, transx, transy,
pTmp, (int *)&npoints, isclosed);
if (points == 0) {
JNU_ThrowOutOfMemoryError(env, "translated coordinate array");
} else {
if (npoints == 2) {
/*
* Some X11 implementations fail to draw anything for
* simple 2 point polygons where the vertices are the
* same point even though this violates the X11
* specification. For simplicity we will dispatch all
* 2 point polygons through XDrawLine even if they are
* non-degenerate as this may invoke less processing
* down the line than a Poly primitive anyway.
*/
XDrawLine(awt_display, xsdo->drawable, (GC) xgc,
points[0].x, points[0].y,
points[1].x, points[1].y);
} else {
XDrawLines(awt_display, xsdo->drawable, (GC) xgc,
points, npoints, CoordModeOrigin);
}
if (points != pTmp) {
free(points);
}
X11SD_DirectRenderNotify(env, xsdo);
}
#endif /* !HEADLESS */
}
// This function is called when a std::bad_alloc exception is caught.
void
handle_bad_alloc(void) {
if (jvm != NULL) {
JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
if (env != NULL) {
JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
}
}
}
JNIEXPORT jlong JNICALL
Java_sun_nio_ch_SocketDispatcher_readv0(JNIEnv *env, jclass clazz, jobject fdo,
jlong address, jint len)
{
/* set up */
int i = 0;
DWORD read = 0;
DWORD flags = 0;
jint fd = fdval(env, fdo);
struct iovec *iovp = (struct iovec *)address;
WSABUF *bufs = malloc(len * sizeof(WSABUF));
jint rem = MAX_BUFFER_SIZE;
if (bufs == 0) {
JNU_ThrowOutOfMemoryError(env, 0);
return IOS_THROWN;
}
/* copy iovec into WSABUF */
for(i=0; i<len; i++) {
jint iov_len = iovp[i].iov_len;
if (iov_len > rem)
iov_len = rem;
bufs[i].buf = (char *)iovp[i].iov_base;
bufs[i].len = (u_long)iov_len;
rem -= iov_len;
if (rem == 0) {
len = i+1;
break;
}
}
/* read into the buffers */
i = WSARecv((SOCKET)fd, /* Socket */
bufs, /* pointers to the buffers */
(DWORD)len, /* number of buffers to process */
&read, /* receives number of bytes read */
&flags, /* no flags */
0, /* no overlapped sockets */
0); /* no completion routine */
/* clean up */
free(bufs);
if (i != 0) {
int theErr = (jint)WSAGetLastError();
if (theErr == WSAEWOULDBLOCK) {
return IOS_UNAVAILABLE;
}
JNU_ThrowIOExceptionWithLastError(env, "Vector read failed");
return IOS_THROWN;
}
return convertLongReturnVal(env, (jlong)read, JNI_TRUE);
}
/*
* Class: sun_security_pkcs11_wrapper_PKCS11
* Method: C_Digest
* Signature: (J[BII[BII)I
* Parametermapping: *PKCS11*
* @param jlong jSessionHandle CK_SESSION_HANDLE hSession
* @param jbyteArray jData CK_BYTE_PTR pData
* CK_ULONG ulDataLen
* @return jbyteArray jDigest CK_BYTE_PTR pDigest
* CK_ULONG_PTR pulDigestLen
*/
JNIEXPORT jint JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestSingle
(JNIEnv *env, jobject obj, jlong jSessionHandle, jobject jMechanism, jbyteArray jIn, jint jInOfs, jint jInLen, jbyteArray jDigest, jint jDigestOfs, jint jDigestLen)
{
CK_SESSION_HANDLE ckSessionHandle;
CK_RV rv;
CK_BYTE_PTR bufP;
CK_BYTE BUF[MAX_STACK_BUFFER_LEN];
CK_BYTE DIGESTBUF[MAX_DIGEST_LEN];
CK_ULONG ckDigestLength = min(MAX_DIGEST_LEN, jDigestLen);
CK_MECHANISM ckMechanism;
CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
if (ckpFunctions == NULL) { return 0; }
ckSessionHandle = jLongToCKULong(jSessionHandle);
jMechanismToCKMechanism(env, jMechanism, &ckMechanism);
if ((*env)->ExceptionCheck(env)) { return 0; }
rv = (*ckpFunctions->C_DigestInit)(ckSessionHandle, &ckMechanism);
if (ckMechanism.pParameter != NULL_PTR) {
free(ckMechanism.pParameter);
}
if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return 0; }
if (jInLen <= MAX_STACK_BUFFER_LEN) {
bufP = BUF;
} else {
/* always use single part op, even for large data */
bufP = (CK_BYTE_PTR) malloc((size_t)jInLen);
if (bufP == NULL) {
JNU_ThrowOutOfMemoryError(env, 0);
return 0;
}
}
(*env)->GetByteArrayRegion(env, jIn, jInOfs, jInLen, (jbyte *)bufP);
if ((*env)->ExceptionCheck(env)) {
if (bufP != BUF) { free(bufP); }
return 0;
}
rv = (*ckpFunctions->C_Digest)(ckSessionHandle, bufP, jInLen, DIGESTBUF, &ckDigestLength);
if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
(*env)->SetByteArrayRegion(env, jDigest, jDigestOfs, ckDigestLength, (jbyte *)DIGESTBUF);
}
if (bufP != BUF) { free(bufP); }
return ckDigestLength;
}
/*
* Class: sun_security_pkcs11_wrapper_PKCS11
* Method: C_DigestUpdate
* Signature: (J[B)V
* Parametermapping: *PKCS11*
* @param jlong jSessionHandle CK_SESSION_HANDLE hSession
* @param jbyteArray jData CK_BYTE_PTR pData
* CK_ULONG ulDataLen
*/
JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestUpdate
(JNIEnv *env, jobject obj, jlong jSessionHandle, jlong directIn, jbyteArray jIn, jint jInOfs, jint jInLen)
{
CK_SESSION_HANDLE ckSessionHandle;
CK_RV rv;
CK_BYTE_PTR bufP;
CK_BYTE BUF[MAX_STACK_BUFFER_LEN];
jsize bufLen;
CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
if (ckpFunctions == NULL) { return; }
ckSessionHandle = jLongToCKULong(jSessionHandle);
if (directIn != 0) {
rv = (*ckpFunctions->C_DigestUpdate)(ckSessionHandle, (CK_BYTE_PTR)directIn, jInLen);
ckAssertReturnValueOK(env, rv);
return;
}
if (jInLen <= MAX_STACK_BUFFER_LEN) {
bufLen = MAX_STACK_BUFFER_LEN;
bufP = BUF;
} else {
bufLen = min(MAX_HEAP_BUFFER_LEN, jInLen);
bufP = (CK_BYTE_PTR) malloc((size_t)bufLen);
if (bufP == NULL) {
JNU_ThrowOutOfMemoryError(env, 0);
return;
}
}
while (jInLen > 0) {
jsize chunkLen = min(bufLen, jInLen);
(*env)->GetByteArrayRegion(env, jIn, jInOfs, chunkLen, (jbyte *)bufP);
if ((*env)->ExceptionCheck(env)) {
if (bufP != BUF) { free(bufP); }
return;
}
rv = (*ckpFunctions->C_DigestUpdate)(ckSessionHandle, bufP, chunkLen);
if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) {
if (bufP != BUF) { free(bufP); }
return;
}
jInOfs += chunkLen;
jInLen -= chunkLen;
}
if (bufP != BUF) {
free(bufP);
}
}
/*
* Class: java_net_DualStackPlainDatagramSocketImpl
* Method: socketSend
* Signature: (I[BIILjava/net/InetAddress;IZ)V
*/
JNIEXPORT void JNICALL Java_java_net_DualStackPlainDatagramSocketImpl_socketSend
(JNIEnv *env, jclass clazz, jint fd, jbyteArray data, jint offset, jint length,
jobject iaObj, jint port, jboolean connected) {
SOCKETADDRESS sa;
int sa_len = sizeof(sa);
SOCKETADDRESS *sap = &sa;
char BUF[MAX_BUFFER_LEN];
char *fullPacket;
int rv;
if (connected) {
sap = 0; /* arg to JVM_Sendto () null in this case */
sa_len = 0;
} else {
if (NET_InetAddressToSockaddr(env, iaObj, port, (struct sockaddr *)&sa,
&sa_len, JNI_TRUE) != 0) {
return;
}
}
if (length > MAX_BUFFER_LEN) {
/* Note: the buffer needn't be greater than 65,536 (0xFFFF)
* the max size of an IP packet. Anything bigger is truncated anyway.
*/
if (length > MAX_PACKET_LEN) {
length = MAX_PACKET_LEN;
}
fullPacket = (char *)malloc(length);
if (!fullPacket) {
JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed");
return;
}
} else {
fullPacket = &(BUF[0]);
}
(*env)->GetByteArrayRegion(env, data, offset, length,
(jbyte *)fullPacket);
rv = sendto(fd, fullPacket, length, 0, (struct sockaddr *)sap, sa_len);
if (rv == SOCKET_ERROR) {
if (rv == JVM_IO_ERR) {
NET_ThrowNew(env, WSAGetLastError(), "Datagram send failed");
} else if (rv == JVM_IO_INTR) {
JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
"operation interrupted");
}
}
if (length > MAX_BUFFER_LEN) {
free(fullPacket);
}
}
/**
* Creates a CF string from the given Java string.
* If javaString is NULL, NULL is returned.
* If a memory error occurs, and OutOfMemoryError is thrown and
* NULL is returned.
*/
static CFStringRef toCFString(JNIEnv *env, jstring javaString)
{
if (javaString == NULL) {
return NULL;
} else {
CFStringRef result = NULL;
jsize length = (*env)->GetStringLength(env, javaString);
const jchar *chars = (*env)->GetStringChars(env, javaString, NULL);
if (chars == NULL) {
JNU_ThrowOutOfMemoryError(env, "toCFString failed");
return NULL;
}
result = CFStringCreateWithCharacters(NULL, (const UniChar *)chars,
length);
(*env)->ReleaseStringChars(env, javaString, chars);
if (result == NULL) {
JNU_ThrowOutOfMemoryError(env, "toCFString failed");
return NULL;
}
return result;
}
}
