Exemplo n.º 1
0
dbus_bool_t
ni_objectmodel_macvtap_newlink(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);
	ni_netdev_t *dev;
	const char *ifname = NULL;

	NI_TRACE_ENTER();

	ni_assert(argc == 2);
	if (!ni_dbus_variant_get_string(&argv[0], &ifname) ||
		!(dev = __ni_objectmodel_macvlan_device_arg(&argv[1], NI_IFTYPE_MACVTAP))) {
		return ni_dbus_error_invalid_args(error,
						factory_object->path,
						method->name);
	}

	if (!(dev = __ni_objectmodel_macvlan_newlink(dev, ifname, error)))
		return FALSE;

	return ni_objectmodel_netif_factory_result(server, reply, dev, NULL, error);
}
Exemplo n.º 2
0
/*
 * Filesystem.getInfo(path)
 *
 */
static dbus_bool_t
__ni_Testbus_Agent_Filesystem_getInfo(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_dbus_variant_t res = NI_DBUS_VARIANT_INIT;
	struct stat stb;
	const char *path;
	dbus_bool_t rv;

	if (argc != 1 || !ni_dbus_variant_get_string(&argv[0], &path) || path[0] != '/')
		return ni_dbus_error_invalid_args(error, object->path, method->name);

	if (stat(path, &stb) < 0) {
		ni_dbus_set_error_from_errno(error, errno, "unable to stat file \"%s\"", path);
		return FALSE;
	}
	if (!S_ISREG(stb.st_mode)) {
		dbus_set_error(error, DBUS_ERROR_FAILED, "not a regular file");
		return FALSE;
	}

	ni_dbus_variant_init_dict(&res);
	ni_dbus_dict_add_uint64(&res, "size", stb.st_size);

	rv = ni_dbus_message_serialize_variants(reply, 1, &res, error);
	ni_dbus_variant_destroy(&res);
	return rv;
}
Exemplo n.º 3
0
/*
 * Create a new ppp interface
 */
static dbus_bool_t
ni_objectmodel_ppp_device_new(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);
	ni_netdev_t *dev, *cfg;
	const char *ifname = NULL;

	if (argc != 2)
		goto error;

	if (!ni_dbus_variant_get_string(&argv[0], &ifname))
		goto error;

	if (!(cfg = ni_objectmodel_ppp_device_arg(&argv[1])))
		goto error;

	dev = ni_objectmodel_ppp_device_create(cfg, ifname, error);
	ni_netdev_put(cfg);

	if (dev)
		return ni_objectmodel_netif_factory_result(server, reply, dev, NULL, error);
	else
		return FALSE;

error:
	return ni_dbus_error_invalid_args(error, factory_object->path, method->name);
}
Exemplo n.º 4
0
Arquivo: ppp.c Projeto: mchf/wicked
/*
 * Create a new PPP interface
 * We're given two arguments, the interface name and the <ppp> configuration data.
 * However, we ignore all the config data at this point and just create the
 * device. The configuration data is consumed by a subsequent call to changeDevice
 * (where we build a config file from it).
 */
dbus_bool_t
ni_objectmodel_ppp_newlink(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,
			__get_device_arg_fn_t get_device_arg_fn)
{
	ni_dbus_server_t *server = ni_dbus_object_get_server(factory_object);
	const char *ifname = NULL;
	ni_netdev_t *dev, *dev_cfg;

	NI_TRACE_ENTER();

	ni_assert(argc == 2);
	if (!ni_dbus_variant_get_string(&argv[0], &ifname))
		return ni_dbus_error_invalid_args(error, factory_object->path, method->name);
	if (!(dev_cfg = get_device_arg_fn(&argv[1], error)))
		return FALSE;

	dev = __ni_objectmodel_ppp_newlink(dev_cfg, ifname, error);
	ni_netdev_put(dev_cfg);

	if (dev == NULL)
		return FALSE;

	return ni_objectmodel_netif_factory_result(server, reply, dev, NULL, error);
}
Exemplo n.º 5
0
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);
}
Exemplo n.º 6
0
/*
 * Filesystem.download(path, offset, count)
 *
 */
static dbus_bool_t
__ni_Testbus_Agent_Filesystem_download(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_dbus_variant_t res = NI_DBUS_VARIANT_INIT;
	const char *path;
	uint64_t offset;
	uint32_t count;
	dbus_bool_t rv;
	ni_buffer_t *bp = NULL;
	int fd = -1;

	if (argc != 3
	 || !ni_dbus_variant_get_string(&argv[0], &path) || path[0] != '/'
	 || !ni_dbus_variant_get_uint64(&argv[1], &offset)
	 || !ni_dbus_variant_get_uint32(&argv[2], &count)
	 || count > 1024 * 1024
	 || offset + count < offset)
		return ni_dbus_error_invalid_args(error, object->path, method->name);

	if ((fd = open(path, O_RDONLY)) < 0) {
		ni_dbus_set_error_from_errno(error, errno, "unable to open file \"%s\"", path);
		return FALSE;
	}
	if (lseek(fd, offset, SEEK_SET) < 0) {
		ni_dbus_set_error_from_errno(error, errno, "seek faile");
		goto out_fail;
	}

	bp = ni_buffer_new(count);
	while (count) {
		int n;

		n = read(fd, ni_buffer_tail(bp), ni_buffer_tailroom(bp));
		if (n < 0) {
			ni_dbus_set_error_from_errno(error, errno, "read failed");
			goto out_fail;
		}
		if (n == 0)
			break;
		ni_buffer_push_tail(bp, n);
	}

	ni_dbus_variant_init_dict(&res);
	ni_dbus_variant_set_byte_array(&res, ni_buffer_head(bp), ni_buffer_count(bp));

	rv = ni_dbus_message_serialize_variants(reply, 1, &res, error);

	ni_dbus_variant_destroy(&res);
	ni_buffer_free(bp);
	close(fd);
	return rv;

out_fail:
	if (fd >= 0)
		close(fd);
	return FALSE;
}
Exemplo n.º 7
0
/*
 * Tmpfile.upload(path, offset, data)
 */
