[deliverable/linux.git] / tools / usb / usbip / libsrc / vhci_driver.c

/*
 * Copyright (C) 2005-2007 Takahiro Hirofuchi
 */

#include "usbip_common.h"
#include "vhci_driver.h"
#include <limits.h>
#include <netdb.h>
#include <libudev.h>
#include "sysfs_utils.h"

#undef  PROGNAME
#define PROGNAME "libusbip"

struct usbip_vhci_driver *vhci_driver;
struct udev *udev_context;

static struct usbip_imported_device *
imported_device_init(struct usbip_imported_device *idev, char *busid)
{
	struct udev_device *sudev;

	sudev = udev_device_new_from_subsystem_sysname(udev_context,
						       "usb", busid);
	if (!sudev) {
		dbg("udev_device_new_from_subsystem_sysname failed: %s", busid);
		goto err;
	}
	read_usb_device(sudev, &idev->udev);
	udev_device_unref(sudev);

	return idev;

err:
	return NULL;
}


static int parse_status(const char *value)
{
	int ret = 0;
	char *c;


	for (int i = 0; i < vhci_driver->nports; i++)
		memset(&vhci_driver->idev[i], 0, sizeof(vhci_driver->idev[i]));


	/* skip a header line */
	c = strchr(value, '\n');
	if (!c)
		return -1;
	c++;

	while (*c != '\0') {
		int port, status, speed, devid;
		unsigned long socket;
		char lbusid[SYSFS_BUS_ID_SIZE];

		ret = sscanf(c, "%d %d %d %x %lx %31s\n",
				&port, &status, &speed,
				&devid, &socket, lbusid);

		if (ret < 5) {
			dbg("sscanf failed: %d", ret);
			BUG();
		}

		dbg("port %d status %d speed %d devid %x",
				port, status, speed, devid);
		dbg("socket %lx lbusid %s", socket, lbusid);


		/* if a device is connected, look at it */
		{
			struct usbip_imported_device *idev = &vhci_driver->idev[port];

			idev->port	= port;
			idev->status	= status;

			idev->devid	= devid;

			idev->busnum	= (devid >> 16);
			idev->devnum	= (devid & 0x0000ffff);

			if (idev->status != VDEV_ST_NULL
			    && idev->status != VDEV_ST_NOTASSIGNED) {
				idev = imported_device_init(idev, lbusid);
				if (!idev) {
					dbg("imported_device_init failed");
					return -1;
				}
			}
		}


		/* go to the next line */
		c = strchr(c, '\n');
		if (!c)
			break;
		c++;
	}

	dbg("exit");

	return 0;
}

static int refresh_imported_device_list(void)
{
	const char *attr_status;

	attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
					       "status");
	if (!attr_status) {
		err("udev_device_get_sysattr_value failed");
		return -1;
	}

	return parse_status(attr_status);
}

static int get_nports(void)
{
	char *c;
	int nports = 0;
	const char *attr_status;

	attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
					       "status");
	if (!attr_status) {
		err("udev_device_get_sysattr_value failed");
		return -1;
	}

	/* skip a header line */
	c = strchr(attr_status, '\n');
	if (!c)
		return 0;
	c++;

	while (*c != '\0') {
		/* go to the next line */
		c = strchr(c, '\n');
		if (!c)
			return nports;
		c++;
		nports += 1;
	}

	return nports;
}

/*
 * Read the given port's record.
 *
 * To avoid buffer overflow we will read the entire line and
 * validate each part's size. The initial buffer is padded by 4 to
 * accommodate the 2 spaces, 1 newline and an additional character
 * which is needed to properly validate the 3rd part without it being
 * truncated to an acceptable length.
 */
