lib/names-cache.c

   1 /*
   2  *      The PCI Library -- ID to Name Cache
   3  *
   4  *      Copyright (c) 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 <string.h>
  12 #include <errno.h>
  13 #include <sys/types.h>
  14 #include <pwd.h>
  15 #include <unistd.h>
  16
  17 #include "internal.h"
  18 #include "names.h"
  19
  20 #ifdef PCI_USE_DNS
  21
  22 static const char cache_version[] = "#PCI-CACHE-1.0";
  23
  24 int
  25 pci_id_cache_load(struct pci_access *a, int flags)
  26 {
  27   char *name;
  28   char line[MAX_LINE];
  29   const char default_name[] = "/.pciids-cache";
  30   FILE *f;
  31   int lino;
  32
  33   a->id_cache_status = 1;
  34   if (!a->id_cache_file)
  35     {
  36       /* Construct the default ID cache name */
  37       uid_t uid = getuid();
  38       struct passwd *pw = getpwuid(uid);
  39       if (!pw)
  40         return 0;
  41       name = pci_malloc(a, strlen(pw->pw_dir) + sizeof(default_name));
  42       sprintf(name, "%s%s", pw->pw_dir, default_name);
  43       pci_set_id_cache(a, name, 1);
  44     }
  45   a->debug("Using cache %s\n", a->id_cache_file);
  46   if (flags & PCI_LOOKUP_REFRESH_CACHE)
  47     {
  48       a->debug("Not loading cache, will refresh everything\n");
  49       a->id_cache_status = 2;
  50       return 0;
  51     }
  52
  53   f = fopen(a->id_cache_file, "rb");
  54   if (!f)
  55     {
  56       a->debug("Cache file does not exist\n");
  57       return 0;
  58     }
  59   /* FIXME: Compare timestamp with the pci.ids file? */
  60
  61   lino = 0;
  62   while (fgets(line, sizeof(line), f))
  63     {
  64       char *p = strchr(line, '\n');
  65       lino++;
  66       if (p)
  67         {
  68           *p = 0;
  69           if (lino == 1)
  70             {
  71               if (strcmp(line, cache_version))
  72                 {
  73                   a->debug("Unrecognized cache version %s, ignoring\n", line);
  74                   break;
  75                 }
  76               continue;
  77             }
  78           else
  79             {
  80               int cat, id1, id2, id3, id4, cnt;
  81               if (sscanf(line, "%d%x%x%x%x%n", &cat, &id1, &id2, &id3, &id4, &cnt) >= 5)
  82                 {
  83                   p = line + cnt;
  84                   while (*p && *p == ' ')
  85                     p++;
  86                   pci_id_insert(a, cat, id1, id2, id3, id4, p, SRC_CACHE);
  87                   continue;
  88                 }
  89             }
  90         }
  91       a->warning("Malformed cache file %s (line %d), ignoring", a->id_cache_file, lino);
  92       break;
  93     }
  94
  95   if (ferror(f))
  96     a->warning("Error while reading %s", a->id_cache_file);
  97   fclose(f);
  98   return 1;
  99 }
 100
 101 void
 102 pci_id_cache_flush(struct pci_access *a)
 103 {
 104   int orig_status = a->id_cache_status;
 105   FILE *f;
 106   unsigned int h;
 107   struct id_entry *e, *e2;
 108
 109   a->id_cache_status = 0;
 110   if (orig_status < 2)
 111     return;
 112   if (!a->id_cache_file)
 113     return;
 114   f = fopen(a->id_cache_file, "wb");
 115   if (!f)
 116     {
 117       a->warning("Cannot write %s: %s", a->id_cache_file, strerror(errno));
 118       return;
 119     }
 120   a->debug("Writing cache to %s\n", a->id_cache_file);
 121   fprintf(f, "%s\n", cache_version);
 122
 123   for (h=0; h<HASH_SIZE; h++)
 124     for (e=a->id_hash[h]; e; e=e->next)
 125       if (e->src == SRC_CACHE || e->src == SRC_NET)
 126         {
 127           /* Verify that every entry is written at most once */
 128           for (e2=a->id_hash[h]; e2 != e; e2=e2->next)
 129             if ((e2->src == SRC_CACHE || e2->src == SRC_NET) &&
 130                 e2->cat == e->cat &&
 131                 e2->id12 == e->id12 && e2->id34 == e->id34)
 132             break;
 133           if (e2 == e)
 134             fprintf(f, "%d %x %x %x %x %s\n",
 135                     e->cat,
 136                     pair_first(e->id12), pair_second(e->id12),
 137                     pair_first(e->id34), pair_second(e->id34),
 138                     e->name);
 139         }
 140
 141   fflush(f);
 142   if (ferror(f))
 143     a->warning("Error writing %s", a->id_cache_file);
 144   fclose(f);
 145 }
 146
 147 #else
 148
 149 int pci_id_cache_load(struct pci_access *a UNUSED, int flags UNUSED)
 150 {
 151   a->id_cache_status = 1;
 152   return 0;
 153 }
 154
 155 void pci_id_cache_flush(struct pci_access *a)
 156 {
 157   a->id_cache_status = 0;
 158 }
 159
 160 #endif
 161
 162 void
 163 pci_id_cache_dirty(struct pci_access *a)
 164 {
 165   if (a->id_cache_status >= 1)
 166     a->id_cache_status = 2;
 167 }
 168
 169 void
 170 pci_set_id_cache(struct pci_access *a, char *name, int to_be_freed)
 171 {
 172   if (a->free_id_cache_file)
 173     free(a->id_cache_file);
 174   a->id_cache_file = name;
 175   a->free_id_cache_file = to_be_freed;
 176 }