1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 2005-2007 Takahiro Hirofuchi
  4 */
  5
  6#include <libudev.h>
  7#include "usbip_common.h"
  8#include "names.h"
  9
 10#undef  PROGNAME
 11#define PROGNAME "libusbip"
 12
 13int usbip_use_syslog;
 14int usbip_use_stderr;
 15int usbip_use_debug;
 16
 17extern struct udev *udev_context;
 18
 19struct speed_string {
 20	int num;
 21	char *speed;
 22	char *desc;
 23};
 24
 25static const struct speed_string speed_strings[] = {
 26	{ USB_SPEED_UNKNOWN, "unknown", "Unknown Speed"},
 27	{ USB_SPEED_LOW,  "1.5", "Low Speed(1.5Mbps)"  },
 28	{ USB_SPEED_FULL, "12",  "Full Speed(12Mbps)" },
 29	{ USB_SPEED_HIGH, "480", "High Speed(480Mbps)" },
 30	{ USB_SPEED_WIRELESS, "53.3-480", "Wireless"},
 31	{ USB_SPEED_SUPER, "5000", "Super Speed(5000Mbps)" },
 32	{ 0, NULL, NULL }
 33};
 34
 35struct portst_string {
 36	int num;
 37	char *desc;
 38};
 39
 40static struct portst_string portst_strings[] = {
 41	{ SDEV_ST_AVAILABLE,	"Device Available" },
 42	{ SDEV_ST_USED,		"Device in Use" },
 43	{ SDEV_ST_ERROR,	"Device Error"},
 44	{ VDEV_ST_NULL,		"Port Available"},
 45	{ VDEV_ST_NOTASSIGNED,	"Port Initializing"},
 46	{ VDEV_ST_USED,		"Port in Use"},
 47	{ VDEV_ST_ERROR,	"Port Error"},
 48	{ 0, NULL}
 49};
 50
 51const char *usbip_status_string(int32_t status)
 52{
 53	for (int i = 0; portst_strings[i].desc != NULL; i++)
 54		if (portst_strings[i].num == status)
 55			return portst_strings[i].desc;
 56
 57	return "Unknown Status";
 58}
 59
 60const char *usbip_speed_string(int num)
 61{
 62	for (int i = 0; speed_strings[i].speed != NULL; i++)
 63		if (speed_strings[i].num == num)
 64			return speed_strings[i].desc;
 65
 66	return "Unknown Speed";
 67}
 68
 69struct op_common_status_string {
 70	int num;
 71	char *desc;
 72};
 73
 74static struct op_common_status_string op_common_status_strings[] = {
 75	{ ST_OK,	"Request Completed Successfully" },
 76	{ ST_NA,	"Request Failed" },
 77	{ ST_DEV_BUSY,	"Device busy (exported)" },
 78	{ ST_DEV_ERR,	"Device in error state" },
 79	{ ST_NODEV,	"Device not found" },
 80	{ ST_ERROR,	"Unexpected response" },
 81	{ 0, NULL}
 82};
 83
 84const char *usbip_op_common_status_string(int status)
 85{
 86	for (int i = 0; op_common_status_strings[i].desc != NULL; i++)
 87		if (op_common_status_strings[i].num == status)
 88			return op_common_status_strings[i].desc;
 89
 90	return "Unknown Op Common Status";
 91}
 92
 93#define DBG_UDEV_INTEGER(name)\
 94	dbg("%-20s = %x", to_string(name), (int) udev->name)
 95
 96#define DBG_UINF_INTEGER(name)\
 97	dbg("%-20s = %x", to_string(name), (int) uinf->name)
 98
 99void dump_usb_interface(struct usbip_usb_interface *uinf)
