lib/blkid/probe.c

   1 /*
   2  * probe.c - identify a block device by its contents, and return a dev
   3  *           struct with the details
   4  *
   5  * Copyright (C) 1999 by Andries Brouwer
   6  * Copyright (C) 1999, 2000, 2003 by Theodore Ts'o
   7  * Copyright (C) 2001 by Andreas Dilger
   8  * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
   9  *
  10  * %Begin-Header%
  11  * This file may be redistributed under the terms of the
  12  * GNU Lesser General Public License.
  13  * %End-Header%
  14  */
  15
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <fcntl.h>
  21 #include <sys/types.h>
  22 #ifdef HAVE_SYS_STAT_H
  23 #include <sys/stat.h>
  24 #endif
  25 #ifdef HAVE_SYS_MKDEV_H
  26 #include <sys/mkdev.h>
  27 #endif
  28 #ifdef HAVE_ERRNO_H
  29 #include <errno.h>
  30 #endif
  31 #include "blkidP.h"
  32 #include "uuid/uuid.h"
  33 #include "probe.h"
  34
  35 static int figure_label_len(const unsigned char *label, int len)
  36 {
  37         const unsigned char *end = label + len - 1;
  38
  39         while ((*end == ' ' || *end == 0) && end >= label)
  40                 --end;
  41         if (end >= label) {
  42                 label = label;
  43                 return end - label + 1;
  44         }
  45         return 0;
  46 }
  47
  48 static unsigned char *get_buffer(struct blkid_probe *pr,
  49                           blkid_loff_t off, size_t len)
  50 {
  51         ssize_t         ret_read;
  52         unsigned char   *newbuf;
  53
  54         if (off + len <= SB_BUFFER_SIZE) {
  55                 if (!pr->sbbuf) {
  56                         pr->sbbuf = malloc(SB_BUFFER_SIZE);
  57                         if (!pr->sbbuf)
  58                                 return NULL;
  59                         if (lseek(pr->fd, 0, SEEK_SET) < 0)
  60                                 return NULL;
  61                         ret_read = read(pr->fd, pr->sbbuf, SB_BUFFER_SIZE);
  62                         if (ret_read < 0)
  63                                 ret_read = 0;
  64                         pr->sb_valid = ret_read;
  65                 }
  66                 if (off+len > pr->sb_valid)
  67                         return NULL;
  68                 return pr->sbbuf + off;
  69         } else {
  70                 if (len > pr->buf_max) {
  71                         newbuf = realloc(pr->buf, len);
  72                         if (newbuf == NULL)
  73                                 return NULL;
  74                         pr->buf = newbuf;
  75                         pr->buf_max = len;
  76                 }
  77                 if (blkid_llseek(pr->fd, off, SEEK_SET) < 0)
  78                         return NULL;
  79                 ret_read = read(pr->fd, pr->buf, len);
  80                 if (ret_read != (ssize_t) len)
  81                         return NULL;
  82                 return pr->buf;
  83         }
  84 }
  85
  86
  87 /*
  88  * This is a special case code to check for an MDRAID device.  We do
  89  * this special since it requires checking for a superblock at the end
  90  * of the device.
  91  */
  92 static int check_mdraid(int fd, unsigned char *ret_uuid)
  93 {
  94         struct mdp_superblock_s *md;
  95         blkid_loff_t            offset;
  96         char                    buf[4096];
  97
  98         if (fd < 0)
  99                 return -BLKID_ERR_PARAM;
 100
 101         offset = (blkid_get_dev_size(fd) & ~((blkid_loff_t)65535)) - 65536;
 102
 103         if (blkid_llseek(fd, offset, 0) < 0 ||
 104             read(fd, buf, 4096) != 4096)
 105                 return -BLKID_ERR_IO;
 106
 107         /* Check for magic number */
 108         if (memcmp("\251+N\374", buf, 4) && memcmp("\374N+\251", buf, 4))
 109                 return -BLKID_ERR_PARAM;
 110
 111         if (!ret_uuid)
 112                 return 0;
 113         *ret_uuid = 0;
 114
 115         /* The MD UUID is not contiguous in the superblock, make it so */
 116         md = (struct mdp_superblock_s *)buf;
 117         if (md->set_uuid0 || md->set_uuid1 || md->set_uuid2 || md->set_uuid3) {
 118                 memcpy(ret_uuid, &md->set_uuid0, 4);
 119                 memcpy(ret_uuid + 4, &md->set_uuid1, 12);
 120         }
 121         return 0;
 122 }
 123
 124 static void set_uuid(blkid_dev dev, uuid_t uuid, char *tag)
 125 {
 126         char    str[37];
 127
 128         if (!uuid_is_null(uuid)) {
 129                 uuid_unparse(uuid, str);
 130                 blkid_set_tag(dev, tag ? tag : "UUID", str, sizeof(str));
 131         }
 132 }
 133
 134 static void get_ext2_info(blkid_dev dev, unsigned char *buf)
 135 {
 136         struct ext2_super_block *es = (struct ext2_super_block *) buf;
 137         const char *label = 0;
 138
 139         DBG(DEBUG_PROBE, printf("ext2_sb.compat = %08X:%08X:%08X\n",
 140                    blkid_le32(es->s_feature_compat),
 141                    blkid_le32(es->s_feature_incompat),
 142                    blkid_le32(es->s_feature_ro_compat)));
 143
 144         if (strlen(es->s_volume_name))
 145                 label = es->s_volume_name;
 146         blkid_set_tag(dev, "LABEL", label, sizeof(es->s_volume_name));
 147
 148         set_uuid(dev, es->s_uuid, 0);
 149 }
 150
 151 static int probe_ext3(struct blkid_probe *probe,
 152                       struct blkid_magic *id __BLKID_ATTR((unused)),
 153                       unsigned char *buf)
 154 {
 155         struct ext2_super_block *es;
 156         es = (struct ext2_super_block *)buf;
 157
 158         /* Distinguish between jbd and ext2/3 fs */
 159         if (blkid_le32(es->s_feature_incompat) &
 160             EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)
 161                 return -BLKID_ERR_PARAM;
 162
 163         /* Distinguish between ext3 and ext2 */
 164         if (!(blkid_le32(es->s_feature_compat) &
 165               EXT3_FEATURE_COMPAT_HAS_JOURNAL))
 166                 return -BLKID_ERR_PARAM;
 167
 168         get_ext2_info(probe->dev, buf);
 169
 170         if ((es->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
 171             !uuid_is_null(es->s_journal_uuid))
 172                 set_uuid(probe->dev, es->s_journal_uuid, "EXT_JOURNAL");
 173
 174         blkid_set_tag(probe->dev, "SEC_TYPE", "ext2", sizeof("ext2"));
 175
 176         return 0;
 177 }
 178
 179 static int probe_ext2(struct blkid_probe *probe,
 180                       struct blkid_magic *id __BLKID_ATTR((unused)),
 181                       unsigned char *buf)
 182 {
 183         struct ext2_super_block *es;
 184
 185         es = (struct ext2_super_block *)buf;
 186
 187         /* Distinguish between jbd and ext2/3 fs */
 188         if (blkid_le32(es->s_feature_incompat) &
 189             EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)
 190                 return -BLKID_ERR_PARAM;
 191
 192         /* Distinguish between ext3 and ext2 */
 193         if ((blkid_le32(es->s_feature_compat) &
 194               EXT3_FEATURE_COMPAT_HAS_JOURNAL))
 195                 return -BLKID_ERR_PARAM;
 196
 197         get_ext2_info(probe->dev, buf);
 198
 199         return 0;
 200 }
 201
 202 static int probe_jbd(struct blkid_probe *probe,
 203                      struct blkid_magic *id __BLKID_ATTR((unused)),
 204                      unsigned char *buf)
 205 {
 206         struct ext2_super_block *es = (struct ext2_super_block *) buf;
 207
 208         if (!(blkid_le32(es->s_feature_incompat) &
 209               EXT3_FEATURE_INCOMPAT_JOURNAL_DEV))
 210                 return -BLKID_ERR_PARAM;
 211
 212         get_ext2_info(probe->dev, buf);
 213
 214         return 0;
 215 }
 216
 217 #define FAT_ATTR_VOLUME_ID              0x08
 218 #define FAT_ATTR_DIR                    0x10
 219 #define FAT_ATTR_LONG_NAME              0x0f
 220 #define FAT_ATTR_MASK                   0x3f
 221 #define FAT_ENTRY_FREE                  0xe5
 222
 223 static char *no_name = "NO NAME    ";
 224
 225 static unsigned char *search_fat_label(struct vfat_dir_entry *dir, int count)
 226 {
 227         int i;
 228
 229         for (i = 0; i < count; i++) {
 230                 if (dir[i].name[0] == 0x00)
 231                         break;
 232
 233                 if ((dir[i].name[0] == FAT_ENTRY_FREE) ||
 234                     (dir[i].cluster_high != 0 || dir[i].cluster_low != 0) ||
 235                     ((dir[i].attr & FAT_ATTR_MASK) == FAT_ATTR_LONG_NAME))
 236                         continue;
 237
 238                 if ((dir[i].attr & (FAT_ATTR_VOLUME_ID | FAT_ATTR_DIR)) ==
 239                     FAT_ATTR_VOLUME_ID) {
 240                         return dir[i].name;
 241                 }
 242         }
 243         return 0;
 244 }
 245
 246 /* FAT label extraction from the root directory taken from Kay
 247  * Sievers's volume_id library */
 248 static int probe_fat(struct blkid_probe *probe,
 249                       struct blkid_magic *id __BLKID_ATTR((unused)),
 250                       unsigned char *buf)
 251 {
 252         struct vfat_super_block *vs = (struct vfat_super_block *) buf;
 253         struct msdos_super_block *ms = (struct msdos_super_block *) buf;
 254         struct vfat_dir_entry *dir;
 255         char serno[10];
 256         const unsigned char *label = 0, *vol_label = 0, *tmp;
 257         unsigned char   *vol_serno;
 258         int label_len = 0, maxloop = 100;
 259         __u16 sector_size, dir_entries, reserved;
 260         __u32 sect_count, fat_size, dir_size, cluster_count, fat_length;
 261         __u32 buf_size, start_data_sect, next, root_start, root_dir_entries;
 262
 263         /* sector size check */
 264         tmp = (unsigned char *)&ms->ms_sector_size;
 265         sector_size = tmp[0] + (tmp[1] << 8);
 266         if (sector_size != 0x200 && sector_size != 0x400 &&
 267             sector_size != 0x800 && sector_size != 0x1000)
 268                 return 1;
 269
 270         tmp = (unsigned char *)&ms->ms_dir_entries;
 271         dir_entries = tmp[0] + (tmp[1] << 8);
 272         reserved =  blkid_le16(ms->ms_reserved);
 273         tmp = (unsigned char *)&ms->ms_sectors;
 274         sect_count = tmp[0] + (tmp[1] << 8);
 275         if (sect_count == 0)
 276                 sect_count = blkid_le32(ms->ms_total_sect);
 277
 278         fat_length = blkid_le16(ms->ms_fat_length);
 279         if (fat_length == 0)
 280                 fat_length = blkid_le32(vs->vs_fat32_length);
 281
 282         fat_size = fat_length * ms->ms_fats;
 283         dir_size = ((dir_entries * sizeof(struct vfat_dir_entry)) +
 284                         (sector_size-1)) / sector_size;
 285
 286         cluster_count = sect_count - (reserved + fat_size + dir_size);
 287         cluster_count /= ms->ms_cluster_size;
 288
 289         if (cluster_count > FAT32_MAX)
 290                 return 1;
 291
 292         if (ms->ms_fat_length) {
 293                 /* the label may be an attribute in the root directory */
 294                 root_start = (reserved + fat_size) * sector_size;
 295                 root_dir_entries = vs->vs_dir_entries[0] +
 296                         (vs->vs_dir_entries[1] << 8);
 297
 298                 buf_size = root_dir_entries * sizeof(struct vfat_dir_entry);
 299                 dir = (struct vfat_dir_entry *) get_buffer(probe, root_start,
 300                                                            buf_size);
 301                 if (dir)
 302                         vol_label = search_fat_label(dir, root_dir_entries);
 303
 304                 if (!vol_label || !memcmp(vol_label, no_name, 11))
 305                         vol_label = ms->ms_label;
 306                 vol_serno = ms->ms_serno;
 307
 308                 blkid_set_tag(probe->dev, "SEC_TYPE", "msdos",
 309                               sizeof("msdos"));
 310         } else {
 311                 /* Search the FAT32 root dir for the label attribute */
 312                 buf_size = vs->vs_cluster_size * sector_size;
 313                 start_data_sect = reserved + fat_size;
 314
 315                 next = blkid_le32(vs->vs_root_cluster);
 316                 while (next && --maxloop) {
 317                         __u32 next_sect_off;
 318                         __u64 next_off, fat_entry_off;
 319                         int count;
 320
 321                         next_sect_off = (next - 2) * vs->vs_cluster_size;
 322                         next_off = (start_data_sect + next_sect_off) *
 323                                 sector_size;
 324
 325                         dir = (struct vfat_dir_entry *)
 326                                 get_buffer(probe, next_off, buf_size);
 327                         if (dir == NULL)
 328                                 break;
 329
 330                         count = buf_size / sizeof(struct vfat_dir_entry);
 331
 332                         vol_label = search_fat_label(dir, count);
 333                         if (vol_label)
 334                                 break;
 335
 336                         /* get FAT entry */
 337                         fat_entry_off = (reserved * sector_size) +
 338                                 (next * sizeof(__u32));
 339                         buf = get_buffer(probe, fat_entry_off, buf_size);
 340                         if (buf == NULL)
 341                                 break;
 342
 343                         /* set next cluster */
 344                         next = blkid_le32(*((__u32 *) buf) & 0x0fffffff);
 345                 }
 346
 347                 if (!vol_label || !memcmp(vol_label, no_name, 11))
 348                         vol_label = vs->vs_label;
 349                 vol_serno = vs->vs_serno;
 350         }
 351
 352         if (vol_label && memcmp(vol_label, no_name, 11)) {
 353                 if ((label_len = figure_label_len(vol_label, 11)))
 354                         label = vol_label;
 355         }
 356
 357         /* We can't just print them as %04X, because they are unaligned */
 358         sprintf(serno, "%02X%02X-%02X%02X", vol_serno[3], vol_serno[2],
 359                 vol_serno[1], vol_serno[0]);
 360
 361         blkid_set_tag(probe->dev, "LABEL", (const char *) label, label_len);
 362         blkid_set_tag(probe->dev, "UUID", serno, sizeof(serno)-1);
 363
 364         return 0;
 365 }
 366
 367 /*
 368  * The FAT filesystem could be without a magic string in superblock
 369  * (e.g. old floppies).  This heuristic for FAT detection is inspired
 370  * by http://vrfy.org/projects/volume_id/ and Linux kernel.
 371  * [7-Jul-2005, Karel Zak <kzak@redhat.com>]
 372  */
 373 static int probe_fat_nomagic(struct blkid_probe *probe,
 374                              struct blkid_magic *id __BLKID_ATTR((unused)),
 375                              unsigned char *buf)
 376 {
 377         struct vfat_super_block *vs;
 378
 379         vs = (struct vfat_super_block *)buf;
 380
 381         /* heads check */
 382         if (vs->vs_heads == 0)
 383                 return 1;
 384
 385         /* cluster size check*/
 386         if (vs->vs_cluster_size == 0 ||
 387             (vs->vs_cluster_size & (vs->vs_cluster_size-1)))
 388                 return 1;
 389
 390         /* media check */
 391         if (vs->vs_media < 0xf8 && vs->vs_media != 0xf0)
 392                 return 1;
 393
 394         /* fat counts(Linux kernel expects at least 1 FAT table) */
 395         if (!vs->vs_fats)
 396                 return 1;
 397
 398         return probe_fat(probe, id, buf);
 399 }
 400
 401 static int probe_ntfs(struct blkid_probe *probe,
 402                       struct blkid_magic *id __BLKID_ATTR((unused)),
 403                       unsigned char *buf)
 404 {
 405         struct ntfs_super_block *ns;
 406         struct master_file_table_record *mft;
 407         struct file_attribute *attr;
 408         char            uuid_str[17], label_str[129], *cp;
 409         int             bytes_per_sector, sectors_per_cluster;
 410         int             mft_record_size, attr_off, attr_len;
 411         unsigned int    i, attr_type, val_len;
 412         int             val_off;
 413         __u64           nr_clusters;
 414         blkid_loff_t off;
 415         unsigned char *buf_mft, *val;
 416
 417         ns = (struct ntfs_super_block *) buf;
 418
 419         bytes_per_sector = ns->bios_parameter_block[0] +
 420                 (ns->bios_parameter_block[1]  << 8);
 421         sectors_per_cluster = ns->bios_parameter_block[2];
 422
 423         if ((bytes_per_sector < 512) || (sectors_per_cluster == 0))
 424                 return 1;
 425
 426         if (ns->cluster_per_mft_record < 0)
 427                 mft_record_size = 1 << (0-ns->cluster_per_mft_record);
 428         else
 429                 mft_record_size = ns->cluster_per_mft_record *
 430                         sectors_per_cluster * bytes_per_sector;
 431         nr_clusters = blkid_le64(ns->number_of_sectors) / sectors_per_cluster;
 432
 433         if ((blkid_le64(ns->mft_cluster_location) > nr_clusters) ||
 434             (blkid_le64(ns->mft_mirror_cluster_location) > nr_clusters))
 435                 return 1;
 436
 437         off = blkid_le64(ns->mft_mirror_cluster_location) *
 438                 bytes_per_sector * sectors_per_cluster;
 439
 440         buf_mft = get_buffer(probe, off, mft_record_size);
 441         if (!buf_mft)
 442                 return 1;
 443
 444         if (memcmp(buf_mft, "FILE", 4))
 445                 return 1;
 446
 447         off = blkid_le64(ns->mft_cluster_location) * bytes_per_sector *
 448                 sectors_per_cluster;
 449
 450         buf_mft = get_buffer(probe, off, mft_record_size);
 451         if (!buf_mft)
 452                 return 1;
 453
 454         if (memcmp(buf_mft, "FILE", 4))
 455                 return 1;
 456
 457         off += MFT_RECORD_VOLUME * mft_record_size;
 458
 459         buf_mft = get_buffer(probe, off, mft_record_size);
 460         if (!buf_mft)
 461                 return 1;
 462
 463         if (memcmp(buf_mft, "FILE", 4))
 464                 return 1;
 465
 466         mft = (struct master_file_table_record *) buf_mft;
 467
 468         attr_off = blkid_le16(mft->attrs_offset);
 469         label_str[0] = 0;
 470
 471         while (1) {
 472                 attr = (struct file_attribute *) (buf_mft + attr_off);
 473                 attr_len = blkid_le16(attr->len);
 474                 attr_type = blkid_le32(attr->type);
 475                 val_off = blkid_le16(attr->value_offset);
 476                 val_len = blkid_le32(attr->value_len);
 477
 478                 attr_off += attr_len;
 479
 480                 if ((attr_off > mft_record_size) ||
 481                     (attr_len == 0))
 482                         break;
 483
 484                 if (attr_type == MFT_RECORD_ATTR_END)
 485                         break;
 486
 487                 if (attr_type == MFT_RECORD_ATTR_VOLUME_NAME) {
 488                         if (val_len > sizeof(label_str))
 489                                 val_len = sizeof(label_str)-1;
 490
 491                         for (i=0, cp=label_str; i < val_len; i+=2,cp++) {
 492                                 val = ((__u8 *) attr) + val_off + i;
 493                                 *cp = val[0];
 494                                 if (val[1])
 495                                         *cp = '?';
 496                         }
 497                         *cp = 0;
 498                 }
 499         }
 500
 501         sprintf(uuid_str, "%llX", blkid_le64(ns->volume_serial));
 502         blkid_set_tag(probe->dev, "UUID", uuid_str, 0);
 503         if (label_str[0])
 504                 blkid_set_tag(probe->dev, "LABEL", label_str, 0);
 505         return 0;
 506 }
 507
 508
 509 static int probe_xfs(struct blkid_probe *probe,
 510                      struct blkid_magic *id __BLKID_ATTR((unused)),
 511                      unsigned char *buf)
 512 {
 513         struct xfs_super_block *xs;
 514         const char *label = 0;
 515
 516         xs = (struct xfs_super_block *)buf;
 517
 518         if (strlen(xs->xs_fname))
 519                 label = xs->xs_fname;
 520         blkid_set_tag(probe->dev, "LABEL", label, sizeof(xs->xs_fname));
 521         set_uuid(probe->dev, xs->xs_uuid, 0);
 522         return 0;
 523 }
 524
 525 static int probe_reiserfs(struct blkid_probe *probe,
 526                           struct blkid_magic *id, unsigned char *buf)
 527 {
 528         struct reiserfs_super_block *rs = (struct reiserfs_super_block *) buf;
 529         unsigned int blocksize;
 530         const char *label = 0;
 531
 532         blocksize = blkid_le16(rs->rs_blocksize);
 533
 534         /* If the superblock is inside the journal, we have the wrong one */
 535         if (id->bim_kboff/(blocksize>>10) > blkid_le32(rs->rs_journal_block))
 536                 return -BLKID_ERR_BIG;
 537
 538         /* LABEL/UUID are only valid for later versions of Reiserfs v3.6. */
 539         if (id->bim_magic[6] == '2' || id->bim_magic[6] == '3') {
 540                 if (strlen(rs->rs_label))
 541                         label = rs->rs_label;
 542                 set_uuid(probe->dev, rs->rs_uuid, 0);
 543         }
 544         blkid_set_tag(probe->dev, "LABEL", label, sizeof(rs->rs_label));
 545
 546         return 0;
 547 }
 548
 549 static int probe_reiserfs4(struct blkid_probe *probe,
 550                            struct blkid_magic *id __BLKID_ATTR((unused)),
 551                            unsigned char *buf)
 552 {
 553         struct reiser4_super_block *rs4 = (struct reiser4_super_block *) buf;
 554         const unsigned char *label = 0;
 555
 556         if (strlen((char *) rs4->rs4_label))
 557                 label = rs4->rs4_label;
 558         set_uuid(probe->dev, rs4->rs4_uuid, 0);
 559         blkid_set_tag(probe->dev, "LABEL", (const char *) label,
 560                       sizeof(rs4->rs4_label));
 561
 562         return 0;
 563 }
 564
 565 static int probe_jfs(struct blkid_probe *probe,
 566                      struct blkid_magic *id __BLKID_ATTR((unused)),
 567                      unsigned char *buf)
 568 {
 569         struct jfs_super_block *js;
 570         const char *label = 0;
 571
 572         js = (struct jfs_super_block *)buf;
 573
 574         if (strlen((char *) js->js_label))
 575                 label = (char *) js->js_label;
 576         blkid_set_tag(probe->dev, "LABEL", label, sizeof(js->js_label));
 577         set_uuid(probe->dev, js->js_uuid, 0);
 578         return 0;
 579 }
 580
 581 static int probe_luks(struct blkid_probe *probe,
 582                        struct blkid_magic *id __BLKID_ATTR((unused)),
 583                        unsigned char *buf)
 584 {
 585         unsigned char uuid[40];
 586         /* 168 is the offset to the 40 character uuid:
 587          * http://luks.endorphin.org/LUKS-on-disk-format.pdf */
 588         strncpy(uuid, buf+168, 40);
 589         blkid_set_tag(probe->dev, "UUID", uuid, sizeof(uuid));
 590         return 0;
 591 }
 592
 593 static int probe_romfs(struct blkid_probe *probe,
 594                        struct blkid_magic *id __BLKID_ATTR((unused)),
 595                        unsigned char *buf)
 596 {
 597         struct romfs_super_block *ros;
 598         const char *label = 0;
 599
 600         ros = (struct romfs_super_block *)buf;
 601
 602         if (strlen((char *) ros->ros_volume))
 603                 label = (char *) ros->ros_volume;
 604         blkid_set_tag(probe->dev, "LABEL", label, 0);
 605         return 0;
 606 }
 607
 608 static int probe_cramfs(struct blkid_probe *probe,
 609                         struct blkid_magic *id __BLKID_ATTR((unused)),
 610                         unsigned char *buf)
 611 {
 612         struct cramfs_super_block *csb;
 613         const char *label = 0;
 614
 615         csb = (struct cramfs_super_block *)buf;
 616
 617         if (strlen((char *) csb->name))
 618                 label = (char *) csb->name;
 619         blkid_set_tag(probe->dev, "LABEL", label, 0);
 620         return 0;
 621 }
 622
 623 static int probe_swap0(struct blkid_probe *probe,
 624                        struct blkid_magic *id __BLKID_ATTR((unused)),
 625                        unsigned char *buf __BLKID_ATTR((unused)))
 626 {
 627         blkid_set_tag(probe->dev, "UUID", 0, 0);
 628         blkid_set_tag(probe->dev, "LABEL", 0, 0);
 629         return 0;
 630 }
 631
 632 static int probe_swap1(struct blkid_probe *probe,
 633                        struct blkid_magic *id __BLKID_ATTR((unused)),
 634                        unsigned char *buf __BLKID_ATTR((unused)))
 635 {
 636         struct swap_id_block *sws;
 637
 638         probe_swap0(probe, id, buf);
 639         /*
 640          * Version 1 swap headers are always located at offset of 1024
 641          * bytes, although the swap signature itself is located at the
 642          * end of the page (which may vary depending on hardware
 643          * pagesize).
 644          */
 645         sws = (struct swap_id_block *) get_buffer(probe, 1024, 1024);
 646         if (!sws)
 647                 return 1;
 648
 649         /* arbitrary sanity check.. is there any garbage down there? */
 650         if (sws->sws_pad[32] == 0 && sws->sws_pad[33] == 0)  {
 651                 if (sws->sws_volume[0])
 652                         blkid_set_tag(probe->dev, "LABEL", sws->sws_volume,
 653                                       sizeof(sws->sws_volume));
 654                 if (sws->sws_uuid[0])
 655                         set_uuid(probe->dev, sws->sws_uuid, 0);
 656         }
 657         return 0;
 658 }
 659
 660 static int probe_iso9660(struct blkid_probe *probe,
 661                          struct blkid_magic *id __BLKID_ATTR((unused)),
 662                          unsigned char *buf)
 663 {
 664         struct iso_volume_descriptor *iso;
 665         const unsigned char *label;
 666
 667         iso = (struct iso_volume_descriptor *) buf;
 668         label = iso->volume_id;
 669
 670         blkid_set_tag(probe->dev, "LABEL", (const char *) label,
 671                       figure_label_len(label, 32));
 672         return 0;
 673 }
 674
 675
 676 static const char
 677 *udf_magic[] = { "BEA01", "BOOT2", "CD001", "CDW02", "NSR02",
 678                  "NSR03", "TEA01", 0 };
 679
 680 static int probe_udf(struct blkid_probe *probe,
 681                      struct blkid_magic *id __BLKID_ATTR((unused)),
 682                      unsigned char *buf __BLKID_ATTR((unused)))
 683 {
 684         int j, bs;
 685         struct iso_volume_descriptor *isosb;
 686         const char ** m;
 687
 688         /* determine the block size by scanning in 2K increments
 689            (block sizes larger than 2K will be null padded) */
 690         for (bs = 1; bs < 16; bs++) {
 691                 isosb = (struct iso_volume_descriptor *)
 692                         get_buffer(probe, bs*2048+32768, sizeof(isosb));
 693                 if (!isosb)
 694                         return 1;
 695                 if (isosb->vd_id[0])
 696                         break;
 697         }
 698
 699         /* Scan up to another 64 blocks looking for additional VSD's */
 700         for (j = 1; j < 64; j++) {
 701                 if (j > 1) {
 702                         isosb = (struct iso_volume_descriptor *)
 703                                 get_buffer(probe, j*bs*2048+32768,
 704                                            sizeof(isosb));
 705                         if (!isosb)
 706                                 return 1;
 707                 }
 708                 /* If we find NSR0x then call it udf:
 709                    NSR01 for UDF 1.00
 710                    NSR02 for UDF 1.50
 711                    NSR03 for UDF 2.00 */
 712                 if (!memcmp(isosb->vd_id, "NSR0", 4))
 713                         return 0;
 714                 for (m = udf_magic; *m; m++)
 715                         if (!memcmp(*m, isosb->vd_id, 5))
 716                                 break;
 717                 if (*m == 0)
 718                         return 1;
 719         }
 720         return 1;
 721 }
 722
 723 static int probe_ocfs(struct blkid_probe *probe,
 724                       struct blkid_magic *id __BLKID_ATTR((unused)),
 725                       unsigned char *buf)
 726 {
 727         struct ocfs_volume_header ovh;
 728         struct ocfs_volume_label ovl;
 729         __u32 major;
 730
 731         memcpy(&ovh, buf, sizeof(ovh));
 732         memcpy(&ovl, buf+512, sizeof(ovl));
 733
 734         major = ocfsmajor(ovh);
 735         if (major == 1)
 736                 blkid_set_tag(probe->dev,"SEC_TYPE","ocfs1",sizeof("ocfs1"));
 737         else if (major >= 9)
 738                 blkid_set_tag(probe->dev,"SEC_TYPE","ntocfs",sizeof("ntocfs"));
 739
 740         blkid_set_tag(probe->dev, "LABEL", ovl.label, ocfslabellen(ovl));
 741         blkid_set_tag(probe->dev, "MOUNT", ovh.mount, ocfsmountlen(ovh));
 742         set_uuid(probe->dev, ovl.vol_id, 0);
 743         return 0;
 744 }
 745
 746 static int probe_ocfs2(struct blkid_probe *probe,
 747                        struct blkid_magic *id __BLKID_ATTR((unused)),
 748                        unsigned char *buf)
 749 {
 750         struct ocfs2_super_block *osb;
 751
 752         osb = (struct ocfs2_super_block *)buf;
 753
 754         blkid_set_tag(probe->dev, "LABEL", osb->s_label, sizeof(osb->s_label));
 755         set_uuid(probe->dev, osb->s_uuid, 0);
 756         return 0;
 757 }
 758
 759 static int probe_oracleasm(struct blkid_probe *probe,
 760                            struct blkid_magic *id __BLKID_ATTR((unused)),
 761                            unsigned char *buf)
 762 {
 763         struct oracle_asm_disk_label *dl;
 764
 765         dl = (struct oracle_asm_disk_label *)buf;
 766
 767         blkid_set_tag(probe->dev, "LABEL", dl->dl_id, sizeof(dl->dl_id));
 768         return 0;
 769 }
 770
 771 static int probe_gfs(struct blkid_probe *probe,
 772                      struct blkid_magic *id __BLKID_ATTR((unused)),
 773                      unsigned char *buf)
 774 {
 775         struct gfs2_sb *sbd;
 776         const char *label = 0;
 777
 778         sbd = (struct gfs2_sb *)buf;
 779
 780         if (blkid_be32(sbd->sb_fs_format) == GFS_FORMAT_FS &&
 781             blkid_be32(sbd->sb_multihost_format) == GFS_FORMAT_MULTI)
 782         {
 783                 blkid_set_tag(probe->dev, "UUID", 0, 0);
 784
 785                 if (strlen(sbd->sb_locktable))
 786                         label = sbd->sb_locktable;
 787                 blkid_set_tag(probe->dev, "LABEL", label, sizeof(sbd->sb_locktable));
 788                 return 0;
 789         }
 790         return 1;
 791 }
 792
 793 static int probe_gfs2(struct blkid_probe *probe,
 794                      struct blkid_magic *id __BLKID_ATTR((unused)),
 795                      unsigned char *buf)
 796 {
 797         struct gfs2_sb *sbd;
 798         const char *label = 0;
 799
 800         sbd = (struct gfs2_sb *)buf;
 801
 802         if (blkid_be32(sbd->sb_fs_format) == GFS2_FORMAT_FS &&
 803             blkid_be32(sbd->sb_multihost_format) == GFS2_FORMAT_MULTI)
 804         {
 805                 blkid_set_tag(probe->dev, "UUID", 0, 0);
 806
 807                 if (strlen(sbd->sb_locktable))
 808                         label = sbd->sb_locktable;
 809                 blkid_set_tag(probe->dev, "LABEL", label, sizeof(sbd->sb_locktable));
 810                 return 0;
 811         }
 812         return 1;
 813 }
 814
 815 /*
 816  * BLKID_BLK_OFFS is at least as large as the highest bim_kboff defined
 817  * in the type_array table below + bim_kbalign.
 818  *
 819  * When probing for a lot of magics, we handle everything in 1kB buffers so
 820  * that we don't have to worry about reading each combination of block sizes.
 821  */
 822 #define BLKID_BLK_OFFS  64      /* currently reiserfs */
 823
 824 /*
 825  * Various filesystem magics that we can check for.  Note that kboff and
 826  * sboff are in kilobytes and bytes respectively.  All magics are in
 827  * byte strings so we don't worry about endian issues.
 828  */
 829 static struct blkid_magic type_array[] = {
 830 /*  type     kboff   sboff len  magic                   probe */
 831   { "oracleasm", 0,     32,  8, "ORCLDISK",             probe_oracleasm },
 832   { "ntfs",      0,      3,  8, "NTFS    ",             probe_ntfs },
 833   { "jbd",       1,   0x38,  2, "\123\357",             probe_jbd },
 834   { "ext3",      1,   0x38,  2, "\123\357",             probe_ext3 },
 835   { "ext2",      1,   0x38,  2, "\123\357",             probe_ext2 },
 836   { "reiserfs",  8,   0x34,  8, "ReIsErFs",             probe_reiserfs },
 837   { "reiserfs", 64,   0x34,  9, "ReIsEr2Fs",            probe_reiserfs },
 838   { "reiserfs", 64,   0x34,  9, "ReIsEr3Fs",            probe_reiserfs },
 839   { "reiserfs", 64,   0x34,  8, "ReIsErFs",             probe_reiserfs },
 840   { "reiserfs",  8,     20,  8, "ReIsErFs",             probe_reiserfs },
 841   { "reiser4",  64,      0,  7, "ReIsEr4",              probe_reiserfs4 },
 842   { "gfs2",     64,      0,  4, "\x01\x16\x19\x70",     probe_gfs2 },
 843   { "gfs",      64,      0,  4, "\x01\x16\x19\x70",     probe_gfs },
 844   { "vfat",      0,   0x52,  5, "MSWIN",                probe_fat },
 845   { "vfat",      0,   0x52,  8, "FAT32   ",             probe_fat },
 846   { "vfat",      0,   0x36,  5, "MSDOS",                probe_fat },
 847   { "vfat",      0,   0x36,  8, "FAT16   ",             probe_fat },
 848   { "vfat",      0,   0x36,  8, "FAT12   ",             probe_fat },
 849   { "vfat",      0,      0,  2, "\353\220",             probe_fat_nomagic },
 850   { "vfat",      0,      0,  1, "\351",                 probe_fat_nomagic },
 851   { "minix",     1,   0x10,  2, "\177\023",             0 },
 852   { "minix",     1,   0x10,  2, "\217\023",             0 },
 853   { "minix",     1,   0x10,  2, "\150\044",             0 },
 854   { "minix",     1,   0x10,  2, "\170\044",             0 },
 855   { "vxfs",      1,      0,  4, "\365\374\001\245",     0 },
 856   { "xfs",       0,      0,  4, "XFSB",                 probe_xfs },
 857   { "romfs",     0,      0,  8, "-rom1fs-",             probe_romfs },
 858   { "bfs",       0,      0,  4, "\316\372\173\033",     0 },
 859   { "cramfs",    0,      0,  4, "E=\315\050",           probe_cramfs },
 860   { "qnx4",      0,      4,  6, "QNX4FS",               0 },
 861   { "udf",      32,      1,  5, "BEA01",                probe_udf },
 862   { "udf",      32,      1,  5, "BOOT2",                probe_udf },
 863   { "udf",      32,      1,  5, "CD001",                probe_udf },
 864   { "udf",      32,      1,  5, "CDW02",                probe_udf },
 865   { "udf",      32,      1,  5, "NSR02",                probe_udf },
 866   { "udf",      32,      1,  5, "NSR03",                probe_udf },
 867   { "udf",      32,      1,  5, "TEA01",                probe_udf },
 868   { "iso9660",  32,      1,  5, "CD001",                probe_iso9660 },
 869   { "iso9660",  32,      9,  5, "CDROM",                probe_iso9660 },
 870   { "jfs",      32,      0,  4, "JFS1",                 probe_jfs },
 871   { "hfs",       1,      0,  2, "BD",                   0 },
 872   { "ufs",       8,  0x55c,  4, "T\031\001\000",        0 },
 873   { "hpfs",      8,      0,  4, "I\350\225\371",        0 },
 874   { "sysv",      0,  0x3f8,  4, "\020~\030\375",        0 },
 875   { "swap",      0,  0xff6, 10, "SWAP-SPACE",           probe_swap0 },
 876   { "swap",      0,  0xff6, 10, "SWAPSPACE2",           probe_swap1 },
 877   { "swsuspend", 0,  0xff6,  9, "S1SUSPEND",            probe_swap1 },
 878   { "swsuspend", 0,  0xff6,  9, "S2SUSPEND",            probe_swap1 },
 879   { "swap",      0, 0x1ff6, 10, "SWAP-SPACE",           probe_swap0 },
 880   { "swap",      0, 0x1ff6, 10, "SWAPSPACE2",           probe_swap1 },
 881   { "swsuspend", 0, 0x1ff6,  9, "S1SUSPEND",            probe_swap1 },
 882   { "swsuspend", 0, 0x1ff6,  9, "S2SUSPEND",            probe_swap1 },
 883   { "swap",      0, 0x3ff6, 10, "SWAP-SPACE",           probe_swap0 },
 884   { "swap",      0, 0x3ff6, 10, "SWAPSPACE2",           probe_swap1 },
 885   { "swsuspend", 0, 0x3ff6,  9, "S1SUSPEND",            probe_swap1 },
 886   { "swsuspend", 0, 0x3ff6,  9, "S2SUSPEND",            probe_swap1 },
 887   { "swap",      0, 0x7ff6, 10, "SWAP-SPACE",           probe_swap0 },
 888   { "swap",      0, 0x7ff6, 10, "SWAPSPACE2",           probe_swap1 },
 889   { "swsuspend", 0, 0x7ff6,  9, "S1SUSPEND",            probe_swap1 },
 890   { "swsuspend", 0, 0x7ff6,  9, "S2SUSPEND",            probe_swap1 },
 891   { "swap",      0, 0xfff6, 10, "SWAP-SPACE",           probe_swap0 },
 892   { "swap",      0, 0xfff6, 10, "SWAPSPACE2",           probe_swap1 },
 893   { "swsuspend", 0, 0xfff6,  9, "S1SUSPEND",            probe_swap1 },
 894   { "swsuspend", 0, 0xfff6,  9, "S2SUSPEND",            probe_swap1 },
 895   { "ocfs",      0,      8,  9, "OracleCFS",            probe_ocfs },
 896   { "ocfs2",     1,      0,  6, "OCFSV2",               probe_ocfs2 },
 897   { "ocfs2",     2,      0,  6, "OCFSV2",               probe_ocfs2 },
 898   { "ocfs2",     4,      0,  6, "OCFSV2",               probe_ocfs2 },
 899   { "ocfs2",     8,      0,  6, "OCFSV2",               probe_ocfs2 },
 900   { "crypt_LUKS", 0,     0,  6, "LUKS\xba\xbe",         probe_luks },
 901   {   NULL,      0,      0,  0, NULL,                   NULL }
 902 };
 903
 904 /*
 905  * Verify that the data in dev is consistent with what is on the actual
 906  * block device (using the devname field only).  Normally this will be
 907  * called when finding items in the cache, but for long running processes
 908  * is also desirable to revalidate an item before use.
 909  *
 910  * If we are unable to revalidate the data, we return the old data and
 911  * do not set the BLKID_BID_FL_VERIFIED flag on it.
 912  */
 913 blkid_dev blkid_verify(blkid_cache cache, blkid_dev dev)
 914 {
 915         struct blkid_magic *id;
 916         struct blkid_probe probe;
 917         blkid_tag_iterate iter;
 918         unsigned char *buf;
 919         const char *type, *value;
 920         struct stat st;
 921         time_t diff, now;
 922         int idx;
 923
 924         if (!dev)
 925                 return NULL;
 926
 927         now = time(0);
 928         diff = now - dev->bid_time;
 929
 930         if ((now > dev->bid_time) && (diff > 0) &&
 931             ((diff < BLKID_PROBE_MIN) ||
 932              (dev->bid_flags & BLKID_BID_FL_VERIFIED &&
 933               diff < BLKID_PROBE_INTERVAL)))
 934                 return dev;
 935
 936         DBG(DEBUG_PROBE,
 937             printf("need to revalidate %s (time since last check %llu)\n",
 938                    dev->bid_name, (unsigned long long)diff));
 939
 940         if (((probe.fd = open(dev->bid_name, O_RDONLY)) < 0) ||
 941             (fstat(probe.fd, &st) < 0)) {
 942                 if (probe.fd >= 0) close(probe.fd);
 943                 if (errno == ENXIO || errno == ENODEV || errno == ENOENT) {
 944                         blkid_free_dev(dev);
 945                         return NULL;
 946                 }
 947                 /* We don't have read permission, just return cache data. */
 948                 DBG(DEBUG_PROBE,
 949                     printf("returning unverified data for %s\n",
 950                            dev->bid_name));
 951                 return dev;
 952         }
 953
 954         probe.cache = cache;
 955         probe.dev = dev;
 956         probe.sbbuf = 0;
 957         probe.buf = 0;
 958         probe.buf_max = 0;
 959
 960         /*
 961          * Iterate over the type array.  If we already know the type,
 962          * then try that first.  If it doesn't work, then blow away
 963          * the type information, and try again.
 964          *
 965          */
 966 try_again:
 967         type = 0;
 968         if (!dev->bid_type || !strcmp(dev->bid_type, "mdraid")) {
 969                 uuid_t  uuid;
 970
 971                 if (check_mdraid(probe.fd, uuid) == 0) {
 972                         set_uuid(dev, uuid, 0);
 973                         type = "mdraid";
 974                         goto found_type;
 975                 }
 976         }
 977         for (id = type_array; id->bim_type; id++) {
 978                 if (dev->bid_type &&
 979                     strcmp(id->bim_type, dev->bid_type))
 980                         continue;
 981
 982                 idx = id->bim_kboff + (id->bim_sboff >> 10);
 983                 buf = get_buffer(&probe, idx << 10, 1024);
 984                 if (!buf)
 985                         continue;
 986
 987                 if (memcmp(id->bim_magic, buf + (id->bim_sboff&0x3ff),
 988                            id->bim_len))
 989                         continue;
 990
 991                 if ((id->bim_probe == NULL) ||
 992                     (id->bim_probe(&probe, id, buf) == 0)) {
 993                         type = id->bim_type;
 994                         goto found_type;
 995                 }
 996         }
 997
 998         if (!id->bim_type && dev->bid_type) {
 999                 /*
1000                  * Zap the device filesystem information and try again
1001                  */
1002                 iter = blkid_tag_iterate_begin(dev);
1003                 while (blkid_tag_next(iter, &type, &value) == 0)
1004                         blkid_set_tag(dev, type, 0, 0);
1005                 blkid_tag_iterate_end(iter);
1006                 goto try_again;
1007         }
1008
1009         if (!dev->bid_type) {
1010                 blkid_free_dev(dev);
1011                 dev = 0;
1012                 goto found_type;
1013         }
1014
1015 found_type:
1016         if (dev && type) {
1017                 dev->bid_devno = st.st_rdev;
1018                 dev->bid_time = time(0);
1019                 dev->bid_flags |= BLKID_BID_FL_VERIFIED;
1020                 cache->bic_flags |= BLKID_BIC_FL_CHANGED;
1021
1022                 blkid_set_tag(dev, "TYPE", type, 0);
1023
1024                 DBG(DEBUG_PROBE, printf("%s: devno 0x%04llx, type %s\n",
1025                            dev->bid_name, (long long)st.st_rdev, type));
1026         }
1027
1028         if (probe.sbbuf)
1029                 free(probe.sbbuf);
1030         if (probe.buf)
1031                 free(probe.buf);
1032         if (probe.fd >= 0)
1033                 close(probe.fd);
1034
1035         return dev;
1036 }
1037
1038 int blkid_known_fstype(const char *fstype)
1039 {
1040         struct blkid_magic *id;
1041
1042         for (id = type_array; id->bim_type; id++) {
1043                 if (strcmp(fstype, id->bim_type) == 0)
1044                         return 1;
1045         }
1046         return 0;
1047 }
1048
1049 #ifdef TEST_PROGRAM
1050 int main(int argc, char **argv)
1051 {
1052         blkid_dev dev;
1053         blkid_cache cache;
1054         int ret;
1055
1056         if (argc != 2) {
1057                 fprintf(stderr, "Usage: %s device\n"
1058                         "Probe a single device to determine type\n", argv[0]);
1059                 exit(1);
1060         }
1061         if ((ret = blkid_get_cache(&cache, "/dev/null")) != 0) {
1062                 fprintf(stderr, "%s: error creating cache (%d)\n",
1063                         argv[0], ret);
1064                 exit(1);
1065         }
1066         dev = blkid_get_dev(cache, argv[1], BLKID_DEV_NORMAL);
1067         if (!dev) {
1068                 printf("%s: %s has an unsupported type\n", argv[0], argv[1]);
1069                 return (1);
1070         }
1071         printf("TYPE='%s'\n", dev->bid_type ? dev->bid_type : "(null)");
1072         if (dev->bid_label)
1073                 printf("LABEL='%s'\n", dev->bid_label);
1074         if (dev->bid_uuid)
1075                 printf("UUID='%s'\n", dev->bid_uuid);
1076
1077         blkid_free_dev(dev);
1078         return (0);
1079 }
1080 #endif