Hi Christian, On 04/11/2018 04:00 PM, Christian Spielberger wrote: Prefix these function with 'random_': random_get() random_cleanup() random_delay_ms() Maybe someone has a better idea for 'random_get()'. I'd to have all the shared code file properly prefixed to avoid clashes. Thanks, Daniel

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 | 3 +- gdhcp/client.c | 9 ++--- gdhcp/ipv4ll.c | 75 ++------------------------------------ gdhcp/ipv4ll.h | 17 +-------- src/shared/arp.c | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/shared/arp.h | 42 ++++++++++++++++++++++ 6 files changed, 160 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 21ef474..23c5171 100644 --- a/Makefile.am +++ b/Makefile.am @@ -49,7 +49,8 @@ endif shared_sources = src/shared/util.h src/shared/util.c \ src/shared/netlink.h src/shared/netlink.c \ - src/shared/random.h src/shared/random.c + src/shared/random.h src/shared/random.c \ + src/shared/arp.h src/shared/arp.c if DATAFILES diff --git a/gdhcp/client.c b/gdhcp/client.c index f46ced4..14c83b6 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -43,7 +43,8 @@ #include <glib.h> -#include "src/shared/random.h" +#include "../src/shared/random.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, + send_arp_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, + send_arp_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 3183348..dc0e4e8 100644 --- a/gdhcp/ipv4ll.c +++ b/gdhcp/ipv4ll.c @@ -34,7 +34,8 @@ #include <glib.h> -#include "src/shared/random.h" +#include "../src/shared/random.h" +#include "../src/shared/arp.h" #include "ipv4ll.h" #include "common.h" @@ -54,75 +55,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..e6c06fd --- /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 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 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..259e962 --- /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 send_arp_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 ACD code will need this utility function. So we moved it to src/shared/arp.c. --- gdhcp/client.c | 32 -------------------------------- src/shared/arp.c | 38 ++++++++++++++++++++++++++++++++++++++ src/shared/arp.h | 2 ++ 3 files changed, 40 insertions(+), 32 deletions(-) diff --git a/gdhcp/client.c b/gdhcp/client.c index 14c83b6..e36c4e0 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -607,38 +607,6 @@ static gboolean send_announce_packet(gpointer dhcp_data) return TRUE; } -static void get_interface_mac_address(int index, uint8_t *mac_address) -{ - struct ifreq ifr; - int sk, err; - - sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); - if (sk < 0) { - perror("Open socket error"); - return; - } - - memset(&ifr, 0, sizeof(ifr)); - ifr.ifr_ifindex = index; - - err = ioctl(sk, SIOCGIFNAME, &ifr); - if (err < 0) { - perror("Get interface name error"); - goto done; - } - - err = ioctl(sk, SIOCGIFHWADDR, &ifr); - if (err < 0) { - perror("Get mac address error"); - goto done; - } - - memcpy(mac_address, ifr.ifr_hwaddr.sa_data, 6); - -done: - close(sk); -} - void g_dhcpv6_client_set_retransmit(GDHCPClient *dhcp_client) { if (!dhcp_client) diff --git a/src/shared/arp.c b/src/shared/arp.c index e6c06fd..f43cbd1 100644 --- a/src/shared/arp.c +++ b/src/shared/arp.c @@ -19,17 +19,22 @@ */ #include <string.h> #include <stdlib.h> +#include <stdio.h> #include <errno.h> #include <unistd.h> #include <sys/time.h> #include <sys/socket.h> #include <sys/types.h> +#include <sys/ioctl.h> + #include <netpacket/packet.h> #include <net/ethernet.h> #include <netinet/if_ether.h> #include <net/if_arp.h> +#include <linux/if.h> + #include <arpa/inet.h> #include "src/shared/arp.h" @@ -106,3 +111,36 @@ int arp_socket(int ifindex) return fd; } + +void get_interface_mac_address(int index, uint8_t *mac_address) +{ + struct ifreq ifr; + int sk, err; + + sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); + if (sk < 0) { + perror("Open socket error"); + return; + } + + memset(&ifr, 0, sizeof(ifr)); + ifr.ifr_ifindex = index; + + err = ioctl(sk, SIOCGIFNAME, &ifr); + if (err < 0) { + perror("Get interface name error"); + goto done; + } + + err = ioctl(sk, SIOCGIFHWADDR, &ifr); + if (err < 0) { + perror("Get MAC address error"); + goto done; + } + + memcpy(mac_address, ifr.ifr_hwaddr.sa_data, ETH_ALEN); + +done: + close(sk); +} + diff --git a/src/shared/arp.h b/src/shared/arp.h index 259e962..1191827 100644 --- a/src/shared/arp.h +++ b/src/shared/arp.h @@ -39,4 +39,6 @@ int send_arp_packet(uint8_t* source_eth, uint32_t source_ip, uint32_t target_ip, int ifindex); int arp_socket(int ifindex); +void get_interface_mac_address(int index, uint8_t *mac_address); + #endif -- 2.7.4

