1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
|
/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
/*
* Core functions for libusb
* Copyright © 2012-2013 Nathan Hjelm <hjelmn@cs.unm.edu>
* Copyright © 2007-2008 Daniel Drake <dsd@gentoo.org>
* Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config.h"
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_SYSLOG_H
#include <syslog.h>
#endif
#ifdef __ANDROID__
#include <android/log.h>
#endif
#include "libusbi.h"
#include "hotplug.h"
#if defined(OS_LINUX)
const struct usbi_os_backend * const usbi_backend = &linux_usbfs_backend;
#elif defined(OS_DARWIN)
const struct usbi_os_backend * const usbi_backend = &darwin_backend;
#elif defined(OS_OPENBSD)
const struct usbi_os_backend * const usbi_backend = &openbsd_backend;
#elif defined(OS_NETBSD)
const struct usbi_os_backend * const usbi_backend = &netbsd_backend;
#elif defined(OS_WINDOWS)
#if defined(USE_USBDK)
const struct usbi_os_backend * const usbi_backend = &usbdk_backend;
#else
const struct usbi_os_backend * const usbi_backend = &windows_backend;
#endif
#elif defined(OS_WINCE)
const struct usbi_os_backend * const usbi_backend = &wince_backend;
#elif defined(OS_HAIKU)
const struct usbi_os_backend * const usbi_backend = &haiku_usb_raw_backend;
#elif defined (OS_SUNOS)
const struct usbi_os_backend * const usbi_backend = &sunos_backend;
#else
#error "Unsupported OS"
#endif
struct libusb_context *usbi_default_context = NULL;
static const struct libusb_version libusb_version_internal =
{ LIBUSB_MAJOR, LIBUSB_MINOR, LIBUSB_MICRO, LIBUSB_NANO,
LIBUSB_RC, "http://libusb.info" };
static int default_context_refcnt = 0;
static usbi_mutex_static_t default_context_lock = USBI_MUTEX_INITIALIZER;
static struct timespec timestamp_origin = { 0, 0 };
usbi_mutex_static_t active_contexts_lock = USBI_MUTEX_INITIALIZER;
struct list_head active_contexts_list;
/**
* \mainpage libusb-1.0 API Reference
*
* \section intro Introduction
*
* libusb is an open source library that allows you to communicate with USB
* devices from userspace. For more info, see the
* <a href="http://libusb.info">libusb homepage</a>.
*
* This documentation is aimed at application developers wishing to
* communicate with USB peripherals from their own software. After reviewing
* this documentation, feedback and questions can be sent to the
* <a href="http://mailing-list.libusb.info">libusb-devel mailing list</a>.
*
* This documentation assumes knowledge of how to operate USB devices from
* a software standpoint (descriptors, configurations, interfaces, endpoints,
* control/bulk/interrupt/isochronous transfers, etc). Full information
* can be found in the <a href="http://www.usb.org/developers/docs/">USB 3.0
* Specification</a> which is available for free download. You can probably
* find less verbose introductions by searching the web.
*
* \section API Application Programming Interface (API)
*
* See the \ref libusb_api page for a complete list of the libusb functions.
*
* \section features Library features
*
* - All transfer types supported (control/bulk/interrupt/isochronous)
* - 2 transfer interfaces:
* -# Synchronous (simple)
* -# Asynchronous (more complicated, but more powerful)
* - Thread safe (although the asynchronous interface means that you
* usually won't need to thread)
* - Lightweight with lean API
* - Compatible with libusb-0.1 through the libusb-compat-0.1 translation layer
* - Hotplug support (on some platforms). See \ref libusb_hotplug.
*
* \section gettingstarted Getting Started
*
* To begin reading the API documentation, start with the Modules page which
* links to the different categories of libusb's functionality.
*
* One decision you will have to make is whether to use the synchronous
* or the asynchronous data transfer interface. The \ref libusb_io documentation
* provides some insight into this topic.
*
* Some example programs can be found in the libusb source distribution under
* the "examples" subdirectory. The libusb homepage includes a list of
* real-life project examples which use libusb.
*
* \section errorhandling Error handling
*
* libusb functions typically return 0 on success or a negative error code
* on failure. These negative error codes relate to LIBUSB_ERROR constants
* which are listed on the \ref libusb_misc "miscellaneous" documentation page.
*
* \section msglog Debug message logging
*
* libusb uses stderr for all logging. By default, logging is set to NONE,
* which means that no output will be produced. However, unless the library
* has been compiled with logging disabled, then any application calls to
* libusb_set_debug(), or the setting of the environmental variable
* LIBUSB_DEBUG outside of the application, can result in logging being
* produced. Your application should therefore not close stderr, but instead
* direct it to the null device if its output is undesirable.
*
* The libusb_set_debug() function can be used to enable logging of certain
* messages. Under standard configuration, libusb doesn't really log much
* so you are advised to use this function to enable all error/warning/
* informational messages. It will help debug problems with your software.
*
* The logged messages are unstructured. There is no one-to-one correspondence
* between messages being logged and success or failure return codes from
* libusb functions. There is no format to the messages, so you should not
* try to capture or parse them. They are not and will not be localized.
* These messages are not intended to being passed to your application user;
* instead, you should interpret the error codes returned from libusb functions
* and provide appropriate notification to the user. The messages are simply
* there to aid you as a programmer, and if you're confused because you're
* getting a strange error code from a libusb function, enabling message
* logging may give you a suitable explanation.
*
* The LIBUSB_DEBUG environment variable can be used to enable message logging
* at run-time. This environment variable should be set to a log level number,
* which is interpreted the same as the libusb_set_debug() parameter. When this
* environment variable is set, the message logging verbosity level is fixed
* and libusb_set_debug() effectively does nothing.
*
* libusb can be compiled without any logging functions, useful for embedded
* systems. In this case, libusb_set_debug() and the LIBUSB_DEBUG environment
* variable have no effects.
*
* libusb can also be compiled with verbose debugging messages always. When
* the library is compiled in this way, all messages of all verbosities are
* always logged. libusb_set_debug() and the LIBUSB_DEBUG environment variable
* have no effects.
*
* \section remarks Other remarks
*
* libusb does have imperfections. The \ref libusb_caveats "caveats" page attempts
* to document these.
*/
/**
* \page libusb_caveats Caveats
*
* \section devresets Device resets
*
* The libusb_reset_device() function allows you to reset a device. If your
* program has to call such a function, it should obviously be aware that
* the reset will cause device state to change (e.g. register values may be
* reset).
*
* The problem is that any other program could reset the device your program
* is working with, at any time. libusb does not offer a mechanism to inform
* you when this has happened, so if someone else resets your device it will
* not be clear to your own program why the device state has changed.
*
* Ultimately, this is a limitation of writing drivers in userspace.
* Separation from the USB stack in the underlying kernel makes it difficult
* for the operating system to deliver such notifications to your program.
* The Linux kernel USB stack allows such reset notifications to be delivered
* to in-kernel USB drivers, but it is not clear how such notifications could
* be delivered to second-class drivers that live in userspace.
*
* \section blockonly Blocking-only functionality
*
* The functionality listed below is only available through synchronous,
* blocking functions. There are no asynchronous/non-blocking alternatives,
* and no clear ways of implementing these.
*
* - Configuration activation (libusb_set_configuration())
* - Interface/alternate setting activation (libusb_set_interface_alt_setting())
* - Releasing of interfaces (libusb_release_interface())
* - Clearing of halt/stall condition (libusb_clear_halt())
* - Device resets (libusb_reset_device())
*
* \section configsel Configuration selection and handling
*
* When libusb presents a device handle to an application, there is a chance
* that the corresponding device may be in unconfigured state. For devices
* with multiple configurations, there is also a chance that the configuration
* currently selected is not the one that the application wants to use.
*
* The obvious solution is to add a call to libusb_set_configuration() early
* on during your device initialization routines, but there are caveats to
* be aware of:
* -# If the device is already in the desired configuration, calling
* libusb_set_configuration() using the same configuration value will cause
* a lightweight device reset. This may not be desirable behaviour.
* -# In the case where the desired configuration is already active, libusb
* may not even be able to perform a lightweight device reset. For example,
* take my USB keyboard with fingerprint reader: I'm interested in driving
* the fingerprint reader interface through libusb, but the kernel's
* USB-HID driver will almost always have claimed the keyboard interface.
* Because the kernel has claimed an interface, it is not even possible to
* perform the lightweight device reset, so libusb_set_configuration() will
* fail. (Luckily the device in question only has a single configuration.)
* -# libusb will be unable to set a configuration if other programs or
* drivers have claimed interfaces. In particular, this means that kernel
* drivers must be detached from all the interfaces before
* libusb_set_configuration() may succeed.
*
* One solution to some of the above problems is to consider the currently
* active configuration. If the configuration we want is already active, then
* we don't have to select any configuration:
\code
cfg = -1;
libusb_get_configuration(dev, &cfg);
if (cfg != desired)
libusb_set_configuration(dev, desired);
\endcode
*
* This is probably suitable for most scenarios, but is inherently racy:
* another application or driver may change the selected configuration
* <em>after</em> the libusb_get_configuration() call.
*
* Even in cases where libusb_set_configuration() succeeds, consider that other
* applications or drivers may change configuration after your application
* calls libusb_set_configuration().
*
* One possible way to lock your device into a specific configuration is as
* follows:
* -# Set the desired configuration (or use the logic above to realise that
* it is already in the desired configuration)
* -# Claim the interface that you wish to use
* -# Check that the currently active configuration is the one that you want
* to use.
*
* The above method works because once an interface is claimed, no application
* or driver is able to select another configuration.
*
* \section earlycomp Early transfer completion
*
* NOTE: This section is currently Linux-centric. I am not sure if any of these
* considerations apply to Darwin or other platforms.
*
* When a transfer completes early (i.e. when less data is received/sent in
* any one packet than the transfer buffer allows for) then libusb is designed
* to terminate the transfer immediately, not transferring or receiving any
* more data unless other transfers have been queued by the user.
*
* On legacy platforms, libusb is unable to do this in all situations. After
* the incomplete packet occurs, "surplus" data may be transferred. For recent
* versions of libusb, this information is kept (the data length of the
* transfer is updated) and, for device-to-host transfers, any surplus data was
* added to the buffer. Still, this is not a nice solution because it loses the
* information about the end of the short packet, and the user probably wanted
* that surplus data to arrive in the next logical transfer.
*
*
* \section zlp Zero length packets
*
* - libusb is able to send a packet of zero length to an endpoint simply by
* submitting a transfer of zero length.
* - The \ref libusb_transfer_flags::LIBUSB_TRANSFER_ADD_ZERO_PACKET
* "LIBUSB_TRANSFER_ADD_ZERO_PACKET" flag is currently only supported on Linux.
*/
/**
* \page libusb_contexts Contexts
*
* It is possible that libusb may be used simultaneously from two independent
* libraries linked into the same executable. For example, if your application
* has a plugin-like system which allows the user to dynamically load a range
* of modules into your program, it is feasible that two independently
* developed modules may both use libusb.
*
* libusb is written to allow for these multiple user scenarios. The two
* "instances" of libusb will not interfere: libusb_set_debug() calls
* from one user will not affect the same settings for other users, other
* users can continue using libusb after one of them calls libusb_exit(), etc.
*
* This is made possible through libusb's <em>context</em> concept. When you
* call libusb_init(), you are (optionally) given a context. You can then pass
* this context pointer back into future libusb functions.
*
* In order to keep things simple for more simplistic applications, it is
* legal to pass NULL to all functions requiring a context pointer (as long as
* you're sure no other code will attempt to use libusb from the same process).
* When you pass NULL, the default context will be used. The default context
* is created the first time a process calls libusb_init() when no other
* context is alive. Contexts are destroyed during libusb_exit().
*
* The default context is reference-counted and can be shared. That means that
* if libusb_init(NULL) is called twice within the same process, the two
* users end up sharing the same context. The deinitialization and freeing of
* the default context will only happen when the last user calls libusb_exit().
* In other words, the default context is created and initialized when its
* reference count goes from 0 to 1, and is deinitialized and destroyed when
* its reference count goes from 1 to 0.
*
* You may be wondering why only a subset of libusb functions require a
* context pointer in their function definition. Internally, libusb stores
* context pointers in other objects (e.g. libusb_device instances) and hence
* can infer the context from those objects.
*/
/**
* \page libusb_api Application Programming Interface
*
* This is the complete list of libusb functions, structures and
* enumerations in alphabetical order.
*
* \section Functions
* - libusb_alloc_streams()
* - libusb_alloc_transfer()
* - libusb_attach_kernel_driver()
* - libusb_bulk_transfer()
* - libusb_cancel_transfer()
* - libusb_claim_interface()
* - libusb_clear_halt()
* - libusb_close()
* - libusb_control_transfer()
* - libusb_control_transfer_get_data()
* - libusb_control_transfer_get_setup()
* - libusb_cpu_to_le16()
* - libusb_detach_kernel_driver()
* - libusb_dev_mem_alloc()
* - libusb_dev_mem_free()
* - libusb_error_name()
* - libusb_event_handler_active()
* - libusb_event_handling_ok()
* - libusb_exit()
* - libusb_fill_bulk_stream_transfer()
* - libusb_fill_bulk_transfer()
* - libusb_fill_control_setup()
* - libusb_fill_control_transfer()
* - libusb_fill_interrupt_transfer()
* - libusb_fill_iso_transfer()
* - libusb_free_bos_descriptor()
* - libusb_free_config_descriptor()
* - libusb_free_container_id_descriptor()
* - libusb_free_device_list()
* - libusb_free_pollfds()
* - libusb_free_ss_endpoint_companion_descriptor()
* - libusb_free_ss_usb_device_capability_descriptor()
* - libusb_free_streams()
* - libusb_free_transfer()
* - libusb_free_usb_2_0_extension_descriptor()
* - libusb_get_active_config_descriptor()
* - libusb_get_bos_descriptor()
* - libusb_get_bus_number()
* - libusb_get_config_descriptor()
* - libusb_get_config_descriptor_by_value()
* - libusb_get_configuration()
* - libusb_get_container_id_descriptor()
* - libusb_get_descriptor()
* - libusb_get_device()
* - libusb_get_device_address()
* - libusb_get_device_descriptor()
* - libusb_get_device_list()
* - libusb_get_device_speed()
* - libusb_get_iso_packet_buffer()
* - libusb_get_iso_packet_buffer_simple()
* - libusb_get_max_iso_packet_size()
* - libusb_get_max_packet_size()
* - libusb_get_next_timeout()
* - libusb_get_parent()
* - libusb_get_pollfds()
* - libusb_get_port_number()
* - libusb_get_port_numbers()
* - libusb_get_port_path()
* - libusb_get_ss_endpoint_companion_descriptor()
* - libusb_get_ss_usb_device_capability_descriptor()
* - libusb_get_string_descriptor()
* - libusb_get_string_descriptor_ascii()
* - libusb_get_usb_2_0_extension_descriptor()
* - libusb_get_version()
* - libusb_handle_events()
* - libusb_handle_events_completed()
* - libusb_handle_events_locked()
* - libusb_handle_events_timeout()
* - libusb_handle_events_timeout_completed()
* - libusb_has_capability()
* - libusb_hotplug_deregister_callback()
* - libusb_hotplug_register_callback()
* - libusb_init()
* - libusb_interrupt_event_handler()
* - libusb_interrupt_transfer()
* - libusb_kernel_driver_active()
* - libusb_lock_events()
* - libusb_lock_event_waiters()
* - libusb_open()
* - libusb_open_device_with_vid_pid()
* - libusb_pollfds_handle_timeouts()
* - libusb_ref_device()
* - libusb_release_interface()
* - libusb_reset_device()
* - libusb_set_auto_detach_kernel_driver()
* - libusb_set_configuration()
* - libusb_set_debug()
* - libusb_set_interface_alt_setting()
* - libusb_set_iso_packet_lengths()
* - libusb_setlocale()
* - libusb_set_pollfd_notifiers()
* - libusb_strerror()
* - libusb_submit_transfer()
* - libusb_transfer_get_stream_id()
* - libusb_transfer_set_stream_id()
* - libusb_try_lock_events()
* - libusb_unlock_events()
* - libusb_unlock_event_waiters()
* - libusb_unref_device()
* - libusb_wait_for_event()
*
* \section Structures
* - libusb_bos_descriptor
* - libusb_bos_dev_capability_descriptor
* - libusb_config_descriptor
* - libusb_container_id_descriptor
* - \ref libusb_context
* - libusb_control_setup
* - \ref libusb_device
* - libusb_device_descriptor
* - \ref libusb_device_handle
* - libusb_endpoint_descriptor
* - libusb_interface
* - libusb_interface_descriptor
* - libusb_iso_packet_descriptor
* - libusb_pollfd
* - libusb_ss_endpoint_companion_descriptor
* - libusb_ss_usb_device_capability_descriptor
* - libusb_transfer
* - libusb_usb_2_0_extension_descriptor
* - libusb_version
*
* \section Enums
* - \ref libusb_bos_type
* - \ref libusb_capability
* - \ref libusb_class_code
* - \ref libusb_descriptor_type
* - \ref libusb_endpoint_direction
* - \ref libusb_error
* - \ref libusb_iso_sync_type
* - \ref libusb_iso_usage_type
* - \ref libusb_log_level
* - \ref libusb_request_recipient
* - \ref libusb_request_type
* - \ref libusb_speed
* - \ref libusb_ss_usb_device_capability_attributes
* - \ref libusb_standard_request
* - \ref libusb_supported_speed
* - \ref libusb_transfer_flags
* - \ref libusb_transfer_status
* - \ref libusb_transfer_type
* - \ref libusb_usb_2_0_extension_attributes
*/
/**
* @defgroup libusb_lib Library initialization/deinitialization
* This page details how to initialize and deinitialize libusb. Initialization
* must be performed before using any libusb functionality, and similarly you
* must not call any libusb functions after deinitialization.
*/
/**
* @defgroup libusb_dev Device handling and enumeration
* The functionality documented below is designed to help with the following
* operations:
* - Enumerating the USB devices currently attached to the system
* - Choosing a device to operate from your software
* - Opening and closing the chosen device
*
* \section nutshell In a nutshell...
*
* The description below really makes things sound more complicated than they
* actually are. The following sequence of function calls will be suitable
* for almost all scenarios and does not require you to have such a deep
* understanding of the resource management issues:
* \code
// discover devices
libusb_device **list;
libusb_device *found = NULL;
ssize_t cnt = libusb_get_device_list(NULL, &list);
ssize_t i = 0;
int err = 0;
if (cnt < 0)
error();
for (i = 0; i < cnt; i++) {
libusb_device *device = list[i];
if (is_interesting(device)) {
found = device;
break;
}
}
if (found) {
libusb_device_handle *handle;
err = libusb_open(found, &handle);
if (err)
error();
// etc
}
libusb_free_device_list(list, 1);
\endcode
*
* The two important points:
* - You asked libusb_free_device_list() to unreference the devices (2nd
* parameter)
* - You opened the device before freeing the list and unreferencing the
* devices
*
* If you ended up with a handle, you can now proceed to perform I/O on the
* device.
*
* \section devshandles Devices and device handles
* libusb has a concept of a USB device, represented by the
* \ref libusb_device opaque type. A device represents a USB device that
* is currently or was previously connected to the system. Using a reference
* to a device, you can determine certain information about the device (e.g.
* you can read the descriptor data).
*
* The libusb_get_device_list() function can be used to obtain a list of
* devices currently connected to the system. This is known as device
* discovery.
*
* Just because you have a reference to a device does not mean it is
* necessarily usable. The device may have been unplugged, you may not have
* permission to operate such device, or another program or driver may be
* using the device.
*
* When you've found a device that you'd like to operate, you must ask
* libusb to open the device using the libusb_open() function. Assuming
* success, libusb then returns you a <em>device handle</em>
* (a \ref libusb_device_handle pointer). All "real" I/O operations then
* operate on the handle rather than the original device pointer.
*
* \section devref Device discovery and reference counting
*
* Device discovery (i.e. calling libusb_get_device_list()) returns a
* freshly-allocated list of devices. The list itself must be freed when
* you are done with it. libusb also needs to know when it is OK to free
* the contents of the list - the devices themselves.
*
* To handle these issues, libusb provides you with two separate items:
* - A function to free the list itself
* - A reference counting system for the devices inside
*
* New devices presented by the libusb_get_device_list() function all have a
* reference count of 1. You can increase and decrease reference count using
* libusb_ref_device() and libusb_unref_device(). A device is destroyed when
* its reference count reaches 0.
*
* With the above information in mind, the process of opening a device can
* be viewed as follows:
* -# Discover devices using libusb_get_device_list().
* -# Choose the device that you want to operate, and call libusb_open().
* -# Unref all devices in the discovered device list.
* -# Free the discovered device list.
*
* The order is important - you must not unreference the device before
* attempting to open it, because unreferencing it may destroy the device.
*
* For convenience, the libusb_free_device_list() function includes a
* parameter to optionally unreference all the devices in the list before
* freeing the list itself. This combines steps 3 and 4 above.
*
* As an implementation detail, libusb_open() actually adds a reference to
* the device in question. This is because the device remains available
* through the handle via libusb_get_device(). The reference is deleted during
* libusb_close().
*/
/** @defgroup libusb_misc Miscellaneous */
/* we traverse usbfs without knowing how many devices we are going to find.
* so we create this discovered_devs model which is similar to a linked-list
* which grows when required. it can be freed once discovery has completed,
* eliminating the need for a list node in the libusb_device structure
* itself. */
#define DISCOVERED_DEVICES_SIZE_STEP 8
static struct discovered_devs *discovered_devs_alloc(void)
{
struct discovered_devs *ret =
malloc(sizeof(*ret) + (sizeof(void *) * DISCOVERED_DEVICES_SIZE_STEP));
if (ret) {
ret->len = 0;
ret->capacity = DISCOVERED_DEVICES_SIZE_STEP;
}
return ret;
}
static void discovered_devs_free(struct discovered_devs *discdevs)
{
size_t i;
for (i = 0; i < discdevs->len; i++)
libusb_unref_device(discdevs->devices[i]);
free(discdevs);
}
/* append a device to the discovered devices collection. may realloc itself,
* returning new discdevs. returns NULL on realloc failure. */
struct discovered_devs *discovered_devs_append(
struct discovered_devs *discdevs, struct libusb_device *dev)
{
size_t len = discdevs->len;
size_t capacity;
struct discovered_devs *new_discdevs;
/* if there is space, just append the device */
if (len < discdevs->capacity) {
discdevs->devices[len] = libusb_ref_device(dev);
discdevs->len++;
return discdevs;
}
/* exceeded capacity, need to grow */
usbi_dbg("need to increase capacity");
capacity = discdevs->capacity + DISCOVERED_DEVICES_SIZE_STEP;
/* can't use usbi_reallocf here because in failure cases it would
* free the existing discdevs without unreferencing its devices. */
new_discdevs = realloc(discdevs,
sizeof(*discdevs) + (sizeof(void *) * capacity));
if (!new_discdevs) {
discovered_devs_free(discdevs);
return NULL;
}
discdevs = new_discdevs;
discdevs->capacity = capacity;
discdevs->devices[len] = libusb_ref_device(dev);
discdevs->len++;
return discdevs;
}
/* Allocate a new device with a specific session ID. The returned device has
* a reference count of 1. */
struct libusb_device *usbi_alloc_device(struct libusb_context *ctx,
unsigned long session_id)
{
size_t priv_size = usbi_backend->device_priv_size;
struct libusb_device *dev = calloc(1, sizeof(*dev) + priv_size);
int r;
if (!dev)
return NULL;
r = usbi_mutex_init(&dev->lock);
if (r) {
free(dev);
return NULL;
}
dev->ctx = ctx;
dev->refcnt = 1;
dev->session_data = session_id;
dev->speed = LIBUSB_SPEED_UNKNOWN;
if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
usbi_connect_device (dev);
}
return dev;
}
void usbi_connect_device(struct libusb_device *dev)
{
struct libusb_context *ctx = DEVICE_CTX(dev);
dev->attached = 1;
usbi_mutex_lock(&dev->ctx->usb_devs_lock);
list_add(&dev->list, &dev->ctx->usb_devs);
usbi_mutex_unlock(&dev->ctx->usb_devs_lock);
/* Signal that an event has occurred for this device if we support hotplug AND
* the hotplug message list is ready. This prevents an event from getting raised
* during initial enumeration. */
if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG) && dev->ctx->hotplug_msgs.next) {
usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
}
}
void usbi_disconnect_device(struct libusb_device *dev)
{
struct libusb_context *ctx = DEVICE_CTX(dev);
usbi_mutex_lock(&dev->lock);
dev->attached = 0;
usbi_mutex_unlock(&dev->lock);
usbi_mutex_lock(&ctx->usb_devs_lock);
list_del(&dev->list);
usbi_mutex_unlock(&ctx->usb_devs_lock);
/* Signal that an event has occurred for this device if we support hotplug AND
* the hotplug message list is ready. This prevents an event from getting raised
* during initial enumeration. libusb_handle_events will take care of dereferencing
* the device. */
if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG) && dev->ctx->hotplug_msgs.next) {
usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT);
}
}
/* Perform some final sanity checks on a newly discovered device. If this
* function fails (negative return code), the device should not be added
* to the discovered device list. */
int usbi_sanitize_device(struct libusb_device *dev)
{
int r;
uint8_t num_configurations;
r = usbi_device_cache_descriptor(dev);
if (r < 0)
return r;
num_configurations = dev->device_descriptor.bNumConfigurations;
if (num_configurations > USB_MAXCONFIG) {
usbi_err(DEVICE_CTX(dev), "too many configurations");
return LIBUSB_ERROR_IO;
} else if (0 == num_configurations)
usbi_dbg("zero configurations, maybe an unauthorized device");
dev->num_configurations = num_configurations;
return 0;
}
/* Examine libusb's internal list of known devices, looking for one with
* a specific session ID. Returns the matching device if it was found, and
* NULL otherwise. */
struct libusb_device *usbi_get_device_by_session_id(struct libusb_context *ctx,
unsigned long session_id)
{
struct libusb_device *dev;
struct libusb_device *ret = NULL;
usbi_mutex_lock(&ctx->usb_devs_lock);
list_for_each_entry(dev, &ctx->usb_devs, list, struct libusb_device)
if (dev->session_data == session_id) {
ret = libusb_ref_device(dev);
break;
}
usbi_mutex_unlock(&ctx->usb_devs_lock);
return ret;
}
/** @ingroup libusb_dev
* Returns a list of USB devices currently attached to the system. This is
* your entry point into finding a USB device to operate.
*
* You are expected to unreference all the devices when you are done with
* them, and then free the list with libusb_free_device_list(). Note that
* libusb_free_device_list() can unref all the devices for you. Be careful
* not to unreference a device you are about to open until after you have
* opened it.
*
* This return value of this function indicates the number of devices in
* the resultant list. The list is actually one element larger, as it is
* NULL-terminated.
*
* \param ctx the context to operate on, or NULL for the default context
* \param list output location for a list of devices. Must be later freed with
* libusb_free_device_list().
* \returns the number of devices in the outputted list, or any
* \ref libusb_error according to errors encountered by the backend.
*/
ssize_t API_EXPORTED libusb_get_device_list(libusb_context *ctx,
libusb_device ***list)
{
struct discovered_devs *discdevs = discovered_devs_alloc();
struct libusb_device **ret;
int r = 0;
ssize_t i, len;
USBI_GET_CONTEXT(ctx);
usbi_dbg("");
if (!discdevs)
return LIBUSB_ERROR_NO_MEM;
if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
/* backend provides hotplug support */
struct libusb_device *dev;
if (usbi_backend->hotplug_poll)
usbi_backend->hotplug_poll();
usbi_mutex_lock(&ctx->usb_devs_lock);
list_for_each_entry(dev, &ctx->usb_devs, list, struct libusb_device) {
discdevs = discovered_devs_append(discdevs, dev);
if (!discdevs) {
r = LIBUSB_ERROR_NO_MEM;
break;
}
}
usbi_mutex_unlock(&ctx->usb_devs_lock);
} else {
/* backend does not provide hotplug support */
r = usbi_backend->get_device_list(ctx, &discdevs);
}
if (r < 0) {
len = r;
goto out;
}
/* convert discovered_devs into a list */
len = discdevs->len;
ret = calloc(len + 1, sizeof(struct libusb_device *));
if (!ret) {
len = LIBUSB_ERROR_NO_MEM;
goto out;
}
ret[len] = NULL;
for (i = 0; i < len; i++) {
struct libusb_device *dev = discdevs->devices[i];
ret[i] = libusb_ref_device(dev);
}
*list = ret;
out:
if (discdevs)
discovered_devs_free(discdevs);
return len;
}
/** \ingroup libusb_dev
* Frees a list of devices previously discovered using
* libusb_get_device_list(). If the unref_devices parameter is set, the
* reference count of each device in the list is decremented by 1.
* \param list the list to free
* \param unref_devices whether to unref the devices in the list
*/
void API_EXPORTED libusb_free_device_list(libusb_device **list,
int unref_devices)
{
if (!list)
return;
if (unref_devices) {
int i = 0;
struct libusb_device *dev;
while ((dev = list[i++]) != NULL)
libusb_unref_device(dev);
}
free(list);
}
/** \ingroup libusb_dev
* Get the number of the bus that a device is connected to.
* \param dev a device
* \returns the bus number
*/
uint8_t API_EXPORTED libusb_get_bus_number(libusb_device *dev)
{
return dev->bus_number;
}
/** \ingroup libusb_dev
* Get the number of the port that a device is connected to.
* Unless the OS does something funky, or you are hot-plugging USB extension cards,
* the port number returned by this call is usually guaranteed to be uniquely tied
* to a physical port, meaning that different devices plugged on the same physical
* port should return the same port number.
*
* But outside of this, there is no guarantee that the port number returned by this
* call will remain the same, or even match the order in which ports have been
* numbered by the HUB/HCD manufacturer.
*
* \param dev a device
* \returns the port number (0 if not available)
*/
uint8_t API_EXPORTED libusb_get_port_number(libusb_device *dev)
{
return dev->port_number;
}
/** \ingroup libusb_dev
* Get the list of all port numbers from root for the specified device
*
* Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
* \param dev a device
* \param port_numbers the array that should contain the port numbers
* \param port_numbers_len the maximum length of the array. As per the USB 3.0
* specs, the current maximum limit for the depth is 7.
* \returns the number of elements filled
* \returns LIBUSB_ERROR_OVERFLOW if the array is too small
*/
int API_EXPORTED libusb_get_port_numbers(libusb_device *dev,
uint8_t* port_numbers, int port_numbers_len)
{
int i = port_numbers_len;
struct libusb_context *ctx = DEVICE_CTX(dev);
if (port_numbers_len <= 0)
return LIBUSB_ERROR_INVALID_PARAM;
// HCDs can be listed as devices with port #0
while((dev) && (dev->port_number != 0)) {
if (--i < 0) {
usbi_warn(ctx, "port numbers array is too small");
return LIBUSB_ERROR_OVERFLOW;
}
port_numbers[i] = dev->port_number;
dev = dev->parent_dev;
}
if (i < port_numbers_len)
memmove(port_numbers, &port_numbers[i], port_numbers_len - i);
return port_numbers_len - i;
}
/** \ingroup libusb_dev
* Deprecated please use libusb_get_port_numbers instead.
*/
int API_EXPORTED libusb_get_port_path(libusb_context *ctx, libusb_device *dev,
uint8_t* port_numbers, uint8_t port_numbers_len)
{
UNUSED(ctx);
return libusb_get_port_numbers(dev, port_numbers, port_numbers_len);
}
/** \ingroup libusb_dev
* Get the the parent from the specified device.
* \param dev a device
* \returns the device parent or NULL if not available
* You should issue a \ref libusb_get_device_list() before calling this
* function and make sure that you only access the parent before issuing
* \ref libusb_free_device_list(). The reason is that libusb currently does
* not maintain a permanent list of device instances, and therefore can
* only guarantee that parents are fully instantiated within a
* libusb_get_device_list() - libusb_free_device_list() block.
*/
DEFAULT_VISIBILITY
libusb_device * LIBUSB_CALL libusb_get_parent(libusb_device *dev)
{
return dev->parent_dev;
}
/** \ingroup libusb_dev
* Get the address of the device on the bus it is connected to.
* \param dev a device
* \returns the device address
*/
uint8_t API_EXPORTED libusb_get_device_address(libusb_device *dev)
{
return dev->device_address;
}
/** \ingroup libusb_dev
* Get the negotiated connection speed for a device.
* \param dev a device
* \returns a \ref libusb_speed code, where LIBUSB_SPEED_UNKNOWN means that
* the OS doesn't know or doesn't support returning the negotiated speed.
*/
int API_EXPORTED libusb_get_device_speed(libusb_device *dev)
{
return dev->speed;
}
static const struct libusb_endpoint_descriptor *find_endpoint(
struct libusb_config_descriptor *config, unsigned char endpoint)
{
int iface_idx;
for (iface_idx = 0; iface_idx < config->bNumInterfaces; iface_idx++) {
const struct libusb_interface *iface = &config->interface[iface_idx];
int altsetting_idx;
for (altsetting_idx = 0; altsetting_idx < iface->num_altsetting;
altsetting_idx++) {
const struct libusb_interface_descriptor *altsetting
= &iface->altsetting[altsetting_idx];
int ep_idx;
for (ep_idx = 0; ep_idx < altsetting->bNumEndpoints; ep_idx++) {
const struct libusb_endpoint_descriptor *ep =
&altsetting->endpoint[ep_idx];
if (ep->bEndpointAddress == endpoint)
return ep;
}
}
}
return NULL;
}
/** \ingroup libusb_dev
* Convenience function to retrieve the wMaxPacketSize value for a particular
* endpoint in the active device configuration.
*
* This function was originally intended to be of assistance when setting up
* isochronous transfers, but a design mistake resulted in this function
* instead. It simply returns the wMaxPacketSize value without considering
* its contents. If you're dealing with isochronous transfers, you probably
* want libusb_get_max_iso_packet_size() instead.
*
* \param dev a device
* \param endpoint address of the endpoint in question
* \returns the wMaxPacketSize value
* \returns LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
* \returns LIBUSB_ERROR_OTHER on other failure
*/
int API_EXPORTED libusb_get_max_packet_size(libusb_device *dev,
unsigned char endpoint)
{
struct libusb_config_descriptor *config;
const struct libusb_endpoint_descriptor *ep;
int r;
r = libusb_get_active_config_descriptor(dev, &config);
if (r < 0) {
usbi_err(DEVICE_CTX(dev),
"could not retrieve active config descriptor");
return LIBUSB_ERROR_OTHER;
}
ep = find_endpoint(config, endpoint);
if (!ep) {
r = LIBUSB_ERROR_NOT_FOUND;
goto out;
}
r = ep->wMaxPacketSize;
out:
libusb_free_config_descriptor(config);
return r;
}
/** \ingroup libusb_dev
* Calculate the maximum packet size which a specific endpoint is capable is
* sending or receiving in the duration of 1 microframe
*
* Only the active configuration is examined. The calculation is based on the
* wMaxPacketSize field in the endpoint descriptor as described in section
* 9.6.6 in the USB 2.0 specifications.
*
* If acting on an isochronous or interrupt endpoint, this function will
* multiply the value found in bits 0:10 by the number of transactions per
* microframe (determined by bits 11:12). Otherwise, this function just
* returns the numeric value found in bits 0:10.
*
* This function is useful for setting up isochronous transfers, for example
* you might pass the return value from this function to
* libusb_set_iso_packet_lengths() in order to set the length field of every
* isochronous packet in a transfer.
*
* Since v1.0.3.
*
* \param dev a device
* \param endpoint address of the endpoint in question
* \returns the maximum packet size which can be sent/received on this endpoint
* \returns LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
* \returns LIBUSB_ERROR_OTHER on other failure
*/
int API_EXPORTED libusb_get_max_iso_packet_size(libusb_device *dev,
unsigned char endpoint)
{
struct libusb_config_descriptor *config;
const struct libusb_endpoint_descriptor *ep;
enum libusb_transfer_type ep_type;
uint16_t val;
int r;
r = libusb_get_active_config_descriptor(dev, &config);
if (r < 0) {
usbi_err(DEVICE_CTX(dev),
"could not retrieve active config descriptor");
return LIBUSB_ERROR_OTHER;
}
ep = find_endpoint(config, endpoint);
if (!ep) {
r = LIBUSB_ERROR_NOT_FOUND;
goto out;
}
val = ep->wMaxPacketSize;
ep_type = (enum libusb_transfer_type) (ep->bmAttributes & 0x3);
r = val & 0x07ff;
if (ep_type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS
|| ep_type == LIBUSB_TRANSFER_TYPE_INTERRUPT)
r *= (1 + ((val >> 11) & 3));
out:
libusb_free_config_descriptor(config);
return r;
}
/** \ingroup libusb_dev
* Increment the reference count of a device.
* \param dev the device to reference
* \returns the same device
*/
DEFAULT_VISIBILITY
libusb_device * LIBUSB_CALL libusb_ref_device(libusb_device *dev)
{
usbi_mutex_lock(&dev->lock);
dev->refcnt++;
usbi_mutex_unlock(&dev->lock);
return dev;
}
/** \ingroup libusb_dev
* Decrement the reference count of a device. If the decrement operation
* causes the reference count to reach zero, the device shall be destroyed.
* \param dev the device to unreference
*/
void API_EXPORTED libusb_unref_device(libusb_device *dev)
{
int refcnt;
if (!dev)
return;
usbi_mutex_lock(&dev->lock);
refcnt = --dev->refcnt;
usbi_mutex_unlock(&dev->lock);
if (refcnt == 0) {
usbi_dbg("destroy device %d.%d", dev->bus_number, dev->device_address);
libusb_unref_device(dev->parent_dev);
if (usbi_backend->destroy_device)
usbi_backend->destroy_device(dev);
if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
/* backend does not support hotplug */
usbi_disconnect_device(dev);
}
usbi_mutex_destroy(&dev->lock);
free(dev);
}
}
/*
* Signal the event pipe so that the event handling thread will be
* interrupted to process an internal event.
*/
int usbi_signal_event(struct libusb_context *ctx)
{
unsigned char dummy = 1;
ssize_t r;
/* write some data on event pipe to interrupt event handlers */
r = usbi_write(ctx->event_pipe[1], &dummy, sizeof(dummy));
if (r != sizeof(dummy)) {
usbi_warn(ctx, "internal signalling write failed");
return LIBUSB_ERROR_IO;
}
return 0;
}
/*
* Clear the event pipe so that the event handling will no longer be
* interrupted.
*/
int usbi_clear_event(struct libusb_context *ctx)
{
unsigned char dummy;
ssize_t r;
/* read some data on event pipe to clear it */
r = usbi_read(ctx->event_pipe[0], &dummy, sizeof(dummy));
if (r != sizeof(dummy)) {
usbi_warn(ctx, "internal signalling read failed");
return LIBUSB_ERROR_IO;
}
return 0;
}
/** \ingroup libusb_dev
* Open a device and obtain a device handle. A handle allows you to perform
* I/O on the device in question.
*
* Internally, this function adds a reference to the device and makes it
* available to you through libusb_get_device(). This reference is removed
* during libusb_close().
*
* This is a non-blocking function; no requests are sent over the bus.
*
* \param dev the device to open
* \param dev_handle output location for the returned device handle pointer. Only
* populated when the return code is 0.
* \returns 0 on success
* \returns LIBUSB_ERROR_NO_MEM on memory allocation failure
* \returns LIBUSB_ERROR_ACCESS if the user has insufficient permissions
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns another LIBUSB_ERROR code on other failure
*/
int API_EXPORTED libusb_open(libusb_device *dev,
libusb_device_handle **dev_handle)
{
struct libusb_context *ctx = DEVICE_CTX(dev);
struct libusb_device_handle *_dev_handle;
size_t priv_size = usbi_backend->device_handle_priv_size;
int r;
usbi_dbg("open %d.%d", dev->bus_number, dev->device_address);
if (!dev->attached) {
return LIBUSB_ERROR_NO_DEVICE;
}
_dev_handle = malloc(sizeof(*_dev_handle) + priv_size);
if (!_dev_handle)
return LIBUSB_ERROR_NO_MEM;
r = usbi_mutex_init(&_dev_handle->lock);
if (r) {
free(_dev_handle);
return LIBUSB_ERROR_OTHER;
}
_dev_handle->dev = libusb_ref_device(dev);
_dev_handle->auto_detach_kernel_driver = 0;
_dev_handle->claimed_interfaces = 0;
memset(&_dev_handle->os_priv, 0, priv_size);
r = usbi_backend->open(_dev_handle);
if (r < 0) {
usbi_dbg("open %d.%d returns %d", dev->bus_number, dev->device_address, r);
libusb_unref_device(dev);
usbi_mutex_destroy(&_dev_handle->lock);
free(_dev_handle);
return r;
}
usbi_mutex_lock(&ctx->open_devs_lock);
list_add(&_dev_handle->list, &ctx->open_devs);
usbi_mutex_unlock(&ctx->open_devs_lock);
*dev_handle = _dev_handle;
return 0;
}
/** \ingroup libusb_dev
* Convenience function for finding a device with a particular
* <tt>idVendor</tt>/<tt>idProduct</tt> combination. This function is intended
* for those scenarios where you are using libusb to knock up a quick test
* application - it allows you to avoid calling libusb_get_device_list() and
* worrying about traversing/freeing the list.
*
* This function has limitations and is hence not intended for use in real
* applications: if multiple devices have the same IDs it will only
* give you the first one, etc.
*
* \param ctx the context to operate on, or NULL for the default context
* \param vendor_id the idVendor value to search for
* \param product_id the idProduct value to search for
* \returns a device handle for the first found device, or NULL on error
* or if the device could not be found. */
DEFAULT_VISIBILITY
libusb_device_handle * LIBUSB_CALL libusb_open_device_with_vid_pid(
libusb_context *ctx, uint16_t vendor_id, uint16_t product_id)
{
struct libusb_device **devs;
struct libusb_device *found = NULL;
struct libusb_device *dev;
struct libusb_device_handle *dev_handle = NULL;
size_t i = 0;
int r;
if (libusb_get_device_list(ctx, &devs) < 0)
return NULL;
while ((dev = devs[i++]) != NULL) {
struct libusb_device_descriptor desc;
r = libusb_get_device_descriptor(dev, &desc);
if (r < 0)
goto out;
if (desc.idVendor == vendor_id && desc.idProduct == product_id) {
found = dev;
break;
}
}
if (found) {
r = libusb_open(found, &dev_handle);
if (r < 0)
dev_handle = NULL;
}
out:
libusb_free_device_list(devs, 1);
return dev_handle;
}
static void do_close(struct libusb_context *ctx,
struct libusb_device_handle *dev_handle)
{
struct usbi_transfer *itransfer;
struct usbi_transfer *tmp;
/* remove any transfers in flight that are for this device */
usbi_mutex_lock(&ctx->flying_transfers_lock);
/* safe iteration because transfers may be being deleted */
list_for_each_entry_safe(itransfer, tmp, &ctx->flying_transfers, list, struct usbi_transfer) {
struct libusb_transfer *transfer =
USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
if (transfer->dev_handle != dev_handle)
continue;
usbi_mutex_lock(&itransfer->lock);
if (!(itransfer->state_flags & USBI_TRANSFER_DEVICE_DISAPPEARED)) {
usbi_err(ctx, "Device handle closed while transfer was still being processed, but the device is still connected as far as we know");
if (itransfer->state_flags & USBI_TRANSFER_CANCELLING)
usbi_warn(ctx, "A cancellation for an in-flight transfer hasn't completed but closing the device handle");
else
usbi_err(ctx, "A cancellation hasn't even been scheduled on the transfer for which the device is closing");
}
usbi_mutex_unlock(&itransfer->lock);
/* remove from the list of in-flight transfers and make sure
* we don't accidentally use the device handle in the future
* (or that such accesses will be easily caught and identified as a crash)
*/
list_del(&itransfer->list);
transfer->dev_handle = NULL;
/* it is up to the user to free up the actual transfer struct. this is
* just making sure that we don't attempt to process the transfer after
* the device handle is invalid
*/
usbi_dbg("Removed transfer %p from the in-flight list because device handle %p closed",
transfer, dev_handle);
}
usbi_mutex_unlock(&ctx->flying_transfers_lock);
usbi_mutex_lock(&ctx->open_devs_lock);
list_del(&dev_handle->list);
usbi_mutex_unlock(&ctx->open_devs_lock);
usbi_backend->close(dev_handle);
libusb_unref_device(dev_handle->dev);
usbi_mutex_destroy(&dev_handle->lock);
free(dev_handle);
}
/** \ingroup libusb_dev
* Close a device handle. Should be called on all open handles before your
* application exits.
*
* Internally, this function destroys the reference that was added by
* libusb_open() on the given device.
*
* This is a non-blocking function; no requests are sent over the bus.
*
* \param dev_handle the device handle to close
*/
void API_EXPORTED libusb_close(libusb_device_handle *dev_handle)
{
struct libusb_context *ctx;
int handling_events;
int pending_events;
if (!dev_handle)
return;
usbi_dbg("");
ctx = HANDLE_CTX(dev_handle);
handling_events = usbi_handling_events(ctx);
/* Similarly to libusb_open(), we want to interrupt all event handlers
* at this point. More importantly, we want to perform the actual close of
* the device while holding the event handling lock (preventing any other
* thread from doing event handling) because we will be removing a file
* descriptor from the polling loop. If this is being called by the current
* event handler, we can bypass the interruption code because we already
* hold the event handling lock. */
if (!handling_events) {
/* Record that we are closing a device.
* Only signal an event if there are no prior pending events. */
usbi_mutex_lock(&ctx->event_data_lock);
pending_events = usbi_pending_events(ctx);
ctx->device_close++;
if (!pending_events)
usbi_signal_event(ctx);
usbi_mutex_unlock(&ctx->event_data_lock);
/* take event handling lock */
libusb_lock_events(ctx);
}
/* Close the device */
do_close(ctx, dev_handle);
if (!handling_events) {
/* We're done with closing this device.
* Clear the event pipe if there are no further pending events. */
usbi_mutex_lock(&ctx->event_data_lock);
ctx->device_close--;
pending_events = usbi_pending_events(ctx);
if (!pending_events)
usbi_clear_event(ctx);
usbi_mutex_unlock(&ctx->event_data_lock);
/* Release event handling lock and wake up event waiters */
libusb_unlock_events(ctx);
}
}
/** \ingroup libusb_dev
* Get the underlying device for a device handle. This function does not modify
* the reference count of the returned device, so do not feel compelled to
* unreference it when you are done.
* \param dev_handle a device handle
* \returns the underlying device
*/
DEFAULT_VISIBILITY
libusb_device * LIBUSB_CALL libusb_get_device(libusb_device_handle *dev_handle)
{
return dev_handle->dev;
}
/** \ingroup libusb_dev
* Determine the bConfigurationValue of the currently active configuration.
*
* You could formulate your own control request to obtain this information,
* but this function has the advantage that it may be able to retrieve the
* information from operating system caches (no I/O involved).
*
* If the OS does not cache this information, then this function will block
* while a control transfer is submitted to retrieve the information.
*
* This function will return a value of 0 in the <tt>config</tt> output
* parameter if the device is in unconfigured state.
*
* \param dev_handle a device handle
* \param config output location for the bConfigurationValue of the active
* configuration (only valid for return code 0)
* \returns 0 on success
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns another LIBUSB_ERROR code on other failure
*/
int API_EXPORTED libusb_get_configuration(libusb_device_handle *dev_handle,
int *config)
{
int r = LIBUSB_ERROR_NOT_SUPPORTED;
usbi_dbg("");
if (usbi_backend->get_configuration)
r = usbi_backend->get_configuration(dev_handle, config);
if (r == LIBUSB_ERROR_NOT_SUPPORTED) {
uint8_t tmp = 0;
usbi_dbg("falling back to control message");
r = libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN,
LIBUSB_REQUEST_GET_CONFIGURATION, 0, 0, &tmp, 1, 1000);
if (r == 0) {
usbi_err(HANDLE_CTX(dev_handle), "zero bytes returned in ctrl transfer?");
r = LIBUSB_ERROR_IO;
} else if (r == 1) {
r = 0;
*config = tmp;
} else {
usbi_dbg("control failed, error %d", r);
}
}
if (r == 0)
usbi_dbg("active config %d", *config);
return r;
}
/** \ingroup libusb_dev
* Set the active configuration for a device.
*
* The operating system may or may not have already set an active
* configuration on the device. It is up to your application to ensure the
* correct configuration is selected before you attempt to claim interfaces
* and perform other operations.
*
* If you call this function on a device already configured with the selected
* configuration, then this function will act as a lightweight device reset:
* it will issue a SET_CONFIGURATION request using the current configuration,
* causing most USB-related device state to be reset (altsetting reset to zero,
* endpoint halts cleared, toggles reset).
*
* You cannot change/reset configuration if your application has claimed
* interfaces. It is advised to set the desired configuration before claiming
* interfaces.
*
* Alternatively you can call libusb_release_interface() first. Note if you
* do things this way you must ensure that auto_detach_kernel_driver for
* <tt>dev</tt> is 0, otherwise the kernel driver will be re-attached when you
* release the interface(s).
*
* You cannot change/reset configuration if other applications or drivers have
* claimed interfaces.
*
* A configuration value of -1 will put the device in unconfigured state.
* The USB specifications state that a configuration value of 0 does this,
* however buggy devices exist which actually have a configuration 0.
*
* You should always use this function rather than formulating your own
* SET_CONFIGURATION control request. This is because the underlying operating
* system needs to know when such changes happen.
*
* This is a blocking function.
*
* \param dev_handle a device handle
* \param configuration the bConfigurationValue of the configuration you
* wish to activate, or -1 if you wish to put the device in an unconfigured
* state
* \returns 0 on success
* \returns LIBUSB_ERROR_NOT_FOUND if the requested configuration does not exist
* \returns LIBUSB_ERROR_BUSY if interfaces are currently claimed
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns another LIBUSB_ERROR code on other failure
* \see libusb_set_auto_detach_kernel_driver()
*/
int API_EXPORTED libusb_set_configuration(libusb_device_handle *dev_handle,
int configuration)
{
usbi_dbg("configuration %d", configuration);
return usbi_backend->set_configuration(dev_handle, configuration);
}
/** \ingroup libusb_dev
* Claim an interface on a given device handle. You must claim the interface
* you wish to use before you can perform I/O on any of its endpoints.
*
* It is legal to attempt to claim an already-claimed interface, in which
* case libusb just returns 0 without doing anything.
*
* If auto_detach_kernel_driver is set to 1 for <tt>dev</tt>, the kernel driver
* will be detached if necessary, on failure the detach error is returned.
*
* Claiming of interfaces is a purely logical operation; it does not cause
* any requests to be sent over the bus. Interface claiming is used to
* instruct the underlying operating system that your application wishes
* to take ownership of the interface.
*
* This is a non-blocking function.
*
* \param dev_handle a device handle
* \param interface_number the <tt>bInterfaceNumber</tt> of the interface you
* wish to claim
* \returns 0 on success
* \returns LIBUSB_ERROR_NOT_FOUND if the requested interface does not exist
* \returns LIBUSB_ERROR_BUSY if another program or driver has claimed the
* interface
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns a LIBUSB_ERROR code on other failure
* \see libusb_set_auto_detach_kernel_driver()
*/
int API_EXPORTED libusb_claim_interface(libusb_device_handle *dev_handle,
int interface_number)
{
int r = 0;
usbi_dbg("interface %d", interface_number);
if (interface_number >= USB_MAXINTERFACES)
return LIBUSB_ERROR_INVALID_PARAM;
if (!dev_handle->dev->attached)
return LIBUSB_ERROR_NO_DEVICE;
usbi_mutex_lock(&dev_handle->lock);
if (dev_handle->claimed_interfaces & (1 << interface_number))
goto out;
r = usbi_backend->claim_interface(dev_handle, interface_number);
if (r == 0)
dev_handle->claimed_interfaces |= 1 << interface_number;
out:
usbi_mutex_unlock(&dev_handle->lock);
return r;
}
/** \ingroup libusb_dev
* Release an interface previously claimed with libusb_claim_interface(). You
* should release all claimed interfaces before closing a device handle.
*
* This is a blocking function. A SET_INTERFACE control request will be sent
* to the device, resetting interface state to the first alternate setting.
*
* If auto_detach_kernel_driver is set to 1 for <tt>dev</tt>, the kernel
* driver will be re-attached after releasing the interface.
*
* \param dev_handle a device handle
* \param interface_number the <tt>bInterfaceNumber</tt> of the
* previously-claimed interface
* \returns 0 on success
* \returns LIBUSB_ERROR_NOT_FOUND if the interface was not claimed
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns another LIBUSB_ERROR code on other failure
* \see libusb_set_auto_detach_kernel_driver()
*/
int API_EXPORTED libusb_release_interface(libusb_device_handle *dev_handle,
int interface_number)
{
int r;
usbi_dbg("interface %d", interface_number);
if (interface_number >= USB_MAXINTERFACES)
return LIBUSB_ERROR_INVALID_PARAM;
usbi_mutex_lock(&dev_handle->lock);
if (!(dev_handle->claimed_interfaces & (1 << interface_number))) {
r = LIBUSB_ERROR_NOT_FOUND;
goto out;
}
r = usbi_backend->release_interface(dev_handle, interface_number);
if (r == 0)
dev_handle->claimed_interfaces &= ~(1 << interface_number);
out:
usbi_mutex_unlock(&dev_handle->lock);
return r;
}
/** \ingroup libusb_dev
* Activate an alternate setting for an interface. The interface must have
* been previously claimed with libusb_claim_interface().
*
* You should always use this function rather than formulating your own
* SET_INTERFACE control request. This is because the underlying operating
* system needs to know when such changes happen.
*
* This is a blocking function.
*
* \param dev_handle a device handle
* \param interface_number the <tt>bInterfaceNumber</tt> of the
* previously-claimed interface
* \param alternate_setting the <tt>bAlternateSetting</tt> of the alternate
* setting to activate
* \returns 0 on success
* \returns LIBUSB_ERROR_NOT_FOUND if the interface was not claimed, or the
* requested alternate setting does not exist
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns another LIBUSB_ERROR code on other failure
*/
int API_EXPORTED libusb_set_interface_alt_setting(libusb_device_handle *dev_handle,
int interface_number, int alternate_setting)
{
usbi_dbg("interface %d altsetting %d",
interface_number, alternate_setting);
if (interface_number >= USB_MAXINTERFACES)
return LIBUSB_ERROR_INVALID_PARAM;
usbi_mutex_lock(&dev_handle->lock);
if (!dev_handle->dev->attached) {
usbi_mutex_unlock(&dev_handle->lock);
return LIBUSB_ERROR_NO_DEVICE;
}
if (!(dev_handle->claimed_interfaces & (1 << interface_number))) {
usbi_mutex_unlock(&dev_handle->lock);
return LIBUSB_ERROR_NOT_FOUND;
}
usbi_mutex_unlock(&dev_handle->lock);
return usbi_backend->set_interface_altsetting(dev_handle, interface_number,
alternate_setting);
}
/** \ingroup libusb_dev
* Clear the halt/stall condition for an endpoint. Endpoints with halt status
* are unable to receive or transmit data until the halt condition is stalled.
*
* You should cancel all pending transfers before attempting to clear the halt
* condition.
*
* This is a blocking function.
*
* \param dev_handle a device handle
* \param endpoint the endpoint to clear halt status
* \returns 0 on success
* \returns LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns another LIBUSB_ERROR code on other failure
*/
int API_EXPORTED libusb_clear_halt(libusb_device_handle *dev_handle,
unsigned char endpoint)
{
usbi_dbg("endpoint %x", endpoint);
if (!dev_handle->dev->attached)
return LIBUSB_ERROR_NO_DEVICE;
return usbi_backend->clear_halt(dev_handle, endpoint);
}
/** \ingroup libusb_dev
* Perform a USB port reset to reinitialize a device. The system will attempt
* to restore the previous configuration and alternate settings after the
* reset has completed.
*
* If the reset fails, the descriptors change, or the previous state cannot be
* restored, the device will appear to be disconnected and reconnected. This
* means that the device handle is no longer valid (you should close it) and
* rediscover the device. A return code of LIBUSB_ERROR_NOT_FOUND indicates
* when this is the case.
*
* This is a blocking function which usually incurs a noticeable delay.
*
* \param dev_handle a handle of the device to reset
* \returns 0 on success
* \returns LIBUSB_ERROR_NOT_FOUND if re-enumeration is required, or if the
* device has been disconnected
* \returns another LIBUSB_ERROR code on other failure
*/
int API_EXPORTED libusb_reset_device(libusb_device_handle *dev_handle)
{
usbi_dbg("");
if (!dev_handle->dev->attached)
return LIBUSB_ERROR_NO_DEVICE;
return usbi_backend->reset_device(dev_handle);
}
/** \ingroup libusb_asyncio
* Allocate up to num_streams usb bulk streams on the specified endpoints. This
* function takes an array of endpoints rather then a single endpoint because
* some protocols require that endpoints are setup with similar stream ids.
* All endpoints passed in must belong to the same interface.
*
* Note this function may return less streams then requested. Also note that the
* same number of streams are allocated for each endpoint in the endpoint array.
*
* Stream id 0 is reserved, and should not be used to communicate with devices.
* If libusb_alloc_streams() returns with a value of N, you may use stream ids
* 1 to N.
*
* Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
*
* \param dev_handle a device handle
* \param num_streams number of streams to try to allocate
* \param endpoints array of endpoints to allocate streams on
* \param num_endpoints length of the endpoints array
* \returns number of streams allocated, or a LIBUSB_ERROR code on failure
*/
int API_EXPORTED libusb_alloc_streams(libusb_device_handle *dev_handle,
uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
{
usbi_dbg("streams %u eps %d", (unsigned) num_streams, num_endpoints);
if (!dev_handle->dev->attached)
return LIBUSB_ERROR_NO_DEVICE;
if (usbi_backend->alloc_streams)
return usbi_backend->alloc_streams(dev_handle, num_streams, endpoints,
num_endpoints);
else
return LIBUSB_ERROR_NOT_SUPPORTED;
}
/** \ingroup libusb_asyncio
* Free usb bulk streams allocated with libusb_alloc_streams().
*
* Note streams are automatically free-ed when releasing an interface.
*
* Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
*
* \param dev_handle a device handle
* \param endpoints array of endpoints to free streams on
* \param num_endpoints length of the endpoints array
* \returns LIBUSB_SUCCESS, or a LIBUSB_ERROR code on failure
*/
int API_EXPORTED libusb_free_streams(libusb_device_handle *dev_handle,
unsigned char *endpoints, int num_endpoints)
{
usbi_dbg("eps %d", num_endpoints);
if (!dev_handle->dev->attached)
return LIBUSB_ERROR_NO_DEVICE;
if (usbi_backend->free_streams)
return usbi_backend->free_streams(dev_handle, endpoints,
num_endpoints);
else
return LIBUSB_ERROR_NOT_SUPPORTED;
}
/** \ingroup libusb_asyncio
* Attempts to allocate a block of persistent DMA memory suitable for transfers
* against the given device. If successful, will return a block of memory
* that is suitable for use as "buffer" in \ref libusb_transfer against this
* device. Using this memory instead of regular memory means that the host
* controller can use DMA directly into the buffer to increase performance, and
* also that transfers can no longer fail due to kernel memory fragmentation.
*
* Note that this means you should not modify this memory (or even data on
* the same cache lines) when a transfer is in progress, although it is legal
* to have several transfers going on within the same memory block.
*
* Will return NULL on failure. Many systems do not support such zerocopy
* and will always return NULL. Memory allocated with this function must be
* freed with \ref libusb_dev_mem_free. Specifically, this means that the
* flag \ref LIBUSB_TRANSFER_FREE_BUFFER cannot be used to free memory allocated
* with this function.
*
* Since version 1.0.21, \ref LIBUSB_API_VERSION >= 0x01000105
*
* \param dev_handle a device handle
* \param length size of desired data buffer
* \returns a pointer to the newly allocated memory, or NULL on failure
*/
DEFAULT_VISIBILITY
unsigned char * LIBUSB_CALL libusb_dev_mem_alloc(libusb_device_handle *dev_handle,
size_t length)
{
if (!dev_handle->dev->attached)
return NULL;
if (usbi_backend->dev_mem_alloc)
return usbi_backend->dev_mem_alloc(dev_handle, length);
else
return NULL;
}
/** \ingroup libusb_asyncio
* Free device memory allocated with libusb_dev_mem_alloc().
*
* \param dev_handle a device handle
* \param buffer pointer to the previously allocated memory
* \param length size of previously allocated memory
* \returns LIBUSB_SUCCESS, or a LIBUSB_ERROR code on failure
*/
int API_EXPORTED libusb_dev_mem_free(libusb_device_handle *dev_handle,
unsigned char *buffer, size_t length)
{
if (usbi_backend->dev_mem_free)
return usbi_backend->dev_mem_free(dev_handle, buffer, length);
else
return LIBUSB_ERROR_NOT_SUPPORTED;
}
/** \ingroup libusb_dev
* Determine if a kernel driver is active on an interface. If a kernel driver
* is active, you cannot claim the interface, and libusb will be unable to
* perform I/O.
*
* This functionality is not available on Windows.
*
* \param dev_handle a device handle
* \param interface_number the interface to check
* \returns 0 if no kernel driver is active
* \returns 1 if a kernel driver is active
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
* is not available
* \returns another LIBUSB_ERROR code on other failure
* \see libusb_detach_kernel_driver()
*/
int API_EXPORTED libusb_kernel_driver_active(libusb_device_handle *dev_handle,
int interface_number)
{
usbi_dbg("interface %d", interface_number);
if (!dev_handle->dev->attached)
return LIBUSB_ERROR_NO_DEVICE;
if (usbi_backend->kernel_driver_active)
return usbi_backend->kernel_driver_active(dev_handle, interface_number);
else
return LIBUSB_ERROR_NOT_SUPPORTED;
}
/** \ingroup libusb_dev
* Detach a kernel driver from an interface. If successful, you will then be
* able to claim the interface and perform I/O.
*
* This functionality is not available on Darwin or Windows.
*
* Note that libusb itself also talks to the device through a special kernel
* driver, if this driver is already attached to the device, this call will
* not detach it and return LIBUSB_ERROR_NOT_FOUND.
*
* \param dev_handle a device handle
* \param interface_number the interface to detach the driver from
* \returns 0 on success
* \returns LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
* \returns LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
* is not available
* \returns another LIBUSB_ERROR code on other failure
* \see libusb_kernel_driver_active()
*/
int API_EXPORTED libusb_detach_kernel_driver(libusb_device_handle *dev_handle,
int interface_number)
{
usbi_dbg("interface %d", interface_number);
if (!dev_handle->dev->attached)
return LIBUSB_ERROR_NO_DEVICE;
if (usbi_backend->detach_kernel_driver)
return usbi_backend->detach_kernel_driver(dev_handle, interface_number);
else
return LIBUSB_ERROR_NOT_SUPPORTED;
}
/** \ingroup libusb_dev
* Re-attach an interface's kernel driver, which was previously detached
* using libusb_detach_kernel_driver(). This call is only effective on
* Linux and returns LIBUSB_ERROR_NOT_SUPPORTED on all other platforms.
*
* This functionality is not available on Darwin or Windows.
*
* \param dev_handle a device handle
* \param interface_number the interface to attach the driver from
* \returns 0 on success
* \returns LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
* \returns LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
* \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
* \returns LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
* is not available
* \returns LIBUSB_ERROR_BUSY if the driver cannot be attached because the
* interface is claimed by a program or driver
* \returns another LIBUSB_ERROR code on other failure
* \see libusb_kernel_driver_active()
*/
int API_EXPORTED libusb_attach_kernel_driver(libusb_device_handle *dev_handle,
int interface_number)
{
usbi_dbg("interface %d", interface_number);
if (!dev_handle->dev->attached)
return LIBUSB_ERROR_NO_DEVICE;
if (usbi_backend->attach_kernel_driver)
return usbi_backend->attach_kernel_driver(dev_handle, interface_number);
else
return LIBUSB_ERROR_NOT_SUPPORTED;
}
/** \ingroup libusb_dev
* Enable/disable libusb's automatic kernel driver detachment. When this is
* enabled libusb will automatically detach the kernel driver on an interface
* when claiming the interface, and attach it when releasing the interface.
*
* Automatic kernel driver detachment is disabled on newly opened device
* handles by default.
*
* On platforms which do not have LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER
* this function will return LIBUSB_ERROR_NOT_SUPPORTED, and libusb will
* continue as if this function was never called.
*
* \param dev_handle a device handle
* \param enable whether to enable or disable auto kernel driver detachment
*
* \returns LIBUSB_SUCCESS on success
* \returns LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
* is not available
* \see libusb_claim_interface()
* \see libusb_release_interface()
* \see libusb_set_configuration()
*/
int API_EXPORTED libusb_set_auto_detach_kernel_driver(
libusb_device_handle *dev_handle, int enable)
{
if (!(usbi_backend->caps & USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER))
return LIBUSB_ERROR_NOT_SUPPORTED;
dev_handle->auto_detach_kernel_driver = enable;
return LIBUSB_SUCCESS;
}
/** \ingroup libusb_lib
* Set log message verbosity.
*
* The default level is LIBUSB_LOG_LEVEL_NONE, which means no messages are ever
* printed. If you choose to increase the message verbosity level, ensure
* that your application does not close the stdout/stderr file descriptors.
*
* You are advised to use level LIBUSB_LOG_LEVEL_WARNING. libusb is conservative
* with its message logging and most of the time, will only log messages that
* explain error conditions and other oddities. This will help you debug
* your software.
*
* If the LIBUSB_DEBUG environment variable was set when libusb was
* initialized, this function does nothing: the message verbosity is fixed
* to the value in the environment variable.
*
* If libusb was compiled without any message logging, this function does
* nothing: you'll never get any messages.
*
* If libusb was compiled with verbose debug message logging, this function
* does nothing: you'll always get messages from all levels.
*
* \param ctx the context to operate on, or NULL for the default context
* \param level debug level to set
*/
void API_EXPORTED libusb_set_debug(libusb_context *ctx, int level)
{
USBI_GET_CONTEXT(ctx);
if (!ctx->debug_fixed)
ctx->debug = level;
}
/** \ingroup libusb_lib
* Initialize libusb. This function must be called before calling any other
* libusb function.
*
* If you do not provide an output location for a context pointer, a default
* context will be created. If there was already a default context, it will
* be reused (and nothing will be initialized/reinitialized).
*
* \param context Optional output location for context pointer.
* Only valid on return code 0.
* \returns 0 on success, or a LIBUSB_ERROR code on failure
* \see libusb_contexts
*/
int API_EXPORTED libusb_init(libusb_context **context)
{
struct libusb_device *dev, *next;
char *dbg = getenv("LIBUSB_DEBUG");
struct libusb_context *ctx;
static int first_init = 1;
int r = 0;
usbi_mutex_static_lock(&default_context_lock);
if (!timestamp_origin.tv_sec) {
usbi_backend->clock_gettime(USBI_CLOCK_REALTIME, ×tamp_origin);
}
if (!context && usbi_default_context) {
usbi_dbg("reusing default context");
default_context_refcnt++;
usbi_mutex_static_unlock(&default_context_lock);
return 0;
}
ctx = calloc(1, sizeof(*ctx));
if (!ctx) {
r = LIBUSB_ERROR_NO_MEM;
goto err_unlock;
}
#ifdef ENABLE_DEBUG_LOGGING
ctx->debug = LIBUSB_LOG_LEVEL_DEBUG;
#endif
if (dbg) {
ctx->debug = atoi(dbg);
if (ctx->debug)
ctx->debug_fixed = 1;
}
/* default context should be initialized before calling usbi_dbg */
if (!usbi_default_context) {
usbi_default_context = ctx;
default_context_refcnt++;
usbi_dbg("created default context");
}
usbi_dbg("libusb v%u.%u.%u.%u%s", libusb_version_internal.major, libusb_version_internal.minor,
libusb_version_internal.micro, libusb_version_internal.nano, libusb_version_internal.rc);
usbi_mutex_init(&ctx->usb_devs_lock);
usbi_mutex_init(&ctx->open_devs_lock);
usbi_mutex_init(&ctx->hotplug_cbs_lock);
list_init(&ctx->usb_devs);
list_init(&ctx->open_devs);
list_init(&ctx->hotplug_cbs);
usbi_mutex_static_lock(&active_contexts_lock);
if (first_init) {
first_init = 0;
list_init (&active_contexts_list);
}
list_add (&ctx->list, &active_contexts_list);
usbi_mutex_static_unlock(&active_contexts_lock);
if (usbi_backend->init) {
r = usbi_backend->init(ctx);
if (r)
goto err_free_ctx;
}
r = usbi_io_init(ctx);
if (r < 0)
goto err_backend_exit;
usbi_mutex_static_unlock(&default_context_lock);
if (context)
*context = ctx;
return 0;
err_backend_exit:
if (usbi_backend->exit)
usbi_backend->exit();
err_free_ctx:
if (ctx == usbi_default_context) {
usbi_default_context = NULL;
default_context_refcnt--;
}
usbi_mutex_static_lock(&active_contexts_lock);
list_del (&ctx->list);
usbi_mutex_static_unlock(&active_contexts_lock);
usbi_mutex_lock(&ctx->usb_devs_lock);
list_for_each_entry_safe(dev, next, &ctx->usb_devs, list, struct libusb_device) {
list_del(&dev->list);
libusb_unref_device(dev);
}
usbi_mutex_unlock(&ctx->usb_devs_lock);
usbi_mutex_destroy(&ctx->open_devs_lock);
usbi_mutex_destroy(&ctx->usb_devs_lock);
usbi_mutex_destroy(&ctx->hotplug_cbs_lock);
free(ctx);
err_unlock:
usbi_mutex_static_unlock(&default_context_lock);
return r;
}
/** \ingroup libusb_lib
* Deinitialize libusb. Should be called after closing all open devices and
* before your application terminates.
* \param ctx the context to deinitialize, or NULL for the default context
*/
void API_EXPORTED libusb_exit(struct libusb_context *ctx)
{
struct libusb_device *dev, *next;
struct timeval tv = { 0, 0 };
usbi_dbg("");
USBI_GET_CONTEXT(ctx);
/* if working with default context, only actually do the deinitialization
* if we're the last user */
usbi_mutex_static_lock(&default_context_lock);
if (ctx == usbi_default_context) {
if (--default_context_refcnt > 0) {
usbi_dbg("not destroying default context");
usbi_mutex_static_unlock(&default_context_lock);
return;
}
usbi_dbg("destroying default context");
usbi_default_context = NULL;
}
usbi_mutex_static_unlock(&default_context_lock);
usbi_mutex_static_lock(&active_contexts_lock);
list_del (&ctx->list);
usbi_mutex_static_unlock(&active_contexts_lock);
if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
usbi_hotplug_deregister_all(ctx);
/*
* Ensure any pending unplug events are read from the hotplug
* pipe. The usb_device-s hold in the events are no longer part
* of usb_devs, but the events still hold a reference!
*
* Note we don't do this if the application has left devices
* open (which implies a buggy app) to avoid packet completion
* handlers running when the app does not expect them to run.
*/
if (list_empty(&ctx->open_devs))
libusb_handle_events_timeout(ctx, &tv);
usbi_mutex_lock(&ctx->usb_devs_lock);
list_for_each_entry_safe(dev, next, &ctx->usb_devs, list, struct libusb_device) {
list_del(&dev->list);
libusb_unref_device(dev);
}
usbi_mutex_unlock(&ctx->usb_devs_lock);
}
/* a few sanity checks. don't bother with locking because unless
* there is an application bug, nobody will be accessing these. */
if (!list_empty(&ctx->usb_devs))
usbi_warn(ctx, "some libusb_devices were leaked");
if (!list_empty(&ctx->open_devs))
usbi_warn(ctx, "application left some devices open");
usbi_io_exit(ctx);
if (usbi_backend->exit)
usbi_backend->exit();
usbi_mutex_destroy(&ctx->open_devs_lock);
usbi_mutex_destroy(&ctx->usb_devs_lock);
usbi_mutex_destroy(&ctx->hotplug_cbs_lock);
free(ctx);
}
/** \ingroup libusb_misc
* Check at runtime if the loaded library has a given capability.
* This call should be performed after \ref libusb_init(), to ensure the
* backend has updated its capability set.
*
* \param capability the \ref libusb_capability to check for
* \returns nonzero if the running library has the capability, 0 otherwise
*/
int API_EXPORTED libusb_has_capability(uint32_t capability)
{
switch (capability) {
case LIBUSB_CAP_HAS_CAPABILITY:
return 1;
case LIBUSB_CAP_HAS_HOTPLUG:
return !(usbi_backend->get_device_list);
case LIBUSB_CAP_HAS_HID_ACCESS:
return (usbi_backend->caps & USBI_CAP_HAS_HID_ACCESS);
case LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER:
return (usbi_backend->caps & USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER);
}
return 0;
}
/* this is defined in libusbi.h if needed */
#ifdef LIBUSB_PRINTF_WIN32
/*
* Prior to VS2015, Microsoft did not provide the snprintf() function and
* provided a vsnprintf() that did not guarantee NULL-terminated output.
* Microsoft did provide a _snprintf() function, but again it did not
* guarantee NULL-terminated output.
*
* The below implementations guarantee NULL-terminated output and are
* C99 compliant.
*/
int usbi_snprintf(char *str, size_t size, const char *format, ...)
{
va_list ap;
int ret;
va_start(ap, format);
ret = usbi_vsnprintf(str, size, format, ap);
va_end(ap);
return ret;
}
int usbi_vsnprintf(char *str, size_t size, const char *format, va_list ap)
{
int ret;
ret = _vsnprintf(str, size, format, ap);
if (ret < 0 || ret == (int)size) {
/* Output is truncated, ensure buffer is NULL-terminated and
* determine how many characters would have been written. */
str[size - 1] = '\0';
if (ret < 0)
ret = _vsnprintf(NULL, 0, format, ap);
}
return ret;
}
#endif
static void usbi_log_str(struct libusb_context *ctx,
enum libusb_log_level level, const char * str)
{
#if defined(USE_SYSTEM_LOGGING_FACILITY)
#if defined(OS_WINDOWS)
OutputDebugString(str);
#elif defined(OS_WINCE)
/* Windows CE only supports the Unicode version of OutputDebugString. */
WCHAR wbuf[USBI_MAX_LOG_LEN];
MultiByteToWideChar(CP_UTF8, 0, str, -1, wbuf, sizeof(wbuf));
OutputDebugStringW(wbuf);
#elif defined(__ANDROID__)
int priority = ANDROID_LOG_UNKNOWN;
switch (level) {
case LIBUSB_LOG_LEVEL_INFO: priority = ANDROID_LOG_INFO; break;
case LIBUSB_LOG_LEVEL_WARNING: priority = ANDROID_LOG_WARN; break;
case LIBUSB_LOG_LEVEL_ERROR: priority = ANDROID_LOG_ERROR; break;
case LIBUSB_LOG_LEVEL_DEBUG: priority = ANDROID_LOG_DEBUG; break;
}
__android_log_write(priority, "libusb", str);
#elif defined(HAVE_SYSLOG_FUNC)
int syslog_level = LOG_INFO;
switch (level) {
case LIBUSB_LOG_LEVEL_INFO: syslog_level = LOG_INFO; break;
case LIBUSB_LOG_LEVEL_WARNING: syslog_level = LOG_WARNING; break;
case LIBUSB_LOG_LEVEL_ERROR: syslog_level = LOG_ERR; break;
case LIBUSB_LOG_LEVEL_DEBUG: syslog_level = LOG_DEBUG; break;
}
syslog(syslog_level, "%s", str);
#else /* All of gcc, Clang, XCode seem to use #warning */
#warning System logging is not supported on this platform. Logging to stderr will be used instead.
fputs(str, stderr);
#endif
#else
fputs(str, stderr);
#endif /* USE_SYSTEM_LOGGING_FACILITY */
UNUSED(ctx);
UNUSED(level);
}
void usbi_log_v(struct libusb_context *ctx, enum libusb_log_level level,
const char *function, const char *format, va_list args)
{
const char *prefix = "";
char buf[USBI_MAX_LOG_LEN];
struct timespec now;
int global_debug, header_len, text_len;
static int has_debug_header_been_displayed = 0;
#ifdef ENABLE_DEBUG_LOGGING
global_debug = 1;
UNUSED(ctx);
#else
int ctx_level = 0;
USBI_GET_CONTEXT(ctx);
if (ctx) {
ctx_level = ctx->debug;
} else {
char *dbg = getenv("LIBUSB_DEBUG");
if (dbg)
ctx_level = atoi(dbg);
}
global_debug = (ctx_level == LIBUSB_LOG_LEVEL_DEBUG);
if (!ctx_level)
return;
if (level == LIBUSB_LOG_LEVEL_WARNING && ctx_level < LIBUSB_LOG_LEVEL_WARNING)
return;
if (level == LIBUSB_LOG_LEVEL_INFO && ctx_level < LIBUSB_LOG_LEVEL_INFO)
return;
if (level == LIBUSB_LOG_LEVEL_DEBUG && ctx_level < LIBUSB_LOG_LEVEL_DEBUG)
return;
#endif
usbi_backend->clock_gettime(USBI_CLOCK_REALTIME, &now);
if ((global_debug) && (!has_debug_header_been_displayed)) {
has_debug_header_been_displayed = 1;
usbi_log_str(ctx, LIBUSB_LOG_LEVEL_DEBUG, "[timestamp] [threadID] facility level [function call] <message>" USBI_LOG_LINE_END);
usbi_log_str(ctx, LIBUSB_LOG_LEVEL_DEBUG, "--------------------------------------------------------------------------------" USBI_LOG_LINE_END);
}
if (now.tv_nsec < timestamp_origin.tv_nsec) {
now.tv_sec--;
now.tv_nsec += 1000000000L;
}
now.tv_sec -= timestamp_origin.tv_sec;
now.tv_nsec -= timestamp_origin.tv_nsec;
switch (level) {
case LIBUSB_LOG_LEVEL_INFO:
prefix = "info";
break;
case LIBUSB_LOG_LEVEL_WARNING:
prefix = "warning";
break;
case LIBUSB_LOG_LEVEL_ERROR:
prefix = "error";
break;
case LIBUSB_LOG_LEVEL_DEBUG:
prefix = "debug";
break;
case LIBUSB_LOG_LEVEL_NONE:
return;
default:
prefix = "unknown";
break;
}
if (global_debug) {
header_len = snprintf(buf, sizeof(buf),
"[%2d.%06d] [%08x] libusb: %s [%s] ",
(int)now.tv_sec, (int)(now.tv_nsec / 1000L), usbi_get_tid(), prefix, function);
} else {
header_len = snprintf(buf, sizeof(buf),
"libusb: %s [%s] ", prefix, function);
}
if (header_len < 0 || header_len >= (int)sizeof(buf)) {
/* Somehow snprintf failed to write to the buffer,
* remove the header so something useful is output. */
header_len = 0;
}
/* Make sure buffer is NUL terminated */
buf[header_len] = '\0';
text_len = vsnprintf(buf + header_len, sizeof(buf) - header_len,
format, args);
if (text_len < 0 || text_len + header_len >= (int)sizeof(buf)) {
/* Truncated log output. On some platforms a -1 return value means
* that the output was truncated. */
text_len = sizeof(buf) - header_len;
}
if (header_len + text_len + sizeof(USBI_LOG_LINE_END) >= sizeof(buf)) {
/* Need to truncate the text slightly to fit on the terminator. */
text_len -= (header_len + text_len + sizeof(USBI_LOG_LINE_END)) - sizeof(buf);
}
strcpy(buf + header_len + text_len, USBI_LOG_LINE_END);
usbi_log_str(ctx, level, buf);
}
void usbi_log(struct libusb_context *ctx, enum libusb_log_level level,
const char *function, const char *format, ...)
{
va_list args;
va_start (args, format);
usbi_log_v(ctx, level, function, format, args);
va_end (args);
}
/** \ingroup libusb_misc
* Returns a constant NULL-terminated string with the ASCII name of a libusb
* error or transfer status code. The caller must not free() the returned
* string.
*
* \param error_code The \ref libusb_error or libusb_transfer_status code to
* return the name of.
* \returns The error name, or the string **UNKNOWN** if the value of
* error_code is not a known error / status code.
*/
DEFAULT_VISIBILITY const char * LIBUSB_CALL libusb_error_name(int error_code)
{
switch (error_code) {
case LIBUSB_ERROR_IO:
return "LIBUSB_ERROR_IO";
case LIBUSB_ERROR_INVALID_PARAM:
return "LIBUSB_ERROR_INVALID_PARAM";
case LIBUSB_ERROR_ACCESS:
return "LIBUSB_ERROR_ACCESS";
case LIBUSB_ERROR_NO_DEVICE:
return "LIBUSB_ERROR_NO_DEVICE";
case LIBUSB_ERROR_NOT_FOUND:
return "LIBUSB_ERROR_NOT_FOUND";
case LIBUSB_ERROR_BUSY:
return "LIBUSB_ERROR_BUSY";
case LIBUSB_ERROR_TIMEOUT:
return "LIBUSB_ERROR_TIMEOUT";
case LIBUSB_ERROR_OVERFLOW:
return "LIBUSB_ERROR_OVERFLOW";
case LIBUSB_ERROR_PIPE:
return "LIBUSB_ERROR_PIPE";
case LIBUSB_ERROR_INTERRUPTED:
return "LIBUSB_ERROR_INTERRUPTED";
case LIBUSB_ERROR_NO_MEM:
return "LIBUSB_ERROR_NO_MEM";
case LIBUSB_ERROR_NOT_SUPPORTED:
return "LIBUSB_ERROR_NOT_SUPPORTED";
case LIBUSB_ERROR_OTHER:
return "LIBUSB_ERROR_OTHER";
case LIBUSB_TRANSFER_ERROR:
return "LIBUSB_TRANSFER_ERROR";
case LIBUSB_TRANSFER_TIMED_OUT:
return "LIBUSB_TRANSFER_TIMED_OUT";
case LIBUSB_TRANSFER_CANCELLED:
return "LIBUSB_TRANSFER_CANCELLED";
case LIBUSB_TRANSFER_STALL:
return "LIBUSB_TRANSFER_STALL";
case LIBUSB_TRANSFER_NO_DEVICE:
return "LIBUSB_TRANSFER_NO_DEVICE";
case LIBUSB_TRANSFER_OVERFLOW:
return "LIBUSB_TRANSFER_OVERFLOW";
case 0:
return "LIBUSB_SUCCESS / LIBUSB_TRANSFER_COMPLETED";
default:
return "**UNKNOWN**";
}
}
/** \ingroup libusb_misc
* Returns a pointer to const struct libusb_version with the version
* (major, minor, micro, nano and rc) of the running library.
*/
DEFAULT_VISIBILITY
const struct libusb_version * LIBUSB_CALL libusb_get_version(void)
{
return &libusb_version_internal;
}
|