Debian Codegraph @

agent/mibgroup/ucd-snmp/dlmod.c

raw
1 /*
2 * Dynamic Loadable Agent Modules MIB (UCD-DLMOD-MIB) - dlmod.c
3 *
4 */
5 #include <net-snmp/net-snmp-config.h>
6 #include <net-snmp/net-snmp-features.h>
7
8 #include <ctype.h>
9 #ifdef HAVE_STDLIB_H
10 #include <stdlib.h>
11 #endif
12 #include <stdio.h>
13 #ifdef HAVE_STRING_H
14 #include <string.h>
15 #else
16 #include <strings.h>
17 #endif
18
19 #include <net-snmp/net-snmp-includes.h>
20 #include <net-snmp/agent/net-snmp-agent-includes.h>
21
22 #if defined(WIN32)
23 #include <windows.h>
24 #else
25 #include <dlfcn.h>
26 #endif
27 #include "dlmod.h"
28
29 #ifndef SNMPDLMODPATH
30 #define SNMPDLMODPATH "/usr/local/lib/snmp/dlmod"
31 #endif
32
33 struct dlmod {
34 struct dlmod *next;
35 int index;
36 char name[64 + 1];
37 char path[255 + 1];
38 char *error;
39 void *handle;
40 int status;
41 };
42
43 #define DLMOD_LOADED 1
44 #define DLMOD_UNLOADED 2
45 #define DLMOD_ERROR 3
46 #define DLMOD_LOAD 4
47 #define DLMOD_UNLOAD 5
48 #define DLMOD_CREATE 6
49 #define DLMOD_DELETE 7
50
51 static struct dlmod *dlmods;
52 static unsigned int dlmod_next_index = 1;
53 static char dlmod_path[1024];
54
55 static struct dlmod *
56 dlmod_create_module(void)
57 {
58 struct dlmod **pdlmod, *dlm;
59
60 DEBUGMSGTL(("dlmod", "dlmod_create_module\n"));
61 dlm = calloc(1, sizeof(struct dlmod));
62 if (dlm == NULL)
63 return NULL;
64
65 dlm->index = dlmod_next_index++;
66 dlm->status = DLMOD_UNLOADED;
67
68 for (pdlmod = &dlmods; *pdlmod != NULL; pdlmod = &((*pdlmod)->next))
69 ;
70 *pdlmod = dlm;
71
72 return dlm;
73 }
74
75 static void
76 dlmod_delete_module(struct dlmod *dlm)
77 {
78 struct dlmod **pdlmod;
79
80 DEBUGMSGTL(("dlmod", "dlmod_delete_module\n"));
81 if (!dlm || dlm->status != DLMOD_UNLOADED)
82 return;
83
84 for (pdlmod = &dlmods; *pdlmod; pdlmod = &((*pdlmod)->next))
85 if (*pdlmod == dlm) {
86 *pdlmod = dlm->next;
87 free(dlm->error);
88 free(dlm);
89 return;
90 }
91 }
92
93 #if defined(WIN32)
94 /*
95 * See also Microsoft, "Overview of x64 Calling Conventions", MSDN
96 * (http://msdn.microsoft.com/en-us/library/ms235286.aspx).
97 */
98 #ifdef _M_X64
99 typedef int (*dl_function_ptr)(void);
100 #else
101 typedef int (__stdcall *dl_function_ptr)(void);
102 #endif
103 #else
104 typedef int (*dl_function_ptr)(void);
105 #endif
106
107 #if defined(WIN32)
108 static const char dlmod_dl_suffix[] = "dll";
109 #else
110 static const char dlmod_dl_suffix[] = "so";
111 #endif
112
113 static void* dlmod_dlopen(const char *path)
114 {
115 #if defined(WIN32)
116 return LoadLibrary(path);
117 #elif defined(RTLD_NOW)
118 return dlopen(path, RTLD_NOW);
119 #else
120 return dlopen(path, RTLD_LAZY);
121 #endif
122 }
123
124 static void dlmod_dlclose(void *handle)
125 {
126 #if defined(WIN32)
127 FreeLibrary(handle);
128 #else
129 dlclose(handle);
130 #endif
131 }
132
133 static void *dlmod_dlsym(void *handle, const char *symbol)
134 {
135 #if defined(WIN32)
136 return GetProcAddress(handle, symbol);
137 #else
138 return dlsym(handle, symbol);
139 #endif
140 }
141
142 static const char *dlmod_dlerror(void)
143 {
144 #if defined(WIN32)
145 static char errstr[256];
146 const DWORD dwErrorcode = GetLastError();
147 LPTSTR lpMsgBuf;
148
149 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
150 NULL, dwErrorcode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
151 (LPTSTR) &lpMsgBuf, 0, NULL);
152 if (lpMsgBuf) {
153 LPTSTR p;
154
155 /*
156 * Remove trailing "\r\n".
157 */
158 p = strchr(lpMsgBuf, '\r');
159 if (p)
160 *p = '\0';
161 snprintf(errstr, sizeof(errstr), "%s", lpMsgBuf);
162 LocalFree(lpMsgBuf);
163 } else {
164 snprintf(errstr, sizeof(errstr), "error code %ld", dwErrorcode);
165 }
166 return errstr;
167 #else
168 return dlerror();
169 #endif
170 }
171
172 static int dlmod_is_abs_path(const char *path)
173 {
174 #if defined(WIN32)
175 return (strncmp(path, "//", 2) == 0 || strncmp(path, "\\\\", 2) == 0) ||
176 (isalpha((u_char)path[0]) && path[1] == ':' &&
177 (path[2] == '/' || path[2] == '\\'));
178 #else
179 return path[0] == '/';
180 #endif
181 }
182
183 static void
184 dlmod_load_module(struct dlmod *dlm)
185 {
186 DEBUGMSGTL(("dlmod", "dlmod_load_module %s: %s\n", dlm->name,
187 dlm->path));
188
189 if (!dlm || (dlm->status != DLMOD_UNLOADED && dlm->status != DLMOD_ERROR))
190 return;
191
192 free(dlm->error);
193 dlm->error = NULL;
194
195 if (dlmod_is_abs_path(dlm->path)) {
196 dlm->handle = dlmod_dlopen(dlm->path);
197 if (dlm->handle == NULL) {
198 if (asprintf(&dlm->error, "dlopen(%s) failed: %s", dlm->path,
199 dlmod_dlerror()) < 0)
200 dlm->error = NULL;
201 dlm->status = DLMOD_ERROR;
202 return;
203 }
204 } else {
205 char *st, *p, *tmp_path = NULL;
206
207 for (p = strtok_r(dlmod_path, ENV_SEPARATOR, &st); p;
208 p = strtok_r(NULL, ENV_SEPARATOR, &st)) {
209 free(tmp_path);
210 if (asprintf(&tmp_path, "%s/%s.%s", p, dlm->path, dlmod_dl_suffix)
211 < 0) {
212 dlm->status = DLMOD_ERROR;
213 return;
214 }
215 DEBUGMSGTL(("dlmod", "p: %s tmp_path: %s\n", p, tmp_path));
216 dlm->handle = tmp_path ? dlmod_dlopen(tmp_path) : NULL;
217 if (dlm->handle == NULL) {
218 free(dlm->error);
219 if (asprintf(&dlm->error, "dlopen(%s) failed: %s", tmp_path,
220 dlmod_dlerror()) < 0)
221 dlm->error = NULL;
222 dlm->status = DLMOD_ERROR;
223 }
224 }
225 strlcpy(dlm->path, tmp_path, sizeof(dlm->path));
226 free(tmp_path);
227 if (dlm->status == DLMOD_ERROR)
228 return;
229 }
230 {
231 char sym_init[64 + sizeof("init_")];
232 dl_function_ptr dl_init;
233
234 snprintf(sym_init, sizeof(sym_init), "init_%s", dlm->name);
235 dl_init = dlmod_dlsym(dlm->handle, sym_init);
236 if (dl_init == NULL) {
237 dlmod_dlclose(dlm->handle);
238 free(dlm->error);
239 if (asprintf(&dlm->error, "dlsym failed: can't find \'%s\'",
240 sym_init) < 0)
241 dlm->error = NULL;
242 dlm->status = DLMOD_ERROR;
243 return;
244 }
245 dl_init();
246 }
247
248 dlm->error = NULL;
249 dlm->status = DLMOD_LOADED;
250 }
251
252 static void
253 dlmod_unload_module(struct dlmod *dlm)
254 {
255 char sym_deinit[64 + sizeof("shutdown_")];
256 dl_function_ptr dl_deinit;
257
258 if (!dlm || dlm->status != DLMOD_LOADED)
259 return;
260
261 snprintf(sym_deinit, sizeof(sym_deinit), "deinit_%s", dlm->name);
262 dl_deinit = dlmod_dlsym(dlm->handle, sym_deinit);
263 if (!dl_deinit) {
264 snprintf(sym_deinit, sizeof(sym_deinit), "shutdown_%s", dlm->name);
265 dl_deinit = dlmod_dlsym(dlm->handle, sym_deinit);
266 }
267 if (dl_deinit) {
268 DEBUGMSGTL(("dlmod", "Calling %s()\n", sym_deinit));
269 dl_deinit();
270 } else {
271 DEBUGMSGTL(("dlmod", "No destructor for %s\n", dlm->name));
272 }
273 dlmod_dlclose(dlm->handle);
274 dlm->status = DLMOD_UNLOADED;
275 DEBUGMSGTL(("dlmod", "Module %s unloaded\n", dlm->name));
276 }
277
278 static struct dlmod *
279 dlmod_get_by_index(int iindex)
280 {
281 struct dlmod *dlmod;
282
283 for (dlmod = dlmods; dlmod; dlmod = dlmod->next)
284 if (dlmod->index == iindex)
285 return dlmod;
286
287 return NULL;
288 }
289
290 /*
291 * Functions to parse config lines
292 */
293
294 static void
295 dlmod_parse_config(const char *token, char *cptr)
296 {
297 char *dlm_name, *dlm_path;
298 struct dlmod *dlm;
299 char *st;
300
301 if (cptr == NULL) {
302 config_perror("Bad dlmod line");
303 return;
304 }
305 /*
306 * remove comments
307 */
308 *(cptr + strcspn(cptr, "#;\r\n")) = '\0';
309
310 dlm = dlmod_create_module();
311 if (!dlm)
312 return;
313
314 /*
315 * dynamic module name
316 */
317 dlm_name = strtok_r(cptr, "\t ", &st);
318 if (dlm_name == NULL) {
319 config_perror("Bad dlmod line");
320 dlmod_delete_module(dlm);
321 return;
322 }
323 strlcpy(dlm->name, dlm_name, sizeof(dlm->name));
324
325 /*
326 * dynamic module path
327 */
328 dlm_path = strtok_r(NULL, "\t ", &st);
329 if (dlm_path)
330 strlcpy(dlm->path, dlm_path, sizeof(dlm->path));
331 else
332 strlcpy(dlm->path, dlm_name, sizeof(dlm->path));
333
334 dlmod_load_module(dlm);
335
336 if (dlm->status == DLMOD_ERROR)
337 snmp_log(LOG_ERR, "%s\n", dlm->error);
338 }
339
340 static void
341 dlmod_free_config(void)
342 {
343 struct dlmod *dtmp, *dtmp2;
344
345 for (dtmp = dlmods; dtmp != NULL;) {
346 dtmp2 = dtmp;
347 dtmp = dtmp->next;
348 dlmod_unload_module(dtmp2);
349 free(dtmp2->error);
350 free(dtmp2);
351 }
352 dlmods = NULL;
353 }
354
355 /*
356 * Functions to handle SNMP management
357 */
358
359 #define DLMODNEXTINDEX 1
360 #define DLMODINDEX 2
361 #define DLMODNAME 3
362 #define DLMODPATH 4
363 #define DLMODERROR 5
364 #define DLMODSTATUS 6
365
366 /*
367 * header_dlmod(...
368 * Arguments:
369 * vp IN - pointer to variable entry that points here
370 * name IN/OUT - IN/name requested, OUT/name found
371 * length IN/OUT - length of IN/OUT oid's
372 * exact IN - TRUE if an exact match was requested
373 * var_len OUT - length of variable or 0 if function returned
374 * write_method
375 */
376
377 static int
378 header_dlmod(struct variable *vp,
379 oid * name,
380 size_t * length,
381 int exact, size_t * var_len, WriteMethod ** write_method)
382 {
383 #define DLMOD_NAME_LENGTH 10
384 oid newname[MAX_OID_LEN];
385 int result;
386
387 memcpy(newname, vp->name, vp->namelen * sizeof(oid));
388 newname[DLMOD_NAME_LENGTH] = 0;
389
390 result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
391 if ((exact && (result != 0)) || (!exact && (result >= 0))) {
392 return MATCH_FAILED;
393 }
394
395 memcpy(name, newname, (vp->namelen + 1) * sizeof(oid));
396 *length = vp->namelen + 1;
397 *write_method = NULL;
398 *var_len = sizeof(long); /* default to 'long' results */
399 return MATCH_SUCCEEDED;
400 }
401
402
403 static u_char *
404 var_dlmod(struct variable * vp,
405 oid * name,
406 size_t * length,
407 int exact, size_t * var_len, WriteMethod ** write_method)
408 {
409
410 /*
411 * variables we may use later
412 */
413
414 *write_method = NULL; /* assume it isn't writable for the time being */
415 *var_len = sizeof(int); /* assume an integer and change later if not */
416
417 if (header_dlmod(vp, name, length, exact,
418 var_len, write_method) == MATCH_FAILED)
419 return NULL;
420
421 /*
422 * this is where we do the value assignments for the mib results.
423 */
424 switch (vp->magic) {
425 case DLMODNEXTINDEX:
426 long_return = dlmod_next_index;
427 return (unsigned char *) &long_return;
428 default:
429 DEBUGMSGTL(("dlmod", "unknown sub-id %d in var_dlmod\n",
430 vp->magic));
431 }
432 return NULL;
433 }
434
435
436 static int
437 write_dlmodName(int action,
438 u_char * var_val,
439 u_char var_val_type,
440 size_t var_val_len,
441 u_char * statP, oid * name, size_t name_len)
442 {
443 static struct dlmod *dlm;
444
445 if (var_val_type != ASN_OCTET_STR) {
446 snmp_log(LOG_ERR, "write to dlmodName not ASN_OCTET_STR\n");
447 return SNMP_ERR_WRONGTYPE;
448 }
449 if (var_val_len > sizeof(dlm->name)-1) {
450 snmp_log(LOG_ERR, "write to dlmodName: bad length: too long\n");
451 return SNMP_ERR_WRONGLENGTH;
452 }
453 if (action == COMMIT) {
454 dlm = dlmod_get_by_index(name[12]);
455 if (!dlm || dlm->status == DLMOD_LOADED)
456 return SNMP_ERR_RESOURCEUNAVAILABLE;
457 strncpy(dlm->name, (const char *) var_val, var_val_len);
458 dlm->name[var_val_len] = 0;
459 }
460 return SNMP_ERR_NOERROR;
461 }
462
463 static int
464 write_dlmodPath(int action,
465 u_char * var_val,
466 u_char var_val_type,
467 size_t var_val_len,
468 u_char * statP, oid * name, size_t name_len)
469 {
470 static struct dlmod *dlm;
471
472 if (var_val_type != ASN_OCTET_STR) {
473 snmp_log(LOG_ERR, "write to dlmodPath not ASN_OCTET_STR\n");
474 return SNMP_ERR_WRONGTYPE;
475 }
476 if (var_val_len > sizeof(dlm->path)-1) {
477 snmp_log(LOG_ERR, "write to dlmodPath: bad length: too long\n");
478 return SNMP_ERR_WRONGLENGTH;
479 }
480 if (action == COMMIT) {
481 dlm = dlmod_get_by_index(name[12]);
482 if (!dlm || dlm->status == DLMOD_LOADED)
483 return SNMP_ERR_RESOURCEUNAVAILABLE;
484 strncpy(dlm->path, (const char *) var_val, var_val_len);
485 dlm->path[var_val_len] = 0;
486 }
487 return SNMP_ERR_NOERROR;
488 }
489
490 static int
491 write_dlmodStatus(int action,
492 u_char * var_val,
493 u_char var_val_type,
494 size_t var_val_len,
495 u_char * statP, oid * name, size_t name_len)
496 {
497 /*
498 * variables we may use later
499 */
500 struct dlmod *dlm;
501
502 if (var_val_type != ASN_INTEGER) {
503 snmp_log(LOG_ERR, "write to dlmodStatus not ASN_INTEGER\n");
504 return SNMP_ERR_WRONGTYPE;
505 }
506 if (var_val_len > sizeof(long)) {
507 snmp_log(LOG_ERR, "write to dlmodStatus: bad length\n");
508 return SNMP_ERR_WRONGLENGTH;
509 }
510 if (action == COMMIT) {
511 /*
512 * object identifier in form .1.3.6.1.4.1.2021.13.14.2.1.4.x
513 * where X is index with offset 12
514 */
515
516 dlm = dlmod_get_by_index(name[12]);
517 switch (*((long *) var_val)) {
518 case DLMOD_CREATE:
519 if (dlm || (name[12] != dlmod_next_index))
520 return SNMP_ERR_RESOURCEUNAVAILABLE;
521 dlm = dlmod_create_module();
522 if (!dlm)
523 return SNMP_ERR_RESOURCEUNAVAILABLE;
524 break;
525 case DLMOD_LOAD:
526 if (!dlm || dlm->status == DLMOD_LOADED)
527 return SNMP_ERR_RESOURCEUNAVAILABLE;
528 dlmod_load_module(dlm);
529 break;
530 case DLMOD_UNLOAD:
531 if (!dlm || dlm->status != DLMOD_LOADED)
532 return SNMP_ERR_RESOURCEUNAVAILABLE;
533 dlmod_unload_module(dlm);
534 break;
535 case DLMOD_DELETE:
536 if (!dlm || dlm->status == DLMOD_LOADED)
537 return SNMP_ERR_RESOURCEUNAVAILABLE;
538 dlmod_delete_module(dlm);
539 break;
540 default:
541 return SNMP_ERR_WRONGVALUE;
542 }
543 }
544 return SNMP_ERR_NOERROR;
545 }
546
547 /*
548 * header_dlmodEntry(...
549 * Arguments:
550 * vp IN - pointer to variable entry that points here
551 * name IN/OUT - IN/name requested, OUT/name found
552 * length IN/OUT - length of IN/OUT oid's
553 * exact IN - TRUE if an exact match was requested
554 * var_len OUT - length of variable or 0 if function returned
555 * write_method
556 *
557 */
558
559
560 static struct dlmod *
561 header_dlmodEntry(struct variable *vp,
562 oid * name,
563 size_t * length,
564 int exact, size_t * var_len, WriteMethod ** write_method)
565 {
566 #define DLMODENTRY_NAME_LENGTH 12
567 oid newname[MAX_OID_LEN];
568 int result;
569 struct dlmod *dlm = NULL;
570 unsigned int dlmod_index;
571
572 memcpy(newname, vp->name, vp->namelen * sizeof(oid));
573 *write_method = NULL;
574
575 for (dlmod_index = 1; dlmod_index < dlmod_next_index; dlmod_index++) {
576 dlm = dlmod_get_by_index(dlmod_index);
577
578 DEBUGMSGTL(("dlmod", "dlmodEntry dlm: %p dlmod_index: %d\n",
579 dlm, dlmod_index));
580
581 if (dlm) {
582 newname[12] = dlmod_index;
583 result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
584
585 if ((exact && (result == 0)) || (!exact && (result < 0)))
586 break;
587 }
588 }
589
590 if (dlmod_index >= dlmod_next_index) {
591 if (dlmod_index == dlmod_next_index &&
592 exact && vp->magic == DLMODSTATUS)
593
594 *write_method = write_dlmodStatus;
595 return NULL;
596 }
597
598 memcpy(name, newname, (vp->namelen + 1) * sizeof(oid));
599 *length = vp->namelen + 1;
600 *var_len = sizeof(long);
601 return dlm;
602 }
603
604 static u_char *
605 var_dlmodEntry(struct variable * vp,
606 oid * name,
607 size_t * length,
608 int exact, size_t * var_len, WriteMethod ** write_method)
609 {
610 /*
611 * variables we may use later
612 */
613 struct dlmod *dlm;
614
615 *var_len = sizeof(int); /* assume an integer and change later
616 * if not */
617
618 dlm = header_dlmodEntry(vp, name, length, exact, var_len, write_method);
619 if (dlm == NULL)
620 return NULL;
621
622 /*
623 * this is where we do the value assignments for the mib results.
624 */
625 switch (vp->magic) {
626 case DLMODNAME:
627 *write_method = write_dlmodName;
628 *var_len = strlen(dlm->name);
629 return (unsigned char *) dlm->name;
630 case DLMODPATH:
631 *write_method = write_dlmodPath;
632 *var_len = strlen(dlm->path);
633 return (unsigned char *) dlm->path;
634 case DLMODERROR:
635 *var_len = dlm->error ? strlen(dlm->error) : 0;
636 return (unsigned char *) dlm->error;
637 case DLMODSTATUS:
638 *write_method = write_dlmodStatus;
639 long_return = dlm->status;
640 return (unsigned char *) &long_return;
641 default:
642 DEBUGMSGTL(("dlmod", "unknown sub-id %d in var_dlmodEntry\n",
643 vp->magic));
644 }
645 return NULL;
646 }
647
648 /*
649 * this variable defines function callbacks and type return
650 * information for the dlmod mib
651 */
652 static struct variable4 dlmod_variables[] = {
653 {DLMODNEXTINDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
654 var_dlmod, 1, {1}},
655 {DLMODNAME, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
656 var_dlmodEntry, 3, {2, 1, 2}},
657 {DLMODPATH, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
658 var_dlmodEntry, 3, {2, 1, 3}},
659 {DLMODERROR, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
660 var_dlmodEntry, 3, {2, 1, 4}},
661 {DLMODSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
662 var_dlmodEntry, 3, {2, 1, 5}},
663 };
664
665 static oid dlmod_variables_oid[] = { 1, 3, 6, 1, 4, 1, 2021, 13, 14 };
666
667 void
668 init_dlmod(void)
669 {
670 REGISTER_MIB("dlmod", dlmod_variables, variable4, dlmod_variables_oid);
671
672 /*
673 * TODO: REGISTER_SYSOR_ENTRY
674 */
675
676 DEBUGMSGTL(("dlmod", "register mib\n"));
677
678 snmpd_register_config_handler("dlmod", dlmod_parse_config,
679 dlmod_free_config,
680 "module-name module-path");
681
682 {
683 const char * const p = getenv("SNMPDLMODPATH");
684 strncpy(dlmod_path, SNMPDLMODPATH, sizeof(dlmod_path));
685 dlmod_path[ sizeof(dlmod_path) - 1 ] = 0;
686 if (p) {
687 if (p[0] == ':') {
688 int len = strlen(dlmod_path);
689 if (dlmod_path[len - 1] != ':') {
690 strncat(dlmod_path, ":", sizeof(dlmod_path) - len - 1);
691 len++;
692 }
693 strncat(dlmod_path, p + 1, sizeof(dlmod_path) - len);
694 } else
695 strncpy(dlmod_path, p, sizeof(dlmod_path));
696 }
697 }
698
699 dlmod_path[ sizeof(dlmod_path)-1 ] = 0;
700 DEBUGMSGTL(("dlmod", "dlmod_path: %s\n", dlmod_path));
701 }
702
703 netsnmp_feature_require(snmpd_unregister_config_handler);
704
705 void
706 shutdown_dlmod(void)
707 {
708 snmpd_unregister_config_handler("dlmod");
709 unregister_mib(dlmod_variables_oid, OID_LENGTH(dlmod_variables_oid));
710 }