From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index b7cc1348..d57346d7 100644 --- a/.gitignore +++ b/.gitignore @@ -82,3 +82,5 @@ vpn/connman-vpnd vpn/connman-vpn-dbus.conf vpn/connman-vpn.service vpn/net.connman.vpn.service +*.swp +tags -- 2.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- Makefile.am | 8 +++--- gdhcp/client.c | 7 ++--- gdhcp/ipv4ll.c | 13 ++------- gdhcp/ipv4ll.h | 1 - src/shared/random.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/shared/random.h | 30 +++++++++++++++++++++ 6 files changed, 119 insertions(+), 18 deletions(-) create mode 100644 src/shared/random.c create mode 100644 src/shared/random.h diff --git a/Makefile.am b/Makefile.am index 97f1c87d..21ef474a 100644 --- a/Makefile.am +++ b/Makefile.am @@ -48,7 +48,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/random.h src/shared/random.c if DATAFILES @@ -350,10 +351,11 @@ tools_wpad_test_LDADD = @GLIB_LIBS@ -lresolv tools_stats_tool_LDADD = @GLIB_LIBS@ -tools_dhcp_test_SOURCES = $(gdhcp_sources) tools/dhcp-test.c +tools_dhcp_test_SOURCES = $(gdhcp_sources) $(shared_sources) tools/dhcp-test.c tools_dhcp_test_LDADD = @GLIB_LIBS@ -tools_dhcp_server_test_SOURCES = $(gdhcp_sources) tools/dhcp-server-test.c +tools_dhcp_server_test_SOURCES = $(gdhcp_sources) $(shared_sources) \ + tools/dhcp-server-test.c tools_dhcp_server_test_LDADD = @GLIB_LIBS@ tools_dbus_test_SOURCES = tools/dbus-test.c diff --git a/gdhcp/client.c b/gdhcp/client.c index 67357782..495e9721 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -43,6 +43,7 @@ #include <glib.h> +#include "shared/random.h" #include "gdhcp.h" #include "common.h" #include "ipv4ll.h" @@ -556,7 +557,7 @@ static gboolean send_probe_packet(gpointer dhcp_data) if (dhcp_client->retry_times < PROBE_NUM) { /*add a random timeout in range of PROBE_MIN to PROBE_MAX*/ - timeout = ipv4ll_random_delay_ms(PROBE_MAX-PROBE_MIN); + timeout = random_delay_ms(PROBE_MAX-PROBE_MIN); timeout += PROBE_MIN*1000; } else timeout = (ANNOUNCE_WAIT * 1000); @@ -1376,7 +1377,7 @@ static void ipv4ll_start(GDHCPClient *dhcp_client) dhcp_client->requested_ip = ipv4ll_random_ip(); /*first wait a random delay to avoid storm of arp request on boot*/ - timeout = ipv4ll_random_delay_ms(PROBE_WAIT); + timeout = random_delay_ms(PROBE_WAIT); dhcp_client->retry_times++; dhcp_client->timeout = g_timeout_add_full(G_PRIORITY_HIGH, @@ -1466,7 +1467,7 @@ static int ipv4ll_recv_arp_packet(GDHCPClient *dhcp_client) dhcp_client->retry_times++; dhcp_client->timeout = g_timeout_add_full(G_PRIORITY_HIGH, - ipv4ll_random_delay_ms(PROBE_WAIT), + random_delay_ms(PROBE_WAIT), send_probe_packet, dhcp_client, NULL); diff --git a/gdhcp/ipv4ll.c b/gdhcp/ipv4ll.c index d9001987..4433337c 100644 --- a/gdhcp/ipv4ll.c +++ b/gdhcp/ipv4ll.c @@ -33,6 +33,8 @@ #include <arpa/inet.h> #include <glib.h> + +#include "shared/random.h" #include "ipv4ll.h" #include "common.h" @@ -52,17 +54,6 @@ uint32_t ipv4ll_random_ip(void) return ((LINKLOCAL_ADDR + 0x0100) + tmp); } -/** - * Return a random delay in range of zero to secs*1000 - */ -guint ipv4ll_random_delay_ms(guint secs) -{ - uint64_t rand; - - dhcp_get_random(&rand); - return rand % (secs * 1000); -} - int ipv4ll_send_arp_packet(uint8_t* source_eth, uint32_t source_ip, uint32_t target_ip, int ifindex) { diff --git a/gdhcp/ipv4ll.h b/gdhcp/ipv4ll.h index bee8138a..bf8c3636 100644 --- a/gdhcp/ipv4ll.h +++ b/gdhcp/ipv4ll.h @@ -44,7 +44,6 @@ extern "C" { #define DEFEND_INTERVAL 10 uint32_t ipv4ll_random_ip(void); -guint ipv4ll_random_delay_ms(guint secs); 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); diff --git a/src/shared/random.c b/src/shared/random.c new file mode 100644 index 00000000..85248c6c --- /dev/null +++ b/src/shared/random.c @@ -0,0 +1,78 @@ +/* + * + * Random number generation + * + * 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 <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <errno.h> +#include <stdlib.h> +#include <unistd.h> + +#include "shared/random.h" + +#define URANDOM "/dev/urandom" + +static int random_fd = -1; + +int 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 cleanup_random(void) +{ + if (random_fd < 0) + return; + + close(random_fd); + random_fd = -1; +} + +/** + * Return a random delay in range of zero to secs*1000 + */ +unsigned int random_delay_ms(unsigned int secs) +{ + uint64_t rand; + + get_random(&rand); + return rand % (secs * 1000); +} + diff --git a/src/shared/random.h b/src/shared/random.h new file mode 100644 index 00000000..10614b14 --- /dev/null +++ b/src/shared/random.h @@ -0,0 +1,30 @@ +/* + * + * Random number generation library + * + * 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_RANDOM_H +#define SHARED_RANDOM_H + +#include <stdint.h> + +int get_random(uint64_t *val); +void cleanup_random(void); +unsigned int random_delay_ms(unsigned int secs); + +#endif -- 2.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- Makefile.am | 3 +- gdhcp/client.c | 7 ++-- gdhcp/ipv4ll.c | 73 +------------------------------------ gdhcp/ipv4ll.h | 15 -------- src/shared/arp.c | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/shared/arp.h | 41 +++++++++++++++++++++ 6 files changed, 156 insertions(+), 91 deletions(-) create mode 100644 src/shared/arp.c create mode 100644 src/shared/arp.h diff --git a/Makefile.am b/Makefile.am index 21ef474a..23c5171c 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 1c988c0c..a52e8197 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -44,6 +44,7 @@ #include <glib.h> #include "shared/random.h" +#include "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 c78a7011..eebf8938 100644 --- a/gdhcp/ipv4ll.c +++ b/gdhcp/ipv4ll.c @@ -35,6 +35,7 @@ #include <glib.h> #include "shared/random.h" +#include "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 3f5edfa8..315ca3db 100644 --- a/gdhcp/ipv4ll.h +++ b/gdhcp/ipv4ll.h @@ -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 00000000..d436eaa9 --- /dev/null +++ b/src/shared/arp.c @@ -0,0 +1,108 @@ +/* + * + * ARP library + * + * 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 "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 00000000..8917f3fd --- /dev/null +++ b/src/shared/arp.h @@ -0,0 +1,41 @@ +/* + * ARP library + * + * 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.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; and drop gdhcp/ipv4ll.h|.c --- Makefile.am | 2 +- gdhcp/client.c | 5 ++--- gdhcp/ipv4ll.c | 57 -------------------------------------------------------- gdhcp/ipv4ll.h | 39 -------------------------------------- src/shared/arp.c | 18 ++++++++++++++++++ src/shared/arp.h | 5 +++++ 6 files changed, 26 insertions(+), 100 deletions(-) delete mode 100644 gdhcp/ipv4ll.c delete mode 100644 gdhcp/ipv4ll.h diff --git a/Makefile.am b/Makefile.am index 23c5171c..aa58691c 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 05c322cc..320b7819 100644 --- a/gdhcp/client.c +++ b/gdhcp/client.c @@ -47,7 +47,6 @@ #include "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.c b/gdhcp/ipv4ll.c deleted file mode 100644 index eebf8938..00000000 --- a/gdhcp/ipv4ll.c +++ /dev/null @@ -1,57 +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 - * - */ -#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 <arpa/inet.h> - -#include <glib.h> - -#include "shared/random.h" -#include "shared/arp.h" -#include "ipv4ll.h" -#include "common.h" - -/** - * Return a random link local IP (in host byte order) - */ -uint32_t ipv4ll_random_ip(void) -{ - unsigned tmp; - uint64_t rand; - - do { - get_random(&rand); - tmp = rand; - tmp = tmp & IN_CLASSB_HOST; - } while (tmp > (IN_CLASSB_HOST - 0x0200)); - return ((LINKLOCAL_ADDR + 0x0100) + tmp); -} - diff --git a/gdhcp/ipv4ll.h b/gdhcp/ipv4ll.h deleted file mode 100644 index 315ca3db..00000000 --- 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 985dd20d..c8fd0c54 100644 --- a/src/shared/arp.c +++ b/src/shared/arp.c @@ -38,6 +38,7 @@ #include <arpa/inet.h> #include "shared/arp.h" +#include "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 6df9ba0a..d7f885c8 100644 --- a/src/shared/arp.h +++ b/src/shared/arp.h @@ -34,10 +34,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.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- include/inet.h | 1 + src/inet.c | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/include/inet.h b/include/inet.h index 6482934a..9c1918f3 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 dcd1ab24..0ef979b3 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 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.16.2