static int read_record(int rhport, char *host, unsigned long host_len,
		char *port, unsigned long port_len, char *busid)
{
	int part;
	FILE *file;
	char path[PATH_MAX+1];
	char *buffer, *start, *end;
	char delim[] = {' ', ' ', '\n'};
	int max_len[] = {(int)host_len, (int)port_len, SYSFS_BUS_ID_SIZE};
	size_t buffer_len = host_len + port_len + SYSFS_BUS_ID_SIZE + 4;

	buffer = malloc(buffer_len);
	if (!buffer)
		return -1;

	snprintf(path, PATH_MAX, VHCI_STATE_PATH"/port%d", rhport);

	file = fopen(path, "r");
	if (!file) {
		err("fopen");
		free(buffer);
		return -1;
	}

	if (fgets(buffer, buffer_len, file) == NULL) {
		err("fgets");
		free(buffer);
		fclose(file);
		return -1;
	}
	fclose(file);

	/* validate the length of each of the 3 parts */
	start = buffer;
	for (part = 0; part < 3; part++) {
		end = strchr(start, delim[part]);
		if (end == NULL || (end - start) > max_len[part]) {
			free(buffer);
			return -1;
		}
		start = end + 1;
	}

	if (sscanf(buffer, "%s %s %s\n", host, port, busid) != 3) {
		err("sscanf");
		free(buffer);
		return -1;
	}

	free(buffer);

	return 0;
}

/* ---------------------------------------------------------------------- */

int usbip_vhci_driver_open(void)
{
	udev_context = udev_new();
	if (!udev_context) {
		err("udev_new failed");
		return -1;
	}

	vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver));

	/* will be freed in usbip_driver_close() */
	vhci_driver->hc_device =
		udev_device_new_from_subsystem_sysname(udev_context,
						       USBIP_VHCI_BUS_TYPE,
						       USBIP_VHCI_DRV_NAME);
	if (!vhci_driver->hc_device) {
		err("udev_device_new_from_subsystem_sysname failed");
		goto err;
	}

	vhci_driver->nports = get_nports();

	dbg("available ports: %d", vhci_driver->nports);

	if (refresh_imported_device_list())
		goto err;

	return 0;

err:
	udev_device_unref(vhci_driver->hc_device);

	if (vhci_driver)
		free(vhci_driver);

	vhci_driver = NULL;

	udev_unref(udev_context);

	return -1;
}


void usbip_vhci_driver_close(void)
{
	if (!vhci_driver)
		return;

	udev_device_unref(vhci_driver->hc_device);

	free(vhci_driver);

	vhci_driver = NULL;

	udev_unref(udev_context);
}


int usbip_vhci_refresh_device_list(void)
{

	if (refresh_imported_device_list())
		goto err;

	return 0;
err:
	dbg("failed to refresh device list");
	return -1;
}


int usbip_vhci_get_free_port(void)
{
	for (int i = 0; i < vhci_driver->nports; i++) {
		if (vhci_driver->idev[i].status == VDEV_ST_NULL)
			return i;
	}

	return -1;
}

int usbip_vhci_attach_device2(uint8_t port, int sockfd, uint32_t devid,
		uint32_t speed) {
	char buff[200]; /* what size should be ? */
	char attach_attr_path[SYSFS_PATH_MAX];
	char attr_attach[] = "attach";
	const char *path;
	int ret;

	snprintf(buff, sizeof(buff), "%u %d %u %u",
			port, sockfd, devid, speed);
	dbg("writing: %s", buff);

	path = udev_device_get_syspath(vhci_driver->hc_device);
	snprintf(attach_attr_path, sizeof(attach_attr_path), "%s/%s",
		 path, attr_attach);
	dbg("attach attribute path: %s", attach_attr_path);

	ret = write_sysfs_attribute(attach_attr_path, buff, strlen(buff));
	if (ret < 0) {
		dbg("write_sysfs_attribute failed");
		return -1;
	}

	dbg("attached port: %d", port);

	return 0;
}

static unsigned long get_devid(uint8_t busnum, uint8_t devnum)
{
	return (busnum << 16) | devnum;
}

/* will be removed */
int usbip_vhci_attach_device(uint8_t port, int sockfd, uint8_t busnum,
		uint8_t devnum, uint32_t speed)
{
	int devid = get_devid(busnum, devnum);

	return usbip_vhci_attach_device2(port, sockfd, devid, speed);
}

int usbip_vhci_detach_device(uint8_t port)
{
	char detach_attr_path[SYSFS_PATH_MAX];
	char attr_detach[] = "detach";
	char buff[200]; /* what size should be ? */
	const char *path;
	int ret;

	snprintf(buff, sizeof(buff), "%u", port);
	dbg("writing: %s", buff);

	path = udev_device_get_syspath(vhci_driver->hc_device);
	snprintf(detach_attr_path, sizeof(detach_attr_path), "%s/%s",
		 path, attr_detach);
	dbg("detach attribute path: %s", detach_attr_path);

	ret = write_sysfs_attribute(detach_attr_path, buff, strlen(buff));
	if (ret < 0) {
		dbg("write_sysfs_attribute failed");
		return -1;
	}

	dbg("detached port: %d", port);

	return 0;
}

