lib/names.c

   1 /*
   2  *      The PCI Library -- ID to Name Translation
   3  *
   4  *      Copyright (c) 1997--2008 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <stdarg.h>
  12 #include <string.h>
  13 #include <errno.h>
  14 #include <netinet/in.h>
  15 #include <arpa/nameser.h>
  16 #include <resolv.h>
  17 #include <sys/types.h>
  18 #include <pwd.h>
  19 #include <unistd.h>
  20
  21 #include "internal.h"
  22
  23 #ifdef PCI_COMPRESSED_IDS
  24 #include <zlib.h>
  25 typedef gzFile pci_file;
  26 #define pci_gets(f, l, s)       gzgets(f, l, s)
  27 #define pci_eof(f)              gzeof(f)
  28
  29 static pci_file pci_open(struct pci_access *a)
  30 {
  31   pci_file result;
  32   size_t len;
  33   char *new_name;
  34
  35   result = gzopen(a->id_file_name, "rb");
  36   if (result)
  37     return result;
  38   len = strlen(a->id_file_name);
  39   if (len >= 3 && memcmp(a->id_file_name + len - 3, ".gz", 3) != 0)
  40     return result;
  41   new_name = malloc(len - 2);
  42   memcpy(new_name, a->id_file_name, len - 3);
  43   new_name[len - 3] = 0;
  44   pci_set_name_list_path(a, new_name, 1);
  45   return gzopen(a->id_file_name, "rb");
  46 }
  47
  48 #define pci_close(f)            gzclose(f)
  49 #define PCI_ERROR(f, err)                                               \
  50         if (!err) {                                                     \
  51                 int errnum;                                             \
  52                 gzerror(f, &errnum);                                    \
  53                 if (errnum >= 0) err = NULL;                            \
  54                 else if (errnum == Z_ERRNO) err = "I/O error";          \
  55                 else err = zError(errnum);                              \
  56         }
  57 #else
  58 typedef FILE * pci_file;
  59 #define pci_gets(f, l, s)       fgets(l, s, f)
  60 #define pci_eof(f)              feof(f)
  61 #define pci_open(a)             fopen(a->id_file_name, "r")
  62 #define pci_close(f)            fclose(f)
  63 #define PCI_ERROR(f, err)       if (!err && ferror(f))  err = "I/O error";
  64 #endif
  65
  66 struct id_entry {
  67   struct id_entry *next;
  68   u32 id12, id34;
  69   byte cat;
  70   byte src;
  71   char name[1];
  72 };
  73
  74 enum id_entry_type {
  75   ID_UNKNOWN,
  76   ID_VENDOR,
  77   ID_DEVICE,
  78   ID_SUBSYSTEM,
  79   ID_GEN_SUBSYSTEM,
  80   ID_CLASS,
  81   ID_SUBCLASS,
  82   ID_PROGIF
  83 };
  84
  85 enum id_entry_src {
  86   SRC_UNKNOWN,
  87   SRC_CACHE,
  88   SRC_NET,
  89   SRC_LOCAL,
  90 };
  91
  92 struct id_bucket {
  93   struct id_bucket *next;
  94   unsigned int full;
  95 };
  96
  97 #define MAX_LINE 1024
  98 #define BUCKET_SIZE 8192
  99 #define HASH_SIZE 4099
 100
 101 #ifdef __GNUC__
 102 #define BUCKET_ALIGNMENT __alignof__(struct id_bucket)
 103 #else
 104 union id_align {
 105   struct id_bucket *next;
 106   unsigned int full;
 107 };
 108 #define BUCKET_ALIGNMENT sizeof(union id_align)
 109 #endif
 110 #define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT)
 111
 112 static void *id_alloc(struct pci_access *a, unsigned int size)
 113 {
 114   struct id_bucket *buck = a->current_id_bucket;
 115   unsigned int pos;
 116
 117   if (!a->id_hash)
 118     {
 119       a->id_hash = pci_malloc(a, sizeof(struct id_entry *) * HASH_SIZE);
 120       memset(a->id_hash, 0, sizeof(struct id_entry *) * HASH_SIZE);
 121     }
 122
 123   if (!buck || buck->full + size > BUCKET_SIZE)
 124     {
 125       buck = pci_malloc(a, BUCKET_SIZE);
 126       buck->next = a->current_id_bucket;
 127       a->current_id_bucket = buck;
 128       buck->full = BUCKET_ALIGN(sizeof(struct id_bucket));
 129     }
 130   pos = buck->full;
 131   buck->full = BUCKET_ALIGN(buck->full + size);
 132   return (byte *)buck + pos;
 133 }
 134
 135 static inline u32 id_pair(unsigned int x, unsigned int y)
 136 {
 137   return ((x << 16) | y);
 138 }
 139
 140 static inline unsigned int pair_first(unsigned int x)
 141 {
 142   return (x >> 16) & 0xffff;
 143 }
 144
 145 static inline unsigned int pair_second(unsigned int x)
 146 {
 147   return x & 0xffff;
 148 }
 149
 150 static inline unsigned int id_hash(int cat, u32 id12, u32 id34)
 151 {
 152   unsigned int h;
 153
 154   h = id12 ^ (id34 << 3) ^ (cat << 5);
 155   return h % HASH_SIZE;
 156 }
 157
 158 static int id_insert(struct pci_access *a, int cat, int id1, int id2, int id3, int id4, char *text, enum id_entry_src src)
 159 {
 160   u32 id12 = id_pair(id1, id2);
 161   u32 id34 = id_pair(id3, id4);
 162   unsigned int h = id_hash(cat, id12, id34);
 163   struct id_entry *n = a->id_hash ? a->id_hash[h] : NULL;
 164   int len = strlen(text);
 165
 166   while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat))
 167     n = n->next;
 168   if (n)
 169     return 1;
 170   n = id_alloc(a, sizeof(struct id_entry) + len);
 171   n->id12 = id12;
 172   n->id34 = id34;
 173   n->cat = cat;
 174   n->src = src;
 175   memcpy(n->name, text, len+1);
 176   n->next = a->id_hash[h];
 177   a->id_hash[h] = n;
 178   return 0;
 179 }
 180
 181 static char *id_lookup_raw(struct pci_access *a, int flags, int cat, int id1, int id2, int id3, int id4)
 182 {
 183   struct id_entry *n, *best;
 184   u32 id12 = id_pair(id1, id2);
 185   u32 id34 = id_pair(id3, id4);
 186
 187   if (a->id_hash)
 188     {
 189       n = a->id_hash[id_hash(cat, id12, id34)];
 190       best = NULL;
 191       for (; n; n=n->next)
 192         {
 193           if (n->id12 != id12 || n->id34 != id34 || n->cat != cat)
 194             continue;
 195           if (n->src == SRC_LOCAL && (flags & PCI_LOOKUP_SKIP_LOCAL))
 196             continue;
 197           if (n->src == SRC_NET && !(flags & PCI_LOOKUP_NETWORK))
 198             continue;
 199           if (n->src == SRC_CACHE && !(flags & PCI_LOOKUP_CACHE))
 200             continue;
 201           if (!best || best->src < n->src)
 202             best = n;
 203         }
 204       if (best)
 205         return best->name;
 206     }
 207   return NULL;
 208 }
 209
 210 static const char cache_version[] = "#PCI-CACHE-1.0";
 211
 212 static int
 213 pci_id_cache_load(struct pci_access *a, int flags)
 214 {
 215   char *name;
 216   char line[MAX_LINE];
 217   const char default_name[] = "/.pciids-cache";
 218   FILE *f;
 219   int lino;
 220
 221   a->id_cache_status = 1;
 222   if (!a->id_cache_file)
 223     {
 224       /* Construct the default ID cache name */
 225       uid_t uid = getuid();
 226       struct passwd *pw = getpwuid(uid);
 227       if (!pw)
 228         return 0;
 229       name = pci_malloc(a, strlen(pw->pw_dir) + sizeof(default_name));
 230       sprintf(name, "%s%s", pw->pw_dir, default_name);
 231       pci_set_id_cache(a, name, 1);
 232     }
 233   a->debug("Using cache %s\n", a->id_cache_file);
 234   if (flags & PCI_LOOKUP_REFRESH_CACHE)
 235     {
 236       a->debug("Not loading cache, will refresh everything\n");
 237       a->id_cache_status = 2;
 238       return 0;
 239     }
 240
 241   f = fopen(a->id_cache_file, "rb");
 242   if (!f)
 243     {
 244       a->debug("Cache file does not exist\n");
 245       return 0;
 246     }
 247   /* FIXME: Compare timestamp with the pci.ids file? */
 248
 249   lino = 0;
 250   while (fgets(line, sizeof(line), f))
 251     {
 252       char *p = strchr(line, '\n');
 253       lino++;
 254       if (p)
 255         {
 256           *p = 0;
 257           if (lino == 1)
 258             {
 259               if (strcmp(line, cache_version))
 260                 {
 261                   a->debug("Unrecognized cache version %s, ignoring\n", line);
 262                   break;
 263                 }
 264               continue;
 265             }
 266           else
 267             {
 268               int cat, id1, id2, id3, id4, cnt;
 269               if (sscanf(line, "%d%x%x%x%x%n", &cat, &id1, &id2, &id3, &id4, &cnt) >= 5)
 270                 {
 271                   p = line + cnt;
 272                   while (*p && *p == ' ')
 273                     p++;
 274                   id_insert(a, cat, id1, id2, id3, id4, p, SRC_CACHE);
 275                   continue;
 276                 }
 277             }
 278         }
 279       a->warning("Malformed cache file %s (line %d), ignoring", a->id_cache_file, lino);
 280       break;
 281     }
 282
 283   if (ferror(f))
 284     a->warning("Error while reading %s", a->id_cache_file);
 285   fclose(f);
 286   return 1;
 287 }
 288
 289 static void
 290 pci_id_cache_dirty(struct pci_access *a)
 291 {
 292   if (a->id_cache_status >= 1)
 293     a->id_cache_status = 2;
 294 }
 295
 296 void
 297 pci_id_cache_flush(struct pci_access *a)
 298 {
 299   int orig_status = a->id_cache_status;
 300   FILE *f;
 301   unsigned int h;
 302   struct id_entry *e, *e2;
 303
 304   a->id_cache_status = 0;
 305   if (orig_status < 2)
 306     return;
 307   if (!a->id_cache_file)
 308     return;
 309   f = fopen(a->id_cache_file, "wb");
 310   if (!f)
 311     {
 312       a->warning("Cannot write %s: %s", a->id_cache_file, strerror(errno));
 313       return;
 314     }
 315   a->debug("Writing cache to %s\n", a->id_cache_file);
 316   fprintf(f, "%s\n", cache_version);
 317
 318   for (h=0; h<HASH_SIZE; h++)
 319     for (e=a->id_hash[h]; e; e=e->next)
 320       if (e->src == SRC_CACHE || e->src == SRC_NET)
 321         {
 322           /* Verify that every entry is written at most once */
 323           for (e2=a->id_hash[h]; e2 != e; e2=e2->next)
 324             if ((e2->src == SRC_CACHE || e2->src == SRC_NET) &&
 325                 e2->cat == e->cat &&
 326                 e2->id12 == e->id12 && e2->id34 == e->id34)
 327             break;
 328           if (e2 == e)
 329             fprintf(f, "%d %x %x %x %x %s\n",
 330                     e->cat,
 331                     pair_first(e->id12), pair_second(e->id12),
 332                     pair_first(e->id34), pair_second(e->id34),
 333                     e->name);
 334         }
 335
 336   fflush(f);
 337   if (ferror(f))
 338     a->warning("Error writing %s", a->id_cache_file);
 339   fclose(f);
 340 }
 341
 342 static char *id_net_lookup(struct pci_access *a, int cat, int id1, int id2, int id3, int id4)
 343 {
 344   char name[256], dnsname[256], txt[256];
 345   byte answer[4096];
 346   const byte *data;
 347   int res, i, j, dlen;
 348   ns_msg m;
 349   ns_rr rr;
 350
 351   switch (cat)
 352     {
 353     case ID_VENDOR:
 354       sprintf(name, "%04x", id1);
 355       break;
 356     case ID_DEVICE:
 357       sprintf(name, "%04x.%04x", id2, id1);
 358       break;
 359     case ID_SUBSYSTEM:
 360       sprintf(name, "%04x.%04x.%04x.%04x", id4, id3, id2, id1);
 361       break;
 362     case ID_GEN_SUBSYSTEM:
 363       sprintf(name, "%04x.%04x.s", id2, id1);
 364       break;
 365     case ID_CLASS:
 366       sprintf(name, "%02x.c", id1);
 367       break;
 368     case ID_SUBCLASS:
 369       sprintf(name, "%02x.%02x.c", id2, id1);
 370       break;
 371     case ID_PROGIF:
 372       sprintf(name, "%02x.%02x.%02x.c", id3, id2, id1);
 373       break;
 374     default:
 375       return NULL;
 376     }
 377   sprintf(dnsname, "%s.%s", name, a->id_domain);
 378
 379   a->debug("Resolving %s\n", dnsname);
 380   res_init();
 381   res = res_query(dnsname, ns_c_in, ns_t_txt, answer, sizeof(answer));
 382   if (res < 0)
 383     {
 384       a->debug("\tfailed, h_errno=%d\n", _res.res_h_errno);
 385       return NULL;
 386     }
 387   if (ns_initparse(answer, res, &m) < 0)
 388     {
 389       a->debug("\tinitparse failed\n");
 390       return NULL;
 391     }
 392   for (i=0; ns_parserr(&m, ns_s_an, i, &rr) >= 0; i++)
 393     {
 394       a->debug("\tanswer %d (class %d, type %d)\n", i, ns_rr_class(rr), ns_rr_type(rr));
 395       if (ns_rr_class(rr) != ns_c_in || ns_rr_type(rr) != ns_t_txt)
 396         continue;
 397       data = ns_rr_rdata(rr);
 398       dlen = ns_rr_rdlen(rr);
 399       j = 0;
 400       while (j < dlen && j+1+data[j] <= dlen)
 401         {
 402           memcpy(txt, &data[j+1], data[j]);
 403           txt[data[j]] = 0;
 404           j += 1+data[j];
 405           a->debug("\t\t%s\n", txt);
 406           if (txt[0] == 'i' && txt[1] == '=')
 407             return strdup(txt+2);
 408         }
 409     }
 410
 411   return NULL;
 412 }
 413
 414 static char *id_lookup(struct pci_access *a, int flags, int cat, int id1, int id2, int id3, int id4)
 415 {
 416   char *name;
 417
 418   while (!(name = id_lookup_raw(a, flags, cat, id1, id2, id3, id4)))
 419     {
 420       if ((flags & PCI_LOOKUP_CACHE) && !a->id_cache_status)
 421         {
 422           if (pci_id_cache_load(a, flags))
 423             continue;
 424         }
 425       if (flags & PCI_LOOKUP_NETWORK)
 426         {
 427           if (name = id_net_lookup(a, cat, id1, id2, id3, id4))
 428             {
 429               id_insert(a, cat, id1, id2, id3, id4, name, SRC_NET);
 430               free(name);
 431               pci_id_cache_dirty(a);
 432             }
 433           else
 434             id_insert(a, cat, id1, id2, id3, id4, "", SRC_NET); /* FIXME: Check that negative caching works */
 435           /* We want to iterate the lookup to get the allocated ID entry from the hash */
 436           continue;
 437         }
 438       return NULL;
 439     }
 440   return (name[0] ? name : NULL);
 441 }
 442
 443 static int id_hex(char *p, int cnt)
 444 {
 445   int x = 0;
 446   while (cnt--)
 447     {
 448       x <<= 4;
 449       if (*p >= '0' && *p <= '9')
 450         x += (*p - '0');
 451       else if (*p >= 'a' && *p <= 'f')
 452         x += (*p - 'a' + 10);
 453       else if (*p >= 'A' && *p <= 'F')
 454         x += (*p - 'A' + 10);
 455       else
 456         return -1;
 457       p++;
 458     }
 459   return x;
 460 }
 461
 462 static inline int id_white_p(int c)
 463 {
 464   return (c == ' ') || (c == '\t');
 465 }
 466
 467 static const char *id_parse_list(struct pci_access *a, pci_file f, int *lino)
 468 {
 469   char line[MAX_LINE];
 470   char *p;
 471   int id1=0, id2=0, id3=0, id4=0;
 472   int cat = -1;
 473   int nest;
 474   static const char parse_error[] = "Parse error";
 475
 476   *lino = 0;
 477   while (pci_gets(f, line, sizeof(line)))
 478     {
 479       (*lino)++;
 480       p = line;
 481       while (*p && *p != '\n' && *p != '\r')
 482         p++;
 483       if (!*p && !pci_eof(f))
 484         return "Line too long";
 485       *p = 0;
 486       if (p > line && (p[-1] == ' ' || p[-1] == '\t'))
 487         *--p = 0;
 488
 489       p = line;
 490       while (id_white_p(*p))
 491         p++;
 492       if (!*p || *p == '#')
 493         continue;
 494
 495       p = line;
 496       while (*p == '\t')
 497         p++;
 498       nest = p - line;
 499
 500       if (!nest)                                        /* Top-level entries */
 501         {
 502           if (p[0] == 'C' && p[1] == ' ')               /* Class block */
 503             {
 504               if ((id1 = id_hex(p+2, 2)) < 0 || !id_white_p(p[4]))
 505                 return parse_error;
 506               cat = ID_CLASS;
 507               p += 5;
 508             }
 509           else if (p[0] == 'S' && p[1] == ' ')
 510             {                                           /* Generic subsystem block */
 511               if ((id1 = id_hex(p+2, 4)) < 0 || p[6])
 512                 return parse_error;
 513               if (!id_lookup(a, 0, ID_VENDOR, id1, 0, 0, 0))
 514                 return "Vendor does not exist";
 515               cat = ID_GEN_SUBSYSTEM;
 516               continue;
 517             }
 518           else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ')
 519             {                                           /* Unrecognized block (RFU) */
 520               cat = ID_UNKNOWN;
 521               continue;
 522             }
 523           else                                          /* Vendor ID */
 524             {
 525               if ((id1 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
 526                 return parse_error;
 527               cat = ID_VENDOR;
 528               p += 5;
 529             }
 530           id2 = id3 = id4 = 0;
 531         }
 532       else if (cat == ID_UNKNOWN)                       /* Nested entries in RFU blocks are skipped */
 533         continue;
 534       else if (nest == 1)                               /* Nesting level 1 */
 535         switch (cat)
 536           {
 537           case ID_VENDOR:
 538           case ID_DEVICE:
 539           case ID_SUBSYSTEM:
 540             if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
 541               return parse_error;
 542             p += 5;
 543             cat = ID_DEVICE;
 544             id3 = id4 = 0;
 545             break;
 546           case ID_GEN_SUBSYSTEM:
 547             if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
 548               return parse_error;
 549             p += 5;
 550             id3 = id4 = 0;
 551             break;
 552           case ID_CLASS:
 553           case ID_SUBCLASS:
 554           case ID_PROGIF:
 555             if ((id2 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
 556               return parse_error;
 557             p += 3;
 558             cat = ID_SUBCLASS;
 559             id3 = id4 = 0;
 560             break;
 561           default:
 562             return parse_error;
 563           }
 564       else if (nest == 2)                               /* Nesting level 2 */
 565         switch (cat)
 566           {
 567           case ID_DEVICE:
 568           case ID_SUBSYSTEM:
 569             if ((id3 = id_hex(p, 4)) < 0 || !id_white_p(p[4]) || (id4 = id_hex(p+5, 4)) < 0 || !id_white_p(p[9]))
 570               return parse_error;
 571             p += 10;
 572             cat = ID_SUBSYSTEM;
 573             break;
 574           case ID_CLASS:
 575           case ID_SUBCLASS:
 576           case ID_PROGIF:
 577             if ((id3 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
 578               return parse_error;
 579             p += 3;
 580             cat = ID_PROGIF;
 581             id4 = 0;
 582             break;
 583           default:
 584             return parse_error;
 585           }
 586       else                                              /* Nesting level 3 or more */
 587         return parse_error;
 588       while (id_white_p(*p))
 589         p++;
 590       if (!*p)
 591         return parse_error;
 592       if (id_insert(a, cat, id1, id2, id3, id4, p, SRC_LOCAL))
 593         return "Duplicate entry";
 594     }
 595   return NULL;
 596 }
 597
 598 int
 599 pci_load_name_list(struct pci_access *a)
 600 {
 601   pci_file f;
 602   int lino;
 603   const char *err;
 604
 605   pci_free_name_list(a);
 606   a->id_load_failed = 1;
 607   if (!(f = pci_open(a)))
 608     return 0;
 609   err = id_parse_list(a, f, &lino);
 610   PCI_ERROR(f, err);
 611   pci_close(f);
 612   if (err)
 613     a->error("%s at %s, line %d\n", err, a->id_file_name, lino);
 614   a->id_load_failed = 0;
 615   return 1;
 616 }
 617
 618 void
 619 pci_free_name_list(struct pci_access *a)
 620 {
 621   pci_id_cache_flush(a);
 622   pci_mfree(a->id_hash);
 623   a->id_hash = NULL;
 624   a->id_cache_status = 0;
 625   while (a->current_id_bucket)
 626     {
 627       struct id_bucket *buck = a->current_id_bucket;
 628       a->current_id_bucket = buck->next;
 629       pci_mfree(buck);
 630     }
 631 }
 632
 633 static char *
 634 id_lookup_subsys(struct pci_access *a, int flags, int iv, int id, int isv, int isd)
 635 {
 636   char *d = NULL;
 637   if (iv > 0 && id > 0)                                         /* Per-device lookup */
 638     d = id_lookup(a, flags, ID_SUBSYSTEM, iv, id, isv, isd);
 639   if (!d)                                                       /* Generic lookup */
 640     d = id_lookup(a, flags, ID_GEN_SUBSYSTEM, isv, isd, 0, 0);
 641   if (!d && iv == isv && id == isd)                             /* Check for subsystem == device */
 642     d = id_lookup(a, flags, ID_DEVICE, iv, id, 0, 0);
 643   return d;
 644 }
 645
 646 static char *
 647 format_name(char *buf, int size, int flags, char *name, char *num, char *unknown)
 648 {
 649   int res;
 650   if ((flags & PCI_LOOKUP_NO_NUMBERS) && !name)
 651     return NULL;
 652   else if (flags & PCI_LOOKUP_NUMERIC)
 653     res = snprintf(buf, size, "%s", num);
 654   else if (!name)
 655     res = snprintf(buf, size, ((flags & PCI_LOOKUP_MIXED) ? "%s [%s]" : "%s %s"), unknown, num);
 656   else if (!(flags & PCI_LOOKUP_MIXED))
 657     res = snprintf(buf, size, "%s", name);
 658   else
 659     res = snprintf(buf, size, "%s [%s]", name, num);
 660   if (res < 0 || res >= size)
 661     return "<pci_lookup_name: buffer too small>";
 662   else
 663     return buf;
 664 }
 665
 666 static char *
 667 format_name_pair(char *buf, int size, int flags, char *v, char *d, char *num)
 668 {
 669   int res;
 670   if ((flags & PCI_LOOKUP_NO_NUMBERS) && (!v || !d))
 671     return NULL;
 672   if (flags & PCI_LOOKUP_NUMERIC)
 673     res = snprintf(buf, size, "%s", num);
 674   else if (flags & PCI_LOOKUP_MIXED)
 675     {
 676       if (v && d)
 677         res = snprintf(buf, size, "%s %s [%s]", v, d, num);
 678       else if (!v)
 679         res = snprintf(buf, size, "Unknown device [%s]", num);
 680       else /* v && !d */
 681         res = snprintf(buf, size, "%s Unknown device [%s]", v, num);
 682     }
 683   else
 684     {
 685       if (v && d)
 686         res = snprintf(buf, size, "%s %s", v, d);
 687       else if (!v)
 688         res = snprintf(buf, size, "Unknown device %s", num);
 689       else /* v && !d */
 690         res = snprintf(buf, size, "%s Unknown device %s", v, num+5);
 691     }
 692   if (res < 0 || res >= size)
 693     return "<pci_lookup_name: buffer too small>";
 694   else
 695     return buf;
 696 }
 697
 698 char *
 699 pci_lookup_name(struct pci_access *a, char *buf, int size, int flags, ...)
 700 {
 701   va_list args;
 702   char *v, *d, *cls, *pif;
 703   int iv, id, isv, isd, icls, ipif;
 704   char numbuf[16], pifbuf[32];
 705
 706   va_start(args, flags);
 707
 708   flags |= a->id_lookup_mode;
 709   if (!(flags & PCI_LOOKUP_NO_NUMBERS))
 710     {
 711       if (a->numeric_ids > 1)
 712         flags |= PCI_LOOKUP_MIXED;
 713       else if (a->numeric_ids)
 714         flags |= PCI_LOOKUP_NUMERIC;
 715     }
 716   if (flags & PCI_LOOKUP_MIXED)
 717     flags &= ~PCI_LOOKUP_NUMERIC;
 718
 719   if (!a->id_hash && !(flags & (PCI_LOOKUP_NUMERIC | PCI_LOOKUP_SKIP_LOCAL)) && !a->id_load_failed)
 720     pci_load_name_list(a);
 721
 722   switch (flags & 0xffff)
 723     {
 724     case PCI_LOOKUP_VENDOR:
 725       iv = va_arg(args, int);
 726       sprintf(numbuf, "%04x", iv);
 727       return format_name(buf, size, flags, id_lookup(a, flags, ID_VENDOR, iv, 0, 0, 0), numbuf, "Unknown vendor");
 728     case PCI_LOOKUP_DEVICE:
 729       iv = va_arg(args, int);
 730       id = va_arg(args, int);
 731       sprintf(numbuf, "%04x", id);
 732       return format_name(buf, size, flags, id_lookup(a, flags, ID_DEVICE, iv, id, 0, 0), numbuf, "Unknown device");
 733     case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE:
 734       iv = va_arg(args, int);
 735       id = va_arg(args, int);
 736       sprintf(numbuf, "%04x:%04x", iv, id);
 737       v = id_lookup(a, flags, ID_VENDOR, iv, 0, 0, 0);
 738       d = id_lookup(a, flags, ID_DEVICE, iv, id, 0, 0);
 739       return format_name_pair(buf, size, flags, v, d, numbuf);
 740     case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR:
 741       isv = va_arg(args, int);
 742       sprintf(numbuf, "%04x", isv);
 743       v = id_lookup(a, flags, ID_VENDOR, isv, 0, 0, 0);
 744       return format_name(buf, size, flags, v, numbuf, "Unknown vendor");
 745     case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE:
 746       iv = va_arg(args, int);
 747       id = va_arg(args, int);
 748       isv = va_arg(args, int);
 749       isd = va_arg(args, int);
 750       sprintf(numbuf, "%04x", isd);
 751       return format_name(buf, size, flags, id_lookup_subsys(a, flags, iv, id, isv, isd), numbuf, "Unknown device");
 752     case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE | PCI_LOOKUP_SUBSYSTEM:
 753       iv = va_arg(args, int);
 754       id = va_arg(args, int);
 755       isv = va_arg(args, int);
 756       isd = va_arg(args, int);
 757       v = id_lookup(a, flags, ID_VENDOR, isv, 0, 0, 0);
 758       d = id_lookup_subsys(a, flags, iv, id, isv, isd);
 759       sprintf(numbuf, "%04x:%04x", isv, isd);
 760       return format_name_pair(buf, size, flags, v, d, numbuf);
 761     case PCI_LOOKUP_CLASS:
 762       icls = va_arg(args, int);
 763       sprintf(numbuf, "%04x", icls);
 764       cls = id_lookup(a, flags, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0);
 765       if (!cls && (cls = id_lookup(a, flags, ID_CLASS, icls >> 8, 0, 0, 0)))
 766         {
 767           if (!(flags & PCI_LOOKUP_NUMERIC)) /* Include full class number */
 768             flags |= PCI_LOOKUP_MIXED;
 769         }
 770       return format_name(buf, size, flags, cls, numbuf, ((flags & PCI_LOOKUP_MIXED) ? "Unknown class" : "Class"));
 771     case PCI_LOOKUP_PROGIF:
 772       icls = va_arg(args, int);
 773       ipif = va_arg(args, int);
 774       sprintf(numbuf, "%02x", ipif);
 775       pif = id_lookup(a, flags, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0);
 776       if (!pif && icls == 0x0101 && !(ipif & 0x70))
 777         {
 778           /* IDE controllers have complex prog-if semantics */
 779           sprintf(pifbuf, "%s%s%s%s%s",
 780                   (ipif & 0x80) ? " Master" : "",
 781                   (ipif & 0x08) ? " SecP" : "",
 782                   (ipif & 0x04) ? " SecO" : "",
 783                   (ipif & 0x02) ? " PriP" : "",
 784                   (ipif & 0x01) ? " PriO" : "");
 785           pif = pifbuf;
 786           if (*pif)
 787             pif++;
 788         }
 789       return format_name(buf, size, flags, pif, numbuf, "ProgIf");
 790     default:
 791       return "<pci_lookup_name: invalid request>";
 792     }
 793 }
 794
 795 void pci_set_name_list_path(struct pci_access *a, char *name, int to_be_freed)
 796 {
 797   if (a->free_id_name)
 798     free(a->id_file_name);
 799   a->id_file_name = name;
 800   a->free_id_name = to_be_freed;
 801 }
 802
 803 void pci_set_net_domain(struct pci_access *a, char *name, int to_be_freed)
 804 {
 805   if (a->free_id_domain)
 806     free(a->id_domain);
 807   a->id_domain = name;
 808   a->free_id_domain = to_be_freed;
 809 }
 810
 811 void pci_set_id_cache(struct pci_access *a, char *name, int to_be_freed)
 812 {
 813   if (a->free_id_cache_file)
 814     free(a->id_cache_file);
 815   a->id_cache_file = name;
 816   a->free_id_cache_file = to_be_freed;
 817 }