tools/usb/usbip/libsrc/names.c

   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 ([email protected])
   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 }