int usbip_vhci_imported_device_dump(struct usbip_imported_device *idev)
{
	char product_name[100];
	char host[NI_MAXHOST] = "unknown host";
	char serv[NI_MAXSERV] = "unknown port";
	char remote_busid[SYSFS_BUS_ID_SIZE];
	int ret;
	int read_record_error = 0;

	if (idev->status == VDEV_ST_NULL || idev->status == VDEV_ST_NOTASSIGNED)
		return 0;

	ret = read_record(idev->port, host, sizeof(host), serv, sizeof(serv),
			  remote_busid);
	if (ret) {
		err("read_record");
		read_record_error = 1;
	}

	printf("Port %02d: <%s> at %s\n", idev->port,
	       usbip_status_string(idev->status),
	       usbip_speed_string(idev->udev.speed));

	usbip_names_get_product(product_name, sizeof(product_name),
				idev->udev.idVendor, idev->udev.idProduct);

	printf("       %s\n",  product_name);

	if (!read_record_error) {
		printf("%10s -> usbip://%s:%s/%s\n", idev->udev.busid,
		       host, serv, remote_busid);
		printf("%10s -> remote bus/dev %03d/%03d\n", " ",
		       idev->busnum, idev->devnum);
	} else {
		printf("%10s -> unknown host, remote port and remote busid\n",
		       idev->udev.busid);
		printf("%10s -> remote bus/dev %03d/%03d\n", " ",
		       idev->busnum, idev->devnum);
	}

	return 0;
}
Commit	Line	Data
0945b4fe TH	1	/*
	2	* Copyright (C) 2005-2007 Takahiro Hirofuchi
	3	*/
	4
099f79fa	5	#include "usbip_common.h"
099f79fa	6	#include "vhci_driver.h"
ec2ff627 VM	7	#include <limits.h>
ec2ff627 VM	8	#include <netdb.h>
021aed84	9	#include <libudev.h>
a744b7c6	10	#include "sysfs_utils.h"
0945b4fe	11
f2fb62b3	12	#undef PROGNAME
	13	#define PROGNAME "libusbip"
	14
0945b4fe	15	struct usbip_vhci_driver *vhci_driver;
021aed84	16	struct udev *udev_context;
0945b4fe	17
9db91e1b KK	18	static struct usbip_imported_device *
9db91e1b KK	19	imported_device_init(struct usbip_imported_device idev, char busid)
0945b4fe	20	{
021aed84	21	struct udev_device *sudev;
0945b4fe	22
021aed84 VM	23	sudev = udev_device_new_from_subsystem_sysname(udev_context,
021aed84 VM	24	"usb", busid);
0945b4fe	25	if (!sudev) {
021aed84	26	dbg("udev_device_new_from_subsystem_sysname failed: %s", busid);
0945b4fe TH	27	goto err;
	28	}
	29	read_usb_device(sudev, &idev->udev);
021aed84	30	udev_device_unref(sudev);
0945b4fe	31
0945b4fe TH	32	return idev;
	33
	34	err:
	35	return NULL;
	36	}
	37
	38
	39
