Merged revisions 69702 via svnmerge from
[asterisk/asterisk.git] / res / res_config_odbc.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * Copyright (C) 2004 - 2005 Anthony Minessale II <anthmct@yahoo.com>
9  *
10  * See http://www.asterisk.org for more information about
11  * the Asterisk project. Please do not directly contact
12  * any of the maintainers of this project for assistance;
13  * the project provides a web site, mailing lists and IRC
14  * channels for your use.
15  *
16  * This program is free software, distributed under the terms of
17  * the GNU General Public License Version 2. See the LICENSE file
18  * at the top of the source tree.
19  */
20
21 /*! \file
22  *
23  * \brief odbc+odbc plugin for portable configuration engine
24  *
25  * \author Mark Spencer <markster@digium.com>
26  * \author Anthony Minessale II <anthmct@yahoo.com>
27  *
28  * \arg http://www.unixodbc.org
29  */
30
31 /*** MODULEINFO
32         <depend>unixodbc</depend>
33         <depend>ltdl</depend>
34         <depend>res_odbc</depend>
35  ***/
36
37 #include "asterisk.h"
38
39 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
40
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <unistd.h>
44 #include <string.h>
45
46 #include "asterisk/file.h"
47 #include "asterisk/logger.h"
48 #include "asterisk/channel.h"
49 #include "asterisk/pbx.h"
50 #include "asterisk/config.h"
51 #include "asterisk/module.h"
52 #include "asterisk/lock.h"
53 #include "asterisk/options.h"
54 #include "asterisk/res_odbc.h"
55 #include "asterisk/utils.h"
56
57 static struct ast_variable *realtime_odbc(const char *database, const char *table, va_list ap)
58 {
59         struct odbc_obj *obj;
60         SQLHSTMT stmt;
61         char sql[1024];
62         char coltitle[256];
63         char rowdata[2048];
64         char *op;
65         const char *newparam, *newval;
66         char *stringp;
67         char *chunk;
68         SQLSMALLINT collen;
69         int res;
70         int x;
71         struct ast_variable *var=NULL, *prev=NULL;
72         SQLULEN colsize;
73         SQLSMALLINT colcount=0;
74         SQLSMALLINT datatype;
75         SQLSMALLINT decimaldigits;
76         SQLSMALLINT nullable;
77         SQLLEN indicator;
78         va_list aq;
79         
80         va_copy(aq, ap);
81         
82         
83         if (!table)
84                 return NULL;
85
86         obj = ast_odbc_request_obj(database, 0);
87         if (!obj)
88                 return NULL;
89
90         res = SQLAllocHandle (SQL_HANDLE_STMT, obj->con, &stmt);
91         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
92                 ast_log(LOG_WARNING, "SQL Alloc Handle failed!\n");
93                 ast_odbc_release_obj(obj);
94                 return NULL;
95         }
96
97         newparam = va_arg(aq, const char *);
98         if (!newparam)  {
99                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
100                 ast_odbc_release_obj(obj);
101                 return NULL;
102         }
103         newval = va_arg(aq, const char *);
104         if (!strchr(newparam, ' ')) op = " ="; else op = "";
105         snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s ?", table, newparam, op);
106         while((newparam = va_arg(aq, const char *))) {
107                 if (!strchr(newparam, ' ')) op = " ="; else op = "";
108                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s ?", newparam, op);
109                 newval = va_arg(aq, const char *);
110         }
111         va_end(aq);
112         res = SQLPrepare(stmt, (unsigned char *)sql, SQL_NTS);
113         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
114                 ast_log(LOG_WARNING, "SQL Prepare failed![%s]\n", sql);
115                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
116                 ast_odbc_release_obj(obj);
117                 return NULL;
118         }
119         
120         /* Now bind the parameters */
121         x = 1;
122
123         while((newparam = va_arg(ap, const char *))) {
124                 newval = va_arg(ap, const char *);
125                 SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL);
126         }
127         
128         res = ast_odbc_smart_execute(obj, stmt);
129
130         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
131                 ast_log(LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
132                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
133                 ast_odbc_release_obj(obj);
134                 return NULL;
135         }
136
137         res = SQLNumResultCols(stmt, &colcount);
138         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
139                 ast_log(LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql);
140                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
141                 ast_odbc_release_obj(obj);
142                 return NULL;
143         }
144
145         res = SQLFetch(stmt);
146         if (res == SQL_NO_DATA) {
147                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
148                 ast_odbc_release_obj(obj);
149                 return NULL;
150         }
151         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
152                 ast_log(LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
153                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
154                 ast_odbc_release_obj(obj);
155                 return NULL;
156         }
157         for (x = 0; x < colcount; x++) {
158                 rowdata[0] = '\0';
159                 collen = sizeof(coltitle);
160                 res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen, 
161                                         &datatype, &colsize, &decimaldigits, &nullable);
162                 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
163                         ast_log(LOG_WARNING, "SQL Describe Column error!\n[%s]\n\n", sql);
164                         if (var)
165                                 ast_variables_destroy(var);
166                         ast_odbc_release_obj(obj);
167                         return NULL;
168                 }
169
170                 indicator = 0;
171                 res = SQLGetData(stmt, x + 1, SQL_CHAR, rowdata, sizeof(rowdata), &indicator);
172                 if (indicator == SQL_NULL_DATA)
173                         rowdata[0] = '\0';
174                 else if (ast_strlen_zero(rowdata)) {
175                         /* Because we encode the empty string for a NULL, we will encode
176                          * actual empty strings as a string containing a single whitespace. */
177                         ast_copy_string(rowdata, " ", sizeof(rowdata));
178                 }
179
180                 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
181                         ast_log(LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
182                         if (var)
183                                 ast_variables_destroy(var);
184                         ast_odbc_release_obj(obj);
185                         return NULL;
186                 }
187                 stringp = rowdata;
188                 while(stringp) {
189                         chunk = strsep(&stringp, ";");
190                         if (prev) {
191                                 prev->next = ast_variable_new(coltitle, chunk);
192                                 if (prev->next)
193                                         prev = prev->next;
194                         } else 
195                                 prev = var = ast_variable_new(coltitle, chunk);
196                 }
197         }
198
199
200         SQLFreeHandle (SQL_HANDLE_STMT, stmt);
201         ast_odbc_release_obj(obj);
202         return var;
203 }
204
205 static struct ast_config *realtime_multi_odbc(const char *database, const char *table, va_list ap)
206 {
207         struct odbc_obj *obj;
208         SQLHSTMT stmt;
209         char sql[1024];
210         char coltitle[256];
211         char rowdata[2048];
212         const char *initfield=NULL;
213         char *op;
214         const char *newparam, *newval;
215         char *stringp;
216         char *chunk;
217         SQLSMALLINT collen;
218         int res;
219         int x;
220         struct ast_variable *var=NULL;
221         struct ast_config *cfg=NULL;
222         struct ast_category *cat=NULL;
223         struct ast_realloca ra;
224         SQLULEN colsize;
225         SQLSMALLINT colcount=0;
226         SQLSMALLINT datatype;
227         SQLSMALLINT decimaldigits;
228         SQLSMALLINT nullable;
229         SQLLEN indicator;
230
231         va_list aq;
232         va_copy(aq, ap);
233         
234         
235         if (!table)
236                 return NULL;
237         memset(&ra, 0, sizeof(ra));
238
239         obj = ast_odbc_request_obj(database, 0);
240         if (!obj)
241                 return NULL;
242
243         res = SQLAllocHandle (SQL_HANDLE_STMT, obj->con, &stmt);
244         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
245                 ast_log(LOG_WARNING, "SQL Alloc Handle failed!\n");
246                 ast_odbc_release_obj(obj);
247                 return NULL;
248         }
249
250         newparam = va_arg(aq, const char *);
251         if (!newparam)  {
252                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
253                 ast_odbc_release_obj(obj);
254                 return NULL;
255         }
256         initfield = ast_strdupa(newparam);
257         if ((op = strchr(initfield, ' '))) 
258                 *op = '\0';
259         newval = va_arg(aq, const char *);
260         if (!strchr(newparam, ' ')) op = " ="; else op = "";
261         snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s ?", table, newparam, op);
262         while((newparam = va_arg(aq, const char *))) {
263                 if (!strchr(newparam, ' ')) op = " ="; else op = "";
264                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s ?", newparam, op);
265                 newval = va_arg(aq, const char *);
266         }
267         if (initfield)
268                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " ORDER BY %s", initfield);
269         va_end(aq);
270         res = SQLPrepare(stmt, (unsigned char *)sql, SQL_NTS);
271         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
272                 ast_log(LOG_WARNING, "SQL Prepare failed![%s]\n", sql);
273                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
274                 ast_odbc_release_obj(obj);
275                 return NULL;
276         }
277         
278         /* Now bind the parameters */
279         x = 1;
280
281         while((newparam = va_arg(ap, const char *))) {
282                 newval = va_arg(ap, const char *);
283                 SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL);
284         }
285                 
286         res = ast_odbc_smart_execute(obj, stmt);
287
288         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
289                 ast_log(LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
290                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
291                 ast_odbc_release_obj(obj);
292                 return NULL;
293         }
294
295         res = SQLNumResultCols(stmt, &colcount);
296         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
297                 ast_log(LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql);
298                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
299                 ast_odbc_release_obj(obj);
300                 return NULL;
301         }
302
303         cfg = ast_config_new();
304         if (!cfg) {
305                 ast_log(LOG_WARNING, "Out of memory!\n");
306                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
307                 ast_odbc_release_obj(obj);
308                 return NULL;
309         }
310
311         while ((res=SQLFetch(stmt)) != SQL_NO_DATA) {
312                 var = NULL;
313                 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
314                         ast_log(LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
315                         continue;
316                 }
317                 cat = ast_category_new("");
318                 if (!cat) {
319                         ast_log(LOG_WARNING, "Out of memory!\n");
320                         continue;
321                 }
322                 for (x=0;x<colcount;x++) {
323                         rowdata[0] = '\0';
324                         collen = sizeof(coltitle);
325                         res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen, 
326                                                 &datatype, &colsize, &decimaldigits, &nullable);
327                         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
328                                 ast_log(LOG_WARNING, "SQL Describe Column error!\n[%s]\n\n", sql);
329                                 ast_category_destroy(cat);
330                                 continue;
331                         }
332
333                         indicator = 0;
334                         res = SQLGetData(stmt, x + 1, SQL_CHAR, rowdata, sizeof(rowdata), &indicator);
335                         if (indicator == SQL_NULL_DATA)
336                                 continue;
337
338                         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
339                                 ast_log(LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
340                                 ast_category_destroy(cat);
341                                 continue;
342                         }
343                         stringp = rowdata;
344                         while(stringp) {
345                                 chunk = strsep(&stringp, ";");
346                                 if (!ast_strlen_zero(ast_strip(chunk))) {
347                                         if (initfield && !strcmp(initfield, coltitle))
348                                                 ast_category_rename(cat, chunk);
349                                         var = ast_variable_new(coltitle, chunk);
350                                         ast_variable_append(cat, var);
351                                 }
352                         }
353                 }
354                 ast_category_append(cfg, cat);
355         }
356
357         SQLFreeHandle(SQL_HANDLE_STMT, stmt);
358         ast_odbc_release_obj(obj);
359         return cfg;
360 }
361
362 static int update_odbc(const char *database, const char *table, const char *keyfield, const char *lookup, va_list ap)
363 {
364         struct odbc_obj *obj;
365         SQLHSTMT stmt;
366         char sql[256];
367         SQLLEN rowcount=0;
368         const char *newparam, *newval;
369         int res;
370         int x;
371         va_list aq;
372         
373         va_copy(aq, ap);
374         
375         if (!table)
376                 return -1;
377
378         obj = ast_odbc_request_obj(database, 0);
379         if (!obj)
380                 return -1;
381
382         res = SQLAllocHandle (SQL_HANDLE_STMT, obj->con, &stmt);
383         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
384                 ast_log(LOG_WARNING, "SQL Alloc Handle failed!\n");
385                 ast_odbc_release_obj(obj);
386                 return -1;
387         }
388
389         newparam = va_arg(aq, const char *);
390         if (!newparam)  {
391                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
392                 ast_odbc_release_obj(obj);
393                 return -1;
394         }
395         newval = va_arg(aq, const char *);
396         snprintf(sql, sizeof(sql), "UPDATE %s SET %s=?", table, newparam);
397         while((newparam = va_arg(aq, const char *))) {
398                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), ", %s=?", newparam);
399                 newval = va_arg(aq, const char *);
400         }
401         va_end(aq);
402         snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " WHERE %s=?", keyfield);
403         
404         res = SQLPrepare(stmt, (unsigned char *)sql, SQL_NTS);
405         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
406                 ast_log(LOG_WARNING, "SQL Prepare failed![%s]\n", sql);
407                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
408                 ast_odbc_release_obj(obj);
409                 return -1;
410         }
411         
412         /* Now bind the parameters */
413         x = 1;
414
415         while((newparam = va_arg(ap, const char *))) {
416                 newval = va_arg(ap, const char *);
417                 SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL);
418         }
419                 
420         SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(lookup), 0, (void *)lookup, 0, NULL);
421
422         res = ast_odbc_smart_execute(obj, stmt);
423
424         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
425                 ast_log(LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
426                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
427                 ast_odbc_release_obj(obj);
428                 return -1;
429         }
430
431         res = SQLRowCount(stmt, &rowcount);
432         SQLFreeHandle (SQL_HANDLE_STMT, stmt);
433         ast_odbc_release_obj(obj);
434
435         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
436                 ast_log(LOG_WARNING, "SQL Row Count error!\n[%s]\n\n", sql);
437                 return -1;
438         }
439
440         if (rowcount >= 0)
441                 return (int)rowcount;
442
443         return -1;
444 }
445
446 struct config_odbc_obj {
447         char *sql;
448         unsigned long cat_metric;
449         char category[128];
450         char var_name[128];
451         char var_val[1024]; /* changed from 128 to 1024 via bug 8251 */
452         SQLLEN err;
453 };
454
455 static SQLHSTMT config_odbc_prepare(struct odbc_obj *obj, void *data)
456 {
457         struct config_odbc_obj *q = data;
458         SQLHSTMT sth;
459         int res;
460
461         res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &sth);
462         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
463                 if (option_verbose > 3)
464                         ast_verbose( VERBOSE_PREFIX_4 "Failure in AllocStatement %d\n", res);
465                 return NULL;
466         }
467
468         res = SQLPrepare(sth, (unsigned char *)q->sql, SQL_NTS);
469         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
470                 if (option_verbose > 3)
471                         ast_verbose( VERBOSE_PREFIX_4 "Error in PREPARE %d\n", res);
472                 SQLFreeHandle(SQL_HANDLE_STMT, sth);
473                 return NULL;
474         }
475
476         SQLBindCol(sth, 1, SQL_C_ULONG, &q->cat_metric, sizeof(q->cat_metric), &q->err);
477         SQLBindCol(sth, 2, SQL_C_CHAR, q->category, sizeof(q->category), &q->err);
478         SQLBindCol(sth, 3, SQL_C_CHAR, q->var_name, sizeof(q->var_name), &q->err);
479         SQLBindCol(sth, 4, SQL_C_CHAR, q->var_val, sizeof(q->var_val), &q->err);
480
481         return sth;
482 }
483
484 static struct ast_config *config_odbc(const char *database, const char *table, const char *file, struct ast_config *cfg, int withcomments)
485 {
486         struct ast_variable *new_v;
487         struct ast_category *cur_cat;
488         int res = 0;
489         struct odbc_obj *obj;
490         char sqlbuf[1024] = "";
491         char *sql = sqlbuf;
492         size_t sqlleft = sizeof(sqlbuf);
493         unsigned int last_cat_metric = 0;
494         SQLSMALLINT rowcount = 0;
495         SQLHSTMT stmt;
496         char last[128] = "";
497         struct config_odbc_obj q;
498
499         memset(&q, 0, sizeof(q));
500
501         if (!file || !strcmp (file, "res_config_odbc.conf"))
502                 return NULL;            /* cant configure myself with myself ! */
503
504         obj = ast_odbc_request_obj(database, 0);
505         if (!obj)
506                 return NULL;
507
508         ast_build_string(&sql, &sqlleft, "SELECT cat_metric, category, var_name, var_val FROM %s ", table);
509         ast_build_string(&sql, &sqlleft, "WHERE filename='%s' AND commented=0 ", file);
510         ast_build_string(&sql, &sqlleft, "ORDER BY cat_metric DESC, var_metric ASC, category, var_name ");
511         q.sql = sqlbuf;
512
513         stmt = ast_odbc_prepare_and_execute(obj, config_odbc_prepare, &q);
514
515         if (!stmt) {
516                 ast_log(LOG_WARNING, "SQL select error!\n[%s]\n\n", sql);
517                 ast_odbc_release_obj(obj);
518                 return NULL;
519         }
520
521         res = SQLNumResultCols(stmt, &rowcount);
522
523         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
524                 ast_log(LOG_WARNING, "SQL NumResultCols error!\n[%s]\n\n", sql);
525                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
526                 ast_odbc_release_obj(obj);
527                 return NULL;
528         }
529
530         if (!rowcount) {
531                 ast_log(LOG_NOTICE, "found nothing\n");
532                 ast_odbc_release_obj(obj);
533                 return cfg;
534         }
535
536         cur_cat = ast_config_get_current_category(cfg);
537
538         while ((res = SQLFetch(stmt)) != SQL_NO_DATA) {
539                 if (!strcmp (q.var_name, "#include")) {
540                         if (!ast_config_internal_load(q.var_val, cfg, 0)) {
541                                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
542                                 ast_odbc_release_obj(obj);
543                                 return NULL;
544                         }
545                         continue;
546                 } 
547                 if (strcmp(last, q.category) || last_cat_metric != q.cat_metric) {
548                         cur_cat = ast_category_new(q.category);
549                         if (!cur_cat) {
550                                 ast_log(LOG_WARNING, "Out of memory!\n");
551                                 break;
552                         }
553                         strcpy(last, q.category);
554                         last_cat_metric = q.cat_metric;
555                         ast_category_append(cfg, cur_cat);
556                 }
557
558                 new_v = ast_variable_new(q.var_name, q.var_val);
559                 ast_variable_append(cur_cat, new_v);
560         }
561
562         SQLFreeHandle(SQL_HANDLE_STMT, stmt);
563         ast_odbc_release_obj(obj);
564         return cfg;
565 }
566
567 static struct ast_config_engine odbc_engine = {
568         .name = "odbc",
569         .load_func = config_odbc,
570         .realtime_func = realtime_odbc,
571         .realtime_multi_func = realtime_multi_odbc,
572         .update_func = update_odbc
573 };
574
575 static int unload_module (void)
576 {
577         ast_module_user_hangup_all();
578         ast_config_engine_deregister(&odbc_engine);
579         if (option_verbose)
580                 ast_verbose("res_config_odbc unloaded.\n");
581         return 0;
582 }
583
584 static int load_module (void)
585 {
586         ast_config_engine_register(&odbc_engine);
587         if (option_verbose)
588                 ast_verbose("res_config_odbc loaded.\n");
589         return 0;
590 }
591
592 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Realtime ODBC configuration",
593                 .load = load_module,
594                 .unload = unload_module,
595                 );