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