Annotation of embedaddon/strongswan/src/libcharon/attributes/attribute_manager.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2008 Martin Willi
! 3: * HSR Hochschule fuer Technik Rapperswil
! 4: *
! 5: * This program is free software; you can redistribute it and/or modify it
! 6: * under the terms of the GNU General Public License as published by the
! 7: * Free Software Foundation; either version 2 of the License, or (at your
! 8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 9: *
! 10: * This program is distributed in the hope that it will be useful, but
! 11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 13: * for more details.
! 14: */
! 15:
! 16: #include "attribute_manager.h"
! 17:
! 18: #include <utils/debug.h>
! 19: #include <collections/linked_list.h>
! 20: #include <threading/rwlock.h>
! 21:
! 22: typedef struct private_attribute_manager_t private_attribute_manager_t;
! 23:
! 24: /**
! 25: * private data of attribute_manager
! 26: */
! 27: struct private_attribute_manager_t {
! 28:
! 29: /**
! 30: * public functions
! 31: */
! 32: attribute_manager_t public;
! 33:
! 34: /**
! 35: * list of registered providers
! 36: */
! 37: linked_list_t *providers;
! 38:
! 39: /**
! 40: * list of registered handlers
! 41: */
! 42: linked_list_t *handlers;
! 43:
! 44: /**
! 45: * rwlock provider list
! 46: */
! 47: rwlock_t *lock;
! 48: };
! 49:
! 50: /**
! 51: * Data to pass to enumerator filters
! 52: */
! 53: typedef struct {
! 54: /** attribute group pools */
! 55: linked_list_t *pools;
! 56: /** associated IKE_SA */
! 57: ike_sa_t *ike_sa;
! 58: /** requesting/assigned virtual IPs */
! 59: linked_list_t *vips;
! 60: } enum_data_t;
! 61:
! 62: METHOD(attribute_manager_t, acquire_address, host_t*,
! 63: private_attribute_manager_t *this, linked_list_t *pools,
! 64: ike_sa_t *ike_sa, host_t *requested)
! 65: {
! 66: enumerator_t *enumerator;
! 67: attribute_provider_t *current;
! 68: host_t *host = NULL;
! 69:
! 70: this->lock->read_lock(this->lock);
! 71: enumerator = this->providers->create_enumerator(this->providers);
! 72: while (enumerator->enumerate(enumerator, ¤t))
! 73: {
! 74: host = current->acquire_address(current, pools, ike_sa, requested);
! 75: if (host)
! 76: {
! 77: break;
! 78: }
! 79: }
! 80: enumerator->destroy(enumerator);
! 81: this->lock->unlock(this->lock);
! 82:
! 83: return host;
! 84: }
! 85:
! 86: METHOD(attribute_manager_t, release_address, bool,
! 87: private_attribute_manager_t *this, linked_list_t *pools, host_t *address,
! 88: ike_sa_t *ike_sa)
! 89: {
! 90: enumerator_t *enumerator;
! 91: attribute_provider_t *current;
! 92: bool found = FALSE;
! 93:
! 94: this->lock->read_lock(this->lock);
! 95: enumerator = this->providers->create_enumerator(this->providers);
! 96: while (enumerator->enumerate(enumerator, ¤t))
! 97: {
! 98: if (current->release_address(current, pools, address, ike_sa))
! 99: {
! 100: found = TRUE;
! 101: break;
! 102: }
! 103: }
! 104: enumerator->destroy(enumerator);
! 105: this->lock->unlock(this->lock);
! 106:
! 107: return found;
! 108: }
! 109:
! 110: /**
! 111: * inner enumerator constructor for responder attributes
! 112: */
! 113: static enumerator_t *responder_enum_create(attribute_provider_t *provider,
! 114: enum_data_t *data)
! 115: {
! 116: return provider->create_attribute_enumerator(provider, data->pools,
! 117: data->ike_sa, data->vips);
! 118: }
! 119:
! 120: METHOD(attribute_manager_t, create_responder_enumerator, enumerator_t*,
! 121: private_attribute_manager_t *this, linked_list_t *pools,
! 122: ike_sa_t *ike_sa, linked_list_t *vips)
! 123: {
! 124: enum_data_t *data;
! 125:
! 126: INIT(data,
! 127: .pools = pools,
! 128: .ike_sa = ike_sa,
! 129: .vips = vips,
! 130: );
! 131: this->lock->read_lock(this->lock);
! 132: return enumerator_create_cleaner(
! 133: enumerator_create_nested(
! 134: this->providers->create_enumerator(this->providers),
! 135: (void*)responder_enum_create, data, free),
! 136: (void*)this->lock->unlock, this->lock);
! 137: }
! 138:
! 139: METHOD(attribute_manager_t, add_provider, void,
! 140: private_attribute_manager_t *this, attribute_provider_t *provider)
! 141: {
! 142: this->lock->write_lock(this->lock);
! 143: this->providers->insert_last(this->providers, provider);
! 144: this->lock->unlock(this->lock);
! 145: }
! 146:
! 147: METHOD(attribute_manager_t, remove_provider, void,
! 148: private_attribute_manager_t *this, attribute_provider_t *provider)
! 149: {
! 150: this->lock->write_lock(this->lock);
! 151: this->providers->remove(this->providers, provider, NULL);
! 152: this->lock->unlock(this->lock);
! 153: }
! 154:
! 155: METHOD(attribute_manager_t, handle, attribute_handler_t*,
! 156: private_attribute_manager_t *this, ike_sa_t *ike_sa,
! 157: attribute_handler_t *handler, configuration_attribute_type_t type,
! 158: chunk_t data)
! 159: {
! 160: enumerator_t *enumerator;
! 161: attribute_handler_t *current, *handled = NULL;
! 162:
! 163: this->lock->read_lock(this->lock);
! 164:
! 165: /* try to find the passed handler */
! 166: enumerator = this->handlers->create_enumerator(this->handlers);
! 167: while (enumerator->enumerate(enumerator, ¤t))
! 168: {
! 169: if (current == handler && current->handle(current, ike_sa, type, data))
! 170: {
! 171: handled = current;
! 172: break;
! 173: }
! 174: }
! 175: enumerator->destroy(enumerator);
! 176: if (!handled)
! 177: { /* handler requesting this attribute not found, try any other */
! 178: enumerator = this->handlers->create_enumerator(this->handlers);
! 179: while (enumerator->enumerate(enumerator, ¤t))
! 180: {
! 181: if (current->handle(current, ike_sa, type, data))
! 182: {
! 183: handled = current;
! 184: break;
! 185: }
! 186: }
! 187: enumerator->destroy(enumerator);
! 188: }
! 189: this->lock->unlock(this->lock);
! 190:
! 191: if (!handled)
! 192: {
! 193: DBG1(DBG_CFG, "handling %N attribute failed",
! 194: configuration_attribute_type_names, type);
! 195: }
! 196: return handled;
! 197: }
! 198:
! 199: METHOD(attribute_manager_t, release, void,
! 200: private_attribute_manager_t *this, attribute_handler_t *handler,
! 201: ike_sa_t *ike_sa, configuration_attribute_type_t type, chunk_t data)
! 202: {
! 203: enumerator_t *enumerator;
! 204: attribute_handler_t *current;
! 205:
! 206: this->lock->read_lock(this->lock);
! 207: enumerator = this->handlers->create_enumerator(this->handlers);
! 208: while (enumerator->enumerate(enumerator, ¤t))
! 209: {
! 210: if (current == handler)
! 211: {
! 212: current->release(current, ike_sa, type, data);
! 213: break;
! 214: }
! 215: }
! 216: enumerator->destroy(enumerator);
! 217: this->lock->unlock(this->lock);
! 218: }
! 219:
! 220: /**
! 221: * Enumerator implementation to enumerate nested initiator attributes
! 222: */
! 223: typedef struct {
! 224: /** implements enumerator_t */
! 225: enumerator_t public;
! 226: /** back ref */
! 227: private_attribute_manager_t *this;
! 228: /** currently processing handler */
! 229: attribute_handler_t *handler;
! 230: /** outer enumerator over handlers */
! 231: enumerator_t *outer;
! 232: /** inner enumerator over current handlers attributes */
! 233: enumerator_t *inner;
! 234: /** IKE_SA to request attributes for */
! 235: ike_sa_t *ike_sa;
! 236: /** virtual IPs we are requesting along with attributes */
! 237: linked_list_t *vips;
! 238: } initiator_enumerator_t;
! 239:
! 240: METHOD(enumerator_t, initiator_enumerate, bool,
! 241: initiator_enumerator_t *this, va_list args)
! 242: {
! 243: configuration_attribute_type_t *type;
! 244: attribute_handler_t **handler;
! 245: chunk_t *value;
! 246:
! 247: VA_ARGS_VGET(args, handler, type, value);
! 248: /* enumerate inner attributes using outer handler enumerator */
! 249: while (!this->inner || !this->inner->enumerate(this->inner, type, value))
! 250: {
! 251: if (!this->outer->enumerate(this->outer, &this->handler))
! 252: {
! 253: return FALSE;
! 254: }
! 255: DESTROY_IF(this->inner);
! 256: this->inner = this->handler->create_attribute_enumerator(this->handler,
! 257: this->ike_sa, this->vips);
! 258: }
! 259: /* inject the handler as additional attribute */
! 260: *handler = this->handler;
! 261: return TRUE;
! 262: }
! 263:
! 264: METHOD(enumerator_t, initiator_destroy, void,
! 265: initiator_enumerator_t *this)
! 266: {
! 267: this->this->lock->unlock(this->this->lock);
! 268: this->outer->destroy(this->outer);
! 269: DESTROY_IF(this->inner);
! 270: free(this);
! 271: }
! 272:
! 273: METHOD(attribute_manager_t, create_initiator_enumerator, enumerator_t*,
! 274: private_attribute_manager_t *this, ike_sa_t *ike_sa, linked_list_t *vips)
! 275: {
! 276: initiator_enumerator_t *enumerator;
! 277:
! 278: this->lock->read_lock(this->lock);
! 279:
! 280: INIT(enumerator,
! 281: .public = {
! 282: .enumerate = enumerator_enumerate_default,
! 283: .venumerate = _initiator_enumerate,
! 284: .destroy = _initiator_destroy,
! 285: },
! 286: .this = this,
! 287: .ike_sa = ike_sa,
! 288: .vips = vips,
! 289: .outer = this->handlers->create_enumerator(this->handlers),
! 290: );
! 291: return &enumerator->public;
! 292: }
! 293:
! 294: METHOD(attribute_manager_t, add_handler, void,
! 295: private_attribute_manager_t *this, attribute_handler_t *handler)
! 296: {
! 297: this->lock->write_lock(this->lock);
! 298: this->handlers->insert_last(this->handlers, handler);
! 299: this->lock->unlock(this->lock);
! 300: }
! 301:
! 302: METHOD(attribute_manager_t, remove_handler, void,
! 303: private_attribute_manager_t *this, attribute_handler_t *handler)
! 304: {
! 305: this->lock->write_lock(this->lock);
! 306: this->handlers->remove(this->handlers, handler, NULL);
! 307: this->lock->unlock(this->lock);
! 308: }
! 309:
! 310: METHOD(attribute_manager_t, destroy, void,
! 311: private_attribute_manager_t *this)
! 312: {
! 313: this->providers->destroy(this->providers);
! 314: this->handlers->destroy(this->handlers);
! 315: this->lock->destroy(this->lock);
! 316: free(this);
! 317: }
! 318:
! 319: /*
! 320: * see header file
! 321: */
! 322: attribute_manager_t *attribute_manager_create()
! 323: {
! 324: private_attribute_manager_t *this;
! 325:
! 326: INIT(this,
! 327: .public = {
! 328: .acquire_address = _acquire_address,
! 329: .release_address = _release_address,
! 330: .create_responder_enumerator = _create_responder_enumerator,
! 331: .add_provider = _add_provider,
! 332: .remove_provider = _remove_provider,
! 333: .handle = _handle,
! 334: .release = _release,
! 335: .create_initiator_enumerator = _create_initiator_enumerator,
! 336: .add_handler = _add_handler,
! 337: .remove_handler = _remove_handler,
! 338: .destroy = _destroy,
! 339: },
! 340: .providers = linked_list_create(),
! 341: .handlers = linked_list_create(),
! 342: .lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
! 343: );
! 344:
! 345: return &this->public;
! 346: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to attribute_manager.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 / attributes