1 /*-
2 * SPDX-License-Identifier: Beerware
3 *
4 * ----------------------------------------------------------------------------
5 * "THE BEER-WARE LICENSE" (Revision 42) (by Poul-Henning Kamp):
6 * <joerg@FreeBSD.ORG> wrote this file. As long as you retain this notice you
7 * can do whatever you want with this stuff. If we meet some day, and you think
8 * this stuff is worth it, you can buy me a beer in return. Joerg Wunsch
9 * ----------------------------------------------------------------------------
10 */
11
12 /*
13 * Simple demo program to illustrate the handling of FreeBSD's
14 * libusb20.
15 */
16
17 /*
18 * Examples:
19 * Just list all VID:PID pairs
20 * ./control
21 *
22 * Standard device request GET_STATUS, report two bytes of status
23 * (bit 0 in the first byte returned is the "self powered" bit)
24 * ./control -v 0x3eb -p 0x2103 in std dev get_status 0 0 2
25 *
26 * Request input reports through the interrupt pipe from a mouse
27 * device (move the mouse around after issuing the command):
28 * ./control -v 0x093a -p 0x2516 -i 0x81
29 *
30 */
31
32
33 #include <capsicum_helpers.h>
34 #include <limits.h>
35 #include <stdbool.h>
36 #include <stdio.h>
37 #include <stdint.h>
38 #include <stdlib.h>
39 #include <sysexits.h>
40 #include <unistd.h>
41 #include <string.h>
42
43 #include <libusb20.h>
44 #include <libusb20_desc.h>
45
46 #include <sys/queue.h>
47
48 #include "util.h"
49
50 /*
51 * If you want to see the details of the internal datastructures
52 * in the debugger, unifdef the following.
53 */
54 #ifdef DEBUG
55 # include "/usr/src/lib/libusb/libusb20_int.h"
56 #endif
57
58 #define BUFLEN 64
59
60 #define TIMEOUT 5000 /* 5 s */
61
62 int intr_ep; /* endpoints */
63 struct LIBUSB20_CONTROL_SETUP_DECODED setup;
64
65 uint8_t out_buf[BUFLEN];
66 uint16_t out_len;
67
68 bool do_request;
69
70 static void
doit(struct libusb20_device * dev)71 doit(struct libusb20_device *dev)
72 {
73 int rv;
74
75 if (do_request)
76 printf("doit(): bmRequestType 0x%02x, bRequest 0x%02x, wValue 0x%04x, wIndex 0x%04x, wLength 0x%04x\n",
77 setup.bmRequestType,
78 setup.bRequest,
79 setup.wValue,
80 setup.wIndex,
81 setup.wLength);
82
83 /*
84 * Open the device, allocating memory for two possible (bulk or
85 * interrupt) transfers.
86 *
87 * If only control transfers are intended (via
88 * libusb20_dev_request_sync()), transfer_max can be given as 0.
89 */
90 if ((rv = libusb20_dev_open(dev, 1)) != 0)
91 {
92 fprintf(stderr, "libusb20_dev_open: %s\n", libusb20_strerror(rv));
93 return;
94 }
95
96 /*
97 * If the device has more than one configuration, select the desired
98 * one here.
99 */
100 if ((rv = libusb20_dev_set_config_index(dev, 0)) != 0)
101 {
102 fprintf(stderr, "libusb20_dev_set_config_index: %s\n", libusb20_strerror(rv));
103 return;
104 }
105
106 uint8_t *data = 0;
107 uint16_t actlen;
108
109 if ((setup.bmRequestType & 0x80) != 0)
110 {
111 /* this is an IN request, allocate a buffer */
112 data = malloc(setup.wLength);
113 if (data == 0)
114 {
115 fprintf(stderr,
116 "Out of memory allocating %u bytes of reply buffer\n",
117 setup.wLength);
118 return;
119 }
120 }
121 else
122 data = out_buf;
123
124 if (do_request)
125 {
126 if ((rv = libusb20_dev_request_sync(dev, &setup, data,
127 &actlen,
128 TIMEOUT,
129 0 /* flags */)) != 0)
130 {
131 fprintf(stderr,
132 "libusb20_dev_request_sync: %s\n", libusb20_strerror(rv));
133 }
134 printf("sent %d bytes\n", actlen);
135 if ((setup.bmRequestType & 0x80) != 0)
136 {
137 print_formatted(data, (uint32_t)setup.wLength);
138 free(data);
139 }
140 }
141
142 if (intr_ep != 0)
143 {
144 /*
145 * One transfer has been requested in libusb20_dev_open() above;
146 * obtain the corresponding transfer struct pointer.
147 */
148 struct libusb20_transfer *xfr_intr = libusb20_tr_get_pointer(dev, 0);
149
150 if (xfr_intr == NULL)
151 {
152 fprintf(stderr, "libusb20_tr_get_pointer: %s\n", libusb20_strerror(rv));
153 return;
154 }
155
156 /*
157 * Open the interrupt transfer.
158 */
159 if ((rv = libusb20_tr_open(xfr_intr, 0, 1, intr_ep)) != 0)
160 {
161 fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv));
162 return;
163 }
164
165 uint8_t in_buf[BUFLEN];
166 uint32_t rlen;
167
168 if ((rv = libusb20_tr_bulk_intr_sync(xfr_intr, in_buf, BUFLEN, &rlen, TIMEOUT))
169 != 0)
170 {
171 fprintf(stderr, "libusb20_tr_bulk_intr_sync: %s\n", libusb20_strerror(rv));
172 }
173 printf("received %d bytes\n", rlen);
174 if (rlen > 0)
175 print_formatted(in_buf, rlen);
176
177 libusb20_tr_close(xfr_intr);
178 }
179
180 libusb20_dev_close(dev);
181 }
182
183 static void
usage(void)184 usage(void)
185 {
186 fprintf(stderr,
187 "Usage ./usb [-i <INTR_EP>] -v <VID> -p <PID> [dir type rcpt req wValue wIndex wLength [<outdata> ...]]\n");
188 exit(EX_USAGE);
189 }
190
191 static const char *reqnames[] =
192 {
193 "get_status",
194 "clear_feature",
195 "res1",
196 "set_feature",
197 "res2",
198 "set_address",
199 "get_descriptor",
200 "set_descriptor",
201 "get_configuration",
202 "set_configuration",
203 "get_interface",
204 "set_interface",
205 "synch_frame",
206 };
207
208 static int
get_req(const char * reqname)209 get_req(const char *reqname)
210 {
211 size_t i;
212 size_t l = strlen(reqname);
213
214 for (i = 0;
215 i < sizeof reqnames / sizeof reqnames[0];
216 i++)
217 if (strncasecmp(reqname, reqnames[i], l) == 0)
218 return i;
219
220 return strtoul(reqname, 0, 0);
221 }
222
223
224 static int
parse_req(int argc,char ** argv)225 parse_req(int argc, char **argv)
226 {
227 int idx;
228 uint8_t rt = 0;
229
230 for (idx = 0; argc != 0 && idx <= 6; argc--, idx++)
231 switch (idx)
232 {
233 case 0:
234 /* dir[ection]: i[n] | o[ut] */
235 if (*argv[idx] == 'i')
236 rt |= 0x80;
237 else if (*argv[idx] == 'o')
238 /* nop */;
239 else
240 {
241 fprintf(stderr, "request direction must be \"in\" or \"out\" (got %s)\n",
242 argv[idx]);
243 return -1;
244 }
245 break;
246
247 case 1:
248 /* type: s[tandard] | c[lass] | v[endor] */
249 if (*argv[idx] == 's')
250 /* nop */;
251 else if (*argv[idx] == 'c')
252 rt |= 0x20;
253 else if (*argv[idx] == 'v')
254 rt |= 0x40;
255 else
256 {
257 fprintf(stderr,
258 "request type must be one of \"standard\", \"class\", or \"vendor\" (got %s)\n",
259 argv[idx]);
260 return -1;
261 }
262 break;
263
264 case 2:
265 /* rcpt: d[evice], i[nterface], e[ndpoint], o[ther] */
266 if (*argv[idx] == 'd')
267 /* nop */;
268 else if (*argv[idx] == 'i')
269 rt |= 1;
270 else if (*argv[idx] == 'e')
271 rt |= 2;
272 else if (*argv[idx] == 'o')
273 rt |= 3;
274 else
275 {
276 fprintf(stderr,
277 "recipient must be one of \"device\", \"interface\", \"endpoint\", or \"other\" (got %s)\n",
278 argv[idx]);
279 return -1;
280 }
281 setup.bmRequestType = rt;
282 break;
283
284 case 3:
285 setup.bRequest = get_req(argv[idx]);
286 break;
287
288 case 4:
289 setup.wValue = strtoul(argv[idx], 0, 0);
290 break;
291
292 case 5:
293 setup.wIndex = strtoul(argv[idx], 0, 0);
294 break;
295
296 case 6:
297 setup.wLength = strtoul(argv[idx], 0, 0);
298 break;
299 }
300
301 return argc;
302 }
303
304
305 int
main(int argc,char ** argv)306 main(int argc, char **argv)
307 {
308 unsigned int vid = UINT_MAX, pid = UINT_MAX; /* impossible VID:PID */
309 int c;
310
311 /*
312 * Initialize setup struct. This step is required, and initializes
313 * internal fields in the struct.
314 *
315 * All the "public" fields are named exactly the way as the USB
316 * standard describes them, namely:
317 *
318 * setup.bmRequestType: bitmask, bit 7 is direction
319 * bits 6/5 is request type
320 * (standard, class, vendor)
321 * bits 4..0 is recipient
322 * (device, interface, endpoint,
323 * other)
324 * setup.bRequest: the request itself (see get_req() for standard
325 * requests, or specific value)
326 * setup.wValue: a 16-bit value
327 * setup.wIndex: another 16-bit value
328 * setup.wLength: length of associated data transfer, direction
329 * depends on bit 7 of bmRequestType
330 */
331 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup);
332
333 while ((c = getopt(argc, argv, "i:p:v:")) != -1)
334 switch (c)
335 {
336 case 'i':
337 intr_ep = strtol(optarg, NULL, 0);
338 break;
339
340 case 'p':
341 pid = strtol(optarg, NULL, 0);
342 break;
343
344 case 'v':
345 vid = strtol(optarg, NULL, 0);
346 break;
347
348 default:
349 usage();
350 break;
351 }
352 argc -= optind;
353 argv += optind;
354
355 if (vid != UINT_MAX || pid != UINT_MAX)
356 {
357 if (intr_ep != 0 && (intr_ep & 0x80) == 0)
358 {
359 fprintf(stderr, "Interrupt endpoint must be of type IN\n");
360 usage();
361 }
362
363 if (argc > 0)
364 {
365 do_request = true;
366
367 int rv = parse_req(argc, argv);
368 if (rv < 0)
369 return EX_USAGE;
370 argc = rv;
371
372 if (argc > 0)
373 {
374 for (out_len = 0; argc > 0 && out_len < BUFLEN; out_len++, argc--)
375 {
376 unsigned n = strtoul(argv[out_len], 0, 0);
377 if (n > 255)
378 fprintf(stderr,
379 "Warning: data #%d 0x%0x > 0xff, truncating\n",
380 out_len, n);
381 out_buf[out_len] = (uint8_t)n;
382 }
383 out_len++;
384 if (argc > 0)
385 fprintf(stderr,
386 "Data count exceeds maximum of %d, ignoring %d elements\n",
387 BUFLEN, optind);
388 }
389 }
390 }
391
392 struct libusb20_backend *be;
393 struct libusb20_device *dev;
394
395 if ((be = libusb20_be_alloc_default(NULL)) == NULL)
396 {
397 perror("libusb20_be_alloc()");
398 return 1;
399 }
400
401 if (caph_enter() < 0)
402 {
403 perror("caph_enter()");
404 return 1;
405 }
406
407 dev = NULL;
408 while ((dev = libusb20_be_device_foreach(be, dev)) != NULL)
409 {
410 struct LIBUSB20_DEVICE_DESC_DECODED *ddp =
411 libusb20_dev_get_device_desc(dev);
412
413 printf("Found device %s (VID:PID = 0x%04x:0x%04x)\n",
414 libusb20_dev_get_desc(dev),
415 ddp->idVendor, ddp->idProduct);
416
417 if (ddp->idVendor == vid && ddp->idProduct == pid)
418 doit(dev);
419 }
420
421 libusb20_be_free(be);
422 return 0;
423 }
424