0001-merge-to-https-github.com-linux-usb-gadgets-libusbgx.patch

+			break;
+	}
+
+	if (ret == USBG_ERROR_NOT_FOUND)
+		ret = 0;
+
+	return ret;
+}
+
+static int uvc_export_frame_attrs(struct usbg_f_uvc *uvcf, const char *format,
+				  int frame_id, config_setting_t *root)
+{
+	union usbg_f_uvc_frame_attr_val val;
+	int ret = 0;
+	int i;
+
+	for (i = USBG_F_UVC_FRAME_ATTR_MIN; i < USBG_F_UVC_FRAME_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_get_frame_attr_val(uvcf, format, frame_id, i, &val);
+		if (ret)
+			break;
+
+		ret = uvc_frame_attr[i].export(root, uvc_frame_attr[i].name, &val);
+		if (ret)
+			break;
+	}
+
+	if (ret == USBG_ERROR_NOT_FOUND)
+		ret = 0;
+
+	return ret;
+}
+
+static int uvc_export_frames(struct usbg_f_uvc *uvcf, const char *format,
+			     bool *frames, config_setting_t *root)
+{
+	config_setting_t *frames_node, *node;
+	int i, nframes;
+	int ret = 0;
+
+	frames_node = config_setting_add(root, "frames", CONFIG_TYPE_LIST);
+	if (!frames_node) {
+		ret = USBG_ERROR_INVALID_FORMAT;
+		goto out;
+	}
+
+	nframes = usbg_f_uvc_get_nframes(frames);
+	if (nframes < 0)
+		return nframes;
+	for (i = 0; i < nframes; ++i) {
+		node = config_setting_add(frames_node, "", CONFIG_TYPE_GROUP);
+		if (!node)
+			goto out;
+
+		ret = uvc_export_frame_attrs(uvcf, format, i, node);
+		if (ret)
+			goto out;
+	}
+
+out:
+	return ret;
+};
+
+static int uvc_libconfig_export(struct usbg_function *f, config_setting_t *root)
+{
+	struct usbg_f_uvc *uvcf = usbg_to_uvc_function(f);
+	config_setting_t *formats_node, *node;
+	char fp[USBG_MAX_PATH_LENGTH];
+	struct formats *formats;
+	int i, ret = 0;
+	char *p;
+
+	formats_node = config_setting_add(root, "formats", CONFIG_TYPE_GROUP);
+	if (!formats_node) {
+		ret = USBG_ERROR_INVALID_PARAM;
+		goto out;
+	}
+
+	formats = get_formats_mask(uvcf);
+	for (i = 0; i < MAX_FORMATS; ++i) {
+
+		/* remove trailing /m and /u from format */
+		strcpy(fp, format_names[i]);
+		p = fp + strlen(fp) - 2; *p = '\0';
+
+		node = config_setting_add(formats_node, fp, CONFIG_TYPE_GROUP);
+		if (!node)
+			goto out;
+
+		ret = uvc_export_frames(uvcf, format_names[i], formats[i].frames, node);
+		if (ret)
+			goto out;
+
+		ret = uvc_export_format_attrs(uvcf, format_names[i], node);
+		if (ret)
+			goto out;
+	}
+
+	ret = uvc_export_config(uvcf, root);
+
+out:
+	return ret;
+}
+
+#endif
+
+static int uvc_set_format(char *format_path, const char *format, const struct usbg_f_uvc_format_attrs *attrs)
+{
+	return usbg_write_dec(format_path, format, "bDefaultFrameIndex", attrs->bDefaultFrameIndex);
+}
+
+static int uvc_set_frame(char *format_path, const char *format, const struct usbg_f_uvc_frame_attrs *attrs)
+{
+	char frame_path[USBG_MAX_PATH_LENGTH];
+	char full_frame_path[USBG_MAX_PATH_LENGTH];
+	char frame_name[32];
+	int nmb, ret;
+
+	nmb = snprintf(frame_name, sizeof(frame_name), "frame.%d", attrs->bFrameIndex);
+	if (nmb >= sizeof(frame_name))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	nmb = snprintf(frame_path, sizeof(frame_path), "%s/%s", format_path, format);
+	if (nmb >= sizeof(frame_path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	nmb = snprintf(full_frame_path, sizeof(frame_path), "%s/%s", frame_path, frame_name);
+	if (nmb >= sizeof(full_frame_path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	ret = uvc_create_dir(full_frame_path);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	ret = usbg_write_dec(frame_path, frame_name, "dwFrameInterval", attrs->dwFrameInterval);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	ret = usbg_write_dec(frame_path, frame_name, "dwMaxVideoFrameBufferSize", attrs->wHeight * attrs->wWidth);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	ret = usbg_write_dec(frame_path, frame_name, "wHeight", attrs->wHeight);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	return usbg_write_dec(frame_path, frame_name, "wWidth", attrs->wWidth);
+}
+
+static int uvc_set_streaming(char *func_path, const char *format, const struct usbg_f_uvc_format_attrs *attrs)
+{
+	struct usbg_f_uvc_frame_attrs **frame_attrs;
+	char streaming_path[USBG_MAX_PATH_LENGTH];
+	int nmb, ret, i;
+
+	nmb = snprintf(streaming_path, sizeof(streaming_path), "%s/" UVC_PATH_STREAMING, func_path);
+	if (nmb >= sizeof(streaming_path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	for(frame_attrs = attrs->frames, i = 0; frame_attrs[i]; ++i) {
+		if (frame_attrs[i]) {
+			ret = uvc_set_frame(streaming_path, format, frame_attrs[i]);
+			if(ret != USBG_SUCCESS)
+				ERROR("Error: %d", ret);
+		}
+	}
+
+	ret = uvc_set_format(streaming_path, format, attrs);
+	if(ret != USBG_SUCCESS)
+		ERROR("Error: %d", ret);
+
+	return ret;
+}
+
+static int dir_nftw_cb(const char *pathname, const struct stat *sbuf, int type, struct FTW *ftwb)
+{
+	(void) sbuf;
+	(void) type;
+	(void) ftwb;
+	int ret;
+
+	ret = remove(pathname);
+	if (ret < -1)
+		ERROR("failed to remove %s - %s", pathname, strerror(ret));
+
+	return 0;
+}
+
+int remove_dir(const char *dirpath)
+{
+	const int max_open_descs = 8;
+	int ret;
+
+	ret = nftw(dirpath, dir_nftw_cb, max_open_descs, FTW_DEPTH | FTW_MOUNT | FTW_PHYS);
+	if (ret < 0) {
+		ERROR("nftw failed");
+		return ret;
+	}
+
+	return 0;
+}
+
+static int content_nftw_cb(const char *pathname, const struct stat *sbuf, int type, struct FTW *ftwb)
+{
+	(void) sbuf;
+	(void) type;
+	(void) ftwb;
+	int ret;
+
+	if(ftwb->level == 0)
+		return 0;
+
+	ret = remove(pathname);
+	if(ret < -1)
+		ERROR("failed to remove %s - %s", pathname, strerror(ret));
+
+	return 0;
+}
+
+int remove_dir_content(const char *dirpath)
+{
+	const int max_open_descs = 8;
+	int ret;
+
+	/* traverse in reverse order (handle directory after it's content), stay within the same file system and do not follow symbolic links */
+	ret = nftw(dirpath, content_nftw_cb, max_open_descs, FTW_DEPTH | FTW_MOUNT | FTW_PHYS);
+	if (ret < 0) {
+		ERROR("nftw failed");
+		return ret;
+	}
+
+	return 0;
+}
+
+static int uvc_remove(struct usbg_function *f, int opts)
+{
+	usbg_f_uvc *uvcf = usbg_to_uvc_function(f);
+	char streaming_path[USBG_MAX_PATH_LENGTH];
+	char control_path[USBG_MAX_PATH_LENGTH];
+	char path[USBG_MAX_PATH_LENGTH];
+	int nmb, ret = USBG_SUCCESS;
+
+	nmb = snprintf(path, sizeof(path), "%s/%s", uvcf->func.path, uvcf->func.name);
+	if (nmb >= sizeof(path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	nmb = snprintf(streaming_path, sizeof(streaming_path), "%s/streaming", path);
+	if (nmb >= sizeof(streaming_path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	nmb = snprintf(control_path, sizeof(control_path), "%s/control", path);
+	if (nmb >= sizeof(control_path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	if(remove_dir_content(streaming_path) < 0)
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	if(remove_dir_content(control_path) < 0)
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	if(remove_dir(streaming_path) < 0)
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	if(remove_dir(control_path) < 0)
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	return ret;
+};
+
+struct usbg_function_type usbg_f_type_uvc = {
+	.name = "uvc",
+	.alloc_inst = uvc_alloc_inst,
+	.free_inst = uvc_free_inst,
+	.set_attrs = uvc_set_attrs,
+	.get_attrs = uvc_get_attrs,
+	.cleanup_attrs = uvc_cleanup_attrs,
+#ifdef HAS_GADGET_SCHEMES
+	.import = uvc_libconfig_import,
+	.export = uvc_libconfig_export,
+#endif
+	.remove = uvc_remove,
+};
+
+/* API implementation */
+
+usbg_f_uvc *usbg_to_uvc_function(usbg_function *f)
+{
+	return f->ops == &usbg_f_type_uvc ?
+			container_of(f, struct usbg_f_uvc, func) : NULL;
+}
+
+usbg_function *usbg_from_uvc_function(usbg_f_uvc *ff)
+{
+	return &ff->func;
+}
+
+int usbg_f_uvc_get_attrs(usbg_f_uvc *uvcf, struct usbg_f_uvc_attrs *attrs)
+{
+	return USBG_SUCCESS;
+}
+
+int usbg_f_uvc_set_attrs(usbg_f_uvc *uvcf, const struct usbg_f_uvc_attrs *attrs)
+{
+	char path[USBG_MAX_PATH_LENGTH];
+	struct usbg_f_uvc_format_attrs **format_attrs;
+	int ret = USBG_SUCCESS;
+	int nmb, i;
+
+	if (!attrs)
+		return USBG_ERROR_INVALID_PARAM;
+
+	nmb = snprintf(path, sizeof(path), "%s/%s", uvcf->func.path, uvcf->func.name);
+	if (nmb >= sizeof(path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	for(format_attrs = attrs->formats, i = 0; format_attrs[i]; ++i) {
+		ret = uvc_set_streaming(path, format_attrs[i]->format, format_attrs[i]);
+		if(ret != USBG_SUCCESS)
+			ERROR("Error: %d", ret);
+	}
+
+	ret = uvc_set_class(uvcf, UVC_PATH_CONTROL);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	ret = uvc_set_class(uvcf, UVC_PATH_STREAMING);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	return ret;
+}
diff --git a/src/usbg.c b/src/usbg.c
index d2bf381..68bded3 100644
--- a/src/usbg.c
+++ b/src/usbg.c
@@ -52,6 +52,8 @@ extern struct usbg_function_type usbg_f_type_phonet;
 extern struct usbg_function_type usbg_f_type_loopback;
 extern struct usbg_function_type usbg_f_type_hid;
 extern struct usbg_function_type usbg_f_type_uac2;
+extern struct usbg_function_type usbg_f_type_uvc;
+extern struct usbg_function_type usbg_f_type_printer;
 
 /**
  * @var function_types
@@ -73,6 +75,8 @@ struct usbg_function_type* function_types[] = {
 	[USBG_F_LOOPBACK] = &usbg_f_type_loopback,
 	[USBG_F_HID] = &usbg_f_type_hid,
 	[USBG_F_UAC2] = &usbg_f_type_uac2,
+	[USBG_F_UVC] = &usbg_f_type_uvc,
+	[USBG_F_PRINTER] = &usbg_f_type_printer,
 };
 
 ARRAY_SIZE_SENTINEL(function_types, USBG_FUNCTION_TYPE_MAX);
@@ -747,8 +751,7 @@ static int usbg_parse_config(const char *path, const char *name,
 		goto free_config;
 
 	TAILQ_INSERT_TAIL(&g->configs, c, cnode);
-
-	return USBG_SUCCESS;
+	goto out;
 
 free_config:
 	usbg_free_config(c);
diff --git a/src/usbg_common.c b/src/usbg_common.c
index f8822fc..5f7f4e5 100644
--- a/src/usbg_common.c
+++ b/src/usbg_common.c
@@ -15,11 +15,13 @@
 
 #include <errno.h>
 #include <sys/stat.h>
+#include <sys/sysmacros.h>
 #include <sys/types.h>
 #include <malloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <sys/sysmacros.h>
 
 int usbg_read_buf_limited(const char *path, const char *name,
 			  const char *file, char *buf, int len)
diff --git a/tests/usbg-test.c b/tests/usbg-test.c
index abe9bff..549667b 100644
--- a/tests/usbg-test.c
+++ b/tests/usbg-test.c
@@ -1067,6 +1067,18 @@ static void push_net_attrs(struct test_function *func,
 	safe_asprintf(&path, "%s/%s/qmult", func->path, func->name);
 	safe_asprintf(&content, "%d\n", attrs->qmult);
 	PUSH_FILE_STR(path, content);
+
+	safe_asprintf(&path, "%s/%s/class", func->path, func->name);
+	safe_asprintf(&content, "%d\n", attrs->class_);
+	PUSH_FILE_STR(path, content);
+
+	safe_asprintf(&path, "%s/%s/subclass", func->path, func->name);
+	safe_asprintf(&content, "%d\n", attrs->subclass);
+	PUSH_FILE_STR(path, content);
+
+	safe_asprintf(&path, "%s/%s/protocol", func->path, func->name);
+	safe_asprintf(&content, "%d\n", attrs->protocol);
+	PUSH_FILE_STR(path, content);
 }
 
 static void push_phonet_attrs(struct test_function *func,
@@ -1128,6 +1140,18 @@ static void pull_function_net_attrs(struct test_function *func,
 	safe_asprintf(&path, "%s/%s/qmult", func->path, func->name);
 	safe_asprintf(&content, "%d\n", attrs->qmult);
 	EXPECT_WRITE_STR(path, content);
+
+	safe_asprintf(&path, "%s/%s/class", func->path, func->name);
+	safe_asprintf(&content, "%d\n", attrs->class_);
+	EXPECT_WRITE_STR(path, content);
+
+	safe_asprintf(&path, "%s/%s/subclass", func->path, func->name);
+	safe_asprintf(&content, "%d\n", attrs->subclass);
+	EXPECT_WRITE_STR(path, content);
+
+	safe_asprintf(&path, "%s/%s/protocol", func->path, func->name);
+	safe_asprintf(&content, "%d\n", attrs->protocol);
+	EXPECT_WRITE_STR(path, content);
 }
 
 void pull_function_attrs(struct test_function *func, void *attrs)
@@ -1317,6 +1341,9 @@ void assert_f_net_attrs_equal(struct usbg_f_net_attrs *actual,
 	assert_ether_addrs_equal(&actual->host_addr, &expected->host_addr);
 	assert_string_equal(actual->ifname, expected->ifname);
 	assert_int_equal(actual->qmult, expected->qmult);
+	assert_int_equal(actual->class_, expected->class_);
+	assert_int_equal(actual->subclass, expected->subclass);
+	assert_int_equal(actual->protocol, expected->protocol);
 }
 
 void assert_f_phonet_attrs_equal(char  **actual, char **expected)
-- 
2.39.2