1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * names.c -- USB name database manipulation routines 4 * 5 * Copyright (C) 1999, 2000 Thomas Sailer (sailer@ife.ee.ethz.ch) 6 * 7 * Copyright (C) 2005 Takahiro Hirofuchi 8 * - names_deinit() is added. 9 */ 10 11 #include <sys/types.h> 12 #include <sys/stat.h> 13 #include <fcntl.h> 14 #include <dirent.h> 15 #include <string.h> 16 #include <errno.h> 17 #include <stdlib.h> 18 #include <unistd.h> 19 #include <stdio.h> 20 #include <ctype.h> 21 22 #include "names.h" 23 #include "usbip_common.h" 24 25 struct vendor { 26 struct vendor *next; 27 u_int16_t vendorid; 28 char name[1]; 29 }; 30 31 struct product { 32 struct product *next; 33 u_int16_t vendorid, productid; 34 char name[1]; 35 }; 36 37 struct class { 38 struct class *next; 39 u_int8_t classid; 40 char name[1]; 41 }; 42 43 struct subclass { 44 struct subclass *next; 45 u_int8_t classid, subclassid; 46 char name[1]; 47 }; 48 49 struct protocol { 50 struct protocol *next; 51 u_int8_t classid, subclassid, protocolid; 52 char name[1]; 53 }; 54 55 struct genericstrtable { 56 struct genericstrtable *next; 57 unsigned int num; 58 char name[1]; 59 }; 60 61 62 #define HASH1 0x10 63 #define HASH2 0x02 64 #define HASHSZ 16 65 66 static unsigned int hashnum(unsigned int num) 67 { 68 unsigned int mask1 = HASH1 << 27, mask2 = HASH2 << 27; 69 70 for (; mask1 >= HASH1; mask1 >>= 1, mask2 >>= 1) 71 if (num & mask1) 72 num ^= mask2; 73 return num & (HASHSZ-1); 74 } 75 76 77 static struct vendor *vendors[HASHSZ] = { NULL, }; 78 static struct product *products[HASHSZ] = { NULL, }; 79 static struct class *classes[HASHSZ] = { NULL, }; 80 static struct subclass *subclasses[HASHSZ] = { NULL, }; 81 static struct protocol *protocols[HASHSZ] = { NULL, }; 82 83 const char *names_vendor(u_int16_t vendorid) 84 { 85 struct vendor *v; 86 87 v = vendors[hashnum(vendorid)]; 88 for (; v; v = v->next) 89 if (v->vendorid == vendorid) 90 return v->name; 91 return NULL; 92 } 93 94 const char *names_product(u_int16_t vendorid, u_int16_t productid) 95 { 96 struct product *p; 97 98 p = products[hashnum((vendorid << 16) | productid)]; 99 for (; p; p = p->next) 100 if (p->vendorid == vendorid && p->productid == productid) 101 return p->name; 102 return NULL; 103 } 104 105 const char *names_class(u_int8_t classid) 106 { 107 struct class *c; 108 109 c = classes[hashnum(classid)]; 110 for (; c; c = c->next) 111 if (c->classid == classid) 112 return c->name; 113 return NULL; 114 } 115 116 const char *names_subclass(u_int8_t classid, u_int8_t subclassid) 117 { 118 struct subclass *s; 119 120 s = subclasses[hashnum((classid << 8) | subclassid)]; 121 for (; s; s = s->next) 122 if (s->classid == classid && s->subclassid == subclassid) 123 return s->name; 124 return NULL; 125 } 126 127 const char *names_protocol(u_int8_t classid, u_int8_t subclassid, 128 u_int8_t protocolid) 129 { 130 struct protocol *p; 131 132 p = protocols[hashnum((classid << 16) | (subclassid << 8) 133 | protocolid)]; 134 for (; p; p = p->next) 135 if (p->classid == classid && p->subclassid == subclassid && 136 p->protocolid == protocolid) 137 return p->name; 138 return NULL; 139 } 140 141 /* add a cleanup function by takahiro */ 142 struct pool { 143 struct pool *next; 144 void *mem; 145 }; 146 147 static struct pool *pool_head; 148 149 static void *my_malloc(size_t size) 150 { 151 struct pool *p; 152 153 p = calloc(1, sizeof(struct pool)); 154 if (!p) 155 return NULL; 156 157 p->mem = calloc(1, size); 158 if (!p->mem) { 159 free(p); 160 return NULL; 161 } 162 163 p->next = pool_head; 164 pool_head = p; 165 166 return p->mem; 167 } 168 169 void names_free(void) 170 { 171 struct pool *pool; 172 173 if (!pool_head) 174 return; 175 176 for (pool = pool_head; pool != NULL; ) { 177 struct pool *tmp; 178 179 if (pool->mem) 180 free(pool->mem); 181 182 tmp = pool; 183 pool = pool->next; 184 free(tmp); 185 } 186 } 187 188 static int new_vendor(const char *name, u_int16_t vendorid) 189 { 190 struct vendor *v; 191 unsigned int h = hashnum(vendorid); 192 193 v = vendors[h]; 194 for (; v; v = v->next) 195 if (v->vendorid == vendorid) 196 return -1; 197 v = my_malloc(sizeof(struct vendor) + strlen(name)); 198 if (!v) 199 return -1; 200 strcpy(v->name, name); 201 v->vendorid = vendorid; 202 v->next = vendors[h]; 203 vendors[h] = v; 204 return 0; 205 } 206 207 static int new_product(const char *name, u_int16_t vendorid, 208 u_int16_t productid) 209 { 210 struct product *p; 211 unsigned int h = hashnum((vendorid << 16) | productid); 212 213 p = products[h]; 214 for (; p; p = p->next) 215 if (p->vendorid == vendorid && p->productid == productid) 216 return -1; 217 p = my_malloc(sizeof(struct product) + strlen(name)); 218 if (!p) 219 return -1; 220 strcpy(p->name, name); 221 p->vendorid = vendorid; 222 p->productid = productid; 223 p->next = products[h]; 224 products[h] = p; 225 return 0; 226 } 227 228 static int new_class(const char *name, u_int8_t classid) 229 { 230 struct class *c; 231 unsigned int h = hashnum(classid); 232 233 c = classes[h]; 234 for (; c; c = c->next) 235 if (c->classid == classid) 236 return -1; 237 c = my_malloc(sizeof(struct class) + strlen(name)); 238 if (!c) 239 return -1; 240 strcpy(c->name, name); 241 c->classid = classid; 242 c->next = classes[h]; 243 classes[h] = c; 244 return 0; 245 } 246 247 static int new_subclass(const char *name, u_int8_t classid, u_int8_t subclassid) 248 { 249 struct subclass *s; 250 unsigned int h = hashnum((classid << 8) | subclassid); 251 252 s = subclasses[h]; 253 for (; s; s = s->next) 254 if (s->classid == classid && s->subclassid == subclassid) 255 return -1; 256 s = my_malloc(sizeof(struct subclass) + strlen(name)); 257 if (!s) 258 return -1; 259 strcpy(s->name, name); 260 s->classid = classid; 261 s->subclassid = subclassid; 262 s->next = subclasses[h]; 263 subclasses[h] = s; 264 return 0; 265 } 266 267 static int new_protocol(const char *name, u_int8_t classid, u_int8_t subclassid, 268 u_int8_t protocolid) 269 { 270 struct protocol *p; 271 unsigned int h = hashnum((classid << 16) | (subclassid << 8) 272 | protocolid); 273 274 p = protocols[h]; 275 for (; p; p = p->next) 276 if (p->classid == classid && p->subclassid == subclassid 277 && p->protocolid == protocolid) 278 return -1; 279 p = my_malloc(sizeof(struct protocol) + strlen(name)); 280 if (!p) 281 return -1; 282 strcpy(p->name, name); 283 p->classid = classid; 284 p->subclassid = subclassid; 285 p->protocolid = protocolid; 286 p->next = protocols[h]; 287 protocols[h] = p; 288 return 0; 289 } 290 291 static void parse(FILE *f) 292 { 293 char buf[512], *cp; 294 unsigned int linectr = 0; 295 int lastvendor = -1; 296 int lastclass = -1; 297 int lastsubclass = -1; 298 int lasthut = -1; 299 int lastlang = -1; 300 unsigned int u; 301 302 while (fgets(buf, sizeof(buf), f)) { 303 linectr++; 304 /* remove line ends */ 305 cp = strchr(buf, '\r'); 306 if (cp) 307 *cp = 0; 308 cp = strchr(buf, '\n'); 309 if (cp) 310 *cp = 0; 311 if (buf[0] == '#' || !buf[0]) 312 continue; 313 cp = buf; 314 if (buf[0] == 'P' && buf[1] == 'H' && buf[2] == 'Y' && 315 buf[3] == 'S' && buf[4] == 'D' && 316 buf[5] == 'E' && buf[6] == 'S' && /*isspace(buf[7])*/ 317 buf[7] == ' ') { 318 continue; 319 } 320 if (buf[0] == 'P' && buf[1] == 'H' && 321 buf[2] == 'Y' && /*isspace(buf[3])*/ buf[3] == ' ') { 322 continue; 323 } 324 if (buf[0] == 'B' && buf[1] == 'I' && buf[2] == 'A' && 325 buf[3] == 'S' && /*isspace(buf[4])*/ buf[4] == ' ') { 326 continue; 327 } 328 if (buf[0] == 'L' && /*isspace(buf[1])*/ buf[1] == ' ') { 329 lasthut = lastclass = lastvendor = lastsubclass = -1; 330 /* 331 * set 1 as pseudo-id to indicate that the parser is 332 * in a `L' section. 333 */ 334 lastlang = 1; 335 continue; 336 } 337 if (buf[0] == 'C' && /*isspace(buf[1])*/ buf[1] == ' ') { 338 /* class spec */ 339 cp = buf+2; 340 while (isspace(*cp)) 341 cp++; 342 if (!isxdigit(*cp)) { 343 err("Invalid class spec at line %u", linectr); 344 continue; 345 } 346 u = strtoul(cp, &cp, 16); 347 while (isspace(*cp)) 348 cp++; 349 if (!*cp) { 350 err("Invalid class spec at line %u", linectr); 351 continue; 352 } 353 if (new_class(cp, u)) 354 err("Duplicate class spec at line %u class %04x %s", 355 linectr, u, cp); 356 dbg("line %5u class %02x %s", linectr, u, cp); 357 lasthut = lastlang = lastvendor = lastsubclass = -1; 358 lastclass = u; 359 continue; 360 } 361 if (buf[0] == 'A' && buf[1] == 'T' && isspace(buf[2])) { 362 /* audio terminal type spec */ 363 continue; 364 } 365 if (buf[0] == 'H' && buf[1] == 'C' && buf[2] == 'C' 366 && isspace(buf[3])) { 367 /* HID Descriptor bCountryCode */ 368 continue; 369 } 370 if (isxdigit(*cp)) { 371 /* vendor */ 372 u = strtoul(cp, &cp, 16); 373 while (isspace(*cp)) 374 cp++; 375 if (!*cp) { 376 err("Invalid vendor spec at line %u", linectr); 377 continue; 378 } 379 if (new_vendor(cp, u)) 380 err("Duplicate vendor spec at line %u vendor %04x %s", 381 linectr, u, cp); 382 dbg("line %5u vendor %04x %s", linectr, u, cp); 383 lastvendor = u; 384 lasthut = lastlang = lastclass = lastsubclass = -1; 385 continue; 386 } 387 if (buf[0] == '\t' && isxdigit(buf[1])) { 388 /* product or subclass spec */ 389 u = strtoul(buf+1, &cp, 16); 390 while (isspace(*cp)) 391 cp++; 392 if (!*cp) { 393 err("Invalid product/subclass spec at line %u", 394 linectr); 395 continue; 396 } 397 if (lastvendor != -1) { 398 if (new_product(cp, lastvendor, u)) 399 err("Duplicate product spec at line %u product %04x:%04x %s", 400 linectr, lastvendor, u, cp); 401 dbg("line %5u product %04x:%04x %s", linectr, 402 lastvendor, u, cp); 403 continue; 404 } 405 if (lastclass != -1) { 406 if (new_subclass(cp, lastclass, u)) 407 err("Duplicate subclass spec at line %u class %02x:%02x %s", 408 linectr, lastclass, u, cp); 409 dbg("line %5u subclass %02x:%02x %s", linectr, 410 lastclass, u, cp); 411 lastsubclass = u; 412 continue; 413 } 414 if (lasthut != -1) { 415 /* do not store hut */ 416 continue; 417 } 418 if (lastlang != -1) { 419 /* do not store langid */ 420 continue; 421 } 422 err("Product/Subclass spec without prior Vendor/Class spec at line %u", 423 linectr); 424 continue; 425 } 426 if (buf[0] == '\t' && buf[1] == '\t' && isxdigit(buf[2])) { 427 /* protocol spec */ 428 u = strtoul(buf+2, &cp, 16); 429 while (isspace(*cp)) 430 cp++; 431 if (!*cp) { 432 err("Invalid protocol spec at line %u", 433 linectr); 434 continue; 435 } 436 if (lastclass != -1 && lastsubclass != -1) { 437 if (new_protocol(cp, lastclass, lastsubclass, 438 u)) 439 err("Duplicate protocol spec at line %u class %02x:%02x:%02x %s", 440 linectr, lastclass, lastsubclass, 441 u, cp); 442 dbg("line %5u protocol %02x:%02x:%02x %s", 443 linectr, lastclass, lastsubclass, u, cp); 444 continue; 445 } 446 err("Protocol spec without prior Class and Subclass spec at line %u", 447 linectr); 448 continue; 449 } 450 if (buf[0] == 'H' && buf[1] == 'I' && 451 buf[2] == 'D' && /*isspace(buf[3])*/ buf[3] == ' ') { 452 continue; 453 } 454 if (buf[0] == 'H' && buf[1] == 'U' && 455 buf[2] == 'T' && /*isspace(buf[3])*/ buf[3] == ' ') { 456 lastlang = lastclass = lastvendor = lastsubclass = -1; 457 /* 458 * set 1 as pseudo-id to indicate that the parser is 459 * in a `HUT' section. 460 */ 461 lasthut = 1; 462 continue; 463 } 464 if (buf[0] == 'R' && buf[1] == ' ') 465 continue; 466 467 if (buf[0] == 'V' && buf[1] == 'T') 468 continue; 469 470 err("Unknown line at line %u", linectr); 471 } 472 } 473 474 475 int names_init(char *n) 476 { 477 FILE *f; 478 479 f = fopen(n, "r"); 480 if (!f) 481 return errno; 482 483 parse(f); 484 fclose(f); 485 return 0; 486 } 487