static void
__do_arp_validate_arm_timer(struct arp_handle *handle)
{
if (handle->timer) {
ni_timer_rearm(handle->timer, handle->timeout);
} else {
handle->timer = ni_timer_register(handle->timeout,
__do_arp_validate_timeout, handle);
}
}
void
ni_dhcp4_fsm_set_timeout_msec(ni_dhcp4_device_t *dev, unsigned int msec)
{
if (msec != 0) {
ni_debug_dhcp("%s: setting timeout to %u msec", dev->ifname, msec);
if (dev->fsm.timer)
ni_timer_rearm(dev->fsm.timer, msec);
else
dev->fsm.timer = ni_timer_register(msec, __ni_dhcp4_fsm_timeout, dev);
}
}
static void
__ni_wireless_scan_timer_arm(ni_wireless_scan_t *scan, ni_netdev_t *dev, unsigned int timeout)
{
/* Fire twice as often as requested. This is because we rearm the
* timer at the point where we *request* a new scan, but the scan
* timestamp is updated when the last *response* comes in, which is
* usually half a second later or so. */
timeout = 1000 * timeout / 2;
if (scan->timer == NULL) {
scan->timer = ni_timer_register(timeout,
__ni_wireless_scan_timeout,
dev);
} else {
ni_timer_rearm(scan->timer, timeout);
}
}
static void
ni_wireless_update_association_timer(ni_netdev_t *dev)
{
ni_wireless_t *wlan = dev->wireless;
if (wlan->assoc.state == NI_WIRELESS_ESTABLISHED) {
ni_wireless_set_association_timer(wlan, NULL);
} else {
const ni_timer_t *new_timer;
unsigned int timeout;
if (wlan->assoc.timer != NULL)
return;
if ((timeout = wlan->assoc.fail_delay) == 0)
timeout = NI_WIRELESS_ASSOC_FAIL_DELAY;
new_timer = ni_timer_register(1000 * timeout,
__ni_wireless_association_timeout,
dev);
ni_wireless_set_association_timer(wlan, new_timer);
}
}
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;
}