Following feature ACD also needs a random IPv4 address as fallback. We move the function ipv4ll_random_ip() from gdhcp/ipv4ll.h to src/shared/random.h. The gdhcp/ipv4ll.h is now empty and can be removed. --- Makefile.am | 2 +- gdhcp/client.c | 5 ++--- gdhcp/ipv4ll.h | 39 --------------------------------------- src/shared/arp.c | 18 ++++++++++++++++++ src/shared/arp.h | 5 +++++ 5 files changed, 26 insertions(+), 43 deletions(-) delete mode 100644 gdhcp/ipv4ll.h diff --git a/Makefile.am b/Makefile.am index 23c5171..aa58691 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 diff --git a/gdhcp/client.c b/gdhcp/client.c index e36c4e0..9542eec 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 = 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 = random_ip(); /*first wait a random delay to avoid storm of arp request on boot*/ timeout = 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 f43cbd1..ac1f944 100644 --- a/src/shared/arp.c +++ b/src/shared/arp.c @@ -38,6 +38,7 @@ #include <arpa/inet.h> #include "src/shared/arp.h" +#include "src/shared/random.h" int send_arp_packet(uint8_t* source_eth, uint32_t source_ip, uint32_t target_ip, int ifindex) @@ -112,6 +113,23 @@ int arp_socket(int ifindex) return fd; } +/** + * Return a random link local IP (in host byte order) + */ +uint32_t random_ip(void) +{ + unsigned tmp; + + do { + uint64_t rand; + get_random(&rand); + tmp = rand; + tmp = tmp & IN_CLASSB_HOST; + } while (tmp > (IN_CLASSB_HOST - 0x0200)); + + return (LINKLOCAL_ADDR + 0x0100) + tmp; +} + void get_interface_mac_address(int index, uint8_t *mac_address) { struct ifreq ifr; diff --git a/src/shared/arp.h b/src/shared/arp.h index 1191827..2db946b 100644 --- a/src/shared/arp.h +++ b/src/shared/arp.h @@ -35,10 +35,15 @@ #define RATE_LIMIT_INTERVAL 60 #define DEFEND_INTERVAL 10 +/* 169.254.0.0 */ +#define LINKLOCAL_ADDR 0xa9fe0000 + int send_arp_packet(uint8_t* source_eth, uint32_t source_ip, uint32_t target_ip, int ifindex); int arp_socket(int ifindex); +uint32_t random_ip(void); + void get_interface_mac_address(int index, uint8_t *mac_address); #endif -- 2.7.4

