static int
__do_arp_validate(struct arp_handle *handle)
{
ni_capture_devinfo_t dev_info;
int ret;
if ((ret = __do_arp_validate_init(handle, &dev_info)) != 0)
return ret;
handle->sock = ni_arp_socket_open(&dev_info,
__do_arp_validate_process, handle);
if (!handle->sock || !handle->sock->user_data) {
ni_error("%s: Cannot initialize arp socket", handle->ifname);
__do_arp_handle_close(handle);
return NI_LSB_RC_ERROR;
}
if (!__do_arp_validate_send(handle)) {
__do_arp_handle_close(handle);
ni_error("%s: Cannot send arp packet", handle->ifname);
return NI_LSB_RC_ERROR;
}
ret = NI_WICKED_RC_ERROR;
while (!ni_caught_terminal_signal()) {
long timeout;
ret = NI_LSB_RC_SUCCESS;
timeout = ni_timer_next_timeout();
if (ni_socket_wait(timeout) != 0)
break;
ret = NI_WICKED_RC_ERROR;
}
if (handle->timer) {
ni_timer_cancel(handle->timer);
handle->timer = NULL;
}
__do_arp_handle_close(handle);
return handle->hwaddr.len ? NI_LSB_RC_NOT_ALLOWED : ret;
}
int
ni_dhcp4_tester_run(ni_dhcp4_tester_t *opts)
{
ni_netconfig_t *nc;
ni_netdev_t *ifp = NULL;
ni_dhcp4_device_t *dev = NULL;
ni_dhcp4_request_t *req = NULL;
unsigned int link_timeout = 20;
int rv;
if (opts->timeout && opts->timeout != -1U) {
link_timeout = (opts->timeout * 2) / 3;
opts->timeout -= link_timeout;
}
if (!opts || ni_string_empty(opts->ifname))
ni_fatal("Invalid start parameters!");
dhcp4_tester_opts = *opts;
dhcp4_tester_status = NI_WICKED_RC_ERROR;
if (!(nc = ni_global_state_handle(1)))
ni_fatal("Cannot refresh interface list!");
if (!(ifp = ni_netdev_by_name(nc, opts->ifname)))
ni_fatal("Cannot find interface with name '%s'", opts->ifname);
if (!ni_dhcp4_supported(ifp))
ni_fatal("DHCPv4 not supported on '%s'", opts->ifname);
if (!(dev = ni_dhcp4_device_new(ifp->name, &ifp->link)))
ni_fatal("Cannot allocate dhcp4 client for '%s'", opts->ifname);
ni_dhcp4_set_event_handler(ni_dhcp4_tester_protocol_event);
if (!(req = ni_dhcp4_request_new())) {
ni_error("Cannot allocate dhcp4 request");
goto failure;
}
if (!ni_dhcp4_tester_req_init(req, opts->request))
goto failure;
if (!ni_netdev_link_is_up(ifp)) {
ni_netdev_req_t *ifreq;
ni_debug_dhcp("%s: Link is not up, trying to bring it up",
ifp->name);
ifreq = ni_netdev_req_new();
ifreq->ifflags = NI_IFF_LINK_UP | NI_IFF_NETWORK_UP;
if ((rv = ni_system_interface_link_change(ifp, ifreq)) < 0) {
ni_error("%s: Unable to set up link", ifp->name);
ni_netdev_req_free(ifreq);
goto failure;
}
ni_netdev_req_free(ifreq);
do {
sleep(1);
if (!(nc = ni_global_state_handle(1)))
goto failure;
if (!(ifp = ni_netdev_by_index(nc, dev->link.ifindex)))
break;
if (ni_netdev_link_is_up(ifp))
break;
ni_debug_dhcp("%s: Link is not (yet) up", ifp->name);
} while (link_timeout-- > 1);
if (!ifp || !ni_netdev_link_is_up(ifp) || !link_timeout) {
ni_error("%s: Unable to bring link up",
ifp && ifp->name ? ifp->name : dev->ifname);
goto failure;
}
/* Do not try to send too early, even link is reported up now */
sleep(1);
}
if (opts->timeout && opts->timeout != -1U)
req->acquire_timeout = opts->timeout;
req->broadcast = opts->broadcast;
if ((rv = ni_dhcp4_acquire(dev, req)) < 0) {
ni_error("%s: DHCP4v6 acquire request %s failed: %s",
dev->ifname, ni_uuid_print(&req->uuid),
ni_strerror(rv));
goto failure;
}
dhcp4_tester_status = NI_WICKED_RC_IN_PROGRESS;
while (!ni_caught_terminal_signal()) {
long timeout;
timeout = ni_timer_next_timeout();
if (ni_socket_wait(timeout) != 0)
break;
}
ni_server_deactivate_interface_events();
ni_socket_deactivate_all();
failure:
if (dev)
ni_dhcp4_device_put(dev);
if (req)
ni_dhcp4_request_free(req);
return dhcp4_tester_status;
}
static int
ni_do_ifup_nanny(int argc, char **argv)
{
enum { OPT_HELP, OPT_IFCONFIG, OPT_CONTROL_MODE, OPT_STAGE, OPT_TIMEOUT,
OPT_SKIP_ACTIVE, OPT_SKIP_ORIGIN, OPT_PERSISTENT, OPT_TRANSIENT,
#ifdef NI_TEST_HACKS
OPT_IGNORE_PRIO, OPT_IGNORE_STARTMODE,
#endif
};
static struct option ifup_options[] = {
{ "help", no_argument, NULL, OPT_HELP },
{ "ifconfig", required_argument, NULL, OPT_IFCONFIG },
{ "mode", required_argument, NULL, OPT_CONTROL_MODE },
{ "boot-stage", required_argument, NULL, OPT_STAGE },
{ "skip-active",required_argument, NULL, OPT_SKIP_ACTIVE },
{ "skip-origin",required_argument, NULL, OPT_SKIP_ORIGIN },
{ "timeout", required_argument, NULL, OPT_TIMEOUT },
{ "transient", no_argument, NULL, OPT_TRANSIENT },
#ifdef NI_TEST_HACKS
{ "ignore-prio",no_argument, NULL, OPT_IGNORE_PRIO },
{ "ignore-startmode",no_argument, NULL, OPT_IGNORE_STARTMODE },
#endif
{ "persistent", no_argument, NULL, OPT_PERSISTENT },
{ NULL }
};
ni_ifmatcher_t ifmatch;
ni_ifworker_array_t ifmarked;
ni_string_array_t opt_ifconfig = NI_STRING_ARRAY_INIT;
ni_bool_t check_prio = TRUE, set_persistent = FALSE;
ni_bool_t opt_transient = FALSE;
int c, status = NI_WICKED_RC_USAGE;
unsigned int timeout = 0;
ni_fsm_t *fsm;
fsm = ni_fsm_new();
ni_assert(fsm);
ni_fsm_require_register_type("reachable", ni_ifworker_reachability_check_new);
memset(&ifmatch, 0, sizeof(ifmatch));
memset(&ifmarked, 0, sizeof(ifmarked));
/* Allow ifup on all interfaces we have config for */
ifmatch.require_configured = FALSE;
ifmatch.allow_persistent = TRUE;
ifmatch.require_config = TRUE;
optind = 1;
while ((c = getopt_long(argc, argv, "", ifup_options, NULL)) != EOF) {
switch (c) {
case OPT_IFCONFIG:
ni_string_array_append(&opt_ifconfig, optarg);
break;
case OPT_CONTROL_MODE:
ifmatch.mode = optarg;
break;
case OPT_STAGE:
ifmatch.boot_stage= optarg;
break;
case OPT_TIMEOUT:
if (!strcmp(optarg, "infinite")) {
timeout = NI_IFWORKER_INFINITE_TIMEOUT;
} else {
unsigned int sec;
if (ni_parse_uint(optarg, &sec, 10) < 0) {
ni_error("ifup: cannot parse timeout option \"%s\"", optarg);
goto usage;
}
timeout = sec * 1000; /* sec -> msec */
}
break;
case OPT_SKIP_ORIGIN:
ifmatch.skip_origin = optarg;
break;
case OPT_SKIP_ACTIVE:
ifmatch.skip_active = TRUE;
break;
#ifdef NI_TEST_HACKS
case OPT_IGNORE_PRIO:
check_prio = FALSE;
break;
case OPT_IGNORE_STARTMODE:
ifmatch.ignore_startmode = TRUE;
break;
#endif
case OPT_PERSISTENT:
set_persistent = TRUE;
break;
case OPT_TRANSIENT:
opt_transient = TRUE;
break;
default:
case OPT_HELP:
usage:
fprintf(stderr,
"wicked [options] ifup [ifup-options] <ifname ...>|all\n"
"\nSupported ifup-options:\n"
" --help\n"
" Show this help text.\n"
" --transient\n"
" Enable transient interface return codes\n"
" --ifconfig <pathname>\n"
" Read interface configuration(s) from file/directory rather than using system config\n"
" --mode <label>\n"
" Only touch interfaces with matching control <mode>\n"
" --boot-stage <label>\n"
" Only touch interfaces with matching <boot-stage>\n"
" --skip-active\n"
" Do not touch running interfaces\n"
" --skip-origin <name>\n"
" Skip interfaces that have a configuration origin of <name>\n"
" Usually, you would use this with the name \"firmware\" to avoid\n"
" touching interfaces that have been set up via firmware (like iBFT) previously\n"
" --timeout <nsec>\n"
" Timeout after <nsec> seconds\n"
#ifdef NI_TEST_HACKS
" --ignore-prio\n"
" Ignore checking the config origin priorities\n"
" --ignore-startmode\n"
" Ignore checking the STARTMODE=off and STARTMODE=manual configs\n"
#endif
" --persistent\n"
" Set interface into persistent mode (no regular ifdown allowed)\n"
);
goto cleanup;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing interface argument\n");
goto usage;
}
if (!ni_client_create(fsm, &ifmarked) || !ni_fsm_refresh_state(fsm)) {
/* Severe error we always explicitly return */
status = NI_WICKED_RC_ERROR;
goto cleanup;
}
if (opt_ifconfig.count == 0) {
const ni_string_array_t *sources = ni_config_sources("ifconfig");
if (sources && sources->count)
ni_string_array_copy(&opt_ifconfig, sources);
if (opt_ifconfig.count == 0) {
ni_error("ifup: unable to load interface config source list");
status = NI_WICKED_RC_NOT_CONFIGURED;
goto cleanup;
}
}
if (!ni_ifconfig_load(fsm, opt_global_rootdir, &opt_ifconfig, check_prio, TRUE)) {
status = NI_WICKED_RC_NOT_CONFIGURED;
goto cleanup;
}
/* Client waits for device-up events for WAIT_FOR_INTERFACES */
if (timeout)
ni_wait_for_interfaces = timeout; /* One set by user */
else
ni_wait_for_interfaces *= 1000; /* in msec */
if (ni_wait_for_interfaces)
fsm->worker_timeout = ni_wait_for_interfaces;
if (ni_fsm_build_hierarchy(fsm) < 0) {
ni_error("ifup: unable to build device hierarchy");
/* Severe error we always explicitly return */
status = NI_WICKED_RC_ERROR;
goto cleanup;
}
status = NI_WICKED_RC_SUCCESS;
/* Get workers that match given criteria */
while (optind < argc) {
ifmatch.name = argv[optind++];
if (!strcmp(ifmatch.name, "boot")) {
ifmatch.name = "all";
ifmatch.mode = "boot";
}
ni_fsm_get_matching_workers(fsm, &ifmatch, &ifmarked);
}
if (!ni_ifup_start_policies(&ifmarked, set_persistent))
status = NI_WICKED_RC_NOT_CONFIGURED;
/* Wait for device-up events */
ni_timer_register(ni_wait_for_interfaces, ni_client_timer_expires, &status);
while (status == NI_WICKED_RC_SUCCESS) {
/* status is already success */
if (0 == ifmarked.count)
break;
if (ni_socket_wait(ni_wait_for_interfaces) != 0)
ni_fatal("ni_socket_wait failed");
ni_timer_next_timeout();
}
/* Do not report any transient errors to systemd (e.g. dhcp
* or whatever not ready in time) -- returning an error may
* cause to stop the network completely.
*/
if (!opt_transient)
status = NI_LSB_RC_SUCCESS;
cleanup:
ni_ifworker_array_destroy(&ifmarked);
ni_string_array_destroy(&opt_ifconfig);
return status;
}
