JNIEXPORT jlong SIGAR_JNIx(getServicePid)
(JNIEnv *env, jobject sigar_obj, jstring jname)
{
#ifdef WIN32
const char *name;
jboolean is_copy;
jlong pid = 0;
int status;
dSIGAR(0);
name = JENV->GetStringUTFChars(env, jname, &is_copy);
status =
sigar_service_pid_get(sigar, (char *)name, &pid);
if (is_copy) {
JENV->ReleaseStringUTFChars(env, jname, name);
}
if (status != ERROR_SUCCESS) {
sigar_throw_error(env, jsigar, status);
}
return pid;
#else
dSIGAR(0);
sigar_throw_error(env, jsigar, SIGAR_ENOTIMPL);
return 0;
#endif
}
JNIEXPORT jobjectArray SIGAR_JNIx(getNetConnectionList)
(JNIEnv *env, jobject sigar_obj, jint flags)
{
int status;
unsigned int i;
jarray connarray;
jclass cls = SIGAR_FIND_CLASS("NetConnection");
sigar_net_connection_list_t connlist;
dSIGAR(NULL);
status = sigar_net_connection_list_get(sigar, &connlist, flags);
if (status != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
JAVA_SIGAR_INIT_FIELDS_NETCONNECTION(cls);
connarray = JENV->NewObjectArray(env, connlist.number, cls, 0);
SIGAR_CHEX;
for (i=0; i<connlist.number; i++) {
jobject obj = JENV->AllocObject(env, cls);
SIGAR_CHEX;
JAVA_SIGAR_SET_FIELDS_NETCONNECTION(cls, obj, connlist.data[i]);
JENV->SetObjectArrayElement(env, connarray, i, obj);
SIGAR_CHEX;
}
sigar_net_connection_list_destroy(sigar, &connlist);
return connarray;
}
JNIEXPORT jint SIGAR_JNIx(nativeClose)
(JNIEnv *env, jobject sigar_obj)
{
jint status;
int i;
dSIGAR(0);
/* only place it is possible this would be something other than
* SIGAR_OK is on win32 if RegCloseKey fails, which i don't think
* is possible either.
*/
status = sigar_close(sigar);
if (jsigar->logger != NULL) {
JENV->DeleteGlobalRef(env, jsigar->logger);
}
if (jsigar->not_impl != NULL) {
JENV->DeleteGlobalRef(env, jsigar->not_impl);
}
for (i=0; i<JSIGAR_FIELDS_MAX; i++) {
if (jsigar->fields[i]) {
JENV->DeleteGlobalRef(env,
jsigar->fields[i]->classref);
free(jsigar->fields[i]->ids);
free(jsigar->fields[i]);
}
}
free(jsigar);
sigar_set_pointer(env, sigar_obj, NULL);
return status;
}
JNIEXPORT jlong SIGAR_JNIx(getPid)
(JNIEnv *env, jobject sigar_obj)
{
dSIGAR(0);
return sigar_pid_get(sigar);
}
JNIEXPORT jstring SIGAR_JNI(ProcEnv_getValue)
(JNIEnv *env, jobject cls, jobject sigar_obj, jlong pid, jstring key)
{
int status;
sigar_proc_env_t procenv;
jni_env_get_t get;
dSIGAR(NULL);
get.env = env;
get.key = JENV->GetStringUTFChars(env, key, 0);
get.klen = JENV->GetStringUTFLength(env, key);
get.val = NULL;
procenv.type = SIGAR_PROC_ENV_KEY;
procenv.key = get.key;
procenv.klen = get.klen;
procenv.env_getter = jni_env_getvalue;
procenv.data = &get;
if ((status = sigar_proc_env_get(sigar, pid, &procenv)) != SIGAR_OK) {
JENV->ReleaseStringUTFChars(env, key, get.key);
sigar_throw_error(env, jsigar, status);
return NULL;
}
JENV->ReleaseStringUTFChars(env, key, get.key);
return get.val;
}
JNIEXPORT jlong SIGAR_JNI(ptql_SigarProcessQuery_findProcess)
(JNIEnv *env, jobject obj, jobject sigar_obj)
{
sigar_pid_t pid;
int status;
jni_ptql_re_data_t re;
sigar_ptql_query_t *query =
(sigar_ptql_query_t *)sigar_get_pointer(env, obj);
dSIGAR(0);
re_impl_set(env, sigar, obj, &re);
status = sigar_ptql_query_find_process(sigar, query, &pid);
sigar_ptql_re_impl_set(sigar, NULL, NULL);
if (status < 0) {
sigar_throw_exception(env, sigar->errbuf);
}
else if (status != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
}
return pid;
}
JNIEXPORT jobjectArray SIGAR_JNIx(getNetInterfaceList)
(JNIEnv *env, jobject sigar_obj)
{
int status;
unsigned int i;
sigar_net_interface_list_t iflist;
jobjectArray ifarray;
jclass stringclass = JENV->FindClass(env, "java/lang/String");
dSIGAR(NULL);
if ((status = sigar_net_interface_list_get(sigar, &iflist)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
ifarray = JENV->NewObjectArray(env, iflist.number, stringclass, 0);
SIGAR_CHEX;
for (i=0; i<iflist.number; i++) {
jstring s = JENV->NewStringUTF(env, iflist.data[i]);
JENV->SetObjectArrayElement(env, ifarray, i, s);
SIGAR_CHEX;
}
sigar_net_interface_list_destroy(sigar, &iflist);
return ifarray;
}
JNIEXPORT jobjectArray SIGAR_JNIx(getCpuListNative)
(JNIEnv *env, jobject sigar_obj)
{
int status;
unsigned int i;
sigar_cpu_list_t cpulist;
jobjectArray cpuarray;
jclass cls = SIGAR_FIND_CLASS("Cpu");
dSIGAR(NULL);
if ((status = sigar_cpu_list_get(sigar, &cpulist)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
JAVA_SIGAR_INIT_FIELDS_CPU(cls);
cpuarray = JENV->NewObjectArray(env, cpulist.number, cls, 0);
SIGAR_CHEX;
for (i=0; i<cpulist.number; i++) {
jobject info_obj = JENV->AllocObject(env, cls);
SIGAR_CHEX;
JAVA_SIGAR_SET_FIELDS_CPU(cls, info_obj,
cpulist.data[i]);
JENV->SetObjectArrayElement(env, cpuarray, i, info_obj);
SIGAR_CHEX;
}
sigar_cpu_list_destroy(sigar, &cpulist);
return cpuarray;
}
JNIEXPORT jobjectArray SIGAR_JNIx(getProcArgs)
(JNIEnv *env, jobject sigar_obj, jlong pid)
{
int status;
unsigned int i;
sigar_proc_args_t procargs;
jobjectArray argsarray;
jclass stringclass = JENV->FindClass(env, "java/lang/String");
dSIGAR(NULL);
if ((status = sigar_proc_args_get(sigar, pid, &procargs)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
argsarray = JENV->NewObjectArray(env, procargs.number, stringclass, 0);
SIGAR_CHEX;
for (i=0; i<procargs.number; i++) {
jstring s = getProcArgStr(procargs.data[i], env);
JENV->SetObjectArrayElement(env, argsarray, i, s);
SIGAR_CHEX;
}
sigar_proc_args_destroy(sigar, &procargs);
return argsarray;
}
JNIEXPORT jobjectArray SIGAR_JNIx(getWhoList)
(JNIEnv *env, jobject sigar_obj)
{
int status;
unsigned int i;
sigar_who_list_t wholist;
jobjectArray whoarray;
jclass cls = SIGAR_FIND_CLASS("Who");
dSIGAR(NULL);
if ((status = sigar_who_list_get(sigar, &wholist)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
JAVA_SIGAR_INIT_FIELDS_WHO(cls);
whoarray = JENV->NewObjectArray(env, wholist.number, cls, 0);
SIGAR_CHEX;
for (i=0; i<wholist.number; i++) {
jobject info_obj = JENV->AllocObject(env, cls);
SIGAR_CHEX;
JAVA_SIGAR_SET_FIELDS_WHO(cls, info_obj,
wholist.data[i]);
JENV->SetObjectArrayElement(env, whoarray, i, info_obj);
SIGAR_CHEX;
}
sigar_who_list_destroy(sigar, &wholist);
return whoarray;
}
JNIEXPORT jobjectArray SIGAR_JNIx(getNetRouteList)
(JNIEnv *env, jobject sigar_obj)
{
int status;
unsigned int i;
jarray routearray;
jclass cls = SIGAR_FIND_CLASS("NetRoute");
sigar_net_route_list_t routelist;
dSIGAR(NULL);
if ((status = sigar_net_route_list_get(sigar, &routelist)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
JAVA_SIGAR_INIT_FIELDS_NETROUTE(cls);
routearray = JENV->NewObjectArray(env, routelist.number, cls, 0);
SIGAR_CHEX;
for (i=0; i<routelist.number; i++) {
jobject obj = JENV->AllocObject(env, cls);
SIGAR_CHEX;
JAVA_SIGAR_SET_FIELDS_NETROUTE(cls, obj, routelist.data[i]);
JENV->SetObjectArrayElement(env, routearray, i, obj);
SIGAR_CHEX;
}
sigar_net_route_list_destroy(sigar, &routelist);
return routearray;
}
JNIEXPORT jobject SIGAR_JNI(ProcEnv_getAll)
(JNIEnv *env, jobject cls, jobject sigar_obj, jlong pid)
{
int status;
sigar_proc_env_t procenv;
jobject hashmap;
jni_env_put_t put;
jclass mapclass =
JENV->FindClass(env, "java/util/HashMap");
jmethodID mapid =
JENV->GetMethodID(env, mapclass, "<init>", "()V");
jmethodID putid =
JENV->GetMethodID(env, mapclass, "put", MAP_PUT_SIG);
dSIGAR(NULL);
hashmap = JENV->NewObject(env, mapclass, mapid);
SIGAR_CHEX;
put.env = env;
put.id = putid;
put.map = hashmap;
procenv.type = SIGAR_PROC_ENV_ALL;
procenv.env_getter = jni_env_getall;
procenv.data = &put;
if ((status = sigar_proc_env_get(sigar, pid, &procenv)) != SIGAR_OK) {
JENV->DeleteLocalRef(env, hashmap);
sigar_throw_error(env, jsigar, status);
return NULL;
}
return hashmap;
}
JNIEXPORT jlongArray SIGAR_JNI(ptql_SigarProcessQuery_find)
(JNIEnv *env, jobject obj, jobject sigar_obj)
{
int status;
jlongArray procarray;
sigar_proc_list_t proclist;
jlong *pids = NULL;
jni_ptql_re_data_t re;
sigar_ptql_query_t *query =
(sigar_ptql_query_t *)sigar_get_pointer(env, obj);
dSIGAR(NULL);
re_impl_set(env, sigar, obj, &re);
status = sigar_ptql_query_find(sigar, query, &proclist);
sigar_ptql_re_impl_set(sigar, NULL, NULL);
if (status < 0) {
sigar_throw_exception(env, sigar->errbuf);
return NULL;
}
else if (status != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
procarray = JENV->NewLongArray(env, proclist.number);
SIGAR_CHEX;
if (sizeof(jlong) == sizeof(sigar_pid_t)) {
pids = (jlong *)proclist.data;
}
else {
unsigned int i;
pids = (jlong *)malloc(sizeof(jlong) * proclist.number);
for (i=0; i<proclist.number; i++) {
pids[i] = proclist.data[i];
}
}
JENV->SetLongArrayRegion(env, procarray, 0,
proclist.number, pids);
if (pids != (jlong *)proclist.data) {
free(pids);
}
sigar_proc_list_destroy(sigar, &proclist);
return procarray;
}
JNIEXPORT jstring SIGAR_JNIx(getNetServicesName)
(JNIEnv *env, jobject sigar_obj, jint protocol, jlong port)
{
char *name;
dSIGAR(NULL);
if ((name = sigar_net_services_name_get(sigar, protocol, port))) {
return JENV->NewStringUTF(env, name);
}
else {
return NULL;
}
}
JNIEXPORT jstring SIGAR_JNIx(getFQDN)
(JNIEnv *env, jobject sigar_obj)
{
char fqdn[SIGAR_FQDN_LEN];
int status;
dSIGAR(NULL);
if ((status = sigar_fqdn_get(sigar, fqdn, sizeof(fqdn))) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
return JENV->NewStringUTF(env, fqdn);
}
JNIEXPORT jstring SIGAR_JNIx(getNetListenAddress)
(JNIEnv *env, jobject sigar_obj, jlong port)
{
int status;
sigar_net_address_t address;
dSIGAR(NULL);
status = sigar_net_listen_address_get(sigar, port, &address);
if (status != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
return jnet_address_to_string(env, sigar, &address);
}
JNIEXPORT jlong SIGAR_JNIx(getProcPort)
(JNIEnv *env, jobject sigar_obj, jint protocol, jlong port)
{
int status;
sigar_pid_t pid;
dSIGAR(0);
status = sigar_proc_port_get(sigar, protocol,
(unsigned long)port, &pid);
if (status != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return -1;
}
return pid;
}
JNIEXPORT jdoubleArray SIGAR_JNIx(getLoadAverage)
(JNIEnv *env, jobject sigar_obj)
{
int status;
jlongArray avgarray;
sigar_loadavg_t loadavg;
dSIGAR(NULL);
if ((status = sigar_loadavg_get(sigar, &loadavg)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
avgarray = JENV->NewDoubleArray(env, 3);
JENV->SetDoubleArrayRegion(env, avgarray, 0,
3, loadavg.loadavg);
return avgarray;
}
JNIEXPORT jlongArray SIGAR_JNIx(getProcList)
(JNIEnv *env, jobject sigar_obj)
{
int status;
jlongArray procarray;
sigar_proc_list_t proclist;
jlong *pids = NULL;
dSIGAR(NULL);
if ((status = sigar_proc_list_get(sigar, &proclist)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
procarray = JENV->NewLongArray(env, proclist.number);
SIGAR_CHEX;
if (sizeof(jlong) == sizeof(sigar_pid_t)) {
pids = (jlong *)proclist.data;
}
else {
unsigned int i;
pids = (jlong *)malloc(sizeof(jlong) * proclist.number);
for (i=0; i<proclist.number; i++) {
pids[i] = proclist.data[i];
}
}
JENV->SetLongArrayRegion(env, procarray, 0,
proclist.number, pids);
if (pids != (jlong *)proclist.data) {
free(pids);
}
sigar_proc_list_destroy(sigar, &proclist);
return procarray;
}
JNIEXPORT jboolean SIGAR_JNI(ptql_SigarProcessQuery_match)
(JNIEnv *env, jobject obj, jobject sigar_obj, jlong pid)
{
int status;
jni_ptql_re_data_t re;
sigar_ptql_query_t *query =
(sigar_ptql_query_t *)sigar_get_pointer(env, obj);
dSIGAR(JNI_FALSE);
re_impl_set(env, sigar, obj, &re);
status = sigar_ptql_query_match(sigar, query, pid);
sigar_ptql_re_impl_set(sigar, NULL, NULL);
if (status == SIGAR_OK) {
return JNI_TRUE;
}
else {
return JNI_FALSE;
}
}
JNIEXPORT jobject SIGAR_JNIx(getProcModulesNative)
(JNIEnv *env, jobject sigar_obj, jlong pid)
{
int status;
sigar_proc_modules_t procmods;
jsigar_list_t obj;
dSIGAR(NULL);
jsigar_list_init(env, &obj);
procmods.module_getter = jsigar_list_add;
procmods.data = &obj;
if ((status = sigar_proc_modules_get(sigar, pid, &procmods)) != SIGAR_OK) {
JENV->DeleteLocalRef(env, obj.obj);
sigar_throw_error(env, jsigar, status);
return NULL;
}
return obj.obj;
}
/* for jni/win32 */
sigar_t *jsigar_get_sigar(JNIEnv *env, jobject sigar_obj)
{
dSIGAR(NULL);
return jsigar->sigar;
}
JNIEXPORT jobjectArray SIGAR_JNIx(getFileSystemListNative)
(JNIEnv *env, jobject sigar_obj)
{
int status;
unsigned int i;
sigar_file_system_list_t fslist;
jobjectArray fsarray;
jfieldID ids[FS_FIELD_MAX];
jclass nfs_cls=NULL, cls = SIGAR_FIND_CLASS("FileSystem");
dSIGAR(NULL);
if ((status = sigar_file_system_list_get(sigar, &fslist)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
ids[FS_FIELD_DIRNAME] =
JENV->GetFieldID(env, cls, "dirName", STRING_SIG);
ids[FS_FIELD_DEVNAME] =
JENV->GetFieldID(env, cls, "devName", STRING_SIG);
ids[FS_FIELD_TYPENAME] =
JENV->GetFieldID(env, cls, "typeName", STRING_SIG);
ids[FS_FIELD_SYS_TYPENAME] =
JENV->GetFieldID(env, cls, "sysTypeName", STRING_SIG);
ids[FS_FIELD_OPTIONS] =
JENV->GetFieldID(env, cls, "options", STRING_SIG);
ids[FS_FIELD_TYPE] =
JENV->GetFieldID(env, cls, "type", "I");
fsarray = JENV->NewObjectArray(env, fslist.number, cls, 0);
SIGAR_CHEX;
for (i=0; i<fslist.number; i++) {
sigar_file_system_t *fs = &(fslist.data)[i];
jobject fsobj;
jclass obj_cls;
#ifdef WIN32
obj_cls = cls;
#else
if ((fs->type == SIGAR_FSTYPE_NETWORK) &&
(strcmp(fs->sys_type_name, "nfs") == 0) &&
strstr(fs->dev_name, ":/"))
{
if (!nfs_cls) {
nfs_cls = SIGAR_FIND_CLASS("NfsFileSystem");
}
obj_cls = nfs_cls;
}
else {
obj_cls = cls;
}
#endif
fsobj = JENV->AllocObject(env, obj_cls);
SIGAR_CHEX;
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_DIRNAME],
fs->dir_name);
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_DEVNAME],
fs->dev_name);
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_SYS_TYPENAME],
fs->sys_type_name);
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_OPTIONS],
fs->options);
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_TYPENAME],
fs->type_name);
JENV->SetIntField(env, fsobj,
ids[FS_FIELD_TYPE],
fs->type);
JENV->SetObjectArrayElement(env, fsarray, i, fsobj);
SIGAR_CHEX;
}
sigar_file_system_list_destroy(sigar, &fslist);
return fsarray;
}
