src/java.c

   1 /**
   2  * collectd - src/java.c
   3  * Copyright (C) 2009  Florian octo Forster
   4  * Copyright (C) 2008  Justo Alonso Achaques
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; only version 2 of the License is applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Authors:
  20  *   Florian octo Forster <octo at collectd.org>
  21  *   Justo Alonso Achaques <justo.alonso at gmail.com>
  22  **/
  23
  24 #include "collectd.h"
  25 #include "plugin.h"
  26 #include "common.h"
  27 #include "filter_chain.h"
  28
  29 #include <pthread.h>
  30 #include <jni.h>
  31
  32 #if !defined(JNI_VERSION_1_2)
  33 # error "Need JNI 1.2 compatible interface!"
  34 #endif
  35
  36 /*
  37  * Types
  38  */
  39 struct cjni_jvm_env_s /* {{{ */
  40 {
  41   JNIEnv *jvm_env;
  42   int reference_counter;
  43 };
  44 typedef struct cjni_jvm_env_s cjni_jvm_env_t;
  45 /* }}} */
  46
  47 struct java_plugin_class_s /* {{{ */
  48 {
  49   char     *name;
  50   jclass    class;
  51   jobject   object;
  52 };
  53 typedef struct java_plugin_class_s java_plugin_class_t;
  54 /* }}} */
  55
  56 #define CB_TYPE_CONFIG       1
  57 #define CB_TYPE_INIT         2
  58 #define CB_TYPE_READ         3
  59 #define CB_TYPE_WRITE        4
  60 #define CB_TYPE_FLUSH        5
  61 #define CB_TYPE_SHUTDOWN     6
  62 #define CB_TYPE_LOG          7
  63 #define CB_TYPE_NOTIFICATION 8
  64 #define CB_TYPE_MATCH        9
  65 #define CB_TYPE_TARGET      10
  66 struct cjni_callback_info_s /* {{{ */
  67 {
  68   char     *name;
  69   int       type;
  70   jclass    class;
  71   jobject   object;
  72   jmethodID method;
  73 };
  74 typedef struct cjni_callback_info_s cjni_callback_info_t;
  75 /* }}} */
  76
  77 /*
  78  * Global variables
  79  */
  80 static JavaVM *jvm = NULL;
  81 static pthread_key_t jvm_env_key;
  82
  83 /* Configuration options for the JVM. */
  84 static char **jvm_argv = NULL;
  85 static size_t jvm_argc = 0;
  86
  87 /* List of class names to load */
  88 static java_plugin_class_t  *java_classes_list = NULL;
  89 static size_t                java_classes_list_len;
  90
  91 /* List of config, init, and shutdown callbacks. */
  92 static cjni_callback_info_t *java_callbacks      = NULL;
  93 static size_t                java_callbacks_num  = 0;
  94 static pthread_mutex_t       java_callbacks_lock = PTHREAD_MUTEX_INITIALIZER;
  95
  96 static oconfig_item_t       *config_block = NULL;
  97
  98 /*
  99  * Prototypes
 100  *
 101  * Mostly functions that are needed by the Java interface (``native'')
 102  * functions.
 103  */
 104 static void cjni_callback_info_destroy (void *arg);
 105 static cjni_callback_info_t *cjni_callback_info_create (JNIEnv *jvm_env,
 106     jobject o_name, jobject o_callback, int type);
 107 static int cjni_callback_register (JNIEnv *jvm_env, jobject o_name,
 108     jobject o_callback, int type);
 109 static int cjni_read (user_data_t *user_data);
 110 static int cjni_write (const data_set_t *ds, const value_list_t *vl,
 111     user_data_t *ud);
 112 static int cjni_flush (cdtime_t timeout, const char *identifier, user_data_t *ud);
 113 static void cjni_log (int severity, const char *message, user_data_t *ud);
 114 static int cjni_notification (const notification_t *n, user_data_t *ud);
 115
 116 /* Create, destroy, and match/invoke functions, used by both, matches AND
 117  * targets. */
 118 static int cjni_match_target_create (const oconfig_item_t *ci, void **user_data);
 119 static int cjni_match_target_destroy (void **user_data);
 120 static int cjni_match_target_invoke (const data_set_t *ds, value_list_t *vl,
 121     notification_meta_t **meta, void **user_data);
 122
 123 /*
 124  * C to Java conversion functions
 125  */
 126 static int ctoj_string (JNIEnv *jvm_env, /* {{{ */
 127     const char *string,
 128     jclass class_ptr, jobject object_ptr, const char *method_name)
 129 {
 130   jmethodID m_set;
 131   jstring o_string;
 132
 133   /* Create a java.lang.String */
 134   o_string = (*jvm_env)->NewStringUTF (jvm_env,
 135       (string != NULL) ? string : "");
 136   if (o_string == NULL)
 137   {
 138     ERROR ("java plugin: ctoj_string: NewStringUTF failed.");
 139     return (-1);
 140   }
 141
 142   /* Search for the `void setFoo (String s)' method. */
 143   m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
 144       method_name, "(Ljava/lang/String;)V");
 145   if (m_set == NULL)
 146   {
 147     ERROR ("java plugin: ctoj_string: Cannot find method `void %s (String)'.",
 148         method_name);
 149     (*jvm_env)->DeleteLocalRef (jvm_env, o_string);
 150     return (-1);
 151   }
 152
 153   /* Call the method. */
 154   (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, o_string);
 155
 156   /* Decrease reference counter on the java.lang.String object. */
 157   (*jvm_env)->DeleteLocalRef (jvm_env, o_string);
 158
 159   return (0);
 160 } /* }}} int ctoj_string */
 161
 162 static jstring ctoj_output_string (JNIEnv *jvm_env, /* {{{ */
 163     const char *string)
 164 {
 165   jstring o_string;
 166
 167   /* Create a java.lang.String */
 168   o_string = (*jvm_env)->NewStringUTF (jvm_env,
 169       (string != NULL) ? string : "");
 170   if (o_string == NULL)
 171   {
 172     ERROR ("java plugin: ctoj_output_string: NewStringUTF failed.");
 173     return NULL;
 174   }
 175
 176   return (o_string);
 177 } /* }}} int ctoj_output_string */
 178
 179 static int ctoj_int (JNIEnv *jvm_env, /* {{{ */
 180     jint value,
 181     jclass class_ptr, jobject object_ptr, const char *method_name)
 182 {
 183   jmethodID m_set;
 184
 185   /* Search for the `void setFoo (int i)' method. */
 186   m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
 187       method_name, "(I)V");
 188   if (m_set == NULL)
 189   {
 190     ERROR ("java plugin: ctoj_int: Cannot find method `void %s (int)'.",
 191         method_name);
 192     return (-1);
 193   }
 194
 195   (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
 196
 197   return (0);
 198 } /* }}} int ctoj_int */
 199
 200 static int ctoj_long (JNIEnv *jvm_env, /* {{{ */
 201     jlong value,
 202     jclass class_ptr, jobject object_ptr, const char *method_name)
 203 {
 204   jmethodID m_set;
 205
 206   /* Search for the `void setFoo (long l)' method. */
 207   m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
 208       method_name, "(J)V");
 209   if (m_set == NULL)
 210   {
 211     ERROR ("java plugin: ctoj_long: Cannot find method `void %s (long)'.",
 212         method_name);
 213     return (-1);
 214   }
 215
 216   (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
 217
 218   return (0);
 219 } /* }}} int ctoj_long */
 220
 221 static int ctoj_double (JNIEnv *jvm_env, /* {{{ */
 222     jdouble value,
 223     jclass class_ptr, jobject object_ptr, const char *method_name)
 224 {
 225   jmethodID m_set;
 226
 227   /* Search for the `void setFoo (double d)' method. */
 228   m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
 229       method_name, "(D)V");
 230   if (m_set == NULL)
 231   {
 232     ERROR ("java plugin: ctoj_double: Cannot find method `void %s (double)'.",
 233         method_name);
 234     return (-1);
 235   }
 236
 237   (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
 238
 239   return (0);
 240 } /* }}} int ctoj_double */
 241
 242 /* Convert a jlong to a java.lang.Number */
 243 static jobject ctoj_jlong_to_number (JNIEnv *jvm_env, jlong value) /* {{{ */
 244 {
 245   jclass c_long;
 246   jmethodID m_long_constructor;
 247
 248   /* Look up the java.lang.Long class */
 249   c_long = (*jvm_env)->FindClass (jvm_env, "java/lang/Long");
 250   if (c_long == NULL)
 251   {
 252     ERROR ("java plugin: ctoj_jlong_to_number: Looking up the "
 253         "java.lang.Long class failed.");
 254     return (NULL);
 255   }
 256
 257   m_long_constructor = (*jvm_env)->GetMethodID (jvm_env,
 258       c_long, "<init>", "(J)V");
 259   if (m_long_constructor == NULL)
 260   {
 261     ERROR ("java plugin: ctoj_jlong_to_number: Looking up the "
 262         "`Long (long)' constructor failed.");
 263     return (NULL);
 264   }
 265
 266   return ((*jvm_env)->NewObject (jvm_env,
 267         c_long, m_long_constructor, value));
 268 } /* }}} jobject ctoj_jlong_to_number */
 269
 270 /* Convert a jdouble to a java.lang.Number */
 271 static jobject ctoj_jdouble_to_number (JNIEnv *jvm_env, jdouble value) /* {{{ */
 272 {
 273   jclass c_double;
 274   jmethodID m_double_constructor;
 275
 276   /* Look up the java.lang.Long class */
 277   c_double = (*jvm_env)->FindClass (jvm_env, "java/lang/Double");
 278   if (c_double == NULL)
 279   {
 280     ERROR ("java plugin: ctoj_jdouble_to_number: Looking up the "
 281         "java.lang.Double class failed.");
 282     return (NULL);
 283   }
 284
 285   m_double_constructor = (*jvm_env)->GetMethodID (jvm_env,
 286       c_double, "<init>", "(D)V");
 287   if (m_double_constructor == NULL)
 288   {
 289     ERROR ("java plugin: ctoj_jdouble_to_number: Looking up the "
 290         "`Double (double)' constructor failed.");
 291     return (NULL);
 292   }
 293
 294   return ((*jvm_env)->NewObject (jvm_env,
 295         c_double, m_double_constructor, value));
 296 } /* }}} jobject ctoj_jdouble_to_number */
 297
 298 /* Convert a value_t to a java.lang.Number */
 299 static jobject ctoj_value_to_number (JNIEnv *jvm_env, /* {{{ */
 300     value_t value, int ds_type)
 301 {
 302   if (ds_type == DS_TYPE_COUNTER)
 303     return (ctoj_jlong_to_number (jvm_env, (jlong) value.counter));
 304   else if (ds_type == DS_TYPE_GAUGE)
 305     return (ctoj_jdouble_to_number (jvm_env, (jdouble) value.gauge));
 306   if (ds_type == DS_TYPE_DERIVE)
 307     return (ctoj_jlong_to_number (jvm_env, (jlong) value.derive));
 308   if (ds_type == DS_TYPE_ABSOLUTE)
 309     return (ctoj_jlong_to_number (jvm_env, (jlong) value.absolute));
 310   else
 311     return (NULL);
 312 } /* }}} jobject ctoj_value_to_number */
 313
 314 /* Convert a data_source_t to a org/collectd/api/DataSource */
 315 static jobject ctoj_data_source (JNIEnv *jvm_env, /* {{{ */
 316     const data_source_t *dsrc)
 317 {
 318   jclass c_datasource;
 319   jmethodID m_datasource_constructor;
 320   jobject o_datasource;
 321   int status;
 322
 323   /* Look up the DataSource class */
 324   c_datasource = (*jvm_env)->FindClass (jvm_env,
 325       "org/collectd/api/DataSource");
 326   if (c_datasource == NULL)
 327   {
 328     ERROR ("java plugin: ctoj_data_source: "
 329         "FindClass (org/collectd/api/DataSource) failed.");
 330     return (NULL);
 331   }
 332
 333   /* Lookup the `ValueList ()' constructor. */
 334   m_datasource_constructor = (*jvm_env)->GetMethodID (jvm_env, c_datasource,
 335       "<init>", "()V");
 336   if (m_datasource_constructor == NULL)
 337   {
 338     ERROR ("java plugin: ctoj_data_source: Cannot find the "
 339         "`DataSource ()' constructor.");
 340     return (NULL);
 341   }
 342
 343   /* Create a new instance. */
 344   o_datasource = (*jvm_env)->NewObject (jvm_env, c_datasource,
 345       m_datasource_constructor);
 346   if (o_datasource == NULL)
 347   {
 348     ERROR ("java plugin: ctoj_data_source: "
 349         "Creating a new DataSource instance failed.");
 350     return (NULL);
 351   }
 352
 353   /* Set name via `void setName (String name)' */
 354   status = ctoj_string (jvm_env, dsrc->name,
 355       c_datasource, o_datasource, "setName");
 356   if (status != 0)
 357   {
 358     ERROR ("java plugin: ctoj_data_source: "
 359         "ctoj_string (setName) failed.");
 360     (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
 361     return (NULL);
 362   }
 363
 364   /* Set type via `void setType (int type)' */
 365   status = ctoj_int (jvm_env, dsrc->type,
 366       c_datasource, o_datasource, "setType");
 367   if (status != 0)
 368   {
 369     ERROR ("java plugin: ctoj_data_source: "
 370         "ctoj_int (setType) failed.");
 371     (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
 372     return (NULL);
 373   }
 374
 375   /* Set min via `void setMin (double min)' */
 376   status = ctoj_double (jvm_env, dsrc->min,
 377       c_datasource, o_datasource, "setMin");
 378   if (status != 0)
 379   {
 380     ERROR ("java plugin: ctoj_data_source: "
 381         "ctoj_double (setMin) failed.");
 382     (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
 383     return (NULL);
 384   }
 385
 386   /* Set max via `void setMax (double max)' */
 387   status = ctoj_double (jvm_env, dsrc->max,
 388       c_datasource, o_datasource, "setMax");
 389   if (status != 0)
 390   {
 391     ERROR ("java plugin: ctoj_data_source: "
 392         "ctoj_double (setMax) failed.");
 393     (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
 394     return (NULL);
 395   }
 396
 397   return (o_datasource);
 398 } /* }}} jobject ctoj_data_source */
 399
 400 /* Convert a oconfig_value_t to a org/collectd/api/OConfigValue */
 401 static jobject ctoj_oconfig_value (JNIEnv *jvm_env, /* {{{ */
 402     oconfig_value_t ocvalue)
 403 {
 404   jclass c_ocvalue;
 405   jmethodID m_ocvalue_constructor;
 406   jobject o_argument;
 407   jobject o_ocvalue;
 408
 409   m_ocvalue_constructor = NULL;
 410   o_argument = NULL;
 411
 412   c_ocvalue = (*jvm_env)->FindClass (jvm_env,
 413       "org/collectd/api/OConfigValue");
 414   if (c_ocvalue == NULL)
 415   {
 416     ERROR ("java plugin: ctoj_oconfig_value: "
 417         "FindClass (org/collectd/api/OConfigValue) failed.");
 418     return (NULL);
 419   }
 420
 421   if (ocvalue.type == OCONFIG_TYPE_BOOLEAN)
 422   {
 423     jboolean tmp_boolean;
 424
 425     tmp_boolean = (ocvalue.value.boolean == 0) ? JNI_FALSE : JNI_TRUE;
 426
 427     m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
 428         "<init>", "(Z)V");
 429     if (m_ocvalue_constructor == NULL)
 430     {
 431       ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
 432           "`OConfigValue (boolean)' constructor.");
 433       return (NULL);
 434     }
 435
 436     return ((*jvm_env)->NewObject (jvm_env,
 437           c_ocvalue, m_ocvalue_constructor, tmp_boolean));
 438   } /* if (ocvalue.type == OCONFIG_TYPE_BOOLEAN) */
 439   else if (ocvalue.type == OCONFIG_TYPE_STRING)
 440   {
 441     m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
 442         "<init>", "(Ljava/lang/String;)V");
 443     if (m_ocvalue_constructor == NULL)
 444     {
 445       ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
 446           "`OConfigValue (String)' constructor.");
 447       return (NULL);
 448     }
 449
 450     o_argument = (*jvm_env)->NewStringUTF (jvm_env, ocvalue.value.string);
 451     if (o_argument == NULL)
 452     {
 453       ERROR ("java plugin: ctoj_oconfig_value: "
 454           "Creating a String object failed.");
 455       return (NULL);
 456     }
 457   }
 458   else if (ocvalue.type == OCONFIG_TYPE_NUMBER)
 459   {
 460     m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
 461         "<init>", "(Ljava/lang/Number;)V");
 462     if (m_ocvalue_constructor == NULL)
 463     {
 464       ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
 465           "`OConfigValue (Number)' constructor.");
 466       return (NULL);
 467     }
 468
 469     o_argument = ctoj_jdouble_to_number (jvm_env,
 470         (jdouble) ocvalue.value.number);
 471     if (o_argument == NULL)
 472     {
 473       ERROR ("java plugin: ctoj_oconfig_value: "
 474           "Creating a Number object failed.");
 475       return (NULL);
 476     }
 477   }
 478   else
 479   {
 480     return (NULL);
 481   }
 482
 483   assert (m_ocvalue_constructor != NULL);
 484   assert (o_argument != NULL);
 485
 486   o_ocvalue = (*jvm_env)->NewObject (jvm_env,
 487       c_ocvalue, m_ocvalue_constructor, o_argument);
 488   if (o_ocvalue == NULL)
 489   {
 490     ERROR ("java plugin: ctoj_oconfig_value: "
 491         "Creating an OConfigValue object failed.");
 492     (*jvm_env)->DeleteLocalRef (jvm_env, o_argument);
 493     return (NULL);
 494   }
 495
 496   (*jvm_env)->DeleteLocalRef (jvm_env, o_argument);
 497   return (o_ocvalue);
 498 } /* }}} jobject ctoj_oconfig_value */
 499
 500 /* Convert a oconfig_item_t to a org/collectd/api/OConfigItem */
 501 static jobject ctoj_oconfig_item (JNIEnv *jvm_env, /* {{{ */
 502     const oconfig_item_t *ci)
 503 {
 504   jclass c_ocitem;
 505   jmethodID m_ocitem_constructor;
 506   jmethodID m_addvalue;
 507   jmethodID m_addchild;
 508   jobject o_key;
 509   jobject o_ocitem;
 510   int i;
 511
 512   c_ocitem = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/OConfigItem");
 513   if (c_ocitem == NULL)
 514   {
 515     ERROR ("java plugin: ctoj_oconfig_item: "
 516         "FindClass (org/collectd/api/OConfigItem) failed.");
 517     return (NULL);
 518   }
 519
 520   /* Get the required methods: m_ocitem_constructor, m_addvalue, and m_addchild
 521    * {{{ */
 522   m_ocitem_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
 523       "<init>", "(Ljava/lang/String;)V");
 524   if (m_ocitem_constructor == NULL)
 525   {
 526     ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
 527         "`OConfigItem (String)' constructor.");
 528     return (NULL);
 529   }
 530
 531   m_addvalue = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
 532       "addValue", "(Lorg/collectd/api/OConfigValue;)V");
 533   if (m_addvalue == NULL)
 534   {
 535     ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
 536         "`addValue (OConfigValue)' method.");
 537     return (NULL);
 538   }
 539
 540   m_addchild = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
 541       "addChild", "(Lorg/collectd/api/OConfigItem;)V");
 542   if (m_addchild == NULL)
 543   {
 544     ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
 545         "`addChild (OConfigItem)' method.");
 546     return (NULL);
 547   }
 548   /* }}} */
 549
 550   /* Create a String object with the key.
 551    * Needed for calling the constructor. */
 552   o_key = (*jvm_env)->NewStringUTF (jvm_env, ci->key);
 553   if (o_key == NULL)
 554   {
 555     ERROR ("java plugin: ctoj_oconfig_item: "
 556         "Creating String object failed.");
 557     return (NULL);
 558   }
 559
 560   /* Create an OConfigItem object */
 561   o_ocitem = (*jvm_env)->NewObject (jvm_env,
 562       c_ocitem, m_ocitem_constructor, o_key);
 563   if (o_ocitem == NULL)
 564   {
 565     ERROR ("java plugin: ctoj_oconfig_item: "
 566         "Creating an OConfigItem object failed.");
 567     (*jvm_env)->DeleteLocalRef (jvm_env, o_key);
 568     return (NULL);
 569   }
 570
 571   /* We don't need the String object any longer.. */
 572   (*jvm_env)->DeleteLocalRef (jvm_env, o_key);
 573
 574   /* Call OConfigItem.addValue for each value */
 575   for (i = 0; i < ci->values_num; i++) /* {{{ */
 576   {
 577     jobject o_value;
 578
 579     o_value = ctoj_oconfig_value (jvm_env, ci->values[i]);
 580     if (o_value == NULL)
 581     {
 582       ERROR ("java plugin: ctoj_oconfig_item: "
 583           "Creating an OConfigValue object failed.");
 584       (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
 585       return (NULL);
 586     }
 587
 588     (*jvm_env)->CallVoidMethod (jvm_env, o_ocitem, m_addvalue, o_value);
 589     (*jvm_env)->DeleteLocalRef (jvm_env, o_value);
 590   } /* }}} for (i = 0; i < ci->values_num; i++) */
 591
 592   /* Call OConfigItem.addChild for each child */
 593   for (i = 0; i < ci->children_num; i++) /* {{{ */
 594   {
 595     jobject o_child;
 596
 597     o_child = ctoj_oconfig_item (jvm_env, ci->children + i);
 598     if (o_child == NULL)
 599     {
 600       ERROR ("java plugin: ctoj_oconfig_item: "
 601           "Creating an OConfigItem object failed.");
 602       (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
 603       return (NULL);
 604     }
 605
 606     (*jvm_env)->CallVoidMethod (jvm_env, o_ocitem, m_addchild, o_child);
 607     (*jvm_env)->DeleteLocalRef (jvm_env, o_child);
 608   } /* }}} for (i = 0; i < ci->children_num; i++) */
 609
 610   return (o_ocitem);
 611 } /* }}} jobject ctoj_oconfig_item */
 612
 613 /* Convert a data_set_t to a org/collectd/api/DataSet */
 614 static jobject ctoj_data_set (JNIEnv *jvm_env, const data_set_t *ds) /* {{{ */
 615 {
 616   jclass c_dataset;
 617   jmethodID m_constructor;
 618   jmethodID m_add;
 619   jobject o_type;
 620   jobject o_dataset;
 621   int i;
 622
 623   /* Look up the org/collectd/api/DataSet class */
 624   c_dataset = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/DataSet");
 625   if (c_dataset == NULL)
 626   {
 627     ERROR ("java plugin: ctoj_data_set: Looking up the "
 628         "org/collectd/api/DataSet class failed.");
 629     return (NULL);
 630   }
 631
 632   /* Search for the `DataSet (String type)' constructor. */
 633   m_constructor = (*jvm_env)->GetMethodID (jvm_env,
 634       c_dataset, "<init>", "(Ljava/lang/String;)V");
 635   if (m_constructor == NULL)
 636   {
 637     ERROR ("java plugin: ctoj_data_set: Looking up the "
 638         "`DataSet (String)' constructor failed.");
 639     return (NULL);
 640   }
 641
 642   /* Search for the `void addDataSource (DataSource)' method. */
 643   m_add = (*jvm_env)->GetMethodID (jvm_env,
 644       c_dataset, "addDataSource", "(Lorg/collectd/api/DataSource;)V");
 645   if (m_add == NULL)
 646   {
 647     ERROR ("java plugin: ctoj_data_set: Looking up the "
 648         "`addDataSource (DataSource)' method failed.");
 649     return (NULL);
 650   }
 651
 652   o_type = (*jvm_env)->NewStringUTF (jvm_env, ds->type);
 653   if (o_type == NULL)
 654   {
 655     ERROR ("java plugin: ctoj_data_set: Creating a String object failed.");
 656     return (NULL);
 657   }
 658
 659   o_dataset = (*jvm_env)->NewObject (jvm_env,
 660       c_dataset, m_constructor, o_type);
 661   if (o_dataset == NULL)
 662   {
 663     ERROR ("java plugin: ctoj_data_set: Creating a DataSet object failed.");
 664     (*jvm_env)->DeleteLocalRef (jvm_env, o_type);
 665     return (NULL);
 666   }
 667
 668   /* Decrease reference counter on the java.lang.String object. */
 669   (*jvm_env)->DeleteLocalRef (jvm_env, o_type);
 670
 671   for (i = 0; i < ds->ds_num; i++)
 672   {
 673     jobject o_datasource;
 674
 675     o_datasource = ctoj_data_source (jvm_env, ds->ds + i);
 676     if (o_datasource == NULL)
 677     {
 678       ERROR ("java plugin: ctoj_data_set: ctoj_data_source (%s.%s) failed",
 679           ds->type, ds->ds[i].name);
 680       (*jvm_env)->DeleteLocalRef (jvm_env, o_dataset);
 681       return (NULL);
 682     }
 683
 684     (*jvm_env)->CallVoidMethod (jvm_env, o_dataset, m_add, o_datasource);
 685
 686     (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
 687   } /* for (i = 0; i < ds->ds_num; i++) */
 688
 689   return (o_dataset);
 690 } /* }}} jobject ctoj_data_set */
 691
 692 static int ctoj_value_list_add_value (JNIEnv *jvm_env, /* {{{ */
 693     value_t value, int ds_type,
 694     jclass class_ptr, jobject object_ptr)
 695 {
 696   jmethodID m_addvalue;
 697   jobject o_number;
 698
 699   m_addvalue = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
 700       "addValue", "(Ljava/lang/Number;)V");
 701   if (m_addvalue == NULL)
 702   {
 703     ERROR ("java plugin: ctoj_value_list_add_value: "
 704         "Cannot find method `void addValue (Number)'.");
 705     return (-1);
 706   }
 707
 708   o_number = ctoj_value_to_number (jvm_env, value, ds_type);
 709   if (o_number == NULL)
 710   {
 711     ERROR ("java plugin: ctoj_value_list_add_value: "
 712         "ctoj_value_to_number failed.");
 713     return (-1);
 714   }
 715
 716   (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_addvalue, o_number);
 717
 718   (*jvm_env)->DeleteLocalRef (jvm_env, o_number);
 719
 720   return (0);
 721 } /* }}} int ctoj_value_list_add_value */
 722
 723 static int ctoj_value_list_add_data_set (JNIEnv *jvm_env, /* {{{ */
 724     jclass c_valuelist, jobject o_valuelist, const data_set_t *ds)
 725 {
 726   jmethodID m_setdataset;
 727   jobject o_dataset;
 728
 729   /* Look for the `void setDataSource (List<DataSource> ds)' method. */
 730   m_setdataset = (*jvm_env)->GetMethodID (jvm_env, c_valuelist,
 731       "setDataSet", "(Lorg/collectd/api/DataSet;)V");
 732   if (m_setdataset == NULL)
 733   {
 734     ERROR ("java plugin: ctoj_value_list_add_data_set: "
 735         "Cannot find the `void setDataSet (DataSet)' method.");
 736     return (-1);
 737   }
 738
 739   /* Create a DataSet object. */
 740   o_dataset = ctoj_data_set (jvm_env, ds);
 741   if (o_dataset == NULL)
 742   {
 743     ERROR ("java plugin: ctoj_value_list_add_data_set: "
 744         "ctoj_data_set (%s) failed.", ds->type);
 745     return (-1);
 746   }
 747
 748   /* Actually call the method. */
 749   (*jvm_env)->CallVoidMethod (jvm_env,
 750       o_valuelist, m_setdataset, o_dataset);
 751
 752   /* Decrease reference counter on the List<DataSource> object. */
 753   (*jvm_env)->DeleteLocalRef (jvm_env, o_dataset);
 754
 755   return (0);
 756 } /* }}} int ctoj_value_list_add_data_set */
 757
 758 /* Convert a value_list_t (and data_set_t) to a org/collectd/api/ValueList */
 759 static jobject ctoj_value_list (JNIEnv *jvm_env, /* {{{ */
 760     const data_set_t *ds, const value_list_t *vl)
 761 {
 762   jclass c_valuelist;
 763   jmethodID m_valuelist_constructor;
 764   jobject o_valuelist;
 765   int status;
 766   int i;
 767
 768   /* First, create a new ValueList instance..
 769    * Look up the class.. */
 770   c_valuelist = (*jvm_env)->FindClass (jvm_env,
 771       "org/collectd/api/ValueList");
 772   if (c_valuelist == NULL)
 773   {
 774     ERROR ("java plugin: ctoj_value_list: "
 775         "FindClass (org/collectd/api/ValueList) failed.");
 776     return (NULL);
 777   }
 778
 779   /* Lookup the `ValueList ()' constructor. */
 780   m_valuelist_constructor = (*jvm_env)->GetMethodID (jvm_env, c_valuelist,
 781       "<init>", "()V");
 782   if (m_valuelist_constructor == NULL)
 783   {
 784     ERROR ("java plugin: ctoj_value_list: Cannot find the "
 785         "`ValueList ()' constructor.");
 786     return (NULL);
 787   }
 788
 789   /* Create a new instance. */
 790   o_valuelist = (*jvm_env)->NewObject (jvm_env, c_valuelist,
 791       m_valuelist_constructor);
 792   if (o_valuelist == NULL)
 793   {
 794     ERROR ("java plugin: ctoj_value_list: Creating a new ValueList instance "
 795         "failed.");
 796     return (NULL);
 797   }
 798
 799   status = ctoj_value_list_add_data_set (jvm_env,
 800       c_valuelist, o_valuelist, ds);
 801   if (status != 0)
 802   {
 803     ERROR ("java plugin: ctoj_value_list: "
 804         "ctoj_value_list_add_data_set failed.");
 805     (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
 806     return (NULL);
 807   }
 808
 809   /* Set the strings.. */
 810 #define SET_STRING(str,method_name) do { \
 811   status = ctoj_string (jvm_env, str, \
 812       c_valuelist, o_valuelist, method_name); \
 813   if (status != 0) { \
 814     ERROR ("java plugin: ctoj_value_list: ctoj_string (%s) failed.", \
 815         method_name); \
 816     (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist); \
 817     return (NULL); \
 818   } } while (0)
 819
 820   SET_STRING (vl->host,            "setHost");
 821   SET_STRING (vl->plugin,          "setPlugin");
 822   SET_STRING (vl->plugin_instance, "setPluginInstance");
 823   SET_STRING (vl->type,            "setType");
 824   SET_STRING (vl->type_instance,   "setTypeInstance");
 825
 826 #undef SET_STRING
 827
 828   /* Set the `time' member. Java stores time in milliseconds. */
 829   status = ctoj_long (jvm_env, (jlong) CDTIME_T_TO_MS (vl->time),
 830       c_valuelist, o_valuelist, "setTime");
 831   if (status != 0)
 832   {
 833     ERROR ("java plugin: ctoj_value_list: ctoj_long (setTime) failed.");
 834     (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
 835     return (NULL);
 836   }
 837
 838   /* Set the `interval' member.. */
 839   status = ctoj_long (jvm_env,
 840       (jlong) CDTIME_T_TO_MS (vl->interval),
 841       c_valuelist, o_valuelist, "setInterval");
 842   if (status != 0)
 843   {
 844     ERROR ("java plugin: ctoj_value_list: ctoj_long (setInterval) failed.");
 845     (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
 846     return (NULL);
 847   }
 848
 849   for (i = 0; i < vl->values_len; i++)
 850   {
 851     status = ctoj_value_list_add_value (jvm_env, vl->values[i], ds->ds[i].type,
 852         c_valuelist, o_valuelist);
 853     if (status != 0)
 854     {
 855       ERROR ("java plugin: ctoj_value_list: "
 856           "ctoj_value_list_add_value failed.");
 857       (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
 858       return (NULL);
 859     }
 860   }
 861
 862   return (o_valuelist);
 863 } /* }}} jobject ctoj_value_list */
 864
 865 /* Convert a notification_t to a org/collectd/api/Notification */
 866 static jobject ctoj_notification (JNIEnv *jvm_env, /* {{{ */
 867     const notification_t *n)
 868 {
 869   jclass c_notification;
 870   jmethodID m_constructor;
 871   jobject o_notification;
 872   int status;
 873
 874   /* First, create a new Notification instance..
 875    * Look up the class.. */
 876   c_notification = (*jvm_env)->FindClass (jvm_env,
 877       "org/collectd/api/Notification");
 878   if (c_notification == NULL)
 879   {
 880     ERROR ("java plugin: ctoj_notification: "
 881         "FindClass (org/collectd/api/Notification) failed.");
 882     return (NULL);
 883   }
 884
 885   /* Lookup the `Notification ()' constructor. */
 886   m_constructor = (*jvm_env)->GetMethodID (jvm_env, c_notification,
 887       "<init>", "()V");
 888   if (m_constructor == NULL)
 889   {
 890     ERROR ("java plugin: ctoj_notification: Cannot find the "
 891         "`Notification ()' constructor.");
 892     return (NULL);
 893   }
 894
 895   /* Create a new instance. */
 896   o_notification = (*jvm_env)->NewObject (jvm_env, c_notification,
 897       m_constructor);
 898   if (o_notification == NULL)
 899   {
 900     ERROR ("java plugin: ctoj_notification: Creating a new Notification "
 901         "instance failed.");
 902     return (NULL);
 903   }
 904
 905   /* Set the strings.. */
 906 #define SET_STRING(str,method_name) do { \
 907   status = ctoj_string (jvm_env, str, \
 908       c_notification, o_notification, method_name); \
 909   if (status != 0) { \
 910     ERROR ("java plugin: ctoj_notification: ctoj_string (%s) failed.", \
 911         method_name); \
 912     (*jvm_env)->DeleteLocalRef (jvm_env, o_notification); \
 913     return (NULL); \
 914   } } while (0)
 915
 916   SET_STRING (n->host,            "setHost");
 917   SET_STRING (n->plugin,          "setPlugin");
 918   SET_STRING (n->plugin_instance, "setPluginInstance");
 919   SET_STRING (n->type,            "setType");
 920   SET_STRING (n->type_instance,   "setTypeInstance");
 921   SET_STRING (n->message,         "setMessage");
 922
 923 #undef SET_STRING
 924
 925   /* Set the `time' member. Java stores time in milliseconds. */
 926   status = ctoj_long (jvm_env, (jlong) CDTIME_T_TO_MS (n->time),
 927       c_notification, o_notification, "setTime");
 928   if (status != 0)
 929   {
 930     ERROR ("java plugin: ctoj_notification: ctoj_long (setTime) failed.");
 931     (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
 932     return (NULL);
 933   }
 934
 935   /* Set the `severity' member.. */
 936   status = ctoj_int (jvm_env, (jint) n->severity,
 937       c_notification, o_notification, "setSeverity");
 938   if (status != 0)
 939   {
 940     ERROR ("java plugin: ctoj_notification: ctoj_int (setSeverity) failed.");
 941     (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
 942     return (NULL);
 943   }
 944
 945   return (o_notification);
 946 } /* }}} jobject ctoj_notification */
 947
 948 /*
 949  * Java to C conversion functions
 950  */
 951 /* Call a `String <method> ()' method. */
 952 static int jtoc_string (JNIEnv *jvm_env, /* {{{ */
 953     char *buffer, size_t buffer_size, int empty_okay,
 954     jclass class_ptr, jobject object_ptr, const char *method_name)
 955 {
 956   jmethodID method_id;
 957   jobject string_obj;
 958   const char *c_str;
 959
 960   method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
 961       method_name, "()Ljava/lang/String;");
 962   if (method_id == NULL)
 963   {
 964     ERROR ("java plugin: jtoc_string: Cannot find method `String %s ()'.",
 965         method_name);
 966     return (-1);
 967   }
 968
 969   string_obj = (*jvm_env)->CallObjectMethod (jvm_env, object_ptr, method_id);
 970   if ((string_obj == NULL) && (empty_okay == 0))
 971   {
 972     ERROR ("java plugin: jtoc_string: CallObjectMethod (%s) failed.",
 973         method_name);
 974     return (-1);
 975   }
 976   else if ((string_obj == NULL) && (empty_okay != 0))
 977   {
 978     memset (buffer, 0, buffer_size);
 979     return (0);
 980   }
 981
 982   c_str = (*jvm_env)->GetStringUTFChars (jvm_env, string_obj, 0);
 983   if (c_str == NULL)
 984   {
 985     ERROR ("java plugin: jtoc_string: GetStringUTFChars failed.");
 986     (*jvm_env)->DeleteLocalRef (jvm_env, string_obj);
 987     return (-1);
 988   }
 989
 990   sstrncpy (buffer, c_str, buffer_size);
 991
 992   (*jvm_env)->ReleaseStringUTFChars (jvm_env, string_obj, c_str);
 993   (*jvm_env)->DeleteLocalRef (jvm_env, string_obj);
 994
 995   return (0);
 996 } /* }}} int jtoc_string */
 997
 998 /* Call an `int <method> ()' method. */
 999 static int jtoc_int (JNIEnv *jvm_env, /* {{{ */
1000     jint *ret_value,
1001     jclass class_ptr, jobject object_ptr, const char *method_name)
1002 {
1003   jmethodID method_id;
1004
1005   method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
1006       method_name, "()I");
1007   if (method_id == NULL)
1008   {
1009     ERROR ("java plugin: jtoc_int: Cannot find method `int %s ()'.",
1010         method_name);
1011     return (-1);
1012   }
1013
1014   *ret_value = (*jvm_env)->CallIntMethod (jvm_env, object_ptr, method_id);
1015
1016   return (0);
1017 } /* }}} int jtoc_int */
1018
1019 /* Call a `long <method> ()' method. */
1020 static int jtoc_long (JNIEnv *jvm_env, /* {{{ */
1021     jlong *ret_value,
1022     jclass class_ptr, jobject object_ptr, const char *method_name)
1023 {
1024   jmethodID method_id;
1025
1026   method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
1027       method_name, "()J");
1028   if (method_id == NULL)
1029   {
1030     ERROR ("java plugin: jtoc_long: Cannot find method `long %s ()'.",
1031         method_name);
1032     return (-1);
1033   }
1034
1035   *ret_value = (*jvm_env)->CallLongMethod (jvm_env, object_ptr, method_id);
1036
1037   return (0);
1038 } /* }}} int jtoc_long */
1039
1040 /* Call a `double <method> ()' method. */
1041 static int jtoc_double (JNIEnv *jvm_env, /* {{{ */
1042     jdouble *ret_value,
1043     jclass class_ptr, jobject object_ptr, const char *method_name)
1044 {
1045   jmethodID method_id;
1046
1047   method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
1048       method_name, "()D");
1049   if (method_id == NULL)
1050   {
1051     ERROR ("java plugin: jtoc_double: Cannot find method `double %s ()'.",
1052         method_name);
1053     return (-1);
1054   }
1055
1056   *ret_value = (*jvm_env)->CallDoubleMethod (jvm_env, object_ptr, method_id);
1057
1058   return (0);
1059 } /* }}} int jtoc_double */
1060
1061 static int jtoc_value (JNIEnv *jvm_env, /* {{{ */
1062     value_t *ret_value, int ds_type, jobject object_ptr)
1063 {
1064   jclass class_ptr;
1065   int status;
1066
1067   class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
1068
1069   if (ds_type == DS_TYPE_GAUGE)
1070   {
1071     jdouble tmp_double;
1072
1073     status = jtoc_double (jvm_env, &tmp_double,
1074         class_ptr, object_ptr, "doubleValue");
1075     if (status != 0)
1076     {
1077       ERROR ("java plugin: jtoc_value: "
1078           "jtoc_double failed.");
1079       return (-1);
1080     }
1081     (*ret_value).gauge = (gauge_t) tmp_double;
1082   }
1083   else
1084   {
1085     jlong tmp_long;
1086
1087     status = jtoc_long (jvm_env, &tmp_long,
1088         class_ptr, object_ptr, "longValue");
1089     if (status != 0)
1090     {
1091       ERROR ("java plugin: jtoc_value: "
1092           "jtoc_long failed.");
1093       return (-1);
1094     }
1095
1096     if (ds_type == DS_TYPE_DERIVE)
1097       (*ret_value).derive = (derive_t) tmp_long;
1098     else if (ds_type == DS_TYPE_ABSOLUTE)
1099       (*ret_value).absolute = (absolute_t) tmp_long;
1100     else
1101       (*ret_value).counter = (counter_t) tmp_long;
1102   }
1103
1104   return (0);
1105 } /* }}} int jtoc_value */
1106
1107 /* Read a List<Number>, convert it to `value_t' and add it to the given
1108  * `value_list_t'. */
1109 static int jtoc_values_array (JNIEnv *jvm_env, /* {{{ */
1110     const data_set_t *ds, value_list_t *vl,
1111     jclass class_ptr, jobject object_ptr)
1112 {
1113   jmethodID m_getvalues;
1114   jmethodID m_toarray;
1115   jobject o_list;
1116   jobjectArray o_number_array;
1117
1118   value_t *values;
1119   int values_num;
1120   int i;
1121
1122   values_num = ds->ds_num;
1123
1124   values = NULL;
1125   o_number_array = NULL;
1126   o_list = NULL;
1127
1128 #define BAIL_OUT(status) \
1129   free (values); \
1130   if (o_number_array != NULL) \
1131     (*jvm_env)->DeleteLocalRef (jvm_env, o_number_array); \
1132   if (o_list != NULL) \
1133     (*jvm_env)->DeleteLocalRef (jvm_env, o_list); \
1134   return (status);
1135
1136   /* Call: List<Number> ValueList.getValues () */
1137   m_getvalues = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
1138       "getValues", "()Ljava/util/List;");
1139   if (m_getvalues == NULL)
1140   {
1141     ERROR ("java plugin: jtoc_values_array: "
1142         "Cannot find method `List getValues ()'.");
1143     BAIL_OUT (-1);
1144   }
1145
1146   o_list = (*jvm_env)->CallObjectMethod (jvm_env, object_ptr, m_getvalues);
1147   if (o_list == NULL)
1148   {
1149     ERROR ("java plugin: jtoc_values_array: "
1150         "CallObjectMethod (getValues) failed.");
1151     BAIL_OUT (-1);
1152   }
1153
1154   /* Call: Number[] List.toArray () */
1155   m_toarray = (*jvm_env)->GetMethodID (jvm_env,
1156       (*jvm_env)->GetObjectClass (jvm_env, o_list),
1157       "toArray", "()[Ljava/lang/Object;");
1158   if (m_toarray == NULL)
1159   {
1160     ERROR ("java plugin: jtoc_values_array: "
1161         "Cannot find method `Object[] toArray ()'.");
1162     BAIL_OUT (-1);
1163   }
1164
1165   o_number_array = (*jvm_env)->CallObjectMethod (jvm_env, o_list, m_toarray);
1166   if (o_number_array == NULL)
1167   {
1168     ERROR ("java plugin: jtoc_values_array: "
1169         "CallObjectMethod (toArray) failed.");
1170     BAIL_OUT (-1);
1171   }
1172
1173   values = (value_t *) calloc (values_num, sizeof (value_t));
1174   if (values == NULL)
1175   {
1176     ERROR ("java plugin: jtoc_values_array: calloc failed.");
1177     BAIL_OUT (-1);
1178   }
1179
1180   for (i = 0; i < values_num; i++)
1181   {
1182     jobject o_number;
1183     int status;
1184
1185     o_number = (*jvm_env)->GetObjectArrayElement (jvm_env,
1186         o_number_array, (jsize) i);
1187     if (o_number == NULL)
1188     {
1189       ERROR ("java plugin: jtoc_values_array: "
1190           "GetObjectArrayElement (%i) failed.", i);
1191       BAIL_OUT (-1);
1192     }
1193
1194     status = jtoc_value (jvm_env, values + i, ds->ds[i].type, o_number);
1195     if (status != 0)
1196     {
1197       ERROR ("java plugin: jtoc_values_array: "
1198           "jtoc_value (%i) failed.", i);
1199       BAIL_OUT (-1);
1200     }
1201   } /* for (i = 0; i < values_num; i++) */
1202
1203   vl->values = values;
1204   vl->values_len = values_num;
1205
1206 #undef BAIL_OUT
1207   (*jvm_env)->DeleteLocalRef (jvm_env, o_number_array);
1208   (*jvm_env)->DeleteLocalRef (jvm_env, o_list);
1209   return (0);
1210 } /* }}} int jtoc_values_array */
1211
1212 /* Convert a org/collectd/api/ValueList to a value_list_t. */
1213 static int jtoc_value_list (JNIEnv *jvm_env, value_list_t *vl, /* {{{ */
1214     jobject object_ptr)
1215 {
1216   jclass class_ptr;
1217   int status;
1218   jlong tmp_long;
1219   const data_set_t *ds;
1220
1221   class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
1222   if (class_ptr == NULL)
1223   {
1224     ERROR ("java plugin: jtoc_value_list: GetObjectClass failed.");
1225     return (-1);
1226   }
1227
1228   /* eo == empty okay */
1229 #define SET_STRING(buffer,method, eo) do { \
1230   status = jtoc_string (jvm_env, buffer, sizeof (buffer), eo, \
1231       class_ptr, object_ptr, method); \
1232   if (status != 0) { \
1233     ERROR ("java plugin: jtoc_value_list: jtoc_string (%s) failed.", \
1234         method); \
1235     return (-1); \
1236   } } while (0)
1237
1238   SET_STRING(vl->type, "getType", /* empty = */ 0);
1239
1240   ds = plugin_get_ds (vl->type);
1241   if (ds == NULL)
1242   {
1243     ERROR ("java plugin: jtoc_value_list: Data-set `%s' is not defined. "
1244         "Please consult the types.db(5) manpage for mor information.",
1245         vl->type);
1246     return (-1);
1247   }
1248
1249   SET_STRING(vl->host,            "getHost",           /* empty = */ 0);
1250   SET_STRING(vl->plugin,          "getPlugin",         /* empty = */ 0);
1251   SET_STRING(vl->plugin_instance, "getPluginInstance", /* empty = */ 1);
1252   SET_STRING(vl->type_instance,   "getTypeInstance",   /* empty = */ 1);
1253
1254 #undef SET_STRING
1255
1256   status = jtoc_long (jvm_env, &tmp_long, class_ptr, object_ptr, "getTime");
1257   if (status != 0)
1258   {
1259     ERROR ("java plugin: jtoc_value_list: jtoc_long (getTime) failed.");
1260     return (-1);
1261   }
1262   /* Java measures time in milliseconds. */
1263   vl->time = MS_TO_CDTIME_T (tmp_long);
1264
1265   status = jtoc_long (jvm_env, &tmp_long,
1266       class_ptr, object_ptr, "getInterval");
1267   if (status != 0)
1268   {
1269     ERROR ("java plugin: jtoc_value_list: jtoc_long (getInterval) failed.");
1270     return (-1);
1271   }
1272   vl->interval = MS_TO_CDTIME_T (tmp_long);
1273
1274   status = jtoc_values_array (jvm_env, ds, vl, class_ptr, object_ptr);
1275   if (status != 0)
1276   {
1277     ERROR ("java plugin: jtoc_value_list: jtoc_values_array failed.");
1278     return (-1);
1279   }
1280
1281   return (0);
1282 } /* }}} int jtoc_value_list */
1283
1284 /* Convert a org/collectd/api/Notification to a notification_t. */
1285 static int jtoc_notification (JNIEnv *jvm_env, notification_t *n, /* {{{ */
1286     jobject object_ptr)
1287 {
1288   jclass class_ptr;
1289   int status;
1290   jlong tmp_long;
1291   jint tmp_int;
1292
1293   class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
1294   if (class_ptr == NULL)
1295   {
1296     ERROR ("java plugin: jtoc_notification: GetObjectClass failed.");
1297     return (-1);
1298   }
1299
1300   /* eo == empty okay */
1301 #define SET_STRING(buffer,method, eo) do { \
1302   status = jtoc_string (jvm_env, buffer, sizeof (buffer), eo, \
1303       class_ptr, object_ptr, method); \
1304   if (status != 0) { \
1305     ERROR ("java plugin: jtoc_notification: jtoc_string (%s) failed.", \
1306         method); \
1307     return (-1); \
1308   } } while (0)
1309
1310   SET_STRING (n->host,            "getHost",           /* empty = */ 1);
1311   SET_STRING (n->plugin,          "getPlugin",         /* empty = */ 1);
1312   SET_STRING (n->plugin_instance, "getPluginInstance", /* empty = */ 1);
1313   SET_STRING (n->type,            "getType",           /* empty = */ 1);
1314   SET_STRING (n->type_instance,   "getTypeInstance",   /* empty = */ 1);
1315   SET_STRING (n->message,         "getMessage",        /* empty = */ 0);
1316
1317 #undef SET_STRING
1318
1319   status = jtoc_long (jvm_env, &tmp_long, class_ptr, object_ptr, "getTime");
1320   if (status != 0)
1321   {
1322     ERROR ("java plugin: jtoc_notification: jtoc_long (getTime) failed.");
1323     return (-1);
1324   }
1325   /* Java measures time in milliseconds. */
1326   n->time = MS_TO_CDTIME_T(tmp_long);
1327
1328   status = jtoc_int (jvm_env, &tmp_int,
1329       class_ptr, object_ptr, "getSeverity");
1330   if (status != 0)
1331   {
1332     ERROR ("java plugin: jtoc_notification: jtoc_int (getSeverity) failed.");
1333     return (-1);
1334   }
1335   n->severity = (int) tmp_int;
1336
1337   return (0);
1338 } /* }}} int jtoc_notification */
1339 /*
1340  * Functions accessible from Java
1341  */
1342 static jint JNICALL cjni_api_dispatch_values (JNIEnv *jvm_env, /* {{{ */
1343     jobject this, jobject java_vl)
1344 {
1345   value_list_t vl = VALUE_LIST_INIT;
1346   int status;
1347
1348   DEBUG ("cjni_api_dispatch_values: java_vl = %p;", (void *) java_vl);
1349
1350   status = jtoc_value_list (jvm_env, &vl, java_vl);
1351   if (status != 0)
1352   {
1353     ERROR ("java plugin: cjni_api_dispatch_values: jtoc_value_list failed.");
1354     return (-1);
1355   }
1356
1357   status = plugin_dispatch_values (&vl);
1358
1359   sfree (vl.values);
1360
1361   return (status);
1362 } /* }}} jint cjni_api_dispatch_values */
1363
1364 static jint JNICALL cjni_api_dispatch_notification (JNIEnv *jvm_env, /* {{{ */
1365     jobject this, jobject o_notification)
1366 {
1367   notification_t n;
1368   int status;
1369
1370   memset (&n, 0, sizeof (n));
1371   n.meta = NULL;
1372
1373   status = jtoc_notification (jvm_env, &n, o_notification);
1374   if (status != 0)
1375   {
1376     ERROR ("java plugin: cjni_api_dispatch_notification: jtoc_notification failed.");
1377     return (-1);
1378   }
1379
1380   status = plugin_dispatch_notification (&n);
1381
1382   return (status);
1383 } /* }}} jint cjni_api_dispatch_notification */
1384
1385 static jobject JNICALL cjni_api_get_ds (JNIEnv *jvm_env, /* {{{ */
1386     jobject this, jobject o_string_type)
1387 {
1388   const char *ds_name;
1389   const data_set_t *ds;
1390   jobject o_dataset;
1391
1392   ds_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_string_type, 0);
1393   if (ds_name == NULL)
1394   {
1395     ERROR ("java plugin: cjni_api_get_ds: GetStringUTFChars failed.");
1396     return (NULL);
1397   }
1398
1399   ds = plugin_get_ds (ds_name);
1400   DEBUG ("java plugin: cjni_api_get_ds: "
1401       "plugin_get_ds (%s) = %p;", ds_name, (void *) ds);
1402
1403   (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_string_type, ds_name);
1404
1405   if (ds == NULL)
1406     return (NULL);
1407
1408   o_dataset = ctoj_data_set (jvm_env, ds);
1409   return (o_dataset);
1410 } /* }}} jint cjni_api_get_ds */
1411
1412 static jint JNICALL cjni_api_register_config (JNIEnv *jvm_env, /* {{{ */
1413     jobject this, jobject o_name, jobject o_config)
1414 {
1415   return (cjni_callback_register (jvm_env, o_name, o_config, CB_TYPE_CONFIG));
1416 } /* }}} jint cjni_api_register_config */
1417
1418 static jint JNICALL cjni_api_register_init (JNIEnv *jvm_env, /* {{{ */
1419     jobject this, jobject o_name, jobject o_config)
1420 {
1421   return (cjni_callback_register (jvm_env, o_name, o_config, CB_TYPE_INIT));
1422 } /* }}} jint cjni_api_register_init */
1423
1424 static jint JNICALL cjni_api_register_read (JNIEnv *jvm_env, /* {{{ */
1425     jobject this, jobject o_name, jobject o_read)
1426 {
1427   user_data_t ud;
1428   cjni_callback_info_t *cbi;
1429
1430   cbi = cjni_callback_info_create (jvm_env, o_name, o_read, CB_TYPE_READ);
1431   if (cbi == NULL)
1432     return (-1);
1433
1434   DEBUG ("java plugin: Registering new read callback: %s", cbi->name);
1435
1436   memset (&ud, 0, sizeof (ud));
1437   ud.data = (void *) cbi;
1438   ud.free_func = cjni_callback_info_destroy;
1439
1440   plugin_register_complex_read (/* group = */ NULL, cbi->name, cjni_read,
1441       /* interval = */ NULL, &ud);
1442
1443   (*jvm_env)->DeleteLocalRef (jvm_env, o_read);
1444
1445   return (0);
1446 } /* }}} jint cjni_api_register_read */
1447
1448 static jint JNICALL cjni_api_register_write (JNIEnv *jvm_env, /* {{{ */
1449     jobject this, jobject o_name, jobject o_write)
1450 {
1451   user_data_t ud;
1452   cjni_callback_info_t *cbi;
1453
1454   cbi = cjni_callback_info_create (jvm_env, o_name, o_write, CB_TYPE_WRITE);
1455   if (cbi == NULL)
1456     return (-1);
1457
1458   DEBUG ("java plugin: Registering new write callback: %s", cbi->name);
1459
1460   memset (&ud, 0, sizeof (ud));
1461   ud.data = (void *) cbi;
1462   ud.free_func = cjni_callback_info_destroy;
1463
1464   plugin_register_write (cbi->name, cjni_write, &ud);
1465
1466   (*jvm_env)->DeleteLocalRef (jvm_env, o_write);
1467
1468   return (0);
1469 } /* }}} jint cjni_api_register_write */
1470
1471 static jint JNICALL cjni_api_register_flush (JNIEnv *jvm_env, /* {{{ */
1472     jobject this, jobject o_name, jobject o_flush)
1473 {
1474   user_data_t ud;
1475   cjni_callback_info_t *cbi;
1476
1477   cbi = cjni_callback_info_create (jvm_env, o_name, o_flush, CB_TYPE_FLUSH);
1478   if (cbi == NULL)
1479     return (-1);
1480
1481   DEBUG ("java plugin: Registering new flush callback: %s", cbi->name);
1482
1483   memset (&ud, 0, sizeof (ud));
1484   ud.data = (void *) cbi;
1485   ud.free_func = cjni_callback_info_destroy;
1486
1487   plugin_register_flush (cbi->name, cjni_flush, &ud);
1488
1489   (*jvm_env)->DeleteLocalRef (jvm_env, o_flush);
1490
1491   return (0);
1492 } /* }}} jint cjni_api_register_flush */
1493
1494 static jint JNICALL cjni_api_register_shutdown (JNIEnv *jvm_env, /* {{{ */
1495     jobject this, jobject o_name, jobject o_shutdown)
1496 {
1497   return (cjni_callback_register (jvm_env, o_name, o_shutdown,
1498         CB_TYPE_SHUTDOWN));
1499 } /* }}} jint cjni_api_register_shutdown */
1500
1501 static jint JNICALL cjni_api_register_log (JNIEnv *jvm_env, /* {{{ */
1502     jobject this, jobject o_name, jobject o_log)
1503 {
1504   user_data_t ud;
1505   cjni_callback_info_t *cbi;
1506
1507   cbi = cjni_callback_info_create (jvm_env, o_name, o_log, CB_TYPE_LOG);
1508   if (cbi == NULL)
1509     return (-1);
1510
1511   DEBUG ("java plugin: Registering new log callback: %s", cbi->name);
1512
1513   memset (&ud, 0, sizeof (ud));
1514   ud.data = (void *) cbi;
1515   ud.free_func = cjni_callback_info_destroy;
1516
1517   plugin_register_log (cbi->name, cjni_log, &ud);
1518
1519   (*jvm_env)->DeleteLocalRef (jvm_env, o_log);
1520
1521   return (0);
1522 } /* }}} jint cjni_api_register_log */
1523
1524 static jint JNICALL cjni_api_register_notification (JNIEnv *jvm_env, /* {{{ */
1525     jobject this, jobject o_name, jobject o_notification)
1526 {
1527   user_data_t ud;
1528   cjni_callback_info_t *cbi;
1529
1530   cbi = cjni_callback_info_create (jvm_env, o_name, o_notification,
1531       CB_TYPE_NOTIFICATION);
1532   if (cbi == NULL)
1533     return (-1);
1534
1535   DEBUG ("java plugin: Registering new notification callback: %s", cbi->name);
1536
1537   memset (&ud, 0, sizeof (ud));
1538   ud.data = (void *) cbi;
1539   ud.free_func = cjni_callback_info_destroy;
1540
1541   plugin_register_notification (cbi->name, cjni_notification, &ud);
1542
1543   (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
1544
1545   return (0);
1546 } /* }}} jint cjni_api_register_notification */
1547
1548 static jint JNICALL cjni_api_register_match_target (JNIEnv *jvm_env, /* {{{ */
1549     jobject this, jobject o_name, jobject o_match, int type)
1550 {
1551   int status;
1552   const char *c_name;
1553
1554   c_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_name, 0);
1555   if (c_name == NULL)
1556   {
1557     ERROR ("java plugin: cjni_api_register_match_target: "
1558         "GetStringUTFChars failed.");
1559     return (-1);
1560   }
1561
1562   status = cjni_callback_register (jvm_env, o_name, o_match, type);
1563   if (status != 0)
1564   {
1565     (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
1566     return (-1);
1567   }
1568
1569   if (type == CB_TYPE_MATCH)
1570   {
1571     match_proc_t m_proc;
1572
1573     memset (&m_proc, 0, sizeof (m_proc));
1574     m_proc.create  = cjni_match_target_create;
1575     m_proc.destroy = cjni_match_target_destroy;
1576     m_proc.match   = (void *) cjni_match_target_invoke;
1577
1578     status = fc_register_match (c_name, m_proc);
1579   }
1580   else if (type == CB_TYPE_TARGET)
1581   {
1582     target_proc_t t_proc;
1583
1584     memset (&t_proc, 0, sizeof (t_proc));
1585     t_proc.create  = cjni_match_target_create;
1586     t_proc.destroy = cjni_match_target_destroy;
1587     t_proc.invoke  = cjni_match_target_invoke;
1588
1589     status = fc_register_target (c_name, t_proc);
1590   }
1591   else
1592   {
1593     ERROR ("java plugin: cjni_api_register_match_target: "
1594         "Don't know whether to create a match or a target.");
1595     (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
1596     return (-1);
1597   }
1598
1599   if (status != 0)
1600   {
1601     ERROR ("java plugin: cjni_api_register_match_target: "
1602         "%s failed.",
1603         (type == CB_TYPE_MATCH) ? "fc_register_match" : "fc_register_target");
1604     (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
1605     return (-1);
1606   }
1607
1608   (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
1609
1610   return (0);
1611 } /* }}} jint cjni_api_register_match_target */
1612
1613 static jint JNICALL cjni_api_register_match (JNIEnv *jvm_env, /* {{{ */
1614     jobject this, jobject o_name, jobject o_match)
1615 {
1616   return (cjni_api_register_match_target (jvm_env, this, o_name, o_match,
1617         CB_TYPE_MATCH));
1618 } /* }}} jint cjni_api_register_match */
1619
1620 static jint JNICALL cjni_api_register_target (JNIEnv *jvm_env, /* {{{ */
1621     jobject this, jobject o_name, jobject o_target)
1622 {
1623   return (cjni_api_register_match_target (jvm_env, this, o_name, o_target,
1624         CB_TYPE_TARGET));
1625 } /* }}} jint cjni_api_register_target */
1626
1627 static void JNICALL cjni_api_log (JNIEnv *jvm_env, /* {{{ */
1628     jobject this, jint severity, jobject o_message)
1629 {
1630   const char *c_str;
1631
1632   c_str = (*jvm_env)->GetStringUTFChars (jvm_env, o_message, 0);
1633   if (c_str == NULL)
1634   {
1635     ERROR ("java plugin: cjni_api_log: GetStringUTFChars failed.");
1636     return;
1637   }
1638
1639   if (severity < LOG_ERR)
1640     severity = LOG_ERR;
1641   if (severity > LOG_DEBUG)
1642     severity = LOG_DEBUG;
1643
1644   plugin_log (severity, "%s", c_str);
1645
1646   (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_message, c_str);
1647 } /* }}} void cjni_api_log */
1648
1649 static jstring JNICALL cjni_api_get_hostname (JNIEnv *jvm_env, jobject this)
1650 {
1651     return ctoj_output_string(jvm_env, hostname_g);
1652 }
1653
1654 /* List of ``native'' functions, i. e. C-functions that can be called from
1655  * Java. */
1656 static JNINativeMethod jni_api_functions[] = /* {{{ */
1657 {
1658   { "dispatchValues",
1659     "(Lorg/collectd/api/ValueList;)I",
1660     cjni_api_dispatch_values },
1661
1662   { "dispatchNotification",
1663     "(Lorg/collectd/api/Notification;)I",
1664     cjni_api_dispatch_notification },
1665
1666   { "getDS",
1667     "(Ljava/lang/String;)Lorg/collectd/api/DataSet;",
1668     cjni_api_get_ds },
1669
1670   { "registerConfig",
1671     "(Ljava/lang/String;Lorg/collectd/api/CollectdConfigInterface;)I",
1672     cjni_api_register_config },
1673
1674   { "registerInit",
1675     "(Ljava/lang/String;Lorg/collectd/api/CollectdInitInterface;)I",
1676     cjni_api_register_init },
1677
1678   { "registerRead",
1679     "(Ljava/lang/String;Lorg/collectd/api/CollectdReadInterface;)I",
1680     cjni_api_register_read },
1681
1682   { "registerWrite",
1683     "(Ljava/lang/String;Lorg/collectd/api/CollectdWriteInterface;)I",
1684     cjni_api_register_write },
1685
1686   { "registerFlush",
1687     "(Ljava/lang/String;Lorg/collectd/api/CollectdFlushInterface;)I",
1688     cjni_api_register_flush },
1689
1690   { "registerShutdown",
1691     "(Ljava/lang/String;Lorg/collectd/api/CollectdShutdownInterface;)I",
1692     cjni_api_register_shutdown },
1693
1694   { "registerLog",
1695     "(Ljava/lang/String;Lorg/collectd/api/CollectdLogInterface;)I",
1696     cjni_api_register_log },
1697
1698   { "registerNotification",
1699     "(Ljava/lang/String;Lorg/collectd/api/CollectdNotificationInterface;)I",
1700     cjni_api_register_notification },
1701
1702   { "registerMatch",
1703     "(Ljava/lang/String;Lorg/collectd/api/CollectdMatchFactoryInterface;)I",
1704     cjni_api_register_match },
1705
1706   { "registerTarget",
1707     "(Ljava/lang/String;Lorg/collectd/api/CollectdTargetFactoryInterface;)I",
1708     cjni_api_register_target },
1709
1710   { "log",
1711     "(ILjava/lang/String;)V",
1712     cjni_api_log },
1713
1714   { "getHostname",
1715     "()Ljava/lang/String;",
1716     cjni_api_get_hostname },
1717
1718 };
1719 static size_t jni_api_functions_num = sizeof (jni_api_functions)
1720   / sizeof (jni_api_functions[0]);
1721 /* }}} */
1722
1723 /*
1724  * Functions
1725  */
1726 /* Allocate a `cjni_callback_info_t' given the type and objects necessary for
1727  * all registration functions. */
1728 static cjni_callback_info_t *cjni_callback_info_create (JNIEnv *jvm_env, /* {{{ */
1729     jobject o_name, jobject o_callback, int type)
1730 {
1731   const char *c_name;
1732   cjni_callback_info_t *cbi;
1733   const char *method_name;
1734   const char *method_signature;
1735
1736   switch (type)
1737   {
1738     case CB_TYPE_CONFIG:
1739       method_name = "config";
1740       method_signature = "(Lorg/collectd/api/OConfigItem;)I";
1741       break;
1742
1743     case CB_TYPE_INIT:
1744       method_name = "init";
1745       method_signature = "()I";
1746       break;
1747
1748     case CB_TYPE_READ:
1749       method_name = "read";
1750       method_signature = "()I";
1751       break;
1752
1753     case CB_TYPE_WRITE:
1754       method_name = "write";
1755       method_signature = "(Lorg/collectd/api/ValueList;)I";
1756       break;
1757
1758     case CB_TYPE_FLUSH:
1759       method_name = "flush";
1760       method_signature = "(Ljava/lang/Number;Ljava/lang/String;)I";
1761       break;
1762
1763     case CB_TYPE_SHUTDOWN:
1764       method_name = "shutdown";
1765       method_signature = "()I";
1766       break;
1767
1768     case CB_TYPE_LOG:
1769       method_name = "log";
1770       method_signature = "(ILjava/lang/String;)V";
1771       break;
1772
1773     case CB_TYPE_NOTIFICATION:
1774       method_name = "notification";
1775       method_signature = "(Lorg/collectd/api/Notification;)I";
1776       break;
1777
1778     case CB_TYPE_MATCH:
1779       method_name = "createMatch";
1780       method_signature = "(Lorg/collectd/api/OConfigItem;)"
1781         "Lorg/collectd/api/CollectdMatchInterface;";
1782       break;
1783
1784     case CB_TYPE_TARGET:
1785       method_name = "createTarget";
1786       method_signature = "(Lorg/collectd/api/OConfigItem;)"
1787         "Lorg/collectd/api/CollectdTargetInterface;";
1788       break;
1789
1790     default:
1791       ERROR ("java plugin: cjni_callback_info_create: Unknown type: %#x",
1792           type);
1793       return (NULL);
1794   }
1795
1796   c_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_name, 0);
1797   if (c_name == NULL)
1798   {
1799     ERROR ("java plugin: cjni_callback_info_create: "
1800         "GetStringUTFChars failed.");
1801     return (NULL);
1802   }
1803
1804   cbi = (cjni_callback_info_t *) malloc (sizeof (*cbi));
1805   if (cbi == NULL)
1806   {
1807     ERROR ("java plugin: cjni_callback_info_create: malloc failed.");
1808     (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
1809     return (NULL);
1810   }
1811   memset (cbi, 0, sizeof (*cbi));
1812   cbi->type = type;
1813
1814   cbi->name = strdup (c_name);
1815   if (cbi->name == NULL)
1816   {
1817     pthread_mutex_unlock (&java_callbacks_lock);
1818     ERROR ("java plugin: cjni_callback_info_create: strdup failed.");
1819     (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
1820     return (NULL);
1821   }
1822
1823   (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
1824
1825   cbi->object = (*jvm_env)->NewGlobalRef (jvm_env, o_callback);
1826   if (cbi->object == NULL)
1827   {
1828     ERROR ("java plugin: cjni_callback_info_create: NewGlobalRef failed.");
1829     free (cbi);
1830     return (NULL);
1831   }
1832
1833   cbi->class  = (*jvm_env)->GetObjectClass (jvm_env, cbi->object);
1834   if (cbi->class == NULL)
1835   {
1836     ERROR ("java plugin: cjni_callback_info_create: GetObjectClass failed.");
1837     free (cbi);
1838     return (NULL);
1839   }
1840
1841   cbi->method = (*jvm_env)->GetMethodID (jvm_env, cbi->class,
1842       method_name, method_signature);
1843   if (cbi->method == NULL)
1844   {
1845     ERROR ("java plugin: cjni_callback_info_create: "
1846         "Cannot find the `%s' method with signature `%s'.",
1847         method_name, method_signature);
1848     free (cbi);
1849     return (NULL);
1850   }
1851
1852   return (cbi);
1853 } /* }}} cjni_callback_info_t cjni_callback_info_create */
1854
1855 /* Allocate a `cjni_callback_info_t' via `cjni_callback_info_create' and add it
1856  * to the global `java_callbacks' variable. This is used for `config', `init',
1857  * and `shutdown' callbacks. */
1858 static int cjni_callback_register (JNIEnv *jvm_env, /* {{{ */
1859     jobject o_name, jobject o_callback, int type)
1860 {
1861   cjni_callback_info_t *cbi;
1862   cjni_callback_info_t *tmp;
1863 #if COLLECT_DEBUG
1864   const char *type_str;
1865 #endif
1866
1867   cbi = cjni_callback_info_create (jvm_env, o_name, o_callback, type);
1868   if (cbi == NULL)
1869     return (-1);
1870
1871 #if COLLECT_DEBUG
1872   switch (type)
1873   {
1874     case CB_TYPE_CONFIG:
1875       type_str = "config";
1876       break;
1877
1878     case CB_TYPE_INIT:
1879       type_str = "init";
1880       break;
1881
1882     case CB_TYPE_SHUTDOWN:
1883       type_str = "shutdown";
1884       break;
1885
1886     case CB_TYPE_MATCH:
1887       type_str = "match";
1888       break;
1889
1890     case CB_TYPE_TARGET:
1891       type_str = "target";
1892       break;
1893
1894     default:
1895       type_str = "<unknown>";
1896   }
1897   DEBUG ("java plugin: Registering new %s callback: %s",
1898       type_str, cbi->name);
1899 #endif
1900
1901   pthread_mutex_lock (&java_callbacks_lock);
1902
1903   tmp = (cjni_callback_info_t *) realloc (java_callbacks,
1904       (java_callbacks_num + 1) * sizeof (*java_callbacks));
1905   if (tmp == NULL)
1906   {
1907     pthread_mutex_unlock (&java_callbacks_lock);
1908     ERROR ("java plugin: cjni_callback_register: realloc failed.");
1909
1910     (*jvm_env)->DeleteGlobalRef (jvm_env, cbi->object);
1911     free (cbi);
1912
1913     return (-1);
1914   }
1915   java_callbacks = tmp;
1916   java_callbacks[java_callbacks_num] = *cbi;
1917   java_callbacks_num++;
1918
1919   pthread_mutex_unlock (&java_callbacks_lock);
1920
1921   free (cbi);
1922   return (0);
1923 } /* }}} int cjni_callback_register */
1924
1925 /* Callback for `pthread_key_create'. It frees the data contained in
1926  * `jvm_env_key' and prints a warning if the reference counter is not zero. */
1927 static void cjni_jvm_env_destroy (void *args) /* {{{ */
1928 {
1929   cjni_jvm_env_t *cjni_env;
1930
1931   if (args == NULL)
1932     return;
1933
1934   cjni_env = (cjni_jvm_env_t *) args;
1935
1936   if (cjni_env->reference_counter > 0)
1937   {
1938     ERROR ("java plugin: cjni_jvm_env_destroy: "
1939         "cjni_env->reference_counter = %i;", cjni_env->reference_counter);
1940   }
1941
1942   if (cjni_env->jvm_env != NULL)
1943   {
1944     ERROR ("java plugin: cjni_jvm_env_destroy: cjni_env->jvm_env = %p;",
1945         (void *) cjni_env->jvm_env);
1946   }
1947
1948   /* The pointer is allocated in `cjni_thread_attach' */
1949   free (cjni_env);
1950 } /* }}} void cjni_jvm_env_destroy */
1951
1952 /* Register ``native'' functions with the JVM. Native functions are C-functions
1953  * that can be called by Java code. */
1954 static int cjni_init_native (JNIEnv *jvm_env) /* {{{ */
1955 {
1956   jclass api_class_ptr;
1957   int status;
1958
1959   api_class_ptr = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/Collectd");
1960   if (api_class_ptr == NULL)
1961   {
1962     ERROR ("cjni_init_native: Cannot find the API class \"org.collectd.api"
1963         ".Collectd\". Please set the correct class path "
1964         "using 'JVMArg \"-Djava.class.path=...\"'.");
1965     return (-1);
1966   }
1967
1968   status = (*jvm_env)->RegisterNatives (jvm_env, api_class_ptr,
1969       jni_api_functions, (jint) jni_api_functions_num);
1970   if (status != 0)
1971   {
1972     ERROR ("cjni_init_native: RegisterNatives failed with status %i.", status);
1973     return (-1);
1974   }
1975
1976   return (0);
1977 } /* }}} int cjni_init_native */
1978
1979 /* Create the JVM. This is called when the first thread tries to access the JVM
1980  * via cjni_thread_attach. */
1981 static int cjni_create_jvm (void) /* {{{ */
1982 {
1983   JNIEnv *jvm_env;
1984   JavaVMInitArgs vm_args;
1985   JavaVMOption vm_options[jvm_argc];
1986
1987   int status;
1988   size_t i;
1989
1990   if (jvm != NULL)
1991     return (0);
1992
1993   status = pthread_key_create (&jvm_env_key, cjni_jvm_env_destroy);
1994   if (status != 0)
1995   {
1996     ERROR ("java plugin: cjni_create_jvm: pthread_key_create failed "
1997         "with status %i.", status);
1998     return (-1);
1999   }
2000
2001   jvm_env = NULL;
2002
2003   memset (&vm_args, 0, sizeof (vm_args));
2004   vm_args.version = JNI_VERSION_1_2;
2005   vm_args.options = vm_options;
2006   vm_args.nOptions = (jint) jvm_argc;
2007
2008   for (i = 0; i < jvm_argc; i++)
2009   {
2010     DEBUG ("java plugin: cjni_create_jvm: jvm_argv[%zu] = %s",
2011         i, jvm_argv[i]);
2012     vm_args.options[i].optionString = jvm_argv[i];
2013   }
2014
2015   status = JNI_CreateJavaVM (&jvm, (void *) &jvm_env, (void *) &vm_args);
2016   if (status != 0)
2017   {
2018     ERROR ("java plugin: cjni_create_jvm: "
2019         "JNI_CreateJavaVM failed with status %i.",
2020         status);
2021     return (-1);
2022   }
2023   assert (jvm != NULL);
2024   assert (jvm_env != NULL);
2025
2026   /* Call RegisterNatives */
2027   status = cjni_init_native (jvm_env);
2028   if (status != 0)
2029   {
2030     ERROR ("java plugin: cjni_create_jvm: cjni_init_native failed.");
2031     return (-1);
2032   }
2033
2034   DEBUG ("java plugin: The JVM has been created.");
2035   return (0);
2036 } /* }}} int cjni_create_jvm */
2037
2038 /* Increase the reference counter to the JVM for this thread. If it was zero,
2039  * attach the JVM first. */
2040 static JNIEnv *cjni_thread_attach (void) /* {{{ */
2041 {
2042   cjni_jvm_env_t *cjni_env;
2043   JNIEnv *jvm_env;
2044
2045   /* If we're the first thread to access the JVM, we'll have to create it
2046    * first.. */
2047   if (jvm == NULL)
2048   {
2049     int status;
2050
2051     status = cjni_create_jvm ();
2052     if (status != 0)
2053     {
2054       ERROR ("java plugin: cjni_thread_attach: cjni_create_jvm failed.");
2055       return (NULL);
2056     }
2057   }
2058   assert (jvm != NULL);
2059
2060   cjni_env = pthread_getspecific (jvm_env_key);
2061   if (cjni_env == NULL)
2062   {
2063     /* This pointer is free'd in `cjni_jvm_env_destroy'. */
2064     cjni_env = (cjni_jvm_env_t *) malloc (sizeof (*cjni_env));
2065     if (cjni_env == NULL)
2066     {
2067       ERROR ("java plugin: cjni_thread_attach: malloc failed.");
2068       return (NULL);
2069     }
2070     memset (cjni_env, 0, sizeof (*cjni_env));
2071     cjni_env->reference_counter = 0;
2072     cjni_env->jvm_env = NULL;
2073
2074     pthread_setspecific (jvm_env_key, cjni_env);
2075   }
2076
2077   if (cjni_env->reference_counter > 0)
2078   {
2079     cjni_env->reference_counter++;
2080     jvm_env = cjni_env->jvm_env;
2081   }
2082   else
2083   {
2084     int status;
2085     JavaVMAttachArgs args;
2086
2087     assert (cjni_env->jvm_env == NULL);
2088
2089     memset (&args, 0, sizeof (args));
2090     args.version = JNI_VERSION_1_2;
2091
2092     status = (*jvm)->AttachCurrentThread (jvm, (void *) &jvm_env, (void *) &args);
2093     if (status != 0)
2094     {
2095       ERROR ("java plugin: cjni_thread_attach: AttachCurrentThread failed "
2096           "with status %i.", status);
2097       return (NULL);
2098     }
2099
2100     cjni_env->reference_counter = 1;
2101     cjni_env->jvm_env = jvm_env;
2102   }
2103
2104   DEBUG ("java plugin: cjni_thread_attach: cjni_env->reference_counter = %i",
2105       cjni_env->reference_counter);
2106   assert (jvm_env != NULL);
2107   return (jvm_env);
2108 } /* }}} JNIEnv *cjni_thread_attach */
2109
2110 /* Decrease the reference counter of this thread. If it reaches zero, detach
2111  * from the JVM. */
2112 static int cjni_thread_detach (void) /* {{{ */
2113 {
2114   cjni_jvm_env_t *cjni_env;
2115   int status;
2116
2117   cjni_env = pthread_getspecific (jvm_env_key);
2118   if (cjni_env == NULL)
2119   {
2120     ERROR ("java plugin: cjni_thread_detach: pthread_getspecific failed.");
2121     return (-1);
2122   }
2123
2124   assert (cjni_env->reference_counter > 0);
2125   assert (cjni_env->jvm_env != NULL);
2126
2127   cjni_env->reference_counter--;
2128   DEBUG ("java plugin: cjni_thread_detach: cjni_env->reference_counter = %i",
2129       cjni_env->reference_counter);
2130
2131   if (cjni_env->reference_counter > 0)
2132     return (0);
2133
2134   status = (*jvm)->DetachCurrentThread (jvm);
2135   if (status != 0)
2136   {
2137     ERROR ("java plugin: cjni_thread_detach: DetachCurrentThread failed "
2138         "with status %i.", status);
2139   }
2140
2141   cjni_env->reference_counter = 0;
2142   cjni_env->jvm_env = NULL;
2143
2144   return (0);
2145 } /* }}} JNIEnv *cjni_thread_attach */
2146
2147 static int cjni_config_add_jvm_arg (oconfig_item_t *ci) /* {{{ */
2148 {
2149   char **tmp;
2150
2151   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
2152   {
2153     WARNING ("java plugin: `JVMArg' needs exactly one string argument.");
2154     return (-1);
2155   }
2156
2157   if (jvm != NULL)
2158   {
2159     ERROR ("java plugin: All `JVMArg' options MUST appear before all "
2160         "`LoadPlugin' options! The JVM is already started and I have to "
2161         "ignore this argument: %s",
2162         ci->values[0].value.string);
2163     return (-1);
2164   }
2165
2166   tmp = (char **) realloc (jvm_argv, sizeof (char *) * (jvm_argc + 1));
2167   if (tmp == NULL)
2168   {
2169     ERROR ("java plugin: realloc failed.");
2170     return (-1);
2171   }
2172   jvm_argv = tmp;
2173
2174   jvm_argv[jvm_argc] = strdup (ci->values[0].value.string);
2175   if (jvm_argv[jvm_argc] == NULL)
2176   {
2177     ERROR ("java plugin: strdup failed.");
2178     return (-1);
2179   }
2180   jvm_argc++;
2181
2182   return (0);
2183 } /* }}} int cjni_config_add_jvm_arg */
2184
2185 static int cjni_config_load_plugin (oconfig_item_t *ci) /* {{{ */
2186 {
2187   JNIEnv *jvm_env;
2188   java_plugin_class_t *class;
2189   jmethodID constructor_id;
2190   jobject tmp_object;
2191
2192   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
2193   {
2194     WARNING ("java plugin: `LoadPlugin' needs exactly one string argument.");
2195     return (-1);
2196   }
2197
2198   jvm_env = cjni_thread_attach ();
2199   if (jvm_env == NULL)
2200     return (-1);
2201
2202   class = (java_plugin_class_t *) realloc (java_classes_list,
2203       (java_classes_list_len + 1) * sizeof (*java_classes_list));
2204   if (class == NULL)
2205   {
2206     ERROR ("java plugin: realloc failed.");
2207     cjni_thread_detach ();
2208     return (-1);
2209   }
2210   java_classes_list = class;
2211   class = java_classes_list + java_classes_list_len;
2212
2213   memset (class, 0, sizeof (*class));
2214   class->name = strdup (ci->values[0].value.string);
2215   if (class->name == NULL)
2216   {
2217     ERROR ("java plugin: strdup failed.");
2218     cjni_thread_detach ();
2219     return (-1);
2220   }
2221   class->class = NULL;
2222   class->object = NULL;
2223
2224   { /* Replace all dots ('.') with slashes ('/'). Dots are usually used
2225        thorough the Java community, but (Sun's) `FindClass' and friends need
2226        slashes. */
2227     size_t i;
2228     for (i = 0; class->name[i] != 0; i++)
2229       if (class->name[i] == '.')
2230         class->name[i] = '/';
2231   }
2232
2233   DEBUG ("java plugin: Loading class %s", class->name);
2234
2235   class->class = (*jvm_env)->FindClass (jvm_env, class->name);
2236   if (class->class == NULL)
2237   {
2238     ERROR ("java plugin: cjni_config_load_plugin: FindClass (%s) failed.",
2239         class->name);
2240     cjni_thread_detach ();
2241     free (class->name);
2242     return (-1);
2243   }
2244
2245   constructor_id = (*jvm_env)->GetMethodID (jvm_env, class->class,
2246       "<init>", "()V");
2247   if (constructor_id == NULL)
2248   {
2249     ERROR ("java plugin: cjni_config_load_plugin: "
2250         "Could not find the constructor for `%s'.",
2251         class->name);
2252     cjni_thread_detach ();
2253     free (class->name);
2254     return (-1);
2255   }
2256
2257   tmp_object = (*jvm_env)->NewObject (jvm_env, class->class,
2258       constructor_id);
2259   if (tmp_object != NULL)
2260     class->object = (*jvm_env)->NewGlobalRef (jvm_env, tmp_object);
2261   else
2262     class->object = NULL;
2263   if (class->object == NULL)
2264   {
2265     ERROR ("java plugin: cjni_config_load_plugin: "
2266         "Could create a new `%s' object.",
2267         class->name);
2268     cjni_thread_detach ();
2269     free (class->name);
2270     return (-1);
2271   }
2272
2273   cjni_thread_detach ();
2274
2275   java_classes_list_len++;
2276
2277   return (0);
2278 } /* }}} int cjni_config_load_plugin */
2279
2280 static int cjni_config_plugin_block (oconfig_item_t *ci) /* {{{ */
2281 {
2282   JNIEnv *jvm_env;
2283   cjni_callback_info_t *cbi;
2284   jobject o_ocitem;
2285   const char *name;
2286   size_t i;
2287
2288   jclass class;
2289   jmethodID method;
2290
2291   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
2292   {
2293     WARNING ("java plugin: `Plugin' blocks "
2294         "need exactly one string argument.");
2295     return (-1);
2296   }
2297
2298   name = ci->values[0].value.string;
2299
2300   cbi = NULL;
2301   for (i = 0; i < java_callbacks_num; i++)
2302   {
2303     if (java_callbacks[i].type != CB_TYPE_CONFIG)
2304       continue;
2305
2306     if (strcmp (name, java_callbacks[i].name) != 0)
2307       continue;
2308
2309     cbi = java_callbacks + i;
2310     break;
2311   }
2312
2313   if (cbi == NULL)
2314   {
2315     NOTICE ("java plugin: Configuration block for `%s' found, but no such "
2316         "configuration callback has been registered. Please make sure, the "
2317         "`LoadPlugin' lines precede the `Plugin' blocks.",
2318         name);
2319     return (0);
2320   }
2321
2322   DEBUG ("java plugin: Configuring %s", name);
2323
2324   jvm_env = cjni_thread_attach ();
2325   if (jvm_env == NULL)
2326     return (-1);
2327
2328   o_ocitem = ctoj_oconfig_item (jvm_env, ci);
2329   if (o_ocitem == NULL)
2330   {
2331     ERROR ("java plugin: cjni_config_plugin_block: ctoj_oconfig_item failed.");
2332     cjni_thread_detach ();
2333     return (-1);
2334   }
2335
2336   class = (*jvm_env)->GetObjectClass (jvm_env, cbi->object);
2337   method = (*jvm_env)->GetMethodID (jvm_env, class,
2338       "config", "(Lorg/collectd/api/OConfigItem;)I");
2339
2340   (*jvm_env)->CallIntMethod (jvm_env,
2341       cbi->object, method, o_ocitem);
2342
2343   (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
2344   cjni_thread_detach ();
2345   return (0);
2346 } /* }}} int cjni_config_plugin_block */
2347
2348 static int cjni_config_perform (oconfig_item_t *ci) /* {{{ */
2349 {
2350   int success;
2351   int errors;
2352   int status;
2353   int i;
2354
2355   success = 0;
2356   errors = 0;
2357
2358   for (i = 0; i < ci->children_num; i++)
2359   {
2360     oconfig_item_t *child = ci->children + i;
2361
2362     if (strcasecmp ("JVMArg", child->key) == 0)
2363     {
2364       status = cjni_config_add_jvm_arg (child);
2365       if (status == 0)
2366         success++;
2367       else
2368         errors++;
2369     }
2370     else if (strcasecmp ("LoadPlugin", child->key) == 0)
2371     {
2372       status = cjni_config_load_plugin (child);
2373       if (status == 0)
2374         success++;
2375       else
2376         errors++;
2377     }
2378     else if (strcasecmp ("Plugin", child->key) == 0)
2379     {
2380       status = cjni_config_plugin_block (child);
2381       if (status == 0)
2382         success++;
2383       else
2384         errors++;
2385     }
2386     else
2387     {
2388       WARNING ("java plugin: Option `%s' not allowed here.", child->key);
2389       errors++;
2390     }
2391   }
2392
2393   DEBUG ("java plugin: jvm_argc = %zu;", jvm_argc);
2394   DEBUG ("java plugin: java_classes_list_len = %zu;", java_classes_list_len);
2395
2396   if ((success == 0) && (errors > 0))
2397   {
2398     ERROR ("java plugin: All statements failed.");
2399     return (-1);
2400   }
2401
2402   return (0);
2403 } /* }}} int cjni_config_perform */
2404
2405 /* Copy the children of `ci' to the global `config_block' variable. */
2406 static int cjni_config_callback (oconfig_item_t *ci) /* {{{ */
2407 {
2408   oconfig_item_t *ci_copy;
2409   oconfig_item_t *tmp;
2410
2411   assert (ci != NULL);
2412   if (ci->children_num == 0)
2413     return (0); /* nothing to do */
2414
2415   ci_copy = oconfig_clone (ci);
2416   if (ci_copy == NULL)
2417   {
2418     ERROR ("java plugin: oconfig_clone failed.");
2419     return (-1);
2420   }
2421
2422   if (config_block == NULL)
2423   {
2424     config_block = ci_copy;
2425     return (0);
2426   }
2427
2428   tmp = realloc (config_block->children,
2429       (config_block->children_num + ci_copy->children_num) * sizeof (*tmp));
2430   if (tmp == NULL)
2431   {
2432     ERROR ("java plugin: realloc failed.");
2433     oconfig_free (ci_copy);
2434     return (-1);
2435   }
2436   config_block->children = tmp;
2437
2438   /* Copy the pointers */
2439   memcpy (config_block->children + config_block->children_num,
2440       ci_copy->children,
2441       ci_copy->children_num * sizeof (*ci_copy->children));
2442   config_block->children_num += ci_copy->children_num;
2443
2444   /* Delete the pointers from the copy, so `oconfig_free' can't free them. */
2445   memset (ci_copy->children, 0,
2446       ci_copy->children_num * sizeof (*ci_copy->children));
2447   ci_copy->children_num = 0;
2448
2449   oconfig_free (ci_copy);
2450
2451   return (0);
2452 } /* }}} int cjni_config_callback */
2453
2454 /* Free the data contained in the `user_data_t' pointer passed to `cjni_read'
2455  * and `cjni_write'. In particular, delete the global reference to the Java
2456  * object. */
2457 static void cjni_callback_info_destroy (void *arg) /* {{{ */
2458 {
2459   JNIEnv *jvm_env;
2460   cjni_callback_info_t *cbi;
2461
2462   DEBUG ("java plugin: cjni_callback_info_destroy (arg = %p);", arg);
2463
2464   cbi = (cjni_callback_info_t *) arg;
2465
2466   /* This condition can occur when shutting down. */
2467   if (jvm == NULL)
2468   {
2469     sfree (cbi);
2470     return;
2471   }
2472
2473   if (arg == NULL)
2474     return;
2475
2476   jvm_env = cjni_thread_attach ();
2477   if (jvm_env == NULL)
2478   {
2479     ERROR ("java plugin: cjni_callback_info_destroy: cjni_thread_attach failed.");
2480     return;
2481   }
2482
2483   (*jvm_env)->DeleteGlobalRef (jvm_env, cbi->object);
2484
2485   cbi->method = NULL;
2486   cbi->object = NULL;
2487   cbi->class  = NULL;
2488   free (cbi);
2489
2490   cjni_thread_detach ();
2491 } /* }}} void cjni_callback_info_destroy */
2492
2493 /* Call the CB_TYPE_READ callback pointed to by the `user_data_t' pointer. */
2494 static int cjni_read (user_data_t *ud) /* {{{ */
2495 {
2496   JNIEnv *jvm_env;
2497   cjni_callback_info_t *cbi;
2498   int status;
2499   int ret_status;
2500
2501   if (jvm == NULL)
2502   {
2503     ERROR ("java plugin: cjni_read: jvm == NULL");
2504     return (-1);
2505   }
2506
2507   if ((ud == NULL) || (ud->data == NULL))
2508   {
2509     ERROR ("java plugin: cjni_read: Invalid user data.");
2510     return (-1);
2511   }
2512
2513   jvm_env = cjni_thread_attach ();
2514   if (jvm_env == NULL)
2515     return (-1);
2516
2517   cbi = (cjni_callback_info_t *) ud->data;
2518
2519   ret_status = (*jvm_env)->CallIntMethod (jvm_env, cbi->object,
2520       cbi->method);
2521
2522   status = cjni_thread_detach ();
2523   if (status != 0)
2524   {
2525     ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
2526     return (-1);
2527   }
2528
2529   return (ret_status);
2530 } /* }}} int cjni_read */
2531
2532 /* Call the CB_TYPE_WRITE callback pointed to by the `user_data_t' pointer. */
2533 static int cjni_write (const data_set_t *ds, const value_list_t *vl, /* {{{ */
2534     user_data_t *ud)
2535 {
2536   JNIEnv *jvm_env;
2537   cjni_callback_info_t *cbi;
2538   jobject vl_java;
2539   int status;
2540   int ret_status;
2541
2542   if (jvm == NULL)
2543   {
2544     ERROR ("java plugin: cjni_write: jvm == NULL");
2545     return (-1);
2546   }
2547
2548   if ((ud == NULL) || (ud->data == NULL))
2549   {
2550     ERROR ("java plugin: cjni_write: Invalid user data.");
2551     return (-1);
2552   }
2553
2554   jvm_env = cjni_thread_attach ();
2555   if (jvm_env == NULL)
2556     return (-1);
2557
2558   cbi = (cjni_callback_info_t *) ud->data;
2559
2560   vl_java = ctoj_value_list (jvm_env, ds, vl);
2561   if (vl_java == NULL)
2562   {
2563     ERROR ("java plugin: cjni_write: ctoj_value_list failed.");
2564     return (-1);
2565   }
2566
2567   ret_status = (*jvm_env)->CallIntMethod (jvm_env,
2568       cbi->object, cbi->method, vl_java);
2569
2570   (*jvm_env)->DeleteLocalRef (jvm_env, vl_java);
2571
2572   status = cjni_thread_detach ();
2573   if (status != 0)
2574   {
2575     ERROR ("java plugin: cjni_write: cjni_thread_detach failed.");
2576     return (-1);
2577   }
2578
2579   return (ret_status);
2580 } /* }}} int cjni_write */
2581
2582 /* Call the CB_TYPE_FLUSH callback pointed to by the `user_data_t' pointer. */
2583 static int cjni_flush (cdtime_t timeout, const char *identifier, /* {{{ */
2584     user_data_t *ud)
2585 {
2586   JNIEnv *jvm_env;
2587   cjni_callback_info_t *cbi;
2588   jobject o_timeout;
2589   jobject o_identifier;
2590   int status;
2591   int ret_status;
2592
2593   if (jvm == NULL)
2594   {
2595     ERROR ("java plugin: cjni_flush: jvm == NULL");
2596     return (-1);
2597   }
2598
2599   if ((ud == NULL) || (ud->data == NULL))
2600   {
2601     ERROR ("java plugin: cjni_flush: Invalid user data.");
2602     return (-1);
2603   }
2604
2605   jvm_env = cjni_thread_attach ();
2606   if (jvm_env == NULL)
2607     return (-1);
2608
2609   cbi = (cjni_callback_info_t *) ud->data;
2610
2611   o_timeout = ctoj_jdouble_to_number (jvm_env,
2612       (jdouble) CDTIME_T_TO_DOUBLE (timeout));
2613   if (o_timeout == NULL)
2614   {
2615     ERROR ("java plugin: cjni_flush: Converting double "
2616         "to Number object failed.");
2617     return (-1);
2618   }
2619
2620   o_identifier = NULL;
2621   if (identifier != NULL)
2622   {
2623     o_identifier = (*jvm_env)->NewStringUTF (jvm_env, identifier);
2624     if (o_identifier == NULL)
2625     {
2626       (*jvm_env)->DeleteLocalRef (jvm_env, o_timeout);
2627       ERROR ("java plugin: cjni_flush: NewStringUTF failed.");
2628       return (-1);
2629     }
2630   }
2631
2632   ret_status = (*jvm_env)->CallIntMethod (jvm_env,
2633       cbi->object, cbi->method, o_timeout, o_identifier);
2634
2635   (*jvm_env)->DeleteLocalRef (jvm_env, o_identifier);
2636   (*jvm_env)->DeleteLocalRef (jvm_env, o_timeout);
2637
2638   status = cjni_thread_detach ();
2639   if (status != 0)
2640   {
2641     ERROR ("java plugin: cjni_flush: cjni_thread_detach failed.");
2642     return (-1);
2643   }
2644
2645   return (ret_status);
2646 } /* }}} int cjni_flush */
2647
2648 /* Call the CB_TYPE_LOG callback pointed to by the `user_data_t' pointer. */
2649 static void cjni_log (int severity, const char *message, /* {{{ */
2650     user_data_t *ud)
2651 {
2652   JNIEnv *jvm_env;
2653   cjni_callback_info_t *cbi;
2654   jobject o_message;
2655
2656   if (jvm == NULL)
2657     return;
2658
2659   if ((ud == NULL) || (ud->data == NULL))
2660     return;
2661
2662   jvm_env = cjni_thread_attach ();
2663   if (jvm_env == NULL)
2664     return;
2665
2666   cbi = (cjni_callback_info_t *) ud->data;
2667
2668   o_message = (*jvm_env)->NewStringUTF (jvm_env, message);
2669   if (o_message == NULL)
2670     return;
2671
2672   (*jvm_env)->CallVoidMethod (jvm_env,
2673       cbi->object, cbi->method, (jint) severity, o_message);
2674
2675   (*jvm_env)->DeleteLocalRef (jvm_env, o_message);
2676
2677   cjni_thread_detach ();
2678 } /* }}} void cjni_log */
2679
2680 /* Call the CB_TYPE_NOTIFICATION callback pointed to by the `user_data_t'
2681  * pointer. */
2682 static int cjni_notification (const notification_t *n, /* {{{ */
2683     user_data_t *ud)
2684 {
2685   JNIEnv *jvm_env;
2686   cjni_callback_info_t *cbi;
2687   jobject o_notification;
2688   int status;
2689   int ret_status;
2690
2691   if (jvm == NULL)
2692   {
2693     ERROR ("java plugin: cjni_read: jvm == NULL");
2694     return (-1);
2695   }
2696
2697   if ((ud == NULL) || (ud->data == NULL))
2698   {
2699     ERROR ("java plugin: cjni_read: Invalid user data.");
2700     return (-1);
2701   }
2702
2703   jvm_env = cjni_thread_attach ();
2704   if (jvm_env == NULL)
2705     return (-1);
2706
2707   cbi = (cjni_callback_info_t *) ud->data;
2708
2709   o_notification = ctoj_notification (jvm_env, n);
2710   if (o_notification == NULL)
2711   {
2712     ERROR ("java plugin: cjni_notification: ctoj_notification failed.");
2713     return (-1);
2714   }
2715
2716   ret_status = (*jvm_env)->CallIntMethod (jvm_env,
2717       cbi->object, cbi->method, o_notification);
2718
2719   (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
2720
2721   status = cjni_thread_detach ();
2722   if (status != 0)
2723   {
2724     ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
2725     return (-1);
2726   }
2727
2728   return (ret_status);
2729 } /* }}} int cjni_notification */
2730
2731 /* Callbacks for matches implemented in Java */
2732 static int cjni_match_target_create (const oconfig_item_t *ci, /* {{{ */
2733     void **user_data)
2734 {
2735   JNIEnv *jvm_env;
2736   cjni_callback_info_t *cbi_ret;
2737   cjni_callback_info_t *cbi_factory;
2738   const char *name;
2739   jobject o_ci;
2740   jobject o_tmp;
2741   int type;
2742   size_t i;
2743
2744   cbi_ret = NULL;
2745   o_ci = NULL;
2746   jvm_env = NULL;
2747
2748 #define BAIL_OUT(status) \
2749   if (cbi_ret != NULL) { \
2750     free (cbi_ret->name); \
2751     if ((jvm_env != NULL) && (cbi_ret->object != NULL)) \
2752       (*jvm_env)->DeleteLocalRef (jvm_env, cbi_ret->object); \
2753   } \
2754   free (cbi_ret); \
2755   if (jvm_env != NULL) { \
2756     if (o_ci != NULL) \
2757       (*jvm_env)->DeleteLocalRef (jvm_env, o_ci); \
2758     cjni_thread_detach (); \
2759   } \
2760   return (status)
2761
2762   if (jvm == NULL)
2763   {
2764     ERROR ("java plugin: cjni_read: jvm == NULL");
2765     BAIL_OUT (-1);
2766   }
2767
2768   jvm_env = cjni_thread_attach ();
2769   if (jvm_env == NULL)
2770   {
2771     BAIL_OUT (-1);
2772   }
2773
2774   /* Find out whether to create a match or a target. */
2775   if (strcasecmp ("Match", ci->key) == 0)
2776     type = CB_TYPE_MATCH;
2777   else if (strcasecmp ("Target", ci->key) == 0)
2778     type = CB_TYPE_TARGET;
2779   else
2780   {
2781     ERROR ("java plugin: cjni_match_target_create: Can't figure out whether "
2782         "to create a match or a target.");
2783     BAIL_OUT (-1);
2784   }
2785
2786   /* This is the name of the match we should create. */
2787   name = ci->values[0].value.string;
2788
2789   /* Lets see if we have a matching factory here.. */
2790   cbi_factory = NULL;
2791   for (i = 0; i < java_callbacks_num; i++)
2792   {
2793     if (java_callbacks[i].type != type)
2794       continue;
2795
2796     if (strcmp (name, java_callbacks[i].name) != 0)
2797       continue;
2798
2799     cbi_factory = java_callbacks + i;
2800     break;
2801   }
2802
2803   /* Nope, no factory for that name.. */
2804   if (cbi_factory == NULL)
2805   {
2806     ERROR ("java plugin: cjni_match_target_create: "
2807         "No such match factory registered: %s",
2808         name);
2809     BAIL_OUT (-1);
2810   }
2811
2812   /* We convert `ci' to its Java equivalent.. */
2813   o_ci = ctoj_oconfig_item (jvm_env, ci);
2814   if (o_ci == NULL)
2815   {
2816     ERROR ("java plugin: cjni_match_target_create: "
2817         "ctoj_oconfig_item failed.");
2818     BAIL_OUT (-1);
2819   }
2820
2821   /* Allocate a new callback info structure. This is going to be our user_data
2822    * pointer. */
2823   cbi_ret = (cjni_callback_info_t *) malloc (sizeof (*cbi_ret));
2824   if (cbi_ret == NULL)
2825   {
2826     ERROR ("java plugin: cjni_match_target_create: malloc failed.");
2827     BAIL_OUT (-1);
2828   }
2829   memset (cbi_ret, 0, sizeof (*cbi_ret));
2830   cbi_ret->object = NULL;
2831   cbi_ret->type = type;
2832
2833   /* Lets fill the callback info structure.. First, the name: */
2834   cbi_ret->name = strdup (name);
2835   if (cbi_ret->name == NULL)
2836   {
2837     ERROR ("java plugin: cjni_match_target_create: strdup failed.");
2838     BAIL_OUT (-1);
2839   }
2840
2841   /* Then call the factory method so it creates a new object for us. */
2842   o_tmp = (*jvm_env)->CallObjectMethod (jvm_env,
2843       cbi_factory->object, cbi_factory->method, o_ci);
2844   if (o_tmp == NULL)
2845   {
2846     ERROR ("java plugin: cjni_match_target_create: CallObjectMethod failed.");
2847     BAIL_OUT (-1);
2848   }
2849
2850   cbi_ret->object = (*jvm_env)->NewGlobalRef (jvm_env, o_tmp);
2851   if (o_tmp == NULL)
2852   {
2853     ERROR ("java plugin: cjni_match_target_create: NewGlobalRef failed.");
2854     BAIL_OUT (-1);
2855   }
2856
2857   /* This is the class of the match. It is possibly different from the class of
2858    * the match-factory! */
2859   cbi_ret->class = (*jvm_env)->GetObjectClass (jvm_env, cbi_ret->object);
2860   if (cbi_ret->class == NULL)
2861   {
2862     ERROR ("java plugin: cjni_match_target_create: GetObjectClass failed.");
2863     BAIL_OUT (-1);
2864   }
2865
2866   /* Lookup the `int match (DataSet, ValueList)' method. */
2867   cbi_ret->method = (*jvm_env)->GetMethodID (jvm_env, cbi_ret->class,
2868       /* method name = */ (type == CB_TYPE_MATCH) ? "match" : "invoke",
2869       "(Lorg/collectd/api/DataSet;Lorg/collectd/api/ValueList;)I");
2870   if (cbi_ret->method == NULL)
2871   {
2872     ERROR ("java plugin: cjni_match_target_create: GetMethodID failed.");
2873     BAIL_OUT (-1);
2874   }
2875
2876   /* Return the newly created match via the user_data pointer. */
2877   *user_data = (void *) cbi_ret;
2878
2879   cjni_thread_detach ();
2880
2881   DEBUG ("java plugin: cjni_match_target_create: "
2882       "Successfully created a `%s' %s.",
2883       cbi_ret->name, (type == CB_TYPE_MATCH) ? "match" : "target");
2884
2885   /* Success! */
2886   return (0);
2887 #undef BAIL_OUT
2888 } /* }}} int cjni_match_target_create */
2889
2890 static int cjni_match_target_destroy (void **user_data) /* {{{ */
2891 {
2892   cjni_callback_info_destroy (*user_data);
2893   *user_data = NULL;
2894
2895   return (0);
2896 } /* }}} int cjni_match_target_destroy */
2897
2898 static int cjni_match_target_invoke (const data_set_t *ds, /* {{{ */
2899     value_list_t *vl, notification_meta_t **meta, void **user_data)
2900 {
2901   JNIEnv *jvm_env;
2902   cjni_callback_info_t *cbi;
2903   jobject o_vl;
2904   jobject o_ds;
2905   int ret_status;
2906   int status;
2907
2908   if (jvm == NULL)
2909   {
2910     ERROR ("java plugin: cjni_match_target_invoke: jvm == NULL");
2911     return (-1);
2912   }
2913
2914   jvm_env = cjni_thread_attach ();
2915   if (jvm_env == NULL)
2916     return (-1);
2917
2918   cbi = (cjni_callback_info_t *) *user_data;
2919
2920   o_vl = ctoj_value_list (jvm_env, ds, vl);
2921   if (o_vl == NULL)
2922   {
2923     ERROR ("java plugin: cjni_match_target_invoke: ctoj_value_list failed.");
2924     cjni_thread_detach ();
2925     return (-1);
2926   }
2927
2928   o_ds = ctoj_data_set (jvm_env, ds);
2929   if (o_ds == NULL)
2930   {
2931     ERROR ("java plugin: cjni_match_target_invoke: ctoj_value_list failed.");
2932     cjni_thread_detach ();
2933     return (-1);
2934   }
2935
2936   ret_status = (*jvm_env)->CallIntMethod (jvm_env, cbi->object, cbi->method,
2937       o_ds, o_vl);
2938
2939   DEBUG ("java plugin: cjni_match_target_invoke: Method returned %i.", ret_status);
2940
2941   /* If we're executing a target, copy the `ValueList' back to our
2942    * `value_list_t'. */
2943   if (cbi->type == CB_TYPE_TARGET)
2944   {
2945     value_list_t new_vl;
2946
2947     memset (&new_vl, 0, sizeof (new_vl));
2948     status = jtoc_value_list (jvm_env, &new_vl, o_vl);
2949     if (status != 0)
2950     {
2951       ERROR ("java plugin: cjni_match_target_invoke: "
2952           "jtoc_value_list failed.");
2953     }
2954     else /* if (status == 0) */
2955     {
2956       /* plugin_dispatch_values assures that this is dynamically allocated
2957        * memory. */
2958       sfree (vl->values);
2959
2960       /* This will replace the vl->values pointer to a new, dynamically
2961        * allocated piece of memory. */
2962       memcpy (vl, &new_vl, sizeof (*vl));
2963     }
2964   } /* if (cbi->type == CB_TYPE_TARGET) */
2965
2966   status = cjni_thread_detach ();
2967   if (status != 0)
2968     ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
2969
2970   return (ret_status);
2971 } /* }}} int cjni_match_target_invoke */
2972
2973 /* Iterate over `java_callbacks' and call all CB_TYPE_INIT callbacks. */
2974 static int cjni_init_plugins (JNIEnv *jvm_env) /* {{{ */
2975 {
2976   int status;
2977   size_t i;
2978
2979   for (i = 0; i < java_callbacks_num; i++)
2980   {
2981     if (java_callbacks[i].type != CB_TYPE_INIT)
2982       continue;
2983
2984     DEBUG ("java plugin: Initializing %s", java_callbacks[i].name);
2985
2986     status = (*jvm_env)->CallIntMethod (jvm_env,
2987         java_callbacks[i].object, java_callbacks[i].method);
2988     if (status != 0)
2989     {
2990       ERROR ("java plugin: Initializing `%s' failed with status %i. "
2991           "Removing read function.",
2992           java_callbacks[i].name, status);
2993       plugin_unregister_read (java_callbacks[i].name);
2994     }
2995   }
2996
2997   return (0);
2998 } /* }}} int cjni_init_plugins */
2999
3000 /* Iterate over `java_callbacks' and call all CB_TYPE_SHUTDOWN callbacks. */
3001 static int cjni_shutdown_plugins (JNIEnv *jvm_env) /* {{{ */
3002 {
3003   int status;
3004   size_t i;
3005
3006   for (i = 0; i < java_callbacks_num; i++)
3007   {
3008     if (java_callbacks[i].type != CB_TYPE_SHUTDOWN)
3009       continue;
3010
3011     DEBUG ("java plugin: Shutting down %s", java_callbacks[i].name);
3012
3013     status = (*jvm_env)->CallIntMethod (jvm_env,
3014         java_callbacks[i].object, java_callbacks[i].method);
3015     if (status != 0)
3016     {
3017       ERROR ("java plugin: Shutting down `%s' failed with status %i. ",
3018           java_callbacks[i].name, status);
3019     }
3020   }
3021
3022   return (0);
3023 } /* }}} int cjni_shutdown_plugins */
3024
3025
3026 static int cjni_shutdown (void) /* {{{ */
3027 {
3028   JNIEnv *jvm_env;
3029   JavaVMAttachArgs args;
3030   int status;
3031   size_t i;
3032
3033   if (jvm == NULL)
3034     return (0);
3035
3036   jvm_env = NULL;
3037   memset (&args, 0, sizeof (args));
3038   args.version = JNI_VERSION_1_2;
3039
3040   status = (*jvm)->AttachCurrentThread (jvm, (void *) &jvm_env, &args);
3041   if (status != 0)
3042   {
3043     ERROR ("java plugin: cjni_shutdown: AttachCurrentThread failed with status %i.",
3044         status);
3045     return (-1);
3046   }
3047
3048   /* Execute all the shutdown functions registered by plugins. */
3049   cjni_shutdown_plugins (jvm_env);
3050
3051   /* Release all the global references to callback functions */
3052   for (i = 0; i < java_callbacks_num; i++)
3053   {
3054     if (java_callbacks[i].object != NULL)
3055     {
3056       (*jvm_env)->DeleteGlobalRef (jvm_env, java_callbacks[i].object);
3057       java_callbacks[i].object = NULL;
3058     }
3059     sfree (java_callbacks[i].name);
3060   }
3061   java_callbacks_num = 0;
3062   sfree (java_callbacks);
3063
3064   /* Release all the global references to directly loaded classes. */
3065   for (i = 0; i < java_classes_list_len; i++)
3066   {
3067     if (java_classes_list[i].object != NULL)
3068     {
3069       (*jvm_env)->DeleteGlobalRef (jvm_env, java_classes_list[i].object);
3070       java_classes_list[i].object = NULL;
3071     }
3072     sfree (java_classes_list[i].name);
3073   }
3074   java_classes_list_len = 0;
3075   sfree (java_classes_list);
3076
3077   /* Destroy the JVM */
3078   DEBUG ("java plugin: Destroying the JVM.");
3079   (*jvm)->DestroyJavaVM (jvm);
3080   jvm = NULL;
3081   jvm_env = NULL;
3082
3083   pthread_key_delete (jvm_env_key);
3084
3085   /* Free the JVM argument list */
3086   for (i = 0; i < jvm_argc; i++)
3087     sfree (jvm_argv[i]);
3088   jvm_argc = 0;
3089   sfree (jvm_argv);
3090
3091   return (0);
3092 } /* }}} int cjni_shutdown */
3093
3094 /* Initialization: Create a JVM, load all configured classes and call their
3095  * `config' and `init' callback methods. */
3096 static int cjni_init (void) /* {{{ */
3097 {
3098   JNIEnv *jvm_env;
3099
3100   if ((config_block == NULL) && (jvm == NULL))
3101   {
3102     ERROR ("java plugin: cjni_init: No configuration block for "
3103         "the java plugin was found.");
3104     return (-1);
3105   }
3106
3107   if (config_block != NULL)
3108   {
3109
3110     cjni_config_perform (config_block);
3111     oconfig_free (config_block);
3112     config_block = NULL;
3113   }
3114
3115   if (jvm == NULL)
3116   {
3117     ERROR ("java plugin: cjni_init: jvm == NULL");
3118     return (-1);
3119   }
3120
3121   jvm_env = cjni_thread_attach ();
3122   if (jvm_env == NULL)
3123     return (-1);
3124
3125   cjni_init_plugins (jvm_env);
3126
3127   cjni_thread_detach ();
3128   return (0);
3129 } /* }}} int cjni_init */
3130
3131 void module_register (void)
3132 {
3133   plugin_register_complex_config ("java", cjni_config_callback);
3134   plugin_register_init ("java", cjni_init);
3135   plugin_register_shutdown ("java", cjni_shutdown);
3136 } /* void module_register (void) */
3137
3138 /* vim: set sw=2 sts=2 et fdm=marker : */