Annotation of embedaddon/strongswan/src/libcharon/bus/bus.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2011-2016 Tobias Brunner
! 3: * Copyright (C) 2006 Martin Willi
! 4: * HSR Hochschule fuer Technik Rapperswil
! 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; either version 2 of the License, or (at your
! 9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 10: *
! 11: * This program is distributed in the hope that it will be useful, but
! 12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 14: * for more details.
! 15: */
! 16:
! 17: #include "bus.h"
! 18:
! 19: #include <stdint.h>
! 20:
! 21: #include <threading/thread.h>
! 22: #include <threading/thread_value.h>
! 23: #include <threading/mutex.h>
! 24: #include <threading/rwlock.h>
! 25:
! 26: /**
! 27: * These operations allow us to speed up the log level checks on some platforms.
! 28: * In particular if acquiring the read lock is expensive even in the absence of
! 29: * any writers.
! 30: *
! 31: * Note that while holding the read/write lock the read does not have to be
! 32: * atomic as the write lock must be held to set the level.
! 33: */
! 34: #ifdef HAVE_GCC_ATOMIC_OPERATIONS
! 35:
! 36: #define skip_level(ptr, level) (__atomic_load_n(ptr, __ATOMIC_RELAXED) < level)
! 37: #define set_level(ptr, val) __atomic_store_n(ptr, val, __ATOMIC_RELAXED)
! 38:
! 39: #elif defined(HAVE_GCC_SYNC_OPERATIONS)
! 40:
! 41: #define skip_level(ptr, level) (__sync_fetch_and_add(ptr, 0) < level)
! 42: #define set_level(ptr, val) __sync_bool_compare_and_swap(ptr, *ptr, val)
! 43:
! 44: #else
! 45:
! 46: #define skip_level(ptr, level) FALSE
! 47: #define set_level(ptr, val) ({ *ptr = val; })
! 48:
! 49: #endif
! 50:
! 51: typedef struct private_bus_t private_bus_t;
! 52:
! 53: /**
! 54: * Private data of a bus_t object.
! 55: */
! 56: struct private_bus_t {
! 57: /**
! 58: * Public part of a bus_t object.
! 59: */
! 60: bus_t public;
! 61:
! 62: /**
! 63: * List of registered listeners as entry_t.
! 64: */
! 65: linked_list_t *listeners;
! 66:
! 67: /**
! 68: * List of registered loggers for each log group as log_entry_t.
! 69: * Loggers are ordered by descending log level.
! 70: * The extra list stores all loggers so we can properly unregister them.
! 71: */
! 72: linked_list_t *loggers[DBG_MAX + 1];
! 73:
! 74: /**
! 75: * Maximum log level of any registered logger for each log group.
! 76: * This allows to check quickly if a log message has to be logged at all.
! 77: */
! 78: level_t max_level[DBG_MAX + 1];
! 79:
! 80: /**
! 81: * Same as max level, but for loggers using the vlog() method.
! 82: */
! 83: level_t max_vlevel[DBG_MAX + 1];
! 84:
! 85: /**
! 86: * Mutex for the list of listeners, recursively.
! 87: */
! 88: mutex_t *mutex;
! 89:
! 90: /**
! 91: * Read-write lock for the list of loggers.
! 92: */
! 93: rwlock_t *log_lock;
! 94:
! 95: /**
! 96: * Thread local storage the threads IKE_SA
! 97: */
! 98: thread_value_t *thread_sa;
! 99: };
! 100:
! 101: typedef struct entry_t entry_t;
! 102:
! 103: /**
! 104: * a listener entry
! 105: */
! 106: struct entry_t {
! 107:
! 108: /**
! 109: * registered listener interface
! 110: */
! 111: listener_t *listener;
! 112:
! 113: /**
! 114: * are we currently calling this listener
! 115: */
! 116: int calling;
! 117:
! 118: };
! 119:
! 120: typedef struct log_entry_t log_entry_t;
! 121:
! 122: /**
! 123: * a logger entry
! 124: */
! 125: struct log_entry_t {
! 126:
! 127: /**
! 128: * registered logger interface
! 129: */
! 130: logger_t *logger;
! 131:
! 132: /**
! 133: * registered log levels per group
! 134: */
! 135: level_t levels[DBG_MAX];
! 136:
! 137: };
! 138:
! 139: METHOD(bus_t, add_listener, void,
! 140: private_bus_t *this, listener_t *listener)
! 141: {
! 142: entry_t *entry;
! 143:
! 144: INIT(entry,
! 145: .listener = listener,
! 146: );
! 147:
! 148: this->mutex->lock(this->mutex);
! 149: this->listeners->insert_last(this->listeners, entry);
! 150: this->mutex->unlock(this->mutex);
! 151: }
! 152:
! 153: METHOD(bus_t, remove_listener, void,
! 154: private_bus_t *this, listener_t *listener)
! 155: {
! 156: enumerator_t *enumerator;
! 157: entry_t *entry;
! 158:
! 159: this->mutex->lock(this->mutex);
! 160: enumerator = this->listeners->create_enumerator(this->listeners);
! 161: while (enumerator->enumerate(enumerator, &entry))
! 162: {
! 163: if (entry->listener == listener)
! 164: {
! 165: this->listeners->remove_at(this->listeners, enumerator);
! 166: free(entry);
! 167: break;
! 168: }
! 169: }
! 170: enumerator->destroy(enumerator);
! 171: this->mutex->unlock(this->mutex);
! 172: }
! 173:
! 174: /**
! 175: * Register a logger on the given log group according to the requested level
! 176: */
! 177: static inline void register_logger(private_bus_t *this, debug_t group,
! 178: log_entry_t *entry)
! 179: {
! 180: enumerator_t *enumerator;
! 181: linked_list_t *loggers;
! 182: log_entry_t *current;
! 183: level_t level;
! 184:
! 185: loggers = this->loggers[group];
! 186: level = entry->levels[group];
! 187:
! 188: enumerator = loggers->create_enumerator(loggers);
! 189: while (enumerator->enumerate(enumerator, (void**)¤t))
! 190: {
! 191: if (current->levels[group] <= level)
! 192: {
! 193: break;
! 194: }
! 195: }
! 196: loggers->insert_before(loggers, enumerator, entry);
! 197: enumerator->destroy(enumerator);
! 198:
! 199: if (entry->logger->log)
! 200: {
! 201: set_level(&this->max_level[group], max(this->max_level[group], level));
! 202: }
! 203: if (entry->logger->vlog)
! 204: {
! 205: set_level(&this->max_vlevel[group],
! 206: max(this->max_vlevel[group], level));
! 207: }
! 208: }
! 209:
! 210: CALLBACK(find_max_levels, bool,
! 211: log_entry_t *entry, va_list args)
! 212: {
! 213: level_t *level, *vlevel;
! 214: debug_t group;
! 215:
! 216: VA_ARGS_VGET(args, group, level, vlevel);
! 217: if (entry->logger->log && *level == LEVEL_SILENT)
! 218: {
! 219: *level = entry->levels[group];
! 220: }
! 221: if (entry->logger->vlog && *vlevel == LEVEL_SILENT)
! 222: {
! 223: *vlevel = entry->levels[group];
! 224: }
! 225: return *level > LEVEL_SILENT && *vlevel > LEVEL_SILENT;
! 226: }
! 227:
! 228: /**
! 229: * Unregister a logger from all log groups (destroys the log_entry_t)
! 230: */
! 231: static inline void unregister_logger(private_bus_t *this, logger_t *logger)
! 232: {
! 233: enumerator_t *enumerator;
! 234: linked_list_t *loggers;
! 235: log_entry_t *entry, *found = NULL;
! 236: debug_t group;
! 237:
! 238: loggers = this->loggers[DBG_MAX];
! 239: enumerator = loggers->create_enumerator(loggers);
! 240: while (enumerator->enumerate(enumerator, &entry))
! 241: {
! 242: if (entry->logger == logger)
! 243: {
! 244: loggers->remove_at(loggers, enumerator);
! 245: found = entry;
! 246: break;
! 247: }
! 248: }
! 249: enumerator->destroy(enumerator);
! 250:
! 251: if (found)
! 252: {
! 253: for (group = 0; group < DBG_MAX; group++)
! 254: {
! 255: if (found->levels[group] > LEVEL_SILENT)
! 256: {
! 257: level_t level = LEVEL_SILENT, vlevel = LEVEL_SILENT;
! 258:
! 259: loggers = this->loggers[group];
! 260: loggers->remove(loggers, found, NULL);
! 261: loggers->find_first(loggers, find_max_levels, NULL, group,
! 262: &level, &vlevel);
! 263: set_level(&this->max_level[group], level);
! 264: set_level(&this->max_vlevel[group], vlevel);
! 265: }
! 266: }
! 267: free(found);
! 268: }
! 269: }
! 270:
! 271: METHOD(bus_t, add_logger, void,
! 272: private_bus_t *this, logger_t *logger)
! 273: {
! 274: log_entry_t *entry;
! 275: debug_t group;
! 276:
! 277: INIT(entry,
! 278: .logger = logger,
! 279: );
! 280:
! 281: this->log_lock->write_lock(this->log_lock);
! 282: unregister_logger(this, logger);
! 283: for (group = 0; group < DBG_MAX; group++)
! 284: {
! 285: entry->levels[group] = logger->get_level(logger, group);
! 286: if (entry->levels[group] > LEVEL_SILENT)
! 287: {
! 288: register_logger(this, group, entry);
! 289: }
! 290: }
! 291: this->loggers[DBG_MAX]->insert_last(this->loggers[DBG_MAX], entry);
! 292: this->log_lock->unlock(this->log_lock);
! 293: }
! 294:
! 295: METHOD(bus_t, remove_logger, void,
! 296: private_bus_t *this, logger_t *logger)
! 297: {
! 298: this->log_lock->write_lock(this->log_lock);
! 299: unregister_logger(this, logger);
! 300: this->log_lock->unlock(this->log_lock);
! 301: }
! 302:
! 303: METHOD(bus_t, set_sa, void,
! 304: private_bus_t *this, ike_sa_t *ike_sa)
! 305: {
! 306: this->thread_sa->set(this->thread_sa, ike_sa);
! 307: }
! 308:
! 309: METHOD(bus_t, get_sa, ike_sa_t*,
! 310: private_bus_t *this)
! 311: {
! 312: return this->thread_sa->get(this->thread_sa);
! 313: }
! 314:
! 315: /**
! 316: * data associated to a signal, passed to callback
! 317: */
! 318: typedef struct {
! 319: /** associated IKE_SA */
! 320: ike_sa_t *ike_sa;
! 321: /** invoking thread */
! 322: long thread;
! 323: /** debug group */
! 324: debug_t group;
! 325: /** debug level */
! 326: level_t level;
! 327: /** message/fmt */
! 328: char *message;
! 329: /** argument list if message is a format string for vlog() */
! 330: va_list args;
! 331: } log_data_t;
! 332:
! 333: CALLBACK(log_cb, void,
! 334: log_entry_t *entry, va_list args)
! 335: {
! 336: log_data_t *data;
! 337:
! 338: VA_ARGS_VGET(args, data);
! 339: if (entry->logger->log && entry->levels[data->group] >= data->level)
! 340: {
! 341: entry->logger->log(entry->logger, data->group, data->level,
! 342: data->thread, data->ike_sa, data->message);
! 343: }
! 344: }
! 345:
! 346: CALLBACK(vlog_cb, void,
! 347: log_entry_t *entry, va_list args)
! 348: {
! 349: log_data_t *data;
! 350:
! 351: VA_ARGS_VGET(args, data);
! 352: if (entry->logger->vlog && entry->levels[data->group] >= data->level)
! 353: {
! 354: va_list copy;
! 355:
! 356: va_copy(copy, data->args);
! 357: entry->logger->vlog(entry->logger, data->group, data->level,
! 358: data->thread, data->ike_sa, data->message, copy);
! 359: va_end(copy);
! 360: }
! 361: }
! 362:
! 363: METHOD(bus_t, vlog, void,
! 364: private_bus_t *this, debug_t group, level_t level,
! 365: char* format, va_list args)
! 366: {
! 367: linked_list_t *loggers;
! 368: log_data_t data;
! 369:
! 370: /* NOTE: This is not 100% thread-safe and done here only because it is
! 371: * performance critical. We therefore ignore the following two issues for
! 372: * this particular case: 1) We might miss some log messages if another
! 373: * thread concurrently increases the log level or registers a new logger.
! 374: * 2) We might have to acquire the read lock below even if it wouldn't be
! 375: * necessary anymore due to another thread concurrently unregistering a
! 376: * logger or reducing the level. */
! 377: if (skip_level(&this->max_level[group], level) &&
! 378: skip_level(&this->max_vlevel[group], level))
! 379: {
! 380: return;
! 381: }
! 382:
! 383: this->log_lock->read_lock(this->log_lock);
! 384: loggers = this->loggers[group];
! 385:
! 386: if (this->max_level[group] >= level)
! 387: {
! 388: char buf[1024];
! 389: ssize_t len;
! 390:
! 391: data.ike_sa = this->thread_sa->get(this->thread_sa);
! 392: data.thread = thread_current_id();
! 393: data.group = group;
! 394: data.level = level;
! 395: data.message = buf;
! 396:
! 397: va_copy(data.args, args);
! 398: len = vsnprintf(data.message, sizeof(buf), format, data.args);
! 399: va_end(data.args);
! 400: if (len >= sizeof(buf))
! 401: {
! 402: len++;
! 403: data.message = malloc(len);
! 404: va_copy(data.args, args);
! 405: len = vsnprintf(data.message, len, format, data.args);
! 406: va_end(data.args);
! 407: }
! 408: if (len > 0)
! 409: {
! 410: loggers->invoke_function(loggers, log_cb, &data);
! 411: }
! 412: if (data.message != buf)
! 413: {
! 414: free(data.message);
! 415: }
! 416: }
! 417: if (this->max_vlevel[group] >= level)
! 418: {
! 419: data.ike_sa = this->thread_sa->get(this->thread_sa);
! 420: data.thread = thread_current_id();
! 421: data.group = group;
! 422: data.level = level;
! 423: data.message = format;
! 424:
! 425: va_copy(data.args, args);
! 426: loggers->invoke_function(loggers, vlog_cb, &data);
! 427: va_end(data.args);
! 428: }
! 429:
! 430: this->log_lock->unlock(this->log_lock);
! 431: }
! 432:
! 433: METHOD(bus_t, log_, void,
! 434: private_bus_t *this, debug_t group, level_t level, char* format, ...)
! 435: {
! 436: va_list args;
! 437:
! 438: va_start(args, format);
! 439: vlog(this, group, level, format, args);
! 440: va_end(args);
! 441: }
! 442:
! 443: /**
! 444: * unregister a listener
! 445: */
! 446: static inline void unregister_listener(private_bus_t *this, entry_t *entry,
! 447: enumerator_t *enumerator)
! 448: {
! 449: this->listeners->remove_at(this->listeners, enumerator);
! 450: free(entry);
! 451: }
! 452:
! 453: METHOD(bus_t, alert, void,
! 454: private_bus_t *this, alert_t alert, ...)
! 455: {
! 456: enumerator_t *enumerator;
! 457: ike_sa_t *ike_sa;
! 458: entry_t *entry;
! 459: va_list args;
! 460: bool keep;
! 461:
! 462: ike_sa = this->thread_sa->get(this->thread_sa);
! 463:
! 464: this->mutex->lock(this->mutex);
! 465: enumerator = this->listeners->create_enumerator(this->listeners);
! 466: while (enumerator->enumerate(enumerator, &entry))
! 467: {
! 468: if (entry->calling || !entry->listener->alert)
! 469: {
! 470: continue;
! 471: }
! 472: entry->calling++;
! 473: va_start(args, alert);
! 474: keep = entry->listener->alert(entry->listener, ike_sa, alert, args);
! 475: va_end(args);
! 476: entry->calling--;
! 477: if (!keep)
! 478: {
! 479: unregister_listener(this, entry, enumerator);
! 480: }
! 481: }
! 482: enumerator->destroy(enumerator);
! 483: this->mutex->unlock(this->mutex);
! 484: }
! 485:
! 486: METHOD(bus_t, ike_state_change, void,
! 487: private_bus_t *this, ike_sa_t *ike_sa, ike_sa_state_t state)
! 488: {
! 489: enumerator_t *enumerator;
! 490: entry_t *entry;
! 491: bool keep;
! 492:
! 493: this->mutex->lock(this->mutex);
! 494: enumerator = this->listeners->create_enumerator(this->listeners);
! 495: while (enumerator->enumerate(enumerator, &entry))
! 496: {
! 497: if (entry->calling || !entry->listener->ike_state_change)
! 498: {
! 499: continue;
! 500: }
! 501: entry->calling++;
! 502: keep = entry->listener->ike_state_change(entry->listener, ike_sa, state);
! 503: entry->calling--;
! 504: if (!keep)
! 505: {
! 506: unregister_listener(this, entry, enumerator);
! 507: }
! 508: }
! 509: enumerator->destroy(enumerator);
! 510: this->mutex->unlock(this->mutex);
! 511: }
! 512:
! 513: METHOD(bus_t, child_state_change, void,
! 514: private_bus_t *this, child_sa_t *child_sa, child_sa_state_t state)
! 515: {
! 516: enumerator_t *enumerator;
! 517: ike_sa_t *ike_sa;
! 518: entry_t *entry;
! 519: bool keep;
! 520:
! 521: ike_sa = this->thread_sa->get(this->thread_sa);
! 522:
! 523: this->mutex->lock(this->mutex);
! 524: enumerator = this->listeners->create_enumerator(this->listeners);
! 525: while (enumerator->enumerate(enumerator, &entry))
! 526: {
! 527: if (entry->calling || !entry->listener->child_state_change)
! 528: {
! 529: continue;
! 530: }
! 531: entry->calling++;
! 532: keep = entry->listener->child_state_change(entry->listener, ike_sa,
! 533: child_sa, state);
! 534: entry->calling--;
! 535: if (!keep)
! 536: {
! 537: unregister_listener(this, entry, enumerator);
! 538: }
! 539: }
! 540: enumerator->destroy(enumerator);
! 541: this->mutex->unlock(this->mutex);
! 542: }
! 543:
! 544: METHOD(bus_t, message, void,
! 545: private_bus_t *this, message_t *message, bool incoming, bool plain)
! 546: {
! 547: enumerator_t *enumerator;
! 548: ike_sa_t *ike_sa;
! 549: entry_t *entry;
! 550: bool keep;
! 551:
! 552: ike_sa = this->thread_sa->get(this->thread_sa);
! 553:
! 554: this->mutex->lock(this->mutex);
! 555: enumerator = this->listeners->create_enumerator(this->listeners);
! 556: while (enumerator->enumerate(enumerator, &entry))
! 557: {
! 558: if (entry->calling || !entry->listener->message)
! 559: {
! 560: continue;
! 561: }
! 562: entry->calling++;
! 563: keep = entry->listener->message(entry->listener, ike_sa,
! 564: message, incoming, plain);
! 565: entry->calling--;
! 566: if (!keep)
! 567: {
! 568: unregister_listener(this, entry, enumerator);
! 569: }
! 570: }
! 571: enumerator->destroy(enumerator);
! 572: this->mutex->unlock(this->mutex);
! 573: }
! 574:
! 575: METHOD(bus_t, ike_keys, void,
! 576: private_bus_t *this, ike_sa_t *ike_sa, diffie_hellman_t *dh,
! 577: chunk_t dh_other, chunk_t nonce_i, chunk_t nonce_r,
! 578: ike_sa_t *rekey, shared_key_t *shared, auth_method_t method)
! 579: {
! 580: enumerator_t *enumerator;
! 581: entry_t *entry;
! 582: bool keep;
! 583:
! 584: this->mutex->lock(this->mutex);
! 585: enumerator = this->listeners->create_enumerator(this->listeners);
! 586: while (enumerator->enumerate(enumerator, &entry))
! 587: {
! 588: if (entry->calling || !entry->listener->ike_keys)
! 589: {
! 590: continue;
! 591: }
! 592: entry->calling++;
! 593: keep = entry->listener->ike_keys(entry->listener, ike_sa, dh, dh_other,
! 594: nonce_i, nonce_r, rekey, shared,
! 595: method);
! 596: entry->calling--;
! 597: if (!keep)
! 598: {
! 599: unregister_listener(this, entry, enumerator);
! 600: }
! 601: }
! 602: enumerator->destroy(enumerator);
! 603: this->mutex->unlock(this->mutex);
! 604: }
! 605:
! 606: METHOD(bus_t, ike_derived_keys, void,
! 607: private_bus_t *this, chunk_t sk_ei, chunk_t sk_er, chunk_t sk_ai,
! 608: chunk_t sk_ar)
! 609: {
! 610: enumerator_t *enumerator;
! 611: ike_sa_t *ike_sa;
! 612: entry_t *entry;
! 613: bool keep;
! 614:
! 615: ike_sa = this->thread_sa->get(this->thread_sa);
! 616:
! 617: this->mutex->lock(this->mutex);
! 618: enumerator = this->listeners->create_enumerator(this->listeners);
! 619: while (enumerator->enumerate(enumerator, &entry))
! 620: {
! 621: if (entry->calling || !entry->listener->ike_derived_keys)
! 622: {
! 623: continue;
! 624: }
! 625: entry->calling++;
! 626: keep = entry->listener->ike_derived_keys(entry->listener, ike_sa, sk_ei,
! 627: sk_er, sk_ai, sk_ar);
! 628: entry->calling--;
! 629: if (!keep)
! 630: {
! 631: unregister_listener(this, entry, enumerator);
! 632: }
! 633: }
! 634: enumerator->destroy(enumerator);
! 635: this->mutex->unlock(this->mutex);
! 636: }
! 637:
! 638: METHOD(bus_t, child_keys, void,
! 639: private_bus_t *this, child_sa_t *child_sa, bool initiator,
! 640: diffie_hellman_t *dh, chunk_t nonce_i, chunk_t nonce_r)
! 641: {
! 642: enumerator_t *enumerator;
! 643: ike_sa_t *ike_sa;
! 644: entry_t *entry;
! 645: bool keep;
! 646:
! 647: ike_sa = this->thread_sa->get(this->thread_sa);
! 648:
! 649: this->mutex->lock(this->mutex);
! 650: enumerator = this->listeners->create_enumerator(this->listeners);
! 651: while (enumerator->enumerate(enumerator, &entry))
! 652: {
! 653: if (entry->calling || !entry->listener->child_keys)
! 654: {
! 655: continue;
! 656: }
! 657: entry->calling++;
! 658: keep = entry->listener->child_keys(entry->listener, ike_sa,
! 659: child_sa, initiator, dh, nonce_i, nonce_r);
! 660: entry->calling--;
! 661: if (!keep)
! 662: {
! 663: unregister_listener(this, entry, enumerator);
! 664: }
! 665: }
! 666: enumerator->destroy(enumerator);
! 667: this->mutex->unlock(this->mutex);
! 668: }
! 669:
! 670: METHOD(bus_t, child_derived_keys, void,
! 671: private_bus_t *this, child_sa_t *child_sa, bool initiator,
! 672: chunk_t encr_i, chunk_t encr_r, chunk_t integ_i, chunk_t integ_r)
! 673: {
! 674: enumerator_t *enumerator;
! 675: ike_sa_t *ike_sa;
! 676: entry_t *entry;
! 677: bool keep;
! 678:
! 679: ike_sa = this->thread_sa->get(this->thread_sa);
! 680:
! 681: this->mutex->lock(this->mutex);
! 682: enumerator = this->listeners->create_enumerator(this->listeners);
! 683: while (enumerator->enumerate(enumerator, &entry))
! 684: {
! 685: if (entry->calling || !entry->listener->child_derived_keys)
! 686: {
! 687: continue;
! 688: }
! 689: entry->calling++;
! 690: keep = entry->listener->child_derived_keys(entry->listener, ike_sa,
! 691: child_sa, initiator, encr_i, encr_r,
! 692: integ_i, integ_r);
! 693: entry->calling--;
! 694: if (!keep)
! 695: {
! 696: unregister_listener(this, entry, enumerator);
! 697: }
! 698: }
! 699: enumerator->destroy(enumerator);
! 700: this->mutex->unlock(this->mutex);
! 701: }
! 702:
! 703: METHOD(bus_t, child_updown, void,
! 704: private_bus_t *this, child_sa_t *child_sa, bool up)
! 705: {
! 706: enumerator_t *enumerator;
! 707: ike_sa_t *ike_sa;
! 708: entry_t *entry;
! 709: bool keep;
! 710:
! 711: ike_sa = this->thread_sa->get(this->thread_sa);
! 712:
! 713: this->mutex->lock(this->mutex);
! 714: enumerator = this->listeners->create_enumerator(this->listeners);
! 715: while (enumerator->enumerate(enumerator, &entry))
! 716: {
! 717: if (entry->calling || !entry->listener->child_updown)
! 718: {
! 719: continue;
! 720: }
! 721: entry->calling++;
! 722: keep = entry->listener->child_updown(entry->listener,
! 723: ike_sa, child_sa, up);
! 724: entry->calling--;
! 725: if (!keep)
! 726: {
! 727: unregister_listener(this, entry, enumerator);
! 728: }
! 729: }
! 730: enumerator->destroy(enumerator);
! 731: this->mutex->unlock(this->mutex);
! 732: }
! 733:
! 734: METHOD(bus_t, child_rekey, void,
! 735: private_bus_t *this, child_sa_t *old, child_sa_t *new)
! 736: {
! 737: enumerator_t *enumerator;
! 738: ike_sa_t *ike_sa;
! 739: entry_t *entry;
! 740: bool keep;
! 741:
! 742: ike_sa = this->thread_sa->get(this->thread_sa);
! 743:
! 744: this->mutex->lock(this->mutex);
! 745: enumerator = this->listeners->create_enumerator(this->listeners);
! 746: while (enumerator->enumerate(enumerator, &entry))
! 747: {
! 748: if (entry->calling || !entry->listener->child_rekey)
! 749: {
! 750: continue;
! 751: }
! 752: entry->calling++;
! 753: keep = entry->listener->child_rekey(entry->listener, ike_sa,
! 754: old, new);
! 755: entry->calling--;
! 756: if (!keep)
! 757: {
! 758: unregister_listener(this, entry, enumerator);
! 759: }
! 760: }
! 761: enumerator->destroy(enumerator);
! 762: this->mutex->unlock(this->mutex);
! 763: }
! 764:
! 765: METHOD(bus_t, children_migrate, void,
! 766: private_bus_t *this, ike_sa_id_t *new, uint32_t unique)
! 767: {
! 768: enumerator_t *enumerator;
! 769: ike_sa_t *ike_sa;
! 770: entry_t *entry;
! 771: bool keep;
! 772:
! 773: ike_sa = this->thread_sa->get(this->thread_sa);
! 774:
! 775: this->mutex->lock(this->mutex);
! 776: enumerator = this->listeners->create_enumerator(this->listeners);
! 777: while (enumerator->enumerate(enumerator, &entry))
! 778: {
! 779: if (entry->calling || !entry->listener->children_migrate)
! 780: {
! 781: continue;
! 782: }
! 783: entry->calling++;
! 784: keep = entry->listener->children_migrate(entry->listener, ike_sa, new,
! 785: unique);
! 786: entry->calling--;
! 787: if (!keep)
! 788: {
! 789: unregister_listener(this, entry, enumerator);
! 790: }
! 791: }
! 792: enumerator->destroy(enumerator);
! 793: this->mutex->unlock(this->mutex);
! 794: }
! 795:
! 796: METHOD(bus_t, ike_updown, void,
! 797: private_bus_t *this, ike_sa_t *ike_sa, bool up)
! 798: {
! 799: enumerator_t *enumerator;
! 800: entry_t *entry;
! 801: bool keep;
! 802:
! 803: this->mutex->lock(this->mutex);
! 804: enumerator = this->listeners->create_enumerator(this->listeners);
! 805: while (enumerator->enumerate(enumerator, &entry))
! 806: {
! 807: if (entry->calling || !entry->listener->ike_updown)
! 808: {
! 809: continue;
! 810: }
! 811: entry->calling++;
! 812: keep = entry->listener->ike_updown(entry->listener, ike_sa, up);
! 813: entry->calling--;
! 814: if (!keep)
! 815: {
! 816: unregister_listener(this, entry, enumerator);
! 817: }
! 818: }
! 819: enumerator->destroy(enumerator);
! 820: this->mutex->unlock(this->mutex);
! 821:
! 822: /* a down event for IKE_SA implicitly downs all CHILD_SAs */
! 823: if (!up)
! 824: {
! 825: enumerator_t *enumerator;
! 826: child_sa_t *child_sa;
! 827:
! 828: enumerator = ike_sa->create_child_sa_enumerator(ike_sa);
! 829: while (enumerator->enumerate(enumerator, (void**)&child_sa))
! 830: {
! 831: if (child_sa->get_state(child_sa) != CHILD_REKEYED &&
! 832: child_sa->get_state(child_sa) != CHILD_DELETED)
! 833: {
! 834: child_updown(this, child_sa, FALSE);
! 835: }
! 836: }
! 837: enumerator->destroy(enumerator);
! 838: }
! 839: }
! 840:
! 841: METHOD(bus_t, ike_rekey, void,
! 842: private_bus_t *this, ike_sa_t *old, ike_sa_t *new)
! 843: {
! 844: enumerator_t *enumerator;
! 845: entry_t *entry;
! 846: bool keep;
! 847:
! 848: this->mutex->lock(this->mutex);
! 849: enumerator = this->listeners->create_enumerator(this->listeners);
! 850: while (enumerator->enumerate(enumerator, &entry))
! 851: {
! 852: if (entry->calling || !entry->listener->ike_rekey)
! 853: {
! 854: continue;
! 855: }
! 856: entry->calling++;
! 857: keep = entry->listener->ike_rekey(entry->listener, old, new);
! 858: entry->calling--;
! 859: if (!keep)
! 860: {
! 861: unregister_listener(this, entry, enumerator);
! 862: }
! 863: }
! 864: enumerator->destroy(enumerator);
! 865: this->mutex->unlock(this->mutex);
! 866: }
! 867:
! 868: METHOD(bus_t, ike_update, void,
! 869: private_bus_t *this, ike_sa_t *ike_sa, bool local, host_t *new)
! 870: {
! 871: enumerator_t *enumerator;
! 872: entry_t *entry;
! 873: bool keep;
! 874:
! 875: this->mutex->lock(this->mutex);
! 876: enumerator = this->listeners->create_enumerator(this->listeners);
! 877: while (enumerator->enumerate(enumerator, &entry))
! 878: {
! 879: if (entry->calling || !entry->listener->ike_update)
! 880: {
! 881: continue;
! 882: }
! 883: entry->calling++;
! 884: keep = entry->listener->ike_update(entry->listener, ike_sa, local, new);
! 885: entry->calling--;
! 886: if (!keep)
! 887: {
! 888: unregister_listener(this, entry, enumerator);
! 889: }
! 890: }
! 891: enumerator->destroy(enumerator);
! 892: this->mutex->unlock(this->mutex);
! 893: }
! 894:
! 895: METHOD(bus_t, ike_reestablish_pre, void,
! 896: private_bus_t *this, ike_sa_t *old, ike_sa_t *new)
! 897: {
! 898: enumerator_t *enumerator;
! 899: entry_t *entry;
! 900: bool keep;
! 901:
! 902: this->mutex->lock(this->mutex);
! 903: enumerator = this->listeners->create_enumerator(this->listeners);
! 904: while (enumerator->enumerate(enumerator, &entry))
! 905: {
! 906: if (entry->calling || !entry->listener->ike_reestablish_pre)
! 907: {
! 908: continue;
! 909: }
! 910: entry->calling++;
! 911: keep = entry->listener->ike_reestablish_pre(entry->listener, old, new);
! 912: entry->calling--;
! 913: if (!keep)
! 914: {
! 915: unregister_listener(this, entry, enumerator);
! 916: }
! 917: }
! 918: enumerator->destroy(enumerator);
! 919: this->mutex->unlock(this->mutex);
! 920: }
! 921:
! 922: METHOD(bus_t, ike_reestablish_post, void,
! 923: private_bus_t *this, ike_sa_t *old, ike_sa_t *new, bool initiated)
! 924: {
! 925: enumerator_t *enumerator;
! 926: entry_t *entry;
! 927: bool keep;
! 928:
! 929: this->mutex->lock(this->mutex);
! 930: enumerator = this->listeners->create_enumerator(this->listeners);
! 931: while (enumerator->enumerate(enumerator, &entry))
! 932: {
! 933: if (entry->calling || !entry->listener->ike_reestablish_post)
! 934: {
! 935: continue;
! 936: }
! 937: entry->calling++;
! 938: keep = entry->listener->ike_reestablish_post(entry->listener, old, new,
! 939: initiated);
! 940: entry->calling--;
! 941: if (!keep)
! 942: {
! 943: unregister_listener(this, entry, enumerator);
! 944: }
! 945: }
! 946: enumerator->destroy(enumerator);
! 947: this->mutex->unlock(this->mutex);
! 948: }
! 949:
! 950: METHOD(bus_t, authorize, bool,
! 951: private_bus_t *this, bool final)
! 952: {
! 953: enumerator_t *enumerator;
! 954: ike_sa_t *ike_sa;
! 955: entry_t *entry;
! 956: bool keep, success = TRUE;
! 957:
! 958: ike_sa = this->thread_sa->get(this->thread_sa);
! 959:
! 960: this->mutex->lock(this->mutex);
! 961: enumerator = this->listeners->create_enumerator(this->listeners);
! 962: while (enumerator->enumerate(enumerator, &entry))
! 963: {
! 964: if (entry->calling || !entry->listener->authorize)
! 965: {
! 966: continue;
! 967: }
! 968: entry->calling++;
! 969: keep = entry->listener->authorize(entry->listener, ike_sa,
! 970: final, &success);
! 971: entry->calling--;
! 972: if (!keep)
! 973: {
! 974: unregister_listener(this, entry, enumerator);
! 975: }
! 976: if (!success)
! 977: {
! 978: break;
! 979: }
! 980: }
! 981: enumerator->destroy(enumerator);
! 982: this->mutex->unlock(this->mutex);
! 983: if (!success)
! 984: {
! 985: alert(this, ALERT_AUTHORIZATION_FAILED);
! 986: }
! 987: return success;
! 988: }
! 989:
! 990: METHOD(bus_t, narrow, void,
! 991: private_bus_t *this, child_sa_t *child_sa, narrow_hook_t type,
! 992: linked_list_t *local, linked_list_t *remote)
! 993: {
! 994: enumerator_t *enumerator;
! 995: ike_sa_t *ike_sa;
! 996: entry_t *entry;
! 997: bool keep;
! 998:
! 999: ike_sa = this->thread_sa->get(this->thread_sa);
! 1000:
! 1001: this->mutex->lock(this->mutex);
! 1002: enumerator = this->listeners->create_enumerator(this->listeners);
! 1003: while (enumerator->enumerate(enumerator, &entry))
! 1004: {
! 1005: if (entry->calling || !entry->listener->narrow)
! 1006: {
! 1007: continue;
! 1008: }
! 1009: entry->calling++;
! 1010: keep = entry->listener->narrow(entry->listener, ike_sa, child_sa,
! 1011: type, local, remote);
! 1012: entry->calling--;
! 1013: if (!keep)
! 1014: {
! 1015: unregister_listener(this, entry, enumerator);
! 1016: }
! 1017: }
! 1018: enumerator->destroy(enumerator);
! 1019: this->mutex->unlock(this->mutex);
! 1020: }
! 1021:
! 1022: METHOD(bus_t, assign_vips, void,
! 1023: private_bus_t *this, ike_sa_t *ike_sa, bool assign)
! 1024: {
! 1025: enumerator_t *enumerator;
! 1026: entry_t *entry;
! 1027: bool keep;
! 1028:
! 1029: this->mutex->lock(this->mutex);
! 1030: enumerator = this->listeners->create_enumerator(this->listeners);
! 1031: while (enumerator->enumerate(enumerator, &entry))
! 1032: {
! 1033: if (entry->calling || !entry->listener->assign_vips)
! 1034: {
! 1035: continue;
! 1036: }
! 1037: entry->calling++;
! 1038: keep = entry->listener->assign_vips(entry->listener, ike_sa, assign);
! 1039: entry->calling--;
! 1040: if (!keep)
! 1041: {
! 1042: unregister_listener(this, entry, enumerator);
! 1043: }
! 1044: }
! 1045: enumerator->destroy(enumerator);
! 1046: this->mutex->unlock(this->mutex);
! 1047: }
! 1048:
! 1049: METHOD(bus_t, handle_vips, void,
! 1050: private_bus_t *this, ike_sa_t *ike_sa, bool handle)
! 1051: {
! 1052: enumerator_t *enumerator;
! 1053: entry_t *entry;
! 1054: bool keep;
! 1055:
! 1056: this->mutex->lock(this->mutex);
! 1057: enumerator = this->listeners->create_enumerator(this->listeners);
! 1058: while (enumerator->enumerate(enumerator, &entry))
! 1059: {
! 1060: if (entry->calling || !entry->listener->handle_vips)
! 1061: {
! 1062: continue;
! 1063: }
! 1064: entry->calling++;
! 1065: keep = entry->listener->handle_vips(entry->listener, ike_sa, handle);
! 1066: entry->calling--;
! 1067: if (!keep)
! 1068: {
! 1069: unregister_listener(this, entry, enumerator);
! 1070: }
! 1071: }
! 1072: enumerator->destroy(enumerator);
! 1073: this->mutex->unlock(this->mutex);
! 1074: }
! 1075:
! 1076: /**
! 1077: * Credential manager hook function to forward bus alerts
! 1078: */
! 1079: static void hook_creds(private_bus_t *this, credential_hook_type_t type,
! 1080: certificate_t *cert)
! 1081: {
! 1082: switch (type)
! 1083: {
! 1084: case CRED_HOOK_EXPIRED:
! 1085: return alert(this, ALERT_CERT_EXPIRED, cert);
! 1086: case CRED_HOOK_REVOKED:
! 1087: return alert(this, ALERT_CERT_REVOKED, cert);
! 1088: case CRED_HOOK_VALIDATION_FAILED:
! 1089: return alert(this, ALERT_CERT_VALIDATION_FAILED, cert);
! 1090: case CRED_HOOK_NO_ISSUER:
! 1091: return alert(this, ALERT_CERT_NO_ISSUER, cert);
! 1092: case CRED_HOOK_UNTRUSTED_ROOT:
! 1093: return alert(this, ALERT_CERT_UNTRUSTED_ROOT, cert);
! 1094: case CRED_HOOK_EXCEEDED_PATH_LEN:
! 1095: return alert(this, ALERT_CERT_EXCEEDED_PATH_LEN, cert);
! 1096: case CRED_HOOK_POLICY_VIOLATION:
! 1097: return alert(this, ALERT_CERT_POLICY_VIOLATION, cert);
! 1098: }
! 1099: }
! 1100:
! 1101: METHOD(bus_t, destroy, void,
! 1102: private_bus_t *this)
! 1103: {
! 1104: debug_t group;
! 1105:
! 1106: lib->credmgr->set_hook(lib->credmgr, NULL, NULL);
! 1107: for (group = 0; group < DBG_MAX; group++)
! 1108: {
! 1109: this->loggers[group]->destroy(this->loggers[group]);
! 1110: }
! 1111: this->loggers[DBG_MAX]->destroy_function(this->loggers[DBG_MAX],
! 1112: (void*)free);
! 1113: this->listeners->destroy_function(this->listeners, (void*)free);
! 1114: this->thread_sa->destroy(this->thread_sa);
! 1115: this->log_lock->destroy(this->log_lock);
! 1116: this->mutex->destroy(this->mutex);
! 1117: free(this);
! 1118: }
! 1119:
! 1120: /*
! 1121: * Described in header.
! 1122: */
! 1123: bus_t *bus_create()
! 1124: {
! 1125: private_bus_t *this;
! 1126: debug_t group;
! 1127:
! 1128: INIT(this,
! 1129: .public = {
! 1130: .add_listener = _add_listener,
! 1131: .remove_listener = _remove_listener,
! 1132: .add_logger = _add_logger,
! 1133: .remove_logger = _remove_logger,
! 1134: .set_sa = _set_sa,
! 1135: .get_sa = _get_sa,
! 1136: .log = _log_,
! 1137: .vlog = _vlog,
! 1138: .alert = _alert,
! 1139: .ike_state_change = _ike_state_change,
! 1140: .child_state_change = _child_state_change,
! 1141: .message = _message,
! 1142: .ike_keys = _ike_keys,
! 1143: .ike_derived_keys = _ike_derived_keys,
! 1144: .child_keys = _child_keys,
! 1145: .child_derived_keys = _child_derived_keys,
! 1146: .ike_updown = _ike_updown,
! 1147: .ike_rekey = _ike_rekey,
! 1148: .ike_update = _ike_update,
! 1149: .ike_reestablish_pre = _ike_reestablish_pre,
! 1150: .ike_reestablish_post = _ike_reestablish_post,
! 1151: .child_updown = _child_updown,
! 1152: .child_rekey = _child_rekey,
! 1153: .children_migrate = _children_migrate,
! 1154: .authorize = _authorize,
! 1155: .narrow = _narrow,
! 1156: .assign_vips = _assign_vips,
! 1157: .handle_vips = _handle_vips,
! 1158: .destroy = _destroy,
! 1159: },
! 1160: .listeners = linked_list_create(),
! 1161: .mutex = mutex_create(MUTEX_TYPE_RECURSIVE),
! 1162: .log_lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
! 1163: .thread_sa = thread_value_create(NULL),
! 1164: );
! 1165:
! 1166: for (group = 0; group <= DBG_MAX; group++)
! 1167: {
! 1168: this->loggers[group] = linked_list_create();
! 1169: this->max_level[group] = LEVEL_SILENT;
! 1170: this->max_vlevel[group] = LEVEL_SILENT;
! 1171: }
! 1172:
! 1173: lib->credmgr->set_hook(lib->credmgr, (credential_hook_t)hook_creds, this);
! 1174:
! 1175: return &this->public;
! 1176: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bus.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libcharon / bus