dump.c revision 188622 
1/* $FreeBSD: head/usr.sbin/usbconfig/dump.c 188622 2009-02-14 23:20:00Z thompsa $ */
2/*-
3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <stdio.h>
28#include <stdlib.h>
29#include <stdint.h>
30#include <err.h>
31#include <string.h>
32#include <pwd.h>
33#include <grp.h>
34#include <ctype.h>
35
36#include <libusb20.h>
37#include <libusb20_desc.h>
38
39#include "dump.h"
40
41#define	DUMP0(n,type,field,...) dump_field(pdev, "  ", #field, n->field);
42#define	DUMP1(n,type,field,...) dump_field(pdev, "    ", #field, n->field);
43#define	DUMP2(n,type,field,...) dump_field(pdev, "      ", #field, n->field);
44#define	DUMP3(n,type,field,...) dump_field(pdev, "        ", #field, n->field);
45
46const char *
47dump_mode(uint8_t value)
48{
49	if (value == LIBUSB20_MODE_HOST)
50		return ("HOST");
51	return ("DEVICE");
52}
53
54const char *
55dump_speed(uint8_t value)
56{
57	;				/* style fix */
58	switch (value) {
59	case LIBUSB20_SPEED_LOW:
60		return ("LOW (1.5Mbps)");
61	case LIBUSB20_SPEED_FULL:
62		return ("FULL (12Mbps)");
63	case LIBUSB20_SPEED_HIGH:
64		return ("HIGH (480Mbps)");
65	case LIBUSB20_SPEED_VARIABLE:
66		return ("VARIABLE (52-480Mbps)");
67	case LIBUSB20_SPEED_SUPER:
68		return ("SUPER (4.8Gbps)");
69	default:
70		break;
71	}
72	return ("unknown");
73}
74
75const char *
76dump_power_mode(uint8_t value)
77{
78	;				/* style fix */
79	switch (value) {
80	case LIBUSB20_POWER_OFF:
81		return ("OFF");
82	case LIBUSB20_POWER_ON:
83		return ("ON");
84	case LIBUSB20_POWER_SAVE:
85		return ("SAVE");
86	case LIBUSB20_POWER_SUSPEND:
87		return ("SUSPEND");
88	case LIBUSB20_POWER_RESUME:
89		return ("RESUME");
90	default:
91		return ("UNKNOWN");
92	}
93}
94
95static void
96dump_field(struct libusb20_device *pdev, const char *plevel,
97    const char *field, uint32_t value)
98{
99	uint8_t temp_string[256];
100
101	printf("%s%s = 0x%04x ", plevel, field, value);
102
103	if ((field[0] != 'i') || (field[1] == 'd')) {
104		printf("\n");
105		return;
106	}
107	if (value == 0) {
108		printf(" <no string>\n");
109		return;
110	}
111	if (libusb20_dev_req_string_simple_sync(pdev, value,
112	    temp_string, sizeof(temp_string))) {
113		printf(" <retrieving string failed>\n");
114		return;
115	}
116	printf(" <%s>\n", temp_string);
117	return;
118}
119
120static void
121dump_extra(struct libusb20_me_struct *str, const char *plevel)
122{
123	const uint8_t *ptr;
124	uint8_t x;
125
126	ptr = NULL;
127
128	while ((ptr = libusb20_desc_foreach(str, ptr))) {
129		printf("\n" "%sAdditional Descriptor\n\n", plevel);
130		printf("%sbLength = 0x%02x\n", plevel, ptr[0]);
131		printf("%sbDescriptorType = 0x%02x\n", plevel, ptr[1]);
132		if (ptr[0] > 1)
133			printf("%sbDescriptorSubType = 0x%02x\n",
134			    plevel, ptr[2]);
135		printf("%s RAW dump: ", plevel);
136		for (x = 0; x != ptr[0]; x++) {
137			if ((x % 8) == 0) {
138				printf("\n%s 0x%02x | ", plevel, x);
139			}
140			printf("0x%02x%s", ptr[x],
141			    (x != (ptr[0] - 1)) ? ", " : (x % 8) ? "\n" : "");
142		}
143		printf("\n");
144	}
145	return;
146}
147
148static void
149dump_endpoint(struct libusb20_device *pdev,
150    struct libusb20_endpoint *ep)
151{
152	struct LIBUSB20_ENDPOINT_DESC_DECODED *edesc;
153
154	edesc = &ep->desc;
155	LIBUSB20_ENDPOINT_DESC(DUMP3, edesc);
156	dump_extra(&ep->extra, "  " "  " "  ");
157	return;
158}
159
160static void
161dump_iface(struct libusb20_device *pdev,
162    struct libusb20_interface *iface)
163{
164	struct LIBUSB20_INTERFACE_DESC_DECODED *idesc;
165	uint8_t z;
166
167	idesc = &iface->desc;
168	LIBUSB20_INTERFACE_DESC(DUMP2, idesc);
169	dump_extra(&iface->extra, "  " "  " "  ");
170
171	for (z = 0; z != iface->num_endpoints; z++) {
172		printf("\n     Endpoint %u\n", z);
173		dump_endpoint(pdev, iface->endpoints + z);
174	}
175	return;
176}
177
178void
179dump_device_info(struct libusb20_device *pdev, uint8_t show_ifdrv)
180{
181	char buf[128];
182	uint8_t n;
183
184	printf("%s, cfg=%u md=%s spd=%s pwr=%s\n",
185	    libusb20_dev_get_desc(pdev),
186	    libusb20_dev_get_config_index(pdev),
187	    dump_mode(libusb20_dev_get_mode(pdev)),
188	    dump_speed(libusb20_dev_get_speed(pdev)),
189	    dump_power_mode(libusb20_dev_get_power_mode(pdev)));
190
191	if (!show_ifdrv)
192		return;
193
194	for (n = 0; n != 255; n++) {
195		if (libusb20_dev_get_iface_desc(pdev, n, buf, sizeof(buf)))
196			break;
197		if (buf[0] == 0)
198			continue;
199		printf("ugen%u.%u.%u: %s\n",
200		    libusb20_dev_get_bus_number(pdev),
201		    libusb20_dev_get_address(pdev), n, buf);
202	}
203}
204
205void
206dump_be_quirk_names(struct libusb20_backend *pbe)
207{
208	struct libusb20_quirk q;
209	uint16_t x;
210	int error;
211
212	memset(&q, 0, sizeof(q));
213
214	printf("\nDumping list of supported quirks:\n\n");
215
216	for (x = 0; x != 0xFFFF; x++) {
217
218		error = libusb20_be_get_quirk_name(pbe, x, &q);
219		if (error) {
220			if (x == 0) {
221				printf("No quirk names - maybe the USB quirk "
222				    "module has not been loaded.\n");
223			}
224			break;
225		}
226		if (strcmp(q.quirkname, "UQ_NONE"))
227			printf("%s\n", q.quirkname);
228	}
229	printf("\n");
230	return;
231}
232
233void
234dump_be_dev_quirks(struct libusb20_backend *pbe)
235{
236	struct libusb20_quirk q;
237	uint16_t x;
238	int error;
239
240	memset(&q, 0, sizeof(q));
241
242	printf("\nDumping current device quirks:\n\n");
243
244	for (x = 0; x != 0xFFFF; x++) {
245
246		error = libusb20_be_get_dev_quirk(pbe, x, &q);
247		if (error) {
248			if (x == 0) {
249				printf("No device quirks - maybe the USB quirk "
250				    "module has not been loaded.\n");
251			}
252			break;
253		}
254		if (strcmp(q.quirkname, "UQ_NONE")) {
255			printf("VID=0x%04x PID=0x%04x REVLO=0x%04x "
256			    "REVHI=0x%04x QUIRK=%s\n",
257			    q.vid, q.pid, q.bcdDeviceLow,
258			    q.bcdDeviceHigh, q.quirkname);
259		}
260	}
261	printf("\n");
262	return;
263}
264
265void
266dump_be_access(struct libusb20_backend *pbe)
267{
268	struct group *gr;
269	struct passwd *pw;
270	const char *owner;
271	const char *group;
272	uid_t uid;
273	gid_t gid;
274	mode_t mode;
275
276	if (libusb20_be_get_owner(pbe, &uid, &gid)) {
277		err(1, "could not get owner");
278	}
279	if (libusb20_be_get_perm(pbe, &mode)) {
280		err(1, "could not get permission");
281	}
282	owner = (pw = getpwuid(uid)) ? pw->pw_name : "UNKNOWN";
283	group = (gr = getgrgid(gid)) ? gr->gr_name : "UNKNOWN";
284
285	if (mode || 1) {
286		printf("Global Access: %s:%s 0%o\n", owner, group, mode);
287	} else {
288		printf("Global Access: <not set>\n");
289	}
290	return;
291}
292
293void
294dump_device_access(struct libusb20_device *pdev, uint8_t iface)
295{
296	struct group *gr;
297	struct passwd *pw;
298	const char *owner;
299	const char *group;
300	uid_t uid;
301	gid_t gid;
302	mode_t mode;
303
304	if (libusb20_dev_get_owner(pdev, &uid, &gid)) {
305		err(1, "could not get owner");
306	}
307	if (libusb20_dev_get_perm(pdev, &mode)) {
308		err(1, "could not get permission");
309	}
310	if (mode) {
311		owner = (pw = getpwuid(uid)) ? pw->pw_name : "UNKNOWN";
312		group = (gr = getgrgid(gid)) ? gr->gr_name : "UNKNOWN";
313
314		printf("  " "Device Access: %s:%s 0%o\n", owner, group, mode);
315
316	} else {
317		printf("  " "Device Access: <not set>\n");
318	}
319
320	if (iface == 0xFF) {
321		for (iface = 0; iface != 0xFF; iface++) {
322			if (dump_device_iface_access(pdev, iface)) {
323				break;
324			}
325		}
326	} else {
327		if (dump_device_iface_access(pdev, iface)) {
328			err(1, "could not get interface access info");
329		}
330	}
331	return;
332}
333
334int
335dump_device_iface_access(struct libusb20_device *pdev, uint8_t iface)
336{
337	struct group *gr;
338	struct passwd *pw;
339	const char *owner;
340	const char *group;
341	uid_t uid;
342	gid_t gid;
343	mode_t mode;
344	int error;
345
346	if ((error = libusb20_dev_get_iface_owner(pdev, iface, &uid, &gid))) {
347		return (error);
348	}
349	if ((error = libusb20_dev_get_iface_perm(pdev, iface, &mode))) {
350		return (error);
351	}
352	if (mode) {
353
354		owner = (pw = getpwuid(uid)) ? pw->pw_name : "UNKNOWN";
355		group = (gr = getgrgid(gid)) ? gr->gr_name : "UNKNOWN";
356
357		printf("    " "Interface %u Access: %s:%s 0%o\n",
358		    iface, owner, group, mode);
359	} else {
360		printf("    " "Interface %u Access: <not set>\n", iface);
361	}
362
363	return (0);
364}
365
366void
367dump_device_desc(struct libusb20_device *pdev)
368{
369	struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
370
371	ddesc = libusb20_dev_get_device_desc(pdev);
372	LIBUSB20_DEVICE_DESC(DUMP0, ddesc);
373	return;
374}
375
376void
377dump_config(struct libusb20_device *pdev, uint8_t all_cfg)
378{
379	struct LIBUSB20_CONFIG_DESC_DECODED *cdesc;
380	struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
381	struct libusb20_config *pcfg = NULL;
382	uint8_t cfg_index;
383	uint8_t cfg_index_end;
384	uint8_t x;
385	uint8_t y;
386
387	ddesc = libusb20_dev_get_device_desc(pdev);
388
389	if (all_cfg) {
390		cfg_index = 0;
391		cfg_index_end = ddesc->bNumConfigurations;
392	} else {
393		cfg_index = libusb20_dev_get_config_index(pdev);
394		cfg_index_end = cfg_index + 1;
395	}
396
397	for (; cfg_index != cfg_index_end; cfg_index++) {
398
399		pcfg = libusb20_dev_alloc_config(pdev, cfg_index);
400		if (!pcfg) {
401			continue;
402		}
403		printf("\n Configuration index %u\n\n", cfg_index);
404		cdesc = &(pcfg->desc);
405		LIBUSB20_CONFIG_DESC(DUMP1, cdesc);
406		dump_extra(&(pcfg->extra), "  " "  ");
407
408		for (x = 0; x != pcfg->num_interface; x++) {
409			printf("\n    Interface %u\n", x);
410			dump_iface(pdev, pcfg->interface + x);
411			printf("\n");
412			for (y = 0; y != (pcfg->interface + x)->num_altsetting; y++) {
413				printf("\n    Interface %u Alt %u\n", x, y + 1);
414				dump_iface(pdev,
415				    (pcfg->interface + x)->altsetting + y);
416				printf("\n");
417			}
418		}
419		printf("\n");
420		free(pcfg);
421	}
422	return;
423}
424