static dbus_bool_t
ni_objectmodel_ethtool_link_adv_unknown_into_dict(ni_dbus_variant_t *dict,
ni_bitfield_t *bitfield)
{
char *hexstr = NULL;
unsigned int words;
words = ni_bitfield_words(bitfield);
while (words) {
if (!bitfield->field[words - 1])
words--;
else
break;
}
if (!dict || !words)
return FALSE;
if (!ni_bitfield_format(bitfield, &hexstr, TRUE) || !hexstr)
return FALSE;
if (!ni_dbus_dict_add_string(dict, "unknown", hexstr)) {
ni_string_free(&hexstr);
return FALSE;
}
ni_string_free(&hexstr);
return TRUE;
}
void
ni_dhcp4_device_free(ni_dhcp4_device_t *dev)
{
ni_dhcp4_device_t **pos;
ni_assert(dev->users == 0);
ni_debug_dhcp("%s: Deleting dhcp4 device with index %u",
dev->ifname, dev->link.ifindex);
ni_dhcp4_device_drop_buffer(dev);
ni_dhcp4_device_drop_lease(dev);
ni_dhcp4_device_drop_best_offer(dev);
ni_dhcp4_device_close(dev);
ni_string_free(&dev->system.ifname);
ni_string_free(&dev->ifname);
/* Drop existing config and request */
ni_dhcp4_device_set_config(dev, NULL);
ni_dhcp4_device_set_request(dev, NULL);
for (pos = &ni_dhcp4_active; *pos; pos = &(*pos)->next) {
if (*pos == dev) {
*pos = dev->next;
break;
}
}
free(dev);
}
static void
__xpath_expression_eval_print_input(const xpath_enode_t *enode,
const xpath_result_t *left,
const xpath_result_t *right)
{
char *leftval = NULL, *rightval = NULL;
const char *name;
char namebuf[256];
if (enode->ops->print) {
name = enode->ops->print(enode);
} else if (enode->identifier == NULL) {
name = enode->ops->name;
} else {
snprintf(namebuf, sizeof(namebuf), "%s %s",
enode->ops->name,
enode->identifier);
name = namebuf;
}
if (left)
leftval = __xpath_node_array_print_short(left);
if (right)
rightval = __xpath_node_array_print_short(right);
if (leftval == NULL)
xtrace(" EVAL %s []", name);
else if (rightval == NULL)
xtrace(" EVAL %s %s", name, leftval);
else
xtrace(" EVAL %s %s %s", name, leftval, rightval);
ni_string_free(&leftval);
ni_string_free(&rightval);
}
static ni_bool_t
ni_set_global_config_dir(const char *pathname)
{
if (pathname == NULL) {
ni_string_free(&ni_global.config_dir);
ni_string_free(&ni_global.config_path);
return TRUE;
}
if (ni_isdir(pathname)) {
char *real = NULL;
if (*pathname != '/') {
/* resolve to absolute path */
if (ni_realpath(pathname, &real) == NULL)
return FALSE;
pathname = real;
}
if (ni_string_eq(WICKED_CONFIGDIR, pathname))
pathname = NULL;
ni_string_dup(&ni_global.config_dir, pathname);
ni_string_free(&real);
return TRUE;
}
errno = ENOTDIR;
return FALSE;
}
void
ni_bridge_status_destroy(ni_bridge_status_t *bs)
{
ni_string_free(&bs->root_id);
ni_string_free(&bs->bridge_id);
ni_string_free(&bs->group_addr);
memset(bs, 0, sizeof(*bs));
}
void
ni_c_binding_free(ni_c_binding_t *binding)
{
ni_string_free(&binding->name);
ni_string_free(&binding->library);
ni_string_free(&binding->symbol);
free(binding);
}
static void
ni_addrconf_lease_dhcp4_destroy(struct ni_addrconf_lease_dhcp4 *dhcp4)
{
if (dhcp4) {
ni_string_free(&dhcp4->boot_sname);
ni_string_free(&dhcp4->boot_file);
ni_string_free(&dhcp4->root_path);
ni_string_free(&dhcp4->message);
}
}
/*
* driver-info (GDRVINFO)
*/
void
ni_ethtool_driver_info_free(ni_ethtool_driver_info_t *info)
{
if (info) {
ni_string_free(&info->driver);
ni_string_free(&info->version);
ni_string_free(&info->fw_version);
ni_string_free(&info->bus_info);
ni_string_free(&info->erom_version);
free(info);
}
}
void
ni_wireless_config_destroy(ni_wireless_config_t *conf)
{
if (conf) {
ni_string_free(&conf->country);
ni_string_free(&conf->driver);
ni_wireless_network_array_destroy(&conf->networks);
memset(conf, 0, sizeof(*conf));
/* reset to ap scan default again */
conf->ap_scan = NI_WIRELESS_AP_SCAN_SUPPLICANT_AUTO;
}
}
void
ni_bridge_port_free(ni_bridge_port_t *port)
{
ni_string_free(&port->ifname);
ni_bridge_port_status_destroy(&port->status);
free(port);
}
ni_bool_t
ni_ifdown_fire_nanny(ni_ifworker_array_t *array)
{
unsigned int i;
char *policy_name;
/* Deleting all requested policies */
for (i = 0; i < array->count; i++) {
ni_ifworker_t *w = array->data[i];
policy_name = ni_ifpolicy_name_from_ifname(w->name);
if (!ni_ifdown_stop_policy(policy_name)) {
/* We ignore errors for now */;
}
ni_string_free(&policy_name);
}
/* Disabling all requested devices */
for (i = 0; i < array->count; i++) {
ni_ifworker_t *w = array->data[i];
ni_netdev_t *dev = w ? w->device : NULL;
/* Ignore non-existing device */
if (!dev || !ni_netdev_device_is_ready(dev)) {
continue;
}
if (!ni_ifdown_stop_device(w->name)) {
/* We ignore errors for now */;
}
}
return TRUE;
}
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;
}
void
xml_document_free(xml_document_t *doc)
{
xml_node_free(doc->root);
ni_string_free(&doc->dtd);
free(doc);
}
static int
__ni_rtevent_deladdr(ni_netconfig_t *nc, const struct sockaddr_nl *nladdr, struct nlmsghdr *h)
{
struct ifaddrmsg *ifa;
ni_address_t tmp, *ap;
ni_netdev_t *dev;
if (!(ifa = ni_rtnl_ifaddrmsg(h, RTM_DELADDR)))
return -1;
dev = ni_netdev_by_index(nc, ifa->ifa_index);
if (dev == NULL)
return 0;
if (__ni_rtnl_parse_newaddr(dev->link.ifflags, h, ifa, &tmp) < 0) {
ni_error("Problem parsing RTM_DELADDR message for %s", dev->name);
return -1;
}
if ((ap = ni_address_list_find(dev->addrs, &tmp.local_addr)) != NULL) {
__ni_netdev_addr_event(dev, NI_EVENT_ADDRESS_DELETE, ap);
__ni_address_list_remove(&dev->addrs, ap);
}
ni_string_free(&tmp.label);
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;
}
static void
ni_netdev_free(ni_netdev_t *dev)
{
/* Clear out linkinfo */
ni_string_free(&dev->link.qdisc);
ni_string_free(&dev->link.kind);
ni_string_free(&dev->link.alias);
ni_netdev_ref_destroy(&dev->link.lowerdev);
ni_netdev_ref_destroy(&dev->link.masterdev);
ni_netdev_slaveinfo_destroy(&dev->link.slave);
ni_netdev_set_link_stats(dev, NULL);
/* Clear out addresses, routes, ... */
ni_netdev_clear_addresses(dev);
ni_netdev_clear_routes(dev);
ni_netdev_set_ethernet(dev, NULL);
ni_netdev_set_infiniband(dev, NULL);
ni_netdev_set_bonding(dev, NULL);
ni_netdev_set_team(dev, NULL);
ni_netdev_set_bridge(dev, NULL);
ni_netdev_set_ovs_bridge(dev, NULL);
ni_netdev_set_vlan(dev, NULL);
ni_netdev_set_vxlan(dev, NULL);
ni_netdev_set_macvlan(dev, NULL);
ni_netdev_set_ipip(dev, NULL);
ni_netdev_set_sit(dev, NULL);
ni_netdev_set_gre(dev, NULL);
ni_netdev_set_wireless(dev, NULL);
ni_netdev_set_openvpn(dev, NULL);
ni_netdev_set_ppp(dev, NULL);
ni_netdev_set_dcb(dev, NULL);
ni_netdev_set_lldp(dev, NULL);
ni_netdev_set_client_state(dev, NULL);
ni_netdev_set_ipv4(dev, NULL);
ni_netdev_set_ipv6(dev, NULL);
ni_netdev_set_auto6(dev, NULL);
ni_netdev_set_pci(dev, NULL);
ni_netdev_set_ethtool(dev, NULL);
ni_netdev_clear_event_filters(dev);
ni_addrconf_lease_list_destroy(&dev->leases);
ni_string_free(&dev->name);
free(dev);
}
void
ni_netdev_req_free(ni_netdev_req_t *req)
{
ni_string_free(&req->alias);
ni_netdev_ref_destroy(&req->master);
ni_netdev_port_req_free(req->port);
free(req);
}
void
ni_netdev_ref_destroy(ni_netdev_ref_t *ref)
{
if (ref) {
ref->index = 0;
ni_string_free(&ref->name);
}
}
void
ni_config_free(ni_config_t *conf)
{
ni_string_array_destroy(&conf->sources.ifconfig);
ni_extension_list_destroy(&conf->dbus_extensions);
ni_extension_list_destroy(&conf->ns_extensions);
ni_extension_list_destroy(&conf->fw_extensions);
ni_extension_list_destroy(&conf->updater_extensions);
ni_string_free(&conf->dbus_name);
ni_string_free(&conf->dbus_type);
ni_string_free(&conf->dbus_xml_schema_file);
ni_config_fslocation_destroy(&conf->piddir);
ni_config_fslocation_destroy(&conf->storedir);
ni_config_fslocation_destroy(&conf->statedir);
ni_config_fslocation_destroy(&conf->backupdir);
free(conf);
}
static void
__ni_shellcmd_free(ni_shellcmd_t *cmd)
{
ni_string_free(&cmd->command);
ni_string_array_destroy(&cmd->argv);
ni_string_array_destroy(&cmd->environ);
free(cmd);
}
static void
get_ethtool_link_advertising(const char *type, ni_bitfield_t *bitfield)
{
ni_string_array_t tmp = NI_STRING_ARRAY_INIT;
char *hexstr = NULL;
unsigned int n;
if (!ni_bitfield_isset(bitfield) || !type)
return;
printf("\t%s:\n", type);
printf("\t\tautoneg: %s\n", ni_format_boolean(ni_ethtool_link_adv_autoneg(bitfield)));
ni_ethtool_link_adv_set_autoneg(bitfield, FALSE);
if (get_ethtool_link_adv_name_array(&tmp, bitfield, ni_ethtool_link_adv_port_name)) {
printf("\t\tport-types:\n");
for (n = 0; n < tmp.count; ++n) {
printf("\t\t\ttype: %s\n", tmp.data[n]);
}
}
ni_string_array_destroy(&tmp);
if (get_ethtool_link_adv_name_array(&tmp, bitfield, ni_ethtool_link_adv_speed_name)) {
printf("\t\tspeed-modes:\n");
for (n = 0; n < tmp.count; ++n) {
printf("\t\t\tmode: %s\n", tmp.data[n]);
}
}
ni_string_array_destroy(&tmp);
if (get_ethtool_link_adv_name_array(&tmp, bitfield, ni_ethtool_link_adv_pause_name)) {
printf("\t\tpause-frames:\n");
for (n = 0; n < tmp.count; ++n) {
printf("\t\t\ttype: %s\n", tmp.data[n]);
}
}
ni_string_array_destroy(&tmp);
if (get_ethtool_link_adv_name_array(&tmp, bitfield, ni_ethtool_link_adv_fec_name)) {
printf("\t\tfec-modes:\n");
for (n = 0; n < tmp.count; ++n) {
printf("\t\t\tmode: %s\n", tmp.data[n]);
}
}
ni_string_array_destroy(&tmp);
if (get_ethtool_link_adv_name_array(&tmp, bitfield, ni_ethtool_link_adv_port_name)) {
printf("\t\tport-types:\n");
for (n = 0; n < tmp.count; ++n) {
printf("\t\t\ttype: %s\n", tmp.data[n]);
}
}
ni_string_array_destroy(&tmp);
if (ni_bitfield_isset(bitfield) && ni_bitfield_format(bitfield, &hexstr, TRUE))
printf("\t\tunknown: %s\n", hexstr);
ni_string_free(&hexstr);
}
/*
* Run the netif firmware discovery scripts and return their output
* as an XML document.
* The optional from parameter allow to specify the firmware extension
* type (e.g. ibft) and a firmware type specific path (e.g. ethernet0),
* passed as last argument to the discovery script.
*/
xml_document_t *
ni_netconfig_firmware_discovery(const char *root, const char *from)
{
ni_buffer_t *buffer;
xml_document_t *doc;
char *path = NULL;
char *type = NULL;
/* sanity adjustments... */
if (ni_string_empty(root))
root = NULL;
if (ni_string_empty(from))
from = NULL;
else {
ni_string_dup(&type, from);
if ((path = strchr(type, ':')))
*path++ = '\0';
if (ni_string_empty(path))
path = NULL;
}
buffer = __ni_netconfig_firmware_discovery(root, type, path);
if (buffer == NULL) {
ni_string_free(&type);
return NULL;
}
ni_debug_ifconfig("%s: %s%sbuffer has %u bytes", __func__,
(from ? from : ""), (from ? " ": ""),
ni_buffer_count(buffer));
doc = xml_document_from_buffer(buffer, from);
ni_buffer_free(buffer);
ni_string_free(&type);
if (doc == NULL)
ni_error("%s: error processing document", __func__);
return doc;
}
static void
ni_addrconf_lease_dhcp6_destroy(struct ni_addrconf_lease_dhcp6 *dhcp6)
{
if (dhcp6) {
ni_dhcp6_status_destroy(&dhcp6->status);
ni_dhcp6_ia_list_destroy(&dhcp6->ia_list);
ni_string_free(&dhcp6->boot_url);
ni_string_array_destroy(&dhcp6->boot_params);
}
}
void
__ni_dbus_client_object_destroy(ni_dbus_object_t *object)
{
ni_dbus_client_object_t *cob;
if ((cob = object->client_object) != NULL) {
ni_string_free(&cob->default_interface);
cob->client = NULL;
free(cob);
object->client_object= NULL;
}
}
const char *
ni_duid_format_hex(char **hex, const ni_opaque_t *duid)
{
ni_string_free(hex);
if (duid->len > 0) {
size_t len = duid->len * 3 + 1;
*hex = xcalloc(1, len);
ni_format_hex(duid->data, duid->len, *hex, len);
}
return *hex;
}
static inline ni_bool_t
try_set_string(const ni_dbus_variant_t *var, char **value)
{
const char *string_value = NULL;
ni_string_free(value);
if (var != NULL && !ni_dbus_variant_get_string(var, &string_value))
return FALSE;
ni_string_dup(value, string_value);
return TRUE;
}
void
ni_team_link_watch_free(ni_team_link_watch_t *lw)
{
if (lw) switch (lw->type) {
case NI_TEAM_LINK_WATCH_ETHTOOL:
break;
case NI_TEAM_LINK_WATCH_ARP_PING:
ni_string_free(&lw->arp.source_host);
ni_string_free(&lw->arp.target_host);
break;
case NI_TEAM_LINK_WATCH_NSNA_PING:
ni_string_free(&lw->nsna.target_host);
break;
case NI_TEAM_LINK_WATCH_TIPC:
ni_string_free(&lw->tipc.bearer);
break;
default:
return;
}
free(lw);
}
void
ni_tempstate_finish(ni_tempstate_t *ts)
{
unsigned int i;
for (i = 0; i < ts->files.count; ++i) {
const char *filename = ts->files.data[i];
if (unlink(filename) < 0)
ni_warn("failed to remove %s: %m", filename);
}
if (ts->dirpath) {
ni_file_remove_recursively(ts->dirpath);
ni_string_free(&ts->dirpath);
}
ni_string_array_destroy(&ts->files);
ni_string_free(&ts->ident);
free(ts);
}
void
ni_addrconf_lease_destroy(ni_addrconf_lease_t *lease)
{
ni_addrconf_updater_free(&lease->updater);
if (lease->old) {
ni_addrconf_lease_free(lease->old);
lease->old = NULL;
}
ni_string_free(&lease->owner);
ni_string_free(&lease->hostname);
ni_address_list_destroy(&lease->addrs);
ni_route_tables_destroy(&lease->routes);
if (lease->nis) {
ni_nis_info_free(lease->nis);
lease->nis = NULL;
}
if (lease->resolver) {
ni_resolver_info_free(lease->resolver);
lease->resolver = NULL;
}
ni_string_array_destroy(&lease->ntp_servers);
ni_string_array_destroy(&lease->nds_servers);
ni_string_array_destroy(&lease->nds_context);
ni_string_free(&lease->nds_tree);
ni_string_array_destroy(&lease->netbios_name_servers);
ni_string_array_destroy(&lease->netbios_dd_servers);
ni_string_free(&lease->netbios_scope);
ni_string_array_destroy(&lease->slp_servers);
ni_string_array_destroy(&lease->slp_scopes);
ni_string_array_destroy(&lease->sip_servers);
ni_string_array_destroy(&lease->lpr_servers);
ni_string_array_destroy(&lease->log_servers);
ni_string_free(&lease->posix_tz_string);
ni_string_free(&lease->posix_tz_dbname);
switch (lease->type) {
case NI_ADDRCONF_DHCP:
switch (lease->family) {
case AF_INET:
ni_addrconf_lease_dhcp4_destroy(&lease->dhcp4);
break;
case AF_INET6:
ni_addrconf_lease_dhcp6_destroy(&lease->dhcp6);
break;
default: ;
}
break;
default: ;
}
}
/*
* Remove a lease file
*/
static void
__ni_addrconf_lease_file_remove(const char *dir, const char *ifname,
int type, int family)
{
char *filename = NULL;
if (!__ni_addrconf_lease_file_path(&filename, dir, ifname, type, family))
return;
if (ni_file_exists(filename) && unlink(filename) == 0)
ni_debug_dhcp("removed %s", filename);
ni_string_free(&filename);
}
