We want to use the utils code for our tools. Because the utils code only uses parts of the logger we need to make sure a __debug section always exists otherwise we get an linker error, e.g. "undefined reference to `__stop___debug'". Currently, the __debug section is only added by using DBG(). By adding a dummy entry we make sure to have always a __debug section. --- Hi Christian, With this change we can drop the tools changes in the first patch of your series. I'll update your patch, so no need to resend. Thanks, Daniel src/log.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/log.c b/src/log.c index 9bae4a3d63a3..5deaff83f2a3 100644 --- a/src/log.c +++ b/src/log.c @@ -37,6 +37,9 @@ static const char *program_exec; static const char *program_path; +/* This makes sure we always have a __debug section. */ +CONNMAN_DEBUG_DEFINE(dummy); + /** * connman_info: * @format: format string -- 2.14.3

In gdhcp replace usage of local functions for random number generation by functions in src/util.c. So dhcp_get_random() and dhcp_cleanup_random() are removed. --- Makefile.am | 4 ---- gdhcp/client.c | 8 ++++---- gdhcp/common.c | 39 ++------------------------------------- gdhcp/gdhcp.h | 3 --- gdhcp/ipv4ll.c | 3 ++- src/dhcp.c | 2 -- 6 files changed, 8 insertions(+), 51 deletions(-) diff --git a/Makefile.am b/Makefile.am index edd1969..dcd803b 100644 --- a/Makefile.am +++ b/Makefile.am @@ -32,10 +32,6 @@ gdbus_libgdbus_internal_la_SOURCES = gdbus/gdbus.h \ gdbus/mainloop.c gdbus/watch.c \ gdbus/object.c gdbus/client.c gdbus/polkit.c -if BACKTRACE -backtrace_sources = src/backtrace.c -endif - gdhcp_sources = gdhcp/gdhcp.h gdhcp/common.h gdhcp/common.c gdhcp/client.c \ gdhcp/server.c gdhcp/ipv4ll.h gdhcp/ipv4ll.c gdhcp/unaligned.h diff --git a/gdhcp/client.c b/gdhcp/client.c index 1f01b57..5f42e39 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -520,7 +520,7 @@ static int send_release(GDHCPClient *dhcp_client, debug(dhcp_client, "sending DHCP release request"); init_packet(dhcp_client, &packet, DHCPRELEASE); - dhcp_get_random(&rand); + __connman_util_get_random(&rand); packet.xid = rand; packet.ciaddr = htonl(ciaddr); @@ -1688,7 +1688,7 @@ static gboolean continue_rebound(gpointer user_data) /*recalculate remaining rebind time*/ dhcp_client->T2 >>= 1; if (dhcp_client->T2 > 60) { - dhcp_get_random(&rand); + __connman_util_get_random(&rand); dhcp_client->t2_timeout = g_timeout_add_full(G_PRIORITY_HIGH, dhcp_client->T2 * 1000 + (rand % 2000) - 1000, @@ -1736,7 +1736,7 @@ static gboolean continue_renew (gpointer user_data) dhcp_client->T1 >>= 1; if (dhcp_client->T1 > 60) { - dhcp_get_random(&rand); + __connman_util_get_random(&rand); dhcp_client->t1_timeout = g_timeout_add_full(G_PRIORITY_HIGH, dhcp_client->T1 * 1000 + (rand % 2000) - 1000, continue_renew, @@ -2830,7 +2830,7 @@ int g_dhcp_client_start(GDHCPClient *dhcp_client, const char *last_address) if (re != 0) return re; - dhcp_get_random(&rand); + __connman_util_get_random(&rand); dhcp_client->xid = rand; dhcp_client->start = time(NULL); } diff --git a/gdhcp/common.c b/gdhcp/common.c index 6f81671..27f14dd 100644 --- a/gdhcp/common.c +++ b/gdhcp/common.c @@ -39,6 +39,7 @@ #include "gdhcp.h" #include "common.h" +#include "../src/connman.h" static const DHCPOption client_options[] = { { OPTION_IP, 0x01 }, /* subnet-mask */ @@ -60,42 +61,6 @@ static const DHCPOption client_options[] = { { OPTION_UNKNOWN, 0x00 }, }; -#define URANDOM "/dev/urandom" -static int random_fd = -1; - -int dhcp_get_random(uint64_t *val) -{ - int r; - - if (random_fd < 0) { - random_fd = open(URANDOM, O_RDONLY); - if (random_fd < 0) { - r = -errno; - *val = random(); - - return r; - } - } - - if (read(random_fd, val, sizeof(uint64_t)) < 0) { - r = -errno; - *val = random(); - - return r; - } - - return 0; -} - -void dhcp_cleanup_random(void) -{ - if (random_fd < 0) - return; - - close(random_fd); - random_fd = -1; -} - GDHCPOptionType dhcp_get_code_type(uint8_t code) { int i; @@ -400,7 +365,7 @@ void dhcpv6_init_header(struct dhcpv6_packet *packet, uint8_t type) packet->message = type; - dhcp_get_random(&rand); + __connman_util_get_random(&rand); id = rand; packet->transaction_id[0] = (id >> 16) & 0xff; diff --git a/gdhcp/gdhcp.h b/gdhcp/gdhcp.h index eaf6a74..1285431 100644 --- a/gdhcp/gdhcp.h +++ b/gdhcp/gdhcp.h @@ -232,9 +232,6 @@ void g_dhcp_server_set_save_lease(GDHCPServer *dhcp_server, void g_dhcp_server_set_lease_added_cb(GDHCPServer *dhcp_server, GDHCPLeaseAddedCb cb); -int dhcp_get_random(uint64_t *val); -void dhcp_cleanup_random(void); - #ifdef __cplusplus } #endif diff --git a/gdhcp/ipv4ll.c b/gdhcp/ipv4ll.c index 82e6c44..2ee58f7 100644 --- a/gdhcp/ipv4ll.c +++ b/gdhcp/ipv4ll.c @@ -36,6 +36,7 @@ #include "ipv4ll.h" #include "common.h" +#include "../src/connman.h" /** * Return a random link local IP (in host byte order) @@ -46,7 +47,7 @@ uint32_t ipv4ll_random_ip(void) uint64_t rand; do { - dhcp_get_random(&rand); + __connman_util_get_random(&rand); tmp = rand; tmp = tmp & IN_CLASSB_HOST; } while (tmp > (IN_CLASSB_HOST - 0x0200)); diff --git a/src/dhcp.c b/src/dhcp.c index 1af1eb5..b57a794 100644 --- a/src/dhcp.c +++ b/src/dhcp.c @@ -761,6 +761,4 @@ void __connman_dhcp_cleanup(void) g_hash_table_destroy(ipconfig_table); ipconfig_table = NULL; - - dhcp_cleanup_random(); } -- 2.7.4

We took the local functions for sending ARP packets in gdhcp and put them into new source files src/shared/arp.[h|c]. This will be helpful for ACD (Address Conflict Detection). --- Makefile.am | 7 ++-- gdhcp/client.c | 7 ++-- gdhcp/ipv4ll.c | 72 ------------------------------------- gdhcp/ipv4ll.h | 17 +-------- src/shared/arp.c | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/shared/arp.h | 42 ++++++++++++++++++++++ 6 files changed, 159 insertions(+), 94 deletions(-) create mode 100644 src/shared/arp.c create mode 100644 src/shared/arp.h diff --git a/Makefile.am b/Makefile.am index dcd803b..e994ab9 100644 --- a/Makefile.am +++ b/Makefile.am @@ -54,7 +54,8 @@ backtrace_sources = src/backtrace.c endif shared_sources = src/shared/util.h src/shared/util.c \ - src/shared/netlink.h src/shared/netlink.c + src/shared/netlink.h src/shared/netlink.c \ + src/shared/arp.h src/shared/arp.c if DATAFILES @@ -356,11 +357,11 @@ tools_wpad_test_LDADD = @GLIB_LIBS@ -lresolv tools_stats_tool_LDADD = @GLIB_LIBS@ tools_dhcp_test_SOURCES = $(backtrace_sources) src/log.c \ - src/util.c $(gdhcp_sources) tools/dhcp-test.c + src/util.c $(gdhcp_sources) tools/dhcp-test.c src/shared/arp.c tools_dhcp_test_LDADD = @GLIB_LIBS@ -ldl tools_dhcp_server_test_SOURCES = $(backtrace_sources) src/log.c src/util.c \ - $(gdhcp_sources) tools/dhcp-server-test.c + $(gdhcp_sources) tools/dhcp-server-test.c src/shared/arp.c tools_dhcp_server_test_LDADD = @GLIB_LIBS@ -ldl tools_dbus_test_SOURCES = tools/dbus-test.c diff --git a/gdhcp/client.c b/gdhcp/client.c index 5f42e39..ac29814 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -44,6 +44,7 @@ #include <glib.h> #include "../src/connman.h" +#include "../src/shared/arp.h" #include "gdhcp.h" #include "common.h" #include "ipv4ll.h" @@ -552,7 +553,7 @@ static gboolean send_probe_packet(gpointer dhcp_data) dhcp_client->state = IPV4LL_PROBE; switch_listening_mode(dhcp_client, L_ARP); } - ipv4ll_send_arp_packet(dhcp_client->mac_address, 0, + arp_send_packet(dhcp_client->mac_address, 0, dhcp_client->requested_ip, dhcp_client->ifindex); if (dhcp_client->retry_times < PROBE_NUM) { @@ -581,7 +582,7 @@ static gboolean send_announce_packet(gpointer dhcp_data) debug(dhcp_client, "sending IPV4LL announce request"); - ipv4ll_send_arp_packet(dhcp_client->mac_address, + arp_send_packet(dhcp_client->mac_address, dhcp_client->requested_ip, dhcp_client->requested_ip, dhcp_client->ifindex); @@ -1568,7 +1569,7 @@ static int switch_listening_mode(GDHCPClient *dhcp_client, dhcp_client->interface, AF_INET); } else if (listen_mode == L_ARP) - listener_sockfd = ipv4ll_arp_socket(dhcp_client->ifindex); + listener_sockfd = arp_socket(dhcp_client->ifindex); else return -EIO; diff --git a/gdhcp/ipv4ll.c b/gdhcp/ipv4ll.c index 2ee58f7..be96f75 100644 --- a/gdhcp/ipv4ll.c +++ b/gdhcp/ipv4ll.c @@ -54,75 +54,3 @@ uint32_t ipv4ll_random_ip(void) return ((LINKLOCAL_ADDR + 0x0100) + tmp); } -int ipv4ll_send_arp_packet(uint8_t* source_eth, uint32_t source_ip, - uint32_t target_ip, int ifindex) -{ - struct sockaddr_ll dest; - struct ether_arp p; - uint32_t ip_source; - uint32_t ip_target; - int fd, n; - - fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, 0); - if (fd < 0) - return -errno; - - memset(&dest, 0, sizeof(dest)); - memset(&p, 0, sizeof(p)); - - dest.sll_family = AF_PACKET; - dest.sll_protocol = htons(ETH_P_ARP); - dest.sll_ifindex = ifindex; - dest.sll_halen = ETH_ALEN; - memset(dest.sll_addr, 0xFF, ETH_ALEN); - if (bind(fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) { - int err = errno; - close(fd); - return -err; - } - - ip_source = htonl(source_ip); - ip_target = htonl(target_ip); - p.arp_hrd = htons(ARPHRD_ETHER); - p.arp_pro = htons(ETHERTYPE_IP); - p.arp_hln = ETH_ALEN; - p.arp_pln = 4; - p.arp_op = htons(ARPOP_REQUEST); - - memcpy(&p.arp_sha, source_eth, ETH_ALEN); - memcpy(&p.arp_spa, &ip_source, sizeof(p.arp_spa)); - memcpy(&p.arp_tpa, &ip_target, sizeof(p.arp_tpa)); - - n = sendto(fd, &p, sizeof(p), 0, - (struct sockaddr*) &dest, sizeof(dest)); - if (n < 0) - n = -errno; - - close(fd); - - return n; -} - -int ipv4ll_arp_socket(int ifindex) -{ - int fd; - struct sockaddr_ll sock; - - fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, 0); - if (fd < 0) - return fd; - - memset(&sock, 0, sizeof(sock)); - - sock.sll_family = AF_PACKET; - sock.sll_protocol = htons(ETH_P_ARP); - sock.sll_ifindex = ifindex; - - if (bind(fd, (struct sockaddr *) &sock, sizeof(sock)) != 0) { - int err = errno; - close(fd); - return -err; - } - - return fd; -} diff --git a/gdhcp/ipv4ll.h b/gdhcp/ipv4ll.h index bf8c363..315ca3d 100644 --- a/gdhcp/ipv4ll.h +++ b/gdhcp/ipv4ll.h @@ -22,7 +22,7 @@ #ifndef __G_IPV4LL_H #define __G_IPV4LL_H -#include <glib.h> +#include <stdint.h> #ifdef __cplusplus extern "C" { @@ -31,22 +31,7 @@ extern "C" { /* 169.254.0.0 */ #define LINKLOCAL_ADDR 0xa9fe0000 -/* See RFC 3927 */ -#define PROBE_WAIT 1 -#define PROBE_NUM 3 -#define PROBE_MIN 1 -#define PROBE_MAX 2 -#define ANNOUNCE_WAIT 2 -#define ANNOUNCE_NUM 2 -#define ANNOUNCE_INTERVAL 2 -#define MAX_CONFLICTS 10 -#define RATE_LIMIT_INTERVAL 60 -#define DEFEND_INTERVAL 10 - uint32_t ipv4ll_random_ip(void); -int ipv4ll_send_arp_packet(uint8_t* source_eth, uint32_t source_ip, - uint32_t target_ip, int ifindex); -int ipv4ll_arp_socket(int ifindex); #ifdef __cplusplus } diff --git a/src/shared/arp.c b/src/shared/arp.c new file mode 100644 index 0000000..02b5003 --- /dev/null +++ b/src/shared/arp.c @@ -0,0 +1,108 @@ +/* + * + * Connection Manager + * + * based on IPv4 Local Link library with GLib integration, + * Copyright (C) 2009-2010 Aldebaran Robotics. All rights reserved. + * + * Copyright (C) 2018 Commend International. 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 + * published by the Free Software Foundation. + * + * 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 <string.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> + +#include <sys/time.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <netpacket/packet.h> +#include <net/ethernet.h> +#include <netinet/if_ether.h> +#include <net/if_arp.h> + +#include <arpa/inet.h> + +#include "src/shared/arp.h" + +int arp_send_packet(uint8_t* source_eth, uint32_t source_ip, + uint32_t target_ip, int ifindex) +{ + struct sockaddr_ll dest; + struct ether_arp p; + uint32_t ip_source; + uint32_t ip_target; + int fd, n; + + fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, 0); + if (fd < 0) + return -errno; + + memset(&dest, 0, sizeof(dest)); + memset(&p, 0, sizeof(p)); + + dest.sll_family = AF_PACKET; + dest.sll_protocol = htons(ETH_P_ARP); + dest.sll_ifindex = ifindex; + dest.sll_halen = ETH_ALEN; + memset(dest.sll_addr, 0xFF, ETH_ALEN); + if (bind(fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) { + int err = errno; + close(fd); + return -err; + } + + ip_source = htonl(source_ip); + ip_target = htonl(target_ip); + p.arp_hrd = htons(ARPHRD_ETHER); + p.arp_pro = htons(ETHERTYPE_IP); + p.arp_hln = ETH_ALEN; + p.arp_pln = 4; + p.arp_op = htons(ARPOP_REQUEST); + + memcpy(&p.arp_sha, source_eth, ETH_ALEN); + memcpy(&p.arp_spa, &ip_source, sizeof(p.arp_spa)); + memcpy(&p.arp_tpa, &ip_target, sizeof(p.arp_tpa)); + + n = sendto(fd, &p, sizeof(p), 0, + (struct sockaddr*) &dest, sizeof(dest)); + if (n < 0) + n = -errno; + + close(fd); + + return n; +} + +int arp_socket(int ifindex) +{ + int fd; + struct sockaddr_ll sock; + + fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, 0); + if (fd < 0) + return fd; + + memset(&sock, 0, sizeof(sock)); + + sock.sll_family = AF_PACKET; + sock.sll_protocol = htons(ETH_P_ARP); + sock.sll_ifindex = ifindex; + + if (bind(fd, (struct sockaddr *) &sock, sizeof(sock)) != 0) { + int err = errno; + close(fd); + return -err; + } + + return fd; +} diff --git a/src/shared/arp.h b/src/shared/arp.h new file mode 100644 index 0000000..e0d26e7 --- /dev/null +++ b/src/shared/arp.h @@ -0,0 +1,42 @@ +/* + * + * Connection Manager + * + * based on IPv4 Local Link library with GLib integration, + * Copyright (C) 2009-2010 Aldebaran Robotics. All rights reserved. + * + * Copyright (C) 2018 Commend International. 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 + * published by the Free Software Foundation. + * + * 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. + * + */ + +#ifndef SHARED_ARP_H +#define SHARED_ARP_H + +#include <stdint.h> + +/* IPv4 Link-Local (RFC 3927), IPv4 Address Conflict Detection (RFC 5227) */ +#define PROBE_WAIT 1 +#define PROBE_NUM 3 +#define PROBE_MIN 1 +#define PROBE_MAX 2 +#define ANNOUNCE_WAIT 2 +#define ANNOUNCE_NUM 2 +#define ANNOUNCE_INTERVAL 2 +#define MAX_CONFLICTS 10 +#define RATE_LIMIT_INTERVAL 60 +#define DEFEND_INTERVAL 10 + +int arp_send_packet(uint8_t* source_eth, uint32_t source_ip, + uint32_t target_ip, int ifindex); +int arp_socket(int ifindex); + +#endif -- 2.7.4

Following feature ACD also needs a random IPv4 address as fallback. This patch moves the function ipv4ll_random_ip() from gdhcp/ipv4ll.h to src/shared/arp.h. The gdhcp/ipv4ll.h is now empty and can be removed. The function arp_random_ip uses __connman_util_get_random() from src/util.c. In Makefile.am this patch removes arp.c from target netlink-test to avoid depenencies of arp.c (src/util.c, src/log.c and src/backtrace.c). --- Makefile.am | 5 +++-- gdhcp/client.c | 5 ++--- gdhcp/ipv4ll.h | 39 --------------------------------------- src/shared/arp.c | 18 ++++++++++++++++++ src/shared/arp.h | 5 +++++ 5 files changed, 28 insertions(+), 44 deletions(-) delete mode 100644 gdhcp/ipv4ll.h diff --git a/Makefile.am b/Makefile.am index 841aef8..5aa77be 100644 --- a/Makefile.am +++ b/Makefile.am @@ -33,7 +33,7 @@ gdbus_libgdbus_internal_la_SOURCES = gdbus/gdbus.h \ gdbus/object.c gdbus/client.c gdbus/polkit.c gdhcp_sources = gdhcp/gdhcp.h gdhcp/common.h gdhcp/common.c gdhcp/client.c \ - gdhcp/server.c gdhcp/ipv4ll.h gdhcp/ipv4ll.c gdhcp/unaligned.h + gdhcp/server.c gdhcp/unaligned.h gweb_sources = gweb/gweb.h gweb/gweb.c gweb/gresolv.h gweb/gresolv.c @@ -396,7 +396,8 @@ endif tools_dnsproxy_test_SOURCES = tools/dnsproxy-test.c tools_dnsproxy_test_LDADD = @GLIB_LIBS@ -tools_netlink_test_SOURCES = $(shared_sources) tools/netlink-test.c +tools_netlink_test_SOURCES = src/shared/util.c src/shared/netlink.c \ + tools/netlink-test.c tools_netlink_test_LDADD = @GLIB_LIBS@ endif diff --git a/gdhcp/client.c b/gdhcp/client.c index eac8b3d..826e8cc 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -47,7 +47,6 @@ #include "../src/shared/arp.h" #include "gdhcp.h" #include "common.h" -#include "ipv4ll.h" #define DISCOVER_TIMEOUT 5 #define DISCOVER_RETRIES 6 @@ -544,7 +543,7 @@ static gboolean send_probe_packet(gpointer dhcp_data) /* if requested_ip is not valid, pick a new address*/ if (dhcp_client->requested_ip == 0) { debug(dhcp_client, "pick a new random address"); - dhcp_client->requested_ip = ipv4ll_random_ip(); + dhcp_client->requested_ip = arp_random_ip(); } debug(dhcp_client, "sending IPV4LL probe request"); @@ -1343,7 +1342,7 @@ static void ipv4ll_start(GDHCPClient *dhcp_client) dhcp_client->retry_times = 0; dhcp_client->requested_ip = 0; - dhcp_client->requested_ip = ipv4ll_random_ip(); + dhcp_client->requested_ip = arp_random_ip(); /*first wait a random delay to avoid storm of arp request on boot*/ timeout = __connman_util_random_delay_ms(PROBE_WAIT); diff --git a/gdhcp/ipv4ll.h b/gdhcp/ipv4ll.h deleted file mode 100644 index 315ca3d..0000000 --- a/gdhcp/ipv4ll.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * - * IPV4 Local Link library with GLib integration - * - * Copyright (C) 2009-2010 Aldebaran Robotics. 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 - * published by the Free Software Foundation. - * - * 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. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifndef __G_IPV4LL_H -#define __G_IPV4LL_H - -#include <stdint.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/* 169.254.0.0 */ -#define LINKLOCAL_ADDR 0xa9fe0000 - -uint32_t ipv4ll_random_ip(void); - -#ifdef __cplusplus -} -#endif -#endif /* !IPV4LL_H_ */ diff --git a/src/shared/arp.c b/src/shared/arp.c index 02b5003..6cd611f 100644 --- a/src/shared/arp.c +++ b/src/shared/arp.c @@ -33,6 +33,7 @@ #include <arpa/inet.h> #include "src/shared/arp.h" +#include "src/connman.h" int arp_send_packet(uint8_t* source_eth, uint32_t source_ip, uint32_t target_ip, int ifindex) @@ -106,3 +107,20 @@ int arp_socket(int ifindex) return fd; } + +/** + * Return a random link local IP (in host byte order) + */ +uint32_t arp_random_ip(void) +{ + unsigned tmp; + + do { + uint64_t rand; + __connman_util_get_random(&rand); + tmp = rand; + tmp = tmp & IN_CLASSB_HOST; + } while (tmp > (IN_CLASSB_HOST - 0x0200)); + + return (LINKLOCAL_ADDR + 0x0100) + tmp; +} diff --git a/src/shared/arp.h b/src/shared/arp.h index e0d26e7..03e2168 100644 --- a/src/shared/arp.h +++ b/src/shared/arp.h @@ -35,8 +35,13 @@ #define RATE_LIMIT_INTERVAL 60 #define DEFEND_INTERVAL 10 +/* 169.254.0.0 */ +#define LINKLOCAL_ADDR 0xa9fe0000 + int arp_send_packet(uint8_t* source_eth, uint32_t source_ip, uint32_t target_ip, int ifindex); int arp_socket(int ifindex); +uint32_t arp_random_ip(void); + #endif -- 2.7.4

Add first acd.h, acd.c, a configuration ACD on/off switch and a first version of start_acd in network.c which does nothing for the moment. --- Makefile.am | 6 ++++-- include/acd.h | 39 +++++++++++++++++++++++++++++++++++++++ src/acd.c | 24 ++++++++++++++++++++++++ src/main.c | 13 +++++++++++++ src/network.c | 38 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 118 insertions(+), 2 deletions(-) create mode 100644 include/acd.h create mode 100644 src/acd.c diff --git a/Makefile.am b/Makefile.am index 5aa77be..3d5dc5f 100644 --- a/Makefile.am +++ b/Makefile.am @@ -11,7 +11,8 @@ include_HEADERS = include/log.h include/plugin.h \ include/device.h include/network.h include/inet.h \ include/storage.h include/provision.h \ include/session.h include/ipaddress.h include/agent.h \ - include/inotify.h include/peer.h include/machine.h + include/inotify.h include/peer.h include/machine.h \ + include/acd.h nodist_include_HEADERS = include/version.h @@ -129,7 +130,8 @@ src_connmand_SOURCES = $(gdhcp_sources) $(gweb_sources) $(stats_sources) \ src/session.c src/tethering.c src/wpad.c src/wispr.c \ src/6to4.c src/ippool.c src/bridge.c src/nat.c \ src/ipaddress.c src/inotify.c src/ipv6pd.c src/peer.c \ - src/peer_service.c src/machine.c src/util.c + src/peer_service.c src/machine.c src/util.c \ + src/acd.c if INTERNAL_DNS_BACKEND src_connmand_SOURCES += src/dnsproxy.c diff --git a/include/acd.h b/include/acd.h new file mode 100644 index 0000000..baca508 --- /dev/null +++ b/include/acd.h @@ -0,0 +1,39 @@ +/* + * + * Connection Manager + * + * Copyright (C) 2018 Commend International. 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 + * published by the Free Software Foundation. + * + * 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. + * + */ + +/* + * Address Conflict Detection (RFC 5227) + * + * based on DHCP client library with GLib integration, + * Copyright (C) 2009-2014 Intel Corporation. All rights reserved. + * + */ + +#ifndef __CONNMAN_ACD_H +#define __CONNMAN_ACD_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct acd_host; + +#ifdef __cplusplus +} +#endif + +#endif /* __CONNMAN_ACD_H */ diff --git a/src/acd.c b/src/acd.c new file mode 100644 index 0000000..70505b3 --- /dev/null +++ b/src/acd.c @@ -0,0 +1,24 @@ +/* + * + * Connection Manager + * + * Copyright (C) 2018 Commend International GmbH. 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 + * published by the Free Software Foundation. + * + * 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. + * + */ + +/* + * Address Conflict Detection (RFC 5227) + * + * based on DHCP client library with GLib integration, + * Copyright (C) 2009-2014 Intel Corporation. All rights reserved. + * + */ diff --git a/src/main.c b/src/main.c index 318bf02..5c732ae 100644 --- a/src/main.c +++ b/src/main.c @@ -81,6 +81,7 @@ static struct { char *vendor_class_id; bool enable_online_check; bool auto_connect_roaming_services; + bool acd; } connman_settings = { .bg_scan = true, .pref_timeservers = NULL, @@ -100,6 +101,7 @@ static struct { .vendor_class_id = NULL, .enable_online_check = true, .auto_connect_roaming_services = false, + .acd = false, }; #define CONF_BG_SCAN "BackgroundScanning" @@ -120,6 +122,7 @@ static struct { #define CONF_VENDOR_CLASS_ID "VendorClassID" #define CONF_ENABLE_ONLINE_CHECK "EnableOnlineCheck" #define CONF_AUTO_CONNECT_ROAMING_SERVICES "AutoConnectRoamingServices" +#define CONF_ACD "AddressConflictDetection" static const char *supported_options[] = { CONF_BG_SCAN, @@ -140,6 +143,7 @@ static const char *supported_options[] = { CONF_VENDOR_CLASS_ID, CONF_ENABLE_ONLINE_CHECK, CONF_AUTO_CONNECT_ROAMING_SERVICES, + CONF_ACD, NULL }; @@ -431,6 +435,12 @@ static void parse_config(GKeyFile *config) connman_settings.auto_connect_roaming_services = boolean; g_clear_error(&error); + + boolean = __connman_config_get_bool(config, "General", CONF_ACD, &error); + if (!error) + connman_settings.acd = boolean; + + g_clear_error(&error); } static int config_init(const char *file) @@ -644,6 +654,9 @@ bool connman_setting_get_bool(const char *key) if (g_str_equal(key, CONF_AUTO_CONNECT_ROAMING_SERVICES)) return connman_settings.auto_connect_roaming_services; + if (g_str_equal(key, CONF_ACD)) + return connman_settings.acd; + return false; } diff --git a/src/network.c b/src/network.c index 4757d0d..134aaf0 100644 --- a/src/network.c +++ b/src/network.c @@ -27,6 +27,7 @@ #include <string.h> #include "connman.h" +#include <connman/acd.h> /* * How many times to send RS with the purpose of @@ -67,6 +68,7 @@ struct connman_network { int index; int router_solicit_count; int router_solicit_refresh_count; + struct acd_host *acd_host; struct connman_network_driver *driver; void *driver_data; @@ -154,6 +156,24 @@ static void set_configuration(struct connman_network *network, type); } +static int start_acd(struct connman_network *network) +{ + struct connman_service *service; + struct connman_ipconfig *ipconfig_ipv4; + + service = connman_service_lookup_from_network(network); + if (!service) + return -EINVAL; + + ipconfig_ipv4 = __connman_service_get_ip4config(service); + if (!ipconfig_ipv4) { + connman_error("Service has no IPv4 configuration"); + return -EINVAL; + } + + return 0; +} + static void dhcp_success(struct connman_network *network) { struct connman_service *service; @@ -171,6 +191,14 @@ static void dhcp_success(struct connman_network *network) if (!ipconfig_ipv4) return; + if (connman_setting_get_bool("AddressConflictDetection")) { + err = start_acd(network); + if (!err) + return; + + /* On error proceed without ACD. */ + } + err = __connman_ipconfig_address_add(ipconfig_ipv4); if (err < 0) goto err; @@ -237,6 +265,14 @@ static int set_connected_manual(struct connman_network *network) if (!__connman_ipconfig_get_local(ipconfig)) __connman_service_read_ip4config(service); + if (connman_setting_get_bool("AddressConflictDetection")) { + err = start_acd(network); + if (!err) + return 0; + + /* On error proceed without ACD. */ + } + err = __connman_ipconfig_address_add(ipconfig); if (err < 0) goto err; @@ -920,6 +956,7 @@ static void network_destruct(struct connman_network *network) g_free(network->node); g_free(network->name); g_free(network->identifier); + g_free(network->acd_host); network->device = NULL; @@ -955,6 +992,7 @@ struct connman_network *connman_network_create(const char *identifier, network->type = type; network->identifier = ident; + network->acd_host = NULL; network_list = g_slist_prepend(network_list, network); -- 2.7.4

Adds an enum for the ACD state machine, the ACD struct, a function for allocation and initialization of the struct. --- include/acd.h | 4 ++++ src/acd.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 76 insertions(+) diff --git a/include/acd.h b/include/acd.h index baca508..db2452d 100644 --- a/include/acd.h +++ b/include/acd.h @@ -26,12 +26,16 @@ #ifndef __CONNMAN_ACD_H #define __CONNMAN_ACD_H +#include <stdint.h> + #ifdef __cplusplus extern "C" { #endif struct acd_host; +struct acd_host *acd_host_new(int ifindex); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index 70505b3..3a060a7 100644 --- a/src/acd.c +++ b/src/acd.c @@ -22,3 +22,75 @@ * Copyright (C) 2009-2014 Intel Corporation. All rights reserved. * */ + +#include "connman.h" +#include <connman/acd.h> +#include <connman/log.h> +#include <connman/inet.h> +#include <glib.h> +#include "src/shared/arp.h" + +enum acd_state { + ACD_STATE_PROBE, + ACD_STATE_ANNOUNCE, + ACD_STATE_MONITOR, + ACD_STATE_DEFEND, +}; + +struct acd_host { + enum acd_state state; + int ifindex; + char *interface; + uint8_t mac_address[6]; + uint32_t requested_ip; /* host byte order */ + + bool listen_on; + int listener_sockfd; + unsigned int retry_times; + unsigned int conflicts; + guint timeout; + guint listener_watch; +}; + +struct acd_host *acd_host_new(int ifindex) +{ + struct acd_host *acd; + + if (ifindex < 0) { + connman_error("Invalid interface index %d", ifindex); + return NULL; + } + + acd = g_try_new0(struct acd_host, 1); + if (!acd) { + connman_error("Could not allocate ACD data structure"); + return NULL; + } + + acd->interface = connman_inet_ifname(ifindex); + if (!acd->interface) { + connman_error("Interface with index %d is not available", ifindex); + goto error; + } + + if (!connman_inet_is_ifup(ifindex)) { + connman_error("Interface with index %d and name %s is down", ifindex, + acd->interface); + goto error; + } + + __connman_inet_get_interface_mac_address(ifindex, acd->mac_address); + + acd->listener_sockfd = -1; + acd->listen_on = false; + acd->ifindex = ifindex; + acd->listener_watch = 0; + acd->retry_times = 0; + + return acd; + +error: + g_free(acd->interface); + g_free(acd); + return NULL; +} -- 2.7.4

Adds a function for sending ARP probe packets and a timeout callback function for invoking send_probe_packet repeatedly. --- src/acd.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/src/acd.c b/src/acd.c index 57fde9c..574b2b0 100644 --- a/src/acd.c +++ b/src/acd.c @@ -62,6 +62,9 @@ static void stop_listening(struct acd_host *acd); static gboolean acd_listener_event(GIOChannel *channel, GIOCondition condition, gpointer acd_data); static int acd_recv_arp_packet(struct acd_host *acd); +static void send_probe_packet(gpointer acd_data); +static gboolean acd_probe_timeout(gpointer acd_data); +static gboolean send_announce_packet(gpointer acd_data); static void debug(struct acd_host *acd, const char *format, ...) { @@ -204,3 +207,57 @@ void acd_host_stop(struct acd_host *acd) { stop_listening(acd); } + +static void send_probe_packet(gpointer acd_data) +{ + guint timeout; + struct acd_host *acd = acd_data; + + debug(acd, "sending ARP probe request"); + if (acd->retry_times == 1) { + acd->state = ACD_STATE_PROBE; + start_listening(acd); + } + arp_send_packet(acd->mac_address, 0, + acd->requested_ip, acd->ifindex); + + if (acd->retry_times < PROBE_NUM) { + /* Add a random timeout in range of PROBE_MIN to PROBE_MAX. */ + timeout = __connman_util_random_delay_ms(PROBE_MAX-PROBE_MIN); + timeout += PROBE_MIN * 1000; + } else + timeout = ANNOUNCE_WAIT * 1000; + + acd->timeout = g_timeout_add_full(G_PRIORITY_HIGH, + timeout, + acd_probe_timeout, + acd, + NULL); +} + +static gboolean acd_probe_timeout(gpointer acd_data) +{ + struct acd_host *acd = acd_data; + + acd->timeout = 0; + + debug(acd, "acd probe timeout (retries %d)", acd->retry_times); + if (acd->retry_times == PROBE_NUM) { + acd->state = ACD_STATE_ANNOUNCE; + acd->retry_times = 1; + + send_announce_packet(acd); + return FALSE; + } + + acd->retry_times++; + send_probe_packet(acd); + + return FALSE; +} + +static gboolean send_announce_packet(gpointer acd_data) +{ + (void) acd_data; + return TRUE; +} -- 2.7.4

Adds the callback functions for higher level address conflict handling. ipv4_available_cb will be called if there was no address conflict detected. ipv4_lost_cb will be called if another host is using our IPv4 address and defending was not successfull. ipv4_conflict_cb will be called if ACD detected a conflict during probing and there had been less than MAX_CONFLICTS conflicts. ipv4_max_conflicts_cb will be called if ACD detected a conflict during probing and there had been at least MAX_CONFLICTS conflicts. --- include/acd.h | 3 +++ src/acd.c | 14 ++++++++++++++ 2 files changed, 17 insertions(+) diff --git a/include/acd.h b/include/acd.h index 211d825..ce7bc9f 100644 --- a/include/acd.h +++ b/include/acd.h @@ -27,6 +27,7 @@ #define __CONNMAN_ACD_H #include <stdint.h> +#include <glib.h> #ifdef __cplusplus extern "C" { @@ -38,6 +39,8 @@ struct acd_host *acd_host_new(int ifindex); int acd_host_start(struct acd_host *acd, uint32_t ip); void acd_host_stop(struct acd_host *acd); +typedef void (*acd_host_cb_t) (struct acd_host *acd, gpointer user_data); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index 306e081..cca9f46 100644 --- a/src/acd.c +++ b/src/acd.c @@ -55,6 +55,15 @@ struct acd_host { unsigned int conflicts; guint timeout; guint listener_watch; + + acd_host_cb_t ipv4_available_cb; + gpointer ipv4_available_data; + acd_host_cb_t ipv4_lost_cb; + gpointer ipv4_lost_data; + acd_host_cb_t ipv4_conflict_cb; + gpointer ipv4_conflict_data; + acd_host_cb_t ipv4_max_conflicts_cb; + gpointer ipv4_max_conflicts_data; }; static int start_listening(struct acd_host *acd); @@ -116,6 +125,11 @@ struct acd_host *acd_host_new(int ifindex) acd->listener_watch = 0; acd->retry_times = 0; + acd->ipv4_available_cb = NULL; + acd->ipv4_lost_cb = NULL; + acd->ipv4_conflict_cb = NULL; + acd->ipv4_max_conflicts_cb = NULL; + return acd; error: -- 2.7.4

Adds the content of acd_defend_timeout which switches from state DEFEND back to MONITOR. Also adds content of acd_announce_timeout which sends repeated announce packets until ANNOUNCE_NUM is reached, then switches back to state MONITOR. --- src/acd.c | 29 +++++++++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-) diff --git a/src/acd.c b/src/acd.c index e7bef4b..a7468be 100644 --- a/src/acd.c +++ b/src/acd.c @@ -23,10 +23,13 @@ * */ +#include <netinet/if_ether.h> +#include <net/if_arp.h> #include <errno.h> #include <unistd.h> #include <stdio.h> #include <stdarg.h> +#include <string.h> #include "connman.h" #include <connman/acd.h> @@ -339,14 +342,36 @@ static gboolean send_announce_packet(gpointer acd_data) static gboolean acd_announce_timeout(gpointer acd_data) { - (void) acd_data; + struct acd_host *acd = acd_data; + + acd->timeout = 0; + + debug(acd, "acd announce timeout (retries %d)", acd->retry_times); + if (acd->retry_times != ANNOUNCE_NUM) { + acd->retry_times++; + send_announce_packet(acd); + return FALSE; + } + + debug(acd, "switching to monitor mode"); + acd->state = ACD_STATE_MONITOR; + + if (acd->ipv4_available_cb) + acd->ipv4_available_cb(acd, + acd->ipv4_available_data); + acd->conflicts = 0; return FALSE; } static gboolean acd_defend_timeout(gpointer acd_data) { - (void) acd_data; + struct acd_host *acd = acd_data; + + debug(acd, "back to MONITOR mode"); + acd->timeout = 0; + acd->conflicts = 0; + acd->state = ACD_STATE_MONITOR; return FALSE; } -- 2.7.4

Adds function acd_host_register_event for registration of higher level address conflict callback functions. --- include/acd.h | 12 ++++++++++++ src/acd.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/include/acd.h b/include/acd.h index ce7bc9f..34e2539 100644 --- a/include/acd.h +++ b/include/acd.h @@ -41,6 +41,18 @@ void acd_host_stop(struct acd_host *acd); typedef void (*acd_host_cb_t) (struct acd_host *acd, gpointer user_data); +enum acd_host_event { + ACD_HOST_EVENT_IPV4_AVAILABLE, + ACD_HOST_EVENT_IPV4_LOST, + ACD_HOST_EVENT_IPV4_CONFLICT, + ACD_HOST_EVENT_IPV4_MAXCONFLICT, +}; + +void acd_host_register_event(struct acd_host *acd, + enum acd_host_event event, + acd_host_cb_t func, + gpointer user_data); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index 6f2a7ab..7f945c7 100644 --- a/src/acd.c +++ b/src/acd.c @@ -464,3 +464,32 @@ static gboolean acd_defend_timeout(gpointer acd_data) return FALSE; } + +void acd_host_register_event(struct acd_host *acd, + enum acd_host_event event, + acd_host_cb_t func, + gpointer user_data) +{ + switch (event) { + case ACD_HOST_EVENT_IPV4_AVAILABLE: + acd->ipv4_available_cb = func; + acd->ipv4_available_data = user_data; + break; + case ACD_HOST_EVENT_IPV4_LOST: + acd->ipv4_lost_cb = func; + acd->ipv4_lost_data = user_data; + break; + case ACD_HOST_EVENT_IPV4_CONFLICT: + acd->ipv4_conflict_cb = func; + acd->ipv4_conflict_data = user_data; + break; + case ACD_HOST_EVENT_IPV4_MAXCONFLICT: + acd->ipv4_max_conflicts_cb = func; + acd->ipv4_max_conflicts_data = user_data; + break; + default: + connman_warn("%s unknown event %d.", __FUNCTION__, event); + break; + } +} + -- 2.7.4

Adds content for acd_host_ipv4_available and acdhost_ipv4_lost which is basically applying (adding) and removing an IPv4 address to ipconfig. --- src/network.c | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) diff --git a/src/network.c b/src/network.c index 6ad3eb5..e467a74 100644 --- a/src/network.c +++ b/src/network.c @@ -157,20 +157,102 @@ static void set_configuration(struct connman_network *network, type); } +static int start_acd(struct connman_network *network); + static void acd_host_ipv4_available(struct acd_host *acd, gpointer user_data) { + struct connman_network *network = user_data; + struct connman_service *service; + struct connman_ipconfig *ipconfig_ipv4; + int err; + + if (!network) + return; + + service = connman_service_lookup_from_network(network); + if (!service) + return; + + ipconfig_ipv4 = __connman_service_get_ip4config(service); + if (!ipconfig_ipv4) { + connman_error("Service has no IPv4 configuration"); + return; + } + + err = __connman_ipconfig_address_add(ipconfig_ipv4); + if (err < 0) + goto err; + + err = __connman_ipconfig_gateway_add(ipconfig_ipv4); + if (err < 0) + goto err; + + __connman_service_save(service); + + return; + +err: + connman_network_set_error(__connman_service_get_network(service), + CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL); } static void acd_host_ipv4_lost(struct acd_host *acd, gpointer user_data) { + struct connman_network *network = user_data; + struct connman_service *service; + struct connman_ipconfig *ipconfig_ipv4; + enum connman_ipconfig_type type; + enum connman_ipconfig_method method; + + if (!network) + return; + + service = connman_service_lookup_from_network(network); + if (!service) + return; + + ipconfig_ipv4 = __connman_service_get_ip4config(service); + if (!ipconfig_ipv4) { + connman_error("Service has no IPv4 configuration"); + return; + } + + type = __connman_ipconfig_get_config_type(ipconfig_ipv4); + if (type != CONNMAN_IPCONFIG_TYPE_IPV4) + return; + + __connman_ipconfig_address_remove(ipconfig_ipv4); + + method = __connman_ipconfig_get_method(ipconfig_ipv4); + if (method == CONNMAN_IPCONFIG_METHOD_DHCP) { + /* + * We have one more chance for DHCP. If this fails + * acd_host_ipv4_conflict will be called. + */ + network = __connman_service_get_network(service); + if (network) + __connman_network_enable_ipconfig(network, ipconfig_ipv4); + } else { + /* Start IPv4LL ACD. */ + } } static void acd_host_ipv4_conflict(struct acd_host *acd, gpointer user_data) { + struct connman_network *network = user_data; + (void) network; + + /* Start IPv4LL ACD. */ } static void acd_host_ipv4_maxconflict(struct acd_host *acd, gpointer user_data) { + struct connman_network *network = user_data; + (void) network; + + connman_info("Had maximum number of conflicts. Next IPv4LL address will be " + "tried in %d seconds", RATE_LIMIT_INTERVAL); + /* Wait, then start IPv4LL ACD. */ } static int start_acd(struct connman_network *network) -- 2.7.4

Adds a D-Bus property called LastAddressConflict and a signal to notify if the property changes. --- doc/service-api.txt | 32 ++++++++++++++++++++ include/acd.h | 4 ++- include/network.h | 5 ++++ include/service.h | 1 + src/acd.c | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++++- src/network.c | 12 +++++++- src/service.c | 11 +++++++ 7 files changed, 146 insertions(+), 3 deletions(-) diff --git a/doc/service-api.txt b/doc/service-api.txt index 4026e7e..c0d5adb 100644 --- a/doc/service-api.txt +++ b/doc/service-api.txt @@ -520,3 +520,35 @@ Properties string State [readonly] Same values as mDNS property. The mDNS represents the actual system configuration while this allows user configuration. + + dict LastAddressConflict [readonly] + + This property contains information about the previously detected + address conflict. If there has been no address conflict then + IPv4 Address is "0.0.0.0", Ethernet Address is "00:00:00:00:00:00", + Timestamp is zero and Resolved is true. + + dict IPv4 [readonly] + + string Address [readonly] + + The IPv4 address which had a conflict. + + dict Ethernet [readonly] + + string Address [readonly] + + The ethernet device address (MAC address) of the conflicting + host. + + int64 Timestamp [readonly] + + A timestamp when the conflict was detected in microseconds + since January 1, 1970 UTC. + + bool Resolved [readonly] + + Set to false when an address conflict occurs. + If a previous conflict could be resolved by probing another + IPv4 address (which is not an IPv4LL) then this boolean is set + to true. diff --git a/include/acd.h b/include/acd.h index 34e2539..6898ccb 100644 --- a/include/acd.h +++ b/include/acd.h @@ -35,7 +35,7 @@ extern "C" { struct acd_host; -struct acd_host *acd_host_new(int ifindex); +struct acd_host *acd_host_new(int ifindex, const char* path); int acd_host_start(struct acd_host *acd, uint32_t ip); void acd_host_stop(struct acd_host *acd); @@ -53,6 +53,8 @@ void acd_host_register_event(struct acd_host *acd, acd_host_cb_t func, gpointer user_data); +void acd_host_append_dbus_property(struct acd_host *acd, DBusMessageIter *dict); + #ifdef __cplusplus } #endif diff --git a/include/network.h b/include/network.h index 4fc20c1..ee5d2f6 100644 --- a/include/network.h +++ b/include/network.h @@ -25,6 +25,8 @@ #include <stdbool.h> #include <stdint.h> +#include <dbus/dbus.h> + #include <connman/device.h> #include <connman/ipconfig.h> @@ -162,6 +164,9 @@ struct connman_network_driver { int connman_network_driver_register(struct connman_network_driver *driver); void connman_network_driver_unregister(struct connman_network_driver *driver); +void connman_network_append_acddbus(DBusMessageIter *dict, + struct connman_network *network); + #ifdef __cplusplus } #endif diff --git a/include/service.h b/include/service.h index 958e7fd..c958375 100644 --- a/include/service.h +++ b/include/service.h @@ -117,6 +117,7 @@ enum connman_service_type connman_service_get_type(struct connman_service *servi char *connman_service_get_interface(struct connman_service *service); const char *connman_service_get_domainname(struct connman_service *service); +const char *connman_service_get_dbuspath(struct connman_service *service); char **connman_service_get_nameservers(struct connman_service *service); char **connman_service_get_timeservers_config(struct connman_service *service); char **connman_service_get_timeservers(struct connman_service *service); diff --git a/src/acd.c b/src/acd.c index 7f945c7..ae6ec79 100644 --- a/src/acd.c +++ b/src/acd.c @@ -35,6 +35,7 @@ #include <connman/acd.h> #include <connman/log.h> #include <connman/inet.h> +#include <connman/dbus.h> #include <glib.h> #include "src/shared/arp.h" @@ -59,6 +60,13 @@ struct acd_host { uint8_t mac_address[6]; uint32_t requested_ip; /* host byte order */ + /* address conflict fields */ + uint32_t ac_ip; /* host byte order */ + uint8_t ac_mac[6]; + gint64 ac_timestamp; + bool ac_resolved; + const char *path; + bool listen_on; int listener_sockfd; unsigned int retry_times; @@ -87,6 +95,9 @@ static gboolean send_announce_packet(gpointer acd_data); static gboolean acd_announce_timeout(gpointer acd_data); static gboolean acd_defend_timeout(gpointer acd_data); +/* for D-Bus property */ +static void report_conflict(struct acd_host *acd); + static void debug(struct acd_host *acd, const char *format, ...) { char str[256]; @@ -100,7 +111,7 @@ static void debug(struct acd_host *acd, const char *format, ...) va_end(ap); } -struct acd_host *acd_host_new(int ifindex) +struct acd_host *acd_host_new(int ifindex, const char *path) { struct acd_host *acd; @@ -140,6 +151,12 @@ struct acd_host *acd_host_new(int ifindex) acd->ipv4_conflict_cb = NULL; acd->ipv4_max_conflicts_cb = NULL; + acd->ac_ip = 0; + memset(acd->ac_mac, 0, sizeof(acd->ac_mac)); + acd->ac_timestamp = 0; + acd->ac_resolved = true; + acd->path = path; + return acd; error: @@ -221,6 +238,11 @@ static gboolean acd_listener_event(GIOChannel *channel, GIOCondition condition, return TRUE; } +static bool is_link_local(uint32_t ip) +{ + return (ip & LINKLOCAL_ADDR) == LINKLOCAL_ADDR; +} + static int acd_recv_arp_packet(struct acd_host *acd) { ssize_t cnt; @@ -290,6 +312,13 @@ static int acd_recv_arp_packet(struct acd_host *acd) } if (acd->conflicts < MAX_CONFLICTS) { + if (!is_link_local(acd->requested_ip)) { + acd->ac_ip = acd->requested_ip; + memcpy(acd->ac_mac, arp.arp_sha, sizeof(acd->ac_mac)); + acd->ac_timestamp = g_get_real_time(); + acd->ac_resolved = false; + report_conflict(acd); + } acd_host_stop(acd); /* we need a new request_ip */ @@ -445,6 +474,11 @@ static gboolean acd_announce_timeout(gpointer acd_data) debug(acd, "switching to monitor mode"); acd->state = ACD_STATE_MONITOR; + if (!acd->ac_resolved && !is_link_local(acd->requested_ip)) { + acd->ac_resolved = true; + report_conflict(acd); + } + if (acd->ipv4_available_cb) acd->ipv4_available_cb(acd, acd->ipv4_available_data); @@ -493,3 +527,51 @@ void acd_host_register_event(struct acd_host *acd, } } +static void append_ac_mac(DBusMessageIter *iter, void *user_data) +{ + struct acd_host *acd = user_data; + char mac[32]; + uint8_t *m = acd->ac_mac; + const char *str = mac; + + snprintf(mac, sizeof(mac), "%02x:%02x:%02x:%02x:%02x:%02x", + m[0], m[1], m[2], m[3], m[4], m[5]); + connman_dbus_dict_append_basic(iter, "Address", DBUS_TYPE_STRING, &str); +} + +static void append_ac_ipv4(DBusMessageIter *iter, void *user_data) +{ + struct acd_host *acd = user_data; + struct in_addr addr; + char *a; + + addr.s_addr = htonl(acd->ac_ip); + a = inet_ntoa(addr); + if (!a) + a = ""; + connman_dbus_dict_append_basic(iter, "Address", DBUS_TYPE_STRING, &a); +} + +static void append_ac_property(DBusMessageIter *iter, void *user_data) +{ + struct acd_host *acd = user_data; + + connman_dbus_dict_append_dict(iter, "IPv4", append_ac_ipv4, acd); + connman_dbus_dict_append_dict(iter, "Ethernet", append_ac_mac, acd); + connman_dbus_dict_append_basic(iter, "Timestamp", DBUS_TYPE_INT64, + &acd->ac_timestamp); + connman_dbus_dict_append_basic(iter, "Resolved", DBUS_TYPE_BOOLEAN, + &acd->ac_resolved); +} + +void acd_host_append_dbus_property(struct acd_host *acd, DBusMessageIter *dict) +{ + connman_dbus_dict_append_dict(dict, "LastAddressConflict", + append_ac_property, acd); +} + +static void report_conflict(struct acd_host *acd) +{ + connman_dbus_property_changed_dict(acd->path, CONNMAN_SERVICE_INTERFACE, + "LastAddressConflict", append_ac_property, acd); +} diff --git a/src/network.c b/src/network.c index 92c36c0..ddcad65 100644 --- a/src/network.c +++ b/src/network.c @@ -158,6 +158,15 @@ static void set_configuration(struct connman_network *network, type); } +void connman_network_append_acddbus(DBusMessageIter *dict, + struct connman_network *network) +{ + if (!network->acd_host) + return; + + acd_host_append_dbus_property(network->acd_host, dict); +} + static int start_acd(struct connman_network *network); static void remove_ipv4ll_timeout(struct connman_network *network) @@ -339,7 +348,8 @@ static int start_acd(struct connman_network *network) int index; index = __connman_ipconfig_get_index(ipconfig_ipv4); - network->acd_host = acd_host_new(index); + network->acd_host = acd_host_new(index, + connman_service_get_dbuspath(service)); if (!network->acd_host) { connman_error("Could not create ACD data structure"); return -EINVAL; diff --git a/src/service.c b/src/service.c index 733c072..03bfb7b 100644 --- a/src/service.c +++ b/src/service.c @@ -2538,6 +2538,9 @@ static void append_properties(DBusMessageIter *dict, dbus_bool_t limited, connman_dbus_dict_append_dict(dict, "Provider", append_provider, service); + + if (service->network) + connman_network_append_acddbus(dict, service->network); } static void append_struct_service(DBusMessageIter *iter, @@ -2669,6 +2672,14 @@ const char *connman_service_get_domainname(struct connman_service *service) return service->domainname; } +const char *connman_service_get_dbuspath(struct connman_service *service) +{ + if (!service) + return NULL; + + return service->path; +} + char **connman_service_get_nameservers(struct connman_service *service) { if (!service) -- 2.7.4

In case of an address conflict for a DHCP lease we have to send a DHCP DECLINE and then try DHCP process a second time after a delay of 10 seconds. If second DHCP lease also has a conflict the fallback is IPv4LL. --- include/network.h | 2 ++ src/network.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/include/network.h b/include/network.h index ee5d2f6..8f87d7c 100644 --- a/include/network.h +++ b/include/network.h @@ -102,6 +102,8 @@ void connman_network_set_error(struct connman_network *network, int connman_network_set_connected(struct connman_network *network, bool connected); bool connman_network_get_connected(struct connman_network *network); +void connman_network_set_connected_dhcp_later(struct connman_network *network, + uint32_t sec); bool connman_network_get_associating(struct connman_network *network); diff --git a/src/network.c b/src/network.c index ddcad65..af23c65 100644 --- a/src/network.c +++ b/src/network.c @@ -71,6 +71,7 @@ struct connman_network { int router_solicit_refresh_count; struct acd_host *acd_host; guint ipv4ll_timeout; + guint dhcp_timeout; struct connman_network_driver *driver; void *driver_data; @@ -493,6 +494,14 @@ err: return err; } +static void remove_dhcp_timeout(struct connman_network *network) +{ + if (network->dhcp_timeout > 0) { + g_source_remove(network->dhcp_timeout); + network->dhcp_timeout = 0; + } +} + static int set_connected_dhcp(struct connman_network *network) { struct connman_service *service; @@ -500,6 +509,7 @@ static int set_connected_dhcp(struct connman_network *network) int err; DBG("network %p", network); + remove_dhcp_timeout(network); service = connman_service_lookup_from_network(network); ipconfig_ipv4 = __connman_service_get_ip4config(service); @@ -515,6 +525,44 @@ static int set_connected_dhcp(struct connman_network *network) return 0; } +static gboolean set_connected_dhcp_timout(gpointer data) +{ + struct connman_network *network = data; + struct connman_service *service; + struct connman_ipconfig *ipconfig; + enum connman_ipconfig_method method; + + network->dhcp_timeout = 0; + + service = connman_service_lookup_from_network(network); + if (!service) + return FALSE; + + ipconfig = __connman_service_get_ip4config(service); + if (!ipconfig) + return FALSE; + + /* Method is still DHCP? */ + method = __connman_ipconfig_get_method(ipconfig); + if (method == CONNMAN_IPCONFIG_METHOD_DHCP) + set_connected_dhcp(network); + + return FALSE; +} + +void connman_network_set_connected_dhcp_later(struct connman_network *network, + uint32_t sec) +{ + remove_dhcp_timeout(network); + + network->dhcp_timeout = + g_timeout_add_seconds_full(G_PRIORITY_HIGH, + sec, + set_connected_dhcp_timout, + network, + NULL); +} + static int manual_ipv6_set(struct connman_network *network, struct connman_ipconfig *ipconfig_ipv6) { @@ -916,6 +964,7 @@ static void set_disconnected(struct connman_network *network) __connman_service_notify_ipv4_configuration(service); /* fall through */ case CONNMAN_IPCONFIG_METHOD_DHCP: + remove_dhcp_timeout(network); __connman_dhcp_stop(ipconfig_ipv4); break; } @@ -1205,6 +1254,8 @@ struct connman_network *connman_network_create(const char *identifier, network_list = g_slist_prepend(network_list, network); + network->dhcp_timeout = 0; + DBG("network %p identifier %s type %s", network, identifier, type2string(type)); return network; @@ -1796,6 +1847,7 @@ int __connman_network_clear_ipconfig(struct connman_network *network, __connman_ipconfig_address_remove(ipconfig); break; case CONNMAN_IPCONFIG_METHOD_DHCP: + remove_dhcp_timeout(network); __connman_dhcp_stop(ipconfig_ipv4); break; } -- 2.7.4

Try DHCP two times, then fallback is IPv4LL. Also invoke __connman_dhcp_decline which sends a DHCP decline. --- src/network.c | 37 ++++++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-) diff --git a/src/network.c b/src/network.c index af23c65..7df5ccb 100644 --- a/src/network.c +++ b/src/network.c @@ -50,6 +50,8 @@ */ #define RTR_SOLICITATION_INTERVAL 4 +#define DHCP_RETRY_TIMEOUT 10 + static GSList *network_list = NULL; static GSList *driver_list = NULL; @@ -304,10 +306,39 @@ static void acd_host_ipv4_lost(struct acd_host *acd, gpointer user_data) static void acd_host_ipv4_conflict(struct acd_host *acd, gpointer user_data) { struct connman_network *network = user_data; - (void) network; + struct connman_service *service; + struct connman_ipconfig *ipconfig_ipv4; + enum connman_ipconfig_method method; - /* Start IPv4LL ACD. */ - start_ipv4ll(network); + service = connman_service_lookup_from_network(network); + if (!service) + return; + + ipconfig_ipv4 = __connman_service_get_ip4config(service); + if (!ipconfig_ipv4) { + connman_error("Service has no IPv4 configuration"); + return; + } + + method = __connman_ipconfig_get_method(ipconfig_ipv4); + connman_info("%s conflict counts=%u", __FUNCTION__, + acd_host_get_conflicts_count(acd)); + + if (method == CONNMAN_IPCONFIG_METHOD_DHCP && + acd_host_get_conflicts_count(acd) < 2) { + connman_info("%s Sending DHCP decline", __FUNCTION__); + __connman_dhcp_decline(ipconfig_ipv4); + + connman_network_set_connected_dhcp_later(network, DHCP_RETRY_TIMEOUT); + __connman_ipconfig_set_local(ipconfig_ipv4, NULL); + } else { + if (method == CONNMAN_IPCONFIG_METHOD_DHCP) { + __connman_ipconfig_set_method(ipconfig_ipv4, + CONNMAN_IPCONFIG_METHOD_AUTO); + } + /* Start IPv4LL ACD. */ + start_ipv4ll(network); + } } static void acd_host_ipv4_maxconflict(struct acd_host *acd, gpointer user_data) -- 2.7.4

DHCP is tried two times. We want to send also a DECLINE after second try fails with an address conflict. --- src/network.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/network.c b/src/network.c index 7df5ccb..c3a7cbf 100644 --- a/src/network.c +++ b/src/network.c @@ -335,6 +335,7 @@ static void acd_host_ipv4_conflict(struct acd_host *acd, gpointer user_data) if (method == CONNMAN_IPCONFIG_METHOD_DHCP) { __connman_ipconfig_set_method(ipconfig_ipv4, CONNMAN_IPCONFIG_METHOD_AUTO); + __connman_dhcp_decline(ipconfig_ipv4); } /* Start IPv4LL ACD. */ start_ipv4ll(network); -- 2.7.4