Hi, Nitpicking: We have almost consistently pattern of the copyright header. Please follow the style. In this example the first line should be /* * * Connection Manager * [ bla bla ] */ And then you can add comments such as the "Address Conflict Detection (RFC 5227)" part. Thanks, Daniel

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- include/acd.h | 4 ++++ src/acd.c | 70 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+) diff --git a/include/acd.h b/include/acd.h index 6d98c289..1fb354a9 100644 --- a/include/acd.h +++ b/include/acd.h @@ -21,6 +21,8 @@ #ifndef __CONNMAN_ACD_H #define __CONNMAN_ACD_H +#include <stdint.h> + #ifdef __cplusplus extern "C" { #endif @@ -29,6 +31,8 @@ struct _ACDHost; typedef struct _ACDHost ACDHost; +ACDHost *acdhost_new(int ifindex); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index 6db816f2..19384515 100644 --- a/src/acd.c +++ b/src/acd.c @@ -14,3 +14,73 @@ * */ +#include <connman/acd.h> +#include <connman/log.h> +#include <connman/inet.h> +#include <shared/arp.h> +#include <glib.h> + +typedef enum _acd_state { + ACD_PROBE, + ACD_ANNOUNCE, + ACD_MONITOR, + ACD_DEFEND, +} ACDState; + +struct _ACDHost { + ACDState 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; +}; + +ACDHost *acdhost_new(int ifindex) +{ + ACDHost *acd; + + if (ifindex < 0) { + connman_error("Invalid interface index %d", ifindex); + return NULL; + } + + acd = g_try_new0(ACDHost, 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; + } + + 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.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- src/acd.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/src/acd.c b/src/acd.c index a19edbe4..78b8a582 100644 --- a/src/acd.c +++ b/src/acd.c @@ -18,6 +18,7 @@ #include <connman/log.h> #include <connman/inet.h> #include <shared/arp.h> +#include <shared/random.h> #include <glib.h> #include <stdio.h> #include <errno.h> @@ -51,6 +52,8 @@ static void stop_listening(ACDHost *acd); static gboolean acd_listener_event(GIOChannel *channel, GIOCondition condition, gpointer acd_data); static int acd_recv_arp_packet(ACDHost *acd); +static void send_probe_packet(gpointer acd_data); +static gboolean acd_probe_timeout(gpointer acd_data); static void debug(ACDHost *acd, const char *format, ...) { @@ -173,3 +176,51 @@ static gboolean acd_listener_event(GIOChannel *channel, GIOCondition condition, return TRUE; } +static void send_probe_packet(gpointer acd_data) +{ + guint timeout; + ACDHost *acd = acd_data; + + debug(acd, "sending ARP probe request"); + if (acd->retry_times == 1) { + acd->state = ACD_PROBE; + start_listening(acd); + } + send_arp_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 = 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) +{ + ACDHost *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_ANNOUNCE; + acd->retry_times = 1; + + send_announce_packet(acd); + return FALSE; + } + + acd->retry_times++; + send_probe_packet(acd); + + return FALSE; +} + -- 2.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- include/acd.h | 3 +++ src/acd.c | 15 ++++++++++++++- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/include/acd.h b/include/acd.h index 1fb354a9..1f940f2b 100644 --- a/include/acd.h +++ b/include/acd.h @@ -22,6 +22,7 @@ #define __CONNMAN_ACD_H #include <stdint.h> +#include <glib.h> #ifdef __cplusplus extern "C" { @@ -33,6 +34,8 @@ typedef struct _ACDHost ACDHost; ACDHost *acdhost_new(int ifindex); +typedef void (*ACDHostEventFunc) (ACDHost *acd, gpointer user_data); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index dcd544c0..bd8901de 100644 --- a/src/acd.c +++ b/src/acd.c @@ -19,7 +19,6 @@ #include <connman/inet.h> #include <shared/arp.h> #include <shared/random.h> -#include <glib.h> #include <stdio.h> #include <errno.h> #include <unistd.h> @@ -45,6 +44,15 @@ struct _ACDHost { 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(ACDHost *acd); @@ -106,6 +114,11 @@ ACDHost *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.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- src/acd.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/src/acd.c b/src/acd.c index bcb49620..2963d44e 100644 --- a/src/acd.c +++ b/src/acd.c @@ -23,6 +23,9 @@ #include <errno.h> #include <unistd.h> #include <stdarg.h> +#include <netinet/if_ether.h> +#include <net/if_arp.h> +#include <string.h> typedef enum _acd_state { ACD_PROBE, @@ -31,6 +34,13 @@ typedef enum _acd_state { ACD_DEFEND, } ACDState; +static const char* acd_state_texts[] = { + "PROBE", + "ANNOUNCE", + "MONITOR", + "DEFEND" +}; + struct _ACDHost { ACDState state; int ifindex; @@ -322,10 +332,37 @@ void acdhost_stop(ACDHost *acd) static gboolean acd_defend_timeout(gpointer acd_data) { + ACDHost *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) { + ACDHost *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(ACDHost *acd) { -- 2.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- include/acd.h | 12 ++++++++++++ src/acd.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/include/acd.h b/include/acd.h index aabe9b25..deaea130 100644 --- a/include/acd.h +++ b/include/acd.h @@ -38,6 +38,18 @@ void acdhost_stop(ACDHost *acd); typedef void (*ACDHostEventFunc) (ACDHost *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(ACDHost *acd, + ACDHostEvent event, + ACDHostEventFunc func, + gpointer user_data); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index aabbedd5..f3a1c759 100644 --- a/src/acd.c +++ b/src/acd.c @@ -449,3 +449,32 @@ static int acd_recv_arp_packet(ACDHost *acd) { return 0; } + +void acdhost_register_event(ACDHost *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("Unknown %s event %d.", __FUNCTION__, event); + break; + } +} + -- 2.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- src/service.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/src/service.c b/src/service.c index 57aa9359..14e9a456 100644 --- a/src/service.c +++ b/src/service.c @@ -7501,19 +7501,90 @@ void __connman_service_cleanup(void) } static void acdhost_ipv4_available(ACDHost *acd, gpointer user_data) +{ + struct connman_service *service = user_data; + int err; + + if (!service) + return; + + if (!service->ipconfig_ipv4) { + connman_error("Service has no IPv4 configuration"); + return; + } + + err = __connman_ipconfig_address_add(service->ipconfig_ipv4); + if (err < 0) + goto err; + + err = __connman_ipconfig_gateway_add(service->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 int service_start_ipv4ll(struct connman_service *service) { } static void acdhost_ipv4_lost(ACDHost *acd, gpointer user_data) { + struct connman_service *service = user_data; + struct connman_network *network; + enum connman_ipconfig_type type; + enum connman_ipconfig_method method; + + if (!service) + return; + + if (!service->ipconfig_ipv4) + return; + + type = __connman_ipconfig_get_config_type(service->ipconfig_ipv4); + if (type != CONNMAN_IPCONFIG_TYPE_IPV4) + return; + + __connman_ipconfig_address_remove(service->ipconfig_ipv4); + + method = __connman_ipconfig_get_method(service->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, service->ipconfig_ipv4); + } else { + /* Start IPv4LL ACD. */ + if (service_start_ipv4ll(service) < 0) + connman_error("Could not start IPv4LL. " + "No address will be assigned"); + } } static void acdhost_ipv4_conflict(ACDHost *acd, gpointer user_data) { + struct connman_service *service = user_data; + + /* Start IPv4LL ACD. */ + if (service_start_ipv4ll(service) < 0) + connman_error("Could not start IPv4LL. " + "No address will be assigned"); } static void acdhost_ipv4_maxconflict(ACDHost *acd, gpointer user_data) { + struct connman_service *service = 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. */ } int connman_service_start_acd(struct connman_service *service) -- 2.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- include/acd.h | 5 +++- src/acd.c | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- src/service.c | 5 +++- 3 files changed, 93 insertions(+), 3 deletions(-) diff --git a/include/acd.h b/include/acd.h index deaea130..4f483c86 100644 --- a/include/acd.h +++ b/include/acd.h @@ -23,6 +23,7 @@ #include <stdint.h> #include <glib.h> +#include <gdbus.h> #ifdef __cplusplus extern "C" { @@ -32,7 +33,7 @@ struct _ACDHost; typedef struct _ACDHost ACDHost; -ACDHost *acdhost_new(int ifindex); +ACDHost *acdhost_new(int ifindex, const char* path); int acdhost_start(ACDHost *acd, uint32_t ip); void acdhost_stop(ACDHost *acd); @@ -50,6 +51,8 @@ void acdhost_register_event(ACDHost *acd, ACDHostEventFunc func, gpointer user_data); +void acdhost_append_dbus_property(ACDHost *acd, DBusMessageIter *dict); + #ifdef __cplusplus } #endif diff --git a/src/acd.c b/src/acd.c index f3a1c759..9b114775 100644 --- a/src/acd.c +++ b/src/acd.c @@ -17,8 +17,10 @@ #include <connman/acd.h> #include <connman/log.h> #include <connman/inet.h> +#include <connman/dbus.h> #include <shared/arp.h> #include <shared/random.h> +#include <glib.h> #include <stdio.h> #include <errno.h> #include <unistd.h> @@ -48,6 +50,13 @@ struct _ACDHost { 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; @@ -76,6 +85,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(ACDHost *acd); + static void debug(ACDHost *acd, const char *format, ...) { char str[256]; @@ -89,7 +101,7 @@ static void debug(ACDHost *acd, const char *format, ...) va_end(ap); } -ACDHost *acdhost_new(int ifindex) +ACDHost *acdhost_new(int ifindex, const char *path) { ACDHost *acd; @@ -129,6 +141,12 @@ ACDHost *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: @@ -342,6 +360,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) { ACDHost *acd = acd_data; @@ -358,10 +381,16 @@ 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); acd->conflicts = 0; + return FALSE; } @@ -433,6 +462,14 @@ static int acd_recv_arp_packet(ACDHost *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 */ @@ -478,3 +515,50 @@ void acdhost_register_event(ACDHost *acd, } } +static void append_ac_mac(DBusMessageIter *iter, void *user_data) +{ + ACDHost *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) +{ + ACDHost *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) +{ + ACDHost *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(ACDHost *acd, DBusMessageIter *dict) +{ + connman_dbus_dict_append_dict(dict, "LastAddressConflict", + append_ac_property, acd); +} + +static void report_conflict(ACDHost *acd) +{ + connman_dbus_property_changed_dict(acd->path, CONNMAN_SERVICE_INTERFACE, + "LastAddressConflict", append_ac_property, acd); +} diff --git a/src/service.c b/src/service.c index d8c0e5e7..bef2d88d 100644 --- a/src/service.c +++ b/src/service.c @@ -2529,6 +2529,9 @@ static void append_properties(DBusMessageIter *dict, dbus_bool_t limited, connman_dbus_dict_append_dict(dict, "Provider", append_provider, service); + + if (service->acdhost) + acdhost_append_dbus_property(service->acdhost, dict); } static void append_struct_service(DBusMessageIter *iter, @@ -7658,7 +7661,7 @@ int connman_service_start_acd(struct connman_service *service) int index; index = __connman_ipconfig_get_index(service->ipconfig_ipv4); - service->acdhost = acdhost_new(index); + service->acdhost = acdhost_new(index, service->path); if (!service->acdhost) { connman_error("Could not create ACD data structure"); return -EINVAL; -- 2.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- include/network.h | 2 ++ src/network.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/include/network.h b/include/network.h index 4fc20c1c..68925389 100644 --- a/include/network.h +++ b/include/network.h @@ -100,6 +100,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 3306e4ed..cec5af48 100644 --- a/src/network.c +++ b/src/network.c @@ -68,6 +68,7 @@ struct connman_network { int index; int router_solicit_count; int router_solicit_refresh_count; + guint dhcp_timeout; struct connman_network_driver *driver; void *driver_data; @@ -266,6 +267,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; @@ -273,6 +282,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); @@ -288,6 +298,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) { @@ -689,6 +737,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; } @@ -975,6 +1024,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; @@ -1562,6 +1613,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.16.2

