lib/blkid/tag.c

   1 /*
   2  * tag.c - allocation/initialization/free routines for tag structs
   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 #include <unistd.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <stdio.h>
  18
  19 #include "blkidP.h"
  20
  21 static blkid_tag blkid_new_tag(void)
  22 {
  23         blkid_tag tag;
  24
  25         if (!(tag = (blkid_tag) calloc(1, sizeof(struct blkid_struct_tag))))
  26                 return NULL;
  27
  28         INIT_LIST_HEAD(&tag->bit_tags);
  29         INIT_LIST_HEAD(&tag->bit_names);
  30
  31         return tag;
  32 }
  33
  34 #ifdef CONFIG_BLKID_DEBUG
  35 void blkid_debug_dump_tag(blkid_tag tag)
  36 {
  37         if (!tag) {
  38                 printf("    tag: NULL\n");
  39                 return;
  40         }
  41
  42         printf("    tag: %s=\"%s\"\n", tag->bit_name, tag->bit_val);
  43 }
  44 #endif
  45
  46 void blkid_free_tag(blkid_tag tag)
  47 {
  48         if (!tag)
  49                 return;
  50
  51         DBG(DEBUG_TAG, printf("    freeing tag %s=%s\n", tag->bit_name,
  52                    tag->bit_val ? tag->bit_val : "(NULL)"));
  53         DBG(DEBUG_TAG, blkid_debug_dump_tag(tag));
  54
  55         list_del(&tag->bit_tags);       /* list of tags for this device */
  56         list_del(&tag->bit_names);      /* list of tags with this type */
  57
  58         free(tag->bit_name);
  59         free(tag->bit_val);
  60
  61         free(tag);
  62 }
  63
  64 /*
  65  * Find the desired tag on a device.  If value is NULL, then the
  66  * first such tag is returned, otherwise return only exact tag if found.
  67  */
  68 blkid_tag blkid_find_tag_dev(blkid_dev dev, const char *type)
  69 {
  70         struct list_head *p;
  71
  72         if (!dev || !type)
  73                 return NULL;
  74
  75         list_for_each(p, &dev->bid_tags) {
  76                 blkid_tag tmp = list_entry(p, struct blkid_struct_tag,
  77                                            bit_tags);
  78
  79                 if (!strcmp(tmp->bit_name, type))
  80                         return tmp;
  81         }
  82         return NULL;
  83 }
  84
  85 extern int blkid_dev_has_tag(blkid_dev dev, const char *type,
  86                              const char *value)
  87 {
  88         blkid_tag               tag;
  89
  90         if (!dev || !type)
  91                 return -1;
  92
  93         tag = blkid_find_tag_dev(dev, type);
  94         if (!value)
  95                 return (tag != NULL);
  96         if (!tag || strcmp(tag->bit_val, value))
  97                 return 0;
  98         return 1;
  99 }
 100
 101 /*
 102  * Find the desired tag type in the cache.
 103  * We return the head tag for this tag type.
 104  */
 105 static blkid_tag blkid_find_head_cache(blkid_cache cache, const char *type)
 106 {
 107         blkid_tag head = NULL, tmp;
 108         struct list_head *p;
 109
 110         if (!cache || !type)
 111                 return NULL;
 112
 113         list_for_each(p, &cache->bic_tags) {
 114                 tmp = list_entry(p, struct blkid_struct_tag, bit_tags);
 115                 if (!strcmp(tmp->bit_name, type)) {
 116                         DBG(DEBUG_TAG,
 117                             printf("    found cache tag head %s\n", type));
 118                         head = tmp;
 119                         break;
 120                 }
 121         }
 122         return head;
 123 }
 124
 125 /*
 126  * Set a tag on an existing device.
 127  *
 128  * If value is NULL, then delete the tagsfrom the device.
 129  */
 130 int blkid_set_tag(blkid_dev dev, const char *name,
 131                   const char *value, const int vlength)
 132 {
 133         blkid_tag       t = 0, head = 0;
 134         char            *val = 0;
 135         char            **dev_var = 0;
 136
 137         if (!dev || !name)
 138                 return -BLKID_ERR_PARAM;
 139
 140         if (!(val = blkid_strndup(value, vlength)) && value)
 141                 return -BLKID_ERR_MEM;
 142
 143         /*
 144          * Certain common tags are linked directly to the device struct
 145          * We need to know what they are before we do anything else because
 146          * the function name parameter might get freed later on.
 147          */
 148         if (!strcmp(name, "TYPE"))
 149                 dev_var = &dev->bid_type;
 150         else if (!strcmp(name, "LABEL"))
 151                 dev_var = &dev->bid_label;
 152         else if (!strcmp(name, "UUID"))
 153                 dev_var = &dev->bid_uuid;
 154
 155         t = blkid_find_tag_dev(dev, name);
 156         if (!value) {
 157                 if (t)
 158                         blkid_free_tag(t);
 159         } else if (t) {
 160                 if (!strcmp(t->bit_val, val)) {
 161                         /* Same thing, exit */
 162                         free(val);
 163                         return 0;
 164                 }
 165                 free(t->bit_val);
 166                 t->bit_val = val;
 167         } else {
 168                 /* Existing tag not present, add to device */
 169                 if (!(t = blkid_new_tag()))
 170                         goto errout;
 171                 t->bit_name = blkid_strdup(name);
 172                 t->bit_val = val;
 173                 t->bit_dev = dev;
 174
 175                 list_add_tail(&t->bit_tags, &dev->bid_tags);
 176
 177                 if (dev->bid_cache) {
 178                         head = blkid_find_head_cache(dev->bid_cache,
 179                                                      t->bit_name);
 180                         if (!head) {
 181                                 head = blkid_new_tag();
 182                                 if (!head)
 183                                         goto errout;
 184
 185                                 DBG(DEBUG_TAG,
 186                                     printf("    creating new cache tag head %s\n", name));
 187                                 head->bit_name = blkid_strdup(name);
 188                                 if (!head->bit_name)
 189                                         goto errout;
 190                                 list_add_tail(&head->bit_tags,
 191                                               &dev->bid_cache->bic_tags);
 192                         }
 193                         list_add_tail(&t->bit_names, &head->bit_names);
 194                 }
 195         }
 196
 197         /* Link common tags directly to the device struct */
 198         if (dev_var)
 199                 *dev_var = val;
 200
 201         if (dev->bid_cache)
 202                 dev->bid_cache->bic_flags |= BLKID_BIC_FL_CHANGED;
 203         return 0;
 204
 205 errout:
 206         if (t)
 207                 blkid_free_tag(t);
 208         else free(val);
 209         if (head)
 210                 blkid_free_tag(head);
 211         return -BLKID_ERR_MEM;
 212 }
 213
 214
 215 /*
 216  * Parse a "NAME=value" string.  This is slightly different than
 217  * parse_token, because that will end an unquoted value at a space, while
 218  * this will assume that an unquoted value is the rest of the token (e.g.
 219  * if we are passed an already quoted string from the command-line we don't
 220  * have to both quote and escape quote so that the quotes make it to
 221  * us).
 222  *
 223  * Returns 0 on success, and -1 on failure.
 224  */
 225 int blkid_parse_tag_string(const char *token, char **ret_type, char **ret_val)
 226 {
 227         char *name, *value, *cp;
 228
 229         DBG(DEBUG_TAG, printf("trying to parse '%s' as a tag\n", token));
 230
 231         if (!token || !(cp = strchr(token, '=')))
 232                 return -1;
 233
 234         name = blkid_strdup(token);
 235         if (!name)
 236                 return -1;
 237         value = name + (cp - token);
 238         *value++ = '\0';
 239         if (*value == '"' || *value == '\'') {
 240                 char c = *value++;
 241                 if (!(cp = strrchr(value, c)))
 242                         goto errout; /* missing closing quote */
 243                 *cp = '\0';
 244         }
 245         value = blkid_strdup(value);
 246         if (!value)
 247                 goto errout;
 248
 249         *ret_type = name;
 250         *ret_val = value;
 251
 252         return 0;
 253
 254 errout:
 255         free(name);
 256         return -1;
 257 }
 258
 259 /*
 260  * Tag iteration routines for the public libblkid interface.
 261  *
 262  * These routines do not expose the list.h implementation, which are a
 263  * contamination of the namespace, and which force us to reveal far, far
 264  * too much of our internal implemenation.  I'm not convinced I want
 265  * to keep list.h in the long term, anyway.  It's fine for kernel
 266  * programming, but performance is not the #1 priority for this
 267  * library, and I really don't like the tradeoff of type-safety for
 268  * performance for this application.  [tytso:20030125.2007EST]
 269  */
 270
 271 /*
 272  * This series of functions iterate over all tags in a device
 273  */
 274 #define TAG_ITERATE_MAGIC       0x01a5284c
 275
 276 struct blkid_struct_tag_iterate {
 277         int                     magic;
 278         blkid_dev               dev;
 279         struct list_head        *p;
 280 };
 281
 282 extern blkid_tag_iterate blkid_tag_iterate_begin(blkid_dev dev)
 283 {
 284         blkid_tag_iterate       iter;
 285
 286         iter = malloc(sizeof(struct blkid_struct_tag_iterate));
 287         if (iter) {
 288                 iter->magic = TAG_ITERATE_MAGIC;
 289                 iter->dev = dev;
 290                 iter->p = dev->bid_tags.next;
 291         }
 292         return (iter);
 293 }
 294
 295 /*
 296  * Return 0 on success, -1 on error
 297  */
 298 extern int blkid_tag_next(blkid_tag_iterate iter,
 299                           const char **type, const char **value)
 300 {
 301         blkid_tag tag;
 302
 303         *type = 0;
 304         *value = 0;
 305         if (!iter || iter->magic != TAG_ITERATE_MAGIC ||
 306             iter->p == &iter->dev->bid_tags)
 307                 return -1;
 308         tag = list_entry(iter->p, struct blkid_struct_tag, bit_tags);
 309         *type = tag->bit_name;
 310         *value = tag->bit_val;
 311         iter->p = iter->p->next;
 312         return 0;
 313 }
 314
 315 extern void blkid_tag_iterate_end(blkid_tag_iterate iter)
 316 {
 317         if (!iter || iter->magic != TAG_ITERATE_MAGIC)
 318                 return;
 319         iter->magic = 0;
 320         free(iter);
 321 }
 322
 323 /*
 324  * This function returns a device which matches a particular
 325  * type/value pair.  If there is more than one device that matches the
 326  * search specification, it returns the one with the highest priority
 327  * value.  This allows us to give preference to EVMS or LVM devices.
 328  */
 329 extern blkid_dev blkid_find_dev_with_tag(blkid_cache cache,
 330                                          const char *type,
 331                                          const char *value)
 332 {
 333         blkid_tag       head;
 334         blkid_dev       dev;
 335         int             pri;
 336         struct list_head *p;
 337         int             probe_new = 0;
 338
 339         if (!cache || !type || !value)
 340                 return NULL;
 341
 342         blkid_read_cache(cache);
 343
 344         DBG(DEBUG_TAG, printf("looking for %s=%s in cache\n", type, value));
 345
 346 try_again:
 347         pri = -1;
 348         dev = 0;
 349         head = blkid_find_head_cache(cache, type);
 350
 351         if (head) {
 352                 list_for_each(p, &head->bit_names) {
 353                         blkid_tag tmp = list_entry(p, struct blkid_struct_tag,
 354                                                    bit_names);
 355
 356                         if (!strcmp(tmp->bit_val, value) &&
 357                             (tmp->bit_dev->bid_pri > pri) &&
 358                             !access(tmp->bit_dev->bid_name, F_OK)) {
 359                                 dev = tmp->bit_dev;
 360                                 pri = dev->bid_pri;
 361                         }
 362                 }
 363         }
 364         if (dev && !(dev->bid_flags & BLKID_BID_FL_VERIFIED)) {
 365                 dev = blkid_verify(cache, dev);
 366                 if (!dev || (dev && (dev->bid_flags & BLKID_BID_FL_VERIFIED)))
 367                         goto try_again;
 368         }
 369
 370         if (!dev && !probe_new) {
 371                 if (blkid_probe_all_new(cache) < 0)
 372                         return NULL;
 373                 probe_new++;
 374                 goto try_again;
 375         }
 376
 377         if (!dev && !(cache->bic_flags & BLKID_BIC_FL_PROBED)) {
 378                 if (blkid_probe_all(cache) < 0)
 379                         return NULL;
 380                 goto try_again;
 381         }
 382         return dev;
 383 }
 384
 385 #ifdef TEST_PROGRAM
 386 #ifdef HAVE_GETOPT_H
 387 #include <getopt.h>
 388 #else
 389 extern char *optarg;
 390 extern int optind;
 391 #endif
 392
 393 void usage(char *prog)
 394 {
 395         fprintf(stderr, "Usage: %s [-f blkid_file] [-m debug_mask] device "
 396                 "[type value]\n",
 397                 prog);
 398         fprintf(stderr, "\tList all tags for a device and exit\n");
 399         exit(1);
 400 }
 401
 402 int main(int argc, char **argv)
 403 {
 404         blkid_tag_iterate       iter;
 405         blkid_cache             cache = NULL;
 406         blkid_dev               dev;
 407         int                     c, ret, found;
 408         int                     flags = BLKID_DEV_FIND;
 409         char                    *tmp;
 410         char                    *file = NULL;
 411         char                    *devname = NULL;
 412         char                    *search_type = NULL;
 413         char                    *search_value = NULL;
 414         const char              *type, *value;
 415
 416         while ((c = getopt (argc, argv, "m:f:")) != EOF)
 417                 switch (c) {
 418                 case 'f':
 419                         file = optarg;
 420                         break;
 421                 case 'm':
 422                         blkid_debug_mask = strtoul (optarg, &tmp, 0);
 423                         if (*tmp) {
 424                                 fprintf(stderr, "Invalid debug mask: %s\n",
 425                                         optarg);
 426                                 exit(1);
 427                         }
 428                         break;
 429                 case '?':
 430                         usage(argv[0]);
 431                 }
 432         if (argc > optind)
 433                 devname = argv[optind++];
 434         if (argc > optind)
 435                 search_type = argv[optind++];
 436         if (argc > optind)
 437                 search_value = argv[optind++];
 438         if (!devname || (argc != optind))
 439                 usage(argv[0]);
 440
 441         if ((ret = blkid_get_cache(&cache, file)) != 0) {
 442                 fprintf(stderr, "%s: error creating cache (%d)\n",
 443                         argv[0], ret);
 444                 exit(1);
 445         }
 446
 447         dev = blkid_get_dev(cache, devname, flags);
 448         if (!dev) {
 449                 fprintf(stderr, "%s: Can not find device in blkid cache\n",
 450                         devname);
 451                 exit(1);
 452         }
 453         if (search_type) {
 454                 found = blkid_dev_has_tag(dev, search_type, search_value);
 455                 printf("Device %s: (%s, %s) %s\n", blkid_dev_devname(dev),
 456                        search_type, search_value ? search_value : "NULL",
 457                        found ? "FOUND" : "NOT FOUND");
 458                 return(!found);
 459         }
 460         printf("Device %s...\n", blkid_dev_devname(dev));
 461
 462         iter = blkid_tag_iterate_begin(dev);
 463         while (blkid_tag_next(iter, &type, &value) == 0) {
 464                 printf("\tTag %s has value %s\n", type, value);
 465         }
 466         blkid_tag_iterate_end(iter);
 467
 468         blkid_put_cache(cache);
 469         return (0);
 470 }
 471 #endif