lib/blkid/cache.c

   1 /*
   2  * cache.c - allocation/initialization/free routines for cache
   3  *
   4  * Copyright (C) 2001 Andreas Dilger
   5  * Copyright (C) 2003 Theodore Ts'o
   6  *
   7  * %Begin-Header%
   8  * This file may be redistributed under the terms of the
   9  * GNU Lesser General Public License.
  10  * %End-Header%
  11  */
  12
  13 #include "config.h"
  14 #if HAVE_SECURE_GETENV
  15 #define _GNU_SOURCE
  16 #endif
  17 #if HAVE_UNISTD_H
  18 #include <unistd.h>
  19 #endif
  20 #ifdef HAVE_ERRNO_H
  21 #include <errno.h>
  22 #endif
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #ifdef HAVE_SYS_PRCTL_H
  26 #include <sys/prctl.h>
  27 #else
  28 #define PR_GET_DUMPABLE 3
  29 #endif
  30 #if (!defined(HAVE_PRCTL) && defined(linux))
  31 #include <sys/syscall.h>
  32 #endif
  33 #ifdef HAVE_SYS_STAT_H
  34 #include <sys/stat.h>
  35 #endif
  36 #include "blkidP.h"
  37
  38 int blkid_debug_mask = 0;
  39
  40
  41 static char *safe_getenv(const char *arg)
  42 {
  43         if ((getuid() != geteuid()) || (getgid() != getegid()))
  44                 return NULL;
  45 #if HAVE_PRCTL
  46         if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) == 0)
  47                 return NULL;
  48 #else
  49 #if (defined(linux) && defined(SYS_prctl))
  50         if (syscall(SYS_prctl, PR_GET_DUMPABLE, 0, 0, 0, 0) == 0)
  51                 return NULL;
  52 #endif
  53 #endif
  54
  55 #if defined(HAVE_SECURE_GETENV)
  56         return secure_getenv(arg);
  57 #elif defined(HAVE___SECURE_GETENV)
  58         return __secure_getenv(arg);
  59 #else
  60         return getenv(arg);
  61 #endif
  62 }
  63
  64 #if 0 /* ifdef CONFIG_BLKID_DEBUG */
  65 static blkid_debug_dump_cache(int mask, blkid_cache cache)
  66 {
  67         struct list_head *p;
  68
  69         if (!cache) {
  70                 printf("cache: NULL\n");
  71                 return;
  72         }
  73
  74         printf("cache: time = %lu\n", cache->bic_time);
  75         printf("cache: flags = 0x%08X\n", cache->bic_flags);
  76
  77         list_for_each(p, &cache->bic_devs) {
  78                 blkid_dev dev = list_entry(p, struct blkid_struct_dev, bid_devs);
  79                 blkid_debug_dump_dev(dev);
  80         }
  81 }
  82 #endif
  83
  84 int blkid_get_cache(blkid_cache *ret_cache, const char *filename)
  85 {
  86         blkid_cache cache;
  87
  88 #ifdef CONFIG_BLKID_DEBUG
  89         if (!(blkid_debug_mask & DEBUG_INIT)) {
  90                 char *dstr = getenv("BLKID_DEBUG");
  91
  92                 if (dstr)
  93                         blkid_debug_mask = strtoul(dstr, 0, 0);
  94                 blkid_debug_mask |= DEBUG_INIT;
  95         }
  96 #endif
  97
  98         DBG(DEBUG_CACHE, printf("creating blkid cache (using %s)\n",
  99                                 filename ? filename : "default cache"));
 100
 101         if (!(cache = (blkid_cache) calloc(1, sizeof(struct blkid_struct_cache))))
 102                 return -BLKID_ERR_MEM;
 103
 104         INIT_LIST_HEAD(&cache->bic_devs);
 105         INIT_LIST_HEAD(&cache->bic_tags);
 106
 107         if (filename && !strlen(filename))
 108                 filename = 0;
 109         if (!filename)
 110                 filename = safe_getenv("BLKID_FILE");
 111         if (!filename)
 112                 filename = BLKID_CACHE_FILE;
 113         cache->bic_filename = blkid_strdup(filename);
 114
 115         blkid_read_cache(cache);
 116
 117         *ret_cache = cache;
 118         return 0;
 119 }
 120
 121 void blkid_put_cache(blkid_cache cache)
 122 {
 123         if (!cache)
 124                 return;
 125
 126         (void) blkid_flush_cache(cache);
 127
 128         DBG(DEBUG_CACHE, printf("freeing cache struct\n"));
 129
 130         /* DBG(DEBUG_CACHE, blkid_debug_dump_cache(cache)); */
 131
 132         while (!list_empty(&cache->bic_devs)) {
 133                 blkid_dev dev = list_entry(cache->bic_devs.next,
 134                                            struct blkid_struct_dev,
 135                                             bid_devs);
 136                 blkid_free_dev(dev);
 137         }
 138
 139         while (!list_empty(&cache->bic_tags)) {
 140                 blkid_tag tag = list_entry(cache->bic_tags.next,
 141                                            struct blkid_struct_tag,
 142                                            bit_tags);
 143
 144                 while (!list_empty(&tag->bit_names)) {
 145                         blkid_tag bad = list_entry(tag->bit_names.next,
 146                                                    struct blkid_struct_tag,
 147                                                    bit_names);
 148
 149                         DBG(DEBUG_CACHE, printf("warning: unfreed tag %s=%s\n",
 150                                                 bad->bit_name, bad->bit_val));
 151                         blkid_free_tag(bad);
 152                 }
 153                 blkid_free_tag(tag);
 154         }
 155         free(cache->bic_filename);
 156
 157         free(cache);
 158 }
 159
 160 void blkid_gc_cache(blkid_cache cache)
 161 {
 162         struct list_head *p, *pnext;
 163         struct stat st;
 164
 165         if (!cache)
 166                 return;
 167
 168         list_for_each_safe(p, pnext, &cache->bic_devs) {
 169                 blkid_dev dev = list_entry(p, struct blkid_struct_dev, bid_devs);
 170                 if (!p)
 171                         break;
 172                 if (stat(dev->bid_name, &st) < 0) {
 173                         DBG(DEBUG_CACHE,
 174                             printf("freeing %s\n", dev->bid_name));
 175                         blkid_free_dev(dev);
 176                         cache->bic_flags |= BLKID_BIC_FL_CHANGED;
 177                 } else {
 178                         DBG(DEBUG_CACHE,
 179                             printf("Device %s exists\n", dev->bid_name));
 180                 }
 181         }
 182 }
 183
 184
 185 #ifdef TEST_PROGRAM
 186 int main(int argc, char** argv)
 187 {
 188         blkid_cache cache = NULL;
 189         int ret;
 190
 191         blkid_debug_mask = DEBUG_ALL;
 192         if ((argc > 2)) {
 193                 fprintf(stderr, "Usage: %s [filename] \n", argv[0]);
 194                 exit(1);
 195         }
 196
 197         if ((ret = blkid_get_cache(&cache, argv[1])) < 0) {
 198                 fprintf(stderr, "error %d parsing cache file %s\n", ret,
 199                         argv[1] ? argv[1] : BLKID_CACHE_FILE);
 200                 exit(1);
 201         }
 202         if ((ret = blkid_get_cache(&cache, "/dev/null")) != 0) {
 203                 fprintf(stderr, "%s: error creating cache (%d)\n",
 204                         argv[0], ret);
 205                 exit(1);
 206         }
 207         if ((ret = blkid_probe_all(cache) < 0))
 208                 fprintf(stderr, "error probing devices\n");
 209
 210         blkid_put_cache(cache);
 211
 212         return ret;
 213 }
 214 #endif