a744b7c6	40	static int parse_status(const char *value)
0945b4fe TH	41	{
	42	int ret = 0;
	43	char *c;
	44
	45
	46	for (int i = 0; i < vhci_driver->nports; i++)
950a4cd8	47	memset(&vhci_driver->idev[i], 0, sizeof(vhci_driver->idev[i]));
0945b4fe TH	48
	49
	50	/* skip a header line */
2f5c638c CH	51	c = strchr(value, '\n');
	52	if (!c)
	53	return -1;
	54	c++;
0945b4fe TH	55
	56	while (*c != '\0') {
	57	int port, status, speed, devid;
	58	unsigned long socket;
	59	char lbusid[SYSFS_BUS_ID_SIZE];
	60
2d329271	61	ret = sscanf(c, "%d %d %d %x %lx %31s\n",
0945b4fe TH	62	&port, &status, &speed,
	63	&devid, &socket, lbusid);
	64
	65	if (ret < 5) {
25567a39	66	dbg("sscanf failed: %d", ret);
0945b4fe TH	67	BUG();
	68	}
	69
	70	dbg("port %d status %d speed %d devid %x",
	71	port, status, speed, devid);
	72	dbg("socket %lx lbusid %s", socket, lbusid);
	73
	74
	75	/* if a device is connected, look at it */
	76	{
	77	struct usbip_imported_device *idev = &vhci_driver->idev[port];
	78
	79	idev->port = port;
	80	idev->status = status;
	81
	82	idev->devid = devid;
	83
	84	idev->busnum = (devid >> 16);
	85	idev->devnum = (devid & 0x0000ffff);
	86
9db91e1b KK	87	if (idev->status != VDEV_ST_NULL
9db91e1b KK	88	&& idev->status != VDEV_ST_NOTASSIGNED) {
0945b4fe TH	89	idev = imported_device_init(idev, lbusid);
0945b4fe TH	90	if (!idev) {
25567a39	91	dbg("imported_device_init failed");
0945b4fe TH	92	return -1;
	93	}
	94	}
	95	}
	96
	97
	98	/* go to the next line */
2f5c638c CH	99	c = strchr(c, '\n');
	100	if (!c)
	101	break;
	102	c++;
0945b4fe TH	103	}
	104
	105	dbg("exit");
	106
	107	return 0;
	108	}
	109
0945b4fe TH	110	static int refresh_imported_device_list(void)
0945b4fe TH	111	{
a744b7c6	112	const char *attr_status;
0945b4fe	113
a744b7c6 VM	114	attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
a744b7c6 VM	115	"status");
0945b4fe	116	if (!attr_status) {
a744b7c6	117	err("udev_device_get_sysattr_value failed");
0945b4fe TH	118	return -1;
	119	}
	120
a744b7c6	121	return parse_status(attr_status);
0945b4fe TH	122	}
	123
	124	static int get_nports(void)
	125	{
25567a39	126	char *c;
0945b4fe	127	int nports = 0;
a744b7c6	128	const char *attr_status;
0945b4fe	129
a744b7c6 VM	130	attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
a744b7c6 VM	131	"status");
0945b4fe	132	if (!attr_status) {
a744b7c6	133	err("udev_device_get_sysattr_value failed");
0945b4fe TH	134	return -1;
	135	}
	136
25567a39	137	/* skip a header line */
a744b7c6	138	c = strchr(attr_status, '\n');
2f5c638c CH	139	if (!c)
	140	return 0;
	141	c++;
0945b4fe	142
25567a39	143	while (*c != '\0') {
25567a39	144	/* go to the next line */
2f5c638c CH	145	c = strchr(c, '\n');
	146	if (!c)
	147	return nports;
	148	c++;
25567a39	149	nports += 1;
0945b4fe TH	150	}
	151
	152	return nports;
	153	}
	154
a37d70eb MA	155	/*
	156	* Read the given port's record.
	157	*
	158	* To avoid buffer overflow we will read the entire line and
	159	* validate each part's size. The initial buffer is padded by 4 to
	160	* accommodate the 2 spaces, 1 newline and an additional character
	161	* which is needed to properly validate the 3rd part without it being
	162	* truncated to an acceptable length.
	163	*/
	164	static int read_record(int rhport, char *host, unsigned long host_len,
	165	char port, unsigned long port_len, char busid)
