| 1 |
/** |
| 2 |
* collectd - src/utils_vl_lookup.c |
| 3 |
* Copyright (C) 2012 Florian Forster |
| 4 |
* |
| 5 |
* Permission is hereby granted, free of charge, to any person obtaining a |
| 6 |
* copy of this software and associated documentation files (the "Software"), |
| 7 |
* to deal in the Software without restriction, including without limitation |
| 8 |
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 9 |
* and/or sell copies of the Software, and to permit persons to whom the |
| 10 |
* Software is furnished to do so, subject to the following conditions: |
| 11 |
* |
| 12 |
* The above copyright notice and this permission notice shall be included in |
| 13 |
* all copies or substantial portions of the Software. |
| 14 |
* |
| 15 |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 16 |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 17 |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 18 |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 19 |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 20 |
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| 21 |
* DEALINGS IN THE SOFTWARE. |
| 22 |
* |
| 23 |
* Authors: |
| 24 |
* Florian Forster <octo at collectd.org> |
| 25 |
**/ |
| 26 |
|
| 27 |
#include "collectd.h" |
| 28 |
|
| 29 |
#include <pthread.h> |
| 30 |
#include <regex.h> |
| 31 |
|
| 32 |
#include "utils/avltree/avltree.h" |
| 33 |
#include "utils/common/common.h" |
| 34 |
#include "utils/lookup/vl_lookup.h" |
| 35 |
|
| 36 |
#if HAVE_KSTAT_H |
| 37 |
#include <kstat.h> |
| 38 |
#endif |
| 39 |
|
| 40 |
#if HAVE_LIBKSTAT |
| 41 |
kstat_ctl_t *kc; |
| 42 |
#endif /* HAVE_LIBKSTAT */ |
| 43 |
|
| 44 |
#if BUILD_TEST |
| 45 |
#define sstrncpy strncpy |
| 46 |
#define plugin_log(s, ...) \ |
| 47 |
do { \ |
| 48 |
printf("[severity %i] ", s); \ |
| 49 |
printf(__VA_ARGS__); \ |
| 50 |
printf("\n"); \ |
| 51 |
} while (0) |
| 52 |
#endif |
| 53 |
|
| 54 |
/* |
| 55 |
* Types |
| 56 |
*/ |
| 57 |
struct part_match_s { |
| 58 |
char str[DATA_MAX_NAME_LEN]; |
| 59 |
regex_t regex; |
| 60 |
bool is_regex; |
| 61 |
}; |
| 62 |
typedef struct part_match_s part_match_t; |
| 63 |
|
| 64 |
struct identifier_match_s { |
| 65 |
part_match_t host; |
| 66 |
part_match_t plugin; |
| 67 |
part_match_t plugin_instance; |
| 68 |
part_match_t type; |
| 69 |
part_match_t type_instance; |
| 70 |
|
| 71 |
unsigned int group_by; |
| 72 |
}; |
| 73 |
typedef struct identifier_match_s identifier_match_t; |
| 74 |
|
| 75 |
struct lookup_s { |
| 76 |
c_avl_tree_t *by_type_tree; |
| 77 |
|
| 78 |
lookup_class_callback_t cb_user_class; |
| 79 |
lookup_obj_callback_t cb_user_obj; |
| 80 |
lookup_free_class_callback_t cb_free_class; |
| 81 |
lookup_free_obj_callback_t cb_free_obj; |
| 82 |
}; |
| 83 |
|
| 84 |
struct user_obj_s; |
| 85 |
typedef struct user_obj_s user_obj_t; |
| 86 |
struct user_obj_s { |
| 87 |
void *user_obj; |
| 88 |
lookup_identifier_t ident; |
| 89 |
|
| 90 |
user_obj_t *next; |
| 91 |
}; |
| 92 |
|
| 93 |
struct user_class_s { |
| 94 |
pthread_mutex_t lock; |
| 95 |
void *user_class; |
| 96 |
identifier_match_t match; |
| 97 |
user_obj_t *user_obj_list; /* list of user_obj */ |
| 98 |
}; |
| 99 |
typedef struct user_class_s user_class_t; |
| 100 |
|
| 101 |
struct user_class_list_s; |
| 102 |
typedef struct user_class_list_s user_class_list_t; |
| 103 |
struct user_class_list_s { |
| 104 |
user_class_t entry; |
| 105 |
user_class_list_t *next; |
| 106 |
}; |
| 107 |
|
| 108 |
struct by_type_entry_s { |
| 109 |
c_avl_tree_t *by_plugin_tree; /* plugin -> user_class_list_t */ |
| 110 |
user_class_list_t *wildcard_plugin_list; |
| 111 |
}; |
| 112 |
typedef struct by_type_entry_s by_type_entry_t; |
| 113 |
|
| 114 |
/* |
| 115 |
* Private functions |
| 116 |
*/ |
| 117 |
static bool lu_part_matches(part_match_t const *match, /* {{{ */ |
| 118 |
char const *str) { |
| 119 |
if (match->is_regex) { |
| 120 |
/* Short cut popular catch-all regex. */ |
| 121 |
if (strcmp(".*", match->str) == 0) |
| 122 |
return true; |
| 123 |
|
| 124 |
int status = regexec(&match->regex, str, |
| 125 |
/* nmatch = */ 0, /* pmatch = */ NULL, |
| 126 |
/* flags = */ 0); |
| 127 |
if (status == 0) |
| 128 |
return true; |
| 129 |
else |
| 130 |
return false; |
| 131 |
} else if (strcmp(match->str, str) == 0) |
| 132 |
return true; |
| 133 |
else |
| 134 |
return false; |
| 135 |
} /* }}} bool lu_part_matches */ |
| 136 |
|
| 137 |
static int lu_copy_ident_to_match_part(part_match_t *match_part, /* {{{ */ |
| 138 |
char const *ident_part) { |
| 139 |
size_t len = strlen(ident_part); |
| 140 |
int status; |
| 141 |
|
| 142 |
if ((len < 3) || (ident_part[0] != '/') || (ident_part[len - 1] != '/')) { |
| 143 |
sstrncpy(match_part->str, ident_part, sizeof(match_part->str)); |
| 144 |
match_part->is_regex = false; |
| 145 |
return 0; |
| 146 |
} |
| 147 |
|
| 148 |
/* Copy string without the leading slash. */ |
| 149 |
sstrncpy(match_part->str, ident_part + 1, sizeof(match_part->str)); |
| 150 |
assert(sizeof(match_part->str) > len); |
| 151 |
/* strip trailing slash */ |
| 152 |
match_part->str[len - 2] = 0; |
| 153 |
|
| 154 |
status = regcomp(&match_part->regex, match_part->str, |
| 155 |
/* flags = */ REG_EXTENDED); |
| 156 |
if (status != 0) { |
| 157 |
char errbuf[1024]; |
| 158 |
regerror(status, &match_part->regex, errbuf, sizeof(errbuf)); |
| 159 |
ERROR("utils_vl_lookup: Compiling regular expression \"%s\" failed: %s", |
| 160 |
match_part->str, errbuf); |
| 161 |
return EINVAL; |
| 162 |
} |
| 163 |
match_part->is_regex = true; |
| 164 |
|
| 165 |
return 0; |
| 166 |
} /* }}} int lu_copy_ident_to_match_part */ |
| 167 |
|
| 168 |
static int lu_copy_ident_to_match(identifier_match_t *match, /* {{{ */ |
| 169 |
lookup_identifier_t const *ident, |
| 170 |
unsigned int group_by) { |
| 171 |
memset(match, 0, sizeof(*match)); |
| 172 |
|
| 173 |
match->group_by = group_by; |
| 174 |
|
| 175 |
#define COPY_FIELD(field) \ |
| 176 |
do { \ |
| 177 |
int status = lu_copy_ident_to_match_part(&match->field, ident->field); \ |
| 178 |
if (status != 0) \ |
| 179 |
return status; \ |
| 180 |
} while (0) |
| 181 |
|
| 182 |
COPY_FIELD(host); |
| 183 |
COPY_FIELD(plugin); |
| 184 |
COPY_FIELD(plugin_instance); |
| 185 |
COPY_FIELD(type); |
| 186 |
COPY_FIELD(type_instance); |
| 187 |
|
| 188 |
#undef COPY_FIELD |
| 189 |
|
| 190 |
return 0; |
| 191 |
} /* }}} int lu_copy_ident_to_match */ |
| 192 |
|
| 193 |
/* user_class->lock must be held when calling this function */ |
| 194 |
static void *lu_create_user_obj(lookup_t *obj, /* {{{ */ |
| 195 |
data_set_t const *ds, value_list_t const *vl, |
| 196 |
user_class_t *user_class) { |
| 197 |
user_obj_t *user_obj; |
| 198 |
|
| 199 |
user_obj = calloc(1, sizeof(*user_obj)); |
| 200 |
if (user_obj == NULL) { |
| 201 |
ERROR("utils_vl_lookup: calloc failed."); |
| 202 |
return NULL; |
| 203 |
} |
| 204 |
user_obj->next = NULL; |
| 205 |
|
| 206 |
user_obj->user_obj = obj->cb_user_class(ds, vl, user_class->user_class); |
| 207 |
if (user_obj->user_obj == NULL) { |
| 208 |
sfree(user_obj); |
| 209 |
WARNING("utils_vl_lookup: User-provided constructor failed."); |
| 210 |
return NULL; |
| 211 |
} |
| 212 |
|
| 213 |
#define COPY_FIELD(field, group_mask) \ |
| 214 |
do { \ |
| 215 |
if (user_class->match.field.is_regex && \ |
| 216 |
((user_class->match.group_by & group_mask) == 0)) \ |
| 217 |
sstrncpy(user_obj->ident.field, "/.*/", sizeof(user_obj->ident.field)); \ |
| 218 |
else \ |
| 219 |
sstrncpy(user_obj->ident.field, vl->field, \ |
| 220 |
sizeof(user_obj->ident.field)); \ |
| 221 |
} while (0) |
| 222 |
|
| 223 |
COPY_FIELD(host, LU_GROUP_BY_HOST); |
| 224 |
COPY_FIELD(plugin, LU_GROUP_BY_PLUGIN); |
| 225 |
COPY_FIELD(plugin_instance, LU_GROUP_BY_PLUGIN_INSTANCE); |
| 226 |
COPY_FIELD(type, 0); |
| 227 |
COPY_FIELD(type_instance, LU_GROUP_BY_TYPE_INSTANCE); |
| 228 |
|
| 229 |
#undef COPY_FIELD |
| 230 |
|
| 231 |
if (user_class->user_obj_list == NULL) { |
| 232 |
user_class->user_obj_list = user_obj; |
| 233 |
} else { |
| 234 |
user_obj_t *last = user_class->user_obj_list; |
| 235 |
while (last->next != NULL) |
| 236 |
last = last->next; |
| 237 |
last->next = user_obj; |
| 238 |
} |
| 239 |
|
| 240 |
return user_obj; |
| 241 |
} /* }}} void *lu_create_user_obj */ |
| 242 |
|
| 243 |
/* user_class->lock must be held when calling this function */ |
| 244 |
static user_obj_t *lu_find_user_obj(user_class_t *user_class, /* {{{ */ |
| 245 |
value_list_t const *vl) { |
| 246 |
user_obj_t *ptr; |
| 247 |
|
| 248 |
for (ptr = user_class->user_obj_list; ptr != NULL; ptr = ptr->next) { |
| 249 |
if (user_class->match.host.is_regex && |
| 250 |
(user_class->match.group_by & LU_GROUP_BY_HOST) && |
| 251 |
(strcmp(vl->host, ptr->ident.host) != 0)) |
| 252 |
continue; |
| 253 |
if (user_class->match.plugin.is_regex && |
| 254 |
(user_class->match.group_by & LU_GROUP_BY_PLUGIN) && |
| 255 |
(strcmp(vl->plugin, ptr->ident.plugin) != 0)) |
| 256 |
continue; |
| 257 |
if (user_class->match.plugin_instance.is_regex && |
| 258 |
(user_class->match.group_by & LU_GROUP_BY_PLUGIN_INSTANCE) && |
| 259 |
(strcmp(vl->plugin_instance, ptr->ident.plugin_instance) != 0)) |
| 260 |
continue; |
| 261 |
if (user_class->match.type_instance.is_regex && |
| 262 |
(user_class->match.group_by & LU_GROUP_BY_TYPE_INSTANCE) && |
| 263 |
(strcmp(vl->type_instance, ptr->ident.type_instance) != 0)) |
| 264 |
continue; |
| 265 |
|
| 266 |
return ptr; |
| 267 |
} |
| 268 |
|
| 269 |
return NULL; |
| 270 |
} /* }}} user_obj_t *lu_find_user_obj */ |
| 271 |
|
| 272 |
static int lu_handle_user_class(lookup_t *obj, /* {{{ */ |
| 273 |
data_set_t const *ds, value_list_t const *vl, |
| 274 |
user_class_t *user_class) { |
| 275 |
user_obj_t *user_obj; |
| 276 |
int status; |
| 277 |
|
| 278 |
assert(strcmp(vl->type, user_class->match.type.str) == 0); |
| 279 |
assert(user_class->match.plugin.is_regex || |
| 280 |
(strcmp(vl->plugin, user_class->match.plugin.str)) == 0); |
| 281 |
|
| 282 |
if (!lu_part_matches(&user_class->match.type_instance, vl->type_instance) || |
| 283 |
!lu_part_matches(&user_class->match.plugin_instance, |
| 284 |
vl->plugin_instance) || |
| 285 |
!lu_part_matches(&user_class->match.plugin, vl->plugin) || |
| 286 |
!lu_part_matches(&user_class->match.host, vl->host)) |
| 287 |
return 1; |
| 288 |
|
| 289 |
pthread_mutex_lock(&user_class->lock); |
| 290 |
user_obj = lu_find_user_obj(user_class, vl); |
| 291 |
if (user_obj == NULL) { |
| 292 |
/* call lookup_class_callback_t() and insert into the list of user objects. |
| 293 |
*/ |
| 294 |
user_obj = lu_create_user_obj(obj, ds, vl, user_class); |
| 295 |
if (user_obj == NULL) { |
| 296 |
pthread_mutex_unlock(&user_class->lock); |
| 297 |
return -1; |
| 298 |
} |
| 299 |
} |
| 300 |
pthread_mutex_unlock(&user_class->lock); |
| 301 |
|
| 302 |
status = obj->cb_user_obj(ds, vl, user_class->user_class, user_obj->user_obj); |
| 303 |
if (status != 0) { |
| 304 |
ERROR("utils_vl_lookup: The user object callback failed with status %i.", |
| 305 |
status); |
| 306 |
/* Returning a negative value means: abort! */ |
| 307 |
if (status < 0) |
| 308 |
return status; |
| 309 |
else |
| 310 |
return 1; |
| 311 |
} |
| 312 |
|
| 313 |
return 0; |
| 314 |
} /* }}} int lu_handle_user_class */ |
| 315 |
|
| 316 |
static int lu_handle_user_class_list(lookup_t *obj, /* {{{ */ |
| 317 |
data_set_t const *ds, |
| 318 |
value_list_t const *vl, |
| 319 |
user_class_list_t *user_class_list) { |
| 320 |
user_class_list_t *ptr; |
| 321 |
int retval = 0; |
| 322 |
|
| 323 |
for (ptr = user_class_list; ptr != NULL; ptr = ptr->next) { |
| 324 |
int status; |
| 325 |
|
| 326 |
status = lu_handle_user_class(obj, ds, vl, &ptr->entry); |
| 327 |
if (status < 0) |
| 328 |
return status; |
| 329 |
else if (status == 0) |
| 330 |
retval++; |
| 331 |
} |
| 332 |
|
| 333 |
return retval; |
| 334 |
} /* }}} int lu_handle_user_class_list */ |
| 335 |
|
| 336 |
static by_type_entry_t *lu_search_by_type(lookup_t *obj, /* {{{ */ |
| 337 |
char const *type, |
| 338 |
bool allocate_if_missing) { |
| 339 |
by_type_entry_t *by_type; |
| 340 |
char *type_copy; |
| 341 |
int status; |
| 342 |
|
| 343 |
status = c_avl_get(obj->by_type_tree, type, (void *)&by_type); |
| 344 |
if (status == 0) |
| 345 |
return by_type; |
| 346 |
|
| 347 |
if (!allocate_if_missing) |
| 348 |
return NULL; |
| 349 |
|
| 350 |
type_copy = strdup(type); |
| 351 |
if (type_copy == NULL) { |
| 352 |
ERROR("utils_vl_lookup: strdup failed."); |
| 353 |
return NULL; |
| 354 |
} |
| 355 |
|
| 356 |
by_type = calloc(1, sizeof(*by_type)); |
| 357 |
if (by_type == NULL) { |
| 358 |
ERROR("utils_vl_lookup: calloc failed."); |
| 359 |
sfree(type_copy); |
| 360 |
return NULL; |
| 361 |
} |
| 362 |
by_type->wildcard_plugin_list = NULL; |
| 363 |
|
| 364 |
by_type->by_plugin_tree = |
| 365 |
c_avl_create((int (*)(const void *, const void *))strcmp); |
| 366 |
if (by_type->by_plugin_tree == NULL) { |
| 367 |
ERROR("utils_vl_lookup: c_avl_create failed."); |
| 368 |
sfree(by_type); |
| 369 |
sfree(type_copy); |
| 370 |
return NULL; |
| 371 |
} |
| 372 |
|
| 373 |
status = c_avl_insert(obj->by_type_tree, |
| 374 |
/* key = */ type_copy, /* value = */ by_type); |
| 375 |
assert(status <= 0); /* >0 => entry exists => race condition. */ |
| 376 |
if (status != 0) { |
| 377 |
ERROR("utils_vl_lookup: c_avl_insert failed."); |
| 378 |
c_avl_destroy(by_type->by_plugin_tree); |
| 379 |
sfree(by_type); |
| 380 |
sfree(type_copy); |
| 381 |
return NULL; |
| 382 |
} |
| 383 |
|
| 384 |
return by_type; |
| 385 |
} /* }}} by_type_entry_t *lu_search_by_type */ |
| 386 |
|
| 387 |
static int lu_add_by_plugin(by_type_entry_t *by_type, /* {{{ */ |
| 388 |
user_class_list_t *user_class_list) { |
| 389 |
user_class_list_t *ptr = NULL; |
| 390 |
identifier_match_t const *match = &user_class_list->entry.match; |
| 391 |
|
| 392 |
/* Lookup user_class_list from the per-plugin structure. If this is the first |
| 393 |
* user_class to be added, the block returns immediately. Otherwise they will |
| 394 |
* set "ptr" to non-NULL. */ |
| 395 |
if (match->plugin.is_regex) { |
| 396 |
if (by_type->wildcard_plugin_list == NULL) { |
| 397 |
by_type->wildcard_plugin_list = user_class_list; |
| 398 |
return 0; |
| 399 |
} |
| 400 |
|
| 401 |
ptr = by_type->wildcard_plugin_list; |
| 402 |
} /* if (plugin is wildcard) */ |
| 403 |
else /* (plugin is not wildcard) */ |
| 404 |
{ |
| 405 |
int status; |
| 406 |
|
| 407 |
status = |
| 408 |
c_avl_get(by_type->by_plugin_tree, match->plugin.str, (void *)&ptr); |
| 409 |
|
| 410 |
if (status != 0) /* plugin not yet in tree */ |
| 411 |
{ |
| 412 |
char *plugin_copy = strdup(match->plugin.str); |
| 413 |
|
| 414 |
if (plugin_copy == NULL) { |
| 415 |
ERROR("utils_vl_lookup: strdup failed."); |
| 416 |
sfree(user_class_list); |
| 417 |
return ENOMEM; |
| 418 |
} |
| 419 |
|
| 420 |
status = |
| 421 |
c_avl_insert(by_type->by_plugin_tree, plugin_copy, user_class_list); |
| 422 |
if (status != 0) { |
| 423 |
ERROR("utils_vl_lookup: c_avl_insert(\"%s\") failed with status %i.", |
| 424 |
plugin_copy, status); |
| 425 |
sfree(plugin_copy); |
| 426 |
sfree(user_class_list); |
| 427 |
return status; |
| 428 |
} else { |
| 429 |
return 0; |
| 430 |
} |
| 431 |
} /* if (plugin not yet in tree) */ |
| 432 |
} /* if (plugin is not wildcard) */ |
| 433 |
|
| 434 |
assert(ptr != NULL); |
| 435 |
|
| 436 |
while (ptr->next != NULL) |
| 437 |
ptr = ptr->next; |
| 438 |
ptr->next = user_class_list; |
| 439 |
|
| 440 |
return 0; |
| 441 |
} /* }}} int lu_add_by_plugin */ |
| 442 |
|
| 443 |
static void lu_destroy_user_obj(lookup_t *obj, /* {{{ */ |
| 444 |
user_obj_t *user_obj) { |
| 445 |
while (user_obj != NULL) { |
| 446 |
user_obj_t *next = user_obj->next; |
| 447 |
|
| 448 |
if (obj->cb_free_obj != NULL) |
| 449 |
obj->cb_free_obj(user_obj->user_obj); |
| 450 |
user_obj->user_obj = NULL; |
| 451 |
|
| 452 |
sfree(user_obj); |
| 453 |
user_obj = next; |
| 454 |
} |
| 455 |
} /* }}} void lu_destroy_user_obj */ |
| 456 |
|
| 457 |
static void lu_destroy_user_class_list(lookup_t *obj, /* {{{ */ |
| 458 |
user_class_list_t *user_class_list) { |
| 459 |
while (user_class_list != NULL) { |
| 460 |
user_class_list_t *next = user_class_list->next; |
| 461 |
|
| 462 |
if (obj->cb_free_class != NULL) |
| 463 |
obj->cb_free_class(user_class_list->entry.user_class); |
| 464 |
user_class_list->entry.user_class = NULL; |
| 465 |
|
| 466 |
#define CLEAR_FIELD(field) \ |
| 467 |
do { \ |
| 468 |
if (user_class_list->entry.match.field.is_regex) { \ |
| 469 |
regfree(&user_class_list->entry.match.field.regex); \ |
| 470 |
user_class_list->entry.match.field.is_regex = false; \ |
| 471 |
} \ |
| 472 |
} while (0) |
| 473 |
|
| 474 |
CLEAR_FIELD(host); |
| 475 |
CLEAR_FIELD(plugin); |
| 476 |
CLEAR_FIELD(plugin_instance); |
| 477 |
CLEAR_FIELD(type); |
| 478 |
CLEAR_FIELD(type_instance); |
| 479 |
|
| 480 |
#undef CLEAR_FIELD |
| 481 |
|
| 482 |
lu_destroy_user_obj(obj, user_class_list->entry.user_obj_list); |
| 483 |
user_class_list->entry.user_obj_list = NULL; |
| 484 |
pthread_mutex_destroy(&user_class_list->entry.lock); |
| 485 |
|
| 486 |
sfree(user_class_list); |
| 487 |
user_class_list = next; |
| 488 |
} |
| 489 |
} /* }}} void lu_destroy_user_class_list */ |
| 490 |
|
| 491 |
static void lu_destroy_by_type(lookup_t *obj, /* {{{ */ |
| 492 |
by_type_entry_t *by_type) { |
| 493 |
|
| 494 |
while (42) { |
| 495 |
char *plugin = NULL; |
| 496 |
user_class_list_t *user_class_list = NULL; |
| 497 |
int status; |
| 498 |
|
| 499 |
status = c_avl_pick(by_type->by_plugin_tree, (void *)&plugin, |
| 500 |
(void *)&user_class_list); |
| 501 |
if (status != 0) |
| 502 |
break; |
| 503 |
|
| 504 |
DEBUG("utils_vl_lookup: lu_destroy_by_type: Destroying plugin \"%s\".", |
| 505 |
plugin); |
| 506 |
sfree(plugin); |
| 507 |
lu_destroy_user_class_list(obj, user_class_list); |
| 508 |
} |
| 509 |
|
| 510 |
c_avl_destroy(by_type->by_plugin_tree); |
| 511 |
by_type->by_plugin_tree = NULL; |
| 512 |
|
| 513 |
lu_destroy_user_class_list(obj, by_type->wildcard_plugin_list); |
| 514 |
by_type->wildcard_plugin_list = NULL; |
| 515 |
|
| 516 |
sfree(by_type); |
| 517 |
} /* }}} int lu_destroy_by_type */ |
| 518 |
|
| 519 |
/* |
| 520 |
* Public functions |
| 521 |
*/ |
| 522 |
lookup_t *lookup_create(lookup_class_callback_t cb_user_class, /* {{{ */ |
| 523 |
lookup_obj_callback_t cb_user_obj, |
| 524 |
lookup_free_class_callback_t cb_free_class, |
| 525 |
lookup_free_obj_callback_t cb_free_obj) { |
| 526 |
lookup_t *obj = calloc(1, sizeof(*obj)); |
| 527 |
if (obj == NULL) { |
| 528 |
ERROR("utils_vl_lookup: calloc failed."); |
| 529 |
return NULL; |
| 530 |
} |
| 531 |
|
| 532 |
obj->by_type_tree = c_avl_create((int (*)(const void *, const void *))strcmp); |
| 533 |
if (obj->by_type_tree == NULL) { |
| 534 |
ERROR("utils_vl_lookup: c_avl_create failed."); |
| 535 |
sfree(obj); |
| 536 |
return NULL; |
| 537 |
} |
| 538 |
|
| 539 |
obj->cb_user_class = cb_user_class; |
| 540 |
obj->cb_user_obj = cb_user_obj; |
| 541 |
obj->cb_free_class = cb_free_class; |
| 542 |
obj->cb_free_obj = cb_free_obj; |
| 543 |
|
| 544 |
return obj; |
| 545 |
} /* }}} lookup_t *lookup_create */ |
| 546 |
|
| 547 |
void lookup_destroy(lookup_t *obj) /* {{{ */ |
| 548 |
{ |
| 549 |
int status; |
| 550 |
|
| 551 |
if (obj == NULL) |
| 552 |
return; |
| 553 |
|
| 554 |
while (42) { |
| 555 |
char *type = NULL; |
| 556 |
by_type_entry_t *by_type = NULL; |
| 557 |
|
| 558 |
status = c_avl_pick(obj->by_type_tree, (void *)&type, (void *)&by_type); |
| 559 |
if (status != 0) |
| 560 |
break; |
| 561 |
|
| 562 |
DEBUG("utils_vl_lookup: lookup_destroy: Destroying type \"%s\".", type); |
| 563 |
sfree(type); |
| 564 |
lu_destroy_by_type(obj, by_type); |
| 565 |
} |
| 566 |
|
| 567 |
c_avl_destroy(obj->by_type_tree); |
| 568 |
obj->by_type_tree = NULL; |
| 569 |
|
| 570 |
sfree(obj); |
| 571 |
} /* }}} void lookup_destroy */ |
| 572 |
|
| 573 |
int lookup_add(lookup_t *obj, /* {{{ */ |
| 574 |
lookup_identifier_t const *ident, unsigned int group_by, |
| 575 |
void *user_class) { |
| 576 |
by_type_entry_t *by_type = NULL; |
| 577 |
user_class_list_t *user_class_obj; |
| 578 |
|
| 579 |
by_type = lu_search_by_type(obj, ident->type, /* allocate = */ true); |
| 580 |
if (by_type == NULL) |
| 581 |
return -1; |
| 582 |
|
| 583 |
user_class_obj = calloc(1, sizeof(*user_class_obj)); |
| 584 |
if (user_class_obj == NULL) { |
| 585 |
ERROR("utils_vl_lookup: calloc failed."); |
| 586 |
return ENOMEM; |
| 587 |
} |
| 588 |
pthread_mutex_init(&user_class_obj->entry.lock, /* attr = */ NULL); |
| 589 |
user_class_obj->entry.user_class = user_class; |
| 590 |
lu_copy_ident_to_match(&user_class_obj->entry.match, ident, group_by); |
| 591 |
user_class_obj->entry.user_obj_list = NULL; |
| 592 |
user_class_obj->next = NULL; |
| 593 |
|
| 594 |
return lu_add_by_plugin(by_type, user_class_obj); |
| 595 |
} /* }}} int lookup_add */ |
| 596 |
|
| 597 |
/* returns the number of successful calls to the callback function */ |
| 598 |
int lookup_search(lookup_t *obj, /* {{{ */ |
| 599 |
data_set_t const *ds, value_list_t const *vl) { |
| 600 |
by_type_entry_t *by_type = NULL; |
| 601 |
user_class_list_t *user_class_list = NULL; |
| 602 |
int retval = 0; |
| 603 |
int status; |
| 604 |
|
| 605 |
if ((obj == NULL) || (ds == NULL) || (vl == NULL)) |
| 606 |
return -EINVAL; |
| 607 |
|
| 608 |
by_type = lu_search_by_type(obj, vl->type, /* allocate = */ false); |
| 609 |
if (by_type == NULL) |
| 610 |
return 0; |
| 611 |
|
| 612 |
status = |
| 613 |
c_avl_get(by_type->by_plugin_tree, vl->plugin, (void *)&user_class_list); |
| 614 |
if (status == 0) { |
| 615 |
status = lu_handle_user_class_list(obj, ds, vl, user_class_list); |
| 616 |
if (status < 0) |
| 617 |
return status; |
| 618 |
retval += status; |
| 619 |
} |
| 620 |
|
| 621 |
if (by_type->wildcard_plugin_list != NULL) { |
| 622 |
status = |
| 623 |
lu_handle_user_class_list(obj, ds, vl, by_type->wildcard_plugin_list); |
| 624 |
if (status < 0) |
| 625 |
return status; |
| 626 |
retval += status; |
| 627 |
} |
| 628 |
|
| 629 |
return retval; |
| 630 |
} /* }}} lookup_search */ |