X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fipconfig.c;h=fe99b816a4b698e498dfe6b67537dfea80f3be3f;hb=dd3cccc5e67548dcc2dd6c6254ed6c97859085d5;hp=26380d89c9006a2b08e19e222c2a6f4fe57687fe;hpb=1c7e42c140557bb9e0e0c7573f8112aa4e833e9f;p=platform%2Fupstream%2Fconnman.git diff --git a/src/ipconfig.c b/src/ipconfig.c index 26380d8..915c082 100644 --- a/src/ipconfig.c +++ b/src/ipconfig.c @@ -2,7 +2,7 @@ * * Connection Manager * - * Copyright (C) 2007-2010 Intel Corporation. All rights reserved. + * Copyright (C) 2007-2013 Intel Corporation. All rights reserved. * * 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 @@ -23,23 +23,27 @@ #include #endif +#include +#include #include #include #include +#include +#include #ifndef IFF_LOWER_UP #define IFF_LOWER_UP 0x10000 #endif #include +#include #include "connman.h" struct connman_ipconfig { - gint refcount; + int refcount; int index; - - struct connman_ipconfig *origin; + enum connman_ipconfig_type type; const struct connman_ipconfig_ops *ops; void *ops_data; @@ -47,126 +51,135 @@ struct connman_ipconfig { enum connman_ipconfig_method method; struct connman_ipaddress *address; struct connman_ipaddress *system; + + int ipv6_privacy_config; + char *last_dhcp_address; + char **last_dhcpv6_prefixes; }; struct connman_ipdevice { int index; - char *ifname; unsigned short type; unsigned int flags; char *address; uint16_t mtu; - uint32_t tx_bytes; + uint32_t rx_packets; + uint32_t tx_packets; uint32_t rx_bytes; + uint32_t tx_bytes; + uint32_t rx_errors; + uint32_t tx_errors; + uint32_t rx_dropped; + uint32_t tx_dropped; GSList *address_list; - char *gateway; + char *ipv4_gateway; + char *ipv6_gateway; + + char *pac; - struct connman_ipconfig *config; + struct connman_ipconfig *config_ipv4; + struct connman_ipconfig *config_ipv6; + + bool ipv6_enabled; + int ipv6_privacy; +}; - struct connman_ipconfig_driver *driver; - struct connman_ipconfig *driver_config; +struct ipconfig_store { + GKeyFile *file; + const char *group; + const char *prefix; }; static GHashTable *ipdevice_hash = NULL; static GList *ipconfig_list = NULL; +static bool is_ipv6_supported = false; -struct connman_ipaddress *connman_ipaddress_alloc(void) -{ - struct connman_ipaddress *ipaddress; - - ipaddress = g_try_new0(struct connman_ipaddress, 1); - if (ipaddress == NULL) - return NULL; +static void store_set_str(struct ipconfig_store *store, + const char *key, const char *val) - return ipaddress; -} - -void connman_ipaddress_free(struct connman_ipaddress *ipaddress) { - if (ipaddress == NULL) + char *pk; + + if (!val || strlen(val) == 0) return; - g_free(ipaddress->broadcast); - g_free(ipaddress->peer); - g_free(ipaddress->local); - g_free(ipaddress->gateway); - g_free(ipaddress); + pk = g_strdup_printf("%s%s", store->prefix, key); + g_key_file_set_string(store->file, store->group, pk, val); + g_free(pk); } -static unsigned char netmask2prefixlen(const char *netmask) +static char *store_get_str(struct ipconfig_store *store, const char *key) { - unsigned char bits = 0; - in_addr_t mask = inet_network(netmask); - in_addr_t host = ~mask; + char *pk, *val; - /* a valid netmask must be 2^n - 1 */ - if ((host & (host + 1)) != 0) - return -1; - - for (; mask; mask <<= 1) - ++bits; + pk = g_strdup_printf("%s%s", store->prefix, key); + val = g_key_file_get_string(store->file, store->group, pk, NULL); + g_free(pk); - return bits; + return val; } -void connman_ipaddress_set(struct connman_ipaddress *ipaddress, - const char *address, const char *netmask, const char *gateway) +static void store_set_strs(struct ipconfig_store *store, + const char *key, char **val) { - if (ipaddress == NULL) - return; + guint len; + char *pk; - if (netmask != NULL) - ipaddress->prefixlen = netmask2prefixlen(netmask); - else - ipaddress->prefixlen = 32; + if (!val) + return; - g_free(ipaddress->local); - ipaddress->local = g_strdup(address); + len = g_strv_length(val); + if (len == 0) + return; - g_free(ipaddress->gateway); - ipaddress->gateway = g_strdup(gateway); + pk = g_strdup_printf("%s%s", store->prefix, key); + g_key_file_set_string_list(store->file, store->group, + pk, (const gchar **)val, len); + g_free(pk); } -void connman_ipaddress_clear(struct connman_ipaddress *ipaddress) +static char **store_get_strs(struct ipconfig_store *store, const char *key) { - if (ipaddress == NULL) - return; + gsize len; + char *pk, **val; - ipaddress->prefixlen = 0; + pk = g_strdup_printf("%s%s", store->prefix, key); + val = g_key_file_get_string_list(store->file, store->group, + pk, &len, NULL); + g_free(pk); - g_free(ipaddress->local); - ipaddress->local = NULL; - - g_free(ipaddress->peer); - ipaddress->peer = NULL; - - g_free(ipaddress->broadcast); - ipaddress->broadcast = NULL; + if (val && len == 0) { + g_free(val); + return NULL; + } - g_free(ipaddress->gateway); - ipaddress->gateway = NULL; + return val; } -void connman_ipaddress_copy(struct connman_ipaddress *ipaddress, - struct connman_ipaddress *source) +static void store_set_int(struct ipconfig_store *store, + const char *key, int val) { - if (ipaddress == NULL || source == NULL) - return; + char *pk; - ipaddress->prefixlen = source->prefixlen; + if (val == 0) + return; - g_free(ipaddress->local); - ipaddress->local = g_strdup(source->local); + pk = g_strdup_printf("%s%s", store->prefix, key); + g_key_file_set_integer(store->file, store->group, pk, val); + g_free(pk); +} - g_free(ipaddress->peer); - ipaddress->peer = g_strdup(source->peer); +static int store_get_int(struct ipconfig_store *store, const char *key) +{ + int val; + char *pk; - g_free(ipaddress->broadcast); - ipaddress->broadcast = g_strdup(source->broadcast); + pk = g_strdup_printf("%s%s", store->prefix, key); + val = g_key_file_get_integer(store->file, store->group, pk, 0); + g_free(pk); - g_free(ipaddress->gateway); - ipaddress->gateway = g_strdup(source->gateway); + return val; } static void free_address_list(struct connman_ipdevice *ipdevice) @@ -200,6 +213,21 @@ static struct connman_ipaddress *find_ipaddress(struct connman_ipdevice *ipdevic return NULL; } +const char *__connman_ipconfig_type2string(enum connman_ipconfig_type type) +{ + switch (type) { + case CONNMAN_IPCONFIG_TYPE_UNKNOWN: + case CONNMAN_IPCONFIG_TYPE_ALL: + return "unknown"; + case CONNMAN_IPCONFIG_TYPE_IPV4: + return "IPv4"; + case CONNMAN_IPCONFIG_TYPE_IPV6: + return "IPv6"; + } + + return NULL; +} + static const char *type2str(unsigned short type) { switch (type) { @@ -230,145 +258,278 @@ static const char *scope2str(unsigned char scope) return ""; } -static void free_ipdevice(gpointer data) +static bool get_ipv6_state(gchar *ifname) { - struct connman_ipdevice *ipdevice = data; + int disabled; + gchar *path; + FILE *f; + bool enabled = false; - connman_info("%s {remove} index %d", ipdevice->ifname, - ipdevice->index); + if (!ifname) + path = g_strdup("/proc/sys/net/ipv6/conf/all/disable_ipv6"); + else + path = g_strdup_printf( + "/proc/sys/net/ipv6/conf/%s/disable_ipv6", ifname); - if (ipdevice->config != NULL) - connman_ipconfig_unref(ipdevice->config); + if (!path) + return enabled; - free_address_list(ipdevice); - g_free(ipdevice->gateway); + f = fopen(path, "r"); - g_free(ipdevice->address); - g_free(ipdevice->ifname); - g_free(ipdevice); + g_free(path); + + if (f) { + if (fscanf(f, "%d", &disabled) > 0) + enabled = !disabled; + fclose(f); + } + + return enabled; } -static GSList *driver_list = NULL; +static void set_ipv6_state(gchar *ifname, bool enable) +{ + gchar *path; + FILE *f; + + if (!ifname) + path = g_strdup("/proc/sys/net/ipv6/conf/all/disable_ipv6"); + else + path = g_strdup_printf( + "/proc/sys/net/ipv6/conf/%s/disable_ipv6", ifname); + + if (!path) + return; + + f = fopen(path, "r+"); + + g_free(path); + + if (!f) + return; + + if (!enable) + fprintf(f, "1"); + else + fprintf(f, "0"); + + fclose(f); +} -static gint compare_priority(gconstpointer a, gconstpointer b) +static int get_ipv6_privacy(gchar *ifname) { - const struct connman_ipconfig_driver *driver1 = a; - const struct connman_ipconfig_driver *driver2 = b; + gchar *path; + FILE *f; + int value; + + if (!ifname) + return 0; + + path = g_strdup_printf("/proc/sys/net/ipv6/conf/%s/use_tempaddr", + ifname); - return driver2->priority - driver1->priority; + if (!path) + return 0; + + f = fopen(path, "r"); + + g_free(path); + + if (!f) + return 0; + + if (fscanf(f, "%d", &value) <= 0) + value = 0; + + fclose(f); + + return value; } -/** - * connman_ipconfig_driver_register: - * @driver: IP configuration driver - * - * Register a new IP configuration driver - * - * Returns: %0 on success +/* Enable the IPv6 privacy extension for stateless address autoconfiguration. + * The privacy extension is described in RFC 3041 and RFC 4941 */ -int connman_ipconfig_driver_register(struct connman_ipconfig_driver *driver) +static void set_ipv6_privacy(gchar *ifname, int value) { - DBG("driver %p name %s", driver, driver->name); + gchar *path; + FILE *f; + + if (!ifname) + return; - driver_list = g_slist_insert_sorted(driver_list, driver, - compare_priority); + path = g_strdup_printf("/proc/sys/net/ipv6/conf/%s/use_tempaddr", + ifname); - return 0; + if (!path) + return; + + if (value < 0) + value = 0; + + f = fopen(path, "r+"); + + g_free(path); + + if (!f) + return; + + fprintf(f, "%d", value); + fclose(f); } -/** - * connman_ipconfig_driver_unregister: - * @driver: IP configuration driver - * - * Remove a previously registered IP configuration driver. - */ -void connman_ipconfig_driver_unregister(struct connman_ipconfig_driver *driver) +static int get_rp_filter(void) { - DBG("driver %p name %s", driver, driver->name); + FILE *f; + int value = -EINVAL, tmp; - driver_list = g_slist_remove(driver_list, driver); + f = fopen("/proc/sys/net/ipv4/conf/all/rp_filter", "r"); + + if (f) { + if (fscanf(f, "%d", &tmp) == 1) + value = tmp; + fclose(f); + } + + return value; } -static void __connman_ipconfig_lower_up(struct connman_ipdevice *ipdevice) +static void set_rp_filter(int value) { - GSList *list; + FILE *f; - DBG("ipconfig %p", ipdevice->config); + f = fopen("/proc/sys/net/ipv4/conf/all/rp_filter", "r+"); - if (ipdevice->config == NULL) + if (!f) return; - switch (ipdevice->config->method) { - case CONNMAN_IPCONFIG_METHOD_UNKNOWN: - case CONNMAN_IPCONFIG_METHOD_OFF: - case CONNMAN_IPCONFIG_METHOD_FIXED: - case CONNMAN_IPCONFIG_METHOD_MANUAL: - return; - case CONNMAN_IPCONFIG_METHOD_DHCP: - break; - } + fprintf(f, "%d", value); - if (ipdevice->driver != NULL) - return; + fclose(f); +} - ipdevice->driver_config = connman_ipconfig_clone(ipdevice->config); - if (ipdevice->driver_config == NULL) - return; +int __connman_ipconfig_set_rp_filter() +{ + int value; - for (list = driver_list; list; list = list->next) { - struct connman_ipconfig_driver *driver = list->data; + value = get_rp_filter(); - if (driver->request(ipdevice->driver_config) == 0) { - ipdevice->driver = driver; - break; - } - } + if (value < 0) + return value; - if (ipdevice->driver == NULL) { - connman_ipconfig_unref(ipdevice->driver_config); - ipdevice->driver_config = NULL; - } + set_rp_filter(2); + + connman_info("rp_filter set to 2 (loose mode routing), " + "old value was %d", value); + + return value; } -static void __connman_ipconfig_lower_down(struct connman_ipdevice *ipdevice) +void __connman_ipconfig_unset_rp_filter(int old_value) { - DBG("ipconfig %p", ipdevice->config); + set_rp_filter(old_value); - if (ipdevice->config == NULL) - return; + connman_info("rp_filter restored to %d", old_value); +} - if (ipdevice->driver == NULL) - return; +bool __connman_ipconfig_ipv6_privacy_enabled(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig) + return false; + + return ipconfig->ipv6_privacy_config == 0 ? FALSE : TRUE; +} + +bool __connman_ipconfig_ipv6_is_enabled(struct connman_ipconfig *ipconfig) +{ + struct connman_ipdevice *ipdevice; + char *ifname; + bool ret; + + if (!ipconfig) + return false; + + ipdevice = g_hash_table_lookup(ipdevice_hash, + GINT_TO_POINTER(ipconfig->index)); + if (!ipdevice) + return false; + + ifname = connman_inet_ifname(ipconfig->index); + ret = get_ipv6_state(ifname); + g_free(ifname); + + return ret; +} + +static void free_ipdevice(gpointer data) +{ + struct connman_ipdevice *ipdevice = data; + char *ifname = connman_inet_ifname(ipdevice->index); + + connman_info("%s {remove} index %d", ifname, ipdevice->index); + + if (ipdevice->config_ipv4) { + __connman_ipconfig_unref(ipdevice->config_ipv4); + ipdevice->config_ipv4 = NULL; + } + + if (ipdevice->config_ipv6) { + __connman_ipconfig_unref(ipdevice->config_ipv6); + ipdevice->config_ipv6 = NULL; + } - ipdevice->driver->release(ipdevice->driver_config); + free_address_list(ipdevice); + g_free(ipdevice->ipv4_gateway); + g_free(ipdevice->ipv6_gateway); + g_free(ipdevice->pac); - ipdevice->driver = NULL; + g_free(ipdevice->address); - connman_ipconfig_unref(ipdevice->driver_config); - ipdevice->driver_config = NULL; + if (ifname) { + set_ipv6_state(ifname, ipdevice->ipv6_enabled); + set_ipv6_privacy(ifname, ipdevice->ipv6_privacy); + } - connman_inet_clear_address(ipdevice->index); + g_free(ifname); + g_free(ipdevice); } static void update_stats(struct connman_ipdevice *ipdevice, - struct rtnl_link_stats *stats) + const char *ifname, struct rtnl_link_stats *stats) { + struct connman_service *service; + if (stats->rx_packets == 0 && stats->tx_packets == 0) return; - connman_info("%s {RX} %u packets %u bytes", ipdevice->ifname, + connman_info("%s {RX} %u packets %u bytes", ifname, stats->rx_packets, stats->rx_bytes); - connman_info("%s {TX} %u packets %u bytes", ipdevice->ifname, + connman_info("%s {TX} %u packets %u bytes", ifname, stats->tx_packets, stats->tx_bytes); - if (ipdevice->config == NULL) + if (!ipdevice->config_ipv4 && !ipdevice->config_ipv6) + return; + + service = __connman_service_lookup_from_index(ipdevice->index); + + DBG("service %p", service); + + if (!service) return; + ipdevice->rx_packets = stats->rx_packets; + ipdevice->tx_packets = stats->tx_packets; ipdevice->rx_bytes = stats->rx_bytes; ipdevice->tx_bytes = stats->tx_bytes; - - __connman_counter_notify(ipdevice->ifname, - ipdevice->rx_bytes, ipdevice->tx_bytes); + ipdevice->rx_errors = stats->rx_errors; + ipdevice->tx_errors = stats->tx_errors; + ipdevice->rx_dropped = stats->rx_dropped; + ipdevice->tx_dropped = stats->tx_dropped; + + __connman_service_notify(service, + ipdevice->rx_packets, ipdevice->tx_packets, + ipdevice->rx_bytes, ipdevice->tx_bytes, + ipdevice->rx_errors, ipdevice->tx_errors, + ipdevice->rx_dropped, ipdevice->tx_dropped); } void __connman_ipconfig_newlink(int index, unsigned short type, @@ -377,10 +538,10 @@ void __connman_ipconfig_newlink(int index, unsigned short type, struct rtnl_link_stats *stats) { struct connman_ipdevice *ipdevice; - GList *list; + GList *list, *ipconfig_copy; GString *str; - gboolean up = FALSE, down = FALSE; - gboolean lower_up = FALSE, lower_down = FALSE; + bool up = false, down = false; + bool lower_up = false, lower_down = false; char *ifname; DBG("index %d", index); @@ -388,64 +549,58 @@ void __connman_ipconfig_newlink(int index, unsigned short type, if (type == ARPHRD_LOOPBACK) return; - ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice != NULL) - goto update; - ifname = connman_inet_ifname(index); - if (__connman_element_device_isfiltered(ifname) == TRUE) { - connman_info("Ignoring interface %s (filtered)", ifname); - g_free(ifname); - return; - } + ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); + if (ipdevice) + goto update; ipdevice = g_try_new0(struct connman_ipdevice, 1); - if (ipdevice == NULL) { - g_free(ifname); - return; - } + if (!ipdevice) + goto out; ipdevice->index = index; - ipdevice->ifname = ifname; ipdevice->type = type; + ipdevice->ipv6_enabled = get_ipv6_state(ifname); + ipdevice->ipv6_privacy = get_ipv6_privacy(ifname); + ipdevice->address = g_strdup(address); g_hash_table_insert(ipdevice_hash, GINT_TO_POINTER(index), ipdevice); - connman_info("%s {create} index %d type %d <%s>", ipdevice->ifname, + connman_info("%s {create} index %d type %d <%s>", ifname, index, type, type2str(type)); update: ipdevice->mtu = mtu; - update_stats(ipdevice, stats); + update_stats(ipdevice, ifname, stats); if (flags == ipdevice->flags) - return; + goto out; if ((ipdevice->flags & IFF_UP) != (flags & IFF_UP)) { if (flags & IFF_UP) - up = TRUE; + up = true; else - down = TRUE; + down = true; } if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) != (flags & (IFF_RUNNING | IFF_LOWER_UP))) { if ((flags & (IFF_RUNNING | IFF_LOWER_UP)) == (IFF_RUNNING | IFF_LOWER_UP)) - lower_up = TRUE; + lower_up = true; else if ((flags & (IFF_RUNNING | IFF_LOWER_UP)) == 0) - lower_down = TRUE; + lower_down = true; } ipdevice->flags = flags; str = g_string_new(NULL); - if (str == NULL) - return; + if (!str) + goto out; if (flags & IFF_UP) g_string_append(str, "UP"); @@ -458,50 +613,54 @@ update: if (flags & IFF_LOWER_UP) g_string_append(str, ",LOWER_UP"); - connman_info("%s {update} flags %u <%s>", ipdevice->ifname, - flags, str->str); + connman_info("%s {update} flags %u <%s>", ifname, flags, str->str); g_string_free(str, TRUE); - for (list = g_list_first(ipconfig_list); list; + ipconfig_copy = g_list_copy(ipconfig_list); + + for (list = g_list_first(ipconfig_copy); list; list = g_list_next(list)) { struct connman_ipconfig *ipconfig = list->data; if (index != ipconfig->index) continue; - if (ipconfig->ops == NULL) + if (!ipconfig->ops) continue; - if (up == TRUE && ipconfig->ops->up) - ipconfig->ops->up(ipconfig); - if (lower_up == TRUE && ipconfig->ops->lower_up) - ipconfig->ops->lower_up(ipconfig); + if (up && ipconfig->ops->up) + ipconfig->ops->up(ipconfig, ifname); + if (lower_up && ipconfig->ops->lower_up) + ipconfig->ops->lower_up(ipconfig, ifname); - if (lower_down == TRUE && ipconfig->ops->lower_down) - ipconfig->ops->lower_down(ipconfig); - if (down == TRUE && ipconfig->ops->down) - ipconfig->ops->down(ipconfig); + if (lower_down && ipconfig->ops->lower_down) + ipconfig->ops->lower_down(ipconfig, ifname); + if (down && ipconfig->ops->down) + ipconfig->ops->down(ipconfig, ifname); } - if (lower_up) - __connman_ipconfig_lower_up(ipdevice); - if (lower_down) - __connman_ipconfig_lower_down(ipdevice); + g_list_free(ipconfig_copy); + +out: + g_free(ifname); } void __connman_ipconfig_dellink(int index, struct rtnl_link_stats *stats) { struct connman_ipdevice *ipdevice; GList *list; + char *ifname; DBG("index %d", index); ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice == NULL) + if (!ipdevice) return; - update_stats(ipdevice, stats); + ifname = connman_inet_ifname(index); + + update_stats(ipdevice, ifname, stats); for (list = g_list_first(ipconfig_list); list; list = g_list_next(list)) { @@ -512,54 +671,88 @@ void __connman_ipconfig_dellink(int index, struct rtnl_link_stats *stats) ipconfig->index = -1; - if (ipconfig->ops == NULL) + if (!ipconfig->ops) continue; if (ipconfig->ops->lower_down) - ipconfig->ops->lower_down(ipconfig); + ipconfig->ops->lower_down(ipconfig, ifname); if (ipconfig->ops->down) - ipconfig->ops->down(ipconfig); + ipconfig->ops->down(ipconfig, ifname); } - __connman_ipconfig_lower_down(ipdevice); + g_free(ifname); g_hash_table_remove(ipdevice_hash, GINT_TO_POINTER(index)); } -void __connman_ipconfig_newaddr(int index, const char *label, +static inline gint check_duplicate_address(gconstpointer a, gconstpointer b) +{ + const struct connman_ipaddress *addr1 = a; + const struct connman_ipaddress *addr2 = b; + + if (addr1->prefixlen != addr2->prefixlen) + return addr2->prefixlen - addr1->prefixlen; + + return g_strcmp0(addr1->local, addr2->local); +} + +int __connman_ipconfig_newaddr(int index, int family, const char *label, unsigned char prefixlen, const char *address) { struct connman_ipdevice *ipdevice; struct connman_ipaddress *ipaddress; + enum connman_ipconfig_type type; GList *list; + char *ifname; DBG("index %d", index); ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice == NULL) - return; + if (!ipdevice) + return -ENXIO; - ipaddress = connman_ipaddress_alloc(); - if (ipaddress == NULL) - return; + ipaddress = connman_ipaddress_alloc(family); + if (!ipaddress) + return -ENOMEM; ipaddress->prefixlen = prefixlen; ipaddress->local = g_strdup(address); - ipdevice->address_list = g_slist_append(ipdevice->address_list, + if (g_slist_find_custom(ipdevice->address_list, ipaddress, + check_duplicate_address)) { + connman_ipaddress_free(ipaddress); + return -EALREADY; + } + + if (family == AF_INET) + type = CONNMAN_IPCONFIG_TYPE_IPV4; + else if (family == AF_INET6) + type = CONNMAN_IPCONFIG_TYPE_IPV6; + else + return -EINVAL; + + ipdevice->address_list = g_slist_prepend(ipdevice->address_list, ipaddress); - connman_info("%s {add} address %s/%u label %s", ipdevice->ifname, - address, prefixlen, label); + ifname = connman_inet_ifname(index); + connman_info("%s {add} address %s/%u label %s family %d", + ifname, address, prefixlen, label, family); - if (ipdevice->config != NULL) - connman_ipaddress_copy(ipdevice->config->system, ipaddress); + if (type == CONNMAN_IPCONFIG_TYPE_IPV4) + __connman_ippool_newaddr(index, address, prefixlen); - if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) != (IFF_RUNNING | IFF_LOWER_UP)) - return; + if (ipdevice->config_ipv4 && family == AF_INET) + connman_ipaddress_copy_address(ipdevice->config_ipv4->system, + ipaddress); - if (g_slist_length(ipdevice->address_list) > 1) - return; + else if (ipdevice->config_ipv6 && family == AF_INET6) + connman_ipaddress_copy_address(ipdevice->config_ipv6->system, + ipaddress); + else + goto out; + + if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) != (IFF_RUNNING | IFF_LOWER_UP)) + goto out; for (list = g_list_first(ipconfig_list); list; list = g_list_next(list)) { @@ -568,44 +761,65 @@ void __connman_ipconfig_newaddr(int index, const char *label, if (index != ipconfig->index) continue; - if (ipconfig->ops == NULL) + if (type != ipconfig->type) + continue; + + if (!ipconfig->ops) continue; if (ipconfig->ops->ip_bound) - ipconfig->ops->ip_bound(ipconfig); + ipconfig->ops->ip_bound(ipconfig, ifname); } + +out: + g_free(ifname); + return 0; } -void __connman_ipconfig_deladdr(int index, const char *label, +void __connman_ipconfig_deladdr(int index, int family, const char *label, unsigned char prefixlen, const char *address) { struct connman_ipdevice *ipdevice; struct connman_ipaddress *ipaddress; + enum connman_ipconfig_type type; GList *list; + char *ifname; DBG("index %d", index); ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice == NULL) + if (!ipdevice) return; ipaddress = find_ipaddress(ipdevice, prefixlen, address); - if (ipaddress == NULL) + if (!ipaddress) + return; + + if (family == AF_INET) + type = CONNMAN_IPCONFIG_TYPE_IPV4; + else if (family == AF_INET6) + type = CONNMAN_IPCONFIG_TYPE_IPV6; + else return; ipdevice->address_list = g_slist_remove(ipdevice->address_list, ipaddress); - connman_ipaddress_free(ipaddress); + if (type == CONNMAN_IPCONFIG_TYPE_IPV4) + __connman_ippool_deladdr(index, address, prefixlen); + + connman_ipaddress_clear(ipaddress); + g_free(ipaddress); - connman_info("%s {del} address %s/%u label %s", ipdevice->ifname, + ifname = connman_inet_ifname(index); + connman_info("%s {del} address %s/%u label %s", ifname, address, prefixlen, label); if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) != (IFF_RUNNING | IFF_LOWER_UP)) - return; + goto out; if (g_slist_length(ipdevice->address_list) > 0) - return; + goto out; for (list = g_list_first(ipconfig_list); list; list = g_list_next(list)) { @@ -614,54 +828,154 @@ void __connman_ipconfig_deladdr(int index, const char *label, if (index != ipconfig->index) continue; - if (ipconfig->ops == NULL) + if (type != ipconfig->type) + continue; + + if (!ipconfig->ops) continue; if (ipconfig->ops->ip_release) - ipconfig->ops->ip_release(ipconfig); + ipconfig->ops->ip_release(ipconfig, ifname); } + +out: + g_free(ifname); } -void __connman_ipconfig_newroute(int index, unsigned char scope, +void __connman_ipconfig_newroute(int index, int family, unsigned char scope, const char *dst, const char *gateway) { struct connman_ipdevice *ipdevice; + char *ifname; DBG("index %d", index); ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice == NULL) + if (!ipdevice) return; - if (scope == 0 && g_strcmp0(dst, "0.0.0.0") == 0) { - g_free(ipdevice->gateway); - ipdevice->gateway = g_strdup(gateway); + ifname = connman_inet_ifname(index); + + if (scope == 0 && (g_strcmp0(dst, "0.0.0.0") == 0 || + g_strcmp0(dst, "::") == 0)) { + GList *config_list; + enum connman_ipconfig_type type; + + if (family == AF_INET6) { + type = CONNMAN_IPCONFIG_TYPE_IPV6; + g_free(ipdevice->ipv6_gateway); + ipdevice->ipv6_gateway = g_strdup(gateway); + + if (ipdevice->config_ipv6 && + ipdevice->config_ipv6->system) { + g_free(ipdevice->config_ipv6->system->gateway); + ipdevice->config_ipv6->system->gateway = + g_strdup(gateway); + } + } else if (family == AF_INET) { + type = CONNMAN_IPCONFIG_TYPE_IPV4; + g_free(ipdevice->ipv4_gateway); + ipdevice->ipv4_gateway = g_strdup(gateway); + + if (ipdevice->config_ipv4 && + ipdevice->config_ipv4->system) { + g_free(ipdevice->config_ipv4->system->gateway); + ipdevice->config_ipv4->system->gateway = + g_strdup(gateway); + } + } else + goto out; + + for (config_list = g_list_first(ipconfig_list); config_list; + config_list = g_list_next(config_list)) { + struct connman_ipconfig *ipconfig = config_list->data; + + if (index != ipconfig->index) + continue; + + if (type != ipconfig->type) + continue; + + if (!ipconfig->ops) + continue; + + if (ipconfig->ops->route_set) + ipconfig->ops->route_set(ipconfig, ifname); + } } connman_info("%s {add} route %s gw %s scope %u <%s>", - ipdevice->ifname, dst, gateway, - scope, scope2str(scope)); + ifname, dst, gateway, scope, scope2str(scope)); + +out: + g_free(ifname); } -void __connman_ipconfig_delroute(int index, unsigned char scope, +void __connman_ipconfig_delroute(int index, int family, unsigned char scope, const char *dst, const char *gateway) { struct connman_ipdevice *ipdevice; + char *ifname; DBG("index %d", index); ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice == NULL) + if (!ipdevice) return; - if (scope == 0 && g_strcmp0(dst, "0.0.0.0") == 0) { - g_free(ipdevice->gateway); - ipdevice->gateway = NULL; + ifname = connman_inet_ifname(index); + + if (scope == 0 && (g_strcmp0(dst, "0.0.0.0") == 0 || + g_strcmp0(dst, "::") == 0)) { + GList *config_list; + enum connman_ipconfig_type type; + + if (family == AF_INET6) { + type = CONNMAN_IPCONFIG_TYPE_IPV6; + g_free(ipdevice->ipv6_gateway); + ipdevice->ipv6_gateway = NULL; + + if (ipdevice->config_ipv6 && + ipdevice->config_ipv6->system) { + g_free(ipdevice->config_ipv6->system->gateway); + ipdevice->config_ipv6->system->gateway = NULL; + } + } else if (family == AF_INET) { + type = CONNMAN_IPCONFIG_TYPE_IPV4; + g_free(ipdevice->ipv4_gateway); + ipdevice->ipv4_gateway = NULL; + + if (ipdevice->config_ipv4 && + ipdevice->config_ipv4->system) { + g_free(ipdevice->config_ipv4->system->gateway); + ipdevice->config_ipv4->system->gateway = NULL; + } + } else + goto out; + + for (config_list = g_list_first(ipconfig_list); config_list; + config_list = g_list_next(config_list)) { + struct connman_ipconfig *ipconfig = config_list->data; + + if (index != ipconfig->index) + continue; + + if (type != ipconfig->type) + continue; + + if (!ipconfig->ops) + continue; + + if (ipconfig->ops->route_unset) + ipconfig->ops->route_unset(ipconfig, ifname); + } } connman_info("%s {del} route %s gw %s scope %u <%s>", - ipdevice->ifname, dst, gateway, - scope, scope2str(scope)); + ifname, dst, gateway, scope, scope2str(scope)); + +out: + g_free(ifname); } void __connman_ipconfig_foreach(void (*function) (int index, void *user_data), @@ -670,7 +984,7 @@ void __connman_ipconfig_foreach(void (*function) (int index, void *user_data), GList *list, *keys; keys = g_hash_table_get_keys(ipdevice_hash); - if (keys == NULL) + if (!keys) return; for (list = g_list_first(keys); list; list = g_list_next(list)) { @@ -682,108 +996,285 @@ void __connman_ipconfig_foreach(void (*function) (int index, void *user_data), g_list_free(keys); } -unsigned short __connman_ipconfig_get_type(int index) +enum connman_ipconfig_type __connman_ipconfig_get_config_type( + struct connman_ipconfig *ipconfig) +{ + return ipconfig ? ipconfig->type : CONNMAN_IPCONFIG_TYPE_UNKNOWN; +} + +unsigned short __connman_ipconfig_get_type_from_index(int index) { struct connman_ipdevice *ipdevice; ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice == NULL) + if (!ipdevice) return ARPHRD_VOID; return ipdevice->type; } -unsigned int __connman_ipconfig_get_flags(int index) +unsigned int __connman_ipconfig_get_flags_from_index(int index) { struct connman_ipdevice *ipdevice; ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice == NULL) + if (!ipdevice) return 0; return ipdevice->flags; } -const char *__connman_ipconfig_get_gateway(int index) +const char *__connman_ipconfig_get_gateway_from_index(int index, + enum connman_ipconfig_type type) { struct connman_ipdevice *ipdevice; ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); - if (ipdevice == NULL) + if (!ipdevice) return NULL; - return ipdevice->gateway; -} + if (type != CONNMAN_IPCONFIG_TYPE_IPV6) { + if (ipdevice->ipv4_gateway) + return ipdevice->ipv4_gateway; -/** - * connman_ipconfig_create: - * - * Allocate a new ipconfig structure. - * - * Returns: a newly-allocated #connman_ipconfig structure - */ -struct connman_ipconfig *connman_ipconfig_create(int index) -{ - struct connman_ipconfig *ipconfig; + if (ipdevice->config_ipv4 && + ipdevice->config_ipv4->address) + return ipdevice->config_ipv4->address->gateway; + } - DBG("index %d", index); + if (type != CONNMAN_IPCONFIG_TYPE_IPV4) { + if (ipdevice->ipv6_gateway) + return ipdevice->ipv6_gateway; - ipconfig = g_try_new0(struct connman_ipconfig, 1); - if (ipconfig == NULL) - return NULL; + if (ipdevice->config_ipv6 && + ipdevice->config_ipv6->address) + return ipdevice->config_ipv6->address->gateway; + } - ipconfig->refcount = 1; + return NULL; +} +void __connman_ipconfig_set_index(struct connman_ipconfig *ipconfig, int index) +{ ipconfig->index = index; +} - ipconfig->address = connman_ipaddress_alloc(); - if (ipconfig->address == NULL) { - g_free(ipconfig); +const char *__connman_ipconfig_get_local(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig->address) return NULL; - } - - ipconfig->system = connman_ipaddress_alloc(); - - DBG("ipconfig %p", ipconfig); - return ipconfig; + return ipconfig->address->local; } -/** - * connman_ipconfig_clone: - * - * Clone an ipconfig structure and create new reference. - * - * Returns: a newly-allocated #connman_ipconfig structure - */ -struct connman_ipconfig *connman_ipconfig_clone(struct connman_ipconfig *ipconfig) +void __connman_ipconfig_set_local(struct connman_ipconfig *ipconfig, + const char *address) { - struct connman_ipconfig *ipconfig_clone; + if (!ipconfig->address) + return; - DBG("ipconfig %p", ipconfig); + g_free(ipconfig->address->local); + ipconfig->address->local = g_strdup(address); +} - ipconfig_clone = g_try_new0(struct connman_ipconfig, 1); - if (ipconfig_clone == NULL) +const char *__connman_ipconfig_get_peer(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig->address) return NULL; - ipconfig_clone->refcount = 1; + return ipconfig->address->peer; +} - ipconfig_clone->origin = connman_ipconfig_ref(ipconfig); +void __connman_ipconfig_set_peer(struct connman_ipconfig *ipconfig, + const char *address) +{ + if (!ipconfig->address) + return; + + g_free(ipconfig->address->peer); + ipconfig->address->peer = g_strdup(address); +} + +const char *__connman_ipconfig_get_broadcast(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig->address) + return NULL; + + return ipconfig->address->broadcast; +} + +void __connman_ipconfig_set_broadcast(struct connman_ipconfig *ipconfig, + const char *broadcast) +{ + if (!ipconfig->address) + return; + + g_free(ipconfig->address->broadcast); + ipconfig->address->broadcast = g_strdup(broadcast); +} + +const char *__connman_ipconfig_get_gateway(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig->address) + return NULL; + + return ipconfig->address->gateway; +} + +void __connman_ipconfig_set_gateway(struct connman_ipconfig *ipconfig, + const char *gateway) +{ + DBG(""); + + if (!ipconfig->address) + return; + g_free(ipconfig->address->gateway); + ipconfig->address->gateway = g_strdup(gateway); +} + +int __connman_ipconfig_gateway_add(struct connman_ipconfig *ipconfig) +{ + struct connman_service *service; + + DBG(""); + + if (!ipconfig->address) + return -EINVAL; + + service = __connman_service_lookup_from_index(ipconfig->index); + if (!service) + return -EINVAL; + + DBG("type %d gw %s peer %s", ipconfig->type, + ipconfig->address->gateway, ipconfig->address->peer); + + if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6 || + ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4) + return __connman_connection_gateway_add(service, + ipconfig->address->gateway, + ipconfig->type, + ipconfig->address->peer); + + return 0; +} + +void __connman_ipconfig_gateway_remove(struct connman_ipconfig *ipconfig) +{ + struct connman_service *service; + + DBG(""); + + service = __connman_service_lookup_from_index(ipconfig->index); + if (service) + __connman_connection_gateway_remove(service, ipconfig->type); +} + +unsigned char __connman_ipconfig_get_prefixlen(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig->address) + return 0; + + return ipconfig->address->prefixlen; +} + +void __connman_ipconfig_set_prefixlen(struct connman_ipconfig *ipconfig, + unsigned char prefixlen) +{ + if (!ipconfig->address) + return; + + ipconfig->address->prefixlen = prefixlen; +} + +static struct connman_ipconfig *create_ipv6config(int index) +{ + struct connman_ipconfig *ipv6config; + struct connman_ipdevice *ipdevice; + + ipv6config = g_try_new0(struct connman_ipconfig, 1); + if (!ipv6config) + return NULL; - ipconfig_clone->index = -1; + ipv6config->refcount = 1; - return ipconfig_clone; + ipv6config->index = index; + ipv6config->type = CONNMAN_IPCONFIG_TYPE_IPV6; + + if (!is_ipv6_supported) + ipv6config->method = CONNMAN_IPCONFIG_METHOD_OFF; + else + ipv6config->method = CONNMAN_IPCONFIG_METHOD_AUTO; + + ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index)); + if (ipdevice) + ipv6config->ipv6_privacy_config = ipdevice->ipv6_privacy; + + ipv6config->address = connman_ipaddress_alloc(AF_INET6); + if (!ipv6config->address) { + g_free(ipv6config); + return NULL; + } + + ipv6config->system = connman_ipaddress_alloc(AF_INET6); + + DBG("ipconfig %p index %d method %s", ipv6config, index, + __connman_ipconfig_method2string(ipv6config->method)); + + return ipv6config; } /** + * connman_ipconfig_create: + * + * Allocate a new ipconfig structure. + * + * Returns: a newly-allocated #connman_ipconfig structure + */ +struct connman_ipconfig *__connman_ipconfig_create(int index, + enum connman_ipconfig_type type) +{ + struct connman_ipconfig *ipconfig; + + if (type == CONNMAN_IPCONFIG_TYPE_IPV6) + return create_ipv6config(index); + + ipconfig = g_try_new0(struct connman_ipconfig, 1); + if (!ipconfig) + return NULL; + + ipconfig->refcount = 1; + + ipconfig->index = index; + ipconfig->type = CONNMAN_IPCONFIG_TYPE_IPV4; + + ipconfig->address = connman_ipaddress_alloc(AF_INET); + if (!ipconfig->address) { + g_free(ipconfig); + return NULL; + } + + ipconfig->system = connman_ipaddress_alloc(AF_INET); + + DBG("ipconfig %p index %d", ipconfig, index); + + return ipconfig; +} + + +/** * connman_ipconfig_ref: * @ipconfig: ipconfig structure * * Increase reference counter of ipconfig */ -struct connman_ipconfig *connman_ipconfig_ref(struct connman_ipconfig *ipconfig) +struct connman_ipconfig * +__connman_ipconfig_ref_debug(struct connman_ipconfig *ipconfig, + const char *file, int line, const char *caller) { - g_atomic_int_inc(&ipconfig->refcount); + DBG("%p ref %d by %s:%d:%s()", ipconfig, ipconfig->refcount + 1, + file, line, caller); + + __sync_fetch_and_add(&ipconfig->refcount, 1); return ipconfig; } @@ -794,22 +1285,28 @@ struct connman_ipconfig *connman_ipconfig_ref(struct connman_ipconfig *ipconfig) * * Decrease reference counter of ipconfig */ -void connman_ipconfig_unref(struct connman_ipconfig *ipconfig) +void __connman_ipconfig_unref_debug(struct connman_ipconfig *ipconfig, + const char *file, int line, const char *caller) { - if (g_atomic_int_dec_and_test(&ipconfig->refcount) == TRUE) { - __connman_ipconfig_disable(ipconfig); + if (!ipconfig) + return; - connman_ipconfig_set_ops(ipconfig, NULL); + DBG("%p ref %d by %s:%d:%s()", ipconfig, ipconfig->refcount - 1, + file, line, caller); - if (ipconfig->origin != NULL) { - connman_ipconfig_unref(ipconfig->origin); - ipconfig->origin = NULL; - } + if (__sync_fetch_and_sub(&ipconfig->refcount, 1) != 1) + return; - connman_ipaddress_free(ipconfig->system); - connman_ipaddress_free(ipconfig->address); - g_free(ipconfig); - } + if (__connman_ipconfig_disable(ipconfig) < 0) + ipconfig_list = g_list_remove(ipconfig_list, ipconfig); + + __connman_ipconfig_set_ops(ipconfig, NULL); + + connman_ipaddress_free(ipconfig->system); + connman_ipaddress_free(ipconfig->address); + g_free(ipconfig->last_dhcp_address); + g_strfreev(ipconfig->last_dhcpv6_prefixes); + g_free(ipconfig); } /** @@ -818,8 +1315,11 @@ void connman_ipconfig_unref(struct connman_ipconfig *ipconfig) * * Get private data pointer */ -void *connman_ipconfig_get_data(struct connman_ipconfig *ipconfig) +void *__connman_ipconfig_get_data(struct connman_ipconfig *ipconfig) { + if (!ipconfig) + return NULL; + return ipconfig->ops_data; } @@ -830,7 +1330,7 @@ void *connman_ipconfig_get_data(struct connman_ipconfig *ipconfig) * * Set private data pointer */ -void connman_ipconfig_set_data(struct connman_ipconfig *ipconfig, void *data) +void __connman_ipconfig_set_data(struct connman_ipconfig *ipconfig, void *data) { ipconfig->ops_data = data; } @@ -841,43 +1341,22 @@ void connman_ipconfig_set_data(struct connman_ipconfig *ipconfig, void *data) * * Get interface index */ -int connman_ipconfig_get_index(struct connman_ipconfig *ipconfig) +int __connman_ipconfig_get_index(struct connman_ipconfig *ipconfig) { - if (ipconfig->origin != NULL) - return ipconfig->origin->index; + if (!ipconfig) + return -1; return ipconfig->index; } /** - * connman_ipconfig_get_ifname: - * @ipconfig: ipconfig structure - * - * Get interface name - */ -const char *connman_ipconfig_get_ifname(struct connman_ipconfig *ipconfig) -{ - struct connman_ipdevice *ipdevice; - - if (ipconfig->index < 0) - return NULL; - - ipdevice = g_hash_table_lookup(ipdevice_hash, - GINT_TO_POINTER(ipconfig->index)); - if (ipdevice == NULL) - return NULL; - - return ipdevice->ifname; -} - -/** * connman_ipconfig_set_ops: * @ipconfig: ipconfig structure * @ops: operation callbacks * * Set the operation callbacks */ -void connman_ipconfig_set_ops(struct connman_ipconfig *ipconfig, +void __connman_ipconfig_set_ops(struct connman_ipconfig *ipconfig, const struct connman_ipconfig_ops *ops) { ipconfig->ops = ops; @@ -890,7 +1369,7 @@ void connman_ipconfig_set_ops(struct connman_ipconfig *ipconfig, * * Set the configuration method */ -int connman_ipconfig_set_method(struct connman_ipconfig *ipconfig, +int __connman_ipconfig_set_method(struct connman_ipconfig *ipconfig, enum connman_ipconfig_method method) { ipconfig->method = method; @@ -901,101 +1380,319 @@ int connman_ipconfig_set_method(struct connman_ipconfig *ipconfig, enum connman_ipconfig_method __connman_ipconfig_get_method( struct connman_ipconfig *ipconfig) { - if (ipconfig == NULL) + if (!ipconfig) return CONNMAN_IPCONFIG_METHOD_UNKNOWN; return ipconfig->method; } -/** - * connman_ipconfig_bind: - * @ipconfig: ipconfig structure - * @ipaddress: ipaddress structure - * - * Bind IP address details to configuration - */ -void connman_ipconfig_bind(struct connman_ipconfig *ipconfig, - struct connman_ipaddress *ipaddress) +int __connman_ipconfig_address_add(struct connman_ipconfig *ipconfig) +{ + switch (ipconfig->method) { + case CONNMAN_IPCONFIG_METHOD_UNKNOWN: + case CONNMAN_IPCONFIG_METHOD_OFF: + break; + case CONNMAN_IPCONFIG_METHOD_AUTO: + case CONNMAN_IPCONFIG_METHOD_FIXED: + case CONNMAN_IPCONFIG_METHOD_DHCP: + case CONNMAN_IPCONFIG_METHOD_MANUAL: + if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4) + return connman_inet_set_address(ipconfig->index, + ipconfig->address); + else if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6) + return connman_inet_set_ipv6_address( + ipconfig->index, ipconfig->address); + } + + return 0; +} + +int __connman_ipconfig_address_remove(struct connman_ipconfig *ipconfig) { - struct connman_ipconfig *origin; + int err; - origin = ipconfig->origin ? ipconfig->origin : ipconfig; + if (!ipconfig) + return 0; - connman_ipaddress_copy(origin->address, ipaddress); + switch (ipconfig->method) { + case CONNMAN_IPCONFIG_METHOD_UNKNOWN: + case CONNMAN_IPCONFIG_METHOD_OFF: + break; + case CONNMAN_IPCONFIG_METHOD_AUTO: + case CONNMAN_IPCONFIG_METHOD_DHCP: + err = __connman_ipconfig_address_unset(ipconfig); + connman_ipaddress_clear(ipconfig->address); - connman_inet_set_address(origin->index, origin->address); + return err; + case CONNMAN_IPCONFIG_METHOD_FIXED: + case CONNMAN_IPCONFIG_METHOD_MANUAL: + return __connman_ipconfig_address_unset(ipconfig); + } + + return 0; } -int __connman_ipconfig_set_address(struct connman_ipconfig *ipconfig) +int __connman_ipconfig_address_unset(struct connman_ipconfig *ipconfig) { - DBG(""); + int err; + + if (!ipconfig) + return 0; switch (ipconfig->method) { case CONNMAN_IPCONFIG_METHOD_UNKNOWN: case CONNMAN_IPCONFIG_METHOD_OFF: + break; + case CONNMAN_IPCONFIG_METHOD_AUTO: case CONNMAN_IPCONFIG_METHOD_FIXED: case CONNMAN_IPCONFIG_METHOD_DHCP: - break; case CONNMAN_IPCONFIG_METHOD_MANUAL: - return connman_inet_set_address(ipconfig->index, - ipconfig->address); + if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4) + err = connman_inet_clear_address(ipconfig->index, + ipconfig->address); + else if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6) + err = connman_inet_clear_ipv6_address( + ipconfig->index, + ipconfig->address->local, + ipconfig->address->prefixlen); + else + err = -EINVAL; + + return err; } return 0; } -int __connman_ipconfig_clear_address(struct connman_ipconfig *ipconfig) +int __connman_ipconfig_set_proxy_autoconfig(struct connman_ipconfig *ipconfig, + const char *url) { + struct connman_ipdevice *ipdevice; + + if (!ipconfig || ipconfig->index < 0) + return -ENODEV; + + ipdevice = g_hash_table_lookup(ipdevice_hash, + GINT_TO_POINTER(ipconfig->index)); + if (!ipdevice) + return -ENXIO; + + g_free(ipdevice->pac); + ipdevice->pac = g_strdup(url); + + return 0; +} + +const char *__connman_ipconfig_get_proxy_autoconfig(struct connman_ipconfig *ipconfig) +{ + struct connman_ipdevice *ipdevice; + + if (!ipconfig || ipconfig->index < 0) + return NULL; + + ipdevice = g_hash_table_lookup(ipdevice_hash, + GINT_TO_POINTER(ipconfig->index)); + if (!ipdevice) + return NULL; + + return ipdevice->pac; +} + +void __connman_ipconfig_set_dhcp_address(struct connman_ipconfig *ipconfig, + const char *address) +{ + if (!ipconfig) + return; + + g_free(ipconfig->last_dhcp_address); + ipconfig->last_dhcp_address = g_strdup(address); +} + +char *__connman_ipconfig_get_dhcp_address(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig) + return NULL; + + return ipconfig->last_dhcp_address; +} + +void __connman_ipconfig_set_dhcpv6_prefixes(struct connman_ipconfig *ipconfig, + char **prefixes) +{ + if (!ipconfig) + return; + + g_strfreev(ipconfig->last_dhcpv6_prefixes); + ipconfig->last_dhcpv6_prefixes = prefixes; +} + +char **__connman_ipconfig_get_dhcpv6_prefixes(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig) + return NULL; + + return ipconfig->last_dhcpv6_prefixes; +} + +static void disable_ipv6(struct connman_ipconfig *ipconfig) +{ + struct connman_ipdevice *ipdevice; + char *ifname; + DBG(""); - if (ipconfig == NULL) - return 0; + ipdevice = g_hash_table_lookup(ipdevice_hash, + GINT_TO_POINTER(ipconfig->index)); + if (!ipdevice) + return; + + ifname = connman_inet_ifname(ipconfig->index); + + set_ipv6_state(ifname, false); + + g_free(ifname); +} + +static void enable_ipv6(struct connman_ipconfig *ipconfig) +{ + struct connman_ipdevice *ipdevice; + char *ifname; + + DBG(""); + + ipdevice = g_hash_table_lookup(ipdevice_hash, + GINT_TO_POINTER(ipconfig->index)); + if (!ipdevice) + return; + + ifname = connman_inet_ifname(ipconfig->index); + + if (ipconfig->method == CONNMAN_IPCONFIG_METHOD_AUTO) + set_ipv6_privacy(ifname, ipconfig->ipv6_privacy_config); + + set_ipv6_state(ifname, true); + + g_free(ifname); +} + +void __connman_ipconfig_enable_ipv6(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig || ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV6) + return; + + enable_ipv6(ipconfig); +} + +void __connman_ipconfig_disable_ipv6(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig || ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV6) + return; + + disable_ipv6(ipconfig); +} - DBG("method %d", ipconfig->method); +bool __connman_ipconfig_is_usable(struct connman_ipconfig *ipconfig) +{ + if (!ipconfig) + return false; switch (ipconfig->method) { case CONNMAN_IPCONFIG_METHOD_UNKNOWN: case CONNMAN_IPCONFIG_METHOD_OFF: + return false; + case CONNMAN_IPCONFIG_METHOD_AUTO: case CONNMAN_IPCONFIG_METHOD_FIXED: case CONNMAN_IPCONFIG_METHOD_DHCP: - break; case CONNMAN_IPCONFIG_METHOD_MANUAL: - return connman_inet_clear_address(ipconfig->index); + break; } - return 0; - + return true; } int __connman_ipconfig_enable(struct connman_ipconfig *ipconfig) { struct connman_ipdevice *ipdevice; + bool up = false, down = false; + bool lower_up = false, lower_down = false; + enum connman_ipconfig_type type; + char *ifname; DBG("ipconfig %p", ipconfig); - if (ipconfig == NULL || ipconfig->index < 0) + if (!ipconfig || ipconfig->index < 0) return -ENODEV; ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(ipconfig->index)); - if (ipdevice == NULL) + if (!ipdevice) return -ENXIO; - if (ipdevice->config == ipconfig) - return -EALREADY; + if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4) { + if (ipdevice->config_ipv4 == ipconfig) + return -EALREADY; + type = CONNMAN_IPCONFIG_TYPE_IPV4; + } else if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6) { + if (ipdevice->config_ipv6 == ipconfig) + return -EALREADY; + type = CONNMAN_IPCONFIG_TYPE_IPV6; + } else + return -EINVAL; - if (ipdevice->config != NULL) { - ipconfig_list = g_list_remove(ipconfig_list, ipconfig); + if (type == CONNMAN_IPCONFIG_TYPE_IPV4 && + ipdevice->config_ipv4) { + ipconfig_list = g_list_remove(ipconfig_list, + ipdevice->config_ipv4); + + connman_ipaddress_clear(ipdevice->config_ipv4->system); + + __connman_ipconfig_unref(ipdevice->config_ipv4); + } + + if (type == CONNMAN_IPCONFIG_TYPE_IPV6 && + ipdevice->config_ipv6) { + ipconfig_list = g_list_remove(ipconfig_list, + ipdevice->config_ipv6); - connman_ipaddress_clear(ipdevice->config->system); + connman_ipaddress_clear(ipdevice->config_ipv6->system); - connman_ipconfig_unref(ipdevice->config); + __connman_ipconfig_unref(ipdevice->config_ipv6); } - ipdevice->config = connman_ipconfig_ref(ipconfig); + if (type == CONNMAN_IPCONFIG_TYPE_IPV4) + ipdevice->config_ipv4 = __connman_ipconfig_ref(ipconfig); + else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) { + ipdevice->config_ipv6 = __connman_ipconfig_ref(ipconfig); + enable_ipv6(ipdevice->config_ipv6); + } ipconfig_list = g_list_append(ipconfig_list, ipconfig); + if (ipdevice->flags & IFF_UP) + up = true; + else + down = true; + + if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) == + (IFF_RUNNING | IFF_LOWER_UP)) + lower_up = true; + else if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) == 0) + lower_down = true; + + ifname = connman_inet_ifname(ipconfig->index); + + if (up && ipconfig->ops->up) + ipconfig->ops->up(ipconfig, ifname); + if (lower_up && ipconfig->ops->lower_up) + ipconfig->ops->lower_up(ipconfig, ifname); + + if (lower_down && ipconfig->ops->lower_down) + ipconfig->ops->lower_down(ipconfig, ifname); + if (down && ipconfig->ops->down) + ipconfig->ops->down(ipconfig, ifname); + + g_free(ifname); + return 0; } @@ -1005,25 +1702,36 @@ int __connman_ipconfig_disable(struct connman_ipconfig *ipconfig) DBG("ipconfig %p", ipconfig); - if (ipconfig == NULL || ipconfig->index < 0) + if (!ipconfig || ipconfig->index < 0) return -ENODEV; ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(ipconfig->index)); - if (ipdevice == NULL) + if (!ipdevice) return -ENXIO; - if (ipdevice->config == NULL || ipdevice->config != ipconfig) + if (!ipdevice->config_ipv4 && !ipdevice->config_ipv6) return -EINVAL; - ipconfig_list = g_list_remove(ipconfig_list, ipconfig); + if (ipdevice->config_ipv4 == ipconfig) { + ipconfig_list = g_list_remove(ipconfig_list, ipconfig); - connman_ipaddress_clear(ipdevice->config->system); + connman_ipaddress_clear(ipdevice->config_ipv4->system); + __connman_ipconfig_unref(ipdevice->config_ipv4); + ipdevice->config_ipv4 = NULL; + return 0; + } - connman_ipconfig_unref(ipdevice->config); - ipdevice->config = NULL; + if (ipdevice->config_ipv6 == ipconfig) { + ipconfig_list = g_list_remove(ipconfig_list, ipconfig); - return 0; + connman_ipaddress_clear(ipdevice->config_ipv6->system); + __connman_ipconfig_unref(ipdevice->config_ipv6); + ipdevice->config_ipv6 = NULL; + return 0; + } + + return -EINVAL; } const char *__connman_ipconfig_method2string(enum connman_ipconfig_method method) @@ -1039,6 +1747,8 @@ const char *__connman_ipconfig_method2string(enum connman_ipconfig_method method return "manual"; case CONNMAN_IPCONFIG_METHOD_DHCP: return "dhcp"; + case CONNMAN_IPCONFIG_METHOD_AUTO: + return "auto"; } return NULL; @@ -1054,38 +1764,224 @@ enum connman_ipconfig_method __connman_ipconfig_string2method(const char *method return CONNMAN_IPCONFIG_METHOD_MANUAL; else if (g_strcmp0(method, "dhcp") == 0) return CONNMAN_IPCONFIG_METHOD_DHCP; + else if (g_strcmp0(method, "auto") == 0) + return CONNMAN_IPCONFIG_METHOD_AUTO; else return CONNMAN_IPCONFIG_METHOD_UNKNOWN; } +static const char *privacy2string(int privacy) +{ + if (privacy <= 0) + return "disabled"; + else if (privacy == 1) + return "enabled"; + else + return "prefered"; +} + +static int string2privacy(const char *privacy) +{ + if (g_strcmp0(privacy, "disabled") == 0) + return 0; + else if (g_strcmp0(privacy, "enabled") == 0) + return 1; + else if (g_strcmp0(privacy, "preferred") == 0) + return 2; + else if (g_strcmp0(privacy, "prefered") == 0) + return 2; + else + return 0; +} + +int __connman_ipconfig_ipv6_reset_privacy(struct connman_ipconfig *ipconfig) +{ + struct connman_ipdevice *ipdevice; + int err; + + if (!ipconfig) + return -EINVAL; + + ipdevice = g_hash_table_lookup(ipdevice_hash, + GINT_TO_POINTER(ipconfig->index)); + if (!ipdevice) + return -ENODEV; + + err = __connman_ipconfig_ipv6_set_privacy(ipconfig, privacy2string( + ipdevice->ipv6_privacy)); + + return err; +} + +int __connman_ipconfig_ipv6_set_privacy(struct connman_ipconfig *ipconfig, + const char *value) +{ + int privacy; + + if (!ipconfig) + return -EINVAL; + + privacy = string2privacy(value); + + ipconfig->ipv6_privacy_config = privacy; + + enable_ipv6(ipconfig); + + return 0; +} + void __connman_ipconfig_append_ipv4(struct connman_ipconfig *ipconfig, DBusMessageIter *iter) { + struct connman_ipaddress *append_addr = NULL; const char *str; + if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV4) + return; + str = __connman_ipconfig_method2string(ipconfig->method); - if (str == NULL) + if (!str) return; connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str); - if (ipconfig->system == NULL) + switch (ipconfig->method) { + case CONNMAN_IPCONFIG_METHOD_UNKNOWN: + case CONNMAN_IPCONFIG_METHOD_OFF: + return; + + case CONNMAN_IPCONFIG_METHOD_FIXED: + append_addr = ipconfig->address; + break; + + case CONNMAN_IPCONFIG_METHOD_AUTO: + case CONNMAN_IPCONFIG_METHOD_MANUAL: + case CONNMAN_IPCONFIG_METHOD_DHCP: + append_addr = ipconfig->system; + break; + } + + if (!append_addr) return; - if (ipconfig->system->local != NULL) { + if (append_addr->local) { in_addr_t addr; struct in_addr netmask; char *mask; connman_dbus_dict_append_basic(iter, "Address", - DBUS_TYPE_STRING, &ipconfig->system->local); + DBUS_TYPE_STRING, &append_addr->local); - addr = 0xffffffff << (32 - ipconfig->system->prefixlen); + addr = 0xffffffff << (32 - append_addr->prefixlen); netmask.s_addr = htonl(addr); mask = inet_ntoa(netmask); connman_dbus_dict_append_basic(iter, "Netmask", DBUS_TYPE_STRING, &mask); } + + if (append_addr->gateway) + connman_dbus_dict_append_basic(iter, "Gateway", + DBUS_TYPE_STRING, &append_addr->gateway); +} + +void __connman_ipconfig_append_ipv6(struct connman_ipconfig *ipconfig, + DBusMessageIter *iter, + struct connman_ipconfig *ipconfig_ipv4) +{ + struct connman_ipaddress *append_addr = NULL; + const char *str, *privacy; + + if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV6) + return; + + str = __connman_ipconfig_method2string(ipconfig->method); + if (!str) + return; + + if (ipconfig_ipv4 && + ipconfig->method == CONNMAN_IPCONFIG_METHOD_AUTO) { + if (__connman_6to4_check(ipconfig_ipv4) == 1) + str = "6to4"; + } + + connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str); + + switch (ipconfig->method) { + case CONNMAN_IPCONFIG_METHOD_UNKNOWN: + case CONNMAN_IPCONFIG_METHOD_OFF: + return; + + case CONNMAN_IPCONFIG_METHOD_FIXED: + append_addr = ipconfig->address; + break; + + case CONNMAN_IPCONFIG_METHOD_MANUAL: + case CONNMAN_IPCONFIG_METHOD_DHCP: + case CONNMAN_IPCONFIG_METHOD_AUTO: + append_addr = ipconfig->system; + break; + } + + if (!append_addr) + return; + + if (append_addr->local) { + connman_dbus_dict_append_basic(iter, "Address", + DBUS_TYPE_STRING, &append_addr->local); + connman_dbus_dict_append_basic(iter, "PrefixLength", + DBUS_TYPE_BYTE, + &append_addr->prefixlen); + } + + if (append_addr->gateway) + connman_dbus_dict_append_basic(iter, "Gateway", + DBUS_TYPE_STRING, &append_addr->gateway); + + privacy = privacy2string(ipconfig->ipv6_privacy_config); + connman_dbus_dict_append_basic(iter, "Privacy", + DBUS_TYPE_STRING, &privacy); +} + +void __connman_ipconfig_append_ipv6config(struct connman_ipconfig *ipconfig, + DBusMessageIter *iter) +{ + const char *str, *privacy; + + str = __connman_ipconfig_method2string(ipconfig->method); + if (!str) + return; + + connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str); + + switch (ipconfig->method) { + case CONNMAN_IPCONFIG_METHOD_UNKNOWN: + case CONNMAN_IPCONFIG_METHOD_OFF: + case CONNMAN_IPCONFIG_METHOD_DHCP: + return; + case CONNMAN_IPCONFIG_METHOD_FIXED: + case CONNMAN_IPCONFIG_METHOD_MANUAL: + case CONNMAN_IPCONFIG_METHOD_AUTO: + break; + } + + if (!ipconfig->address) + return; + + if (ipconfig->address->local) { + connman_dbus_dict_append_basic(iter, "Address", + DBUS_TYPE_STRING, &ipconfig->address->local); + connman_dbus_dict_append_basic(iter, "PrefixLength", + DBUS_TYPE_BYTE, + &ipconfig->address->prefixlen); + } + + if (ipconfig->address->gateway) + connman_dbus_dict_append_basic(iter, "Gateway", + DBUS_TYPE_STRING, &ipconfig->address->gateway); + + privacy = privacy2string(ipconfig->ipv6_privacy_config); + connman_dbus_dict_append_basic(iter, "Privacy", + DBUS_TYPE_STRING, &privacy); } void __connman_ipconfig_append_ipv4config(struct connman_ipconfig *ipconfig, @@ -1094,7 +1990,7 @@ void __connman_ipconfig_append_ipv4config(struct connman_ipconfig *ipconfig, const char *str; str = __connman_ipconfig_method2string(ipconfig->method); - if (str == NULL) + if (!str) return; connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str); @@ -1102,17 +1998,18 @@ void __connman_ipconfig_append_ipv4config(struct connman_ipconfig *ipconfig, switch (ipconfig->method) { case CONNMAN_IPCONFIG_METHOD_UNKNOWN: case CONNMAN_IPCONFIG_METHOD_OFF: - case CONNMAN_IPCONFIG_METHOD_FIXED: case CONNMAN_IPCONFIG_METHOD_DHCP: + case CONNMAN_IPCONFIG_METHOD_AUTO: return; + case CONNMAN_IPCONFIG_METHOD_FIXED: case CONNMAN_IPCONFIG_METHOD_MANUAL: break; } - if (ipconfig->address == NULL) + if (!ipconfig->address) return; - if (ipconfig->address->local != NULL) { + if (ipconfig->address->local) { in_addr_t addr; struct in_addr netmask; char *mask; @@ -1126,16 +2023,21 @@ void __connman_ipconfig_append_ipv4config(struct connman_ipconfig *ipconfig, connman_dbus_dict_append_basic(iter, "Netmask", DBUS_TYPE_STRING, &mask); } + + if (ipconfig->address->gateway) + connman_dbus_dict_append_basic(iter, "Gateway", + DBUS_TYPE_STRING, &ipconfig->address->gateway); } -int __connman_ipconfig_set_ipv4config(struct connman_ipconfig *ipconfig, +int __connman_ipconfig_set_config(struct connman_ipconfig *ipconfig, DBusMessageIter *array) { enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN; - const char *address = NULL, *netmask = NULL, *gateway = NULL; + const char *address = NULL, *netmask = NULL, *gateway = NULL, + *privacy_string = NULL; + int prefix_length = 0, privacy = 0; DBusMessageIter dict; - - DBG("ipconfig %p", ipconfig); + int type = -1; if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY) return -EINVAL; @@ -1143,7 +2045,7 @@ int __connman_ipconfig_set_ipv4config(struct connman_ipconfig *ipconfig, dbus_message_iter_recurse(array, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { - DBusMessageIter entry; + DBusMessageIter entry, value; const char *key; int type; @@ -1155,56 +2057,119 @@ int __connman_ipconfig_set_ipv4config(struct connman_ipconfig *ipconfig, dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); - type = dbus_message_iter_get_arg_type(&entry); + if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) + return -EINVAL; - if (g_str_equal(key, "Method") == TRUE) { + dbus_message_iter_recurse(&entry, &value); + + type = dbus_message_iter_get_arg_type(&value); + + if (g_str_equal(key, "Method")) { const char *str; if (type != DBUS_TYPE_STRING) return -EINVAL; - dbus_message_iter_get_basic(&entry, &str); + dbus_message_iter_get_basic(&value, &str); method = __connman_ipconfig_string2method(str); - } else if (g_str_equal(key, "Address") == TRUE) { + } else if (g_str_equal(key, "Address")) { if (type != DBUS_TYPE_STRING) return -EINVAL; - dbus_message_iter_get_basic(&entry, &address); - } else if (g_str_equal(key, "Netmask") == TRUE) { + dbus_message_iter_get_basic(&value, &address); + } else if (g_str_equal(key, "PrefixLength")) { + if (type != DBUS_TYPE_BYTE) + return -EINVAL; + + dbus_message_iter_get_basic(&value, &prefix_length); + + if (prefix_length < 0 || prefix_length > 128) + return -EINVAL; + } else if (g_str_equal(key, "Netmask")) { + if (type != DBUS_TYPE_STRING) + return -EINVAL; + + dbus_message_iter_get_basic(&value, &netmask); + } else if (g_str_equal(key, "Gateway")) { if (type != DBUS_TYPE_STRING) return -EINVAL; - dbus_message_iter_get_basic(&entry, &netmask); - } else if (g_str_equal(key, "Gateway") == TRUE) { + dbus_message_iter_get_basic(&value, &gateway); + } else if (g_str_equal(key, "Privacy")) { if (type != DBUS_TYPE_STRING) return -EINVAL; - dbus_message_iter_get_basic(&entry, &gateway); + dbus_message_iter_get_basic(&value, &privacy_string); + privacy = string2privacy(privacy_string); } + dbus_message_iter_next(&dict); } - DBG("method %d address %s netmask %s gateway %s", - method, address, netmask, gateway); + DBG("method %d address %s netmask %s gateway %s prefix_length %d " + "privacy %s", + method, address, netmask, gateway, prefix_length, + privacy_string); switch (method) { case CONNMAN_IPCONFIG_METHOD_UNKNOWN: - case CONNMAN_IPCONFIG_METHOD_OFF: case CONNMAN_IPCONFIG_METHOD_FIXED: return -EINVAL; + case CONNMAN_IPCONFIG_METHOD_OFF: + ipconfig->method = method; + + break; + + case CONNMAN_IPCONFIG_METHOD_AUTO: + if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV6) + return -EOPNOTSUPP; + + ipconfig->method = method; + if (privacy_string) + ipconfig->ipv6_privacy_config = privacy; + + break; + case CONNMAN_IPCONFIG_METHOD_MANUAL: - if (address == NULL) + switch (ipconfig->type) { + case CONNMAN_IPCONFIG_TYPE_IPV4: + type = AF_INET; + break; + case CONNMAN_IPCONFIG_TYPE_IPV6: + type = AF_INET6; + break; + case CONNMAN_IPCONFIG_TYPE_UNKNOWN: + case CONNMAN_IPCONFIG_TYPE_ALL: + type = -1; + break; + } + + if ((address && connman_inet_check_ipaddress(address) + != type) || + (netmask && + connman_inet_check_ipaddress(netmask) + != type) || + (gateway && + connman_inet_check_ipaddress(gateway) + != type)) return -EINVAL; ipconfig->method = method; - connman_ipaddress_set(ipconfig->address, - address, netmask, gateway); + + if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4) + connman_ipaddress_set_ipv4(ipconfig->address, + address, netmask, gateway); + else + return connman_ipaddress_set_ipv6( + ipconfig->address, address, + prefix_length, gateway); + break; case CONNMAN_IPCONFIG_METHOD_DHCP: - if (ipconfig->method == method) - return 0; + if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV4) + return -EOPNOTSUPP; ipconfig->method = method; break; @@ -1213,15 +2178,6 @@ int __connman_ipconfig_set_ipv4config(struct connman_ipconfig *ipconfig, return 0; } -void __connman_ipconfig_append_proxy(struct connman_ipconfig *ipconfig, - DBusMessageIter *iter) -{ - const char *method = "direct"; - - connman_dbus_dict_append_basic(iter, "Method", - DBUS_TYPE_STRING, &method); -} - void __connman_ipconfig_append_ethernet(struct connman_ipconfig *ipconfig, DBusMessageIter *iter) { @@ -1233,14 +2189,19 @@ void __connman_ipconfig_append_ethernet(struct connman_ipconfig *ipconfig, ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(ipconfig->index)); - if (ipdevice == NULL) + if (!ipdevice) return; - if (ipdevice->ifname != NULL) - connman_dbus_dict_append_basic(iter, "Interface", - DBUS_TYPE_STRING, &ipdevice->ifname); + if (ipconfig->index >= 0) { + char *ifname = connman_inet_ifname(ipconfig->index); + if (ifname) { + connman_dbus_dict_append_basic(iter, "Interface", + DBUS_TYPE_STRING, &ifname); + g_free(ifname); + } + } - if (ipdevice->address != NULL) + if (ipdevice->address) connman_dbus_dict_append_basic(iter, "Address", DBUS_TYPE_STRING, &ipdevice->address); @@ -1249,94 +2210,153 @@ void __connman_ipconfig_append_ethernet(struct connman_ipconfig *ipconfig, DBUS_TYPE_UINT16, &ipdevice->mtu); } -int __connman_ipconfig_load(struct connman_ipconfig *ipconfig, +void __connman_ipconfig_load(struct connman_ipconfig *ipconfig, GKeyFile *keyfile, const char *identifier, const char *prefix) { - const char *method; - char *key; + char *method; + char *str; + struct ipconfig_store is = { .file = keyfile, + .group = identifier, + .prefix = prefix }; DBG("ipconfig %p identifier %s", ipconfig, identifier); - key = g_strdup_printf("%smethod", prefix); - method = g_key_file_get_string(keyfile, identifier, key, NULL); - if (method == NULL) - ipconfig->method = CONNMAN_IPCONFIG_METHOD_DHCP; - else + method = store_get_str(&is, "method"); + if (!method) { + switch (ipconfig->type) { + case CONNMAN_IPCONFIG_TYPE_IPV4: + ipconfig->method = CONNMAN_IPCONFIG_METHOD_DHCP; + break; + + case CONNMAN_IPCONFIG_TYPE_IPV6: + ipconfig->method = CONNMAN_IPCONFIG_METHOD_AUTO; + break; + + case CONNMAN_IPCONFIG_TYPE_UNKNOWN: + case CONNMAN_IPCONFIG_TYPE_ALL: + ipconfig->method = CONNMAN_IPCONFIG_METHOD_OFF; + break; + } + } else { ipconfig->method = __connman_ipconfig_string2method(method); - g_free(key); + g_free(method); + } - key = g_strdup_printf("%snetmask_prefixlen", prefix); - ipconfig->address->prefixlen = g_key_file_get_integer( - keyfile, identifier, key, NULL); - g_free(key); + if (ipconfig->method == CONNMAN_IPCONFIG_METHOD_UNKNOWN) + ipconfig->method = CONNMAN_IPCONFIG_METHOD_OFF; - key = g_strdup_printf("%slocal_address", prefix); - ipconfig->address->local = g_key_file_get_string( - keyfile, identifier, key, NULL); - g_free(key); + if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6) { + if (ipconfig->method == CONNMAN_IPCONFIG_METHOD_AUTO || + ipconfig->method == CONNMAN_IPCONFIG_METHOD_MANUAL) { + char *privacy; - key = g_strdup_printf("%speer_address", prefix); - ipconfig->address->peer = g_key_file_get_string( - keyfile, identifier, key, NULL); - g_free(key); + privacy = store_get_str(&is, "privacy"); + ipconfig->ipv6_privacy_config = string2privacy(privacy); + g_free(privacy); + } - key = g_strdup_printf("%sbroadcast_address", prefix); - ipconfig->address->broadcast = g_key_file_get_string( - keyfile, identifier, key, NULL); - g_free(key); + g_strfreev(ipconfig->last_dhcpv6_prefixes); + ipconfig->last_dhcpv6_prefixes = + store_get_strs(&is, "DHCP.LastPrefixes"); + } - key = g_strdup_printf("%sgateway", prefix); - ipconfig->address->gateway = g_key_file_get_string( - keyfile, identifier, key, NULL); - g_free(key); - return 0; + switch (ipconfig->method) { + case CONNMAN_IPCONFIG_METHOD_UNKNOWN: + case CONNMAN_IPCONFIG_METHOD_OFF: + break; + + case CONNMAN_IPCONFIG_METHOD_FIXED: + case CONNMAN_IPCONFIG_METHOD_MANUAL: + ipconfig->address->prefixlen = + store_get_int(&is, "netmask_prefixlen"); + + g_free(ipconfig->address->local); + ipconfig->address->local = + store_get_str(&is, "local_address"); + + g_free(ipconfig->address->peer); + ipconfig->address->peer = + store_get_str(&is, "peer_address"); + + g_free(ipconfig->address->broadcast); + ipconfig->address->broadcast = + store_get_str(&is, "broadcast_address"); + + g_free(ipconfig->address->gateway); + ipconfig->address->gateway = + store_get_str(&is, "gateway"); + break; + + case CONNMAN_IPCONFIG_METHOD_AUTO: + if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV4) + break; + + /* + * If the last used method for IPv4 was AUTO then we + * try first DHCP. We will try also to use the last + * used DHCP address, if exits. + */ + __connman_ipconfig_set_method(ipconfig, + CONNMAN_IPCONFIG_METHOD_DHCP); + /* fall through */ + + case CONNMAN_IPCONFIG_METHOD_DHCP: + str = store_get_str(&is, "DHCP.LastAddress"); + if (str) { + g_free(ipconfig->last_dhcp_address); + ipconfig->last_dhcp_address = str; + } + + break; + } } -int __connman_ipconfig_save(struct connman_ipconfig *ipconfig, +void __connman_ipconfig_save(struct connman_ipconfig *ipconfig, GKeyFile *keyfile, const char *identifier, const char *prefix) { const char *method; - char *key; - - DBG("ipconfig %p identifier %s", ipconfig, identifier); + struct ipconfig_store is = { .file = keyfile, + .group = identifier, + .prefix = prefix }; method = __connman_ipconfig_method2string(ipconfig->method); + DBG("ipconfig %p identifier %s method %s", ipconfig, identifier, + method); + store_set_str(&is, "method", method); - key = g_strdup_printf("%smethod", prefix); - g_key_file_set_string(keyfile, identifier, key, method); - g_free(key); - - key = g_strdup_printf("%snetmask_prefixlen", prefix); - g_key_file_set_integer(keyfile, identifier, - key, ipconfig->address->prefixlen); - g_free(key); - - key = g_strdup_printf("%slocal_address", prefix); - if (ipconfig->address->local != NULL) - g_key_file_set_string(keyfile, identifier, - key, ipconfig->address->local); - g_free(key); - - key = g_strdup_printf("%speer_address", prefix); - if (ipconfig->address->peer != NULL) - g_key_file_set_string(keyfile, identifier, - key, ipconfig->address->peer); - g_free(key); - - key = g_strdup_printf("%sbroadcast_address", prefix); - if (ipconfig->address->broadcast != NULL) - g_key_file_set_string(keyfile, identifier, - key, ipconfig->address->broadcast); - g_free(key); - - key = g_strdup_printf("%sgateway", prefix); - if (ipconfig->address->gateway != NULL) - g_key_file_set_string(keyfile, identifier, - key, ipconfig->address->gateway); - g_free(key); + if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6) { + store_set_str(&is, "privacy", + privacy2string(ipconfig->ipv6_privacy_config)); - return 0; + store_set_str(&is, "DHCP.LastAddress", + ipconfig->last_dhcp_address); + + store_set_strs(&is, "DHCP.LastPrefixes", + ipconfig->last_dhcpv6_prefixes); + } + + switch (ipconfig->method) { + case CONNMAN_IPCONFIG_METHOD_FIXED: + case CONNMAN_IPCONFIG_METHOD_MANUAL: + break; + + case CONNMAN_IPCONFIG_METHOD_DHCP: + store_set_str(&is, "DHCP.LastAddress", + ipconfig->last_dhcp_address); + /* fall through */ + + case CONNMAN_IPCONFIG_METHOD_UNKNOWN: + case CONNMAN_IPCONFIG_METHOD_OFF: + case CONNMAN_IPCONFIG_METHOD_AUTO: + return; + } + + store_set_int(&is, "netmask_prefixlen", ipconfig->address->prefixlen); + store_set_str(&is, "local_address", ipconfig->address->local); + store_set_str(&is, "peer_address", ipconfig->address->peer); + store_set_str(&is, "broadcast_address", ipconfig->address->broadcast); + store_set_str(&is, "gateway", ipconfig->address->gateway); } int __connman_ipconfig_init(void) @@ -1346,6 +2366,8 @@ int __connman_ipconfig_init(void) ipdevice_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, free_ipdevice); + is_ipv6_supported = connman_inet_is_ipv6_supported(); + return 0; }