ec2ff627	166	{
a37d70eb	167	int part;
ec2ff627 VM	168	FILE *file;
ec2ff627 VM	169	char path[PATH_MAX+1];
a37d70eb MA	170	char buffer, start, *end;
	171	char delim[] = {' ', ' ', '\n'};
	172	int max_len[] = {(int)host_len, (int)port_len, SYSFS_BUS_ID_SIZE};
	173	size_t buffer_len = host_len + port_len + SYSFS_BUS_ID_SIZE + 4;
	174
	175	buffer = malloc(buffer_len);
	176	if (!buffer)
	177	return -1;
ec2ff627 VM	178
	179	snprintf(path, PATH_MAX, VHCI_STATE_PATH"/port%d", rhport);
	180
	181	file = fopen(path, "r");
	182	if (!file) {
	183	err("fopen");
a37d70eb	184	free(buffer);
ec2ff627 VM	185	return -1;
	186	}
	187
a37d70eb MA	188	if (fgets(buffer, buffer_len, file) == NULL) {
	189	err("fgets");
	190	free(buffer);
ec2ff627 VM	191	fclose(file);
	192	return -1;
	193	}
ec2ff627 VM	194	fclose(file);
ec2ff627 VM	195
a37d70eb MA	196	/* validate the length of each of the 3 parts */
	197	start = buffer;
	198	for (part = 0; part < 3; part++) {
	199	end = strchr(start, delim[part]);
	200	if (end == NULL \|\| (end - start) > max_len[part]) {
	201	free(buffer);
	202	return -1;
	203	}
	204	start = end + 1;
	205	}
	206
	207	if (sscanf(buffer, "%s %s %s\n", host, port, busid) != 3) {
	208	err("sscanf");
	209	free(buffer);
	210	return -1;
	211	}
	212
	213	free(buffer);
	214
ec2ff627 VM	215	return 0;
ec2ff627 VM	216	}
0945b4fe TH	217
	218	/* ---------------------------------------------------------------------- */
	219
	220	int usbip_vhci_driver_open(void)
	221	{
021aed84 VM	222	udev_context = udev_new();
	223	if (!udev_context) {
	224	err("udev_new failed");
	225	return -1;
	226	}
	227
a744b7c6	228	vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver));
0945b4fe TH	229
0945b4fe TH	230	/* will be freed in usbip_driver_close() */
a744b7c6 VM	231	vhci_driver->hc_device =
	232	udev_device_new_from_subsystem_sysname(udev_context,
	233	USBIP_VHCI_BUS_TYPE,
	234	USBIP_VHCI_DRV_NAME);
0945b4fe	235	if (!vhci_driver->hc_device) {
a744b7c6	236	err("udev_device_new_from_subsystem_sysname failed");
0945b4fe TH	237	goto err;
	238	}
	239
	240	vhci_driver->nports = get_nports();
	241
25567a39	242	dbg("available ports: %d", vhci_driver->nports);
0945b4fe	243
0945b4fe TH	244	if (refresh_imported_device_list())
	245	goto err;
	246
0945b4fe TH	247	return 0;
0945b4fe TH	248
0945b4fe	249	err:
a744b7c6 VM	250	udev_device_unref(vhci_driver->hc_device);
a744b7c6 VM	251
0945b4fe TH	252	if (vhci_driver)
	253	free(vhci_driver);
	254
	255	vhci_driver = NULL;
021aed84 VM	256
	257	udev_unref(udev_context);
	258
0945b4fe TH	259	return -1;
	260	}
	261
	262
