static ni_bool_t
ni_iaid_map_set_fallback_file(char **filename)
{
return ni_string_printf(filename, "%s/%s",
ni_config_statedir(),
NI_CONFIG_DEFAULT_IAID_FILE) != NULL;
}
static int
__ni_dhcp6_lease_ia_addr_to_xml(const ni_dhcp6_ia_addr_t *iadr, uint16_t type,
xml_node_t *node)
{
ni_sockaddr_t addr;
char *tmp = NULL;
ni_sockaddr_set_ipv6(&addr, iadr->addr, 0);
switch (type) {
case NI_DHCP6_OPTION_IA_TA:
case NI_DHCP6_OPTION_IA_NA:
xml_node_new_element("address", node, ni_sockaddr_print(&addr));
break;
case NI_DHCP6_OPTION_IA_PD:
ni_string_printf(&tmp, "%s/%u", ni_sockaddr_print(&addr), iadr->plen);
xml_node_new_element("prefix", node, tmp);
ni_string_free(&tmp);
break;
default:
return -1;
}
xml_node_new_element_uint("preferred-lft", node, iadr->preferred_lft);
xml_node_new_element_uint("valid-lft", node, iadr->valid_lft);
/* xml_node_new_element_uint("flags", node, iadr->flags); */
__ni_dhcp6_lease_status_to_xml(&iadr->status, node);
return 0;
}
static int
ni_do_duid_create(int argc, char **argv)
{
enum { OPT_HELP = 'h' };
static struct option options[] = {
{ "help", no_argument, NULL, OPT_HELP },
{ NULL, no_argument, NULL, 0 }
};
int opt = 0, status = NI_WICKED_RC_USAGE;
const char *type = NULL;
char *command = NULL;
optind = 1;
while ((opt = getopt_long(argc, argv, "+h", options, NULL)) != EOF) {
switch (opt) {
case OPT_HELP:
status = NI_WICKED_RC_SUCCESS;
default:
usage:
fprintf(stderr,
"Usage: %s [options] <ll|llt|en|uuid> ...\n"
"\n"
"Options:\n"
" --help, -h show this help text and exit.\n"
"\n", argv[0]);
goto cleanup;
}
}
if (optind >= argc || ni_string_empty(argv[optind])) {
fprintf(stderr, "%s: missing duid type argument\n\n", argv[0]);
goto usage;
}
type = argv[optind];
ni_string_printf(&command, "%s %s", argv[0], type);
argv[optind] = command;
if (ni_string_eq(type, "ll")) {
status = ni_do_duid_create_ll(argc - optind, argv + optind);
} else
if (ni_string_eq(type, "llt")) {
status = ni_do_duid_create_llt(argc - optind, argv + optind);
} else
if (ni_string_eq(type, "en")) {
status = ni_do_duid_create_en(argc - optind, argv + optind);
} else
if (ni_string_eq(type, "uuid")) {
status = ni_do_duid_create_uuid(argc - optind, argv + optind);
} else {
argv[optind] = (char *)type;
fprintf(stderr, "%s: unsupported duid type '%s'\n", argv[0],
ni_print_suspect(type, ni_string_len(type)));
goto usage;
}
argv[optind] = (char *)type;
cleanup:
ni_string_free(&command);
return status;
}
/*
* InfinibandChild.Factory.newDevice:
* Create a new infiniband child interface
*/
static ni_netdev_t *
__ni_objectmodel_ib_newchild(ni_netdev_t *cfg, const char *ifname, DBusError *error)
{
ni_netconfig_t *nc = ni_global_state_handle(0);
ni_netdev_t *dev = NULL;
const ni_infiniband_t *ib;
const char *err;
int rv;
ib = ni_netdev_get_infiniband(cfg);
if ((err = ni_infiniband_validate(NI_IFTYPE_INFINIBAND_CHILD,
ib, &cfg->link.lowerdev)) != NULL) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "%s", err);
return NULL;
}
if (ni_string_empty(ifname)) {
if (ni_string_empty(cfg->name) &&
!ni_string_printf(&cfg->name, "%s.%04x",
cfg->link.lowerdev.name, ib->pkey)) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"Unable to create infiniband child: "
"name argument missed, failed to construct");
return NULL;
}
ifname = NULL;
} else if (!ni_string_eq(cfg->name, ifname)) {
ni_string_dup(&cfg->name, ifname);
}
if (ni_string_eq(cfg->name, cfg->link.lowerdev.name)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"Cannot to create infiniband child: "
"child name %s equal with parent device name",
cfg->name);
return NULL;
}
if ((rv = ni_system_infiniband_child_create(nc, cfg, &dev)) < 0) {
if (rv != -NI_ERROR_DEVICE_EXISTS || !dev
|| (ifname && dev && !ni_string_eq(ifname, dev->name))) {
dbus_set_error(error,
DBUS_ERROR_FAILED,
"Unable to create infiniband child interface: %s",
ni_strerror(rv));
return NULL;
}
}
if (dev && dev->link.type != NI_IFTYPE_INFINIBAND_CHILD) {
dbus_set_error(error,
DBUS_ERROR_FAILED,
"Unable to create infiniband child interface %s: it exists with type %s",
cfg->name, ni_linktype_type_to_name(dev->link.type));
return NULL;
}
return dev;
}
static const char *
__ni_addrconf_lease_file_path(char **path, const char *dir,
const char *ifname, int type, int family)
{
const char *t = ni_addrconf_type_to_name(type);
const char *f = ni_addrfamily_type_to_name(family);
if (!path || ni_string_empty(dir) || ni_string_empty(ifname) || !t || !f)
return NULL;
return ni_string_printf(path, "%s/lease-%s-%s-%s.xml", dir, ifname, t, f);
}
static ni_bool_t
__ni_compat_generate_infiniband(xml_node_t *ifnode, const ni_compat_netdev_t *compat)
{
ni_infiniband_t *ib = ni_netdev_get_infiniband(compat->dev);
xml_node_t *child;
const char *value;
char *pkey = NULL;
switch (compat->dev->link.type) {
case NI_IFTYPE_INFINIBAND:
value = "infiniband";
break;
case NI_IFTYPE_INFINIBAND_CHILD:
value = "infiniband-child";
break;
default:
return FALSE;
}
if (!(child = xml_node_new(value, ifnode)))
return FALSE;
if ((value = ni_infiniband_get_mode_name(ib->mode)))
xml_node_new_element("mode", child, value);
if ((value = ni_infiniband_get_umcast_name(ib->umcast)))
xml_node_new_element("multicast", child, value);
if (ib->parent.name) {
if (!ni_string_printf(&pkey, "0x%04x", ib->pkey))
return FALSE;
xml_node_new_element("parent", child, ib->parent.name);
xml_node_new_element("pkey", child, pkey);
ni_string_free(&pkey);
}
return TRUE;
}
/*
* Install information from a lease, and remember that we did
*/
static ni_bool_t
ni_system_updater_install(ni_updater_t *updater, const ni_addrconf_lease_t *lease, const char *ifname)
{
ni_string_array_t arguments = NI_STRING_ARRAY_INIT;
const char *statedir = NULL;
char *file = NULL;
ni_bool_t result = FALSE;
int rv = 0;
ni_debug_ifconfig("Updating system %s settings from %s/%s lease",
ni_updater_name(updater->kind),
ni_addrconf_type_to_name(lease->type),
ni_addrfamily_type_to_name(lease->family));
if (!updater->proc_install)
return TRUE;
if (!ifname || (!updater->have_backup && !ni_system_updater_backup(updater, ifname)))
return FALSE;
ni_string_array_append(&arguments, "-i");
ni_string_array_append(&arguments, ifname);
ni_string_array_append(&arguments, "-t");
ni_string_array_append(&arguments, ni_addrconf_type_to_name(lease->type));
ni_string_array_append(&arguments, "-f");
ni_string_array_append(&arguments, ni_addrfamily_type_to_name(lease->family));
switch (updater->kind) {
case NI_ADDRCONF_UPDATER_GENERIC:
switch (updater->format) {
case NI_ADDRCONF_UPDATER_FORMAT_INFO:
ni_leaseinfo_dump(NULL, lease, ifname, NULL);
if (!(file = ni_leaseinfo_path(ifname, lease->type, lease->family))) {
ni_error("Unable to determine leaseinfo file path.");
goto done;
}
ni_string_array_append(&arguments, file);
break;
default:
ni_error("Unsupported %s updater data format.",
ni_updater_name(updater->kind));
goto done;
}
ni_string_array_append(&arguments,
ni_updater_format_name(updater->format));
break;
case NI_ADDRCONF_UPDATER_RESOLVER:
statedir = ni_extension_statedir(ni_updater_name(updater->kind));
if (!statedir) {
ni_error("failed to get %s statedir", ni_updater_name(updater->kind));
goto done;
}
ni_string_printf(&file, "%s/resolv.conf.%s.%s.%s",
statedir, ifname,
ni_addrconf_type_to_name(lease->type),
ni_addrfamily_type_to_name(lease->family));
ni_string_array_append(&arguments, file);
if ((rv = ni_resolver_write_resolv_conf(file, lease->resolver, NULL)) < 0) {
ni_error("failed to write resolver info to file: %s",
ni_strerror(rv));
goto done;
}
break;
case NI_ADDRCONF_UPDATER_HOSTNAME:
if (!ni_string_empty(lease->hostname)) {
ni_string_array_append(&arguments, lease->hostname);
} else {
const ni_address_t *ap;
char *name = NULL;
unsigned int count;
/* bnc#861476 workaround */
if (!can_try_reverse_lookup(lease))
goto done;
for (count = 0, ap = lease->addrs; ap; ap = ap->next) {
if (!ni_sockaddr_is_specified(&ap->local_addr))
continue;
if (!ni_resolve_reverse_timed(&ap->local_addr,
&name, NI_UPDATER_REVERSE_TIMEOUT))
break;
ni_info("Unable to resolve %s to hostname",
ni_sockaddr_print(&ap->local_addr));
if (++count >= NI_UPDATER_REVERSE_MAX_CNT)
break;
}
if (ni_string_empty(name)) {
ni_note("Skipping hostname update, none available");
goto done;
}
ni_string_array_append(&arguments, name);
ni_string_free(&name);
}
break;
default:
ni_error("cannot install new %s settings - file format not understood",
ni_updater_name(updater->kind));
goto done;
}
if (!ni_system_updater_run(updater->proc_install, &arguments)) {
ni_error("failed to install %s settings", ni_updater_name(updater->kind));
goto done;
}
result = TRUE;
switch (updater->kind) {
case NI_ADDRCONF_UPDATER_RESOLVER:
if (ni_global.other_event)
ni_global.other_event(NI_EVENT_RESOLVER_UPDATED);
break;
case NI_ADDRCONF_UPDATER_HOSTNAME:
if (ni_global.other_event)
ni_global.other_event(NI_EVENT_HOSTNAME_UPDATED);
break;
case NI_ADDRCONF_UPDATER_GENERIC:
if (ni_global.other_event)
ni_global.other_event(NI_EVENT_GENERIC_UPDATED);
break;
default:
break;
}
done:
if (file)
free(file);
ni_string_array_destroy(&arguments);
return result;
}
int
ni_do_duid(const char *caller, int argc, char **argv)
{
enum { OPT_HELP = 'h' };
static struct option options[] = {
{ "help", no_argument, NULL, OPT_HELP },
{ NULL, no_argument, NULL, 0 }
};
int opt = 0, status = NI_WICKED_RC_USAGE;
char *program = NULL;
char *command = NULL;
const char *cmd;
ni_string_printf(&program, "%s %s", caller ? caller : "wicked",
argv[0] ? argv[0] : "duid");
optind = 1;
argv[0] = program;
while ((opt = getopt_long(argc, argv, "+h", options, NULL)) != EOF) {
switch (opt) {
case OPT_HELP:
status = NI_WICKED_RC_SUCCESS;
default:
usage:
fprintf(stderr,
"\nUsage:\n"
" %s [common options] <command> [...]\n"
"\n"
"Common options:\n"
" --help, -h show this help text and exit.\n"
"\n"
"Supported commands:\n"
" help show this help text and exit.\n"
" dump, show show the duid map contents\n"
" get [options] get current duid\n"
" del [options] delete current duid\n"
" set [options] <duid> set/update the duid\n"
" create <type> [...] create a new duid\n"
"\n", argv[0]);
goto cleanup;
}
}
if (optind >= argc || ni_string_empty(argv[optind])) {
fprintf(stderr, "%s: missing command argument\n", argv[0]);
goto usage;
}
cmd = argv[optind];
ni_string_printf(&command, "%s %s", program, cmd);
argv[optind] = command;
if (ni_string_eq(cmd, "help")) {
argv[optind] = (char *)cmd;
status = NI_WICKED_RC_SUCCESS;
goto usage;
} else
if (ni_string_eq(cmd, "dump") || ni_string_eq(cmd, "show")) {
status = ni_do_duid_dump(argc - optind, argv + optind);
} else
if (ni_string_eq(cmd, "get")) {
status = ni_do_duid_get (argc - optind, argv + optind);
} else
if (ni_string_eq(cmd, "set")) {
status = ni_do_duid_set (argc - optind, argv + optind);
} else
if (ni_string_eq(cmd, "del")) {
status = ni_do_duid_del (argc - optind, argv + optind);
} else
if (ni_string_eq(cmd, "create")) {
status = ni_do_duid_create (argc - optind, argv + optind);
} else {
argv[optind] = (char *)cmd;
fprintf(stderr, "%s: unsupported command %s\n", program, (char *)cmd);
goto usage;
}
argv[optind] = (char *)cmd;
cleanup:
argv[0] = NULL;
ni_string_free(&command);
ni_string_free(&program);
return status;
}
void
__ni_compat_generate_static_route(xml_node_t *aconf, const ni_route_t *rp, const char *ifname)
{
xml_node_t *rnode, *mnode, *knode;
char *tmp = NULL;
const char *ptr;
rnode = xml_node_new("route", aconf);
if (rp->destination.ss_family != AF_UNSPEC && rp->prefixlen != 0) {
xml_node_new_element("destination", rnode,
ni_sockaddr_prefix_print(&rp->destination, rp->prefixlen));
}
__ni_compat_generate_static_route_hops(rnode, &rp->nh, ifname);
knode = NULL;
if (rp->table != RT_TABLE_UNSPEC && rp->table != RT_TABLE_MAIN) {
if (!(ptr = ni_route_table_type_to_name(rp->table)))
ptr = ni_sprint_uint(rp->table);
if (knode == NULL)
knode = xml_node_new("kern", rnode);
xml_node_new_element("table", knode, ptr);
}
if (rp->type != RTN_UNSPEC && rp->type != RTN_UNICAST) {
if (!(ptr = ni_route_type_type_to_name(rp->type)))
ptr = ni_sprint_uint(rp->type);
if (knode == NULL)
knode = xml_node_new("kern", rnode);
xml_node_new_element("type", knode, ptr);
}
if (rp->scope != RT_SCOPE_UNIVERSE) {
if (!(ptr = ni_route_scope_type_to_name(rp->scope)))
ptr = ni_sprint_uint(rp->scope);
if (knode == NULL)
knode = xml_node_new("kern", rnode);
xml_node_new_element("scope", knode, ptr);
}
if (rp->protocol != RTPROT_UNSPEC && rp->protocol != RTPROT_BOOT) {
if (!(ptr = ni_route_protocol_type_to_name(rp->protocol)))
ptr = ni_sprint_uint(rp->protocol);
if (knode == NULL)
knode = xml_node_new("kern", rnode);
xml_node_new_element("protocol", knode, ptr);
}
if (rp->priority > 0) {
xml_node_new_element("priority", rnode, ni_sprint_uint(rp->priority));
}
if (ni_sockaddr_is_specified(&rp->pref_src)) {
xml_node_new_element("source", rnode, ni_sockaddr_print(&rp->pref_src));
}
if (rp->realm > 0) {
/* Hmm */
xml_node_new_element("realm", rnode, ni_sprint_uint(rp->realm));
}
if (rp->mark > 0 && ni_string_printf(&tmp, "0x%02x", rp->mark)) {
xml_node_new_element("mark", rnode, tmp);
ni_string_free(&tmp);
}
if (rp->flags > 0) {
ni_string_array_t names = NI_STRING_ARRAY_INIT;
xml_node_t *fnode = NULL;
unsigned int i;
ni_route_flags_get_names(rp->flags, &names);
for (i = 0; i < names.count; ++i) {
if (fnode == NULL)
fnode = xml_node_new("flags", rnode);
xml_node_new(names.data[i], fnode);
}
}
if (rp->tos > 0 && ni_string_printf(&tmp, "0x%02x", rp->tos)) {
xml_node_new_element("tos", rnode, tmp);
ni_string_free(&tmp);
}
mnode = xml_node_new("metrics", NULL);
__ni_compat_generate_static_route_metrics(mnode, rp);
if (mnode->children || mnode->attrs.count || mnode->cdata)
xml_node_add_child(rnode, mnode);
else
xml_node_free(mnode);
}
static ni_bool_t
__ni_compat_generate_wireless(xml_node_t *ifnode, const ni_compat_netdev_t *compat)
{
ni_wireless_t *wlan;
ni_wireless_network_t *net;
xml_node_t *wireless, *network, *wep, *wpa_psk, *wpa_eap;
ni_wireless_blob_t *cert;
char *tmp = NULL;
const char *value;
int i, count, key_i;
wlan = ni_netdev_get_wireless(compat->dev);
if (!(wireless = xml_node_create(ifnode, "wireless"))) {
return FALSE;
}
if (ni_string_len(wlan->conf.country) == 2) {
xml_node_new_element("country", wireless, wlan->conf.country);
}
if (wlan->conf.ap_scan <= NI_WIRELESS_AP_SCAN_SUPPLICANT_EXPLICIT_MATCH &&
ni_string_printf(&tmp, "%u", wlan->conf.ap_scan)) {
xml_node_new_element("ap-scan", wireless, tmp);
ni_string_free(&tmp);
}
if (!ni_string_empty(wlan->conf.driver))
xml_node_new_element("wpa-driver", wireless, wlan->conf.driver);
count = wlan->conf.networks.count;
for (i = 0; i < count; i++) {
net = wlan->conf.networks.data[i];
if (!(network = xml_node_new("network", wireless)))
return FALSE;
if (net->essid.len > 0) {
ni_string_set(&tmp, (const char *) net->essid.data, net->essid.len);
xml_node_new_element("essid", network, tmp);
ni_string_free(&tmp);
}
xml_node_new_element("scan-ssid", network, net->scan_ssid?"true":"false");
if (net->priority > 0 &&
ni_string_printf(&tmp, "%u", net->priority)) {
xml_node_new_element("priority", network, tmp);
ni_string_free(&tmp);
}
if ((value = ni_wireless_mode_to_name(net->mode))) {
xml_node_new_element("mode", network, value);
}
if (net->access_point.len > 0) {
xml_node_new_element("access-point", network,
ni_link_address_print(&net->access_point));
}
if (net->channel > 0 &&
ni_string_printf(&tmp, "%u", net->channel)) {
xml_node_new_element("channel", network, tmp);
ni_string_free(&tmp);
}
if (net->fragment_size > 0 &&
ni_string_printf(&tmp, "%u", net->fragment_size)) {
xml_node_new_element("fragment-size", network, tmp);
ni_string_free(&tmp);
}
if ((value = ni_wireless_key_management_to_name(net->keymgmt_proto))) {
xml_node_new_element("key-management", network, value);
}
switch (net->keymgmt_proto) {
case NI_WIRELESS_KEY_MGMT_NONE:
if (!(wep = xml_node_new("wep", network))) {
return FALSE;
}
if ((value = ni_wireless_auth_algo_to_name(net->auth_algo))) {
xml_node_new_element("auth-algo", wep, value);
}
if (net->default_key < NI_WIRELESS_WEP_KEY_COUNT &&
ni_string_printf(&tmp, "%u", net->default_key)) {
xml_node_new_element("default-key", wep, tmp);
ni_string_free(&tmp);
}
for (key_i = 0; key_i < NI_WIRELESS_WEP_KEY_COUNT; key_i++) {
if (!ni_string_empty(net->wep_keys[key_i])) {
/* To be secured */
xml_node_new_element("key", wep, net->wep_keys[key_i]);
}
}
break;
case NI_WIRELESS_KEY_MGMT_PSK:
if (!(wpa_psk = xml_node_new("wpa-psk", network))) {
return FALSE;
}
if (!ni_string_empty(net->wpa_psk.passphrase)) {
/* To be secured */
xml_node_new_element("passphrase", wpa_psk,
net->wpa_psk.passphrase);
}
if ((value = ni_wireless_auth_mode_to_name(net->auth_proto))) {
xml_node_new_element("auth-proto", wpa_psk, value);
}
if ((value = ni_wireless_cipher_to_name(net->pairwise_cipher))) {
xml_node_new_element("pairwise-cipher", wpa_psk, value);
}
if ((value = ni_wireless_cipher_to_name(net->group_cipher))) {
xml_node_new_element("group-cipher", wpa_psk, value);
}
break;
case NI_WIRELESS_KEY_MGMT_EAP:
if (!(wpa_eap = xml_node_new("wpa-eap", network))) {
return FALSE;
}
if ((value = ni_wireless_eap_method_to_name(net->wpa_eap.method))) {
xml_node_new_element("method", wpa_eap, value);
}
if ((value = ni_wireless_auth_mode_to_name(net->auth_proto))) {
xml_node_new_element("auth-proto", wpa_eap, value);
}
if ((value = ni_wireless_cipher_to_name(net->pairwise_cipher))) {
xml_node_new_element("pairwise-cipher", wpa_eap, value);
}
if ((value = ni_wireless_cipher_to_name(net->group_cipher))) {
xml_node_new_element("group-cipher", wpa_eap, value);
}
if (!ni_string_empty(net->wpa_eap.identity)) {
xml_node_new_element("identity", wpa_eap, net->wpa_eap.identity);
}
xml_node_t *phase1 = xml_node_new("phase1", wpa_eap);
if (ni_string_printf(&tmp, "%u", net->wpa_eap.phase1.peapver)) {
xml_node_new_element("peap-version", phase1, tmp);
ni_string_free(&tmp);
}
xml_node_t *phase2 = xml_node_new("phase2", wpa_eap);
if ((value = ni_wireless_eap_method_to_name(net->wpa_eap.phase2.method))) {
xml_node_new_element("method", phase2, value);
}
if (!ni_string_empty(net->wpa_eap.phase2.password)) {
/* To be secured */
xml_node_new_element("password", phase2,
net->wpa_eap.phase2.password);
}
if (!ni_string_empty(net->wpa_eap.anonid)) {
xml_node_new_element("anonid", wpa_eap, net->wpa_eap.anonid);
}
xml_node_t *tls = xml_node_new("tls", wpa_eap);
if ((cert = net->wpa_eap.tls.ca_cert)) {
if (!ni_string_empty(cert->name)) {
xml_node_new_element("ca-cert", tls, cert->name);
/* FIXME/ADDME file data and size exporting */
}
}
if ((cert = net->wpa_eap.tls.client_cert)) {
if (!ni_string_empty(cert->name)) {
xml_node_new_element("client-cert", tls, cert->name);
/* FIXME/ADDME file data and size exporting */
}
}
if ((cert = net->wpa_eap.tls.client_key)) {
if (!ni_string_empty(cert->name)) {
xml_node_new_element("client-key", tls, cert->name);
/* FIXME/ADDME file data and size exporting */
}
}
if (!ni_string_empty(net->wpa_eap.tls.client_key_passwd)) {
xml_node_new_element("client-key-passwd", tls,
net->wpa_eap.tls.client_key_passwd);
/* FIXME/ADDME file data and size exporting */
}
break;
default:
return FALSE;
break;
}
}
return TRUE;
}
static ni_bool_t
__ni_compat_generate_bridge(xml_node_t *ifnode, const ni_compat_netdev_t *compat)
{
ni_bridge_t *bridge;
xml_node_t *child;
xml_node_t *ports;
unsigned int i;
char *tmp = NULL;
bridge = ni_netdev_get_bridge(compat->dev);
child = xml_node_create(ifnode, "bridge");
xml_node_new_element("stp", child, bridge->stp ? "true" : "false");
if (bridge->priority != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%u", bridge->priority)) {
xml_node_new_element("priority", child, tmp);
ni_string_free(&tmp);
}
if (bridge->forward_delay != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%.2f", bridge->forward_delay)) {
xml_node_new_element("forward-delay", child, tmp);
ni_string_free(&tmp);
}
if (bridge->ageing_time != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%.2f", bridge->ageing_time)) {
xml_node_new_element("aging-time", child, tmp);
ni_string_free(&tmp);
}
if (bridge->hello_time != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%.2f", bridge->hello_time)) {
xml_node_new_element("hello-time", child, tmp);
ni_string_free(&tmp);
}
if (bridge->max_age != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%.2f", bridge->max_age)) {
xml_node_new_element("max-age", child, tmp);
ni_string_free(&tmp);
}
ports = xml_node_new("ports", child);
for (i = 0; i < bridge->ports.count; ++i) {
const ni_bridge_port_t *port = bridge->ports.data[i];
xml_node_t *portnode = xml_node_new("port", ports);
xml_node_new_element("device", portnode, port->ifname);
if (port->priority != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%u", port->priority)) {
xml_node_new_element("priority", portnode, tmp);
ni_string_free(&tmp);
}
if (port->path_cost != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%u", port->path_cost)) {
xml_node_new_element("path-cost", portnode, tmp);
ni_string_free(&tmp);
}
}
return TRUE;
}
int
ni_do_test_dhcp4(const char *caller, int argc, char **argv)
{
enum {
OPT_HELP = 'h',
OPT_TEST_TIMEOUT = 't',
OPT_TEST_REQUEST = 'r',
OPT_TEST_OUTPUT = 'o',
OPT_TEST_OUTFMT = 'F',
};
static struct option options[] = {
{ "help", no_argument, NULL, OPT_HELP },
{ "request", required_argument, NULL, OPT_TEST_REQUEST},
{ "timeout", required_argument, NULL, OPT_TEST_TIMEOUT},
{ "output", required_argument, NULL, OPT_TEST_OUTPUT },
{ "format", required_argument, NULL, OPT_TEST_OUTFMT },
{ NULL, no_argument, NULL, 0 }
};
int opt = 0, status = NI_WICKED_RC_USAGE;
char *program = NULL;
ni_dhcp4_tester_t *tester;
ni_string_printf(&program, "%s %s", caller ? caller : "wicked",
argv[0] ? argv[0] : "test");
argv[0] = program;
tester = ni_dhcp4_tester_init();
if (tester == NULL) {
fprintf(stderr, "Error: %s: unable to initialize dhcp4 tester\n", program);
status = NI_WICKED_RC_ERROR;
goto cleanup;
}
optind = 1;
while ((opt = getopt_long(argc, argv, "+hr:t:o:F:", options, NULL)) != EOF) {
switch (opt) {
case OPT_HELP:
status = NI_WICKED_RC_SUCCESS;
default:
usage:
fprintf(stderr,
"\nUsage:\n"
" %s [options] <ifname>\n"
"\n"
"Options:\n"
" --help, -h show this help text and exit.\n"
"\n"
" --timeout, -t <timeout in sec> (default: 20+10)\n"
" --request, -r <request.xml>\n"
" --output, -o <output file name>\n"
" --format, -F <leaseinfo|lease-xml>\n"
"\n", program);
goto cleanup;
case OPT_TEST_TIMEOUT:
if (ni_string_empty(optarg))
goto usage;
if (ni_parse_uint(optarg, &tester->timeout, 0) < 0) {
fprintf(stderr, "%s: unable to parse timeout option '%s'\n",
program, optarg);
status = NI_WICKED_RC_ERROR;
goto cleanup;
}
break;
case OPT_TEST_REQUEST:
if (ni_string_empty(optarg))
goto usage;
tester->request = optarg;
break;
case OPT_TEST_OUTPUT:
if (ni_string_empty(optarg))
goto usage;
tester->output = optarg;
break;
case OPT_TEST_OUTFMT:
if (ni_string_empty(optarg))
goto usage;
if (!ni_dhcp4_tester_set_outfmt(optarg, &tester->outfmt)) {
fprintf(stderr, "%s: unable to parse output format option '%s'\n",
program, optarg);
status = NI_WICKED_RC_ERROR;
goto cleanup;
}
break;
}
}
if (optind >= argc || ni_string_empty(argv[optind])) {
fprintf(stderr, "Error: %s: missing interface name argument\n", program);
goto usage;
} else
if (optind + 1 != argc) {
fprintf(stderr, "Error: %s: multiple interface names not supported\n", program);
goto cleanup;
}
ni_netconfig_set_family_filter(ni_global_state_handle(0), AF_INET);
ni_netconfig_set_discover_filter(ni_global_state_handle(0),
NI_NETCONFIG_DISCOVER_LINK_EXTERN);
tester->ifname = argv[optind];
status = ni_dhcp4_tester_run(tester);
cleanup:
ni_string_free(&program);
return status;
}
int
ni_do_test(const char *caller, int argc, char **argv)
{
enum { OPT_HELP = 'h' };
static struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ NULL, no_argument, NULL, 0 }
};
int opt = 0, status = NI_WICKED_RC_USAGE;
char *program = NULL;
const char *cmd;
ni_string_printf(&program, "%s %s", caller ? caller : "wicked",
argv[0] ? argv[0] : "test");
argv[0] = program;
optind = 1;
while ((opt = getopt_long(argc, argv, "+h", options, NULL)) != EOF) {
switch (opt) {
case OPT_HELP:
status = NI_WICKED_RC_SUCCESS;
default:
usage:
fprintf(stderr,
"\nUsage:\n"
" %s <command>\n"
"\n"
"Options:\n"
" --help, -h show this help text and exit.\n"
"\n"
"Commands:\n"
" dhcp4 [options...]\n"
" dhcp6 [options...]\n"
"\n", program);
goto cleanup;
}
}
if (optind >= argc || ni_string_empty(argv[optind])) {
fprintf(stderr, "%s: missing command\n", program);
goto usage;
}
cmd = argv[optind];
if (ni_string_eq(cmd, "help")) {
status = NI_WICKED_RC_SUCCESS;
goto usage;
} else
if (ni_string_eq(cmd, "dhcp4")) {
status = ni_do_test_dhcp4(program, argc - optind, argv + optind);
} else
if (ni_string_eq(cmd, "dhcp6")) {
status = ni_do_test_dhcp6(program, argc - optind, argv + optind);
} else {
fprintf(stderr, "%s: unsupported command %s\n", program, cmd);
goto usage;
}
cleanup:
ni_string_free(&program);
return status;
}