static dbus_bool_t
__ni_Testbus_Agent_Filesystem_upload(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_buffer_t wbuf;
	const char *path;
	uint64_t offset;
	unsigned int written = 0;
	int fd;

	if (argc != 3
	 || !ni_dbus_variant_get_string(&argv[0], &path) || path[0] != '/'
	 || !ni_dbus_variant_get_uint64(&argv[1], &offset)
	 || !ni_dbus_variant_is_byte_array(&argv[2]))
		return ni_dbus_error_invalid_args(error, object->path, method->name);

	if (offset == 0)
		fd = open(path, O_CREAT|O_TRUNC|O_WRONLY, 0644);
	else
		fd = open(path, O_WRONLY);
	if (fd < 0) {
		ni_dbus_set_error_from_errno(error, errno, "unable to open file \"%s\"", path);
		return FALSE;
	}
	if (lseek(fd, offset, SEEK_SET) < 0) {
		ni_dbus_set_error_from_errno(error, errno, "seek faile");
		goto out_fail;
	}

	ni_buffer_init_reader(&wbuf, argv[2].byte_array_value, argv[2].array.len);
	while (ni_buffer_count(&wbuf)) {
		int n;

		n = write(fd, ni_buffer_head(&wbuf), ni_buffer_count(&wbuf));
		if (n < 0) {
			ni_dbus_set_error_from_errno(error, errno,
						"error writing to \"%s\" at offset %Lu",
						path, (unsigned long long) offset + written);
			goto out_fail;
		}

		ni_buffer_pull_head(&wbuf, n);
		written += n;
	}

	close(fd);

	ni_debug_testbus("%s: wrote %u bytes at offset %Lu",
			path, written, (unsigned long long) offset);
	return TRUE;

out_fail:
	if (fd >= 0)
		close(fd);
	return FALSE;
}
Exemplo n.º 8
0
Arquivo: lldp.c Projeto: mchf/wicked
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;
}
Exemplo n.º 9
0
static dbus_bool_t
__wicked_dbus_autoip4_set_name(ni_dbus_object_t *object,
				const ni_dbus_property_t *property,
				const ni_dbus_variant_t *argument,
				DBusError *error)
{
	ni_autoip_device_t *dev = ni_dbus_object_get_handle(object);
	const char *value;

	if (!ni_dbus_variant_get_string(argument, &value))
		return FALSE;
	ni_string_dup(&dev->ifname, value);
	return TRUE;
}
Exemplo n.º 10
0
/*
 * Create a new ovs bridge interface
 */
static dbus_bool_t
__ni_objectmodel_ovs_bridge_create(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);
	ni_netdev_t *ifp;
	const char *ifname = NULL;

	ni_assert(argc == 2);
	if (!ni_dbus_variant_get_string(&argv[0], &ifname)
	 || !(ifp = __ni_objectmodel_ovs_bridge_device_arg(&argv[1])))
		return ni_dbus_error_invalid_args(error, factory_object->path, method->name);

	if (!(ifp = __ni_objectmodel_ovs_bridge_newlink(ifp, ifname, error)))
		return FALSE;

	return ni_objectmodel_netif_factory_result(server, reply, ifp, NULL, error);
}
Exemplo n.º 11
0
Arquivo: calls.c Projeto: mijos/wicked
/*
 * Identify an interface by name
 */
char *
ni_call_device_by_name(ni_dbus_object_t *list_object, const char *name)
{
	DBusError error = DBUS_ERROR_INIT;
	ni_dbus_variant_t arg = NI_DBUS_VARIANT_INIT;
	ni_dbus_variant_t res = NI_DBUS_VARIANT_INIT;
	char *result = NULL;

	ni_dbus_variant_set_string(&arg, name);
	if (ni_dbus_object_call_variant(list_object, NULL, "deviceByName", 1, &arg, 1, &res, &error)) {
		const char *value;

		if (ni_dbus_variant_get_string(&res, &value))
			result = strdup(value);
	} else {
		ni_dbus_print_error(&error, "%s.deviceByName(%s): failed",
				list_object->path, name);
		dbus_error_free(&error);
	}

	ni_dbus_variant_destroy(&arg);
	ni_dbus_variant_destroy(&res);
	return result;
}
Exemplo n.º 12
0
static dbus_bool_t
ni_objectmodel_ib_newchild(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);
	ni_netdev_t *cfg, *dev;
	const char *ifname = NULL;

	NI_TRACE_ENTER();

	if (argc != 2 || !ni_dbus_variant_get_string(&argv[0], &ifname) || !ifname ||
	    !(cfg = __ni_objectmodel_ibchild_device_arg(&argv[1]))) {
		return ni_dbus_error_invalid_args(error, factory_object->path, method->name);
	}

	if (!(dev = __ni_objectmodel_ib_newchild(cfg, ifname, error))) {
		ni_netdev_put(cfg);
		return FALSE;
	}
	ni_netdev_put(cfg);

	return ni_objectmodel_netif_factory_result(server, reply, dev, NULL, error);
}