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