2014-02-28 16:10:20 +01:00
|
|
|
/***
|
|
|
|
This file is part of systemd.
|
|
|
|
|
|
|
|
Copyright (C) 2014 Axis Communications AB. All rights reserved.
|
2015-08-20 11:26:57 +02:00
|
|
|
Copyright (C) 2015 Tom Gundersen
|
2014-02-28 16:10:20 +01:00
|
|
|
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
systemd 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
|
|
|
|
Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <arpa/inet.h>
|
2014-02-28 16:10:20 +01:00
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "sd-ipv4acd.h"
|
|
|
|
#include "sd-ipv4ll.h"
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2015-10-01 21:51:49 +02:00
|
|
|
#include "in-addr-util.h"
|
2014-02-28 16:10:20 +01:00
|
|
|
#include "list.h"
|
2015-04-10 22:27:10 +02:00
|
|
|
#include "random-util.h"
|
2015-08-21 12:50:31 +02:00
|
|
|
#include "refcnt.h"
|
|
|
|
#include "siphash24.h"
|
|
|
|
#include "sparse-endian.h"
|
|
|
|
#include "util.h"
|
2014-02-28 16:10:20 +01:00
|
|
|
|
|
|
|
#define IPV4LL_NETWORK 0xA9FE0000L
|
|
|
|
#define IPV4LL_NETMASK 0xFFFF0000L
|
|
|
|
|
2015-08-20 11:40:10 +02:00
|
|
|
#define IPV4LL_DONT_DESTROY(ll) \
|
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy
GLIB has recently started to officially support the gcc cleanup
attribute in its public API, hence let's do the same for our APIs.
With this patch we'll define an xyz_unrefp() call for each public
xyz_unref() call, to make it easy to use inside a
__attribute__((cleanup())) expression. Then, all code is ported over to
make use of this.
The new calls are also documented in the man pages, with examples how to
use them (well, I only added docs where the _unref() call itself already
had docs, and the examples, only cover sd_bus_unrefp() and
sd_event_unrefp()).
This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we
tend to call our destructors these days.
Note that this defines no public macro that wraps gcc's attribute and
makes it easier to use. While I think it's our duty in the library to
make our stuff easy to use, I figure it's not our duty to make gcc's own
features easy to use on its own. Most likely, client code which wants to
make use of this should define its own:
#define _cleanup_(function) __attribute__((cleanup(function)))
Or similar, to make the gcc feature easier to use.
Making this logic public has the benefit that we can remove three header
files whose only purpose was to define these functions internally.
See #2008.
2015-11-27 19:13:45 +01:00
|
|
|
_cleanup_(sd_ipv4ll_unrefp) _unused_ sd_ipv4ll *_dont_destroy_##ll = sd_ipv4ll_ref(ll)
|
2015-08-20 11:40:10 +02:00
|
|
|
|
2014-02-28 16:10:20 +01:00
|
|
|
struct sd_ipv4ll {
|
2015-08-27 19:56:52 +02:00
|
|
|
unsigned n_ref;
|
2014-04-09 12:12:09 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
sd_ipv4acd *acd;
|
|
|
|
be32_t address; /* the address pushed to ACD */
|
2014-03-21 19:23:35 +01:00
|
|
|
struct random_data *random_data;
|
|
|
|
char *random_data_state;
|
2015-08-21 12:50:31 +02:00
|
|
|
|
2014-02-28 16:10:20 +01:00
|
|
|
/* External */
|
|
|
|
be32_t claimed_address;
|
2016-02-16 18:58:51 +01:00
|
|
|
sd_ipv4ll_callback_t cb;
|
2014-02-28 16:10:20 +01:00
|
|
|
void* userdata;
|
|
|
|
};
|
|
|
|
|
2015-08-20 11:40:10 +02:00
|
|
|
sd_ipv4ll *sd_ipv4ll_ref(sd_ipv4ll *ll) {
|
|
|
|
if (!ll)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
assert(ll->n_ref >= 1);
|
|
|
|
ll->n_ref++;
|
|
|
|
|
|
|
|
return ll;
|
|
|
|
}
|
|
|
|
|
|
|
|
sd_ipv4ll *sd_ipv4ll_unref(sd_ipv4ll *ll) {
|
|
|
|
if (!ll)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
assert(ll->n_ref >= 1);
|
|
|
|
ll->n_ref--;
|
|
|
|
|
|
|
|
if (ll->n_ref > 0)
|
|
|
|
return NULL;
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
sd_ipv4acd_unref(ll->acd);
|
2015-08-20 11:40:10 +02:00
|
|
|
|
|
|
|
free(ll->random_data);
|
|
|
|
free(ll->random_data_state);
|
|
|
|
free(ll);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
static void ipv4ll_on_acd(sd_ipv4acd *ll, int event, void *userdata);
|
|
|
|
|
2015-08-20 11:40:10 +02:00
|
|
|
int sd_ipv4ll_new(sd_ipv4ll **ret) {
|
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy
GLIB has recently started to officially support the gcc cleanup
attribute in its public API, hence let's do the same for our APIs.
With this patch we'll define an xyz_unrefp() call for each public
xyz_unref() call, to make it easy to use inside a
__attribute__((cleanup())) expression. Then, all code is ported over to
make use of this.
The new calls are also documented in the man pages, with examples how to
use them (well, I only added docs where the _unref() call itself already
had docs, and the examples, only cover sd_bus_unrefp() and
sd_event_unrefp()).
This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we
tend to call our destructors these days.
Note that this defines no public macro that wraps gcc's attribute and
makes it easier to use. While I think it's our duty in the library to
make our stuff easy to use, I figure it's not our duty to make gcc's own
features easy to use on its own. Most likely, client code which wants to
make use of this should define its own:
#define _cleanup_(function) __attribute__((cleanup(function)))
Or similar, to make the gcc feature easier to use.
Making this logic public has the benefit that we can remove three header
files whose only purpose was to define these functions internally.
See #2008.
2015-11-27 19:13:45 +01:00
|
|
|
_cleanup_(sd_ipv4ll_unrefp) sd_ipv4ll *ll = NULL;
|
2015-08-21 12:50:31 +02:00
|
|
|
int r;
|
2015-08-20 11:40:10 +02:00
|
|
|
|
|
|
|
assert_return(ret, -EINVAL);
|
|
|
|
|
|
|
|
ll = new0(sd_ipv4ll, 1);
|
|
|
|
if (!ll)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-11-17 00:16:21 +01:00
|
|
|
ll->n_ref = 1;
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
r = sd_ipv4acd_new(&ll->acd);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_ipv4acd_set_callback(ll->acd, ipv4ll_on_acd, ll);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-08-20 11:40:10 +02:00
|
|
|
*ret = ll;
|
|
|
|
ll = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int sd_ipv4ll_stop(sd_ipv4ll *ll) {
|
2015-08-20 00:09:08 +02:00
|
|
|
int r;
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
assert_return(ll, -EINVAL);
|
2015-08-20 00:09:08 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
r = sd_ipv4acd_stop(ll->acd);
|
2015-08-20 00:09:08 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return 0;
|
2014-02-28 16:10:20 +01:00
|
|
|
}
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
int sd_ipv4ll_set_index(sd_ipv4ll *ll, int interface_index) {
|
|
|
|
assert_return(ll, -EINVAL);
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
return sd_ipv4acd_set_index(ll->acd, interface_index);
|
2014-02-28 16:10:20 +01:00
|
|
|
}
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
#define HASH_KEY SD_ID128_MAKE(df,04,22,98,3f,ad,14,52,f9,87,2e,d1,9c,70,e2,f2)
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
int sd_ipv4ll_set_mac(sd_ipv4ll *ll, const struct ether_addr *addr) {
|
2015-08-18 23:58:58 +02:00
|
|
|
int r;
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
assert_return(ll, -EINVAL);
|
2015-08-18 23:58:58 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
if (!ll->random_data) {
|
2015-11-16 09:21:20 +01:00
|
|
|
uint64_t seed;
|
2015-08-18 23:58:58 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
/* If no random data is set, generate some from the MAC */
|
2015-11-16 23:17:52 +01:00
|
|
|
seed = siphash24(&addr->ether_addr_octet, ETH_ALEN, HASH_KEY.bytes);
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
assert_cc(sizeof(unsigned) <= 8);
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-11-16 23:17:52 +01:00
|
|
|
r = sd_ipv4ll_set_address_seed(ll, (unsigned) htole64(seed));
|
2015-08-19 19:42:38 +02:00
|
|
|
if (r < 0)
|
2015-08-21 12:50:31 +02:00
|
|
|
return r;
|
2014-02-28 16:10:20 +01:00
|
|
|
}
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
return sd_ipv4acd_set_mac(ll->acd, addr);
|
2014-02-28 16:10:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int sd_ipv4ll_detach_event(sd_ipv4ll *ll) {
|
|
|
|
assert_return(ll, -EINVAL);
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
return sd_ipv4acd_detach_event(ll->acd);
|
2014-02-28 16:10:20 +01:00
|
|
|
}
|
|
|
|
|
2016-02-16 19:33:36 +01:00
|
|
|
int sd_ipv4ll_attach_event(sd_ipv4ll *ll, sd_event *event, int64_t priority) {
|
2014-02-28 16:10:20 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert_return(ll, -EINVAL);
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
r = sd_ipv4acd_attach_event(ll->acd, event, priority);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-02-28 16:10:20 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-16 18:58:51 +01:00
|
|
|
int sd_ipv4ll_set_callback(sd_ipv4ll *ll, sd_ipv4ll_callback_t cb, void *userdata) {
|
2014-02-28 16:10:20 +01:00
|
|
|
assert_return(ll, -EINVAL);
|
|
|
|
|
|
|
|
ll->cb = cb;
|
|
|
|
ll->userdata = userdata;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-23 18:52:52 +01:00
|
|
|
int sd_ipv4ll_get_address(sd_ipv4ll *ll, struct in_addr *address) {
|
2014-02-28 16:10:20 +01:00
|
|
|
assert_return(ll, -EINVAL);
|
|
|
|
assert_return(address, -EINVAL);
|
|
|
|
|
2015-09-08 23:03:38 +02:00
|
|
|
if (ll->claimed_address == 0)
|
2014-02-28 16:10:20 +01:00
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
address->s_addr = ll->claimed_address;
|
2015-08-21 12:50:31 +02:00
|
|
|
|
2014-02-28 16:10:20 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
int sd_ipv4ll_set_address_seed(sd_ipv4ll *ll, unsigned seed) {
|
|
|
|
_cleanup_free_ struct random_data *random_data = NULL;
|
|
|
|
_cleanup_free_ char *random_data_state = NULL;
|
2014-03-21 19:23:35 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert_return(ll, -EINVAL);
|
2014-04-27 21:58:26 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
random_data = new0(struct random_data, 1);
|
|
|
|
if (!random_data)
|
|
|
|
return -ENOMEM;
|
2014-03-21 19:23:35 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
random_data_state = new0(char, 128);
|
|
|
|
if (!random_data_state)
|
|
|
|
return -ENOMEM;
|
2014-03-21 19:23:35 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
r = initstate_r(seed, random_data_state, 128, random_data);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-03-21 19:23:35 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
free(ll->random_data);
|
|
|
|
ll->random_data = random_data;
|
|
|
|
random_data = NULL;
|
2014-03-21 19:23:35 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
free(ll->random_data_state);
|
|
|
|
ll->random_data_state = random_data_state;
|
|
|
|
random_data_state = NULL;
|
2014-03-21 19:23:35 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
return 0;
|
2014-03-21 19:23:35 +01:00
|
|
|
}
|
|
|
|
|
2015-10-24 23:42:56 +02:00
|
|
|
int sd_ipv4ll_is_running(sd_ipv4ll *ll) {
|
2015-08-06 00:32:25 +02:00
|
|
|
assert_return(ll, false);
|
2014-04-02 21:31:12 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
return sd_ipv4acd_is_running(ll->acd);
|
2014-04-02 21:31:12 +02:00
|
|
|
}
|
|
|
|
|
2015-10-01 21:51:49 +02:00
|
|
|
static bool ipv4ll_address_is_valid(const struct in_addr *address) {
|
|
|
|
uint32_t addr;
|
|
|
|
|
|
|
|
assert(address);
|
|
|
|
|
|
|
|
if (!in_addr_is_link_local(AF_INET, (const union in_addr_union *) address))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
addr = be32toh(address->s_addr);
|
|
|
|
|
|
|
|
if ((addr & 0x0000FF00) == 0x0000 ||
|
|
|
|
(addr & 0x0000FF00) == 0xFF00)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
int sd_ipv4ll_set_address(sd_ipv4ll *ll, const struct in_addr *address) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert_return(ll, -EINVAL);
|
|
|
|
assert_return(address, -EINVAL);
|
|
|
|
assert_return(ipv4ll_address_is_valid(address), -EINVAL);
|
|
|
|
|
|
|
|
r = sd_ipv4acd_set_address(ll->acd, address);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
ll->address = address->s_addr;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
static int ipv4ll_pick_address(sd_ipv4ll *ll) {
|
|
|
|
struct in_addr in_addr;
|
|
|
|
be32_t addr;
|
2014-02-28 16:10:20 +01:00
|
|
|
int r;
|
2015-08-21 12:50:31 +02:00
|
|
|
int32_t random;
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
assert(ll);
|
|
|
|
assert(ll->random_data);
|
2014-04-09 12:12:10 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
do {
|
|
|
|
r = random_r(ll->random_data, &random);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
addr = htonl((random & 0x0000FFFF) | IPV4LL_NETWORK);
|
|
|
|
} while (addr == ll->address ||
|
|
|
|
(ntohl(addr) & 0x0000FF00) == 0x0000 ||
|
|
|
|
(ntohl(addr) & 0x0000FF00) == 0xFF00);
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
in_addr.s_addr = addr;
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-10-01 21:51:49 +02:00
|
|
|
r = sd_ipv4ll_set_address(ll, &in_addr);
|
2015-08-21 12:50:31 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-03-21 19:23:35 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int sd_ipv4ll_start(sd_ipv4ll *ll) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert_return(ll, -EINVAL);
|
|
|
|
assert_return(ll->random_data, -EINVAL);
|
2014-03-21 19:23:35 +01:00
|
|
|
|
|
|
|
if (ll->address == 0) {
|
2015-08-21 12:50:31 +02:00
|
|
|
r = ipv4ll_pick_address(ll);
|
2014-03-21 19:23:35 +01:00
|
|
|
if (r < 0)
|
2015-08-21 12:50:31 +02:00
|
|
|
return r;
|
2014-03-21 19:23:35 +01:00
|
|
|
}
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
r = sd_ipv4acd_start(ll->acd);
|
2015-08-18 15:37:43 +02:00
|
|
|
if (r < 0)
|
2015-08-21 12:50:31 +02:00
|
|
|
return r;
|
2015-08-18 15:37:43 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2015-08-18 15:37:43 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
static void ipv4ll_client_notify(sd_ipv4ll *ll, int event) {
|
|
|
|
assert(ll);
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
if (ll->cb)
|
|
|
|
ll->cb(ll, event, ll->userdata);
|
|
|
|
}
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
void ipv4ll_on_acd(sd_ipv4acd *acd, int event, void *userdata) {
|
|
|
|
sd_ipv4ll *ll = userdata;
|
|
|
|
IPV4LL_DONT_DESTROY(ll);
|
|
|
|
int r;
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
assert(acd);
|
|
|
|
assert(ll);
|
2014-08-28 15:46:29 +02:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
switch (event) {
|
2015-09-22 15:05:35 +02:00
|
|
|
case SD_IPV4ACD_EVENT_STOP:
|
2015-09-22 15:08:28 +02:00
|
|
|
ipv4ll_client_notify(ll, SD_IPV4LL_EVENT_STOP);
|
2014-02-28 16:10:20 +01:00
|
|
|
|
2015-08-21 12:50:31 +02:00
|
|
|
ll->claimed_address = 0;
|
|
|
|
|
|
|
|
break;
|
2015-09-22 15:05:35 +02:00
|
|
|
case SD_IPV4ACD_EVENT_BIND:
|
2015-08-21 12:50:31 +02:00
|
|
|
ll->claimed_address = ll->address;
|
2015-09-22 15:08:28 +02:00
|
|
|
ipv4ll_client_notify(ll, SD_IPV4LL_EVENT_BIND);
|
2015-08-21 12:50:31 +02:00
|
|
|
|
|
|
|
break;
|
2015-09-22 15:05:35 +02:00
|
|
|
case SD_IPV4ACD_EVENT_CONFLICT:
|
2015-08-21 12:50:31 +02:00
|
|
|
/* if an address was already bound we must call up to the
|
|
|
|
user to handle this, otherwise we just try again */
|
|
|
|
if (ll->claimed_address != 0) {
|
2015-09-22 15:08:28 +02:00
|
|
|
ipv4ll_client_notify(ll, SD_IPV4LL_EVENT_CONFLICT);
|
2015-08-21 12:50:31 +02:00
|
|
|
|
|
|
|
ll->claimed_address = 0;
|
|
|
|
} else {
|
|
|
|
r = ipv4ll_pick_address(ll);
|
|
|
|
if (r < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
r = sd_ipv4acd_start(ll->acd);
|
|
|
|
if (r < 0)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert_not_reached("Invalid IPv4ACD event.");
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
2015-09-22 15:08:28 +02:00
|
|
|
ipv4ll_client_notify(ll, SD_IPV4LL_EVENT_STOP);
|
2014-02-28 16:10:20 +01:00
|
|
|
}
|