static ni_netdev_t *
__ni_objectmodel_dummy_newlink(ni_netdev_t *cfg_ifp, const char *ifname, DBusError *error)
{
ni_netconfig_t *nc = ni_global_state_handle(0);
ni_netdev_t *dev_ifp = NULL;
int rv;
if (ni_string_empty(ifname)) {
if (ni_string_empty(cfg_ifp->name) &&
(ifname = ni_netdev_make_name(nc, "dummy", 0))) {
ni_string_dup(&cfg_ifp->name, ifname);
} else {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"Unable to create dummy interface: "
"name argument missed");
goto out;
}
ifname = NULL;
} else if(!ni_string_eq(cfg_ifp->name, ifname)) {
ni_string_dup(&cfg_ifp->name, ifname);
}
if (cfg_ifp->link.hwaddr.len) {
if (cfg_ifp->link.hwaddr.type == ARPHRD_VOID)
cfg_ifp->link.hwaddr.type = ARPHRD_ETHER;
if (cfg_ifp->link.hwaddr.type != ARPHRD_ETHER ||
cfg_ifp->link.hwaddr.len != ni_link_address_length(ARPHRD_ETHER)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"Cannot create dummy interface: "
"invalid ethernet address '%s'",
ni_link_address_print(&cfg_ifp->link.hwaddr));
return NULL;
}
}
if ((rv = ni_system_dummy_create(nc, cfg_ifp, &dev_ifp)) < 0) {
if (rv != -NI_ERROR_DEVICE_EXISTS || dev_ifp == NULL
|| (ifname && dev_ifp && !ni_string_eq(dev_ifp->name, ifname))) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"Unable to create dummy interface: %s",
ni_strerror(rv));
dev_ifp = NULL;
goto out;
}
ni_debug_dbus("dummy interface exists (and name matches)");
}
if (dev_ifp->link.type != NI_IFTYPE_DUMMY) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"Unable to create dummy interface: "
"new interface is of type %s",
ni_linktype_type_to_name(dev_ifp->link.type));
dev_ifp = NULL;
}
out:
if (cfg_ifp)
ni_netdev_put(cfg_ifp);
return dev_ifp;
}
int
ni_ethtool_get_driver_info(const char *ifname, ni_ethtool_t *ethtool)
{
static const ni_ethtool_cmd_info_t NI_ETHTOOL_CMD_GDRVINFO = {
ETHTOOL_GDRVINFO, "get driver-info"
};
struct ethtool_drvinfo drv_info;
ni_ethtool_driver_info_t *info;
int ret;
if (!ni_ethtool_supported(ethtool, NI_ETHTOOL_SUPP_GET_DRIVER_INFO))
return -EOPNOTSUPP;
ni_ethtool_driver_info_free(ethtool->driver_info);
ethtool->driver_info = NULL;
memset(&drv_info, 0, sizeof(drv_info));
ret = ni_ethtool_call(ifname, &NI_ETHTOOL_CMD_GDRVINFO, &drv_info, NULL);
ni_ethtool_set_supported(ethtool, NI_ETHTOOL_SUPP_GET_DRIVER_INFO,
ret != -EOPNOTSUPP);
if (ret < 0)
return ret;
if (!(info = ni_ethtool_driver_info_new()))
return -ENOMEM;
drv_info.driver[sizeof(drv_info.driver)-1] = '\0';
if (!ni_string_empty(drv_info.driver) && !ni_string_eq(drv_info.driver, "N/A"))
ni_string_dup(&info->driver, drv_info.driver);
drv_info.version[sizeof(drv_info.version)-1] = '\0';
if (!ni_string_empty(drv_info.version) && !ni_string_eq(drv_info.version, "N/A"))
ni_string_dup(&info->version, drv_info.version);
drv_info.fw_version[sizeof(drv_info.fw_version)-1] = '\0';
if (!ni_string_empty(drv_info.fw_version) && !ni_string_eq(drv_info.fw_version, "N/A"))
ni_string_dup(&info->fw_version, drv_info.fw_version);
drv_info.bus_info[sizeof(drv_info.bus_info)-1] = '\0';
if (!ni_string_empty(drv_info.bus_info) && !ni_string_eq(drv_info.bus_info, "N/A"))
ni_string_dup(&info->bus_info, drv_info.bus_info);
drv_info.erom_version[sizeof(drv_info.erom_version)-1] = '\0';
if (!ni_string_empty(drv_info.erom_version) && !ni_string_eq(drv_info.erom_version, "N/A"))
ni_string_dup(&info->erom_version, drv_info.erom_version);
if ((info->supports.n_priv_flags = drv_info.n_priv_flags))
info->supports.bitmap |= NI_BIT(NI_ETHTOOL_DRIVER_SUPP_PRIV_FLAGS);
if ((info->supports.n_stats = drv_info.n_stats))
info->supports.bitmap |= NI_BIT(NI_ETHTOOL_DRIVER_SUPP_STATS);
if ((info->supports.testinfo_len = drv_info.testinfo_len))
info->supports.bitmap |= NI_BIT(NI_ETHTOOL_DRIVER_SUPP_TEST);
if ((info->supports.eedump_len = drv_info.eedump_len))
info->supports.bitmap |= NI_BIT(NI_ETHTOOL_DRIVER_SUPP_EEPROM);
if ((info->supports.regdump_len = drv_info.regdump_len))
info->supports.bitmap |= NI_BIT(NI_ETHTOOL_DRIVER_SUPP_REGDUMP);
ethtool->driver_info = info;
return 0;
}
static dbus_bool_t
__ni_objectmodel_team_link_watch_from_dict(ni_team_link_watch_t *lw, const ni_dbus_variant_t *dict,
DBusError *error, const ni_dbus_property_t *property)
{
const char *string;
dbus_bool_t bvalue;
uint32_t value;
if (!lw || !dict || !error)
return FALSE;
switch(lw->type) {
case NI_TEAM_LINK_WATCH_ETHTOOL:
if (ni_dbus_dict_get_uint32(dict, "delay_up", &value))
lw->ethtool.delay_up = value;
if (ni_dbus_dict_get_uint32(dict, "delay_down", &value))
lw->ethtool.delay_down = value;
break;
case NI_TEAM_LINK_WATCH_ARP_PING:
if (ni_dbus_dict_get_string(dict, "source_host", &string))
ni_string_dup(&lw->arp.source_host, string);
if (ni_dbus_dict_get_string(dict, "target_host", &string))
ni_string_dup(&lw->arp.target_host, string);
if (ni_dbus_dict_get_uint32(dict, "interval", &value))
lw->arp.interval = value;
if (ni_dbus_dict_get_uint32(dict, "init_wait", &value))
lw->arp.init_wait = value;
if (ni_dbus_dict_get_bool(dict, "validate_active", &bvalue))
lw->arp.validate_active = bvalue;
if (ni_dbus_dict_get_bool(dict, "validate_inactive", &bvalue))
lw->arp.validate_inactive = bvalue;
if (ni_dbus_dict_get_bool(dict, "send_always", &bvalue))
lw->arp.send_always = bvalue;
if (ni_dbus_dict_get_uint32(dict, "missed_max", &value))
lw->arp.missed_max = value;
break;
case NI_TEAM_LINK_WATCH_NSNA_PING:
if (ni_dbus_dict_get_string(dict, "target_host", &string))
ni_string_dup(&lw->nsna.target_host, string);
if (ni_dbus_dict_get_uint32(dict, "interval", &value))
lw->nsna.interval = value;
if (ni_dbus_dict_get_uint32(dict, "init_wait", &value))
lw->nsna.init_wait = value;
if (ni_dbus_dict_get_uint32(dict, "missed_max", &value))
lw->nsna.missed_max = value;
break;
case NI_TEAM_LINK_WATCH_TIPC:
if (ni_dbus_dict_get_string(dict, "bearer", &string))
ni_string_dup(&lw->tipc.bearer, string);
break;
default:
return FALSE;
}
return TRUE;
}
void
ni_var_array_copy(ni_var_array_t *dst, const ni_var_array_t *src)
{
unsigned int i;
ni_var_array_destroy(dst);
__ni_var_array_realloc(dst, src->count);
for (i = 0; i < src->count; ++i) {
const ni_var_t *sv = &src->data[i];
ni_var_t *dv = &dst->data[i];
ni_string_dup(&dv->name, sv->name);
ni_string_dup(&dv->value, sv->value);
}
}
static dbus_bool_t
__ni_objectmodel_tuntap_newlink(ni_iftype_t iftype, ni_dbus_object_t *factory_object,
const ni_dbus_method_t *method,
unsigned int argc, const ni_dbus_variant_t *argv,
ni_dbus_message_t *reply, DBusError *error)
{
ni_dbus_server_t *server = ni_dbus_object_get_server(factory_object);
const char *ifname = NULL;
ni_netdev_t *dev;
ni_netdev_t *cfg;
NI_TRACE_ENTER();
ni_assert(argc == 2);
if (!ni_dbus_variant_get_string(&argv[0], &ifname) ||
!(cfg = __ni_objectmodel_tuntap_device_arg(&argv[1], iftype))) {
return ni_dbus_error_invalid_args(error,
factory_object->path,
method->name);
}
ni_string_dup(&cfg->name, ifname);
dev = __ni_objectmodel_tuntap_create(cfg, error);
ni_netdev_put(cfg);
if (!dev)
return FALSE;
return ni_objectmodel_netif_factory_result(server, reply, dev, NULL, error);
}
static ni_netdev_t *
ni_objectmodel_ppp_device_create(ni_netdev_t *cfg, const char *ifname, DBusError *error)
{
ni_netconfig_t *nc = ni_global_state_handle(0);
ni_netdev_t *dev = NULL;
int rv;
ni_netdev_get_ppp(cfg);
if (ifname == NULL && !(ifname = ni_netdev_make_name(nc, "ppp", 0))) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"Unable to create ppp interface - too many interfaces");
return NULL;
}
ni_string_dup(&cfg->name, ifname);
if ((rv = ni_system_ppp_create(nc, cfg, &dev)) < 0) {
dbus_set_error(error, DBUS_ERROR_FAILED, "Unable to create ppp interface '%s'",
cfg->name);
return NULL;
}
if (dev && dev->link.type != NI_IFTYPE_PPP) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"Unable to create ppp interface: new interface is of type %s",
ni_linktype_type_to_name(dev->link.type));
return NULL;
}
return dev;
}
int
ni_tempstate_mkdir(ni_tempstate_t *ts)
{
if (ts->dirpath == NULL) {
char pathbuf[PATH_MAX];
if (ts->ident != NULL) {
snprintf(pathbuf, sizeof(pathbuf), "%s/%s", ni_config_statedir(), ts->ident);
if (mkdir(pathbuf, 0700) < 0) {
ni_error("unable to create tempstate directory %s: %m", pathbuf);
return -1;
}
} else {
snprintf(pathbuf, sizeof(pathbuf), "%s/tempdirXXXXXX", ni_config_statedir());
if (!mkdtemp(pathbuf)) {
ni_error("unable to create tempstate directory: %m");
return -1;
}
}
ni_string_dup(&ts->dirpath, pathbuf);
}
return 0;
}
static dbus_bool_t
__ni_objectmodel_bridge_port_from_dict(ni_bridge_port_t *port, const ni_dbus_variant_t *dict,
DBusError *error,
int config_only)
{
const char *string;
uint32_t value;
if (dict->array.len == 0)
return TRUE;
/* FIXME: should expect object path here and map that to an ifindex */
if (ni_dbus_dict_get_string(dict, "device", &string) && !ni_string_empty(string))
ni_string_dup(&port->ifname, string);
else
return FALSE;
if (ni_dbus_dict_get_uint32(dict, "priority", &value))
port->priority = value;
if (ni_dbus_dict_get_uint32(dict, "path-cost", &value))
port->path_cost = value;
/* FIXME: Really? I don't think so... */
if (ni_dbus_dict_get_uint32(dict, "state", &value))
port->status.state = value;
if (ni_dbus_dict_get_uint32(dict, "port-id", &value))
port->status.port_id = value;
if (ni_dbus_dict_get_uint32(dict, "port-no", &value))
port->status.port_no = value;
return TRUE;
}
/*
* Handle methods implemented via C bindings
*/
static ni_c_binding_t *
ni_c_binding_new(ni_c_binding_t **list, const char *name, const char *library, const char *symbol)
{
ni_c_binding_t *binding, **pos;
for (pos = list; (binding = *pos) != NULL; pos = &binding->next)
;
binding = xcalloc(1, sizeof(*binding));
ni_string_dup(&binding->name, name);
ni_string_dup(&binding->library, library);
ni_string_dup(&binding->symbol, symbol);
*pos = binding;
return binding;
}
/*
* Create and destroy dhcp4 device handles
*/
ni_dhcp4_device_t *
ni_dhcp4_device_new(const char *ifname, const ni_linkinfo_t *link)
{
ni_dhcp4_device_t *dev, **pos;
for (pos = &ni_dhcp4_active; (dev = *pos) != NULL; pos = &dev->next)
;
dev = calloc(1, sizeof(*dev));
ni_string_dup(&dev->ifname, ifname);
dev->users = 1;
dev->listen_fd = -1;
dev->link.ifindex = link->ifindex;
if (ni_capture_devinfo_init(&dev->system, dev->ifname, link) < 0) {
ni_error("%s: cannot set up %s for DHCP4", __func__, ifname);
ni_dhcp4_device_put(dev);
return NULL;
}
dev->start_time = time(NULL);
dev->fsm.state = NI_DHCP4_STATE_INIT;
/* append to end of list */
*pos = dev;
return dev;
}
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;
}
/*
* 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;
}
void
xml_node_set_int(xml_node_t *node, int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%d", value);
ni_string_dup(&node->cdata, buffer);
}
int
ni_addrconf_lease_ptz_data_from_xml(ni_addrconf_lease_t *lease, const xml_node_t *node)
{
const xml_node_t *child;
for (child = node->children; child; child = child->next) {
if (ni_string_eq(child->name, "posix-string") &&
!ni_string_empty(child->cdata)) {
ni_string_dup(&lease->posix_tz_string, child->cdata);
} else
if (ni_string_eq(child->name, "posix-dbname") &&
!ni_string_empty(child->cdata)) {
ni_string_dup(&lease->posix_tz_dbname, child->cdata);
}
}
return 0;
}
void
xml_node_set_uint_hex(xml_node_t *node, unsigned int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "0x%x", value);
ni_string_dup(&node->cdata, buffer);
}
static ni_netdev_t *
__ni_objectmodel_team_newlink(ni_netdev_t *cfg_ifp, const char *ifname, DBusError *error)
{
ni_netconfig_t *nc = ni_global_state_handle(0);
ni_netdev_t *new_ifp = NULL;
int rv;
ni_netdev_get_team(cfg_ifp);
if (ifname == NULL && !(ifname = ni_netdev_make_name(nc, "team", 0))) {
dbus_set_error(error, DBUS_ERROR_FAILED, "Unable to create team interface - too many interfaces");
goto out;
}
ni_string_dup(&cfg_ifp->name, ifname);
if (cfg_ifp->link.hwaddr.len) {
if (cfg_ifp->link.hwaddr.type == ARPHRD_VOID)
cfg_ifp->link.hwaddr.type = ARPHRD_ETHER;
if (cfg_ifp->link.hwaddr.type != ARPHRD_ETHER ||
cfg_ifp->link.hwaddr.len != ni_link_address_length(ARPHRD_ETHER)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"Cannot create team interface: invalid ethernet address '%s'",
ni_link_address_print(&cfg_ifp->link.hwaddr));
goto out;
}
}
if ((rv = ni_system_team_create(nc, cfg_ifp, &new_ifp)) < 0) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"Unable to create team interface '%s'", cfg_ifp->name);
new_ifp = NULL;
goto out;
#if 0
if (rv != -NI_ERROR_DEVICE_EXISTS
&& (ifname != NULL && strcmp(ifname, new_ifp->name))) {
dbus_set_error(error,
DBUS_ERROR_FAILED,
"Unable to create team interface: %s",
ni_strerror(rv));
goto out;
}
ni_debug_dbus("Bonding interface exists (and name matches)");
#endif
}
if (new_ifp->link.type != NI_IFTYPE_TEAM) {
dbus_set_error(error,
DBUS_ERROR_FAILED,
"Unable to create team interface: new interface is of type %s",
ni_linktype_type_to_name(new_ifp->link.type));
new_ifp = NULL;
}
out:
if (cfg_ifp)
ni_netdev_put(cfg_ifp);
return new_ifp;
}
static int
__ni_dhcp_get_string(const xml_node_t *node, const char *name, char **res)
{
const char *value;
if ((value = __ni_dhcp_get_cdata(node, name)) != NULL)
ni_string_dup(res, value);
return 0;
}
ni_bool_t
ni_netdev_ref_set_ifname(ni_netdev_ref_t *ref, const char *ifname)
{
if (ref) {
ni_string_dup(&ref->name, ifname);
return TRUE;
}
return FALSE;
}
ni_tempstate_t *
ni_tempstate_new(const char *tag)
{
ni_tempstate_t *ts;
ts = xcalloc(1, sizeof(*ts));
ni_string_dup(&ts->ident, tag);
return ts;
}
ni_json_t *
ni_json_new_string(const char *value)
{
ni_json_t *json;
json = ni_json_new(NI_JSON_TYPE_STRING);
ni_string_dup(&json->string_value, value);
return json;
}
void
ni_config_parse_fslocation(ni_config_fslocation_t *fsloc, xml_node_t *node)
{
const char *attrval;
if ((attrval = xml_node_get_attr(node, "path")) != NULL)
ni_string_dup(&fsloc->path, attrval);
if ((attrval = xml_node_get_attr(node, "mode")) != NULL)
ni_parse_uint(attrval, &fsloc->mode, 8);
}
ni_bool_t
ni_netdev_ref_set(ni_netdev_ref_t *ref, const char *ifname, unsigned int ifindex)
{
if (ref) {
ni_string_dup(&ref->name, ifname);
ref->index = ifindex;
return TRUE;
}
return FALSE;
}
/*
* Constructor/Destructor for client-side objects
*/
void
__ni_dbus_client_object_init(ni_dbus_object_t *object, ni_dbus_client_t *client, const char *interface)
{
ni_dbus_client_object_t *cob;
cob = xcalloc(1, sizeof(*cob));
cob->client = client;
ni_string_dup(&cob->default_interface, interface);
object->client_object = cob;
}
int
ni_string_array_get(ni_string_array_t *nsa, unsigned int pos, char **str)
{
if (pos >= nsa->count)
return -1;
ni_string_dup(str, nsa->data[pos]);
return *str ? 0 : -1;
}
int
ni_string_array_set(ni_string_array_t *nsa, unsigned int pos, const char *str)
{
if (pos >= nsa->count)
return -1;
ni_string_dup(&nsa->data[pos], str);
return nsa->data[pos] ? 0 : -1;
}
/*
* 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;
}
ni_bool_t
ni_json_string_get(ni_json_t *json, char **ret)
{
char **val;
if (ret && (val = ni_json_to_string(json))) {
ni_string_dup(ret, *val);
return TRUE;
}
return FALSE;
}
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;
}
ni_bool_t
ni_config_parse_addrconf_dhcp4(struct ni_config_dhcp4 *dhcp4, xml_node_t *node)
{
xml_node_t *child;
for (child = node->children; child; child = child->next) {
const char *attrval;
if (!strcmp(child->name, "vendor-class"))
ni_string_dup(&dhcp4->vendor_class, child->cdata);
if (!strcmp(child->name, "lease-time") && child->cdata)
dhcp4->lease_time = strtoul(child->cdata, NULL, 0);
if (!strcmp(child->name, "ignore-server")
&& (attrval = xml_node_get_attr(child, "ip")) != NULL)
ni_string_array_append(&dhcp4->ignore_servers, attrval);
if (!strcmp(child->name, "prefer-server")
&& (attrval = xml_node_get_attr(child, "ip")) != NULL) {
ni_server_preference_t *pref;
if (dhcp4->num_preferred_servers >= NI_DHCP_SERVER_PREFERENCES_MAX) {
ni_warn("config: too many <prefer-server> elements");
continue;
}
pref = &dhcp4->preferred_server[dhcp4->num_preferred_servers++];
if (ni_sockaddr_parse(&pref->address, attrval, AF_INET) < 0) {
ni_error("config: unable to parse <prefer-server ip=\"%s\"",
attrval);
return FALSE;
}
pref->weight = 100;
if ((attrval = xml_node_get_attr(child, "weight")) != NULL) {
if (!strcmp(attrval, "always")) {
pref->weight = 100;
} else if (!strcmp(attrval, "never")) {
pref->weight = -1;
} else {
pref->weight = strtol(attrval, NULL, 0);
if (pref->weight > 100) {
pref->weight = 100;
ni_warn("preferred dhcp server weight exceeds max, "
"clamping to %d",
pref->weight);
}
}
}
}
if (!strcmp(child->name, "allow-update"))
ni_config_parse_update_targets(&dhcp4->allow_update, child);
}
return TRUE;
}
static dbus_bool_t
ni_objectmodel_gre_change(ni_dbus_object_t *object, const ni_dbus_method_t *method,
unsigned int argc, const ni_dbus_variant_t *argv,
ni_dbus_message_t *reply, DBusError *error)
{
ni_netconfig_t *nc = ni_global_state_handle(0);
ni_netdev_t *dev, *cfg;
ni_gre_t *gre;
const char *err;
/* we've already checked that argv matches our signature */
ni_assert(argc == 1);
if (!(dev = ni_objectmodel_unwrap_netif(object, error)) ||
!(cfg = __ni_objectmodel_gre_device_arg(&argv[0])) ||
!(ni_netdev_get_gre(dev))) {
ni_dbus_error_invalid_args(error, object->path, method->name);
return FALSE;
}
gre = ni_netdev_get_gre(cfg);
if ((err = ni_gre_validate(gre))) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "%s", err);
return FALSE;
}
cfg->link.ifindex = dev->link.ifindex;
if (ni_string_empty(cfg->name))
ni_string_dup(&cfg->name, dev->name);
if (ni_netdev_device_is_up(dev)) {
ni_debug_objectmodel("Skipping gre changeDevice call on %s: "
"device is up", dev->name);
return TRUE;
}
if (!ni_string_empty(cfg->link.lowerdev.name) &&
!ni_objectmodel_bind_netdev_ref_index(cfg->name, "gre tunnel",
&cfg->link.lowerdev, nc, error))
return FALSE;
if (ni_system_tunnel_change(nc, dev, cfg) < 0) {
dbus_set_error(error,
DBUS_ERROR_FAILED,
"Unable to change gre properties on interface %s",
dev->name);
return FALSE;
}
return TRUE;
}