From: Christian Spielberger <christian.spielberger(a)gmail.com&gt; --- src/service.c | 29 +++++++++++++++++++++++++---- 1 file changed, 25 insertions(+), 4 deletions(-) diff --git a/src/service.c b/src/service.c index bef2d88d..66d5d1a0 100644 --- a/src/service.c +++ b/src/service.c @@ -40,6 +40,7 @@ #include "connman.h" #define CONNECT_TIMEOUT 120 +#define DHCP_RETRY_TIMEOUT 10 static DBusConnection *connection = NULL; @@ -7620,11 +7621,31 @@ static void acdhost_ipv4_lost(ACDHost *acd, gpointer user_data) static void acdhost_ipv4_conflict(ACDHost *acd, gpointer user_data) { struct connman_service *service = user_data; + struct connman_network *network; + enum connman_ipconfig_method method; - /* Start IPv4LL ACD. */ - if (service_start_ipv4ll(service) < 0) - connman_error("Could not start IPv4LL. " - "No address will be assigned"); + method = __connman_ipconfig_get_method(service->ipconfig_ipv4); + + connman_info("%s conflict counts=%u", __FUNCTION__, + acdhost_get_conflicts_count(acd)); + if (method == CONNMAN_IPCONFIG_METHOD_DHCP && + acdhost_get_conflicts_count(acd) < 2) { + connman_info("%s Sending DHCP decline", __FUNCTION__); + __connman_dhcp_decline(service->ipconfig_ipv4); + + network = __connman_service_get_network(service); + connman_network_set_connected_dhcp_later(network, DHCP_RETRY_TIMEOUT); + __connman_ipconfig_set_local(service->ipconfig_ipv4, NULL); + } else { + if (method == CONNMAN_IPCONFIG_METHOD_DHCP) { + __connman_ipconfig_set_method(service->ipconfig_ipv4, + CONNMAN_IPCONFIG_METHOD_AUTO); + } + /* Start IPv4LL ACD. */ + if (service_start_ipv4ll(service) < 0) + connman_error("Could not start IPv4LL. " + "No address will be assigned"); + } } static void acdhost_ipv4_maxconflict(ACDHost *acd, gpointer user_data) -- 2.16.2