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