static void
ni_dhcp4_tester_protocol_event(enum ni_dhcp4_event ev, const ni_dhcp4_device_t *dev,
ni_addrconf_lease_t *lease)
{
ni_debug_dhcp("%s(ev=%u, dev=%s[%u], config-uuid=%s)", __func__, ev,
dev->ifname, dev->link.ifindex,
dev->config ? ni_uuid_print(&dev->config->uuid) : "<none>");
switch (ev) {
case NI_DHCP4_EVENT_ACQUIRED:
if (lease && lease->state == NI_ADDRCONF_STATE_GRANTED) {
FILE *fp = stdout;
if (dhcp4_tester_opts.output != NULL) {
fp = fopen(dhcp4_tester_opts.output, "w");
if (!fp) {
ni_error("Cannot open %s for output",
dhcp4_tester_opts.output);
dhcp4_tester_status = NI_WICKED_RC_ERROR;
return;
}
}
if (dhcp4_tester_opts.outfmt == NI_DHCP4_TESTER_OUT_LEASE_XML) {
xml_node_t *xml = NULL;
if (ni_addrconf_lease_to_xml(lease, &xml, dev->ifname) != 0) {
if (dhcp4_tester_opts.output)
fclose(fp);
dhcp4_tester_status = NI_WICKED_RC_ERROR;
return;
}
xml_node_print(xml, fp);
xml_node_free(xml);
} else {
ni_leaseinfo_dump(fp, lease, dev->ifname, NULL);
}
fflush(fp);
if (dhcp4_tester_opts.output)
fclose(fp);
dhcp4_tester_status = NI_WICKED_RC_SUCCESS;
}
break;
default:
break;
}
}
int
__ni_addrconf_lease_info_to_xml(const ni_addrconf_lease_t *lease, xml_node_t *node)
{
char hex[32] = { '\0' };
xml_node_new_element("family", node, ni_addrfamily_type_to_name(lease->family));
xml_node_new_element("type", node, ni_addrconf_type_to_name(lease->type));
if (!ni_string_empty(lease->owner))
xml_node_new_element("owner", node, lease->owner);
if (!ni_uuid_is_null(&lease->uuid))
xml_node_new_element("uuid", node, ni_uuid_print(&lease->uuid));
xml_node_new_element("state", node, ni_addrconf_state_to_name(lease->state));
snprintf(hex, sizeof(hex), "0x%08x", lease->update);
xml_node_new_element("update", node, hex);
xml_node_new_element_uint("acquired", node, lease->time_acquired);
return 0;
}
/*
* Callback from addrconf supplicant whenever it acquired, released or lost a lease.
*
* FIXME SECURITY:
* Is it good enough to check for the sender interface to avoid that someone is sending
* us spoofed lease messages?!
*/
void
ni_objectmodel_addrconf_signal_handler(ni_dbus_connection_t *conn, ni_dbus_message_t *msg, void *user_data)
{
ni_dbus_addrconf_forwarder_t *forwarder = user_data;
const char *signal_name = dbus_message_get_member(msg);
ni_netdev_t *ifp;
ni_addrconf_lease_t *lease = NULL;
ni_dbus_variant_t argv[16];
ni_uuid_t uuid = NI_UUID_INIT;
ni_event_t ifevent;
int argc, optind = 0;
memset(argv, 0, sizeof(argv));
argc = ni_dbus_message_get_args_variants(msg, argv, 16);
if (argc < 0) {
ni_error("%s: cannot parse arguments for signal %s", __func__, signal_name);
goto done;
}
ifp = ni_objectmodel_addrconf_path_to_device(dbus_message_get_path(msg));
if (ifp == NULL) {
ni_debug_dbus("%s: received signal %s for unknown interface %s", __func__,
signal_name, dbus_message_get_path(msg));
goto done;
}
lease = ni_addrconf_lease_new(forwarder->addrconf, forwarder->addrfamily);
if (argc != 1 && argc != 2) {
ni_warn("%s: ignoring %s event from %s: bad number of arguments (%u)",
__func__, signal_name, dbus_message_get_path(msg), argc);
goto done;
}
if (argc == 2 && !ni_dbus_variant_get_uuid(&argv[optind++], &uuid)) {
ni_debug_dbus("%s: unable to parse uuid argument", __func__);
goto done;
}
if (!ni_objectmodel_set_addrconf_lease(lease, &argv[optind++])) {
ni_error("%s: unable to parse lease argument received from %s", __func__,
dbus_message_get_sender(msg));
goto done;
}
ni_debug_dbus("received signal %s for interface %s (ifindex %d), lease %s:%s, uuid=%s, update=0x%x, flags=0x%x",
signal_name, ifp->name, ifp->link.ifindex,
ni_addrfamily_type_to_name(lease->family),
ni_addrconf_type_to_name(lease->type),
ni_uuid_print(&uuid), lease->update, lease->flags);
if (!strcmp(signal_name, NI_OBJECTMODEL_LEASE_ACQUIRED_SIGNAL)) {
if (lease->state != NI_ADDRCONF_STATE_GRANTED) {
ni_error("%s: unexpected lease state in signal %s", __func__, signal_name);
goto done;
}
ifevent = NI_EVENT_ADDRESS_ACQUIRED;
if (!__ni_addrconf_should_update(lease->update, NI_ADDRCONF_UPDATE_DEFAULT_ROUTE)) {
ni_route_table_t *tab;
ni_route_t *rp;
unsigned int i;
for (tab = lease->routes; tab; tab = tab->next) {
for (i = 0; i < tab->routes.count; ++i) {
if (!(rp = tab->routes.data[i]))
continue;
if (ni_sockaddr_is_specified(&rp->destination))
continue;
if (ni_route_array_delete(&tab->routes, i))
i--;
}
}
}
} else if (!strcmp(signal_name, NI_OBJECTMODEL_LEASE_RELEASED_SIGNAL)) {
lease->state = NI_ADDRCONF_STATE_RELEASED;
ifevent = NI_EVENT_ADDRESS_RELEASED;
} else if (!strcmp(signal_name, NI_OBJECTMODEL_LEASE_LOST_SIGNAL)) {
lease->state = NI_ADDRCONF_STATE_FAILED;
ifevent = NI_EVENT_ADDRESS_LOST;
} else {
/* Ignore unknown signal */
goto done;
}
/*
* The following call updates the system with the information given in
* the lease. This includes setting all addresses, as well as updating
* resolver and hostname, if provided.
* When a lease is dropped, we either fall back to the config information
* from the next best lease, or if there is none, we restore the original
* system settings.
*
* Note, lease may be NULL after this, as the interface object
* takes ownership of it.
*/
__ni_system_interface_update_lease(ifp, &lease);
/* Potentially, there's a client somewhere waiting for that event.
* We use the UUID that's passed back and forth to make sure we
* really match the event we were expecting to match.
*/
{
ni_dbus_object_t *object;
object = ni_objectmodel_get_netif_object(__ni_objectmodel_server, ifp);
if (object)
ni_objectmodel_send_netif_event(__ni_objectmodel_server, object,
ifevent, ni_uuid_is_null(&uuid)? NULL : &uuid);
}
done:
while (argc--)
ni_dbus_variant_destroy(&argv[argc]);
if (lease)
ni_addrconf_lease_free(lease);
}
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;
}
int
ni_dhcp4_fsm_commit_lease(ni_dhcp4_device_t *dev, ni_addrconf_lease_t *lease)
{
ni_capture_free(dev->capture);
dev->capture = NULL;
if (lease) {
ni_debug_dhcp("%s: committing lease", dev->ifname);
if (dev->config->dry_run == NI_DHCP4_RUN_NORMAL) {
ni_debug_dhcp("%s: schedule renewal of lease in %u seconds",
dev->ifname, lease->dhcp4.renewal_time);
ni_dhcp4_fsm_set_timeout(dev, lease->dhcp4.renewal_time);
}
/* If the user requested a specific route metric, apply it now */
if (dev->config) {
ni_route_table_t *tab;
ni_route_t *rp;
unsigned int i;
for (tab = lease->routes; tab; tab = tab->next) {
for (i = 0; i < tab->routes.count; ++i) {
if ((rp = tab->routes.data[i]) == NULL)
continue;
rp->protocol = RTPROT_DHCP;
rp->priority = dev->config->route_priority;
}
}
}
ni_dhcp4_device_set_lease(dev, lease);
dev->fsm.state = NI_DHCP4_STATE_BOUND;
ni_note("%s: Committed DHCPv4 lease with address %s "
"(lease time %u sec, renew in %u sec, rebind in %u sec)",
dev->ifname, inet_ntoa(lease->dhcp4.address),
lease->dhcp4.lease_time, lease->dhcp4.renewal_time,
lease->dhcp4.rebind_time);
/* Write the lease to lease cache */
if (dev->config->dry_run != NI_DHCP4_RUN_OFFER) {
ni_addrconf_lease_file_write(dev->ifname, lease);
}
/* Notify anyone who cares that we've (re-)acquired the lease */
ni_dhcp4_send_event(NI_DHCP4_EVENT_ACQUIRED, dev, lease);
if (dev->config->dry_run != NI_DHCP4_RUN_NORMAL) {
ni_dhcp4_fsm_restart(dev);
ni_dhcp4_device_stop(dev);
}
} else {
/* Delete old lease file */
if ((lease = dev->lease) != NULL) {
ni_note("%s: Dropped DHCPv4 lease with UUID %s",
dev->ifname, ni_uuid_print(&lease->uuid));
lease->state = NI_ADDRCONF_STATE_RELEASED;
ni_dhcp4_send_event(NI_DHCP4_EVENT_RELEASED, dev, lease);
if (!dev->config || dev->config->dry_run != NI_DHCP4_RUN_OFFER) {
ni_addrconf_lease_file_remove(dev->ifname, lease->type, lease->family);
}
ni_dhcp4_device_drop_lease(dev);
}
ni_dhcp4_fsm_restart(dev);
}
return 0;
}
/*
* Process a request to reconfigure the device (ie rebind a lease, or discover
* a new lease).
*/
int
ni_dhcp4_acquire(ni_dhcp4_device_t *dev, const ni_dhcp4_request_t *info)
{
ni_dhcp4_config_t *config;
const char *classid;
size_t len;
int rv;
if ((rv = ni_dhcp4_device_refresh(dev)) < 0)
return rv;
config = xcalloc(1, sizeof(*config));
config->dry_run = info->dry_run;
config->resend_timeout = NI_DHCP4_RESEND_TIMEOUT_INIT;
config->request_timeout = info->acquire_timeout?: NI_DHCP4_REQUEST_TIMEOUT;
config->initial_discovery_timeout = NI_DHCP4_DISCOVERY_TIMEOUT;
config->uuid = info->uuid;
config->flags = info->flags;
config->update = info->update;
config->route_priority = info->route_priority;
config->start_delay = info->start_delay;
config->recover_lease = info->recover_lease;
config->release_lease = info->release_lease;
config->max_lease_time = ni_dhcp4_config_max_lease_time();
if (config->max_lease_time == 0)
config->max_lease_time = ~0U;
if (info->lease_time && info->lease_time < config->max_lease_time)
config->max_lease_time = info->lease_time;
if ((len = ni_string_len(info->hostname)) > 0) {
if (ni_check_domain_name(info->hostname, len, 0)) {
strncpy(config->hostname, info->hostname, sizeof(config->hostname) - 1);
} else {
ni_debug_dhcp("Discarded request to use suspect hostname: '%s'",
ni_print_suspect(info->hostname, len));
}
}
if (info->clientid) {
ni_dhcp4_parse_client_id(&config->client_id, dev->system.hwaddr.type,
info->clientid);
} else {
/* Set client ID from interface hwaddr */
ni_dhcp4_set_client_id(&config->client_id, &dev->system.hwaddr);
}
if ((classid = info->vendor_class) == NULL)
classid = ni_dhcp4_config_vendor_class();
if (classid)
strncpy(config->classid, classid, sizeof(config->classid) - 1);
config->doflags = DHCP4_DO_DEFAULT;
config->doflags |= ni_dhcp4_do_bits(info->update);
if (ni_debug & NI_TRACE_DHCP) {
ni_trace("Received request:");
ni_trace(" acquire-timeout %u", config->request_timeout);
ni_trace(" lease-time %u", config->max_lease_time);
ni_trace(" start-delay %u", config->start_delay);
ni_trace(" hostname %s", config->hostname[0]? config->hostname : "<none>");
ni_trace(" vendor-class %s", config->classid[0]? config->classid : "<none>");
ni_trace(" client-id %s", ni_print_hex(config->client_id.data, config->client_id.len));
ni_trace(" uuid %s", ni_uuid_print(&config->uuid));
ni_trace(" update-flags %s", __ni_dhcp4_print_doflags(config->doflags));
ni_trace(" recover_lease %s", config->recover_lease ? "true" : "false");
ni_trace(" release_lease %s", config->release_lease ? "true" : "false");
}
ni_dhcp4_device_set_config(dev, config);
if (!dev->lease)
ni_dhcp4_recover_lease(dev);
if (dev->lease) {
if (!ni_addrconf_lease_is_valid(dev->lease)
|| (config->client_id.len && !ni_opaque_eq(&config->client_id, &dev->lease->dhcp4.client_id))) {
ni_debug_dhcp("%s: lease doesn't match request", dev->ifname);
ni_dhcp4_device_drop_lease(dev);
dev->notify = 1;
}
}
ni_note("%s: Request to acquire DHCPv4 lease with UUID %s",
dev->ifname, ni_uuid_print(&config->uuid));
if (ni_dhcp4_device_start(dev) < 0)
return -1;
return 1;
}