diff options
Diffstat (limited to 'src/libhydra/attributes')
| -rw-r--r-- | src/libhydra/attributes/mem_pool.c | 429 | ||||
| -rw-r--r-- | src/libhydra/attributes/mem_pool.h | 112 |
2 files changed, 541 insertions, 0 deletions
diff --git a/src/libhydra/attributes/mem_pool.c b/src/libhydra/attributes/mem_pool.c new file mode 100644 index 000000000..bba793f28 --- /dev/null +++ b/src/libhydra/attributes/mem_pool.c @@ -0,0 +1,429 @@ +/* + * Copyright (C) 2010 Tobias Brunner + * Copyright (C) 2008 Martin Willi + * Hochschule fuer Technik Rapperswil + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#include "mem_pool.h" + +#include <debug.h> +#include <utils/hashtable.h> + +#define POOL_LIMIT (sizeof(uintptr_t)*8) + +typedef struct private_mem_pool_t private_mem_pool_t; + +/** + * private data of mem_pool_t + */ +struct private_mem_pool_t { + /** + * public interface + */ + mem_pool_t public; + + /** + * name of the pool + */ + char *name; + + /** + * base address of the pool + */ + host_t *base; + + /** + * size of the pool + */ + u_int size; + + /** + * next unused address + */ + u_int unused; + + /** + * hashtable [identity => offset], for online leases + */ + hashtable_t *online; + + /** + * hashtable [identity => offset], for offline leases + */ + hashtable_t *offline; + + /** + * hashtable [identity => identity], handles identity references + */ + hashtable_t *ids; +}; + +/** + * hashtable hash function for identities + */ +static u_int id_hash(identification_t *id) +{ + return chunk_hash(id->get_encoding(id)); +} + +/** + * hashtable equals function for identities + */ +static bool id_equals(identification_t *a, identification_t *b) +{ + return a->equals(a, b); +} + +/** + * convert a pool offset to an address + */ +static host_t* offset2host(private_mem_pool_t *pool, int offset) +{ + chunk_t addr; + host_t *host; + u_int32_t *pos; + + offset--; + if (offset > pool->size) + { + return NULL; + } + + addr = chunk_clone(pool->base->get_address(pool->base)); + if (pool->base->get_family(pool->base) == AF_INET6) + { + pos = (u_int32_t*)(addr.ptr + 12); + } + else + { + pos = (u_int32_t*)addr.ptr; + } + *pos = htonl(offset + ntohl(*pos)); + host = host_create_from_chunk(pool->base->get_family(pool->base), addr, 0); + free(addr.ptr); + return host; +} + +/** + * convert a host to a pool offset + */ +static int host2offset(private_mem_pool_t *pool, host_t *addr) +{ + chunk_t host, base; + u_int32_t hosti, basei; + + if (addr->get_family(addr) != pool->base->get_family(pool->base)) + { + return -1; + } + host = addr->get_address(addr); + base = pool->base->get_address(pool->base); + if (addr->get_family(addr) == AF_INET6) + { + /* only look at last /32 block */ + if (!memeq(host.ptr, base.ptr, 12)) + { + return -1; + } + host = chunk_skip(host, 12); + base = chunk_skip(base, 12); + } + hosti = ntohl(*(u_int32_t*)(host.ptr)); + basei = ntohl(*(u_int32_t*)(base.ptr)); + if (hosti > basei + pool->size) + { + return -1; + } + return hosti - basei + 1; +} + +METHOD(mem_pool_t, get_name, const char*, + private_mem_pool_t *this) +{ + return this->name; +} + +METHOD(mem_pool_t, get_size, u_int, + private_mem_pool_t *this) +{ + return this->size; +} + +METHOD(mem_pool_t, get_online, u_int, + private_mem_pool_t *this) +{ + return this->online->get_count(this->online); +} + +METHOD(mem_pool_t, get_offline, u_int, + private_mem_pool_t *this) +{ + return this->offline->get_count(this->offline); +} + +METHOD(mem_pool_t, acquire_address, host_t*, + private_mem_pool_t *this, identification_t *id, host_t *requested) +{ + uintptr_t offset = 0; + enumerator_t *enumerator; + identification_t *old_id; + + /* if the pool is empty (e.g. in the %config case) we simply return the + * requested address */ + if (this->size == 0) + { + return requested->clone(requested); + } + + while (TRUE) + { + if (!requested->is_anyaddr(requested) && + requested->get_family(requested) != + this->base->get_family(this->base)) + { + DBG1("IP pool address family mismatch"); + break; + } + + /* check for a valid offline lease, refresh */ + offset = (uintptr_t)this->offline->remove(this->offline, id); + if (offset) + { + id = this->ids->get(this->ids, id); + if (id) + { + DBG1("reassigning offline lease to '%Y'", id); + this->online->put(this->online, id, (void*)offset); + break; + } + } + + /* check for a valid online lease, reassign */ + offset = (uintptr_t)this->online->get(this->online, id); + if (offset && offset == host2offset(this, requested)) + { + DBG1("reassigning online lease to '%Y'", id); + break; + } + + if (this->unused < this->size) + { + /* assigning offset, starting by 1. Handling 0 in hashtable + * is difficult. */ + offset = ++this->unused; + id = id->clone(id); + this->ids->put(this->ids, id, id); + this->online->put(this->online, id, (void*)offset); + DBG1("assigning new lease to '%Y'", id); + break; + } + + /* no more addresses, replace the first found offline lease */ + enumerator = this->offline->create_enumerator(this->offline); + if (enumerator->enumerate(enumerator, &old_id, &offset)) + { + offset = (uintptr_t)this->offline->remove(this->offline, old_id); + if (offset) + { + /* destroy reference to old ID */ + old_id = this->ids->remove(this->ids, old_id); + DBG1("reassigning existing offline lease by '%Y' to '%Y'", + old_id, id); + if (old_id) + { + old_id->destroy(old_id); + } + id = id->clone(id); + this->ids->put(this->ids, id, id); + this->online->put(this->online, id, (void*)offset); + enumerator->destroy(enumerator); + break; + } + } + enumerator->destroy(enumerator); + + DBG1("pool '%s' is full, unable to assign address", this->name); + break; + } + + if (offset) + { + return offset2host(this, offset); + } + return NULL; +} + +METHOD(mem_pool_t, release_address, bool, + private_mem_pool_t *this, host_t *address, identification_t *id) +{ + uintptr_t offset; + if (this->size != 0) + { + offset = (uintptr_t)this->online->remove(this->online, id); + if (offset) + { + id = this->ids->get(this->ids, id); + if (id) + { + DBG1("lease %H by '%Y' went offline", address, id); + this->offline->put(this->offline, id, (void*)offset); + return TRUE; + } + } + } + return FALSE; +} + +/** + * lease enumerator + */ +typedef struct { + /** implemented enumerator interface */ + enumerator_t public; + /** inner hash-table enumerator */ + enumerator_t *inner; + /** enumerated pool */ + private_mem_pool_t *pool; + /** currently enumerated lease address */ + host_t *current; +} lease_enumerator_t; + +METHOD(enumerator_t, lease_enumerate, bool, + lease_enumerator_t *this, identification_t **id_out, host_t **addr_out, + bool *online) +{ + identification_t *id; + uintptr_t offset; + + DESTROY_IF(this->current); + this->current = NULL; + + if (this->inner->enumerate(this->inner, &id, NULL)) + { + offset = (uintptr_t)this->pool->online->get(this->pool->online, id); + if (offset) + { + *id_out = id; + *addr_out = this->current = offset2host(this->pool, offset); + *online = TRUE; + return TRUE; + } + offset = (uintptr_t)this->pool->offline->get(this->pool->offline, id); + if (offset) + { + *id_out = id; + *addr_out = this->current = offset2host(this->pool, offset); + *online = FALSE; + return TRUE; + } + } + return FALSE; +} + +METHOD(enumerator_t, lease_enumerator_destroy, void, + lease_enumerator_t *this) +{ + DESTROY_IF(this->current); + this->inner->destroy(this->inner); + free(this); +} + +METHOD(mem_pool_t, create_lease_enumerator, enumerator_t*, + private_mem_pool_t *this) +{ + lease_enumerator_t *enumerator; + + INIT(enumerator, + .public = { + .enumerate = (void*)_lease_enumerate, + .destroy = (void*)_lease_enumerator_destroy, + }, + .pool = this, + .inner = this->ids->create_enumerator(this->ids), + ); + + return &enumerator->public; +} + +METHOD(mem_pool_t, destroy, void, + private_mem_pool_t *this) +{ + enumerator_t *enumerator; + identification_t *id; + + enumerator = this->ids->create_enumerator(this->ids); + while (enumerator->enumerate(enumerator, &id, NULL)) + { + id->destroy(id); + } + enumerator->destroy(enumerator); + + this->ids->destroy(this->ids); + this->online->destroy(this->online); + this->offline->destroy(this->offline); + DESTROY_IF(this->base); + free(this->name); + free(this); +} + +/** + * Described in header + */ +mem_pool_t *mem_pool_create(char *name, host_t *base, int bits) +{ + private_mem_pool_t *this; + + INIT(this, + .public = { + .get_name = _get_name, + .get_size = _get_size, + .get_online = _get_online, + .get_offline = _get_offline, + .acquire_address = _acquire_address, + .release_address = _release_address, + .create_lease_enumerator = _create_lease_enumerator, + .destroy = _destroy, + }, + .name = strdup(name), + .online = hashtable_create((hashtable_hash_t)id_hash, + (hashtable_equals_t)id_equals, 16), + .offline = hashtable_create((hashtable_hash_t)id_hash, + (hashtable_equals_t)id_equals, 16), + .ids = hashtable_create((hashtable_hash_t)id_hash, + (hashtable_equals_t)id_equals, 16), + ); + + if (base) + { + int addr_bits = base->get_family(base) == AF_INET ? 32 : 128; + /* net bits -> host bits */ + bits = addr_bits - bits; + if (bits > POOL_LIMIT) + { + bits = POOL_LIMIT; + DBG1("virtual IP pool too large, limiting to %H/%d", + base, addr_bits - bits); + } + this->size = 1 << (bits); + + if (this->size > 2) + { /* do not use first and last addresses of a block */ + this->unused++; + this->size--; + } + this->base = base->clone(base); + } + + return &this->public; +} + diff --git a/src/libhydra/attributes/mem_pool.h b/src/libhydra/attributes/mem_pool.h new file mode 100644 index 000000000..6685fd61a --- /dev/null +++ b/src/libhydra/attributes/mem_pool.h @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2010 Tobias Brunner + * Hochschule fuer Technik Rapperswil + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +/** + * @defgroup mem_pool mem_pool + * @{ @ingroup attributes + */ + +#ifndef MEM_POOL_H +#define MEM_POOL_H + +typedef struct mem_pool_t mem_pool_t; + +#include <utils/host.h> +#include <utils/identification.h> + +/** + * An in-memory IP address pool. + * + * @note the implementation is not thread-safe. + */ +struct mem_pool_t { + + /** + * Get the name of this pool. + * + * @return the name of this pool + */ + const char* (*get_name)(mem_pool_t *this); + + /** + * Get the size (i.e. number of addresses) of this pool. + * + * @return the size of this pool + */ + u_int (*get_size)(mem_pool_t *this); + + /** + * Get the number of online leases. + * + * @return the number of offline leases + */ + u_int (*get_online)(mem_pool_t *this); + + /** + * Get the number of offline leases. + * + * @return the number of online leases + */ + u_int (*get_offline)(mem_pool_t *this); + + /** + * Acquire an address for the given id from this pool. + * + * @param id the id to acquire an address for + * @param requested acquire this address, if possible + * @return the acquired address + */ + host_t* (*acquire_address)(mem_pool_t *this, identification_t *id, + host_t *requested); + + /** + * Release a previously acquired address. + * + * @param address the address to release + * @param id the id the address was assigned to + * @return TRUE, if the lease was found + */ + bool (*release_address)(mem_pool_t *this, host_t *address, + identification_t *id); + + /** + * Create an enumerator over the leases of this pool. + * + * Enumerator enumerates over + * identification_t *id, host_t *address, bool online + * + * @return enumerator + */ + enumerator_t* (*create_lease_enumerator)(mem_pool_t *this); + + /** + * Destroy a mem_pool_t instance. + */ + void (*destroy)(mem_pool_t *this); +}; + +/** + * Create an in-memory IP address pool. + * + * An empty pool just returns the requested address. + * + * @param name name of this pool + * @param base base address of this pool, NULL to create an empty pool + * @param bits net mask + */ +mem_pool_t *mem_pool_create(char *name, host_t *base, int bits); + +#endif /** MEM_POOL_H_ @} */ + |