static ni_bool_t
ni_dhcp4_tester_req_init(ni_dhcp4_request_t *req, const char *request)
{
/* Apply some defaults */
req->dry_run = NI_DHCP4_RUN_OFFER;
req->update = ~0;
req->acquire_timeout = 10;
if (!ni_string_empty(request)) {
xml_document_t *doc;
if (!(doc = xml_document_read(request))) {
ni_error("Cannot parse dhcp4 request xml '%s'", request);
return FALSE;
}
if (!ni_dhcp4_tester_req_xml_init(req, doc)) {
xml_document_free(doc);
return FALSE;
}
xml_document_free(doc);
}
/* Always enter dry run mode */
if (ni_uuid_is_null(&req->uuid))
ni_uuid_generate(&req->uuid);
return TRUE;
}
/*
* Generic functions for static address configuration
*/
static dbus_bool_t
ni_objectmodel_addrconf_static_request(ni_dbus_object_t *object, unsigned int addrfamily,
unsigned int argc, const ni_dbus_variant_t *argv,
ni_dbus_message_t *reply, DBusError *error)
{
ni_addrconf_lease_t *lease = NULL;
const ni_dbus_variant_t *dict;
const char *string_value;
ni_netdev_t *dev;
ni_address_t *ap;
int rv;
if (!(dev = ni_objectmodel_unwrap_netif(object, error)))
return FALSE;
if (argc != 1 || !ni_dbus_variant_is_dict(&argv[0])) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"requestLease: expected one dict argument");
return FALSE;
}
dict = &argv[0];
lease = ni_addrconf_lease_new(NI_ADDRCONF_STATIC, addrfamily);
lease->state = NI_ADDRCONF_STATE_GRANTED;
ni_uuid_generate(&lease->uuid);
if (!__ni_objectmodel_set_address_dict(&lease->addrs, dict, error)
|| !__ni_objectmodel_set_route_dict(&lease->routes, dict, error)
|| !__ni_objectmodel_set_resolver_dict(&lease->resolver, dict, error)) {
ni_addrconf_lease_free(lease);
return FALSE;
}
if (__ni_objectmodel_get_domain_string(dict, "hostname", &string_value))
ni_string_dup(&lease->hostname, string_value);
/* mark all addresses tentative, causing to verify them */
for (ap = lease->addrs; ap; ap = ap->next)
ni_address_set_tentative(ap, TRUE);
rv = __ni_system_interface_update_lease(dev, &lease);
if (lease)
ni_addrconf_lease_free(lease);
if (rv < 0) {
dbus_set_error(error,
DBUS_ERROR_FAILED,
"Error configuring static %s addresses: %s",
ni_addrfamily_type_to_name(addrfamily),
ni_strerror(rv));
return FALSE;
}
/* Don't return anything. */
return TRUE;
}
/*
* Handle event filters
*/
static ni_event_filter_t *
__ni_event_filter_new(unsigned int mask)
{
ni_event_filter_t *efp;
efp = xcalloc(1, sizeof(*efp));
ni_uuid_generate(&efp->uuid);
efp->event_mask = mask;
return efp;
}
/*
* Forward an addrconf request to a supplicant service, such as DHCP or zeroconf
*
* What we do here is:
*
* - create an addrconf request handle, and register it with the interface
* - assign a uuid
* - assign an event ID
* - forward the request, along with the uuid
* - when we receive a lease event with the matching uuid,
* broadcast a corresponding interface event (with the assigned even ID)
*
* Note, we do not record the contents of the addrconf request, which may be totally
* free-form. We just pass it on to the respective addrconf service.
*/
static dbus_bool_t
ni_objectmodel_addrconf_forward_request(ni_dbus_addrconf_forwarder_t *forwarder,
ni_netdev_t *dev, const ni_dbus_variant_t *dict,
ni_dbus_message_t *reply, DBusError *error)
{
ni_addrconf_lease_t *lease;
ni_uuid_t req_uuid;
dbus_bool_t rv, enabled;
uint32_t flags = 0;
/* Check whether we already have a lease on this interface. */
lease = ni_netdev_get_lease(dev, forwarder->addrfamily, forwarder->addrconf);
/* Generate a uuid and assign an event ID */
ni_uuid_generate(&req_uuid);
/* If the caller tells us to disable this addrconf family, we may need
* to do a release() call. */
if (!ni_dbus_dict_get_bool(dict, "enabled", &enabled) || !enabled)
return ni_objectmodel_addrconf_forward_release(forwarder, dev, NULL, reply, error);
if (!ni_dbus_dict_get_uint32(dict, "flags", &flags))
flags = 0;
if (lease == NULL) {
/* We didn't have a lease for this address family and addrconf protocol yet.
* Create one and track it. */
lease = ni_addrconf_lease_new(forwarder->addrconf, forwarder->addrfamily);
ni_netdev_set_lease(dev, lease);
}
lease->uuid = req_uuid;
lease->state = NI_ADDRCONF_STATE_REQUESTING;
lease->flags = flags;
rv = ni_objectmodel_addrconf_forwarder_call(forwarder, dev, "acquire", &req_uuid, dict, error);
if (rv) {
/* Tell the client to wait for an addressAcquired event with the given uuid */
rv = __ni_objectmodel_return_callback_info(reply, NI_EVENT_ADDRESS_ACQUIRED, &req_uuid, error);
}
return rv;
}
