#include <netinet/ether.h>

#include <linux/if.h>

#include <getopt.h>

#include "sd-event.h"

#include "event-util.h"

#include "sd-rtnl.h"

#include "rtnl-util.h"

#include "sd-daemon.h"

#include "sd-network.h"

#include "network-util.h"

#include "network-internal.h"

#include "networkd-wait-online.h"

#include "conf-parser.h"

#include "strv.h"

#include "util.h"

#include "build.h"

static bool arg_quiet = false;

static char **arg_interfaces = NULL;

static int help(void) {

printf("%s [OPTIONS...]\n\n"

"Block until network is configured.\n\n"

" -h --help Show this help\n"

" --version Print version string\n"

" -q --quiet Do not show status information\n"

" -i --interface=INTERFACE Block until at least these interfaces have appeared\n",

program_invocation_short_name);

return 0;

}

static int parse_argv(int argc, char *argv[]) {

enum {

ARG_VERSION = 0x100,

};

static const struct option options[] = {

{ "help", no_argument, NULL, 'h' },

{ "version", no_argument, NULL, ARG_VERSION },

{ "quiet", no_argument, NULL, 'q' },

{ "interface", required_argument, NULL, 'i' },

{}

};

int c;

assert(argc >= 0);

assert(argv);

while ((c = getopt_long(argc, argv, "+hq", options, NULL)) >= 0) {

switch (c) {

case 'h':

return help();

case 'q':

arg_quiet = true;

break;

case ARG_VERSION:

puts(PACKAGE_STRING);

puts(SYSTEMD_FEATURES);

return 0;

case 'i':

if (strv_extend(&arg_interfaces, optarg) < 0)

return log_oom();

break;

case '?':

return -EINVAL;

default:

assert_not_reached("Unhandled option");

}

}

return 1;

}

static bool all_configured(Manager *m) {

_cleanup_free_ unsigned *indices = NULL;

char **ifname;

bool one_ready = false;

int r, n, i;

n = sd_network_get_ifindices(&indices);

if (n <= 0)

return false;

/* wait for networkd to be aware of all the links given on the commandline */

STRV_FOREACH(ifname, arg_interfaces) {

_cleanup_rtnl_message_unref_ sd_rtnl_message *message = NULL, *reply = NULL;

bool found = false;

int index;

r = sd_rtnl_message_new_link(m->rtnl, &message, RTM_GETLINK, 0);

if (r < 0) {

log_warning("colud not create GETLINK message: %s", strerror(-r));

return false;

}

r = sd_rtnl_message_append_string(message, IFLA_IFNAME, *ifname);

if (r < 0) {

log_warning("could not attach ifname to GETLINK message: %s", strerror(-r));

return false;

}

r = sd_rtnl_call(m->rtnl, message, 0, &reply);

if (r < 0) {

if (r != -ENODEV)

log_warning("could not get link info for %s: %s", *ifname,

strerror(-r));

/* link does not yet exist */

return false;

}

r = sd_rtnl_message_link_get_ifindex(reply, &index);

if (r < 0) {

log_warning("could not get ifindex: %s", strerror(-r));

return false;

}

if (index <= 0) {

log_warning("invalid ifindex %d for %s", index, *ifname);

return false;

}

for (i = 0; i < n; i++) {

if (indices[i] == (unsigned) index) {

found = true;

break;

}

}

if (!found) {

/* link exists, but networkd is not yet aware of it */

return false;

}

}

/* wait for all links networkd manages to be in admin state 'configured'

for (i = 0; i < n; i++) {

_cleanup_free_ char *state = NULL, *oper_state = NULL;

if (sd_network_link_is_loopback(indices[i]))

/* ignore loopback devices */

continue;

r = sd_network_get_link_state(indices[i], &state);

if (r == -EBUSY || (r >= 0 && !streq(state, "configured")))

/* not yet processed by udev, or managed by networkd, but not yet configured */

return false;

r = sd_network_get_link_operational_state(indices[i], &oper_state);

if (r >= 0 &&

(streq(oper_state, "degraded") ||

streq(oper_state, "routable")))

/* we wait for at least one link to be ready,

one_ready = true;

}

return one_ready;

}

static int monitor_event_handler(sd_event_source *s, int fd, uint32_t revents,

void *userdata) {

Manager *m = userdata;

assert(m);

assert(m->event);

if (all_configured(m))

sd_event_exit(m->event, 0);

sd_network_monitor_flush(m->monitor);

return 1;

}

void manager_free(Manager *m) {

if (!m)

return;

sd_event_unref(m->event);

sd_rtnl_unref(m->rtnl);

free(m);

}

int main(int argc, char *argv[]) {

_cleanup_manager_free_ Manager *m = NULL;

_cleanup_event_source_unref_ sd_event_source *event_source = NULL;

int r, fd, events;

umask(0022);

log_parse_environment();

log_open();

r = parse_argv(argc, argv);

if (r <= 0)

return r;

if (arg_quiet)

log_set_max_level(LOG_WARNING);

m = new0(Manager, 1);

if (!m)

return log_oom();

r = sd_event_new(&m->event);

if (r < 0) {

log_error("Could not create event: %s", strerror(-r));

goto out;

}

r = sd_rtnl_open(&m->rtnl, 0);

if (r < 0) {

log_error("Could not create rtnl: %s", strerror(-r));

goto out;

}

r = sd_network_monitor_new(NULL, &m->monitor);

if (r < 0) {

log_error("Could not create monitor: %s", strerror(-r));

goto out;

}

fd = sd_network_monitor_get_fd(m->monitor);

if (fd < 0) {

log_error("Could not get monitor fd: %s", strerror(-r));

goto out;

}

events = sd_network_monitor_get_events(m->monitor);

if (events < 0) {

log_error("Could not get monitor events: %s", strerror(-r));

goto out;

}

r = sd_event_add_io(m->event, &event_source, fd, events, &monitor_event_handler,

m);

if (r < 0) {

log_error("Could not add io event source: %s", strerror(-r));

goto out;

}

if (all_configured(m)) {

r = 0;

goto out;

}

sd_notify(false,

"READY=1\n"

"STATUS=Waiting for network connections...");

r = sd_event_loop(m->event);

if (r < 0) {

log_error("Event loop failed: %s", strerror(-r));

goto out;

}

out:

sd_notify(false,

"STATUS=All interfaces configured...");

return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;

}