Add function connman_inet_is_ifup() which checks if an interface is up. It will be used when initializing ACD. --- include/inet.h | 1 + src/inet.c | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/include/inet.h b/include/inet.h index 6482934..9c1918f 100644 --- a/include/inet.h +++ b/include/inet.h @@ -38,6 +38,7 @@ char *connman_inet_ifname(int index); int connman_inet_ifup(int index); int connman_inet_ifdown(int index); +bool connman_inet_is_ifup(int index); int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress); int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress); diff --git a/src/inet.c b/src/inet.c index dcd1ab2..4c2ebb8 100644 --- a/src/inet.c +++ b/src/inet.c @@ -330,6 +330,40 @@ done: return err; } +bool connman_inet_is_ifup(int index) +{ + int sk; + struct ifreq ifr; + bool ret = false; + + sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); + if (sk < 0) { + connman_warn("Failed to open socket"); + return false; + } + + memset(&ifr, 0, sizeof(ifr)); + ifr.ifr_ifindex = index; + + if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) { + connman_warn("Failed to get interface name for interface %d", index); + goto done; + } + + if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) { + connman_warn("Failed to get interface flags for index %d", index); + goto done; + } + + if (ifr.ifr_flags & IFF_UP) + ret = true; + +done: + close(sk); + + return ret; +} + struct in6_ifreq { struct in6_addr ifr6_addr; __u32 ifr6_prefixlen; -- 2.7.4

On Mon 16.04.18 16:46, Daniel Wagner wrote: Hi Daniel, sorry for the long delay. Today I found some time to proceed with the ACD patches. Here is the first question about your last comments. Do you mean, it should return 0 for "The interface is down.", 1 for "The interface is up." and a negative value in case of an error? regards, chris.

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 | 38 ++++++++++++++++++++++++++++++++++++++ src/acd.c | 19 +++++++++++++++++++ src/main.c | 13 +++++++++++++ src/network.c | 38 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 112 insertions(+), 2 deletions(-) create mode 100644 include/acd.h create mode 100644 src/acd.c diff --git a/Makefile.am b/Makefile.am index aa58691..1e54d88 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 @@ -125,7 +126,8 @@ src_connmand_SOURCES = $(gdhcp_sources) $(gweb_sources) $(backtrace_sources) \ src/stats.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..c347d77 --- /dev/null +++ b/include/acd.h @@ -0,0 +1,38 @@ +/* + * + * Connection Manager + * + * Address Conflict Detection (RFC 5227) + * + * based on DHCP client library with GLib integration, + * Copyright (C) 2009-2014 Intel Corporation. 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 __CONNMAN_ACD_H +#define __CONNMAN_ACD_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct _acd_host; + +typedef struct _acd_host 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..1653d2f --- /dev/null +++ b/src/acd.c @@ -0,0 +1,19 @@ +/* + * + * Connection Manager + * + * Address Conflict Detection (ACD) RFC 5227 + * + * 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. + * + */ + diff --git a/src/main.c b/src/main.c index dda54bb..4a07d60 100644 --- a/src/main.c +++ b/src/main.c @@ -82,6 +82,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, @@ -101,6 +102,7 @@ static struct { .vendor_class_id = NULL, .enable_online_check = true, .auto_connect_roaming_services = false, + .acd = false, }; #define CONF_BG_SCAN "BackgroundScanning" @@ -121,6 +123,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, @@ -141,6 +144,7 @@ static const char *supported_options[] = { CONF_VENDOR_CLASS_ID, CONF_ENABLE_ONLINE_CHECK, CONF_AUTO_CONNECT_ROAMING_SERVICES, + CONF_ACD, NULL }; @@ -432,6 +436,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) @@ -645,6 +655,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..6df1d01 100644 --- a/src/network.c +++ b/src/network.c @@ -26,6 +26,7 @@ #include <errno.h> #include <string.h> +#include <connman/acd.h> #include "connman.h" /* @@ -67,6 +68,7 @@ struct connman_network { int index; int router_solicit_count; int router_solicit_refresh_count; + acd_host *acdhost; 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->acdhost); network->device = NULL; @@ -955,6 +992,7 @@ struct connman_network *connman_network_create(const char *identifier, network->type = type; network->identifier = ident; + network->acdhost = NULL; network_list = g_slist_prepend(network_list, network); -- 2.7.4

From: Peter Meerwald-Stadler <pmeerw(a)pmeerw.net&gt; Signed-off-by: Peter Meerwald-Stadler <pmeerw(a)pmeerw.net&gt; --- doc/connman.conf.5.in | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/doc/connman.conf.5.in b/doc/connman.conf.5.in index 809a0a4..be31902 100644 --- a/doc/connman.conf.5.in +++ b/doc/connman.conf.5.in @@ -161,6 +161,16 @@ Default value is true. Automatically connect roaming services. This is not recommended unless you know you won't have any billing problem. Default value is false. +.TP +.BI AddressConflictDetection=true\ \fR|\fB\ false +Enable or disable the implementation of IPv4 address conflict detection +according to RFC5227. ConnMan will send probe ARP packets to see if an +IPv4 address is already in use before assigning the address to an interface. +If an address conflict occurs for a statically configured address, an IPv4LL +address will be chosen instead (according to RFC3927). If an address conflict +occurs for an address offered via DHCP, ConnMan send a DHCP DECLINE once and +for the second conflict resort to finding an IPv4LL address. +Default value is false. .SH "EXAMPLE" The following example configuration disables hostname updates and enables ethernet tethering. -- 2.7.4

Hi Christian, On 04/11/2018 04:00 PM, Christian Spielberger wrote: Rename it to acd_host_new() Check coding-style.txt on 'M11: Naming of enums' So this would be enum acd_state { ACD_STATE_PROBE, ACD_STATE_ANNOUNCE, ... }; Note no typedef. struct acd_host Thanks, Danie

Hi Christian, On 04/11/2018 04:00 PM, Christian Spielberger wrote: Move this after the standard headers. Thanks, Daniel

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 08f9ec9..dbef0b3 100644 --- a/include/acd.h +++ b/include/acd.h @@ -24,6 +24,7 @@ #define __CONNMAN_ACD_H #include <stdint.h> +#include <glib.h> #ifdef __cplusplus extern "C" { @@ -35,6 +36,8 @@ typedef struct _acd_host acd_host; acd_host *acdhost_new(int ifindex); +typedef void (*ACDHostEventFunc) (acd_host *acd, gpointer user_data); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index 8d3e121..f1e0c6f 100644 --- a/src/acd.c +++ b/src/acd.c @@ -48,6 +48,15 @@ struct _acd_host { unsigned int conflicts; guint timeout; guint listener_watch; + + ACDHostEventFunc ipv4_available_cb; + gpointer ipv4_available_data; + ACDHostEventFunc ipv4_lost_cb; + gpointer ipv4_lost_data; + ACDHostEventFunc ipv4_conflict_cb; + gpointer ipv4_conflict_data; + ACDHostEventFunc ipv4_max_conflicts_cb; + gpointer ipv4_max_conflicts_data; }; static int start_listening(acd_host *acd); @@ -109,6 +118,11 @@ acd_host *acdhost_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 functions for starting and stopping ACD. --- include/acd.h | 2 ++ src/acd.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/network.c | 3 +++ 3 files changed, 59 insertions(+) diff --git a/include/acd.h b/include/acd.h index dbef0b3..24b4707 100644 --- a/include/acd.h +++ b/include/acd.h @@ -35,6 +35,8 @@ struct _acd_host; typedef struct _acd_host acd_host; acd_host *acdhost_new(int ifindex); +int acdhost_start(acd_host *acd, uint32_t ip); +void acdhost_stop(acd_host *acd); typedef void (*ACDHostEventFunc) (acd_host *acd, gpointer user_data); diff --git a/src/acd.c b/src/acd.c index f1e0c6f..fcc955c 100644 --- a/src/acd.c +++ b/src/acd.c @@ -280,3 +280,57 @@ static gboolean send_announce_packet(gpointer acd_data) NULL); return TRUE; } + +int acdhost_start(acd_host *acd, uint32_t ip) +{ + guint timeout; + int err; + + remove_timeout(acd); + + err = start_listening(acd); + if (err) + return err; + + acd->retry_times = 0; + acd->requested_ip = ip; + + /* First wait a random delay to avoid storm of ARP requests on boot */ + timeout = random_delay_ms(PROBE_WAIT); + acd->state = ACD_PROBE; + + acd->timeout = g_timeout_add_full(G_PRIORITY_HIGH, + timeout, + acd_probe_timeout, + acd, + NULL); + return 0; +} + +void acdhost_stop(acd_host *acd) +{ + + stop_listening(acd); + + remove_timeout(acd); + + if (acd->listener_watch > 0) { + g_source_remove(acd->listener_watch); + acd->listener_watch = 0; + } + + acd->state = ACD_PROBE; + acd->retry_times = 0; + acd->requested_ip = 0; +} + +static gboolean acd_defend_timeout(gpointer acd_data) +{ +} + +static gboolean acd_announce_timeout(gpointer acd_data) +{ +} + +static int acd_recv_arp_packet(acd_host *acd) { +} diff --git a/src/network.c b/src/network.c index 6df1d01..acf4179 100644 --- a/src/network.c +++ b/src/network.c @@ -1537,6 +1537,9 @@ int __connman_network_disconnect(struct connman_network *network) DBG("network %p", network); + if (network->acdhost) + acdhost_stop(network->acdhost); + if (!network->connected && !network->connecting && !network->associating) return -ENOTCONN; -- 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 | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/src/acd.c b/src/acd.c index fcc955c..76dbc77 100644 --- a/src/acd.c +++ b/src/acd.c @@ -27,6 +27,9 @@ #include <unistd.h> #include <stdarg.h> #include <stdio.h> +#include <netinet/if_ether.h> +#include <net/if_arp.h> +#include <string.h> typedef enum _acd_state { ACD_PROBE, @@ -35,6 +38,13 @@ typedef enum _acd_state { ACD_DEFEND, } ACDState; +static const char* acd_state_texts[] = { + "PROBE", + "ANNOUNCE", + "MONITOR", + "DEFEND" +}; + struct _acd_host { ACDState state; int ifindex; @@ -326,10 +336,38 @@ void acdhost_stop(acd_host *acd) static gboolean acd_defend_timeout(gpointer acd_data) { + acd_host *acd = acd_data; + + debug(acd, "back to MONITOR mode"); + acd->timeout = 0; + acd->conflicts = 0; + acd->state = ACD_MONITOR; + + return FALSE; } static gboolean acd_announce_timeout(gpointer acd_data) { + 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_MONITOR; + + if (acd->ipv4_available_cb) + acd->ipv4_available_cb(acd, + acd->ipv4_available_data); + acd->conflicts = 0; + + return FALSE; } static int acd_recv_arp_packet(acd_host *acd) { -- 2.7.4

Adds implementation of acd_recv_arp_packet. This is the main logic for ACD. As long as ACD is activated received ARP packets are checked for potential address conflicts. --- src/acd.c | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) diff --git a/src/acd.c b/src/acd.c index 76dbc77..c796f2f 100644 --- a/src/acd.c +++ b/src/acd.c @@ -371,4 +371,86 @@ static gboolean acd_announce_timeout(gpointer acd_data) } static int acd_recv_arp_packet(acd_host *acd) { + ssize_t cnt; + struct ether_arp arp; + uint32_t ip_n; /* network byte order */ + struct in_addr addr; + int source_conflict; + int target_conflict; + bool probe; + char* confltxt; + uint8_t* mac; + uint8_t* omac; + + memset(&arp, 0, sizeof(arp)); + cnt = read(acd->listener_sockfd, &arp, sizeof(arp)); + if (cnt != sizeof(arp)) + return -EINVAL; + + if (arp.arp_op != htons(ARPOP_REPLY) && + arp.arp_op != htons(ARPOP_REQUEST)) + return -EINVAL; + + if (memcmp(arp.arp_sha, acd->mac_address, ETH_ALEN) == 0) + return 0; + + ip_n = htonl(acd->requested_ip); + source_conflict = !memcmp(arp.arp_spa, &ip_n, sizeof(uint32_t)); + probe = !memcmp(arp.arp_spa, "\0\0\0\0", sizeof(uint32_t)); + target_conflict = probe && + !memcmp(arp.arp_tpa, &ip_n, sizeof(uint32_t)); + + if (!source_conflict && !target_conflict) + return 0; + + acd->conflicts++; + + confltxt = target_conflict ? "target" : "source"; + + addr.s_addr = ip_n; + debug(acd, "IPv4 %d %s conflicts detected for address %s. " + "State=%s", acd->conflicts, confltxt, inet_ntoa(addr), + acd_state_texts[acd->state]); + mac = acd->mac_address; + omac = arp.arp_sha; + debug(acd, "Our MAC: %02x:%02x:%02x:%02x:%02x:%02x" + " other MAC: %02x:%02x:%02x:%02x:%02x:%02x", + mac[0], mac[1], mac[2],mac[3], mac[4], mac[5], + omac[0], omac[1], omac[2],omac[3], omac[4], omac[5]); + + if (acd->state == ACD_MONITOR) { + if (!source_conflict) + return 0; + + acd->state = ACD_DEFEND; + debug(acd, "DEFEND mode conflicts: %d", acd->conflicts); + /* Try to defend with a single announce. */ + send_announce_packet(acd); + return 0; + } else if (acd->state == ACD_DEFEND) { + if (!source_conflict) + return 0; + + debug(acd, "LOST IPv4 address %s", inet_ntoa(addr)); + if (acd->ipv4_lost_cb) + acd->ipv4_lost_cb(acd, acd->ipv4_lost_data); + return 0; + } + + if (acd->conflicts < MAX_CONFLICTS) { + acdhost_stop(acd); + + /* we need a new request_ip */ + if (acd->ipv4_conflict_cb) + acd->ipv4_conflict_cb(acd, acd->ipv4_conflict_data); + } else { + acdhost_stop(acd); + + /* Here we got a lot of conflicts, RFC3927 and RFC5227 state that we + * have to wait RATE_LIMIT_INTERVAL before retrying. */ + if (acd->ipv4_max_conflicts_cb) + acd->ipv4_max_conflicts_cb(acd, acd->ipv4_max_conflicts_data); + } + + return 0; } -- 2.7.4

