/*
* Class: sun_tools_attach_BSDVirtualMachine
* Method: createAttachFile
* Signature: (Ljava.lang.String;)V
*/
JNIEXPORT void JNICALL Java_sun_tools_attach_BsdVirtualMachine_createAttachFile(JNIEnv *env, jclass cls, jstring path)
{
const char* _path;
jboolean isCopy;
int fd, rc;
_path = GetStringPlatformChars(env, path, &isCopy);
if (_path == NULL) {
JNU_ThrowIOException(env, "Must specify a path");
return;
}
RESTARTABLE(open(_path, O_CREAT | O_EXCL, S_IWUSR | S_IRUSR), fd);
if (fd == -1) {
/* release p here before we throw an I/O exception */
if (isCopy) {
JNU_ReleaseStringPlatformChars(env, path, _path);
}
JNU_ThrowIOExceptionWithLastError(env, "open");
return;
}
RESTARTABLE(chown(_path, geteuid(), getegid()), rc);
RESTARTABLE(close(fd), rc);
/* release p here */
if (isCopy) {
JNU_ReleaseStringPlatformChars(env, path, _path);
}
}
JNIEXPORT jint JNICALL
Java_sun_print_Win32PrintService_getCopiesSupported(JNIEnv *env,
jobject peer,
jstring printer,
jstring port)
{
LPTSTR printerName = (LPTSTR)JNU_GetStringPlatformChars(env, printer, NULL);
LPTSTR printerPort = (LPTSTR)JNU_GetStringPlatformChars(env, port, NULL);
if (printerName == NULL || printerPort == NULL) {
if (printerName != NULL) {
JNU_ReleaseStringPlatformChars(env, printer, printerName);
}
if (printerPort != NULL) {
JNU_ReleaseStringPlatformChars(env, port, printerPort);
}
return 1;
}
SAVE_CONTROLWORD
int numCopies = ::DeviceCapabilities(printerName, printerPort,
DC_COPIES, NULL, NULL);
RESTORE_CONTROLWORD
if (numCopies == -1)
return 1; // default
JNU_ReleaseStringPlatformChars(env, printer, printerName);
JNU_ReleaseStringPlatformChars(env, port, printerPort);
return numCopies;
}
/*
PostScript Drivers return wrong support info for the following code:
DWORD dmFields = (::DeviceCapabilities(printerName,
NULL, DC_FIELDS, NULL, NULL)) ;
if ((dmFields & DM_YRESOLUTION) )
isSupported = true;
Returns not supported even if it supports resolution. Therefore, we use the
function _getAllResolutions.
*/
JNIEXPORT jintArray JNICALL
Java_sun_print_Win32PrintService_getAllResolutions(JNIEnv *env,
jobject peer,
jstring printer,
jstring port)
{
LPTSTR printerName = (LPTSTR)JNU_GetStringPlatformChars(env, printer, NULL);
LPTSTR printerPort = (LPTSTR)JNU_GetStringPlatformChars(env, port, NULL);
if (printerName == NULL || printerPort == NULL) {
if (printerName != NULL) {
JNU_ReleaseStringPlatformChars(env, printer, printerName);
}
if (printerPort != NULL) {
JNU_ReleaseStringPlatformChars(env, port, printerPort);
}
return NULL;
}
SAVE_CONTROLWORD
int nResolutions = ::DeviceCapabilities(printerName, printerPort,
DC_ENUMRESOLUTIONS, NULL, NULL);
RESTORE_CONTROLWORD
jintArray resolutionArray = NULL;
if (nResolutions > 0) {
resolutionArray = env->NewIntArray(nResolutions*2);
if (resolutionArray != NULL) {
jint *jpcIndices = env->GetIntArrayElements(resolutionArray, NULL);
if (jpcIndices != NULL) {
jint *saveFormats = jpcIndices;
LPTSTR resBuf = NULL;
try {
resBuf = (LPTSTR)new char[nResolutions * sizeof(LONG) * 2];
} catch (std::bad_alloc&) {
resBuf = NULL;
}
if (resBuf != NULL) {
if (::DeviceCapabilities(printerName, printerPort,
DC_ENUMRESOLUTIONS, resBuf,
NULL) != -1) {
LONG *pResolution = (LONG *)resBuf;
for (int i = 0; i < nResolutions; i++) {
jpcIndices[i*2] = *pResolution++;
jpcIndices[i*2+1] = *pResolution++;
}
}
RESTORE_CONTROLWORD
delete[] resBuf;
}
env->ReleaseIntArrayElements(resolutionArray, saveFormats, 0);
}
}
}
JNU_ReleaseStringPlatformChars(env, printer, printerName);
JNU_ReleaseStringPlatformChars(env, printer, printerPort);
return resolutionArray;
}
jintArray getIDs(JNIEnv *env, jstring printer, jstring port, int dm_id)
{
LPTSTR printerName = (LPTSTR)JNU_GetStringPlatformChars(env, printer, NULL);
LPTSTR printerPort = (LPTSTR)JNU_GetStringPlatformChars(env, port, NULL);
if (printerName == NULL || printerPort == NULL) {
if (printerName != NULL) {
JNU_ReleaseStringPlatformChars(env, printer, printerName);
}
if (printerPort != NULL) {
JNU_ReleaseStringPlatformChars(env, port, printerPort);
}
return NULL;
}
SAVE_CONTROLWORD
int numIDs = ::DeviceCapabilities(printerName, printerPort, dm_id,
NULL, NULL);
RESTORE_CONTROLWORD
jintArray idArray = NULL;
if (numIDs > 0) {
idArray = env->NewIntArray(numIDs);
if (idArray != NULL) {
jint *jpcIndices = env->GetIntArrayElements(idArray, NULL);
if (jpcIndices != NULL) {
jint *saveFormats = jpcIndices;
LPTSTR buf = NULL;
try {
buf = (LPTSTR)new char[numIDs * sizeof(WORD)];
} catch (std::bad_alloc&) {
buf = NULL;
}
if (buf != NULL) {
if (::DeviceCapabilities(printerName, printerPort,
dm_id, buf, NULL) != -1) {
WORD *id = (WORD *)buf;
for (int i = 0; i < numIDs; i++, id++) {
jpcIndices[i] = *id;
}
}
RESTORE_CONTROLWORD
delete[] buf;
}
env->ReleaseIntArrayElements(idArray, saveFormats, 0);
}
}
}
JNU_ReleaseStringPlatformChars(env, printer, printerName);
JNU_ReleaseStringPlatformChars(env, port, printerPort);
return idArray;
}
JNIEXPORT jintArray JNICALL
Java_sun_print_Win32PrintService_getAllMediaSizes(JNIEnv *env,
jobject peer,
jstring printer,
jstring port)
{
TRY;
LPTSTR printerName = (LPTSTR)JNU_GetStringPlatformChars(env,
printer, NULL);
LPTSTR printerPort = (LPTSTR)JNU_GetStringPlatformChars(env, port, NULL);
jintArray mediaArray = NULL;
SAVE_CONTROLWORD
int nPapers = ::DeviceCapabilities(printerName, printerPort,
DC_PAPERSIZE, NULL, NULL) ;
RESTORE_CONTROLWORD
if (nPapers > 0) {
mediaArray = env->NewIntArray(nPapers*2);
if (mediaArray == NULL) {
throw std::bad_alloc();
}
jboolean isCopy;
jint *jpcIndices = env->GetIntArrayElements(mediaArray,
&isCopy), *saveFormats = jpcIndices;
LPTSTR buf = (LPTSTR)new char[nPapers * sizeof(POINT)]; // array of POINTs
if (::DeviceCapabilities(printerName, printerPort,
DC_PAPERSIZE, buf, NULL) != -1) {
POINT *pDim = (POINT *)buf;
for (int i = 0; i < nPapers; i++) {
jpcIndices[i*2] = (pDim+i)->x;
jpcIndices[i*2+1] = (pDim+i)->y;
}
}
RESTORE_CONTROLWORD
delete[] buf;
env->ReleaseIntArrayElements(mediaArray, saveFormats, 0);
}
JNU_ReleaseStringPlatformChars(env, printer, printerName);
JNU_ReleaseStringPlatformChars(env, port, printerPort);
return mediaArray;
CATCH_BAD_ALLOC_RET(NULL);
}
JNIEXPORT jintArray JNICALL
Java_sun_print_Win32PrintService_getAllMediaTrays(JNIEnv *env,
jobject peer,
jstring printer,
jstring port)
{
TRY;
LPTSTR printerName = (LPTSTR)JNU_GetStringPlatformChars(env,
printer, NULL);
LPTSTR printerPort = (LPTSTR)JNU_GetStringPlatformChars(env, port, NULL);
jintArray mediaTrayArray = NULL;
SAVE_CONTROLWORD
int nBins = ::DeviceCapabilities(printerName, printerPort,
DC_BINS, NULL, NULL) ;
RESTORE_CONTROLWORD
if (nBins > 0) {
mediaTrayArray = env->NewIntArray(nBins);
if (mediaTrayArray == NULL) {
throw std::bad_alloc();
}
jboolean isCopy;
jint *jpcIndices = env->GetIntArrayElements(mediaTrayArray,
&isCopy), *saveFormats = jpcIndices;
LPTSTR buf = (LPTSTR)new char[nBins * sizeof(WORD)];
if (::DeviceCapabilities(printerName, printerPort,
DC_BINS, buf, NULL) != -1) {
RESTORE_CONTROLWORD
WORD *pBins = (WORD *)buf;
for (int i = 0; i < nBins; i++) {
jpcIndices[i] = *(pBins+i);
}
}
delete[] buf;
env->ReleaseIntArrayElements(mediaTrayArray, saveFormats, 0);
}
JNU_ReleaseStringPlatformChars(env, printer, printerName);
JNU_ReleaseStringPlatformChars(env, port, printerPort);
return mediaTrayArray;
CATCH_BAD_ALLOC_RET(NULL);
}
/*
* Class: sun_awt_windows_WCheckboxPeer
* Method: setLabel
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT void JNICALL
Java_sun_awt_windows_WCheckboxPeer_setLabel(JNIEnv *env, jobject self,
jstring label)
{
TRY;
PDATA pData;
JNI_CHECK_PEER_RETURN(self);
AwtComponent* c = (AwtComponent*)JNI_GET_PDATA(self);
LPCTSTR labelStr;
// Fix for 4378378: by convention null label means empty string
if (label == NULL) {
labelStr = TEXT("");
} else {
labelStr = JNU_GetStringPlatformChars(env, label, JNI_FALSE);
}
if (labelStr == NULL) {
throw std::bad_alloc();
}
c->SetText(labelStr);
c->VerifyState();
// Fix for 4378378: release StringPlatformChars only if label is not null
if (label != NULL) {
JNU_ReleaseStringPlatformChars(env, label, labelStr);
}
CATCH_BAD_ALLOC;
}
/*
* Class: sun_tools_attach_VirtualMachineImpl
* Method: open
* Signature: (Ljava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_sun_tools_attach_VirtualMachineImpl_open
(JNIEnv *env, jclass cls, jstring path)
{
jboolean isCopy;
const char* p = GetStringPlatformChars(env, path, &isCopy);
if (p == NULL) {
return 0;
} else {
int fd;
int err = 0;
fd = open(p, O_RDWR);
if (fd == -1) {
err = errno;
}
if (isCopy) {
JNU_ReleaseStringPlatformChars(env, path, p);
}
if (fd == -1) {
if (err == ENOENT) {
JNU_ThrowByName(env, "java/io/FileNotFoundException", NULL);
} else {
char* msg = strdup(strerror(err));
JNU_ThrowIOException(env, msg);
if (msg != NULL) {
free(msg);
}
}
}
return fd;
}
}
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;
}
void AwtList::_AddItems(void *param)
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
AddItemsStruct *ais = (AddItemsStruct *)param;
jobject self = ais->list;
jobjectArray items = ais->items;
jint index = ais->index;
jint width = ais->width;
int badAlloc = 0;
AwtList *l = NULL;
PDATA pData;
JNI_CHECK_PEER_GOTO(self, ret);
JNI_CHECK_NULL_GOTO(items, "null items", ret);
l = (AwtList*)pData;
if (::IsWindow(l->GetHWnd()))
{
int itemCount = env->GetArrayLength(items);
if (itemCount > 0)
{
AwtList* l = (AwtList*)pData;
l->SendListMessage(WM_SETREDRAW, (WPARAM)FALSE, 0);
for (jsize i=0; i < itemCount; i++)
{
LPTSTR itemPtr = NULL;
jstring item = (jstring)env->GetObjectArrayElement(items, i);
if (env->ExceptionCheck()) goto ret;
if (item == NULL) goto next_item;
itemPtr = (LPTSTR)JNU_GetStringPlatformChars(env, item, 0);
if (itemPtr == NULL)
{
badAlloc = 1;
}
else
{
l->InsertString(index+i, itemPtr);
JNU_ReleaseStringPlatformChars(env, item, itemPtr);
}
env->DeleteLocalRef(item);
next_item:
;
}
l->SendListMessage(WM_SETREDRAW, (WPARAM)TRUE, 0);
l->InvalidateList(NULL, TRUE);
l->CheckMaxWidth(width);
}
}
ret:
env->DeleteGlobalRef(self);
env->DeleteGlobalRef(items);
delete ais;
if (badAlloc)
{
throw std::bad_alloc();
}
}
void AwtPopupMenu::Enable(BOOL isEnabled)
{
AwtMenu *menu = GetMenuContainer();
if (menu != NULL) {
AwtMenu::Enable(isEnabled);
return;
}
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
if (env->EnsureLocalCapacity(1) < 0) {
return;
}
jobject target = GetTarget(env);
int nCount = CountItem(target);
for (int i = 0; i < nCount; ++i) {
AwtMenuItem *item = GetItem(target,i);
jobject jitem = item->GetTarget(env);
BOOL bItemEnabled = isEnabled && (jboolean)env->GetBooleanField(jitem,
AwtMenuItem::enabledID);
jstring labelStr = static_cast<jstring>(env->GetObjectField(jitem, AwtMenuItem::labelID));
LPCWSTR labelStrW = JNU_GetStringPlatformChars(env, labelStr, NULL);
if (labelStrW && wcscmp(labelStrW, L"-") != 0) {
item->Enable(bItemEnabled);
}
JNU_ReleaseStringPlatformChars(env, labelStr, labelStrW);
env->DeleteLocalRef(labelStr);
env->DeleteLocalRef(jitem);
}
env->DeleteLocalRef(target);
}
JNIEXPORT jlong JNICALL
Java_sun_print_Win32PrintServiceLookup_notifyFirstPrinterChange(JNIEnv *env,
jobject peer,
jstring printer) {
HANDLE hPrinter;
LPTSTR printerName = NULL;
if (printer != NULL) {
printerName = (LPTSTR)JNU_GetStringPlatformChars(env,
printer,
NULL);
JNU_ReleaseStringPlatformChars(env, printer, printerName);
}
// printerName - "Win NT/2K/XP: If NULL, it indicates the local printer
// server" - MSDN. Win9x : OpenPrinter returns 0.
BOOL ret = OpenPrinter(printerName, &hPrinter, NULL);
if (!ret) {
return (jlong)-1;
}
// PRINTER_CHANGE_PRINTER = PRINTER_CHANGE_ADD_PRINTER |
// PRINTER_CHANGE_SET_PRINTER |
// PRINTER_CHANGE_DELETE_PRINTER |
// PRINTER_CHANGE_FAILED_CONNECTION_PRINTER
HANDLE chgObj = FindFirstPrinterChangeNotification(hPrinter,
PRINTER_CHANGE_PRINTER,
0,
NULL);
return (chgObj == INVALID_HANDLE_VALUE) ? (jlong)-1 : (jlong)chgObj;
}
JNIEXPORT jint JNICALL
Java_sun_nio_ch_InheritedChannel_open0(JNIEnv *env, jclass cla, jstring path, jint oflag)
{
const char* str;
int oflag_actual;
/* convert to OS specific value */
switch (oflag) {
case sun_nio_ch_InheritedChannel_O_RDWR :
oflag_actual = O_RDWR;
break;
case sun_nio_ch_InheritedChannel_O_RDONLY :
oflag_actual = O_RDONLY;
break;
case sun_nio_ch_InheritedChannel_O_WRONLY :
oflag_actual = O_WRONLY;
break;
default :
JNU_ThrowInternalError(env, "Unrecognized file mode");
return -1;
}
str = JNU_GetStringPlatformChars(env, path, NULL);
if (str == NULL) {
return (jint)-1;
} else {
int fd = open(str, oflag_actual);
if (fd < 0) {
JNU_ThrowIOExceptionWithLastError(env, str);
}
JNU_ReleaseStringPlatformChars(env, path, str);
return (jint)fd;
}
}
/*
* Class: sun_tools_attach_VirtualMachineImpl
* Method: checkPermissions
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_sun_tools_attach_VirtualMachineImpl_checkPermissions
(JNIEnv *env, jclass cls, jstring path)
{
jboolean isCopy;
const char* p = GetStringPlatformChars(env, path, &isCopy);
if (p != NULL) {
struct stat64 sb;
uid_t uid, gid;
int res;
/*
* Check that the path is owned by the effective uid/gid of this
* process. Also check that group/other access is not allowed.
*/
uid = geteuid();
gid = getegid();
res = stat64(p, &sb);
if (res != 0) {
/* save errno */
res = errno;
}
if (res == 0) {
char msg[100];
jboolean isError = JNI_FALSE;
if (sb.st_uid != uid) {
jio_snprintf(msg, sizeof(msg)-1,
"file should be owned by the current user (which is %d) but is owned by %d", uid, sb.st_uid);
isError = JNI_TRUE;
} else if (sb.st_gid != gid) {
jio_snprintf(msg, sizeof(msg)-1,
"file's group should be the current group (which is %d) but the group is %d", gid, sb.st_gid);
isError = JNI_TRUE;
} else if ((sb.st_mode & (S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)) != 0) {
jio_snprintf(msg, sizeof(msg)-1,
"file should only be readable and writable by the owner but has 0%03o access", sb.st_mode & 0777);
isError = JNI_TRUE;
}
if (isError) {
char buf[256];
jio_snprintf(buf, sizeof(buf)-1, "well-known file %s is not secure: %s", p, msg);
JNU_ThrowIOException(env, buf);
}
} else {
char* msg = strdup(strerror(res));
JNU_ThrowIOException(env, msg);
if (msg != NULL) {
free(msg);
}
}
if (isCopy) {
JNU_ReleaseStringPlatformChars(env, path, p);
}
}
}
void AwtCheckbox::_SetLabel(void *param)
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
SetLabelStruct *sls = (SetLabelStruct *)param;
jobject checkbox = sls->checkbox;
jstring label = sls->label;
int badAlloc = 0;
AwtCheckbox *c = NULL;
PDATA pData;
JNI_CHECK_PEER_GOTO(checkbox, done);
c = (AwtCheckbox *)pData;
if (::IsWindow(c->GetHWnd()))
{
LPCTSTR labelStr = NULL;
// By convension null label means empty string
if (label == NULL)
{
labelStr = TEXT("");
}
else
{
labelStr = JNU_GetStringPlatformChars(env, label, JNI_FALSE);
}
if (labelStr == NULL)
{
badAlloc = 1;
}
else
{
c->SetText(labelStr);
c->VerifyState();
if (label != NULL) {
JNU_ReleaseStringPlatformChars(env, label, labelStr);
}
}
}
done:
env->DeleteGlobalRef(checkbox);
if (label != NULL)
{
env->DeleteGlobalRef(label);
}
delete sls;
if (badAlloc) {
throw std::bad_alloc();
}
}
/* Implementation of DebugHelperImpl.printlnImpl */
JNIEXPORT void JNICALL
Java_sun_awt_DebugHelperImpl_printlnImpl(JNIEnv *env, jclass cls, jstring msg) {
const char * cstr;
cstr = JNU_GetStringPlatformChars(env, msg, NULL);
if ( cstr == NULL ) {
return;
}
DTrace_JavaPrintln(cstr);
JNU_ReleaseStringPlatformChars(env, msg, cstr);
}
JNIEXPORT jint JNICALL
Java_java_util_prefs_FileSystemPreferences_chmod(JNIEnv *env,
jclass thisclass, jstring java_fname, jint permission) {
const char *fname = JNU_GetStringPlatformChars(env, java_fname, JNI_FALSE);
int result;
result = chmod(fname, permission);
if (result != 0)
result = errno;
JNU_ReleaseStringPlatformChars(env, java_fname, fname);
return (jint) result;
}
/**
* Try to open a named lock file.
* The result is a cookie that can be used later to unlock the file.
* On failure the result is zero.
*/
JNIEXPORT jintArray JNICALL
Java_java_util_prefs_FileSystemPreferences_lockFile0(JNIEnv *env,
jclass thisclass, jstring java_fname, jint permission, jboolean shared) {
const char *fname = JNU_GetStringPlatformChars(env, java_fname, NULL);
int fd, rc;
int result[2];
jintArray javaResult = NULL;
int old_umask;
FLOCK fl;
if (!fname)
return javaResult;
fl.l_whence = SEEK_SET;
fl.l_len = 0;
fl.l_start = 0;
if (shared == JNI_TRUE) {
fl.l_type = F_RDLCK;
} else {
fl.l_type = F_WRLCK;
}
if (shared == JNI_TRUE) {
fd = open(fname, O_RDONLY, 0);
} else {
old_umask = umask(0);
fd = open(fname, O_WRONLY|O_CREAT, permission);
result[1] = errno;
umask(old_umask);
}
if (fd < 0) {
result[0] = 0;
} else {
#if defined(_ALLBSD_SOURCE)
rc = fcntl(fd, F_SETLK, &fl);
#else
rc = fcntl(fd, F_SETLK64, &fl);
#endif
result[1] = errno;
if (rc < 0) {
result[0]= 0;
close(fd);
} else {
result[0] = fd;
}
}
JNU_ReleaseStringPlatformChars(env, java_fname, fname);
javaResult = (*env)->NewIntArray(env,2);
if (javaResult)
(*env)->SetIntArrayRegion(env, javaResult, 0, 2, result);
return javaResult;
}
/*
* Given the JDK/JRE install directory form the name of the robot child process
* e.g. Directory /foo/kestrel/jre -> Executable /foo/kestrel/jre/bin/awt_robot
*/
JNIEXPORT void JNICALL Java_sun_awt_motif_MRobotPeer_buildChildProcessName(
JNIEnv *env, jclass cls, jstring installDir) {
char * cdir;
cdir = (char *) JNU_GetStringPlatformChars(env, installDir, NULL);
if (cdir == NULL) {
return;
}
sprintf(RobotChildExePath, "%s/%s", cdir, ROBOT_EXE);
DTRACE_PRINTLN1("Robot child process name is : %s", RobotChildExePath);
JNU_ReleaseStringPlatformChars(env, installDir, cdir);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XChangePropertyS
* Signature: (JJJJJJJJJLjava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangePropertyS(
JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property,
jlong type, jint format, jint mode, jstring value)
{
jboolean iscopy;
const char * chars = JNU_GetStringPlatformChars(env, value, &iscopy);
AWT_CHECK_HAVE_LOCK();
XChangeProperty((Display*)display, window, (Atom)property,
(Atom)type, format, mode, (unsigned char*)chars, strlen(chars));
if (iscopy) {
JNU_ReleaseStringPlatformChars(env, value, chars);
}
}
/*
* Class: sun_awt_shell_Win32ShellFolder2
* Method: getIcon
* Signature: (Ljava/lang/String;Z)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_shell_Win32ShellFolder2_getIcon
(JNIEnv* env, jclass cls, jstring absolutePath, jboolean getLargeIcon)
{
HICON hIcon = NULL;
SHFILEINFO fileInfo;
LPCTSTR pathStr = (LPCTSTR)JNU_GetStringPlatformChars(env, absolutePath, NULL);
if (fn_SHGetFileInfo(pathStr, 0L, &fileInfo, sizeof(fileInfo),
SHGFI_ICON | (getLargeIcon ? 0 : SHGFI_SMALLICON)) != 0) {
hIcon = fileInfo.hIcon;
}
JNU_ReleaseStringPlatformChars(env, absolutePath, pathStr);
return (jlong)hIcon;
}
JNIEXPORT void JNICALL
Java_sun_awt_windows_WDesktopProperties_playWindowsSound(JNIEnv *env, jobject self, jstring event) {
TRY;
LPCTSTR winEventName;
winEventName = JNU_GetStringPlatformChars(env, event, NULL);
if ( winEventName == NULL ) {
return;
}
GetCppThis(env, self)->PlayWindowsSound(winEventName);
JNU_ReleaseStringPlatformChars(env, event, winEventName);
CATCH_BAD_ALLOC;
}
/*
* Class: sun_awt_windows_ThemeReader
* Method: setWindowTheme
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_sun_awt_windows_ThemeReader_setWindowTheme
(JNIEnv *env, jclass klass, jstring subAppName) {
LPCTSTR str = NULL;
if (subAppName != NULL) {
str = (LPCTSTR) JNU_GetStringPlatformChars(env, subAppName, NULL);
}
// We need to set the Window theme on the same theme that we opened it with.
HRESULT hres = SetWindowTheme(AwtToolkit::GetInstance().GetHWnd(), str, NULL);
assert_result(hres, env);
if (subAppName != NULL) {
JNU_ReleaseStringPlatformChars(env, subAppName, str);
}
}
/*
* Class: sun_awt_windows_ThemeReader
* Method: openTheme
* Signature: (Ljava/lang/String;)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_windows_ThemeReader_openTheme
(JNIEnv *env, jclass klass, jstring widget) {
LPCTSTR str = (LPCTSTR) JNU_GetStringPlatformChars(env, widget, NULL);
if (str == NULL) {
JNU_ThrowOutOfMemoryError(env, 0);
return 0;
}
// We need to open the Theme on a Window that will stick around.
// The best one for that purpose is the Toolkit window.
HTHEME htheme = OpenThemeData(AwtToolkit::GetInstance().GetHWnd(), str);
JNU_ReleaseStringPlatformChars(env, widget, str);
return (jlong) htheme;
}
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_windows_WDataTransferer
* Method: registerClipboardFormat
* Signature: (Ljava/lang/String;)J
*/
JNIEXPORT jlong JNICALL
Java_sun_awt_windows_WDataTransferer_registerClipboardFormat(JNIEnv *env,
jclass cls,
jstring str)
{
TRY;
LPCTSTR cStr = JNU_GetStringPlatformChars(env, str, NULL);
jlong value = ::RegisterClipboardFormat(cStr);
JNU_ReleaseStringPlatformChars(env, str, cStr);
return value;
CATCH_BAD_ALLOC_RET(0);
}
/*
* Class: sun_awt_shell_Win32ShellFolder2
* Method: getExecutableType
* Signature: (Ljava/lang/String;)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_sun_awt_shell_Win32ShellFolder2_getExecutableType
(JNIEnv* env, jobject folder, jstring path)
{
TCHAR szBuf[MAX_PATH];
LPCTSTR szPath = JNU_GetStringPlatformChars(env, path, NULL);
if (szPath == NULL) {
return NULL;
}
HINSTANCE res = fn_FindExecutable(szPath, szPath, szBuf);
JNU_ReleaseStringPlatformChars(env, path, szPath);
if ((UINT_PTR)res < 32) {
return NULL;
}
return JNU_NewStringPlatform(env, szBuf);
}
/* convert jstring to C string */
static void jstring_to_cstring(JNIEnv* env, jstring jstr, char* cstr, int len) {
jboolean isCopy;
const char* str;
if (jstr == NULL) {
cstr[0] = '\0';
} else {
str = JNU_GetStringPlatformChars(env, jstr, &isCopy);
strncpy(cstr, str, len);
cstr[len-1] = '\0';
if (isCopy) {
JNU_ReleaseStringPlatformChars(env, jstr, str);
}
}
}
/* Implementation of DebugHelperImpl.setCTracingOn*/
JNIEXPORT void JNICALL
Java_sun_awt_DebugHelperImpl_setCTracingOn__ZLjava_lang_String_2(
JNIEnv *env,
jobject self,
jboolean enabled,
jstring file ) {
#if defined(DEBUG)
const char * cfile;
cfile = JNU_GetStringPlatformChars(env, file, NULL);
if ( cfile == NULL ) {
return;
}
DTrace_EnableFile(cfile, enabled == JNI_TRUE);
JNU_ReleaseStringPlatformChars(env, file, cfile);
#endif
}
DWORD
selectProcessFlag(JNIEnv *env, jstring cmd0)
{
DWORD newFlag = 0;
char *exe = (char *)JNU_GetStringPlatformChars(env, cmd0, 0);
if (exe != NULL) {
char buf[MAX_PATH];
char *name;
DWORD len;
exe = extractExecutablePath(env, exe);
if (exe != NULL) {
/* We are here for Win9x/Me, so the [/] is not the path sep */
char *p = strrchr(exe, '\\');
if (p == NULL) {
len = SearchPath(NULL, exe, EXE_EXT, MAX_PATH, buf, &name);
} else {
*p = 0;
len = SearchPath(exe, p + 1, EXE_EXT, MAX_PATH, buf, &name);
}
}
if (len > 0 && len < MAX_PATH) {
/* Here the [buf] path is valid and null terminated */
int fd = _open(buf, _O_RDONLY);
if (fd != -1) {
unsigned char buffer[2];
if (_read(fd, buffer, 2) == 2
&& buffer[0] == 'M' && buffer[1] == 'Z'
&& _lseek(fd, 60L, SEEK_SET) == 60L
&& _read(fd, buffer, 2) == 2)
{
long headerLoc = (long)buffer[1] << 8 | (long)buffer[0];
if (_lseek(fd, headerLoc, SEEK_SET) == headerLoc
&& _read(fd, buffer, 2) == 2
&& buffer[0] == 'P' && buffer[1] == 'E')
{
newFlag = DETACHED_PROCESS;
}
}
_close(fd);
}
}
JNU_ReleaseStringPlatformChars(env, cmd0, exe);
}
return newFlag;
}
