int link_new(Manager *m, Link **ret, int ifindex, const char *ifname) {
_cleanup_(link_freep) Link *l = NULL;
+ _cleanup_free_ char *n = NULL;
int r;
assert(m);
if (r < 0)
return r;
- l = new0(Link, 1);
- if (!l)
+ n = strdup(ifname);
+ if (!n)
return -ENOMEM;
- l->manager = m;
-
- l->ifname = strdup(ifname);
- if (!l->ifname)
+ l = new(Link, 1);
+ if (!l)
return -ENOMEM;
+ *l = (Link) {
+ .manager = m,
+ .ifname = TAKE_PTR(n),
+ .ifindex = ifindex,
+ .required_operstate = LINK_OPERSTATE_DEGRADED,
+ };
+
r = hashmap_put(m->links_by_name, l->ifname, l);
if (r < 0)
return r;
- l->ifindex = ifindex;
-
r = hashmap_put(m->links, INT_TO_PTR(ifindex), l);
if (r < 0)
return r;
if (ret)
*ret = l;
- l = NULL;
+ TAKE_PTR(l);
return 0;
}
hashmap_remove(l->manager->links_by_name, l->ifname);
}
+ free(l->state);
free(l->ifname);
return mfree(l);
}
if (!new_ifname)
return -ENOMEM;
- hashmap_remove(l->manager->links_by_name, l->ifname);
- free(l->ifname);
- l->ifname = new_ifname;
+ assert_se(hashmap_remove(l->manager->links_by_name, l->ifname) == l);
+ free_and_replace(l->ifname, new_ifname);
r = hashmap_put(l->manager->links_by_name, l->ifname, l);
if (r < 0)
}
int link_update_monitor(Link *l) {
- assert(l);
+ _cleanup_free_ char *operstate = NULL, *required_operstate = NULL, *state = NULL;
+ LinkOperationalState s;
+ int r, ret = 0;
- l->required_for_online = sd_network_link_get_required_for_online(l->ifindex) != 0;
+ assert(l);
+ assert(l->ifname);
- l->operational_state = mfree(l->operational_state);
+ r = sd_network_link_get_required_for_online(l->ifindex);
+ if (r < 0)
+ ret = log_debug_errno(r,
+ "Failed to get whether link %s is required for online or not, "
+ "ignoring: %m", l->ifname);
+ else
+ l->required_for_online = r > 0;
- sd_network_link_get_operational_state(l->ifindex, &l->operational_state);
+ r = sd_network_link_get_required_operstate_for_online(l->ifindex, &required_operstate);
+ if (r < 0)
+ ret = log_debug_errno(r, "Failed to get required operational state for link %s to be online, "
+ "ignoring: %m", l->ifname);
+ else {
+ s = link_operstate_from_string(required_operstate);
+ if (s < 0)
+ ret = log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Failed to parse required operational state for link %s to be online, "
+ "ignoring: %m", l->ifname);
+ else
+ l->required_operstate = s;
+ }
- l->state = mfree(l->state);
+ r = sd_network_link_get_operational_state(l->ifindex, &operstate);
+ if (r < 0)
+ ret = log_debug_errno(r, "Failed to get operational state of link %s, ignoring: %m",
+ l->ifname);
+ else {
+ s = link_operstate_from_string(operstate);
+ if (s < 0)
+ ret = log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Failed to parse operational state of link %s, ignoring: %m",
+ l->ifname);
+ else
+ l->operational_state = s;
+ }
- sd_network_link_get_setup_state(l->ifindex, &l->state);
+ r = sd_network_link_get_setup_state(l->ifindex, &state);
+ if (r < 0)
+ ret = log_debug_errno(r, "Failed to get setup state of link %s, ignoring: %m",
+ l->ifname);
+ else
+ free_and_replace(l->state, state);
- return 0;
+ return ret;
}
#include "sd-netlink.h"
+#include "network-util.h"
+
typedef struct Link Link;
typedef struct Manager Manager;
unsigned flags;
bool required_for_online;
- char *operational_state;
+ LinkOperationalState required_operstate;
+ LinkOperationalState operational_state;
char *state;
};
#include "time-util.h"
#include "util.h"
-bool manager_ignore_link(Manager *m, Link *link) {
+static bool manager_ignore_link(Manager *m, Link *link) {
assert(m);
assert(link);
return true;
/* if interfaces are given on the command line, ignore all others */
- if (m->interfaces && !strv_contains(m->interfaces, link->ifname))
+ if (m->interfaces && !hashmap_contains(m->interfaces, link->ifname))
return true;
if (!link->required_for_online)
return strv_fnmatch(m->ignore, link->ifname, 0);
}
+static int manager_link_is_online(Manager *m, Link *l, LinkOperationalState s) {
+ /* This returns the following:
+ * -EAGAIN: not processed by udev or networkd
+ * 0: operstate is not enough
+ * 1: online */
+
+ if (!l->state) {
+ log_debug("link %s has not yet been processed by udev",
+ l->ifname);
+ return -EAGAIN;
+ }
+
+ if (STR_IN_SET(l->state, "configuring", "pending")) {
+ log_debug("link %s is being processed by networkd",
+ l->ifname);
+ return -EAGAIN;
+ }
+
+ if (s < 0)
+ s = m->required_operstate >= 0 ? m->required_operstate : l->required_operstate;
+
+ if (l->operational_state < s) {
+ log_debug("Operational state of link %s does not reach to %s",
+ l->ifname, link_operstate_to_string(s));
+ return 0;
+ }
+
+ return 1;
+}
+
bool manager_all_configured(Manager *m) {
+ bool one_ready = false;
Iterator i;
+ const char *ifname;
+ void *p;
Link *l;
- char **ifname;
- bool one_ready = false;
+ int r;
/* wait for all the links given on the command line to appear */
- STRV_FOREACH(ifname, m->interfaces) {
- l = hashmap_get(m->links_by_name, *ifname);
+ HASHMAP_FOREACH_KEY(p, ifname, m->interfaces, i) {
+ LinkOperationalState s = PTR_TO_INT(p);
+
+ l = hashmap_get(m->links_by_name, ifname);
if (!l) {
- log_debug("still waiting for %s", *ifname);
+ log_debug("still waiting for %s", ifname);
return false;
}
+
+ if (manager_link_is_online(m, l, s) <= 0)
+ return false;
}
+ if (!hashmap_isempty(m->interfaces))
+ /* all interfaces given by the command line are online. */
+ return true;
+
/* wait for all links networkd manages to be in admin state 'configured'
- and at least one link to gain a carrier */
+ * and at least one link to gain a carrier */
HASHMAP_FOREACH(l, m->links, i) {
if (manager_ignore_link(m, l)) {
log_info("ignoring: %s", l->ifname);
continue;
}
- if (!l->state) {
- log_debug("link %s has not yet been processed by udev",
- l->ifname);
- return false;
- }
-
- if (STR_IN_SET(l->state, "configuring", "pending")) {
- log_debug("link %s is being processed by networkd",
- l->ifname);
+ r = manager_link_is_online(m, l, _LINK_OPERSTATE_INVALID);
+ if (r < 0)
return false;
- }
-
- if (l->operational_state &&
- STR_IN_SET(l->operational_state, "degraded", "routable"))
+ if (r > 0)
/* we wait for at least one link to be ready,
- regardless of who manages it */
+ * regardless of who manages it */
one_ready = true;
}
r = link_new(m, &l, ifindex, ifname);
if (r < 0)
return log_error_errno(r, "Failed to create link object: %m");
-
- r = link_update_monitor(l);
- if (r < 0)
- return log_error_errno(r, "Failed to initialize link object: %m");
}
r = link_update_rtnl(l, mm);
if (r < 0)
- return log_warning_errno(r, "Failed to process RTNL link message: %m");;
+ log_warning_errno(r, "Failed to process RTNL link message, ignoring: %m");
+
+ r = link_update_monitor(l);
+ if (r < 0)
+ log_warning_errno(r, "Failed to initialize link object, ignoring: %m");
break;
return 0;
}
-int manager_new(Manager **ret, char **interfaces, char **ignore, usec_t timeout) {
+int manager_new(Manager **ret, Hashmap *interfaces, char **ignore,
+ LinkOperationalState required_operstate, usec_t timeout) {
_cleanup_(manager_freep) Manager *m = NULL;
int r;
assert(ret);
- m = new0(Manager, 1);
+ m = new(Manager, 1);
if (!m)
return -ENOMEM;
- m->interfaces = interfaces;
- m->ignore = ignore;
+ *m = (Manager) {
+ .interfaces = interfaces,
+ .ignore = ignore,
+ .required_operstate = required_operstate,
+ };
r = sd_event_default(&m->event);
if (r < 0)
#include "sd-network.h"
#include "hashmap.h"
+#include "network-util.h"
typedef struct Manager Manager;
typedef struct Link Link;
Hashmap *links;
Hashmap *links_by_name;
- char **interfaces;
+ /* Do not free the two members below. */
+ Hashmap *interfaces;
char **ignore;
+ LinkOperationalState required_operstate;
+
sd_netlink *rtnl;
sd_event_source *rtnl_event_source;
};
void manager_free(Manager *m);
-int manager_new(Manager **ret, char **interfaces, char **ignore, usec_t timeout);
+int manager_new(Manager **ret, Hashmap *interfaces, char **ignore,
+ LinkOperationalState required_operstate, usec_t timeout);
DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
bool manager_all_configured(Manager *m);
-bool manager_ignore_link(Manager *m, Link *link);
#include "manager.h"
#include "pretty-print.h"
#include "signal-util.h"
+#include "socket-util.h"
#include "strv.h"
static bool arg_quiet = false;
static usec_t arg_timeout = 120 * USEC_PER_SEC;
-static char **arg_interfaces = NULL;
+static Hashmap *arg_interfaces = NULL;
static char **arg_ignore = NULL;
+static LinkOperationalState arg_required_operstate = _LINK_OPERSTATE_INVALID;
-STATIC_DESTRUCTOR_REGISTER(arg_interfaces, strv_freep);
+STATIC_DESTRUCTOR_REGISTER(arg_interfaces, hashmap_free_free_keyp);
STATIC_DESTRUCTOR_REGISTER(arg_ignore, strv_freep);
static int help(void) {
" -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"
+ " -i --interface=INTERFACE[:OPERSTATE]\n"
+ " Block until at least these interfaces have appeared\n"
" --ignore=INTERFACE Don't take these interfaces into account\n"
+ " -o --operational-state=OPERSTATE\n"
+ " Required operational state\n"
" --timeout=SECS Maximum time to wait for network connectivity\n"
"\nSee the %s for details.\n"
, program_invocation_short_name
return 0;
}
+static int parse_interface_with_operstate(const char *str) {
+ _cleanup_free_ char *ifname = NULL;
+ LinkOperationalState s;
+ const char *p;
+ int r;
+
+ assert(str);
+
+ p = strchr(str, ':');
+ if (p) {
+ if (isempty(p + 1))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Operational state is empty.");
+
+ s = link_operstate_from_string(p + 1);
+ if (s < 0)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Invalid operational state '%s'", p + 1);
+
+ ifname = strndup(optarg, p - optarg);
+ } else {
+ s = _LINK_OPERSTATE_INVALID;
+ ifname = strdup(str);
+ }
+ if (!ifname)
+ return log_oom();
+
+ if (!ifname_valid(ifname))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Invalid interface name '%s'", ifname);
+
+ r = hashmap_ensure_allocated(&arg_interfaces, &string_hash_ops);
+ if (r < 0)
+ return log_oom();
+
+ r = hashmap_put(arg_interfaces, ifname, INT_TO_PTR(s));
+ if (r < 0)
+ return log_error_errno(r, "Failed to store interface name: %m");
+ if (r == 0)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Interface name %s is already specified", ifname);
+
+ TAKE_PTR(ifname);
+ return 0;
+}
+
static int parse_argv(int argc, char *argv[]) {
enum {
};
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' },
- { "ignore", required_argument, NULL, ARG_IGNORE },
- { "timeout", required_argument, NULL, ARG_TIMEOUT },
+ { "help", no_argument, NULL, 'h' },
+ { "version", no_argument, NULL, ARG_VERSION },
+ { "quiet", no_argument, NULL, 'q' },
+ { "interface", required_argument, NULL, 'i' },
+ { "ignore", required_argument, NULL, ARG_IGNORE },
+ { "operational-state", required_argument, NULL, 'o' },
+ { "timeout", required_argument, NULL, ARG_TIMEOUT },
{}
};
assert(argc >= 0);
assert(argv);
- while ((c = getopt_long(argc, argv, "+hi:q", options, NULL)) >= 0)
+ while ((c = getopt_long(argc, argv, "hi:qo:", options, NULL)) >= 0)
switch (c) {
return version();
case 'i':
- if (strv_extend(&arg_interfaces, optarg) < 0)
- return log_oom();
-
+ r = parse_interface_with_operstate(optarg);
+ if (r < 0)
+ return r;
break;
case ARG_IGNORE:
break;
+ case 'o': {
+ LinkOperationalState s;
+
+ s = link_operstate_from_string(optarg);
+ if (s < 0)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Invalid operational state '%s'", optarg);
+
+ arg_required_operstate = s;
+ break;
+ }
case ARG_TIMEOUT:
r = parse_sec(optarg, &arg_timeout);
if (r < 0)
return r;
-
break;
case '?':
return r;
if (arg_quiet)
- log_set_max_level(LOG_WARNING);
+ log_set_max_level(LOG_ERR);
assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, -1) >= 0);
- r = manager_new(&m, arg_interfaces, arg_ignore, arg_timeout);
+ r = manager_new(&m, arg_interfaces, arg_ignore, arg_required_operstate, arg_timeout);
if (r < 0)
return log_error_errno(r, "Could not create manager: %m");
projects / thirdparty / systemd.git / commitdiff