Adds function acdhost_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 24b4707..dc7e570 100644 --- a/include/acd.h +++ b/include/acd.h @@ -40,6 +40,18 @@ void acdhost_stop(acd_host *acd); typedef void (*ACDHostEventFunc) (acd_host *acd, gpointer user_data); +typedef enum { + ACDHOST_EVENT_IPV4_AVAILABLE, + ACDHOST_EVENT_IPV4_LOST, + ACDHOST_EVENT_IPV4_CONFLICT, + ACDHOST_EVENT_IPV4_MAXCONFLICT, +} ACDHostEvent; + +void acdhost_register_event(acd_host *acd, + ACDHostEvent event, + ACDHostEventFunc func, + gpointer user_data); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index c796f2f..cdd2569 100644 --- a/src/acd.c +++ b/src/acd.c @@ -454,3 +454,32 @@ static int acd_recv_arp_packet(acd_host *acd) { return 0; } + +void acdhost_register_event(acd_host *acd, + ACDHostEvent event, + ACDHostEventFunc func, + gpointer user_data) +{ + switch (event) { + case ACDHOST_EVENT_IPV4_AVAILABLE: + acd->ipv4_available_cb = func; + acd->ipv4_available_data = user_data; + break; + case ACDHOST_EVENT_IPV4_LOST: + acd->ipv4_lost_cb = func; + acd->ipv4_lost_data = user_data; + break; + case ACDHOST_EVENT_IPV4_CONFLICT: + acd->ipv4_conflict_cb = func; + acd->ipv4_conflict_data = user_data; + break; + case ACDHOST_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 empty higher level ACD callback functions. Also adds content of function start_acd which is allocation of ACD structure, registration of callback functions and invoke ACD with a pre-defined IPv4 address. --- src/network.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/src/network.c b/src/network.c index acf4179..e3207da 100644 --- a/src/network.c +++ b/src/network.c @@ -27,6 +27,7 @@ #include <string.h> #include <connman/acd.h> +#include "src/shared/arp.h" #include "connman.h" /* @@ -156,10 +157,28 @@ static void set_configuration(struct connman_network *network, type); } +static void acdhost_ipv4_available(acd_host *acd, gpointer user_data) +{ +} + +static void acdhost_ipv4_lost(acd_host *acd, gpointer user_data) +{ +} + +static void acdhost_ipv4_conflict(acd_host *acd, gpointer user_data) +{ +} + +static void acdhost_ipv4_maxconflict(acd_host *acd, gpointer user_data) +{ +} + static int start_acd(struct connman_network *network) { struct connman_service *service; struct connman_ipconfig *ipconfig_ipv4; + const char* address; + struct in_addr addr; service = connman_service_lookup_from_network(network); if (!service) @@ -171,6 +190,40 @@ static int start_acd(struct connman_network *network) return -EINVAL; } + if (!network->acdhost) { + int index; + + index = __connman_ipconfig_get_index(ipconfig_ipv4); + network->acdhost = acdhost_new(index); + if (!network->acdhost) { + connman_error("Could not create ACD data structure"); + return -EINVAL; + } + + acdhost_register_event(network->acdhost, + ACDHOST_EVENT_IPV4_AVAILABLE, + acdhost_ipv4_available, network); + acdhost_register_event(network->acdhost, + ACDHOST_EVENT_IPV4_LOST, + acdhost_ipv4_lost, network); + acdhost_register_event(network->acdhost, + ACDHOST_EVENT_IPV4_CONFLICT, + acdhost_ipv4_conflict, network); + acdhost_register_event(network->acdhost, + ACDHOST_EVENT_IPV4_MAXCONFLICT, + acdhost_ipv4_maxconflict, network); + } + + address = __connman_ipconfig_get_local(ipconfig_ipv4); + if (!address) + return -EINVAL; + + connman_info("Starting ACD for address %s", address); + if (inet_pton(AF_INET, address, &addr) != 1) + connman_error("Could not convert address %s", address); + + acdhost_start(network->acdhost, htonl(addr.s_addr)); + return 0; } -- 2.7.4

Adds content for acdhost_ipv4_available and acdhost_ipv4_lost which is basically applying (adding) and removing an IPv4 address to ipconfig. --- src/network.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/src/network.c b/src/network.c index e3207da..5b79a2a 100644 --- a/src/network.c +++ b/src/network.c @@ -157,20 +157,98 @@ static void set_configuration(struct connman_network *network, type); } +static int start_acd(struct connman_network *network); + static void acdhost_ipv4_available(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 acdhost_ipv4_lost(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 + * acdhost_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 acdhost_ipv4_conflict(acd_host *acd, gpointer user_data) { + struct connman_network *network = user_data; + + /* Start IPv4LL ACD. */ } static void acdhost_ipv4_maxconflict(acd_host *acd, gpointer user_data) { + struct connman_network *network = user_data; + + 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

When an address conflict is detected for the static IPv4 configuration a free IPv4LL address has to be found. This patch adds functions start_ipv4ll for starting the IPv4LL process, start_ipv4ll_ontimeout for a delayed start of IPv4LL and remove_ipv4ll_timeout for stopping the delayed start. For IPv4LL process again we use the new ACD functions. --- src/network.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/src/network.c b/src/network.c index 5b79a2a..a7d6af4 100644 --- a/src/network.c +++ b/src/network.c @@ -70,6 +70,7 @@ struct connman_network { int router_solicit_count; int router_solicit_refresh_count; acd_host *acdhost; + guint ipv4ll_timeout; struct connman_network_driver *driver; void *driver_data; @@ -159,6 +160,14 @@ static void set_configuration(struct connman_network *network, static int start_acd(struct connman_network *network); +static void remove_ipv4ll_timeout(struct connman_network *network) +{ + if (network->ipv4ll_timeout > 0) { + g_source_remove(network->ipv4ll_timeout); + network->ipv4ll_timeout = 0; + } +} + static void acdhost_ipv4_available(acd_host *acd, gpointer user_data) { struct connman_network *network = user_data; @@ -196,6 +205,51 @@ err: CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL); } +static int start_ipv4ll(struct connman_network *network) +{ + struct connman_service *service; + struct connman_ipconfig *ipconfig_ipv4; + struct in_addr addr; + char *address; + + 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; + } + + /* Apply random IPv4 address. */ + addr.s_addr = htonl(random_ip()); + address = inet_ntoa(addr); + if (!address) { + connman_error("Could not convert IPv4LL random address %u", + addr.s_addr); + return -EINVAL; + } + __connman_ipconfig_set_local(ipconfig_ipv4, address); + + connman_info("Probing IPv4LL address %s", address); + return start_acd(network); +} + +static gboolean start_ipv4ll_ontimeout(gpointer data) +{ + struct connman_network *network = data; + + if (!network) + return FALSE; + + /* Start IPv4LL ACD. */ + if (start_ipv4ll(network) < 0) + connman_error("Could not start IPv4LL. No address will be assigned"); + + return FALSE; +} + static void acdhost_ipv4_lost(acd_host *acd, gpointer user_data) { struct connman_network *network = user_data; @@ -232,6 +286,9 @@ static void acdhost_ipv4_lost(acd_host *acd, gpointer user_data) __connman_network_enable_ipconfig(network, ipconfig_ipv4); } else { /* Start IPv4LL ACD. */ + if (start_ipv4ll(network) < 0) + connman_error("Could not start IPv4LL. " + "No address will be assigned"); } } @@ -240,15 +297,25 @@ static void acdhost_ipv4_conflict(acd_host *acd, gpointer user_data) struct connman_network *network = user_data; /* Start IPv4LL ACD. */ + if (start_ipv4ll(network) < 0) + connman_error("Could not start IPv4LL. " + "No address will be assigned"); } static void acdhost_ipv4_maxconflict(acd_host *acd, gpointer user_data) { struct connman_network *network = user_data; + remove_ipv4ll_timeout(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. */ + network->ipv4ll_timeout = + g_timeout_add_seconds_full(G_PRIORITY_HIGH, + RATE_LIMIT_INTERVAL, + start_ipv4ll_ontimeout, + network, + NULL); } static int start_acd(struct connman_network *network) @@ -258,6 +325,8 @@ static int start_acd(struct connman_network *network) const char* address; struct in_addr addr; + remove_ipv4ll_timeout(network); + service = connman_service_lookup_from_network(network); if (!service) return -EINVAL; @@ -1124,6 +1193,7 @@ struct connman_network *connman_network_create(const char *identifier, network->type = type; network->identifier = ident; network->acdhost = NULL; + network->ipv4ll_timeout = 0; network_list = g_slist_prepend(network_list, network); @@ -1668,6 +1738,7 @@ int __connman_network_disconnect(struct connman_network *network) DBG("network %p", network); + remove_ipv4ll_timeout(network); if (network->acdhost) acdhost_stop(network->acdhost); -- 2.7.4

Adds a dbus property called LastAddressConflict and a signal to notify if the property changes. --- doc/service-api.txt | 32 ++++++++++++++++++++ include/acd.h | 5 +++- include/network.h | 4 +++ 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 b5b4fab..ac597bc 100644 --- a/doc/service-api.txt +++ b/doc/service-api.txt @@ -513,3 +513,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 dc7e570..69d740d 100644 --- a/include/acd.h +++ b/include/acd.h @@ -25,6 +25,7 @@ #include <stdint.h> #include <glib.h> +#include <gdbus.h> #ifdef __cplusplus extern "C" { @@ -34,7 +35,7 @@ struct _acd_host; typedef struct _acd_host acd_host; -acd_host *acdhost_new(int ifindex); +acd_host *acdhost_new(int ifindex, const char* path); int acdhost_start(acd_host *acd, uint32_t ip); void acdhost_stop(acd_host *acd); @@ -52,6 +53,8 @@ void acdhost_register_event(acd_host *acd, ACDHostEventFunc func, gpointer user_data); +void acdhost_append_dbus_property(acd_host *acd, DBusMessageIter *dict); + #ifdef __cplusplus } #endif diff --git a/include/network.h b/include/network.h index 4fc20c1..22463cc 100644 --- a/include/network.h +++ b/include/network.h @@ -24,6 +24,7 @@ #include <stdbool.h> #include <stdint.h> +#include <dbus/dbus.h> #include <connman/device.h> #include <connman/ipconfig.h> @@ -162,6 +163,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 cdd2569..f10e3d7 100644 --- a/src/acd.c +++ b/src/acd.c @@ -21,6 +21,7 @@ #include <connman/log.h> #include <connman/inet.h> #include <glib.h> +#include <connman/dbus.h> #include "src/shared/arp.h" #include "src/shared/random.h" #include <errno.h> @@ -52,6 +53,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; @@ -80,6 +88,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 DBus property */ +static void report_conflict(acd_host *acd); + static void debug(acd_host *acd, const char *format, ...) { char str[256]; @@ -93,7 +104,7 @@ static void debug(acd_host *acd, const char *format, ...) va_end(ap); } -acd_host *acdhost_new(int ifindex) +acd_host *acdhost_new(int ifindex, const char *path) { acd_host *acd; @@ -133,6 +144,12 @@ acd_host *acdhost_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: @@ -346,6 +363,11 @@ static gboolean acd_defend_timeout(gpointer acd_data) return FALSE; } +static bool is_link_local(uint32_t ip) +{ + return (ip & LINKLOCAL_ADDR) == LINKLOCAL_ADDR; +} + static gboolean acd_announce_timeout(gpointer acd_data) { acd_host *acd = acd_data; @@ -362,6 +384,11 @@ static gboolean acd_announce_timeout(gpointer acd_data) debug(acd, "switching to monitor mode"); acd->state = ACD_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); @@ -438,6 +465,14 @@ static int acd_recv_arp_packet(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); + } + acdhost_stop(acd); /* we need a new request_ip */ @@ -483,3 +518,50 @@ void acdhost_register_event(acd_host *acd, } } +static void append_ac_mac(DBusMessageIter *iter, void *user_data) +{ + 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) +{ + 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) +{ + 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 acdhost_append_dbus_property(acd_host *acd, DBusMessageIter *dict) +{ + connman_dbus_dict_append_dict(dict, "LastAddressConflict", + append_ac_property, acd); +} + +static void report_conflict(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 a7d6af4..399a0cd 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->acdhost) + return; + + acdhost_append_dbus_property(network->acdhost, dict); +} + static int start_acd(struct connman_network *network); static void remove_ipv4ll_timeout(struct connman_network *network) @@ -341,7 +350,8 @@ static int start_acd(struct connman_network *network) int index; index = __connman_ipconfig_get_index(ipconfig_ipv4); - network->acdhost = acdhost_new(index); + network->acdhost = acdhost_new(index, + connman_service_get_dbuspath(service)); if (!network->acdhost) { connman_error("Could not create ACD data structure"); return -EINVAL; diff --git a/src/service.c b/src/service.c index ab5b2c6..b16555d 100644 --- a/src/service.c +++ b/src/service.c @@ -2524,6 +2524,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, @@ -2655,6 +2658,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

Add sending of DHCP decline in case of address conflict for a DHCP lease. --- gdhcp/client.c | 29 ++++++++++++++++++++++++++++- gdhcp/gdhcp.h | 1 + src/connman.h | 1 + src/dhcp.c | 24 ++++++++++++++++++++++++ 4 files changed, 54 insertions(+), 1 deletion(-) diff --git a/gdhcp/client.c b/gdhcp/client.c index 9542eec..d405424 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -66,6 +66,7 @@ typedef enum _dhcp_client_state { REBOOTING, REQUESTING, BOUND, + DECLINED, RENEWING, REBINDING, RELEASED, @@ -471,6 +472,30 @@ static int send_discover(GDHCPClient *dhcp_client, uint32_t requested) dhcp_client->retry_times % 2); } +int g_dhcp_client_decline(GDHCPClient *dhcp_client, uint32_t requested) +{ + struct dhcp_packet packet; + + dhcp_client->state = DECLINED; + dhcp_client->retry_times = 0; + + debug(dhcp_client, "sending DHCP decline"); + + init_packet(dhcp_client, &packet, DHCPDECLINE); + + packet.xid = dhcp_client->xid; + packet.secs = dhcp_attempt_secs(dhcp_client); + + if (requested) + dhcp_add_option_uint32(&packet, DHCP_REQUESTED_IP, requested); + + add_send_options(dhcp_client, &packet); + + return dhcp_send_raw_packet(&packet, INADDR_ANY, CLIENT_PORT, + INADDR_BROADCAST, SERVER_PORT, MAC_BCAST_ADDR, + dhcp_client->ifindex, true); +} + static int send_request(GDHCPClient *dhcp_client) { struct dhcp_packet packet; @@ -2688,6 +2713,7 @@ int g_dhcp_client_start(GDHCPClient *dhcp_client, const char *last_address) int re; uint32_t addr; uint64_t rand; + ClientState oldstate = dhcp_client->state; remove_timeouts(dhcp_client); @@ -2803,7 +2829,7 @@ int g_dhcp_client_start(GDHCPClient *dhcp_client, const char *last_address) dhcp_client->start = time(NULL); } - if (!last_address) { + if (!last_address || oldstate == DECLINED) { addr = 0; } else { addr = ntohl(inet_addr(last_address)); @@ -3003,6 +3029,7 @@ char *g_dhcp_client_get_netmask(GDHCPClient *dhcp_client) case REBOOTING: case REQUESTING: case RELEASED: + case DECLINED: case IPV4LL_PROBE: case IPV4LL_ANNOUNCE: case INFORMATION_REQ: diff --git a/gdhcp/gdhcp.h b/gdhcp/gdhcp.h index 1285431..e3b0131 100644 --- a/gdhcp/gdhcp.h +++ b/gdhcp/gdhcp.h @@ -134,6 +134,7 @@ GDHCPClient *g_dhcp_client_new(GDHCPType type, int index, int g_dhcp_client_start(GDHCPClient *client, const char *last_address); void g_dhcp_client_stop(GDHCPClient *client); +int g_dhcp_client_decline(GDHCPClient *client, uint32_t requested); GDHCPClient *g_dhcp_client_ref(GDHCPClient *client); void g_dhcp_client_unref(GDHCPClient *client); diff --git a/src/connman.h b/src/connman.h index 6d1831b..303fddd 100644 --- a/src/connman.h +++ b/src/connman.h @@ -466,6 +466,7 @@ int __connman_dhcp_start(struct connman_ipconfig *ipconfig, struct connman_network *network, dhcp_cb callback, gpointer user_data); void __connman_dhcp_stop(struct connman_ipconfig *ipconfig); +void __connman_dhcp_decline(struct connman_ipconfig *ipconfig); int __connman_dhcp_init(void); void __connman_dhcp_cleanup(void); int __connman_dhcpv6_init(void); diff --git a/src/dhcp.c b/src/dhcp.c index 615ad4a..75e6d85 100644 --- a/src/dhcp.c +++ b/src/dhcp.c @@ -746,6 +746,30 @@ void __connman_dhcp_stop(struct connman_ipconfig *ipconfig) } } +void __connman_dhcp_decline(struct connman_ipconfig *ipconfig) +{ + struct connman_dhcp *dhcp; + const char *address; + struct in_addr addr; + + DBG("ipconfig_table %p ipconfig %p", ipconfig_table, ipconfig); + + if (!ipconfig_table) + return; + + dhcp = g_hash_table_lookup(ipconfig_table, ipconfig); + if (dhcp) { + address = __connman_ipconfig_get_local(ipconfig); + if (!address) + return; + + if (inet_pton(AF_INET, address, &addr) != 1) + connman_error("Could not convert address %s", address); + + g_dhcp_client_decline(dhcp->dhcp_client, htonl(addr.s_addr)); + } +} + int __connman_dhcp_init(void) { DBG(""); -- 2.7.4

This is necessary to decide if DHCP can be tried again. --- include/acd.h | 2 ++ src/acd.c | 5 +++++ 2 files changed, 7 insertions(+) diff --git a/include/acd.h b/include/acd.h index 69d740d..b4ecfc5 100644 --- a/include/acd.h +++ b/include/acd.h @@ -55,6 +55,8 @@ void acdhost_register_event(acd_host *acd, void acdhost_append_dbus_property(acd_host *acd, DBusMessageIter *dict); +unsigned int acdhost_get_conflicts_count(acd_host *acd); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index f10e3d7..9c8ed8f 100644 --- a/src/acd.c +++ b/src/acd.c @@ -565,3 +565,8 @@ static void report_conflict(acd_host *acd) connman_dbus_property_changed_dict(acd->path, CONNMAN_SERVICE_INTERFACE, "LastAddressConflict", append_ac_property, acd); } + +unsigned int acdhost_get_conflicts_count(acd_host *acd) +{ + return acd->conflicts; +} -- 2.7.4

We also want to report an address conflict if we loose our IPv4 address because another host is using the same one. --- src/acd.c | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/src/acd.c b/src/acd.c index 9c8ed8f..4401e24 100644 --- a/src/acd.c +++ b/src/acd.c @@ -89,7 +89,7 @@ static gboolean acd_announce_timeout(gpointer acd_data); static gboolean acd_defend_timeout(gpointer acd_data); /* for DBus property */ -static void report_conflict(acd_host *acd); +static void report_conflict(acd_host *acd, const struct ether_arp* arp); static void debug(acd_host *acd, const char *format, ...) { @@ -384,10 +384,8 @@ static gboolean acd_announce_timeout(gpointer acd_data) debug(acd, "switching to monitor mode"); acd->state = ACD_MONITOR; - if (!acd->ac_resolved && !is_link_local(acd->requested_ip)) { - acd->ac_resolved = true; - report_conflict(acd); - } + if (!acd->ac_resolved && !is_link_local(acd->requested_ip)) + report_conflict(acd, NULL); if (acd->ipv4_available_cb) acd->ipv4_available_cb(acd, @@ -459,19 +457,17 @@ static int acd_recv_arp_packet(acd_host *acd) { return 0; debug(acd, "LOST IPv4 address %s", inet_ntoa(addr)); + if (!is_link_local(acd->requested_ip)) + report_conflict(acd, &arp); + if (acd->ipv4_lost_cb) acd->ipv4_lost_cb(acd, acd->ipv4_lost_data); return 0; } 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); - } + if (!is_link_local(acd->requested_ip)) + report_conflict(acd, &arp); acdhost_stop(acd); @@ -560,8 +556,17 @@ void acdhost_append_dbus_property(acd_host *acd, DBusMessageIter *dict) append_ac_property, acd); } -static void report_conflict(acd_host *acd) +static void report_conflict(acd_host *acd, const struct ether_arp* arp) { + if (arp) { + 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; + } else { + acd->ac_resolved = true; + } + connman_dbus_property_changed_dict(acd->path, CONNMAN_SERVICE_INTERFACE, "LastAddressConflict", append_ac_property, acd); } -- 2.7.4