19495513	263	void usbip_vhci_driver_close(void)
0945b4fe TH	264	{
	265	if (!vhci_driver)
	266	return;
	267
a744b7c6 VM	268	udev_device_unref(vhci_driver->hc_device);
a744b7c6 VM	269
0945b4fe TH	270	free(vhci_driver);
	271
	272	vhci_driver = NULL;
021aed84 VM	273
021aed84 VM	274	udev_unref(udev_context);
0945b4fe TH	275	}
	276
	277
	278	int usbip_vhci_refresh_device_list(void)
	279	{
0945b4fe TH	280
	281	if (refresh_imported_device_list())
	282	goto err;
	283
	284	return 0;
	285	err:
25567a39	286	dbg("failed to refresh device list");
0945b4fe TH	287	return -1;
	288	}
	289
	290
	291	int usbip_vhci_get_free_port(void)
	292	{
	293	for (int i = 0; i < vhci_driver->nports; i++) {
	294	if (vhci_driver->idev[i].status == VDEV_ST_NULL)
	295	return i;
	296	}
	297
	298	return -1;
	299	}
	300
	301	int usbip_vhci_attach_device2(uint8_t port, int sockfd, uint32_t devid,
	302	uint32_t speed) {
0945b4fe	303	char buff[200]; /* what size should be ? */
a744b7c6 VM	304	char attach_attr_path[SYSFS_PATH_MAX];
	305	char attr_attach[] = "attach";
	306	const char *path;
0945b4fe TH	307	int ret;
0945b4fe TH	308
5484081d	309	snprintf(buff, sizeof(buff), "%u %d %u %u",
0945b4fe TH	310	port, sockfd, devid, speed);
	311	dbg("writing: %s", buff);
	312
a744b7c6 VM	313	path = udev_device_get_syspath(vhci_driver->hc_device);
	314	snprintf(attach_attr_path, sizeof(attach_attr_path), "%s/%s",
	315	path, attr_attach);
	316	dbg("attach attribute path: %s", attach_attr_path);
	317
	318	ret = write_sysfs_attribute(attach_attr_path, buff, strlen(buff));
0945b4fe	319	if (ret < 0) {
a744b7c6	320	dbg("write_sysfs_attribute failed");
0945b4fe TH	321	return -1;
	322	}
	323
25567a39	324	dbg("attached port: %d", port);
0945b4fe TH	325
	326	return 0;
	327	}
	328
	329	static unsigned long get_devid(uint8_t busnum, uint8_t devnum)
	330	{
	331	return (busnum << 16) \| devnum;
	332	}
	333
	334	/* will be removed */
	335	int usbip_vhci_attach_device(uint8_t port, int sockfd, uint8_t busnum,
	336	uint8_t devnum, uint32_t speed)
	337	{
	338	int devid = get_devid(busnum, devnum);
	339
	340	return usbip_vhci_attach_device2(port, sockfd, devid, speed);
	341	}
	342
	343	int usbip_vhci_detach_device(uint8_t port)
	344	{
a744b7c6 VM	345	char detach_attr_path[SYSFS_PATH_MAX];
a744b7c6 VM	346	char attr_detach[] = "detach";
0945b4fe	347	char buff[200]; /* what size should be ? */
a744b7c6	348	const char *path;
0945b4fe TH	349	int ret;
0945b4fe TH	350
0945b4fe	351	snprintf(buff, sizeof(buff), "%u", port);
0945b4fe TH	352	dbg("writing: %s", buff);
0945b4fe TH	353
a744b7c6 VM	354	path = udev_device_get_syspath(vhci_driver->hc_device);
	355	snprintf(detach_attr_path, sizeof(detach_attr_path), "%s/%s",
	356	path, attr_detach);
	357	dbg("detach attribute path: %s", detach_attr_path);
	358
	359	ret = write_sysfs_attribute(detach_attr_path, buff, strlen(buff));
0945b4fe	360	if (ret < 0) {
a744b7c6	361	dbg("write_sysfs_attribute failed");
0945b4fe TH	362	return -1;
	363	}
	364
25567a39	365	dbg("detached port: %d", port);
0945b4fe TH	366
	367	return 0;
	368	}
ec2ff627 VM	369
	370	int usbip_vhci_imported_device_dump(struct usbip_imported_device *idev)
	371	{
	372	char product_name[100];
	373	char host[NI_MAXHOST] = "unknown host";
	374	char serv[NI_MAXSERV] = "unknown port";
	375	char remote_busid[SYSFS_BUS_ID_SIZE];
	376	int ret;
	377	int read_record_error = 0;
	378
	379	if (idev->status == VDEV_ST_NULL \|\| idev->status == VDEV_ST_NOTASSIGNED)
	380	return 0;
	381
a37d70eb MA	382	ret = read_record(idev->port, host, sizeof(host), serv, sizeof(serv),
a37d70eb MA	383	remote_busid);
ec2ff627 VM	384	if (ret) {
	385	err("read_record");
	386	read_record_error = 1;
	387	}
	388
	389	printf("Port %02d: <%s> at %s\n", idev->port,
	390	usbip_status_string(idev->status),
	391	usbip_speed_string(idev->udev.speed));
	392
	393	usbip_names_get_product(product_name, sizeof(product_name),
	394	idev->udev.idVendor, idev->udev.idProduct);
	395
	396	printf(" %s\n", product_name);
	397
	398	if (!read_record_error) {
	399	printf("%10s -> usbip://%s:%s/%s\n", idev->udev.busid,
	400	host, serv, remote_busid);
	401	printf("%10s -> remote bus/dev %03d/%03d\n", " ",
	402	idev->busnum, idev->devnum);
	403	} else {
	404	printf("%10s -> unknown host, remote port and remote busid\n",
	405	idev->udev.busid);
	406	printf("%10s -> remote bus/dev %03d/%03d\n", " ",
	407	idev->busnum, idev->devnum);
	408	}
	409
	410	return 0;
	411	}