100{
101	char buff[100];
102
103	usbip_names_get_class(buff, sizeof(buff),
104			uinf->bInterfaceClass,
105			uinf->bInterfaceSubClass,
106			uinf->bInterfaceProtocol);
107	dbg("%-20s = %s", "Interface(C/SC/P)", buff);
108}
109
110void dump_usb_device(struct usbip_usb_device *udev)
111{
112	char buff[100];
113
114	dbg("%-20s = %s", "path",  udev->path);
115	dbg("%-20s = %s", "busid", udev->busid);
116
117	usbip_names_get_class(buff, sizeof(buff),
118			udev->bDeviceClass,
119			udev->bDeviceSubClass,
120			udev->bDeviceProtocol);
121	dbg("%-20s = %s", "Device(C/SC/P)", buff);
122
123	DBG_UDEV_INTEGER(bcdDevice);
124
125	usbip_names_get_product(buff, sizeof(buff),
126			udev->idVendor,
127			udev->idProduct);
128	dbg("%-20s = %s", "Vendor/Product", buff);
129
130	DBG_UDEV_INTEGER(bNumConfigurations);
131	DBG_UDEV_INTEGER(bNumInterfaces);
132
133	dbg("%-20s = %s", "speed",
134			usbip_speed_string(udev->speed));
135
136	DBG_UDEV_INTEGER(busnum);
137	DBG_UDEV_INTEGER(devnum);
138}
139
140
141int read_attr_value(struct udev_device *dev, const char *name,
142		    const char *format)
143{
144	const char *attr;
145	int num = 0;
146	int ret;
147
148	attr = udev_device_get_sysattr_value(dev, name);
149	if (!attr) {
150		err("udev_device_get_sysattr_value failed");
151		goto err;
152	}
153
154	/* The client chooses the device configuration
155	 * when attaching it so right after being bound
156	 * to usbip-host on the server the device will
157	 * have no configuration.
158	 * Therefore, attributes such as bConfigurationValue
159	 * and bNumInterfaces will not exist and sscanf will
160	 * fail. Check for these cases and don't treat them
161	 * as errors.
162	 */
163
164	ret = sscanf(attr, format, &num);
165	if (ret < 1) {
166		if (strcmp(name, "bConfigurationValue") &&
167				strcmp(name, "bNumInterfaces")) {
168			err("sscanf failed for attribute %s", name);
169			goto err;
170		}
171	}
172
173err:
174
175	return num;
176}
177
178
179int read_attr_speed(struct udev_device *dev)
180{
181	const char *speed;
182
183	speed = udev_device_get_sysattr_value(dev, "speed");
184	if (!speed) {
185		err("udev_device_get_sysattr_value failed");
186		goto err;
187	}
188
189	for (int i = 0; speed_strings[i].speed != NULL; i++) {
190		if (!strcmp(speed, speed_strings[i].speed))
191			return speed_strings[i].num;
192	}
193
194err:
195
196	return USB_SPEED_UNKNOWN;
197}
198
199#define READ_ATTR(object, type, dev, name, format)			      \
200	do {								      \
201		(object)->name = (type) read_attr_value(dev, to_string(name), \
202							format);	      \
203	} while (0)
204
205
206int read_usb_device(struct udev_device *sdev, struct usbip_usb_device *udev)
207{
208	uint32_t busnum, devnum;
209	const char *path, *name;
210
211	READ_ATTR(udev, uint8_t,  sdev, bDeviceClass,		"%02x\n");
212	READ_ATTR(udev, uint8_t,  sdev, bDeviceSubClass,	"%02x\n");
213	READ_ATTR(udev, uint8_t,  sdev, bDeviceProtocol,	"%02x\n");
214
215	READ_ATTR(udev, uint16_t, sdev, idVendor,		"%04x\n");
216	READ_ATTR(udev, uint16_t, sdev, idProduct,		"%04x\n");
217	READ_ATTR(udev, uint16_t, sdev, bcdDevice,		"%04x\n");
218
219	READ_ATTR(udev, uint8_t,  sdev, bConfigurationValue,	"%02x\n");
220	READ_ATTR(udev, uint8_t,  sdev, bNumConfigurations,	"%02x\n");
221	READ_ATTR(udev, uint8_t,  sdev, bNumInterfaces,		"%02x\n");
222
223	READ_ATTR(udev, uint8_t,  sdev, devnum,			"%d\n");
224	udev->speed = read_attr_speed(sdev);
225
226	path = udev_device_get_syspath(sdev);
227	name = udev_device_get_sysname(sdev);
228
229	strncpy(udev->path,  path,  SYSFS_PATH_MAX);
230	strncpy(udev->busid, name, SYSFS_BUS_ID_SIZE);
231
232	sscanf(name, "%u-%u", &busnum, &devnum);
233	udev->busnum = busnum;
234
235	return 0;
236}
237
238int read_usb_interface(struct usbip_usb_device *udev, int i,
239		       struct usbip_usb_interface *uinf)
240{
241	char busid[SYSFS_BUS_ID_SIZE];
242	int size;
243	struct udev_device *sif;
244
245	size = snprintf(busid, sizeof(busid), "%s:%d.%d",
246			udev->busid, udev->bConfigurationValue, i);
247	if (size < 0 || (unsigned int)size >= sizeof(busid)) {
248		err("busid length %i >= %lu or < 0", size,
249		    (long unsigned)sizeof(busid));
250		return -1;
251	}
252
253	sif = udev_device_new_from_subsystem_sysname(udev_context, "usb", busid);
254	if (!sif) {
255		err("udev_device_new_from_subsystem_sysname %s failed", busid);
256		return -1;
257	}
258
259	READ_ATTR(uinf, uint8_t,  sif, bInterfaceClass,		"%02x\n");
260	READ_ATTR(uinf, uint8_t,  sif, bInterfaceSubClass,	"%02x\n");
261	READ_ATTR(uinf, uint8_t,  sif, bInterfaceProtocol,	"%02x\n");
262
263	return 0;
264}
265
266int usbip_names_init(char *f)
267{
268	return names_init(f);
269}
270
271void usbip_names_free(void)
272{
273	names_free();
274}
275
276void usbip_names_get_product(char *buff, size_t size, uint16_t vendor,
277			     uint16_t product)
278{
279	const char *prod, *vend;
280
281	prod = names_product(vendor, product);
282	if (!prod)
283		prod = "unknown product";
284
285
286	vend = names_vendor(vendor);
287	if (!vend)
288		vend = "unknown vendor";
289
290	snprintf(buff, size, "%s : %s (%04x:%04x)", vend, prod, vendor, product);
291}
292
293void usbip_names_get_class(char *buff, size_t size, uint8_t class,
294			   uint8_t subclass, uint8_t protocol)
295{
296	const char *c, *s, *p;
297
298	if (class == 0 && subclass == 0 && protocol == 0) {
299		snprintf(buff, size, "(Defined at Interface level) (%02x/%02x/%02x)", class, subclass, protocol);
300		return;
301	}
302
303	p = names_protocol(class, subclass, protocol);
304	if (!p)
305		p = "unknown protocol";
306
307	s = names_subclass(class, subclass);
308	if (!s)
309		s = "unknown subclass";
310
311	c = names_class(class);
312	if (!c)
313		c = "unknown class";
314
315	snprintf(buff, size, "%s / %s / %s (%02x/%02x/%02x)", c, s, p, class, subclass, protocol);
316}