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; }