fs/udf.c

   1 /* udf.c - Universal Disk Format filesystem.  */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2008  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/err.h>
  21 #include <grub/file.h>
  22 #include <grub/mm.h>
  23 #include <grub/misc.h>
  24 #include <grub/disk.h>
  25 #include <grub/dl.h>
  26 #include <grub/types.h>
  27 #include <grub/fshelp.h>
  28
  29 #define GRUB_UDF_MAX_PDS                2
  30 #define GRUB_UDF_MAX_PMS                6
  31
  32 #define U16                             grub_le_to_cpu16
  33 #define U32                             grub_le_to_cpu32
  34 #define U64                             grub_le_to_cpu64
  35
  36 #define GRUB_UDF_LOG2_BLKSZ             2
  37 #define GRUB_UDF_BLKSZ                  2048
  38
  39 #define GRUB_UDF_TAG_IDENT_PVD          0x0001
  40 #define GRUB_UDF_TAG_IDENT_AVDP         0x0002
  41 #define GRUB_UDF_TAG_IDENT_VDP          0x0003
  42 #define GRUB_UDF_TAG_IDENT_IUVD         0x0004
  43 #define GRUB_UDF_TAG_IDENT_PD           0x0005
  44 #define GRUB_UDF_TAG_IDENT_LVD          0x0006
  45 #define GRUB_UDF_TAG_IDENT_USD          0x0007
  46 #define GRUB_UDF_TAG_IDENT_TD           0x0008
  47 #define GRUB_UDF_TAG_IDENT_LVID         0x0009
  48
  49 #define GRUB_UDF_TAG_IDENT_FSD          0x0100
  50 #define GRUB_UDF_TAG_IDENT_FID          0x0101
  51 #define GRUB_UDF_TAG_IDENT_AED          0x0102
  52 #define GRUB_UDF_TAG_IDENT_IE           0x0103
  53 #define GRUB_UDF_TAG_IDENT_TE           0x0104
  54 #define GRUB_UDF_TAG_IDENT_FE           0x0105
  55 #define GRUB_UDF_TAG_IDENT_EAHD         0x0106
  56 #define GRUB_UDF_TAG_IDENT_USE          0x0107
  57 #define GRUB_UDF_TAG_IDENT_SBD          0x0108
  58 #define GRUB_UDF_TAG_IDENT_PIE          0x0109
  59 #define GRUB_UDF_TAG_IDENT_EFE          0x010A
  60
  61 #define GRUB_UDF_ICBTAG_TYPE_UNDEF      0x00
  62 #define GRUB_UDF_ICBTAG_TYPE_USE        0x01
  63 #define GRUB_UDF_ICBTAG_TYPE_PIE        0x02
  64 #define GRUB_UDF_ICBTAG_TYPE_IE         0x03
  65 #define GRUB_UDF_ICBTAG_TYPE_DIRECTORY  0x04
  66 #define GRUB_UDF_ICBTAG_TYPE_REGULAR    0x05
  67 #define GRUB_UDF_ICBTAG_TYPE_BLOCK      0x06
  68 #define GRUB_UDF_ICBTAG_TYPE_CHAR       0x07
  69 #define GRUB_UDF_ICBTAG_TYPE_EA         0x08
  70 #define GRUB_UDF_ICBTAG_TYPE_FIFO       0x09
  71 #define GRUB_UDF_ICBTAG_TYPE_SOCKET     0x0A
  72 #define GRUB_UDF_ICBTAG_TYPE_TE         0x0B
  73 #define GRUB_UDF_ICBTAG_TYPE_SYMLINK    0x0C
  74 #define GRUB_UDF_ICBTAG_TYPE_STREAMDIR  0x0D
  75
  76 #define GRUB_UDF_ICBTAG_FLAG_AD_MASK    0x0007
  77 #define GRUB_UDF_ICBTAG_FLAG_AD_SHORT   0x0000
  78 #define GRUB_UDF_ICBTAG_FLAG_AD_LONG    0x0001
  79 #define GRUB_UDF_ICBTAG_FLAG_AD_EXT     0x0002
  80 #define GRUB_UDF_ICBTAG_FLAG_AD_IN_ICB  0x0003
  81
  82 #define GRUB_UDF_EXT_NORMAL             0x00000000
  83 #define GRUB_UDF_EXT_NREC_ALLOC         0x40000000
  84 #define GRUB_UDF_EXT_NREC_NALLOC        0x80000000
  85 #define GRUB_UDF_EXT_MASK               0xC0000000
  86
  87 #define GRUB_UDF_FID_CHAR_HIDDEN        0x01
  88 #define GRUB_UDF_FID_CHAR_DIRECTORY     0x02
  89 #define GRUB_UDF_FID_CHAR_DELETED       0x04
  90 #define GRUB_UDF_FID_CHAR_PARENT        0x08
  91 #define GRUB_UDF_FID_CHAR_METADATA      0x10
  92
  93 #define GRUB_UDF_STD_IDENT_BEA01        "BEA01"
  94 #define GRUB_UDF_STD_IDENT_BOOT2        "BOOT2"
  95 #define GRUB_UDF_STD_IDENT_CD001        "CD001"
  96 #define GRUB_UDF_STD_IDENT_CDW02        "CDW02"
  97 #define GRUB_UDF_STD_IDENT_NSR02        "NSR02"
  98 #define GRUB_UDF_STD_IDENT_NSR03        "NSR03"
  99 #define GRUB_UDF_STD_IDENT_TEA01        "TEA01"
 100
 101 #define GRUB_UDF_CHARSPEC_TYPE_CS0      0x00
 102 #define GRUB_UDF_CHARSPEC_TYPE_CS1      0x01
 103 #define GRUB_UDF_CHARSPEC_TYPE_CS2      0x02
 104 #define GRUB_UDF_CHARSPEC_TYPE_CS3      0x03
 105 #define GRUB_UDF_CHARSPEC_TYPE_CS4      0x04
 106 #define GRUB_UDF_CHARSPEC_TYPE_CS5      0x05
 107 #define GRUB_UDF_CHARSPEC_TYPE_CS6      0x06
 108 #define GRUB_UDF_CHARSPEC_TYPE_CS7      0x07
 109 #define GRUB_UDF_CHARSPEC_TYPE_CS8      0x08
 110
 111 #define GRUB_UDF_PARTMAP_TYPE_1         1
 112 #define GRUB_UDF_PARTMAP_TYPE_2         2
 113
 114 struct grub_udf_lb_addr
 115 {
 116   grub_uint32_t block_num;
 117   grub_uint16_t part_ref;
 118 } __attribute__ ((packed));
 119
 120 struct grub_udf_short_ad
 121 {
 122   grub_uint32_t length;
 123   grub_uint32_t position;
 124 } __attribute__ ((packed));
 125
 126 struct grub_udf_long_ad
 127 {
 128   grub_uint32_t length;
 129   struct grub_udf_lb_addr block;
 130   grub_uint8_t imp_use[6];
 131 } __attribute__ ((packed));
 132
 133 struct grub_udf_extent_ad
 134 {
 135   grub_uint32_t length;
 136   grub_uint32_t start;
 137 } __attribute__ ((packed));
 138
 139 struct grub_udf_charspec
 140 {
 141   grub_uint8_t charset_type;
 142   grub_uint8_t charset_info[63];
 143 } __attribute__ ((packed));
 144
 145 struct grub_udf_timestamp
 146 {
 147   grub_uint16_t type_and_timezone;
 148   grub_uint16_t year;
 149   grub_uint8_t month;
 150   grub_uint8_t day;
 151   grub_uint8_t hour;
 152   grub_uint8_t minute;
 153   grub_uint8_t second;
 154   grub_uint8_t centi_seconds;
 155   grub_uint8_t hundreds_of_micro_seconds;
 156   grub_uint8_t micro_seconds;
 157 } __attribute__ ((packed));
 158
 159 struct grub_udf_regid
 160 {
 161   grub_uint8_t flags;
 162   grub_uint8_t ident[23];
 163   grub_uint8_t ident_suffix[8];
 164 } __attribute__ ((packed));
 165
 166 struct grub_udf_tag
 167 {
 168   grub_uint16_t tag_ident;
 169   grub_uint16_t desc_version;
 170   grub_uint8_t tag_checksum;
 171   grub_uint8_t reserved;
 172   grub_uint16_t tag_serial_number;
 173   grub_uint16_t desc_crc;
 174   grub_uint16_t desc_crc_length;
 175   grub_uint32_t tag_location;
 176 } __attribute__ ((packed));
 177
 178 struct grub_udf_fileset
 179 {
 180   struct grub_udf_tag tag;
 181   struct grub_udf_timestamp datetime;
 182   grub_uint16_t interchange_level;
 183   grub_uint16_t max_interchange_level;
 184   grub_uint32_t charset_list;
 185   grub_uint32_t max_charset_list;
 186   grub_uint32_t fileset_num;
 187   grub_uint32_t fileset_desc_num;
 188   struct grub_udf_charspec vol_charset;
 189   grub_uint8_t vol_ident[128];
 190   struct grub_udf_charspec fileset_charset;
 191   grub_uint8_t fileset_ident[32];
 192   grub_uint8_t copyright_file_ident[32];
 193   grub_uint8_t abstract_file_ident[32];
 194   struct grub_udf_long_ad root_icb;
 195   struct grub_udf_regid domain_ident;
 196   struct grub_udf_long_ad next_ext;
 197   struct grub_udf_long_ad streamdir_icb;
 198 } __attribute__ ((packed));
 199
 200 struct grub_udf_icbtag
 201 {
 202   grub_uint32_t prior_recorded_num_direct_entries;
 203   grub_uint16_t strategy_type;
 204   grub_uint16_t strategy_parameter;
 205   grub_uint16_t num_entries;
 206   grub_uint8_t reserved;
 207   grub_uint8_t file_type;
 208   struct grub_udf_lb_addr parent_idb;
 209   grub_uint16_t flags;
 210 } __attribute__ ((packed));
 211
 212 struct grub_udf_file_ident
 213 {
 214   struct grub_udf_tag tag;
 215   grub_uint16_t version_num;
 216   grub_uint8_t characteristics;
 217   grub_uint8_t file_ident_length;
 218   struct grub_udf_long_ad icb;
 219   grub_uint16_t imp_use_length;
 220 } __attribute__ ((packed));
 221
 222 struct grub_udf_file_entry
 223 {
 224   struct grub_udf_tag tag;
 225   struct grub_udf_icbtag icbtag;
 226   grub_uint32_t uid;
 227   grub_uint32_t gid;
 228   grub_uint32_t permissions;
 229   grub_uint16_t link_count;
 230   grub_uint8_t record_format;
 231   grub_uint8_t record_display_attr;
 232   grub_uint32_t record_length;
 233   grub_uint64_t file_size;
 234   grub_uint64_t blocks_recorded;
 235   struct grub_udf_timestamp access_time;
 236   struct grub_udf_timestamp modification_time;
 237   struct grub_udf_timestamp attr_time;
 238   grub_uint32_t checkpoint;
 239   struct grub_udf_long_ad extended_attr_idb;
 240   struct grub_udf_regid imp_ident;
 241   grub_uint64_t unique_id;
 242   grub_uint32_t ext_attr_length;
 243   grub_uint32_t alloc_descs_length;
 244   grub_uint8_t ext_attr[1872];
 245 } __attribute__ ((packed));
 246
 247 struct grub_udf_extended_file_entry
 248 {
 249   struct grub_udf_tag tag;
 250   struct grub_udf_icbtag icbtag;
 251   grub_uint32_t uid;
 252   grub_uint32_t gid;
 253   grub_uint32_t permissions;
 254   grub_uint16_t link_count;
 255   grub_uint8_t record_format;
 256   grub_uint8_t record_display_attr;
 257   grub_uint32_t record_length;
 258   grub_uint64_t file_size;
 259   grub_uint64_t object_size;
 260   grub_uint64_t blocks_recorded;
 261   struct grub_udf_timestamp access_time;
 262   struct grub_udf_timestamp modification_time;
 263   struct grub_udf_timestamp create_time;
 264   struct grub_udf_timestamp attr_time;
 265   grub_uint32_t checkpoint;
 266   grub_uint32_t reserved;
 267   struct grub_udf_long_ad extended_attr_icb;
 268   struct grub_udf_long_ad streamdir_icb;
 269   struct grub_udf_regid imp_ident;
 270   grub_uint64_t unique_id;
 271   grub_uint32_t ext_attr_length;
 272   grub_uint32_t alloc_descs_length;
 273   grub_uint8_t ext_attr[1832];
 274 } __attribute__ ((packed));
 275
 276 struct grub_udf_vrs
 277 {
 278   grub_uint8_t type;
 279   grub_uint8_t magic[5];
 280   grub_uint8_t version;
 281 } __attribute__ ((packed));
 282
 283 struct grub_udf_avdp
 284 {
 285   struct grub_udf_tag tag;
 286   struct grub_udf_extent_ad vds;
 287 } __attribute__ ((packed));
 288
 289 struct grub_udf_pd
 290 {
 291   struct grub_udf_tag tag;
 292   grub_uint32_t seq_num;
 293   grub_uint16_t flags;
 294   grub_uint16_t part_num;
 295   struct grub_udf_regid contents;
 296   grub_uint8_t contents_use[128];
 297   grub_uint32_t access_type;
 298   grub_uint32_t start;
 299   grub_uint32_t length;
 300 } __attribute__ ((packed));
 301
 302 struct grub_udf_partmap
 303 {
 304   grub_uint8_t type;
 305   grub_uint8_t length;
 306   union
 307   {
 308     struct
 309     {
 310       grub_uint16_t seq_num;
 311       grub_uint16_t part_num;
 312     } type1;
 313
 314     struct
 315     {
 316       grub_uint8_t ident[62];
 317     } type2;
 318   };
 319 };
 320
 321 struct grub_udf_lvd
 322 {
 323   struct grub_udf_tag tag;
 324   grub_uint32_t seq_num;
 325   struct grub_udf_charspec charset;
 326   grub_uint8_t ident[128];
 327   grub_uint32_t bsize;
 328   struct grub_udf_regid domain_ident;
 329   struct grub_udf_long_ad root_fileset;
 330   grub_uint32_t map_table_length;
 331   grub_uint32_t num_part_maps;
 332   struct grub_udf_regid imp_ident;
 333   grub_uint8_t imp_use[128];
 334   struct grub_udf_extent_ad integrity_seq_ext;
 335   grub_uint8_t part_maps[1608];
 336 } __attribute__ ((packed));
 337
 338 struct grub_udf_data
 339 {
 340   grub_disk_t disk;
 341   struct grub_udf_lvd lvd;
 342   struct grub_udf_pd pds[GRUB_UDF_MAX_PDS];
 343   struct grub_udf_partmap *pms[GRUB_UDF_MAX_PMS];
 344   struct grub_udf_long_ad root_icb;
 345   int npd, npm;
 346 };
 347
 348 struct grub_fshelp_node
 349 {
 350   struct grub_udf_data *data;
 351   union
 352   {
 353     struct grub_udf_file_entry fe;
 354     struct grub_udf_extended_file_entry efe;
 355   };
 356   int part_ref;
 357 };
 358
 359 static grub_dl_t my_mod;
 360
 361 static grub_uint32_t
 362 grub_udf_get_block (struct grub_udf_data *data,
 363                     grub_uint16_t part_ref, grub_uint32_t block)
 364 {
 365   part_ref = U16 (part_ref);
 366
 367   if (part_ref >= data->npm)
 368     {
 369       grub_error (GRUB_ERR_BAD_FS, "invalid part ref");
 370       return 0;
 371     }
 372
 373   return (U32 (data->pds[data->pms[part_ref]->type1.part_num].start)
 374           + U32 (block));
 375 }
 376
 377 static grub_err_t
 378 grub_udf_read_icb (struct grub_udf_data *data,
 379                    struct grub_udf_long_ad *icb,
 380                    struct grub_fshelp_node *node)
 381 {
 382   grub_uint32_t block;
 383
 384   block = grub_udf_get_block (data,
 385                               icb->block.part_ref,
 386                               icb->block.block_num);
 387
 388   if (grub_errno)
 389     return grub_errno;
 390
 391   if (grub_disk_read (data->disk, block << GRUB_UDF_LOG2_BLKSZ, 0,
 392                       sizeof (struct grub_udf_file_entry),
 393                       &node->fe))
 394     return grub_errno;
 395
 396   if ((U16 (node->fe.tag.tag_ident) != GRUB_UDF_TAG_IDENT_FE) &&
 397       (U16 (node->fe.tag.tag_ident) != GRUB_UDF_TAG_IDENT_EFE))
 398     return grub_error (GRUB_ERR_BAD_FS, "invalid fe/efe descriptor");
 399
 400   node->part_ref = icb->block.part_ref;
 401   node->data = data;
 402   return 0;
 403 }
 404
 405 static grub_disk_addr_t
 406 grub_udf_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
 407 {
 408   char *ptr;
 409   int len;
 410
 411   if (U16 (node->fe.tag.tag_ident) == GRUB_UDF_TAG_IDENT_FE)
 412     {
 413       ptr = (char *) &node->fe.ext_attr[0] + U32 (node->fe.ext_attr_length);
 414       len = U32 (node->fe.alloc_descs_length);
 415     }
 416   else
 417     {
 418       ptr = (char *) &node->efe.ext_attr[0] + U32 (node->efe.ext_attr_length);
 419       len = U32 (node->efe.alloc_descs_length);
 420     }
 421
 422   if ((U16 (node->fe.icbtag.flags) & GRUB_UDF_ICBTAG_FLAG_AD_MASK)
 423       == GRUB_UDF_ICBTAG_FLAG_AD_SHORT)
 424     {
 425       struct grub_udf_short_ad *ad = (struct grub_udf_short_ad *) ptr;
 426
 427       len /= sizeof (struct grub_udf_short_ad);
 428       while (len > 0)
 429         {
 430           if (fileblock < U32 (ad->length))
 431             return ((U32 (ad->position) & GRUB_UDF_EXT_MASK) ? 0 :
 432                     (grub_udf_get_block (node->data,
 433                                          node->part_ref,
 434                                          ad->position)
 435                      + fileblock));
 436
 437           fileblock -= U32 (ad->length);
 438           ad++;
 439           len--;
 440         }
 441     }
 442   else
 443     {
 444       struct grub_udf_long_ad *ad = (struct grub_udf_long_ad *) ptr;
 445
 446       len /= sizeof (struct grub_udf_long_ad);
 447       while (len > 0)
 448         {
 449           if (fileblock < U32 (ad->length))
 450             return ((U32 (ad->block.block_num) & GRUB_UDF_EXT_MASK) ?  0 :
 451                     (grub_udf_get_block (node->data,
 452                                          ad->block.part_ref,
 453                                          ad->block.block_num)
 454                     + fileblock));
 455
 456           fileblock -= U32 (ad->length);
 457           ad++;
 458           len--;
 459         }
 460     }
 461
 462   return 0;
 463 }
 464
 465 static grub_ssize_t
 466 grub_udf_read_file (grub_fshelp_node_t node,
 467                     void NESTED_FUNC_ATTR
 468                     (*read_hook) (grub_disk_addr_t sector,
 469                                   unsigned offset, unsigned length),
 470                     int pos, grub_size_t len, char *buf)
 471 {
 472   switch (U16 (node->fe.icbtag.flags) & GRUB_UDF_ICBTAG_FLAG_AD_MASK)
 473     {
 474     case GRUB_UDF_ICBTAG_FLAG_AD_IN_ICB:
 475       {
 476         char *ptr;
 477
 478         ptr = ((U16 (node->fe.tag.tag_ident) == GRUB_UDF_TAG_IDENT_FE) ?
 479                ((char *) &node->fe.ext_attr[0]
 480                 + U32 (node->fe.ext_attr_length)) :
 481                ((char *) &node->efe.ext_attr[0]
 482                 + U32 (node->efe.ext_attr_length)));
 483
 484         grub_memcpy (buf, ptr + pos, len);
 485
 486         return len;
 487       }
 488
 489     case GRUB_UDF_ICBTAG_FLAG_AD_EXT:
 490       grub_error (GRUB_ERR_BAD_FS, "invalid extent type");
 491       return 0;
 492     }
 493
 494   return  grub_fshelp_read_file (node->data->disk, node, read_hook,
 495                                  pos, len, buf, grub_udf_read_block,
 496                                  U64 (node->fe.file_size),
 497                                  GRUB_UDF_LOG2_BLKSZ);
 498 }
 499
 500 static int sblocklist[] = { 256, 512, 0 };
 501
 502 static struct grub_udf_data *
 503 grub_udf_mount (grub_disk_t disk)
 504 {
 505   struct grub_udf_data *data = 0;
 506   struct grub_udf_fileset root_fs;
 507   int *sblklist = sblocklist;
 508   grub_uint32_t block;
 509   int i;
 510
 511   data = grub_malloc (sizeof (struct grub_udf_data));
 512   if (!data)
 513     return 0;
 514
 515   data->disk = disk;
 516
 517   /* Search for Volume Recognition Sequence (VRS).  */
 518   for (block = 16;; block++)
 519     {
 520       struct grub_udf_vrs vrs;
 521
 522       if (grub_disk_read (disk, block << GRUB_UDF_LOG2_BLKSZ, 0,
 523                           sizeof (struct grub_udf_vrs), &vrs))
 524         {
 525           grub_error (GRUB_ERR_BAD_FS, "not an udf filesystem");
 526           goto fail;
 527         }
 528
 529       if ((!grub_memcmp (vrs.magic, GRUB_UDF_STD_IDENT_NSR03, 5)) ||
 530           (!grub_memcmp (vrs.magic, GRUB_UDF_STD_IDENT_NSR02, 5)))
 531         break;
 532
 533       if ((grub_memcmp (vrs.magic, GRUB_UDF_STD_IDENT_BEA01, 5)) &&
 534           (grub_memcmp (vrs.magic, GRUB_UDF_STD_IDENT_BOOT2, 5)) &&
 535           (grub_memcmp (vrs.magic, GRUB_UDF_STD_IDENT_CD001, 5)) &&
 536           (grub_memcmp (vrs.magic, GRUB_UDF_STD_IDENT_CDW02, 5)) &&
 537           (grub_memcmp (vrs.magic, GRUB_UDF_STD_IDENT_TEA01, 5)))
 538         {
 539           grub_error (GRUB_ERR_BAD_FS, "not an udf filesystem");
 540           goto fail;
 541         }
 542     }
 543
 544   /* Search for Anchor Volume Descriptor Pointer (AVDP).  */
 545   while (1)
 546     {
 547       struct grub_udf_avdp avdp;
 548
 549       if (grub_disk_read (disk, *sblklist << GRUB_UDF_LOG2_BLKSZ, 0,
 550                           sizeof (struct grub_udf_avdp), &avdp))
 551         {
 552           grub_error (GRUB_ERR_BAD_FS, "not an udf filesystem");
 553           goto fail;
 554         }
 555
 556       if (U16 (avdp.tag.tag_ident) == GRUB_UDF_TAG_IDENT_AVDP)
 557         {
 558           block = U32 (avdp.vds.start);
 559           break;
 560         }
 561
 562       sblklist++;
 563       if (*sblklist == 0)
 564         {
 565           grub_error (GRUB_ERR_BAD_FS, "not an udf filesystem");
 566           goto fail;
 567         }
 568     }
 569
 570   data->npd = data->npm = 0;
 571   /* Locate Partition Descriptor (PD) and Logical Volume Descriptor (LVD).  */
 572   while (1)
 573     {
 574       struct grub_udf_tag tag;
 575
 576       if (grub_disk_read (disk, block << GRUB_UDF_LOG2_BLKSZ, 0,
 577                           sizeof (struct grub_udf_tag), &tag))
 578         {
 579           grub_error (GRUB_ERR_BAD_FS, "not an udf filesystem");
 580           goto fail;
 581         }
 582
 583       tag.tag_ident = U16 (tag.tag_ident);
 584       if (tag.tag_ident == GRUB_UDF_TAG_IDENT_PD)
 585         {
 586           if (data->npd >= GRUB_UDF_MAX_PDS)
 587             {
 588               grub_error (GRUB_ERR_BAD_FS, "too many PDs");
 589               goto fail;
 590             }
 591
 592           if (grub_disk_read (disk, block << GRUB_UDF_LOG2_BLKSZ, 0,
 593                               sizeof (struct grub_udf_pd),
 594                               &data->pds[data->npd]))
 595             {
 596               grub_error (GRUB_ERR_BAD_FS, "not an udf filesystem");
 597               goto fail;
 598             }
 599
 600           data->npd++;
 601         }
 602       else if (tag.tag_ident == GRUB_UDF_TAG_IDENT_LVD)
 603         {
 604           int k;
 605
 606           struct grub_udf_partmap *ppm;
 607
 608           if (grub_disk_read (disk, block << GRUB_UDF_LOG2_BLKSZ, 0,
 609                               sizeof (struct grub_udf_lvd),
 610                               &data->lvd))
 611             {
 612               grub_error (GRUB_ERR_BAD_FS, "not an udf filesystem");
 613               goto fail;
 614             }
 615
 616           if (data->npm + U32 (data->lvd.num_part_maps) > GRUB_UDF_MAX_PMS)
 617             {
 618               grub_error (GRUB_ERR_BAD_FS, "too many partition maps");
 619               goto fail;
 620             }
 621
 622           ppm = (struct grub_udf_partmap *) &data->lvd.part_maps;
 623           for (k = U32 (data->lvd.num_part_maps); k > 0; k--)
 624             {
 625               if (ppm->type != GRUB_UDF_PARTMAP_TYPE_1)
 626                 {
 627                   grub_error (GRUB_ERR_BAD_FS, "partmap type not supported");
 628                   goto fail;
 629                 }
 630
 631               data->pms[data->npm++] = ppm;
 632               ppm = (struct grub_udf_partmap *) ((char *) ppm +
 633                                                  U32 (ppm->length));
 634             }
 635         }
 636       else if (tag.tag_ident > GRUB_UDF_TAG_IDENT_TD)
 637         {
 638           grub_error (GRUB_ERR_BAD_FS, "invalid tag ident");
 639           goto fail;
 640         }
 641       else if (tag.tag_ident == GRUB_UDF_TAG_IDENT_TD)
 642         break;
 643
 644       block++;
 645     }
 646
 647   for (i = 0; i < data->npm; i++)
 648     {
 649       int j;
 650
 651       for (j = 0; j < data->npd; j++)
 652         if (data->pms[i]->type1.part_num == data->pds[j].part_num)
 653           {
 654             data->pms[i]->type1.part_num = j;
 655             break;
 656           }
 657
 658       if (j == data->npd)
 659         {
 660           grub_error (GRUB_ERR_BAD_FS, "can\'t find PD");
 661           goto fail;
 662         }
 663     }
 664
 665   block = grub_udf_get_block (data,
 666                               data->lvd.root_fileset.block.part_ref,
 667                               data->lvd.root_fileset.block.block_num);
 668
 669   if (grub_errno)
 670     goto fail;
 671
 672   if (grub_disk_read (disk, block << GRUB_UDF_LOG2_BLKSZ, 0,
 673                       sizeof (struct grub_udf_fileset), &root_fs))
 674     {
 675       grub_error (GRUB_ERR_BAD_FS, "not an udf filesystem");
 676       goto fail;
 677     }
 678
 679   if (U16 (root_fs.tag.tag_ident) != GRUB_UDF_TAG_IDENT_FSD)
 680     {
 681       grub_error (GRUB_ERR_BAD_FS, "invalid fileset descriptor");
 682       goto fail;
 683     }
 684
 685   data->root_icb = root_fs.root_icb;
 686
 687   return data;
 688
 689 fail:
 690   grub_free (data);
 691   return 0;
 692 }
 693
 694 static int
 695 grub_udf_iterate_dir (grub_fshelp_node_t dir,
 696                       int NESTED_FUNC_ATTR
 697                       (*hook) (const char *filename,
 698                                enum grub_fshelp_filetype filetype,
 699                                grub_fshelp_node_t node))
 700 {
 701   grub_fshelp_node_t child;
 702   struct grub_udf_file_ident dirent;
 703   grub_uint32_t offset = 0;
 704
 705   child = grub_malloc (sizeof (struct grub_fshelp_node));
 706   if (!child)
 707     return 0;
 708
 709   /* The current directory is not stored.  */
 710   grub_memcpy ((char *) child, (char *) dir,
 711                sizeof (struct grub_fshelp_node));
 712
 713   if (hook (".", GRUB_FSHELP_DIR, child))
 714     return 1;
 715
 716   while (offset < U64 (dir->fe.file_size))
 717     {
 718       if (grub_udf_read_file (dir, 0, offset, sizeof (dirent),
 719                               (char *) &dirent) != sizeof (dirent))
 720         return 0;
 721
 722       if (U16 (dirent.tag.tag_ident) != GRUB_UDF_TAG_IDENT_FID)
 723         {
 724           grub_error (GRUB_ERR_BAD_FS, "invalid fid tag");
 725           return 0;
 726         }
 727
 728       child = grub_malloc (sizeof (struct grub_fshelp_node));
 729       if (!child)
 730         return 0;
 731
 732       if (grub_udf_read_icb (dir->data, &dirent.icb, child))
 733         return 0;
 734
 735       offset += sizeof (dirent) + U16 (dirent.imp_use_length);
 736       if (dirent.characteristics & GRUB_UDF_FID_CHAR_PARENT)
 737         {
 738           /* This is the parent directory.  */
 739           if (hook ("..", GRUB_FSHELP_DIR, child))
 740             return 1;
 741         }
 742       else
 743         {
 744           enum grub_fshelp_filetype type;
 745           char filename[dirent.file_ident_length + 1];
 746
 747           type = ((dirent.characteristics & GRUB_UDF_FID_CHAR_DIRECTORY) ?
 748                   (GRUB_FSHELP_DIR) : (GRUB_FSHELP_REG));
 749
 750           if ((grub_udf_read_file (dir, 0, offset,
 751                                    dirent.file_ident_length, filename))
 752               != dirent.file_ident_length)
 753             return 0;
 754
 755           filename[dirent.file_ident_length] = 0;
 756           if (hook (&filename[1], type, child))
 757             return 1;
 758         }
 759
 760       /* Align to dword boundary.  */
 761       offset = (offset + dirent.file_ident_length + 3) & (~3);
 762     }
 763
 764   return 0;
 765 }
 766
 767 static grub_err_t
 768 grub_udf_dir (grub_device_t device, const char *path,
 769               int (*hook) (const char *filename,
 770                            const struct grub_dirhook_info *info))
 771 {
 772   struct grub_udf_data *data = 0;
 773   struct grub_fshelp_node rootnode;
 774   struct grub_fshelp_node *foundnode;
 775
 776   auto int NESTED_FUNC_ATTR iterate (const char *filename,
 777                                      enum grub_fshelp_filetype filetype,
 778                                      grub_fshelp_node_t node);
 779
 780   int NESTED_FUNC_ATTR iterate (const char *filename,
 781                                 enum grub_fshelp_filetype filetype,
 782                                 grub_fshelp_node_t node)
 783   {
 784       struct grub_dirhook_info info;
 785       grub_memset (&info, 0, sizeof (info));
 786       info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
 787       grub_free (node);
 788       return hook (filename, &info);
 789   }
 790
 791   grub_dl_ref (my_mod);
 792
 793   data = grub_udf_mount (device->disk);
 794   if (!data)
 795     goto fail;
 796
 797   if (grub_udf_read_icb (data, &data->root_icb, &rootnode))
 798     goto fail;
 799
 800   if (grub_fshelp_find_file (path, &rootnode,
 801                              &foundnode,
 802                              grub_udf_iterate_dir, 0, GRUB_FSHELP_DIR))
 803     goto fail;
 804
 805   grub_udf_iterate_dir (foundnode, iterate);
 806
 807   if (foundnode != &rootnode)
 808     grub_free (foundnode);
 809
 810 fail:
 811   grub_free (data);
 812
 813   grub_dl_unref (my_mod);
 814
 815   return grub_errno;
 816 }
 817
 818 static grub_err_t
 819 grub_udf_open (struct grub_file *file, const char *name)
 820 {
 821   struct grub_udf_data *data;
 822   struct grub_fshelp_node rootnode;
 823   struct grub_fshelp_node *foundnode;
 824
 825   grub_dl_ref (my_mod);
 826
 827   data = grub_udf_mount (file->device->disk);
 828   if (!data)
 829     goto fail;
 830
 831   if (grub_udf_read_icb (data, &data->root_icb, &rootnode))
 832     goto fail;
 833
 834   if (grub_fshelp_find_file (name, &rootnode,
 835                              &foundnode,
 836                              grub_udf_iterate_dir, 0, GRUB_FSHELP_REG))
 837     goto fail;
 838
 839   file->data = foundnode;
 840   file->offset = 0;
 841   file->size = U64 (foundnode->fe.file_size);
 842
 843   return 0;
 844
 845 fail:
 846   grub_dl_unref (my_mod);
 847
 848   grub_free (data);
 849
 850   return grub_errno;
 851 }
 852
 853 static grub_ssize_t
 854 grub_udf_read (grub_file_t file, char *buf, grub_size_t len)
 855 {
 856   struct grub_fshelp_node *node = (struct grub_fshelp_node *) file->data;
 857
 858   return grub_udf_read_file (node, file->read_hook, file->offset, len, buf);
 859 }
 860
 861 static grub_err_t
 862 grub_udf_close (grub_file_t file)
 863 {
 864   if (file->data)
 865     {
 866       struct grub_fshelp_node *node = (struct grub_fshelp_node *) file->data;
 867
 868       grub_free (node->data);
 869       grub_free (node);
 870     }
 871
 872   grub_dl_unref (my_mod);
 873
 874   return GRUB_ERR_NONE;
 875 }
 876
 877 static grub_err_t
 878 grub_udf_label (grub_device_t device, char **label)
 879 {
 880   struct grub_udf_data *data;
 881   data = grub_udf_mount (device->disk);
 882
 883   if (data)
 884     {
 885       *label = grub_strdup ((char *) &data->lvd.ident[1]);
 886       grub_free (data);
 887     }
 888   else
 889     *label = 0;
 890
 891   return grub_errno;
 892 }
 893
 894 static struct grub_fs grub_udf_fs = {
 895   .name = "udf",
 896   .dir = grub_udf_dir,
 897   .open = grub_udf_open,
 898   .read = grub_udf_read,
 899   .close = grub_udf_close,
 900   .label = grub_udf_label,
 901   .next = 0
 902 };
 903
 904 GRUB_MOD_INIT (udf)
 905 {
 906   grub_fs_register (&grub_udf_fs);
 907   my_mod = mod;
 908 }
 909
 910 GRUB_MOD_FINI (udf)
 911 {
 912   grub_fs_unregister (&grub_udf_fs);
 913 }