merging in the win32bindings package
This commit is contained in:
1 parent
3b0a6af2d2
commit
6353b7bcc3
22 files changed
+3289
No files matched your search
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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
|
||||
Reference in new issue
Block a user