src/oracle.c

   1 /**
   2  * collectd - src/oracle.c
   3  * Copyright (C) 2008,2009  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Linking src/oracle.c ("the oracle plugin") statically or dynamically with
  19  * other modules is making a combined work based on the oracle plugin. Thus,
  20  * the terms and conditions of the GNU General Public License cover the whole
  21  * combination.
  22  *
  23  * In addition, as a special exception, the copyright holders of the oracle
  24  * plugin give you permission to combine the oracle plugin with free software
  25  * programs or libraries that are released under the GNU LGPL and with code
  26  * included in the standard release of the Oracle® Call Interface (OCI) under
  27  * the Oracle® Technology Network (OTN) License (or modified versions of such
  28  * code, with unchanged license). You may copy and distribute such a system
  29  * following the terms of the GNU GPL for the oracle plugin and the licenses of
  30  * the other code concerned.
  31  *
  32  * Note that people who make modified versions of the oracle plugin are not
  33  * obligated to grant this special exception for their modified versions; it is
  34  * their choice whether to do so. The GNU General Public License gives
  35  * permission to release a modified version without this exception; this
  36  * exception also makes it possible to release a modified version which carries
  37  * forward this exception. However, without this exception the OTN License does
  38  * not allow linking with code licensed under the GNU General Public License.
  39  *
  40  * Oracle® is a registered trademark of Oracle Corporation and/or its
  41  * affiliates. Other names may be trademarks of their respective owners.
  42  *
  43  * Authors:
  44  *   Florian octo Forster <octo at noris.net>
  45  **/
  46
  47 #include "collectd.h"
  48 #include "common.h"
  49 #include "plugin.h"
  50 #include "configfile.h"
  51 #include "utils_db_query.h"
  52
  53 #include <oci.h>
  54
  55 /*
  56  * Data types
  57  */
  58 struct o_database_s
  59 {
  60   char *name;
  61   char *connect_id;
  62   char *username;
  63   char *password;
  64
  65   udb_query_t **queries;
  66   size_t        queries_num;
  67
  68   OCISvcCtx *oci_service_context;
  69 };
  70 typedef struct o_database_s o_database_t;
  71
  72 /*
  73  * Global variables
  74  */
  75 static udb_query_t  **queries       = NULL;
  76 static size_t         queries_num   = 0;
  77 static o_database_t **databases     = NULL;
  78 static size_t         databases_num = 0;
  79
  80 OCIEnv   *oci_env = NULL;
  81 OCIError *oci_error = NULL;
  82
  83 /*
  84  * Functions
  85  */
  86 static void o_report_error (const char *where, /* {{{ */
  87     const char *what, OCIError *eh)
  88 {
  89   char buffer[2048];
  90   sb4 error_code;
  91   int status;
  92
  93   status = OCIErrorGet (eh, /* record number = */ 1,
  94       /* sqlstate = */ NULL,
  95       &error_code,
  96       (text *) &buffer[0],
  97       (ub4) sizeof (buffer),
  98       OCI_HTYPE_ERROR);
  99   buffer[sizeof (buffer) - 1] = 0;
 100
 101   if (status == OCI_SUCCESS)
 102   {
 103     size_t buffer_length;
 104
 105     buffer_length = strlen (buffer);
 106     while ((buffer_length > 0) && (buffer[buffer_length - 1] < 32))
 107     {
 108       buffer_length--;
 109       buffer[buffer_length] = 0;
 110     }
 111
 112     ERROR ("oracle plugin: %s: %s failed: %s",
 113         where, what, buffer);
 114   }
 115   else
 116   {
 117     ERROR ("oracle plugin: %s: %s failed. Additionally, OCIErrorGet failed with status %i.",
 118         where, what, status);
 119   }
 120 } /* }}} void o_report_error */
 121
 122 static void o_database_free (o_database_t *db) /* {{{ */
 123 {
 124   if (db == NULL)
 125     return;
 126
 127   sfree (db->name);
 128   sfree (db->connect_id);
 129   sfree (db->username);
 130   sfree (db->password);
 131   sfree (db->queries);
 132
 133   sfree (db);
 134 } /* }}} void o_database_free */
 135
 136 /* Configuration handling functions {{{
 137  *
 138  * <Plugin oracle>
 139  *   <Query "plugin_instance0">
 140  *     Statement "SELECT name, value FROM table"
 141  *     <Result>
 142  *       Type "gauge"
 143  *       InstancesFrom "name"
 144  *       ValuesFrom "value"
 145  *     </Result>
 146  *   </Query>
 147  *
 148  *   <Database "plugin_instance1">
 149  *     ConnectID "db01"
 150  *     Username "oracle"
 151  *     Password "secret"
 152  *     Query "plugin_instance0"
 153  *   </Database>
 154  * </Plugin>
 155  */
 156
 157 static int o_config_set_string (char **ret_string, /* {{{ */
 158     oconfig_item_t *ci)
 159 {
 160   char *string;
 161
 162   if ((ci->values_num != 1)
 163       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 164   {
 165     WARNING ("oracle plugin: The `%s' config option "
 166         "needs exactly one string argument.", ci->key);
 167     return (-1);
 168   }
 169
 170   string = strdup (ci->values[0].value.string);
 171   if (string == NULL)
 172   {
 173     ERROR ("oracle plugin: strdup failed.");
 174     return (-1);
 175   }
 176
 177   if (*ret_string != NULL)
 178     free (*ret_string);
 179   *ret_string = string;
 180
 181   return (0);
 182 } /* }}} int o_config_set_string */
 183
 184 static int o_config_add_database (oconfig_item_t *ci) /* {{{ */
 185 {
 186   o_database_t *db;
 187   int status;
 188   int i;
 189
 190   if ((ci->values_num != 1)
 191       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 192   {
 193     WARNING ("oracle plugin: The `Database' block "
 194         "needs exactly one string argument.");
 195     return (-1);
 196   }
 197
 198   db = (o_database_t *) malloc (sizeof (*db));
 199   if (db == NULL)
 200   {
 201     ERROR ("oracle plugin: malloc failed.");
 202     return (-1);
 203   }
 204   memset (db, 0, sizeof (*db));
 205
 206   status = o_config_set_string (&db->name, ci);
 207   if (status != 0)
 208   {
 209     sfree (db);
 210     return (status);
 211   }
 212
 213   /* Fill the `o_database_t' structure.. */
 214   for (i = 0; i < ci->children_num; i++)
 215   {
 216     oconfig_item_t *child = ci->children + i;
 217
 218     if (strcasecmp ("ConnectID", child->key) == 0)
 219       status = o_config_set_string (&db->connect_id, child);
 220     else if (strcasecmp ("Username", child->key) == 0)
 221       status = o_config_set_string (&db->username, child);
 222     else if (strcasecmp ("Password", child->key) == 0)
 223       status = o_config_set_string (&db->password, child);
 224     else if (strcasecmp ("Query", child->key) == 0)
 225       status = udb_query_pick_from_list (child, queries, queries_num,
 226           &db->queries, &db->queries_num);
 227     else
 228     {
 229       WARNING ("oracle plugin: Option `%s' not allowed here.", child->key);
 230       status = -1;
 231     }
 232
 233     if (status != 0)
 234       break;
 235   }
 236
 237   /* Check that all necessary options have been given. */
 238   while (status == 0)
 239   {
 240     if (db->connect_id == NULL)
 241     {
 242       WARNING ("oracle plugin: `ConnectID' not given for query `%s'", db->name);
 243       status = -1;
 244     }
 245     if (db->username == NULL)
 246     {
 247       WARNING ("oracle plugin: `Username' not given for query `%s'", db->name);
 248       status = -1;
 249     }
 250     if (db->password == NULL)
 251     {
 252       WARNING ("oracle plugin: `Password' not given for query `%s'", db->name);
 253       status = -1;
 254     }
 255
 256     break;
 257   } /* while (status == 0) */
 258
 259   /* If all went well, add this query to the list of queries within the
 260    * database structure. */
 261   if (status == 0)
 262   {
 263     o_database_t **temp;
 264
 265     temp = (o_database_t **) realloc (databases,
 266         sizeof (*databases) * (databases_num + 1));
 267     if (temp == NULL)
 268     {
 269       ERROR ("oracle plugin: realloc failed");
 270       status = -1;
 271     }
 272     else
 273     {
 274       databases = temp;
 275       databases[databases_num] = db;
 276       databases_num++;
 277     }
 278   }
 279
 280   if (status != 0)
 281   {
 282     o_database_free (db);
 283     return (-1);
 284   }
 285
 286   return (0);
 287 } /* }}} int o_config_add_database */
 288
 289 static int o_config (oconfig_item_t *ci) /* {{{ */
 290 {
 291   int i;
 292
 293   for (i = 0; i < ci->children_num; i++)
 294   {
 295     oconfig_item_t *child = ci->children + i;
 296     if (strcasecmp ("Query", child->key) == 0)
 297       udb_query_create (&queries, &queries_num, child,
 298           /* callback = */ NULL, /* legacy mode = */ 0);
 299     else if (strcasecmp ("Database", child->key) == 0)
 300       o_config_add_database (child);
 301     else
 302     {
 303       WARNING ("oracle plugin: Ignoring unknown config option `%s'.", child->key);
 304     }
 305
 306     if (queries_num > 0)
 307     {
 308       DEBUG ("oracle plugin: o_config: queries_num = %zu; queries[0] = %p; udb_query_get_user_data (queries[0]) = %p;",
 309           queries_num, (void *) queries[0], udb_query_get_user_data (queries[0]));
 310     }
 311   } /* for (ci->children) */
 312
 313   return (0);
 314 } /* }}} int o_config */
 315
 316 /* }}} End of configuration handling functions */
 317
 318 static int o_init (void) /* {{{ */
 319 {
 320   int status;
 321
 322   if (oci_env != NULL)
 323     return (0);
 324
 325   status = OCIEnvCreate (&oci_env,
 326       /* mode = */ OCI_THREADED,
 327       /* context        = */ NULL,
 328       /* malloc         = */ NULL,
 329       /* realloc        = */ NULL,
 330       /* free           = */ NULL,
 331       /* user_data_size = */ 0,
 332       /* user_data_ptr  = */ NULL);
 333   if (status != 0)
 334   {
 335     ERROR ("oracle plugin: OCIEnvCreate failed with status %i.", status);
 336     return (-1);
 337   }
 338
 339   status = OCIHandleAlloc (oci_env, (void *) &oci_error, OCI_HTYPE_ERROR,
 340       /* user_data_size = */ 0, /* user_data = */ NULL);
 341   if (status != OCI_SUCCESS)
 342   {
 343     ERROR ("oracle plugin: OCIHandleAlloc (OCI_HTYPE_ERROR) failed "
 344         "with status %i.", status);
 345     return (-1);
 346   }
 347
 348   return (0);
 349 } /* }}} int o_init */
 350
 351 static int o_read_database_query (o_database_t *db, /* {{{ */
 352     udb_query_t *q)
 353 {
 354   char **column_names;
 355   char **column_values;
 356   size_t column_num;
 357
 358   OCIStmt *oci_statement;
 359
 360   /* List of `OCIDefine' pointers. These defines map columns to the buffer
 361    * space declared above. */
 362   OCIDefine **oci_defines;
 363
 364   int status;
 365   size_t i;
 366
 367   oci_statement = udb_query_get_user_data (q);
 368
 369   /* Prepare the statement */
 370   if (oci_statement == NULL) /* {{{ */
 371   {
 372     const char *statement;
 373
 374     statement = udb_query_get_statement (q);
 375     assert (statement != NULL);
 376
 377     status = OCIHandleAlloc (oci_env, (void *) &oci_statement,
 378         OCI_HTYPE_STMT, /* user_data_size = */ 0, /* user_data = */ NULL);
 379     if (status != OCI_SUCCESS)
 380     {
 381       o_report_error ("o_read_database_query", "OCIHandleAlloc", oci_error);
 382       oci_statement = NULL;
 383       return (-1);
 384     }
 385
 386     status = OCIStmtPrepare (oci_statement, oci_error,
 387         (text *) statement, (ub4) strlen (statement),
 388         /* language = */ OCI_NTV_SYNTAX,
 389         /* mode     = */ OCI_DEFAULT);
 390     if (status != OCI_SUCCESS)
 391     {
 392       o_report_error ("o_read_database_query", "OCIStmtPrepare", oci_error);
 393       OCIHandleFree (oci_statement, OCI_HTYPE_STMT);
 394       oci_statement = NULL;
 395       return (-1);
 396     }
 397     udb_query_set_user_data (q, oci_statement);
 398
 399     DEBUG ("oracle plugin: o_read_database_query (%s, %s): "
 400         "Successfully allocated statement handle.",
 401         db->name, udb_query_get_name (q));
 402   } /* }}} */
 403
 404   assert (oci_statement != NULL);
 405
 406   /* Execute the statement */
 407   status = OCIStmtExecute (db->oci_service_context, /* {{{ */
 408       oci_statement,
 409       oci_error,
 410       /* iters = */ 0,
 411       /* rowoff = */ 0,
 412       /* snap_in = */ NULL, /* snap_out = */ NULL,
 413       /* mode = */ OCI_DEFAULT);
 414   if (status != OCI_SUCCESS)
 415   {
 416     DEBUG ("oracle plugin: o_read_database_query: status = %i (%#x)", status, status);
 417     o_report_error ("o_read_database_query", "OCIStmtExecute", oci_error);
 418     ERROR ("oracle plugin: o_read_database_query: "
 419         "Failing statement was: %s", udb_query_get_statement (q));
 420     return (-1);
 421   } /* }}} */
 422
 423   /* Acquire the number of columns returned. */
 424   do /* {{{ */
 425   {
 426     ub4 param_counter = 0;
 427     status = OCIAttrGet (oci_statement, OCI_HTYPE_STMT, /* {{{ */
 428         &param_counter, /* size pointer = */ NULL,
 429         OCI_ATTR_PARAM_COUNT, oci_error);
 430     if (status != OCI_SUCCESS)
 431     {
 432       o_report_error ("o_read_database_query", "OCIAttrGet", oci_error);
 433       return (-1);
 434     } /* }}} */
 435
 436     column_num = (size_t) param_counter;
 437   } while (0); /* }}} */
 438
 439   /* Allocate the following buffers:
 440    *
 441    *  +---------------+-----------------------------------+
 442    *  ! Name          ! Size                              !
 443    *  +---------------+-----------------------------------+
 444    *  ! column_names  ! column_num x DATA_MAX_NAME_LEN    !
 445    *  ! column_values ! column_num x DATA_MAX_NAME_LEN    !
 446    *  ! oci_defines   ! column_num x sizeof (OCIDefine *) !
 447    *  +---------------+-----------------------------------+
 448    *
 449    * {{{ */
 450 #define NUMBER_BUFFER_SIZE 64
 451
 452 #define FREE_ALL \
 453   if (column_names != NULL) { \
 454     sfree (column_names[0]); \
 455     sfree (column_names); \
 456   } \
 457   if (column_values != NULL) { \
 458     sfree (column_values[0]); \
 459     sfree (column_values); \
 460   } \
 461   sfree (oci_defines)
 462
 463 #define ALLOC_OR_FAIL(ptr, ptr_size) \
 464   do { \
 465     size_t alloc_size = (size_t) ((ptr_size)); \
 466     (ptr) = malloc (alloc_size); \
 467     if ((ptr) == NULL) { \
 468       FREE_ALL; \
 469       ERROR ("oracle plugin: o_read_database_query: malloc failed."); \
 470       return (-1); \
 471     } \
 472     memset ((ptr), 0, alloc_size); \
 473   } while (0)
 474
 475   /* Initialize everything to NULL so the above works. */
 476   column_names  = NULL;
 477   column_values = NULL;
 478   oci_defines   = NULL;
 479
 480   ALLOC_OR_FAIL (column_names, column_num * sizeof (char *));
 481   ALLOC_OR_FAIL (column_names[0], column_num * DATA_MAX_NAME_LEN
 482       * sizeof (char));
 483   for (i = 1; i < column_num; i++)
 484     column_names[i] = column_names[i - 1] + DATA_MAX_NAME_LEN;
 485
 486   ALLOC_OR_FAIL (column_values, column_num * sizeof (char *));
 487   ALLOC_OR_FAIL (column_values[0], column_num * DATA_MAX_NAME_LEN
 488       * sizeof (char));
 489   for (i = 1; i < column_num; i++)
 490     column_values[i] = column_values[i - 1] + DATA_MAX_NAME_LEN;
 491
 492   ALLOC_OR_FAIL (oci_defines, column_num * sizeof (OCIDefine *));
 493   /* }}} End of buffer allocations. */
 494
 495   /* ``Define'' the returned data, i. e. bind the columns to the buffers
 496    * allocated above. */
 497   for (i = 0; i < column_num; i++) /* {{{ */
 498   {
 499     char *column_name;
 500     ub4 column_name_length;
 501     OCIParam *oci_param;
 502
 503     oci_param = NULL;
 504
 505     status = OCIParamGet (oci_statement, OCI_HTYPE_STMT, oci_error,
 506         (void *) &oci_param, (ub4) (i + 1));
 507     if (status != OCI_SUCCESS)
 508     {
 509       /* This is probably alright */
 510       DEBUG ("oracle plugin: o_read_database_query: status = %#x (= %i);", status, status);
 511       o_report_error ("o_read_database_query", "OCIParamGet", oci_error);
 512       status = OCI_SUCCESS;
 513       break;
 514     }
 515
 516     column_name = NULL;
 517     column_name_length = 0;
 518     status = OCIAttrGet (oci_param, OCI_DTYPE_PARAM,
 519         &column_name, &column_name_length, OCI_ATTR_NAME, oci_error);
 520     if (status != OCI_SUCCESS)
 521     {
 522       o_report_error ("o_read_database_query", "OCIAttrGet (OCI_ATTR_NAME)",
 523           oci_error);
 524       continue;
 525     }
 526
 527     /* Copy the name to column_names. Warning: The ``string'' returned by OCI
 528      * may not be null terminated! */
 529     memset (column_names[i], 0, DATA_MAX_NAME_LEN);
 530     if (column_name_length >= DATA_MAX_NAME_LEN)
 531       column_name_length = DATA_MAX_NAME_LEN - 1;
 532     memcpy (column_names[i], column_name, column_name_length);
 533     column_names[i][column_name_length] = 0;
 534
 535     DEBUG ("oracle plugin: o_read_database_query: column_names[%zu] = %s; "
 536         "column_name_length = %"PRIu32";",
 537         i, column_names[i], (uint32_t) column_name_length);
 538
 539     status = OCIDefineByPos (oci_statement,
 540         &oci_defines[i], oci_error, (ub4) (i + 1),
 541         column_values[i], DATA_MAX_NAME_LEN, SQLT_STR,
 542         NULL, NULL, NULL, OCI_DEFAULT);
 543     if (status != OCI_SUCCESS)
 544     {
 545       o_report_error ("o_read_database_query", "OCIDefineByPos", oci_error);
 546       continue;
 547     }
 548   } /* for (j = 1; j <= param_counter; j++) */
 549   /* }}} End of the ``define'' stuff. */
 550
 551   status = udb_query_prepare_result (q, hostname_g, /* plugin = */ "oracle",
 552       db->name, column_names, column_num);
 553   if (status != 0)
 554   {
 555     ERROR ("oracle plugin: o_read_database_query (%s, %s): "
 556         "udb_query_prepare_result failed.",
 557         db->name, udb_query_get_name (q));
 558     FREE_ALL;
 559     return (-1);
 560   }
 561
 562   /* Fetch and handle all the rows that matched the query. */
 563   while (42) /* {{{ */
 564   {
 565     status = OCIStmtFetch2 (oci_statement, oci_error,
 566         /* nrows = */ 1, /* orientation = */ OCI_FETCH_NEXT,
 567         /* fetch offset = */ 0, /* mode = */ OCI_DEFAULT);
 568     if (status == OCI_NO_DATA)
 569     {
 570       status = OCI_SUCCESS;
 571       break;
 572     }
 573     else if ((status != OCI_SUCCESS) && (status != OCI_SUCCESS_WITH_INFO))
 574     {
 575       o_report_error ("o_read_database_query", "OCIStmtFetch2", oci_error);
 576       break;
 577     }
 578
 579     status = udb_query_handle_result (q, column_values);
 580     if (status != 0)
 581     {
 582       WARNING ("oracle plugin: o_read_database_query (%s, %s): "
 583           "udb_query_handle_result failed.",
 584           db->name, udb_query_get_name (q));
 585     }
 586   } /* }}} while (42) */
 587
 588   /* DEBUG ("oracle plugin: o_read_database_query: This statement succeeded: %s", q->statement); */
 589   FREE_ALL;
 590
 591   return (0);
 592 #undef FREE_ALL
 593 #undef ALLOC_OR_FAIL
 594 } /* }}} int o_read_database_query */
 595
 596 static int o_read_database (o_database_t *db) /* {{{ */
 597 {
 598   size_t i;
 599   int status;
 600
 601   if (db->oci_service_context != NULL)
 602   {
 603     OCIServer *server_handle;
 604     ub4 connection_status;
 605
 606     server_handle = NULL;
 607     status = OCIAttrGet ((void *) db->oci_service_context, OCI_HTYPE_SVCCTX,
 608         (void *) &server_handle, /* size pointer = */ NULL,
 609         OCI_ATTR_SERVER, oci_error);
 610     if (status != OCI_SUCCESS)
 611     {
 612       o_report_error ("o_read_database", "OCIAttrGet", oci_error);
 613       return (-1);
 614     }
 615
 616     if (server_handle == NULL)
 617     {
 618       connection_status = OCI_SERVER_NOT_CONNECTED;
 619     }
 620     else /* if (server_handle != NULL) */
 621     {
 622       connection_status = 0;
 623       status = OCIAttrGet ((void *) server_handle, OCI_HTYPE_SERVER,
 624           (void *) &connection_status, /* size pointer = */ NULL,
 625           OCI_ATTR_SERVER_STATUS, oci_error);
 626       if (status != OCI_SUCCESS)
 627       {
 628         o_report_error ("o_read_database", "OCIAttrGet", oci_error);
 629         return (-1);
 630       }
 631     }
 632
 633     if (connection_status != OCI_SERVER_NORMAL)
 634     {
 635       INFO ("oracle plugin: Connection to %s lost. Trying to reconnect.",
 636           db->name);
 637       OCIHandleFree (db->oci_service_context, OCI_HTYPE_SVCCTX);
 638       db->oci_service_context = NULL;
 639     }
 640   } /* if (db->oci_service_context != NULL) */
 641
 642   if (db->oci_service_context == NULL)
 643   {
 644     status = OCILogon (oci_env, oci_error,
 645         &db->oci_service_context,
 646         (OraText *) db->username, (ub4) strlen (db->username),
 647         (OraText *) db->password, (ub4) strlen (db->password),
 648         (OraText *) db->connect_id, (ub4) strlen (db->connect_id));
 649     if (status != OCI_SUCCESS)
 650     {
 651       o_report_error ("o_read_database", "OCILogon", oci_error);
 652       DEBUG ("oracle plugin: OCILogon (%s): db->oci_service_context = %p;",
 653           db->connect_id, db->oci_service_context);
 654       db->oci_service_context = NULL;
 655       return (-1);
 656     }
 657     assert (db->oci_service_context != NULL);
 658   }
 659
 660   DEBUG ("oracle plugin: o_read_database: db->connect_id = %s; db->oci_service_context = %p;",
 661       db->connect_id, db->oci_service_context);
 662
 663   for (i = 0; i < db->queries_num; i++)
 664     o_read_database_query (db, db->queries[i]);
 665
 666   return (0);
 667 } /* }}} int o_read_database */
 668
 669 static int o_read (void) /* {{{ */
 670 {
 671   size_t i;
 672
 673   for (i = 0; i < databases_num; i++)
 674     o_read_database (databases[i]);
 675
 676   return (0);
 677 } /* }}} int o_read */
 678
 679 static int o_shutdown (void) /* {{{ */
 680 {
 681   size_t i;
 682
 683   for (i = 0; i < databases_num; i++)
 684     if (databases[i]->oci_service_context != NULL)
 685     {
 686       OCIHandleFree (databases[i]->oci_service_context, OCI_HTYPE_SVCCTX);
 687       databases[i]->oci_service_context = NULL;
 688     }
 689
 690   for (i = 0; i < queries_num; i++)
 691   {
 692     OCIStmt *oci_statement;
 693
 694     oci_statement = udb_query_get_user_data (queries[i]);
 695     if (oci_statement != NULL)
 696     {
 697       OCIHandleFree (oci_statement, OCI_HTYPE_STMT);
 698       udb_query_set_user_data (queries[i], NULL);
 699     }
 700   }
 701
 702   OCIHandleFree (oci_env, OCI_HTYPE_ENV);
 703
 704   udb_query_free (queries, queries_num);
 705   queries = NULL;
 706   queries_num = 0;
 707
 708   return (0);
 709 } /* }}} int o_shutdown */
 710
 711 void module_register (void) /* {{{ */
 712 {
 713   plugin_register_complex_config ("oracle", o_config);
 714   plugin_register_init ("oracle", o_init);
 715   plugin_register_read ("oracle", o_read);
 716   plugin_register_shutdown ("oracle", o_shutdown);
 717 } /* }}} void module_register */
 718
 719 /*
 720  * vim: shiftwidth=2 softtabstop=2 et fdm=marker
 721  */