X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fippool.c;h=f2e9b000195723cd711c511faee93dff81591a6d;hb=c647a4b6f1132684c9d8b8ad71ec38d81147b278;hp=f0952ff1c856f6e41038e468afc4aa6928597181;hpb=da94095914e25fd26a793d348884b39e913a56d2;p=platform%2Fupstream%2Fconnman.git diff --git a/src/ippool.c b/src/ippool.c old mode 100644 new mode 100755 index f0952ff..f2e9b00 --- a/src/ippool.c +++ b/src/ippool.c @@ -2,8 +2,8 @@ * * Connection Manager * - * Copyright (C) 2007-2012 Intel Corporation. All rights reserved. - * Copyright (C) 2012 BMW Car IT GmbH. All rights reserved. + * Copyright (C) 2007-2013 Intel Corporation. All rights reserved. + * Copyright (C) 2012-2014 BMW Car IT GmbH. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as @@ -24,21 +24,25 @@ #include #endif -#include #include #include #include #include -#include #include #include "connman.h" -struct connman_ippool { - unsigned int refcount; - +struct address_info { int index; - uint32_t block; + uint32_t start; + uint32_t end; + + unsigned int use_count; + struct connman_ippool *pool; +}; + +struct connman_ippool { + struct address_info *info; char *gateway; char *broadcast; @@ -50,39 +54,31 @@ struct connman_ippool { void *user_data; }; -static GHashTable *hash_pool; -static GHashTable *hash_addresses; +GSList *allocated_blocks; + static uint32_t last_block; static uint32_t block_16_bits; static uint32_t block_20_bits; static uint32_t block_24_bits; static uint32_t subnet_mask_24; -struct connman_ippool * -__connman_ippool_ref_debug(struct connman_ippool *pool, - const char *file, int line, const char *caller) +void __connman_ippool_free(struct connman_ippool *pool) { - DBG("%p ref %d by %s:%d:%s()", pool, pool->refcount + 1, - file, line, caller); - - __sync_fetch_and_add(&pool->refcount, 1); - - return pool; -} - -void __connman_ippool_unref_debug(struct connman_ippool *pool, - const char *file, int line, const char *caller) -{ - if (pool == NULL) + if (!pool) return; - DBG("%p ref %d by %s:%d:%s()", pool, pool->refcount - 1, - file, line, caller); + if (pool->info) { + allocated_blocks = g_slist_remove(allocated_blocks, pool->info); + g_free(pool->info); + } - if (__sync_fetch_and_sub(&pool->refcount, 1) != 1) - return; + g_free(pool->gateway); + g_free(pool->broadcast); + g_free(pool->start_ip); + g_free(pool->end_ip); + g_free(pool->subnet_mask); - g_hash_table_remove(hash_pool, GUINT_TO_POINTER(pool->block)); + g_free(pool); } static char *get_ip(uint32_t ip) @@ -110,7 +106,7 @@ static uint32_t next_block(uint32_t block) next += 1; if (next == 255) { - if ((block & 0xffffff00) == block_16_bits) { + if ((block & 0xffff0000) == block_16_bits) { /* * Reached the end of the 16 bit block, switch * to the 20-bit block. @@ -156,15 +152,12 @@ static uint32_t next_block(uint32_t block) return (block & 0xffff0000) | ((next << 8) & 0x0000ff00); } -static uint32_t find_free_block() +static uint32_t get_free_block(unsigned int size) { - struct connman_ippool *pool; - uint32_t start; + struct address_info *info; uint32_t block; - uint32_t *key; - - if (last_block == 0) - return block_16_bits; + GSList *list; + bool collision; /* * Instead starting always from the 16 bit block, we start @@ -176,77 +169,156 @@ static uint32_t find_free_block() * To only thing we have to make sure is that we terminated if * there is no block left. */ - start = last_block; + if (last_block) + block = last_block; + else + block = block_16_bits; + + do { + collision = false; + for (list = allocated_blocks; list; list = list->next) { + info = list->data; + + if (info->start <= block && block <= info->end) { + collision = true; + break; + } + } + + if (!collision) + return block; - block = next_block(start); - while (start != block) { block = next_block(block); + } while (block != last_block); - key = GUINT_TO_POINTER(block); - pool = g_hash_table_lookup(hash_pool, key); - if (pool != NULL) - continue; + return 0; +} - if (g_hash_table_lookup(hash_addresses, key) != NULL) - continue; +static struct address_info *lookup_info(int index, uint32_t start) +{ + GSList *list; + + for (list = allocated_blocks; list; list = list->next) { + struct address_info *info = list->data; - return block; + if (info->index == index && info->start == start) + return info; } - return 0; + return NULL; +} + +static bool is_private_address(uint32_t address) +{ + unsigned int a, b; + + a = (address & 0xff000000) >> 24; + b = (address & 0x00ff0000) >> 16; + + if (a == 10 || (a == 192 && b == 168) || + (a == 172 && (b >= 16 && b <= 31))) + return true; + + return false; } void __connman_ippool_newaddr(int index, const char *address, unsigned char prefixlen) { - struct connman_ippool *pool; + struct address_info *info, *it; struct in_addr inp; - uint32_t block; - uint32_t *key; - unsigned int count; + uint32_t start, end, mask; + GSList *list; if (inet_aton(address, &inp) == 0) return; - block = ntohl(inp.s_addr) & 0xffffff00; + start = ntohl(inp.s_addr); + if (!is_private_address(start)) + return; + + if (prefixlen >= 32) + mask = 0xffffffff; + else + mask = ~(0xffffffff >> prefixlen); + + start = start & mask; + end = start | ~mask; - key = GUINT_TO_POINTER(block); - count = GPOINTER_TO_UINT(g_hash_table_lookup(hash_addresses, key)); - count = count + 1; - g_hash_table_replace(hash_addresses, key, GUINT_TO_POINTER(count)); + info = lookup_info(index, start); + if (info) + goto update; - pool = g_hash_table_lookup(hash_pool, key); - if (pool == NULL) + info = g_try_new0(struct address_info, 1); + if (!info) return; - if (pool->index == index) + info->index = index; + info->start = start; + info->end = end; + + allocated_blocks = g_slist_prepend(allocated_blocks, info); + +update: + info->use_count = info->use_count + 1; + + if (info->use_count > 1 || info->pool) { + /* + * We need only to check for the first IP in a block for + * collisions. + */ return; + } + + for (list = allocated_blocks; list; list = list->next) { + it = list->data; + + if (it == info) + continue; + + if (!(info->start >= it->start && info->start <= it->end)) + continue; + + if (it->pool && it->pool->collision_cb) + it->pool->collision_cb(it->pool, it->pool->user_data); - if (pool->collision_cb != NULL) - pool->collision_cb(pool, pool->user_data); + return; + } } void __connman_ippool_deladdr(int index, const char *address, unsigned char prefixlen) { + struct address_info *info; struct in_addr inp; - uint32_t block; - uint32_t *key; - unsigned int count; + uint32_t start, mask; if (inet_aton(address, &inp) == 0) return; - block = ntohl(inp.s_addr) & 0xffffff00; + start = ntohl(inp.s_addr); + if (!is_private_address(start)) + return; - key = GUINT_TO_POINTER(block); - count = GPOINTER_TO_UINT(g_hash_table_lookup(hash_addresses, key)); - count = count - 1; + mask = ~(0xffffffff >> prefixlen); + start = start & mask; - if (count == 0) - g_hash_table_remove(hash_addresses, key); - else - g_hash_table_replace(hash_addresses, key, GUINT_TO_POINTER(count)); + info = lookup_info(index, start); + if (!info) { + /* In theory this should never happen */ + connman_error("Inconsistent IP pool management (start not found)"); + return; + } + + info->use_count = info->use_count - 1; + if (info->pool) + return; + + if (info->use_count > 0) + return; + + allocated_blocks = g_slist_remove(allocated_blocks, info); + g_free(info); } struct connman_ippool *__connman_ippool_create(int index, @@ -256,41 +328,58 @@ struct connman_ippool *__connman_ippool_create(int index, void *user_data) { struct connman_ippool *pool; + struct address_info *info; uint32_t block; + DBG(""); + /* * The range is at max 255 and we don't support overlapping * blocks. */ - if (start + range > 254) + if (start + range > 254) { + connman_error("IP pool does not support pool size larger than 254"); return NULL; + } - block = find_free_block(); - if (block == 0) + block = get_free_block(start + range); + if (block == 0) { + connman_warn("Could not find a free IP block"); return NULL; + } pool = g_try_new0(struct connman_ippool, 1); - if (pool == NULL) + if (!pool) + return NULL; + + info = g_try_new0(struct address_info, 1); + if (!info) { + g_free(pool); return NULL; + } + + last_block = block; - pool->refcount = 1; - pool->index = index; - pool->block = block; + info->index = index; + info->start = block; + info->end = block + range; + + pool->info = info; pool->collision_cb = collision_cb; pool->user_data = user_data; - last_block = block; + info->pool = pool; if (range == 0) range = 1; - pool->gateway = get_ip(block + 1); - pool->broadcast = get_ip(block + 255); + pool->gateway = get_ip(info->start + 1); + pool->broadcast = get_ip(info->start + 255); pool->subnet_mask = get_ip(subnet_mask_24); pool->start_ip = get_ip(block + start); pool->end_ip = get_ip(block + start + range); - g_hash_table_insert(hash_pool, GUINT_TO_POINTER(pool->block), pool); + allocated_blocks = g_slist_prepend(allocated_blocks, info); return pool; } @@ -320,34 +409,15 @@ const char *__connman_ippool_get_subnet_mask(struct connman_ippool *pool) return pool->subnet_mask; } -static void pool_free(gpointer data) -{ - struct connman_ippool *pool = data; - - g_free(pool->gateway); - g_free(pool->broadcast); - g_free(pool->start_ip); - g_free(pool->end_ip); - g_free(pool->subnet_mask); - - g_free(pool); -} - int __connman_ippool_init(void) { DBG(""); - /* We start at 254 by default to avoid common addresses */ - block_16_bits = ntohl(inet_addr("192.168.254.0")); + block_16_bits = ntohl(inet_addr("192.168.0.0")); block_20_bits = ntohl(inet_addr("172.16.0.0")); block_24_bits = ntohl(inet_addr("10.0.0.0")); subnet_mask_24 = ntohl(inet_addr("255.255.255.0")); - hash_pool = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, - pool_free); - hash_addresses = g_hash_table_new_full(g_direct_hash, g_direct_equal, - NULL, NULL); - return 0; } @@ -355,9 +425,7 @@ void __connman_ippool_cleanup(void) { DBG(""); - g_hash_table_destroy(hash_pool); - hash_pool = NULL; - - g_hash_table_destroy(hash_addresses); - hash_addresses = NULL; + g_slist_free_full(allocated_blocks, g_free); + last_block = 0; + allocated_blocks = NULL; }