merging in the win32bindings package

This commit is contained in:
Doug MacEachern committed 2004-11-20 21:01:16 +00:00
1 parent 3b0a6af2d2
commit 6353b7bcc3
22 files changed
+3289

No files matched your search

+301
View File
@@ -0,0 +1,301 @@
#ifdef WIN32
#include "javasigar.h"
#include "win32bindings.h"
#define MAX_INSERT_STRS 8
#define MAX_MSG_LENGTH 4096
#define MAX_ERROR_LENGTH 1024
#define REG_MSGFILE_ROOT "SYSTEM\\CurrentControlSet\\Services\\EventLog\\"
static void win32_set_pointer(JNIEnv *env, jobject obj, const void *ptr)
{
jfieldID pointer_field;
int pointer_int;
jclass cls;
cls = JENV->GetObjectClass(env, obj);
pointer_field = JENV->GetFieldID(env, cls, "eventLogHandle", "I");
pointer_int = (int)ptr;
JENV->SetIntField(env, obj, pointer_field, pointer_int);
}
static HANDLE win32_get_pointer(JNIEnv *env, jobject obj)
{
jfieldID pointer_field;
HANDLE h;
jclass cls;
cls = JENV->GetObjectClass(env, obj);
pointer_field = JENV->GetFieldID(env, cls, "eventLogHandle", "I");
h = (HANDLE)JENV->GetIntField(env, obj, pointer_field);
if (!h) {
win32_throw_exception(env, "Event log not opened");
}
return h;
}
static int get_messagefile_dll(char *app, char *source, char *dllfile)
{
HKEY hk;
DWORD type, data;
char buf[MAX_MSG_LENGTH];
sprintf(buf, "%s%s\\%s", REG_MSGFILE_ROOT, app, source);
if (RegOpenKey(HKEY_LOCAL_MACHINE, buf, &hk)) {
return GetLastError();
}
if (RegQueryValueEx(hk, "EventMessageFile", NULL, &type,
(UCHAR *)buf, &data)) {
RegCloseKey(hk);
return GetLastError();
}
strncpy(dllfile, buf, sizeof(dllfile));
RegCloseKey(hk);
return 0;
}
static int get_formatted_message(EVENTLOGRECORD *pevlr, char *dllfile,
char *msg)
{
HINSTANCE hlib;
LPTSTR msgbuf;
char msgdll[MAX_MSG_LENGTH];
char *insert_strs[MAX_INSERT_STRS], *ch;
int i;
if (!ExpandEnvironmentStrings(dllfile, msgdll, MAX_PATH))
return GetLastError();
if (!(hlib = LoadLibraryEx(msgdll, NULL,
LOAD_LIBRARY_AS_DATAFILE)))
return GetLastError();
ch = (char *)((LPBYTE)pevlr + pevlr->StringOffset);
for (i = 0; i < pevlr->NumStrings && i < MAX_INSERT_STRS; i++) {
insert_strs[i] = ch;
ch += strlen(ch) + 1;
}
FormatMessage(FORMAT_MESSAGE_FROM_HMODULE |
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_ARGUMENT_ARRAY,
hlib,
pevlr->EventID,
MAKELANGID(LANG_NEUTRAL, SUBLANG_ENGLISH_US),
(LPTSTR) &msgbuf,
MAX_MSG_LENGTH,
insert_strs);
strncpy(msg, msgbuf, sizeof(msg));
FreeLibrary(hlib);
LocalFree((HLOCAL)msgbuf);
return 0;
}
JNIEXPORT void SIGAR_JNI(win32_EventLog_open)
(JNIEnv *env, jobject obj, jstring lpSourceName)
{
HANDLE h;
const char *name;
name = JENV->GetStringUTFChars(env, lpSourceName, 0);
h = OpenEventLog(NULL, name);
if (h == NULL) {
char buf[MAX_ERROR_LENGTH];
DWORD lastError = GetLastError();
sprintf(buf, "Unable to open event log: %d", lastError);
JENV->ReleaseStringUTFChars(env, lpSourceName, name);
win32_throw_exception(env, buf);
return;
}
JENV->ReleaseStringUTFChars(env, lpSourceName, name);
/* Save the handle for later use */
win32_set_pointer(env, obj, h);
}
JNIEXPORT void SIGAR_JNI(win32_EventLog_close)
(JNIEnv *env, jobject obj)
{
HANDLE h = win32_get_pointer(env, obj);
CloseEventLog(h);
win32_set_pointer(env, obj, NULL);
}
JNIEXPORT jint SIGAR_JNI(win32_EventLog_getNumberOfRecords)
(JNIEnv *env, jobject obj)
{
DWORD records;
HANDLE h = win32_get_pointer(env, obj);
GetNumberOfEventLogRecords(h, &records);
return records;
}
JNIEXPORT jint SIGAR_JNI(win32_EventLog_getOldestRecord)
(JNIEnv *env, jobject obj)
{
DWORD oldest;
HANDLE h = win32_get_pointer(env, obj);
GetOldestEventLogRecord(h, &oldest);
return oldest;
}
JNIEXPORT jobject SIGAR_JNI(win32_EventLog_read)
(JNIEnv *env, jobject obj, jint recordOffset)
{
EVENTLOGRECORD *pevlr;
BYTE buffer[8192];
char dllfile[1024];
DWORD dwRead, dwNeeded;
LPSTR source, machineName;
HANDLE h;
BOOL rv;
jclass cls = WIN32_FIND_CLASS("EventLogRecord");
jobject eventObj; /* Actual instance of the EventLogRecord */
jfieldID id;
h = win32_get_pointer(env, obj);
pevlr = (EVENTLOGRECORD *)&buffer;
rv = ReadEventLog(h,
EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ,
recordOffset,
pevlr,
sizeof(buffer),
&dwRead,
&dwNeeded);
if (!rv) {
char buf[MAX_ERROR_LENGTH];
DWORD lastError = GetLastError();
sprintf(buf, "Error reading from the event log: %d", lastError);
win32_throw_exception(env, buf);
return NULL;
}
eventObj = JENV->AllocObject(env, cls);
id = JENV->GetFieldID(env, cls, "recordNumber", "J");
JENV->SetLongField(env, eventObj, id, pevlr->RecordNumber);
id = JENV->GetFieldID(env, cls, "timeGenerated", "J");
JENV->SetLongField(env, eventObj, id, pevlr->TimeGenerated);
id = JENV->GetFieldID(env, cls, "timeWritten", "J");
JENV->SetLongField(env, eventObj, id, pevlr->TimeWritten);
id = JENV->GetFieldID(env, cls, "eventId", "J");
JENV->SetLongField(env, eventObj, id, pevlr->EventID);
id = JENV->GetFieldID(env, cls, "eventType", "S");
JENV->SetShortField(env, eventObj, id, pevlr->EventType);
/* Extract string data from the end of the structure. Lame. */
id = JENV->GetFieldID(env, cls, "source", "Ljava/lang/String;");
source = (LPSTR)((LPBYTE)pevlr + sizeof(EVENTLOGRECORD));
SetStringField(env, eventObj, id, source);
/* Get the formatted message */
if (!get_messagefile_dll("Application", source, dllfile)) {
char msg[MAX_MSG_LENGTH];
if (!get_formatted_message(pevlr, dllfile, msg)) {
id = JENV->GetFieldID(env, cls, "stringData",
"Ljava/lang/String;");
SetStringField(env, eventObj, id, msg);
}
} else if (pevlr->StringOffset > 0) {
/* Work around some applications not using a message file */
char *tmp = (LPSTR)((LPBYTE)pevlr + pevlr->StringOffset);
id = JENV->GetFieldID(env, cls, "stringData", "Ljava/lang/String;");
SetStringField(env, eventObj, id, tmp);
}
/* Increment up to the machine name. */
id = JENV->GetFieldID(env, cls, "computerName", "Ljava/lang/String;");
machineName = (LPSTR)((LPBYTE)pevlr + sizeof(EVENTLOGRECORD) +
strlen(source) + 1);
SetStringField(env, eventObj, id, machineName);
/* Get user id info */
if (pevlr->UserSidLength > 0) {
char name[256];
char domain[256];
DWORD namelen = sizeof(name);
DWORD domainlen = sizeof(domain);
DWORD len;
SID_NAME_USE snu;
PSID sid;
sid = (PSID)((LPBYTE)pevlr + pevlr->UserSidOffset);
if (LookupAccountSid(NULL, sid, name, &namelen, domain,
&domainlen, &snu)) {
id = JENV->GetFieldID(env, cls, "user", "Ljava/lang/String;");
SetStringField(env, eventObj, id, name);
}
}
return eventObj;
}
JNIEXPORT void SIGAR_JNI(win32_EventLog_waitForChange)
(JNIEnv *env, jobject obj, jint timeout)
{
HANDLE h, hEvent;
DWORD millis;
h = win32_get_pointer(env, obj);
hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (hEvent == NULL) {
win32_throw_exception(env, "Unable to create event");
return;
}
if (timeout == -1)
millis = INFINITE;
else
millis = timeout;
if(!(NotifyChangeEventLog(h, hEvent))) {
char buf[MAX_ERROR_LENGTH];
sprintf(buf, "Error registering for event log to change: %d",
GetLastError());
win32_throw_exception(env, buf);
return;
}
if (WaitForSingleObject(hEvent, millis) == WAIT_FAILED)
{
char buf[MAX_ERROR_LENGTH];
sprintf(buf, "Error waiting for event log change: %d",
GetLastError());
win32_throw_exception(env, buf);
}
return;
}
#endif /* WIN32 */
+282
View File
@@ -0,0 +1,282 @@
#ifdef WIN32
#define UNICODE
#define _UNICODE
#define _WIN32_DCOM
#define INITGUID
#include <objbase.h> // COM Interface header file.
#include <iadmw.h> // COM Interface header file.
#include <iiscnfg.h> // MD_ & IIS_MD_ #defines header file.
#include <ks.h>
#include <atlBase.h> // ATL support header file.
#include "win32bindings.h"
#include "javasigar.h"
#ifdef __cplusplus
extern "C" {
#endif
static jfieldID ptr_field = 0;
static jfieldID IMeta_field = 0;
JNIEXPORT void SIGAR_JNI(win32_MetaBase_MetaBaseClose)
(JNIEnv *env, jobject cur)
{
CComPtr <IMSAdminBase> *pIMeta;
pIMeta = (CComPtr <IMSAdminBase> *)env->GetLongField(cur, IMeta_field);
METADATA_HANDLE MyHandle;
MyHandle = (METADATA_HANDLE)env->GetIntField(cur, ptr_field);
(*pIMeta)->CloseKey(MyHandle);
}
JNIEXPORT void SIGAR_JNI(win32_MetaBase_MetaBaseRelease)
(JNIEnv *env, jobject cur)
{
CComPtr <IMSAdminBase> *pIMeta;
pIMeta = (CComPtr <IMSAdminBase> *)env->GetLongField(cur, IMeta_field);
pIMeta->Release();
delete pIMeta;
env->SetIntField(cur, ptr_field, 0);
CoUninitialize();
}
JNIEXPORT jstring SIGAR_JNI(win32_MetaBase_MetaBaseEnumKey)
(JNIEnv *env, jobject cur, jint index)
{
HRESULT hRes = 0;
METADATA_HANDLE MyHandle;
DWORD dwBufLen = 8096;
DWORD dwReqBufLen = 0;
TCHAR pbBuffer[METADATA_MAX_NAME_LEN];
CComPtr <IMSAdminBase> *pIMeta;
pIMeta = (CComPtr <IMSAdminBase> *)env->GetLongField(cur, IMeta_field);
MyHandle = (METADATA_HANDLE)env->GetIntField(cur, ptr_field);
hRes = (*pIMeta)->EnumKeys(MyHandle, TEXT(""), pbBuffer, index);
if (SUCCEEDED(hRes)) {
jstring strResult;
// Store the data identifiers in an array for future use.
// Note: declare a suitable DWORD array for names and add
// array bounds checking.
strResult = env->NewString((const jchar *)pbBuffer, lstrlen(pbBuffer));
return strResult;
} else if (hRes == HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS)) {
return NULL;
}
jclass cls = env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, "MetaBaseEnumKey");
return NULL;
}
JNIEXPORT jlong SIGAR_JNI(win32_MetaBase_MetaBaseInit)
(JNIEnv *env, jobject cur)
{
CComPtr <IMSAdminBase> *pIMeta;
HRESULT hRes = 0;
hRes = CoInitializeEx(NULL, COINIT_MULTITHREADED);
if (FAILED(hRes)) {
jclass cls = env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, "MetaBaseInit");
return 0;
}
pIMeta = new (CComPtr <IMSAdminBase>);
hRes = CoCreateInstance(CLSID_MSAdminBase, NULL, CLSCTX_ALL,
IID_IMSAdminBase, (void **)pIMeta);
if (FAILED(hRes)) {
jclass cls = env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, "MetaBaseInit: Can't CoCreateInstance");
return 0;
}
jclass cls = env->GetObjectClass(cur);
ptr_field = env->GetFieldID(cls, "m_handle", "I");
IMeta_field = env->GetFieldID(cls, "pIMeta", "J");
return (jlong)pIMeta;
}
static void MetaBaseOpenSubKey(JNIEnv *env, jobject cur,
jstring path, METADATA_HANDLE MyHandle)
{
HRESULT hRes = 0;
CComPtr <IMSAdminBase> *pIMeta;
pIMeta = (CComPtr <IMSAdminBase> *)env->GetLongField(cur, IMeta_field);
// Get a handle to the Web service.
LPCTSTR lpSubkey = (LPCTSTR)env->GetStringChars(path, NULL);
hRes = (*pIMeta)->OpenKey(MyHandle, lpSubkey,
METADATA_PERMISSION_READ, 20, &MyHandle);
env->ReleaseStringChars(path, (const jchar *)lpSubkey);
if (FAILED(hRes)) {
jclass cls = env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, "Can't open Sub Key");
return;
}
env->SetIntField(cur, ptr_field, MyHandle);
}
JNIEXPORT void SIGAR_JNI(win32_MetaBase_MetaBaseOpenSubKey)
(JNIEnv *env, jobject cur, jstring path)
{
METADATA_HANDLE MyHandle;
MyHandle = (METADATA_HANDLE)env->GetIntField(cur, ptr_field);
MetaBaseOpenSubKey(env, cur, path, MyHandle);
}
JNIEXPORT void SIGAR_JNI(win32_MetaBase_MetaBaseOpenSubKeyAbs)
(JNIEnv *env, jobject cur, jstring path)
{
MetaBaseOpenSubKey(env, cur, path, METADATA_MASTER_ROOT_HANDLE);
}
JNIEXPORT jint SIGAR_JNI(win32_MetaBase_MetaBaseGetIntValue)
(JNIEnv *env, jobject cur, jint key)
{
HRESULT hRes = 0;
METADATA_HANDLE MyHandle;
METADATA_RECORD MyRecord;
DWORD dwBufLen = 8096;
DWORD dwReqBufLen = 0;
TCHAR pbBuffer[8096];
CComPtr <IMSAdminBase> *pIMeta;
pIMeta = (CComPtr <IMSAdminBase> *)env->GetLongField(cur, IMeta_field);
MyHandle = (METADATA_HANDLE)env->GetIntField(cur, ptr_field);
// Initialize the input structure -
// the values specify what kind of data to enumerate.
MyRecord.dwMDIdentifier = key;
MyRecord.dwMDAttributes = 0;
MyRecord.dwMDUserType = IIS_MD_UT_SERVER;
MyRecord.dwMDDataType = DWORD_METADATA;
MyRecord.dwMDDataLen = dwBufLen;
MyRecord.pbMDData = (unsigned char *)pbBuffer;
// Enumerate the data of the first virtual Web server,
// checking to ensure that the data returned does not
// overflow the buffer.
hRes = (*pIMeta)->GetData(MyHandle, TEXT(""), &MyRecord, &dwReqBufLen);
if (SUCCEEDED(hRes)) {
int ret = (int)MyRecord.pbMDData;
return ret;
}
jclass cls = env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, "No such Int value");
return 0;
}
JNIEXPORT jstring SIGAR_JNI(win32_MetaBase_MetaBaseGetStringValue)
(JNIEnv *env, jobject cur, jint key)
{
HRESULT hRes = 0;
METADATA_HANDLE MyHandle;
METADATA_RECORD MyRecord;
DWORD dwBufLen = 8096;
DWORD dwReqBufLen = 0;
TCHAR pbBuffer[8096];
CComPtr <IMSAdminBase> *pIMeta;
pIMeta = (CComPtr <IMSAdminBase> *)env->GetLongField(cur, IMeta_field);
MyHandle = (METADATA_HANDLE)env->GetIntField(cur, ptr_field);
// Initialize the input structure -
// the values specify what kind of data to enumerate.
MyRecord.dwMDIdentifier = key;
MyRecord.dwMDAttributes = 0;
MyRecord.dwMDUserType = IIS_MD_UT_SERVER;
MyRecord.dwMDDataType = STRING_METADATA;
MyRecord.dwMDDataLen = dwBufLen;
MyRecord.pbMDData = (unsigned char *)pbBuffer;
hRes = (*pIMeta)->GetData(MyHandle, TEXT(""), &MyRecord, &dwReqBufLen);
if (SUCCEEDED(hRes)) {
jstring strResult;
// Store the data identifiers in an array for future use.
// Note: declare a suitable DWORD array for names and add
// array bounds checking.
strResult = env->NewString((const jchar *)MyRecord.pbMDData,
lstrlen(pbBuffer));
return strResult;
}
jclass cls = env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, "No Such string value");
return NULL;
}
JNIEXPORT jobjectArray SIGAR_JNI(win32_MetaBase_MetaBaseGetMultiStringValue)
(JNIEnv *env, jobject cur, jint key)
{
HRESULT hRes = 0;
METADATA_HANDLE MyHandle;
METADATA_RECORD MyRecord;
DWORD dwBufLen = 8096;
DWORD dwReqBufLen = 0;
TCHAR pbBuffer[8096];
CComPtr <IMSAdminBase> *pIMeta;
pIMeta = (CComPtr <IMSAdminBase> *)env->GetLongField(cur, IMeta_field);
MyHandle = (METADATA_HANDLE)env->GetIntField(cur, ptr_field);
// Initialize the input structure -
// the values specify what kind of data to enumerate.
MyRecord.dwMDIdentifier = key;
MyRecord.dwMDAttributes = 0;
MyRecord.dwMDUserType = IIS_MD_UT_SERVER;
MyRecord.dwMDDataType = MULTISZ_METADATA;
MyRecord.dwMDDataLen = dwBufLen;
MyRecord.pbMDData = (unsigned char *)pbBuffer;
hRes = (*pIMeta)->GetData(MyHandle, TEXT(""), &MyRecord, &dwReqBufLen);
if (SUCCEEDED(hRes)) {
TCHAR *szThisInstance = NULL;
jobjectArray ret = NULL;
int i;
// Start at -1 to account for the \0 at the end of the
// list.
int count = -1;
// Count # of objects in dwInstanceList
for (i = 0; i < MyRecord.dwMDDataLen; i+=2) {
if ((TCHAR)MyRecord.pbMDData[i] == '\0') {
count++;
}
}
ret = (jobjectArray)env->
NewObjectArray(count,
env->FindClass("java/lang/String"),
env->NewString((const jchar *)"", 1));
// Walk the return instance list, creating an array
for (szThisInstance = (TCHAR *)MyRecord.pbMDData, i = 0;
*szThisInstance != 0;
szThisInstance += lstrlen(szThisInstance) + 1, i++)
{
env->SetObjectArrayElement(ret,i,env->NewString(
(const jchar *)(LPCTSTR)szThisInstance,
lstrlen(szThisInstance)));
}
return ret;
}
jclass cls = env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, "No Such string value");
return NULL;
}
#ifdef __cplusplus
}
#endif
#endif /* WIN32 */
+338
View File
@@ -0,0 +1,338 @@
#ifdef WIN32
#include <pdh.h>
#include <pdhmsg.h>
#include "win32bindings.h"
#include "javasigar.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* Hack around not being able to format error codes using
* FORMAT_MESSAGE_FROM_HMODULE. We only define the error
* codes that could be possibly returned.
*/
static char *get_error_message(PDH_STATUS status) {
switch (status) {
case PDH_CSTATUS_NO_MACHINE:
return "The computer is unavailable";
case PDH_CSTATUS_NO_OBJECT:
return "The specified object could not be found on the computer";
case PDH_INVALID_ARGUMENT:
return "A required argument is invalid";
case PDH_MEMORY_ALLOCATION_FAILURE:
return "A required temporary buffer could not be allocated";
case PDH_INVALID_HANDLE:
return "The query handle is not valid";
case PDH_NO_DATA:
return "The query does not currently have any counters";
case PDH_CSTATUS_BAD_COUNTERNAME:
return "The counter name path string could not be parsed or "
"interpreted";
case PDH_CSTATUS_NO_COUNTER:
return "The specified counter was not found";
case PDH_CSTATUS_NO_COUNTERNAME:
return "An empty counter name path string was passed in";
case PDH_FUNCTION_NOT_FOUND:
return "The calculation function for this counter could not "
"be determined";
default:
return "Unknown error";
}
}
JNIEXPORT jlong JNICALL SIGAR_JNI(win32_Pdh_pdhOpenQuery)
(JNIEnv *env, jobject cur)
{
HQUERY h_query;
PDH_STATUS status;
status = PdhOpenQuery(NULL, 0, &h_query);
if (status != ERROR_SUCCESS) {
win32_throw_exception(env, get_error_message(status));
return 0;
}
return (jlong)h_query;
}
JNIEXPORT void SIGAR_JNI(win32_Pdh_pdhCloseQuery)
(JNIEnv *env, jclass cur, jlong query)
{
HQUERY h_query = (HQUERY)query;
PDH_STATUS status;
// Close the query and the log file.
status = PdhCloseQuery(h_query);
if (status != ERROR_SUCCESS) {
win32_throw_exception(env, get_error_message(status));
return;
}
}
JNIEXPORT jlong SIGAR_JNI(win32_Pdh_pdhAddCounter)
(JNIEnv *env, jclass cur, jlong query, jstring cp)
{
HCOUNTER h_counter;
HQUERY h_query = (HQUERY)query;
PDH_STATUS status;
LPCTSTR counter_path = JENV->GetStringUTFChars(env, cp, NULL);
/* Add the counter that created the data in the log file. */
status = PdhAddCounter(h_query, counter_path, 0, &h_counter);
JENV->ReleaseStringUTFChars(env, cp, counter_path);
if (status != ERROR_SUCCESS) {
win32_throw_exception(env, get_error_message(status));
return 0;
}
return (jlong)h_counter;
}
JNIEXPORT void SIGAR_JNI(win32_Pdh_pdhRemoveCounter)
(JNIEnv *env, jclass cur, jlong counter)
{
HCOUNTER h_counter = (HCOUNTER)counter;
PDH_STATUS status;
status = PdhRemoveCounter(h_counter);
if (status != ERROR_SUCCESS) {
win32_throw_exception(env, get_error_message(status));
return;
}
}
JNIEXPORT jdouble SIGAR_JNI(win32_Pdh_pdhGetSingleValue)
(JNIEnv *env, jclass cur, jlong query, jlong counter)
{
HCOUNTER h_counter = (HCOUNTER)counter;
HQUERY h_query = (HQUERY)query;
PDH_FMT_COUNTERVALUE pdh_value;
PDH_STATUS status;
status = PdhCollectQueryData(h_query);
if (status != ERROR_SUCCESS) {
win32_throw_exception(env, get_error_message(status));
return 0;
}
// Format the performance data record.
status = PdhGetFormattedCounterValue(h_counter,
PDH_FMT_DOUBLE,
(LPDWORD)NULL,
&pdh_value);
if (status != ERROR_SUCCESS) {
win32_throw_exception(env, get_error_message(status));
return 0;
}
return pdh_value.doubleValue;
}
JNIEXPORT jobjectArray SIGAR_JNI(win32_Pdh_pdhGetInstances)
(JNIEnv *env, jclass cur, jstring cp)
{
PDH_STATUS status = ERROR_SUCCESS;
DWORD counter_list_size = 0;
DWORD instance_list_size = 8096;
LPTSTR instance_list_buf =
(LPTSTR)malloc ((instance_list_size * sizeof (TCHAR)));
LPTSTR cur_object = NULL;
LPCTSTR counter_path =
(LPCTSTR)JENV->GetStringUTFChars(env, cp, 0);
jobjectArray array = NULL;
status = PdhEnumObjectItems(NULL, NULL, counter_path, NULL,
&counter_list_size, instance_list_buf,
&instance_list_size, PERF_DETAIL_WIZARD,
FALSE);
if (status == PDH_MORE_DATA && instance_list_size > 0) {
// Allocate the buffers and try the call again.
if (instance_list_buf != NULL)
free(instance_list_buf);
instance_list_buf = (LPTSTR)malloc((instance_list_size *
sizeof (TCHAR)));
counter_list_size = 0;
status = PdhEnumObjectItems (NULL, NULL, counter_path,
NULL, &counter_list_size,
instance_list_buf,
&instance_list_size,
PERF_DETAIL_WIZARD, FALSE);
}
JENV->ReleaseStringUTFChars(env, cp, counter_path);
// Still may get PDH_ERROR_MORE data after the first reallocation,
// but that is OK for just browsing the instances
if (status == ERROR_SUCCESS || status == PDH_MORE_DATA) {
int i, count;
for (cur_object = instance_list_buf, count = 0;
*cur_object != 0;
cur_object += lstrlen(cur_object) + 1, count++);
array = JENV->NewObjectArray(env, count,
JENV->FindClass(env,
"java/lang/String"),
JENV->NewStringUTF(env, ""));
/* Walk the return instance list, creating an array */
for (cur_object = instance_list_buf, i = 0;
*cur_object != 0;
cur_object += lstrlen(cur_object) + 1, i++)
{
jstring s = JENV->NewStringUTF(env, cur_object);
JENV->SetObjectArrayElement(env, array, i, s);
}
} else {
if (instance_list_buf != NULL)
free(instance_list_buf);
// An error occured
win32_throw_exception(env, get_error_message(status));
return NULL;
}
if (instance_list_buf != NULL)
free(instance_list_buf);
return array;
}
JNIEXPORT jobjectArray SIGAR_JNI(win32_Pdh_pdhGetKeys)
(JNIEnv *env, jclass cur, jstring cp)
{
PDH_STATUS status = ERROR_SUCCESS;
DWORD counter_list_size = 8096;
DWORD instance_list_size = 0;
LPTSTR instance_list_buf =
(LPTSTR)malloc (counter_list_size * sizeof(TCHAR));
LPTSTR cur_object = NULL;
LPCTSTR counter_path = JENV->GetStringUTFChars(env, cp, 0);
jobjectArray array = NULL;
status = PdhEnumObjectItems(NULL, NULL, counter_path,
instance_list_buf, &counter_list_size,
NULL, &instance_list_size,
PERF_DETAIL_WIZARD, FALSE);
if (status == PDH_MORE_DATA) {
/* Allocate the buffers and try the call again. */
if (instance_list_buf != NULL)
free(instance_list_buf);
instance_list_buf = (LPTSTR)malloc(counter_list_size *
sizeof(TCHAR));
instance_list_size = 0;
status = PdhEnumObjectItems (NULL, NULL, counter_path,
instance_list_buf,
&counter_list_size, NULL,
&instance_list_size,
PERF_DETAIL_WIZARD, 0);
}
JENV->ReleaseStringUTFChars(env, cp, counter_path);
if (status == ERROR_SUCCESS || status == PDH_MORE_DATA) {
int i, count;
for (cur_object = instance_list_buf, count = 0;
*cur_object != 0;
cur_object += lstrlen(cur_object) + 1, count++);
array = JENV->NewObjectArray(env, count,
JENV->FindClass(env,
"java/lang/String"),
JENV->NewStringUTF(env, ""));
/* Walk the return instance list, creating an array */
for (cur_object = instance_list_buf, i = 0;
*cur_object != 0;
cur_object += lstrlen(cur_object) + 1, i++)
{
jstring s = JENV->NewStringUTF(env, cur_object);
JENV->SetObjectArrayElement(env, array, i, s);
}
} else {
// An error occured
if (instance_list_buf != NULL)
free(instance_list_buf);
// An error occured
win32_throw_exception(env, get_error_message(status));
return NULL;
}
if (instance_list_buf != NULL)
free(instance_list_buf);
return array;
}
JNIEXPORT jobjectArray SIGAR_JNI(win32_Pdh_pdhGetObjects)
(JNIEnv *env, jclass cur)
{
PDH_STATUS status;
DWORD list_size = 8096;
LPTSTR list_buf = (LPTSTR)malloc(list_size * sizeof(TCHAR));
LPTSTR cur_object;
DWORD i, num_objects = 0;
jobjectArray array = NULL;
status = PdhEnumObjects(NULL, NULL, list_buf, &list_size,
PERF_DETAIL_WIZARD, FALSE);
if (status == PDH_MORE_DATA) {
// Re-try call with a larger buffer
if (list_buf != NULL)
free(list_buf);
list_buf = (LPTSTR)malloc(list_size * sizeof(TCHAR));
status = PdhEnumObjects(NULL, NULL, list_buf, &list_size,
PERF_DETAIL_WIZARD, FALSE);
}
if (status != ERROR_SUCCESS) {
if (list_buf != NULL)
free(list_buf);
win32_throw_exception(env, get_error_message(status));
return NULL;
}
// Walk the return buffer counting the number of objects
for (cur_object = list_buf, num_objects = 0;
*cur_object != 0;
cur_object += lstrlen(cur_object) + 1, num_objects++);
array = JENV->NewObjectArray(env, num_objects,
JENV->FindClass(env,
"java/lang/String"),
JENV->NewStringUTF(env, ""));
for (cur_object = list_buf, i = 0;
*cur_object != 0;
cur_object += lstrlen(cur_object) + 1, i++)
{
jstring s = JENV->NewStringUTF(env, cur_object);
JENV->SetObjectArrayElement(env, array, i, s);
}
if (list_buf != NULL)
free(list_buf);
return array;
}
#ifdef __cplusplus
}
#endif
#endif /* WIN32 */
+274
View File
@@ -0,0 +1,274 @@
#ifdef WIN32
#define UNICODE
#define _UNICODE
#include <stdlib.h>
#include "win32bindings.h"
#include "javasigar.h"
#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT jint JNICALL SIGAR_JNI(win32_RegistryKey_RegCloseKey)
(JNIEnv *, jclass, jlong hkey)
{
return RegCloseKey((HKEY)hkey);
}
JNIEXPORT jlong JNICALL SIGAR_JNI(win32_RegistryKey_RegCreateKey)
(JNIEnv *env, jclass, jlong hkey, jstring subkey)
{
HKEY hkeyResult = NULL;
LPCTSTR lpSubkey = (LPCTSTR)env->GetStringChars(subkey, NULL);
RegCreateKeyEx((HKEY)hkey, lpSubkey, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
NULL, &hkeyResult, NULL);
env->ReleaseStringChars(subkey, (const jchar *)lpSubkey);
return (jlong)hkeyResult;
}
JNIEXPORT jint SIGAR_JNI(win32_RegistryKey_RegDeleteKey)
(JNIEnv *env, jclass, jlong hkey, jstring subkey)
{
LPCTSTR lpSubkey = (LPCTSTR)env->GetStringChars(subkey, NULL);
LONG lResult = RegDeleteKey((HKEY)hkey, lpSubkey);
env->ReleaseStringChars(subkey, (const jchar *)lpSubkey);
return lResult;
}
JNIEXPORT jint SIGAR_JNI(win32_RegistryKey_RegDeleteValue)
(JNIEnv *env, jclass, jlong hkey, jstring valueName)
{
LPCTSTR lpValueName = (LPCTSTR)env->GetStringChars(valueName, NULL);
LONG lResult = RegDeleteValue((HKEY)hkey, lpValueName);
env->ReleaseStringChars(valueName, (const jchar *)lpValueName);
return lResult;
}
JNIEXPORT jstring SIGAR_JNI(win32_RegistryKey_RegEnumKey)
(JNIEnv *env, jclass, jlong hkey, jint index)
{
jstring strResult;
TCHAR szBuffer[MAX_PATH + 1];
if(RegEnumKey((HKEY)hkey, index, szBuffer,
sizeof(szBuffer)) == ERROR_SUCCESS)
strResult = env->NewString((const jchar *)szBuffer,
lstrlen(szBuffer));
else
strResult = NULL;
return strResult;
}
JNIEXPORT jstring SIGAR_JNI(win32_RegistryKey_RegEnumValueName)
(JNIEnv *env, jclass, jlong hkey, jint index)
{
jstring strResult;
TCHAR szValueName[MAX_PATH + 1];
DWORD cbValueName = sizeof(szValueName);
if(RegEnumValue((HKEY)hkey, index, szValueName,
&cbValueName, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
strResult = env->NewString((const jchar *)szValueName,
lstrlen(szValueName));
else
strResult = NULL;
return strResult;
}
JNIEXPORT jint SIGAR_JNI(win32_RegistryKey_RegFlushKey)
(JNIEnv *env, jclass, long hkey)
{
return RegFlushKey((HKEY)hkey);
}
JNIEXPORT jint SIGAR_JNI(win32_RegistryKey_RegLoadKey)
(JNIEnv *env, jclass, jlong hkey, jstring subkey, jstring file)
{
LPCTSTR lpSubkey = (LPCTSTR)env->GetStringChars(subkey, NULL);
LPCTSTR lpFile = (LPCTSTR)env->GetStringChars(file, NULL);
LONG lResult = RegLoadKey((HKEY)hkey, lpSubkey, lpFile);
env->ReleaseStringChars(subkey, (const jchar *)lpSubkey);
env->ReleaseStringChars(file, (const jchar *)lpFile);
return lResult;
}
JNIEXPORT jlong SIGAR_JNI(win32_RegistryKey_RegOpenKey)
(JNIEnv *env, jclass, jlong hkey, jstring subkey)
{
HKEY hkeyResult = NULL;
LPCTSTR lpSubkey = (LPCTSTR)env->GetStringChars(subkey, NULL);
RegOpenKey((HKEY)hkey, lpSubkey, &hkeyResult);
env->ReleaseStringChars(subkey, (const jchar *)lpSubkey);
return (jlong)hkeyResult;
}
JNIEXPORT jint SIGAR_JNI(win32_RegistryKey_RegQueryIntValue)
(JNIEnv *env, jclass, jlong hkey, jstring valueName)
{
DWORD dwResult;
DWORD dwType;
LPBYTE lpValue;
DWORD cbValue;
LPCTSTR lpValueName = (LPCTSTR)env->GetStringChars(valueName, NULL);
LONG lErr = RegQueryValueEx((HKEY)hkey, lpValueName,
NULL, (LPDWORD)&dwType,
NULL, &cbValue);
if(lErr == ERROR_SUCCESS) {
lpValue = (LPBYTE)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, cbValue);
if(RegQueryValueEx((HKEY)hkey, lpValueName, NULL,
NULL, lpValue, &cbValue) == ERROR_SUCCESS)
{
switch(dwType) {
case REG_DWORD:
dwResult = *(LPDWORD)lpValue;
break;
case REG_SZ:
dwResult = _ttol((LPCTSTR)lpValue);
break;
default:
lErr = ERROR_SUCCESS - 1; // Make an error
}
}
HeapFree(GetProcessHeap(), 0, lpValue);
}
else
// Make an error out of not seeing a REG_DWORD
lErr = ERROR_SUCCESS - 1;
env->ReleaseStringChars(valueName, (const jchar *)lpValueName);
if(lErr != ERROR_SUCCESS)
{
jclass cls =
env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, NULL);
}
return dwResult;
}
JNIEXPORT jstring SIGAR_JNI(win32_RegistryKey_RegQueryStringValue)
(JNIEnv *env, jclass, jlong hkey, jstring name)
{
jstring strResult;
DWORD dwType;
LPBYTE lpValue;
DWORD cbValue;
LPCTSTR lpValueName = (LPCTSTR)env->GetStringChars(name, NULL);
LONG lErr = RegQueryValueEx((HKEY)hkey,
lpValueName, NULL,
(LPDWORD)&dwType, NULL, &cbValue);
if(lErr == ERROR_SUCCESS)
{
lpValue = (LPBYTE)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, cbValue);
if(RegQueryValueEx((HKEY)hkey, lpValueName, NULL, NULL,
lpValue, &cbValue) == ERROR_SUCCESS)
{
switch(dwType) {
case REG_DWORD:
TCHAR szBuf[20];
_ltot(*(LPDWORD)lpValue, szBuf, 10);
strResult = env->NewString((const jchar *)szBuf,
lstrlen(szBuf));
break;
case REG_SZ:
case REG_EXPAND_SZ: {
DWORD len;
LPTSTR dest = NULL;
len = ExpandEnvironmentStrings((LPCTSTR)lpValue, dest, 0);
dest = (LPTSTR)malloc(len * sizeof(TCHAR));
ExpandEnvironmentStrings((LPCTSTR)lpValue, dest, len);
strResult = env->NewString((const jchar *)dest, len);
free(dest);
break;
}
default:
lErr = ERROR_SUCCESS - 1; // Make an error
}
}
HeapFree(GetProcessHeap(), 0, lpValue);
}
env->ReleaseStringChars(name, (const jchar *)lpValueName);
if(lErr == ERROR_SUCCESS)
return strResult;
else
{
jclass cls = env->FindClass(WIN32_PACKAGE "Win32Exception");
env->ThrowNew(cls, "");
return NULL;
}
}
JNIEXPORT jint SIGAR_JNI(win32_RegistryKey_RegSetIntValue)
(JNIEnv * env, jclass, jlong hkey, jstring valueName, jint value)
{
LPCTSTR lpValueName;
if(valueName != NULL)
lpValueName = (LPCTSTR)env->GetStringChars(valueName, NULL);
else
lpValueName = NULL;
int iResult = RegSetValueEx((HKEY)hkey, lpValueName, 0,
REG_DWORD, (LPBYTE)&value, sizeof(value));
if(valueName != NULL)
env->ReleaseStringChars(valueName, (const jchar *)lpValueName);
return iResult;
}
JNIEXPORT jint SIGAR_JNI(win32_RegistryKey_RegSetStringValue)
(JNIEnv *env, jclass, jlong hkey, jstring name, jstring value)
{
LPCTSTR lpValueName;
if(name != NULL)
lpValueName = (LPCTSTR)env->GetStringChars(name, NULL);
else
lpValueName = NULL;
LPCTSTR lpValue = (LPCTSTR)env->GetStringChars(value, NULL);
int iResult = RegSetValueEx((HKEY)hkey, lpValueName, 0,
REG_SZ, (LPBYTE)lpValue,
(lstrlen(lpValue) + 1) * sizeof(TCHAR));
if(name != NULL)
env->ReleaseStringChars(name, (const jchar *)lpValueName);
env->ReleaseStringChars(value, (const jchar *)lpValue);
return iResult;
}
#ifdef __cplusplus
}
#endif
#endif /* WIN32 */
+361
View File
@@ -0,0 +1,361 @@
#ifdef WIN32
#define UNICODE
#define _UNICODE
#include "win32bindings.h"
#include "javasigar.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* This code is stolen from misc/win32/misc.c and apr_private.h
* This helper code resolves late bound entry points
* missing from one or more releases of the Win32 API...
* This is covered under the Apache Software License
*
* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
* Portions of this software are based upon public domain software
* originally written at the National Center for Supercomputing Applications,
* University of Illinois, Urbana-Champaign.
*/
typedef enum {
DLL_WINBASEAPI = 0, // kernel32 From WinBase.h
DLL_WINADVAPI = 1, // advapi32 From WinBase.h
DLL_WINSOCKAPI = 2, // mswsock From WinSock.h
DLL_WINSOCK2API = 3, // ws2_32 From WinSock2.h
DLL_SHSTDAPI = 4, // shell32 From ShellAPI.h
DLL_NTDLL = 5, // shell32 From our real kernel
DLL_defined = 6 // must define as last idx_ + 1
} dlltoken_e;
FARPROC load_dll_func(dlltoken_e fnLib, TCHAR* fnName, int ordinal);
#define DECLARE_LATE_DLL_FUNC(lib, rettype, calltype, fn, ord, args, names) \
typedef rettype (calltype *winapi_fpt_##fn) args; \
static winapi_fpt_##fn winapi_pfn_##fn = NULL; \
__inline rettype winapi_##fn args \
{ if (!winapi_pfn_##fn) \
winapi_pfn_##fn = (winapi_fpt_##fn) load_dll_func(lib, (wchar_t *)#fn, ord); \
return (*(winapi_pfn_##fn)) names; }; \
/* Win2K kernel only */
DECLARE_LATE_DLL_FUNC(DLL_WINADVAPI, BOOL, WINAPI,
ChangeServiceConfig2W, 0,
(SC_HANDLE hService,
DWORD dwInfoLevel,
LPVOID lpInfo),
(hService, dwInfoLevel, lpInfo));
#undef ChangeServiceConfig2
#define ChangeServiceConfig2 winapi_ChangeServiceConfig2W
/* End Apache licensed code */
static TCHAR* lateDllName[] = {
L"kernel32", L"advapi32", L"mswsock", L"ws2_32" };
static HMODULE lateDllHandle[] = {
NULL, NULL, NULL, NULL };
FARPROC load_dll_func(dlltoken_e fnLib, TCHAR* fnName, int ordinal)
{
if (!lateDllHandle[fnLib]) {
lateDllHandle[fnLib] = LoadLibrary(lateDllName[fnLib]);
if (!lateDllHandle[fnLib]) {
DWORD err = GetLastError();
fprintf(stderr, "GetLastError(): %d %s\r\n",
err, lateDllName[fnLib]);
return NULL;
}
}
if (ordinal)
return GetProcAddress(lateDllHandle[fnLib], (char *)ordinal);
else
return GetProcAddress(lateDllHandle[fnLib], (char *)fnName);
}
/*End ASF licensed code */
JNIEXPORT jboolean SIGAR_JNI(win32_Service_ChangeServiceDescription)
(JNIEnv *env, jclass, jlong handle, jstring description)
{
jboolean bResult = TRUE;
SERVICE_DESCRIPTION servdesc;
OSVERSIONINFO osver; /* VER_PLATFORM_WIN32_NT */
osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osver);
if ((osver.dwPlatformId == VER_PLATFORM_WIN32_NT)
&& (osver.dwMajorVersion > 4)
&& (ChangeServiceConfig2 != NULL)) {
servdesc.lpDescription = (LPTSTR)env->GetStringChars(description,
NULL);
bResult = ChangeServiceConfig2((SC_HANDLE)handle,
SERVICE_CONFIG_DESCRIPTION, &servdesc);
env->ReleaseStringChars(description,
(const jchar *)servdesc.lpDescription);
}
return bResult;
}
JNIEXPORT jboolean SIGAR_JNI(win32_Service_CloseServiceHandle)
(JNIEnv *, jclass, jlong handle)
{
return CloseServiceHandle((SC_HANDLE)handle);
}
JNIEXPORT jboolean SIGAR_JNI(win32_Service_ControlService)
(JNIEnv *, jclass, jlong handle, jint control)
{
SERVICE_STATUS status;
return ControlService((SC_HANDLE)handle, control, &status);
}
JNIEXPORT jlong SIGAR_JNI(win32_Service_CreateService)
(JNIEnv *env,
jclass,
jlong handle,
jstring serviceName,
jstring displayName,
jint serviceType,
jint startType,
jint errorControl,
jstring path,
jobjectArray dependencies,
jstring startName,
jstring password)
{
TCHAR szBuf[4048];
LPCTSTR lpDepend = NULL;
jlong lResult;
LPCTSTR lpStartName;
LPCTSTR lpServiceName = (LPCTSTR)env->GetStringChars(serviceName, NULL);
LPCTSTR lpDisplayName = (LPCTSTR)env->GetStringChars(displayName, NULL);
LPCTSTR lpPath = (LPCTSTR)env->GetStringChars(path, NULL);
LPCTSTR lpPassword = (LPCTSTR)env->GetStringChars(password, NULL);
if(startName != NULL)
lpStartName = (LPCTSTR)env->GetStringChars(path, NULL);
else
lpStartName = NULL;
if(dependencies != NULL)
{
// Build a buffer of a double null terminated array of
// null terminated service names
lpDepend = szBuf;
LPTSTR lpBuf = szBuf;
size_t cbLen = 0;
jsize cSize = env->GetArrayLength(dependencies);
for(int i = 0;i < cSize;i ++)
{
jstring str = (jstring)env->GetObjectArrayElement(dependencies, i);
LPCTSTR lpStr = (LPCTSTR)env->GetStringChars(str, NULL);
cbLen = lstrlen(lpStr);
// If we're going to overrun the buffer then break out of the loop
if((lpBuf + cbLen + 1) >= (szBuf + sizeof(szBuf) / sizeof(TCHAR)))
break;
lstrcpy(lpBuf, lpStr);
env->ReleaseStringChars(str, (const jchar *)lpStr);
// Move the buffer to the byte beyond the current string
// null terminator
lpBuf = lpBuf + cbLen + 1;
}
*lpBuf = 0; // Double null terminate the string
}
// Create the Service
lResult = (jlong)CreateService((SC_HANDLE)handle, lpServiceName,
lpDisplayName, SERVICE_ALL_ACCESS,
serviceType,
startType, errorControl, lpPath,
NULL, NULL, lpDepend, lpStartName,
lpPassword);
if(lpStartName != NULL)
env->ReleaseStringChars(path, (const jchar *)lpStartName);
env->ReleaseStringChars(password, (const jchar *)lpPassword);
env->ReleaseStringChars(path, (const jchar *)lpPath);
env->ReleaseStringChars(displayName, (const jchar *)lpDisplayName);
env->ReleaseStringChars(serviceName, (const jchar *)lpServiceName);
return lResult;
}
JNIEXPORT jboolean SIGAR_JNI(win32_Service_DeleteService)
(JNIEnv *env, jclass, jlong handle)
{
return DeleteService((SC_HANDLE)handle);
}
JNIEXPORT jstring SIGAR_JNI(win32_Service_GetErrorMessage)
(JNIEnv *env, jclass, jint error)
{
LPTSTR lpMsg;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|
FORMAT_MESSAGE_IGNORE_INSERTS|
FORMAT_MESSAGE_FROM_SYSTEM,
NULL, error,
MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
(LPTSTR)&lpMsg, 0, NULL);
return env->NewString((const jchar *)lpMsg, lstrlen(lpMsg));
}
/**
* XXX: this should probablly be moved into a util class
*/
JNIEXPORT jint SIGAR_JNI(win32_Service_GetLastError)
(JNIEnv *, jclass)
{
return GetLastError();
}
JNIEXPORT jlong SIGAR_JNI(win32_Service_OpenSCManager)
(JNIEnv *env, jclass, jstring machine, jint access)
{
jlong lResult;
LPCTSTR lpMachine = (LPCTSTR)env->GetStringChars(machine, NULL);
lResult = (jlong)OpenSCManager(lpMachine, NULL, access);
env->ReleaseStringChars(machine, (const jchar *)lpMachine);
return lResult;
}
JNIEXPORT jlong SIGAR_JNI(win32_Service_OpenService)
(JNIEnv *env,
jclass,
jlong handle,
jstring service,
jint access)
{
jlong lResult;
LPCTSTR lpService = (LPCTSTR)env->GetStringChars(service, NULL);
lResult = (jlong)OpenService((SC_HANDLE)handle,
lpService, access);
env->ReleaseStringChars(service, (const jchar *)lpService);
return lResult;
}
JNIEXPORT jint
SIGAR_JNI(win32_Service_QueryServiceStatus)
(JNIEnv *, jclass, jlong handle)
{
SERVICE_STATUS status;
int iResult;
if(QueryServiceStatus((SC_HANDLE)handle, &status) == TRUE) {
iResult = status.dwCurrentState;
} else
iResult = -1;
return iResult;
}
JNIEXPORT jint SIGAR_JNI(win32_Service_QueryServiceStartType)
(JNIEnv *, jclass, jlong handle)
{
LPQUERY_SERVICE_CONFIG config;
int iResult;
DWORD dwBytesNeeded;
config = (LPQUERY_SERVICE_CONFIG) LocalAlloc(LPTR, 4096);
if (config == NULL)
return -1;
/* Get the configuration information. */
if (QueryServiceConfig((SC_HANDLE)handle, config, 4096,
&dwBytesNeeded) == 0) {
iResult = -1;
}
else
iResult = config->dwStartType;
return iResult;
}
JNIEXPORT jboolean SIGAR_JNI(win32_Service_StartService)
(JNIEnv *, jclass, jlong handle)
{
return StartService((SC_HANDLE)handle, 0, NULL);
}
JNIEXPORT jboolean SIGAR_JNI(win32_Service_StopService)
(JNIEnv *, jclass, jlong handle)
{
SERVICE_STATUS status;
return ControlService((SC_HANDLE)handle, SERVICE_CONTROL_STOP, &status);
}
#ifdef __cplusplus
}
#endif
#endif /* WIN32 */
+25
View File
@@ -0,0 +1,25 @@
#ifdef WIN32
#include <pdh.h>
#include <pdhmsg.h>
#include "win32bindings.h"
#include "javasigar.h"
/**
* Set of common utilities for all win32bindings objects
*/
#ifdef __cplusplus
extern "C" {
#endif
void win32_throw_exception(JNIEnv *env, char *msg)
{
jclass exceptionClass = WIN32_FIND_CLASS("Win32Exception");
JENV->ThrowNew(env, exceptionClass, msg);
}
#ifdef __cplusplus
}
#endif
#endif /* WIN32 */
@@ -0,0 +1,28 @@
#ifndef WIN32_BINDINGS_H
#define WIN32_BINDINGS_H
/* Exclude rarely-used stuff from windows headers */
#define WIN32_LEAN_AND_MEAN
/* Windows Header Files */
#include <windows.h>
#include <tchar.h>
/* Include java jni headers */
#include <jni.h>
#define WIN32_PACKAGE "net/covalent/win32bindings/"
#define WIN32_FIND_CLASS(name) \
JENV->FindClass(env, WIN32_PACKAGE name)
#define WIN32_ALLOC_OBJECT(name) \
JENV->AllocObject(env, WIN32_FIND_CLASS(name))
#define SetStringField(env, obj, fieldID, val) \
JENV->SetObjectField(env, obj, fieldID, JENV->NewStringUTF(env, val))
void win32_throw_exception(JNIEnv *env, char *msg);
#endif