src/add-ons/kernel/file_systems/udf/UdfStructures.h

   1 /*
   2  * Copyright 2012, Jérôme Duval, korli@users.berlios.de.
   3  * Copyright (c) 2003 Tyler Dauwalder, tyler@dauwalder.net
   4  * This file may be used under the terms of the MIT License.
   5  */
   6 #ifndef _UDF_DISK_STRUCTURES_H
   7 #define _UDF_DISK_STRUCTURES_H
   8
   9 #include <string.h>
  10
  11 #include <ByteOrder.h>
  12 #include <SupportDefs.h>
  13
  14 #include "UdfDebug.h"
  15 #include "Utils.h"
  16
  17 #include "Array.h"
  18
  19 /*! \file UdfStructures.h
  20
  21         \brief UDF on-disk data structure declarations
  22
  23         UDF is a specialization of the ECMA-167 standard. For the most part,
  24         ECMA-167 structures are used by UDF with special restrictions. In a
  25         few instances, UDF introduces its own structures to augment those
  26         supplied by ECMA-167; those structures are clearly marked.
  27
  28         For UDF info: <a href='http://www.osta.org'>http://www.osta.org</a>
  29         For ECMA info: <a href='http://www.ecma-international.org'>http://www.ecma-international.org</a>
  30
  31         For lack of a better place to store this info, the structures that
  32         are allowed to have length greater than the logical block size are
  33         as follows (other length restrictions may be found in UDF-2.01 5.1):
  34         - \c logical_volume_descriptor
  35         - \c unallocated_space_descriptor
  36         - \c logical_volume_integrity_descriptor
  37         - \c space_bitmap_descriptor
  38
  39         Other links of interest:
  40         - <a href='http://www.extra.research.philips.com/udf/'>Philips UDF verifier</a>
  41         - <a href='http://www.hi-ho.ne.jp/y-komachi/committees/fpro/fpro.htm'>Possible test disc image generator (?)</a>
  42 */
  43
  44 //----------------------------------------------------------------------
  45 // ECMA-167 Part 1
  46 //----------------------------------------------------------------------
  47
  48 /*! \brief Character set specifications
  49
  50         The character_set_info field shall be set to the ASCII string
  51         "OSTA Compressed Unicode" (padded right with NULL chars).
  52
  53         See also: ECMA 167 1/7.2.1, UDF-2.01 2.1.2
  54 */
  55 struct charspec {
  56 public:
  57         charspec(uint8 type = 0, const char *info = NULL);
  58
  59         void dump() const;
  60
  61         uint8 character_set_type() const { return _character_set_type; }
  62         const char* character_set_info() const { return _character_set_info; }
  63         char* character_set_info() { return _character_set_info; }
  64
  65         void set_character_set_type(uint8 type) { _character_set_type = type; }
  66         void set_character_set_info(const char *info);
  67 private:
  68         uint8 _character_set_type;      //!< to be set to 0 to indicate CS0
  69         char _character_set_info[63];   //!< "OSTA Compressed Unicode"
  70 } __attribute__((packed));
  71
  72 extern const charspec kCs0CharacterSet;
  73
  74 /*! \brief Date and time stamp
  75
  76         See also: ECMA 167 1/7.3, UDF-2.01 2.1.4
  77 */
  78 class timestamp {
  79 private:
  80         union type_and_timezone_accessor {
  81                 uint16 type_and_timezone;
  82                 struct {
  83                         uint16 timezone:12,
  84                                type:4;
  85                 } bits;
  86         };
  87
  88 public:
  89         timestamp() { _clear(); }
  90         timestamp(time_t time);
  91
  92         void dump() const;
  93
  94         // Get functions
  95         uint16 type_and_timezone() const { return B_LENDIAN_TO_HOST_INT16(_type_and_timezone); }
  96         uint8 type() const {
  97                 type_and_timezone_accessor t;
  98                 t.type_and_timezone = type_and_timezone();
  99                 return t.bits.type;
 100         }
 101         int16 timezone() const {
 102                 type_and_timezone_accessor t;
 103                 t.type_and_timezone = type_and_timezone();
 104                 int16 result = t.bits.timezone;
 105                 // Fill the lefmost bits with ones if timezone is negative
 106                 result <<= 4;
 107                 result >>= 4;
 108                 return result;
 109         }
 110         uint16 year() const { return B_LENDIAN_TO_HOST_INT16(_year); }
 111         uint8 month() const { return _month; }
 112         uint8 day() const { return _day; }
 113         uint8 hour() const { return _hour; }
 114         uint8 minute() const { return _minute; }
 115         uint8 second() const { return _second; }
 116         uint8 centisecond() const { return _centisecond; }
 117         uint8 hundred_microsecond() const { return _hundred_microsecond; }
 118         uint8 microsecond() const { return _microsecond; }
 119
 120         // Set functions
 121         void set_type_and_timezone(uint16 type_and_timezone) {
 122                 _type_and_timezone = B_HOST_TO_LENDIAN_INT16(type_and_timezone); }
 123         void set_type(uint8 type) {
 124                 type_and_timezone_accessor t;
 125                 t.type_and_timezone = type_and_timezone();
 126                 t.bits.type = type;
 127                 set_type_and_timezone(t.type_and_timezone);
 128         }
 129         void set_timezone(int16 tz) {
 130                 type_and_timezone_accessor t;
 131                 t.type_and_timezone = type_and_timezone();
 132                 t.bits.timezone = tz;
 133                 set_type_and_timezone(t.type_and_timezone);
 134         }
 135         void set_year(uint16 year) { _year = B_HOST_TO_LENDIAN_INT16(year); }
 136         void set_month(uint8 month) { _month = month; }
 137         void set_day(uint8 day) { _day = day; }
 138         void set_hour(uint8 hour) { _hour = hour; }
 139         void set_minute(uint8 minute) { _minute = minute; }
 140         void set_second(uint8 second) { _second = second; }
 141         void set_centisecond(uint8 centisecond) { _centisecond = centisecond; }
 142         void set_hundred_microsecond(uint8 hundred_microsecond) {
 143                 _hundred_microsecond = hundred_microsecond; }
 144         void set_microsecond(uint8 microsecond) { _microsecond = microsecond; }
 145 private:
 146         void _clear();
 147
 148         uint16 _type_and_timezone;
 149         uint16 _year;
 150         uint8 _month;
 151         uint8 _day;
 152         uint8 _hour;
 153         uint8 _minute;
 154         uint8 _second;
 155         uint8 _centisecond;
 156         uint8 _hundred_microsecond;
 157         uint8 _microsecond;
 158
 159 } __attribute__((packed));
 160
 161
 162 /*! \brief UDF ID Identify Suffix
 163
 164         See also: UDF 2.50 2.1.5.3
 165 */
 166 struct udf_id_suffix {
 167 public:
 168         udf_id_suffix(uint16 udfRevision, uint8 os_class, uint8 os_identifier);
 169
 170         //! Note that revision 2.50 is denoted by 0x0250.
 171         uint16 udf_revision() const { return _udf_revision; }
 172         uint8 os_class() const { return _os_class; }
 173         uint8 os_identifier() const { return _os_identifier; }
 174
 175         void set_os_class(uint8 os_class) { _os_class = os_class; }
 176         void set_os_identifier(uint8 identifier) { _os_identifier = identifier; }
 177 private:
 178         uint16 _udf_revision;
 179         uint8 _os_class;
 180         uint8 _os_identifier;
 181         array<uint8, 4> _reserved;
 182 };
 183
 184 /*! \brief Implementation ID Identify Suffix
 185
 186         See also: UDF 2.50 2.1.5.3
 187 */
 188 struct implementation_id_suffix {
 189 public:
 190         implementation_id_suffix(uint8 os_class, uint8 os_identifier);
 191
 192         uint8 os_class() const { return _os_class; }
 193         uint8 os_identifier() const { return _os_identifier; }
 194
 195         void set_os_class(uint8 os_class) { _os_class = os_class; }
 196         void set_os_identifier(uint8 identifier) { _os_identifier = identifier; }
 197 private:
 198         uint8 _os_class;
 199         uint8 _os_identifier;
 200         array<uint8, 6> _implementation_use;
 201 };
 202
 203 /*! \brief Operating system classes for implementation_id_suffixes
 204
 205         See also: Udf 2.50 6.3
 206 */
 207 enum {
 208         OS_UNDEFINED = 0,
 209         OS_DOS,
 210         OS_OS2,
 211         OS_MACOS,
 212         OS_UNIX,
 213         OS_WIN9X,
 214         OS_WINNT,
 215         OS_OS400,
 216         OS_BEOS,
 217         OS_WINCE
 218 };
 219
 220 /*! \brief BeOS operating system classes identifiers for implementation_id_suffixes
 221
 222         See also: Udf 2.50 6.3
 223 */
 224 enum {
 225         BEOS_GENERIC = 0,
 226         BEOS_OPENBEOS = 1       // not part of the standard, but perhaps someday. :-)
 227 };
 228
 229 /*! \brief Domain ID Identify Suffix
 230
 231         See also: UDF 2.50 2.1.5.3
 232 */
 233 struct domain_id_suffix {
 234 public:
 235         domain_id_suffix(uint16 udfRevision, uint8 domainFlags);
 236
 237         //! Note that revision 2.50 is denoted by 0x0250.
 238         uint16 udf_revision() const { return _udf_revision; }
 239         uint8 domain_flags() const { return _domain_flags; }
 240
 241         void set_udf_revision(uint16 revision) { _udf_revision = B_HOST_TO_LENDIAN_INT16(revision); }
 242         void set_domain_flags(uint8 flags) { _domain_flags = flags; }
 243 private:
 244         uint16 _udf_revision;
 245         uint8 _domain_flags;
 246         array<uint8, 5> _reserved;
 247 };
 248
 249 /*! \brief Domain flags
 250
 251         See also: UDF 2.50 2.1.5.3
 252 */
 253 enum {
 254         DF_HARD_WRITE_PROTECT = 0x01,
 255         DF_SOFT_WRITE_PROTECT = 0x02
 256 };
 257
 258 /*! \brief Identifier used to designate the implementation responsible
 259         for writing associated data structures on the medium.
 260
 261         See also: ECMA 167 1/7.4, UDF 2.01 2.1.5
 262 */
 263 struct entity_id {
 264 public:
 265         static const int kIdentifierLength = 23;
 266         static const int kIdentifierSuffixLength = 8;
 267
 268         entity_id(uint8 flags = 0, const char *identifier = NULL,
 269                   uint8 *identifier_suffix = NULL);
 270         entity_id(uint8 flags, const char *identifier,
 271                   const udf_id_suffix &suffix);
 272         entity_id(uint8 flags, const char *identifier,
 273                   const implementation_id_suffix &suffix);
 274         entity_id(uint8 flags, const char *identifier,
 275                   const domain_id_suffix &suffix);
 276
 277         void dump() const;
 278         bool matches(const entity_id &id) const;
 279
 280         // Get functions
 281         uint8 flags() const { return _flags; }
 282         const char* identifier() const { return _identifier; }
 283         char* identifier() { return _identifier; }
 284         const array<uint8, kIdentifierSuffixLength>& identifier_suffix() const { return _identifier_suffix; }
 285         array<uint8, kIdentifierSuffixLength>& identifier_suffix() { return _identifier_suffix; }
 286
 287         // Set functions
 288         void set_flags(uint8 flags) { _flags = flags; }
 289 private:
 290         uint8 _flags;
 291         char _identifier[kIdentifierLength];
 292         array<uint8, kIdentifierSuffixLength> _identifier_suffix;
 293 } __attribute__((packed));
 294
 295 extern entity_id kMetadataPartitionMapId;
 296 extern entity_id kSparablePartitionMapId;
 297 extern entity_id kVirtualPartitionMapId;
 298 extern entity_id kImplementationId;
 299 extern entity_id kPartitionContentsId1xx;
 300 extern entity_id kPartitionContentsId2xx;
 301 extern entity_id kUdfId;
 302 extern entity_id kLogicalVolumeInfoId150;
 303 extern entity_id kLogicalVolumeInfoId201;
 304 extern entity_id kDomainId150;
 305 extern entity_id kDomainId201;
 306 extern void init_entities(void);
 307
 308 //----------------------------------------------------------------------
 309 // ECMA-167 Part 2
 310 //----------------------------------------------------------------------
 311
 312
 313 /*! \brief Header for volume structure descriptors
 314
 315         Each descriptor consumes an entire block. All unused trailing
 316         bytes in the descriptor should be set to 0.
 317
 318         The following descriptors contain no more information than
 319         that contained in the header:
 320
 321         - BEA01:
 322           - type: 0
 323           - id: "BEA01"
 324           - version: 1
 325
 326         - TEA01:
 327           - type: 0
 328           - id: "TEA01"
 329           - version: 1
 330
 331         - NSR03:
 332           - type: 0
 333           - id: "NSR03"
 334           - version: 1
 335
 336         See also: ECMA 167 2/9.1
 337 */
 338 struct volume_structure_descriptor_header {
 339 public:
 340         volume_structure_descriptor_header(uint8 type, const char *id, uint8 version);
 341
 342         uint8 type;
 343         char id[5];
 344         uint8 version;
 345
 346         bool id_matches(const char *id);
 347 } __attribute__((packed));
 348
 349 // Volume structure descriptor ids
 350 extern const char* kVSDID_BEA;
 351 extern const char* kVSDID_TEA;
 352 extern const char* kVSDID_BOOT;
 353 extern const char* kVSDID_ISO;
 354 extern const char* kVSDID_ECMA167_2;
 355 extern const char* kVSDID_ECMA167_3;
 356 extern const char* kVSDID_ECMA168;
 357
 358 //----------------------------------------------------------------------
 359 // ECMA-167 Part 3
 360 //----------------------------------------------------------------------
 361
 362
 363 /*! \brief Location and length of a contiguous chunk of data on the volume.
 364
 365         \c _location is an absolute block address.
 366
 367         See also: ECMA 167 3/7.1
 368 */
 369 struct extent_address {
 370 public:
 371         extent_address(uint32 location = 0, uint32 length = 0);
 372
 373         void dump() const;
 374
 375         uint32 length() const { return B_LENDIAN_TO_HOST_INT32(_length); }
 376         uint32 location() const { return B_LENDIAN_TO_HOST_INT32(_location); }
 377
 378         void set_length(int32 length) { _length = B_HOST_TO_LENDIAN_INT32(length); }
 379         void set_location(int32 location) { _location = B_HOST_TO_LENDIAN_INT32(location); }
 380 private:
 381         uint32 _length;
 382         uint32 _location;
 383 } __attribute__((packed));
 384
 385
 386 /*! \brief Location of a logical block within a logical volume.
 387
 388         See also: ECMA 167 4/7.1
 389 */
 390 struct logical_block_address {
 391 public:
 392         void dump() const;
 393         logical_block_address(uint16 partition = 0, uint32 block = 0);
 394
 395         uint32 block() const { return B_LENDIAN_TO_HOST_INT32(_block); }
 396         uint16 partition() const { return B_LENDIAN_TO_HOST_INT16(_partition); }
 397
 398         void set_block(uint32 block) { _block = B_HOST_TO_LENDIAN_INT32(block); }
 399         void set_partition(uint16 partition) { _partition = B_HOST_TO_LENDIAN_INT16(partition); }
 400
 401 private:
 402         uint32 _block;  //!< Block location relative to start of corresponding partition
 403         uint16 _partition;      //!< Numeric partition id within logical volume
 404 } __attribute__((packed));
 405
 406 /*! \brief Extent types used in short_address, long_address,
 407         and extended_address.
 408
 409         See also: ECMA-167 4/14.14.1.1
 410 */
 411 enum extent_type {
 412         EXTENT_TYPE_RECORDED = 0,       //!< Allocated and recorded
 413         EXTENT_TYPE_ALLOCATED,          //!< Allocated but unrecorded
 414         EXTENT_TYPE_UNALLOCATED,        //!< Unallocated and unrecorded
 415         EXTENT_TYPE_CONTINUATION,       //!< Specifies next extent of descriptors
 416 };
 417
 418
 419 /*! \brief Allocation descriptor.
 420
 421         See also: ECMA 167 4/14.14.1
 422 */
 423 struct short_address {
 424 private:
 425         union type_and_length_accessor {
 426                 uint32 type_and_length;
 427                 struct {
 428                         uint32 length:30,
 429                                type:2;
 430 //                      uint32 type:2,
 431 //                             length:30;
 432                 } bits;
 433         };
 434
 435 public:
 436         void dump() const;
 437
 438         uint8 type() const {
 439                 type_and_length_accessor t;
 440                 t.type_and_length = type_and_length();
 441                 return t.bits.type;
 442         }
 443         uint32 length() const {
 444                 type_and_length_accessor t;
 445                 t.type_and_length = type_and_length();
 446                 return t.bits.length;
 447         }
 448         uint32 block() const { return B_LENDIAN_TO_HOST_INT32(_block); }
 449
 450         void set_type(uint8 type) {
 451                 type_and_length_accessor t;
 452                 t.type_and_length = type_and_length();
 453                 t.bits.type = type;
 454                 set_type_and_length(t.type_and_length);
 455         }
 456         void set_length(uint32 length) {
 457                 type_and_length_accessor t;
 458                 t.type_and_length = type_and_length();
 459                 t.bits.length = length;
 460                 set_type_and_length(t.type_and_length);
 461         }
 462         void set_block(uint32 block) { _block = B_HOST_TO_LENDIAN_INT32(block); }
 463 private:
 464         uint32 type_and_length() const { return B_LENDIAN_TO_HOST_INT32(_type_and_length); }
 465         void set_type_and_length(uint32 value) { _type_and_length = B_HOST_TO_LENDIAN_INT32(value); }
 466
 467         uint32 _type_and_length;
 468         uint32 _block;
 469 } __attribute__((packed));
 470
 471
 472 /*! \brief Allocation descriptor w/ 6 byte implementation use field.
 473
 474         See also: ECMA 167 4/14.14.2
 475 */
 476 struct long_address {
 477 private:
 478         union type_and_length_accessor {
 479                 uint32 type_and_length;
 480                 struct {
 481                         uint32 length:30,
 482                                type:2;
 483                 } bits;
 484         };
 485
 486 public:
 487         long_address(uint16 partition = 0, uint32 block = 0, uint32 length = 0,
 488                      uint8 type = 0);
 489
 490         void dump() const;
 491
 492         uint8 type() const {
 493                 type_and_length_accessor t;
 494                 t.type_and_length = type_and_length();
 495                 return t.bits.type;
 496         }
 497         uint32 length() const {
 498                 type_and_length_accessor t;
 499                 t.type_and_length = type_and_length();
 500                 return t.bits.length;
 501         }
 502
 503         uint32 block() const { return _location.block(); }
 504         uint16 partition() const { return _location.partition(); }
 505
 506         const array<uint8, 6>& implementation_use() const { return _implementation_use; }
 507         array<uint8, 6>& implementation_use() { return _implementation_use; }
 508
 509         uint16 flags() const { return B_LENDIAN_TO_HOST_INT16(_accessor().flags); }
 510         uint32 unique_id() const { return B_LENDIAN_TO_HOST_INT32(_accessor().unique_id); }
 511
 512         void set_type(uint8 type) {
 513                 type_and_length_accessor t;
 514                 t.type_and_length = type_and_length();
 515                 t.bits.type = type;
 516                 set_type_and_length(t.type_and_length);
 517         }
 518         void set_length(uint32 length) {
 519                 type_and_length_accessor t;
 520                 t.type_and_length = type_and_length();
 521                 t.bits.length = length;
 522                 set_type_and_length(t.type_and_length);
 523         }
 524         void set_block(uint32 block) { _location.set_block(block); }
 525         void set_partition(uint16 partition) { _location.set_partition(partition); }
 526
 527         void set_flags(uint16 flags) { _accessor().flags = B_HOST_TO_LENDIAN_INT16(flags); }
 528         void set_unique_id(uint32 id) { _accessor().unique_id = B_HOST_TO_LENDIAN_INT32(id); }
 529
 530         void set_to(uint32 block, uint16 partition, uint32 length = 1,
 531                uint8 type = EXTENT_TYPE_RECORDED, uint16 flags = 0, uint32 unique_id = 0)
 532         {
 533                 set_block(block);
 534                 set_partition(partition);
 535                 set_length(length);
 536                 set_type(type);
 537                 set_flags(flags);
 538                 set_unique_id(unique_id);
 539         }
 540
 541 private:
 542         //! See UDF-2.50 2.3.4.3
 543         struct _implementation_use_accessor {
 544                 uint16 flags;
 545                 uint32 unique_id;
 546         } __attribute__((packed));
 547
 548         _implementation_use_accessor& _accessor() { return
 549                 *reinterpret_cast<_implementation_use_accessor*>(implementation_use().data); }
 550         const _implementation_use_accessor& _accessor() const { return
 551                 *reinterpret_cast<const _implementation_use_accessor*>(implementation_use().data); }
 552
 553         uint32 type_and_length() const { return B_LENDIAN_TO_HOST_INT32(_type_and_length); }
 554         void set_type_and_length(uint32 value) { _type_and_length = B_HOST_TO_LENDIAN_INT32(value); }
 555
 556         uint32 _type_and_length;
 557         logical_block_address _location;
 558         array<uint8, 6> _implementation_use;
 559 } __attribute__((packed));
 560
 561 /*! \brief Common tag found at the beginning of most udf descriptor structures.
 562
 563         For error checking, \c descriptor_tag  structures have:
 564         - The disk location of the tag redundantly stored in the tag itself
 565         - A checksum value for the tag
 566         - A CRC value and length
 567
 568         See also: ECMA 167 1/7.2, UDF 2.01 2.2.1, UDF 2.01 2.3.1
 569 */
 570 struct descriptor_tag {
 571 public:
 572         void dump() const;
 573
 574         status_t init_check(uint32 block, bool calculateCrc = true);
 575
 576         uint16 id() const { return B_LENDIAN_TO_HOST_INT16(_id); }
 577         uint16 version() const { return B_LENDIAN_TO_HOST_INT16(_version); }
 578         uint8 checksum() const { return _checksum; }
 579         uint16 serial_number() const { return B_LENDIAN_TO_HOST_INT16(_serial_number); }
 580         uint16 crc() const { return B_LENDIAN_TO_HOST_INT16(_crc); }
 581         uint16 crc_length() const { return B_LENDIAN_TO_HOST_INT16(_crc_length); }
 582         uint32 location() const { return B_LENDIAN_TO_HOST_INT32(_location); }
 583
 584         void set_id(uint16 id) { _id = B_HOST_TO_LENDIAN_INT16(id); }
 585         void set_version(uint16 version) { _version = B_HOST_TO_LENDIAN_INT16(version); }
 586         void set_checksum(uint8 checksum) { _checksum = checksum; }
 587         void set_serial_number(uint16 serial_number) { _serial_number = B_HOST_TO_LENDIAN_INT16(serial_number); }
 588         void set_crc(uint16 crc) { _crc = B_HOST_TO_LENDIAN_INT16(crc); }
 589         void set_crc_length(uint16 crc_length) { _crc_length = B_HOST_TO_LENDIAN_INT16(crc_length); }
 590         void set_location(uint32 location) { _location = B_HOST_TO_LENDIAN_INT32(location); }
 591
 592         /*! \brief Calculates and sets the crc length, crc checksumm, and
 593                 checksum for the tag.
 594
 595                 This function should not be called until all member variables in
 596                 the descriptor_tag's enclosing descriptor and all member variables
 597                 in the descriptor_tag itself other than crc_length, crc, and checksum
 598                 have been set (since the checksum is based off of values in the
 599                 descriptor_tag, and the crc is based off the values in and the
 600                 size of the     enclosing descriptor).
 601
 602                 \param The tag's enclosing descriptor.
 603                 \param The size of the tag's enclosing descriptor (including the
 604                        tag); only necessary if different from sizeof(Descriptor).
 605         */
 606         template <class Descriptor>
 607         void
 608         set_checksums(Descriptor &descriptor, uint16 size = sizeof(Descriptor))
 609         {
 610
 611                 // check that this tag is actually owned by
 612                 // the given descriptor
 613                 if (this == &descriptor.tag())
 614                 {
 615                         // crc_length, based off provided descriptor
 616                         set_crc_length(size - sizeof(descriptor_tag));
 617                         // crc
 618                         uint16 crc = calculate_crc(reinterpret_cast<uint8*>(this)
 619                                        + sizeof(descriptor_tag), crc_length());
 620                         set_crc(crc);
 621                         // checksum (which depends on the other two values)
 622                         uint32 sum = 0;
 623                         for (int i = 0; i <= 3; i++)
 624                                 sum += reinterpret_cast<uint8*>(this)[i];
 625                         for (int i = 5; i <= 15; i++)
 626                                 sum += reinterpret_cast<uint8*>(this)[i];
 627                         set_checksum(sum % 256);
 628                 }
 629         }
 630 private:
 631         uint16 _id;
 632         uint16 _version;
 633         uint8 _checksum;                        //!< Sum modulo 256 of bytes 0-3 and 5-15 of this struct.
 634         uint8 _reserved;                        //!< Set to #00.
 635         uint16 _serial_number;
 636         uint16 _crc;                            //!< May be 0 if \c crc_length field is 0.
 637         /*! \brief Length of the data chunk used to calculate CRC.
 638
 639                 If 0, no CRC was calculated, and the \c crc field must be 0.
 640
 641                 According to UDF-2.01 2.3.1.2, the CRC shall be calculated for all descriptors
 642                 unless otherwise noted, and this field shall be set to:
 643
 644                 <code>(descriptor length) - (descriptor tag length)</code>
 645         */
 646         uint16 _crc_length;
 647         /*! \brief Address of this tag within its partition (for error checking).
 648
 649                 For virtually addressed structures (i.e. those accessed thru a VAT), this
 650                 shall be the virtual address, not the physical or logical address.
 651         */
 652         uint32 _location;
 653
 654 } __attribute__((packed));
 655
 656
 657 /*! \c descriptor_tag ::id values
 658 */
 659 enum tag_id {
 660         TAGID_UNDEFINED = 0,
 661
 662         // ECMA 167, PART 3
 663         TAGID_PRIMARY_VOLUME_DESCRIPTOR,
 664         TAGID_ANCHOR_VOLUME_DESCRIPTOR_POINTER,
 665         TAGID_VOLUME_DESCRIPTOR_POINTER,
 666         TAGID_IMPLEMENTATION_USE_VOLUME_DESCRIPTOR,
 667         TAGID_PARTITION_DESCRIPTOR,
 668         TAGID_LOGICAL_VOLUME_DESCRIPTOR,
 669         TAGID_UNALLOCATED_SPACE_DESCRIPTOR,
 670         TAGID_TERMINATING_DESCRIPTOR,
 671         TAGID_LOGICAL_VOLUME_INTEGRITY_DESCRIPTOR,
 672
 673         TAGID_CUSTOM_START = 65280,
 674         TAGID_CUSTOM_END = 65535,
 675
 676         // ECMA 167, PART 4
 677         TAGID_FILE_SET_DESCRIPTOR = 256,
 678         TAGID_FILE_ID_DESCRIPTOR,
 679         TAGID_ALLOCATION_EXTENT_DESCRIPTOR,
 680         TAGID_INDIRECT_ENTRY,
 681         TAGID_TERMINAL_ENTRY,
 682         TAGID_FILE_ENTRY,
 683         TAGID_EXTENDED_ATTRIBUTE_HEADER_DESCRIPTOR,
 684         TAGID_UNALLOCATED_SPACE_ENTRY,
 685         TAGID_SPACE_BITMAP_DESCRIPTOR,
 686         TAGID_PARTITION_INTEGRITY_ENTRY,
 687         TAGID_EXTENDED_FILE_ENTRY,
 688 };
 689
 690 const char *tag_id_to_string(tag_id id);
 691
 692 extern const uint16 kCrcTable[256];
 693
 694 /*! \brief Primary volume descriptor
 695 */
 696 struct primary_volume_descriptor {
 697 public:
 698         void dump() const;
 699
 700         // Get functions
 701         const descriptor_tag & tag() const { return _tag; }
 702         descriptor_tag & tag() { return _tag; }
 703
 704         uint32 vds_number() const { return B_LENDIAN_TO_HOST_INT32(_vds_number); }
 705         uint32 primary_volume_descriptor_number() const { return B_LENDIAN_TO_HOST_INT32(_primary_volume_descriptor_number); }
 706
 707         const array<char, 32>& volume_identifier() const { return _volume_identifier; }
 708         array<char, 32>& volume_identifier() { return _volume_identifier; }
 709
 710         uint16 volume_sequence_number() const { return B_LENDIAN_TO_HOST_INT16(_volume_sequence_number); }
 711         uint16 max_volume_sequence_number() const { return B_LENDIAN_TO_HOST_INT16(_max_volume_sequence_number); }
 712         uint16 interchange_level() const { return B_LENDIAN_TO_HOST_INT16(_interchange_level); }
 713         uint16 max_interchange_level() const { return B_LENDIAN_TO_HOST_INT16(_max_interchange_level); }
 714         uint32 character_set_list() const { return B_LENDIAN_TO_HOST_INT32(_character_set_list); }
 715         uint32 max_character_set_list() const { return B_LENDIAN_TO_HOST_INT32(_max_character_set_list); }
 716
 717         const array<char, 128>& volume_set_identifier() const { return _volume_set_identifier; }
 718         array<char, 128>& volume_set_identifier() { return _volume_set_identifier; }
 719
 720         const charspec& descriptor_character_set() const { return _descriptor_character_set; }
 721         charspec& descriptor_character_set() { return _descriptor_character_set; }
 722
 723         const charspec& explanatory_character_set() const { return _explanatory_character_set; }
 724         charspec& explanatory_character_set() { return _explanatory_character_set; }
 725
 726         const extent_address& volume_abstract() const { return _volume_abstract; }
 727         extent_address& volume_abstract() { return _volume_abstract; }
 728         const extent_address& volume_copyright_notice() const { return _volume_copyright_notice; }
 729         extent_address& volume_copyright_notice() { return _volume_copyright_notice; }
 730
 731         const entity_id& application_id() const { return _application_id; }
 732         entity_id& application_id() { return _application_id; }
 733
 734         const timestamp& recording_date_and_time() const { return _recording_date_and_time; }
 735         timestamp& recording_date_and_time() { return _recording_date_and_time; }
 736
 737         const entity_id& implementation_id() const { return _implementation_id; }
 738         entity_id& implementation_id() { return _implementation_id; }
 739
 740         const array<uint8, 64>& implementation_use() const { return _implementation_use; }
 741         array<uint8, 64>& implementation_use() { return _implementation_use; }
 742
 743         uint32 predecessor_volume_descriptor_sequence_location() const
 744           { return B_LENDIAN_TO_HOST_INT32(_predecessor_volume_descriptor_sequence_location); }
 745         uint16 flags() const { return B_LENDIAN_TO_HOST_INT16(_flags); }
 746
 747         const array<uint8, 22>& reserved() const { return _reserved; }
 748         array<uint8, 22>& reserved() { return _reserved; }
 749
 750         // Set functions
 751         void set_vds_number(uint32 number)
 752           { _vds_number = B_HOST_TO_LENDIAN_INT32(number); }
 753         void set_primary_volume_descriptor_number(uint32 number)
 754           { _primary_volume_descriptor_number = B_HOST_TO_LENDIAN_INT32(number); }
 755         void set_volume_sequence_number(uint16 number)
 756           { _volume_sequence_number = B_HOST_TO_LENDIAN_INT16(number); }
 757         void set_max_volume_sequence_number(uint16 number)
 758           { _max_volume_sequence_number = B_HOST_TO_LENDIAN_INT16(number); }
 759         void set_interchange_level(uint16 level)
 760           { _interchange_level = B_HOST_TO_LENDIAN_INT16(level); }
 761         void set_max_interchange_level(uint16 level)
 762           { _max_interchange_level = B_HOST_TO_LENDIAN_INT16(level); }
 763         void set_character_set_list(uint32 list)
 764           { _character_set_list = B_HOST_TO_LENDIAN_INT32(list); }
 765         void set_max_character_set_list(uint32 list)
 766           { _max_character_set_list = B_HOST_TO_LENDIAN_INT32(list); }
 767         void set_predecessor_volume_descriptor_sequence_location(uint32 location)
 768           { _predecessor_volume_descriptor_sequence_location = B_HOST_TO_LENDIAN_INT32(location); }
 769         void set_flags(uint16 flags)
 770           { _flags = B_HOST_TO_LENDIAN_INT16(flags); }
 771
 772 private:
 773         descriptor_tag  _tag;
 774         uint32 _vds_number;
 775         uint32 _primary_volume_descriptor_number;
 776         array<char, 32> _volume_identifier;
 777         uint16 _volume_sequence_number;
 778         uint16 _max_volume_sequence_number;
 779         uint16 _interchange_level; //!< to be set to 3 if part of multivolume set, 2 otherwise
 780         uint16 _max_interchange_level; //!< to be set to 3 unless otherwise directed by user
 781         uint32 _character_set_list;
 782         uint32 _max_character_set_list;
 783         array<char, 128> _volume_set_identifier;
 784
 785         /*! \brief Identifies the character set for the \c volume_identifier
 786                 and \c volume_set_identifier fields.
 787
 788                 To be set to CS0.
 789         */
 790         charspec _descriptor_character_set;
 791
 792         /*! \brief Identifies the character set used in the \c volume_abstract
 793                 and \c volume_copyright_notice extents.
 794
 795                 To be set to CS0.
 796         */
 797         charspec _explanatory_character_set;
 798
 799         extent_address _volume_abstract;
 800         extent_address _volume_copyright_notice;
 801
 802         entity_id _application_id;
 803         timestamp _recording_date_and_time;
 804         entity_id _implementation_id;
 805         array<uint8, 64> _implementation_use;
 806         uint32 _predecessor_volume_descriptor_sequence_location;
 807         uint16 _flags;
 808         array<uint8, 22> _reserved;
 809
 810 } __attribute__((packed));
 811
 812
 813 /*! \brief Anchor Volume Descriptor Pointer
 814
 815         vd recorded at preset locations in the partition, used as a reference
 816         point to the main vd sequences
 817
 818         According to UDF 2.01, an avdp shall be recorded in at least 2 of
 819         the 3 following locations, where N is the last recordable sector
 820         of the partition:
 821         - 256
 822         - (N - 256)
 823         - N
 824
 825         See also: ECMA 167 3/10.2, UDF-2.01 2.2.3
 826 */
 827 struct anchor_volume_descriptor {
 828 public:
 829         anchor_volume_descriptor() { memset(_reserved.data, 0, _reserved.size()); }
 830         void dump() const;
 831
 832         descriptor_tag & tag() { return _tag; }
 833         const descriptor_tag & tag() const { return _tag; }
 834
 835         extent_address& main_vds() { return _main_vds; }
 836         const extent_address& main_vds() const { return _main_vds; }
 837
 838         extent_address& reserve_vds() { return _reserve_vds; }
 839         const extent_address& reserve_vds() const { return _reserve_vds; }
 840 private:
 841         descriptor_tag  _tag;
 842         extent_address _main_vds;       //!< min length of 16 sectors
 843         extent_address _reserve_vds;    //!< min length of 16 sectors
 844         array<uint8, 480> _reserved;
 845 } __attribute__((packed));
 846
 847
 848 /*! \brief Volume Descriptor Pointer
 849
 850         Used to chain extents of volume descriptor sequences together.
 851
 852         See also: ECMA 167 3/10.3
 853 */
 854 struct descriptor_pointer {
 855         descriptor_tag  tag;
 856         uint32 vds_number;
 857         extent_address next;
 858 } __attribute__((packed));
 859
 860
 861 /*! \brief UDF Implementation Use Volume Descriptor struct found in
 862         implementation_use() field of implementation_use_descriptor when
 863         said descriptor's implementation_id() field specifies "*UDF LV Info"
 864
 865         See also: UDF 2.50 2.2.7
 866 */
 867 struct logical_volume_info {
 868 public:
 869         void dump() const;
 870
 871         charspec& character_set() { return _character_set; }
 872         const charspec& character_set() const { return _character_set; }
 873
 874         array<char, 128>& logical_volume_id() { return _logical_volume_id; }
 875         const array<char, 128>& logical_volume_id() const { return _logical_volume_id; }
 876
 877         array<char, 36>& logical_volume_info_1() { return _logical_volume_info.data[0]; }
 878         const array<char, 36>& logical_volume_info_1() const { return _logical_volume_info.data[0]; }
 879
 880         array<char, 36>& logical_volume_info_2() { return _logical_volume_info.data[1]; }
 881         const array<char, 36>& logical_volume_info_2() const { return _logical_volume_info.data[1]; }
 882
 883         array<char, 36>& logical_volume_info_3() { return _logical_volume_info.data[2]; }
 884         const array<char, 36>& logical_volume_info_3() const { return _logical_volume_info.data[2]; }
 885
 886         entity_id& implementation_id() { return _implementation_id; }
 887         const entity_id& implementation_id() const { return _implementation_id; }
 888
 889         array<uint8, 128>& implementation_use() { return _implementation_use; }
 890         const array<uint8, 128>& implementation_use() const { return _implementation_use; }
 891 private:
 892         charspec _character_set;
 893         array<char, 128> _logical_volume_id;                            // d-string
 894         array<array<char, 36>, 3> _logical_volume_info; // d-strings
 895         entity_id _implementation_id;
 896         array<uint8, 128> _implementation_use;
 897 } __attribute__((packed));
 898
 899 /*! \brief Implementation Use Volume Descriptor
 900
 901         See also: ECMA 167 3/10.4
 902 */
 903 struct implementation_use_descriptor {
 904 public:
 905         void dump() const;
 906
 907         // Get functions
 908         const descriptor_tag & tag() const { return _tag; }
 909         descriptor_tag & tag() { return _tag; }
 910
 911         uint32 vds_number() const { return B_LENDIAN_TO_HOST_INT32(_vds_number); }
 912
 913         const entity_id& implementation_id() const { return _implementation_id; }
 914         entity_id& implementation_id() { return _implementation_id; }
 915
 916         const array<uint8, 460>& implementation_use() const { return _implementation_use; }
 917         array<uint8, 460>& implementation_use() { return _implementation_use; }
 918
 919         // Only valid if implementation_id() returns Udf::kLogicalVolumeInfoId.
 920         logical_volume_info& info() { return *reinterpret_cast<logical_volume_info*>(_implementation_use.data); }
 921         const logical_volume_info& info() const { return *reinterpret_cast<const logical_volume_info*>(_implementation_use.data); }
 922
 923         // Set functions
 924         void set_vds_number(uint32 number) { _vds_number = B_HOST_TO_LENDIAN_INT32(number); }
 925 private:
 926         descriptor_tag  _tag;
 927         uint32 _vds_number;
 928         entity_id _implementation_id;
 929         array<uint8, 460> _implementation_use;
 930 } __attribute__((packed));
 931
 932
 933 /*! \brief Maximum number of partition descriptors to be found in volume
 934         descriptor sequence, per UDF-2.50
 935 */
 936 const uint8 kMaxPartitionDescriptors = 2;
 937 #define UDF_MAX_PARTITION_MAPS 2
 938 #define UDF_MAX_PARTITION_MAP_SIZE 64
 939
 940 /*! \brief Partition Descriptor
 941
 942         See also: ECMA 167 3/10.5
 943 */
 944 struct partition_descriptor {
 945 private:
 946         union partition_flags_accessor {
 947                 uint16 partition_flags;
 948                 struct {
 949                         uint16 allocated:1,
 950                                reserved:15;
 951                 } bits;
 952         };
 953
 954 public:
 955         void dump() const;
 956
 957         // Get functions
 958         const descriptor_tag & tag() const { return _tag; }
 959         descriptor_tag & tag() { return _tag; }
 960
 961         uint32 vds_number() const { return B_LENDIAN_TO_HOST_INT32(_vds_number); }
 962         uint16 partition_flags() const { return B_LENDIAN_TO_HOST_INT16(_partition_flags); }
 963         bool allocated() const {
 964                 partition_flags_accessor f;
 965                 f.partition_flags = partition_flags();
 966                 return f.bits.allocated;
 967         }
 968         uint16 partition_number() const { return B_LENDIAN_TO_HOST_INT16(_partition_number); }
 969
 970         const entity_id& partition_contents() const { return _partition_contents; }
 971         entity_id& partition_contents() { return _partition_contents; }
 972
 973         const array<uint8, 128>& partition_contents_use() const { return _partition_contents_use; }
 974         array<uint8, 128>& partition_contents_use() { return _partition_contents_use; }
 975
 976         uint32 access_type() const { return B_LENDIAN_TO_HOST_INT32(_access_type); }
 977         uint32 start() const { return B_LENDIAN_TO_HOST_INT32(_start); }
 978         uint32 length() const { return B_LENDIAN_TO_HOST_INT32(_length); }
 979
 980         const entity_id& implementation_id() const { return _implementation_id; }
 981         entity_id& implementation_id() { return _implementation_id; }
 982
 983         const array<uint8, 128>& implementation_use() const { return _implementation_use; }
 984         array<uint8, 128>& implementation_use() { return _implementation_use; }
 985
 986         const array<uint8, 156>& reserved() const { return _reserved; }
 987         array<uint8, 156>& reserved() { return _reserved; }
 988
 989         // Set functions
 990         void set_vds_number(uint32 number) { _vds_number = B_HOST_TO_LENDIAN_INT32(number); }
 991         void set_partition_flags(uint16 flags) { _partition_flags = B_HOST_TO_LENDIAN_INT16(flags); }
 992         void set_allocated(bool allocated) {
 993                 partition_flags_accessor f;
 994                 f.partition_flags = partition_flags();
 995                 f.bits.allocated = allocated;
 996                 set_partition_flags(f.partition_flags);
 997         }
 998         void set_partition_number(uint16 number) { _partition_number = B_HOST_TO_LENDIAN_INT16(number); }
 999         void set_access_type(uint32 type) { _access_type = B_HOST_TO_LENDIAN_INT32(type); }
1000         void set_start(uint32 start) { _start = B_HOST_TO_LENDIAN_INT32(start); }
1001         void set_length(uint32 length) { _length = B_HOST_TO_LENDIAN_INT32(length); }
1002
1003 private:
1004         descriptor_tag  _tag;
1005         uint32 _vds_number;
1006         /*! Bit 0: If 0, shall mean volume space has not been allocated. If 1,
1007             shall mean volume space has been allocated.
1008         */
1009         uint16 _partition_flags;
1010         uint16 _partition_number;
1011
1012         /*! - "+NSR03" Volume recorded according to ECMA-167, i.e. UDF
1013                 - "+CD001" Volume recorded according to ECMA-119, i.e. iso9660
1014                 - "+FDC01" Volume recorded according to ECMA-107
1015                 - "+CDW02" Volume recorded according to ECMA-168
1016         */
1017         entity_id _partition_contents;
1018         array<uint8, 128> _partition_contents_use;
1019
1020         /*! See \c partition_access_type enum
1021         */
1022         uint32 _access_type;
1023         uint32 _start;
1024         uint32 _length;
1025         entity_id _implementation_id;
1026         array<uint8, 128> _implementation_use;
1027         array<uint8, 156> _reserved;
1028 } __attribute__((packed));
1029
1030
1031 enum partition_access_type {
1032         ACCESS_UNSPECIFIED,
1033         ACCESS_READ_ONLY,
1034         ACCESS_WRITE_ONCE,
1035         ACCESS_REWRITABLE,
1036         ACCESS_OVERWRITABLE,
1037 };
1038
1039
1040 /*! \brief Logical volume descriptor
1041
1042         See also: ECMA 167 3/10.6, UDF-2.01 2.2.4
1043 */
1044 struct logical_volume_descriptor {
1045         void dump() const;
1046
1047         // Get functions
1048         const descriptor_tag & tag() const { return _tag; }
1049         descriptor_tag & tag() { return _tag; }
1050
1051         uint32 vds_number() const { return B_LENDIAN_TO_HOST_INT32(_vds_number); }
1052
1053         const charspec& character_set() const { return _character_set; }
1054         charspec& character_set() { return _character_set; }
1055
1056         const array<char, 128>& logical_volume_identifier() const { return _logical_volume_identifier; }
1057         array<char, 128>& logical_volume_identifier() { return _logical_volume_identifier; }
1058
1059         uint32 logical_block_size() const { return B_LENDIAN_TO_HOST_INT32(_logical_block_size); }
1060
1061         const entity_id& domain_id() const { return _domain_id; }
1062         entity_id& domain_id() { return _domain_id; }
1063
1064         const array<uint8, 16>& logical_volume_contents_use() const { return _logical_volume_contents_use; }
1065         array<uint8, 16>& logical_volume_contents_use() { return _logical_volume_contents_use; }
1066
1067         const long_address& file_set_address() const { return *reinterpret_cast<const long_address*>(&_logical_volume_contents_use); }
1068         long_address& file_set_address() { return *reinterpret_cast<long_address*>(&_logical_volume_contents_use); }
1069
1070         uint32 map_table_length() const { return B_LENDIAN_TO_HOST_INT32(_map_table_length); }
1071         uint32 partition_map_count() const { return B_LENDIAN_TO_HOST_INT32(_partition_map_count); }
1072
1073         const entity_id& implementation_id() const { return _implementation_id; }
1074         entity_id& implementation_id() { return _implementation_id; }
1075
1076         const array<uint8, 128>& implementation_use() const { return _implementation_use; }
1077         array<uint8, 128>& implementation_use() { return _implementation_use; }
1078
1079         const extent_address& integrity_sequence_extent() const { return _integrity_sequence_extent; }
1080         extent_address& integrity_sequence_extent() { return _integrity_sequence_extent; }
1081
1082         const uint8* partition_maps() const { return _partition_maps; }
1083         uint8* partition_maps() { return _partition_maps; }
1084
1085         // Set functions
1086         void set_vds_number(uint32 number) { _vds_number = B_HOST_TO_LENDIAN_INT32(number); }
1087         void set_logical_block_size(uint32 size) { _logical_block_size = B_HOST_TO_LENDIAN_INT32(size); }
1088
1089         void set_map_table_length(uint32 length) { _map_table_length = B_HOST_TO_LENDIAN_INT32(length); }
1090         void set_partition_map_count(uint32 count) { _partition_map_count = B_HOST_TO_LENDIAN_INT32(count); }
1091
1092         // Other functions
1093         logical_volume_descriptor& operator=(const logical_volume_descriptor &rhs);
1094
1095 private:
1096         descriptor_tag  _tag;
1097         uint32 _vds_number;
1098
1099         /*! \brief Identifies the character set for the
1100                 \c logical_volume_identifier field.
1101
1102                 To be set to CS0.
1103         */
1104         charspec _character_set;
1105         array<char, 128> _logical_volume_identifier;
1106         uint32 _logical_block_size;
1107
1108         /*! \brief To be set to 0 or "*OSTA UDF Compliant". See UDF specs.
1109         */
1110         entity_id _domain_id;
1111
1112         /*! \brief For UDF, shall contain a \c long_address which identifies
1113                 the location of the logical volume's first file set.
1114         */
1115         array<uint8, 16> _logical_volume_contents_use;
1116
1117         uint32 _map_table_length;
1118         uint32 _partition_map_count;
1119         entity_id _implementation_id;
1120         array<uint8, 128> _implementation_use;
1121
1122         /*! \brief Logical volume integrity sequence location.
1123
1124                 For re/overwritable media, shall be a min of 8KB in length.
1125                 For WORM media, shall be quite frickin large, as a new volume
1126                 must be added to the set if the extent fills up (since you
1127                 can't chain lvis's I guess).
1128         */
1129         extent_address _integrity_sequence_extent;
1130
1131         /*! \brief Restricted to maps of type 1 for normal maps and
1132                 UDF type 2 for virtual maps or maps on systems not supporting
1133                 defect management.
1134
1135                 Note that we actually allocate memory for the partition maps
1136                 here due to the fact that we allocate logical_volume_descriptor
1137                 objects on the stack sometimes.
1138
1139                 See UDF-2.01 2.2.8, 2.2.9
1140         */
1141         uint8 _partition_maps[UDF_MAX_PARTITION_MAPS * UDF_MAX_PARTITION_MAP_SIZE];
1142 } __attribute__((packed));
1143
1144 //! Base size (excluding partition maps) of lvd
1145 extern const uint32 kLogicalVolumeDescriptorBaseSize;
1146
1147 /*! \brief (Mostly) common portion of various partition maps
1148
1149         See also: ECMA-167 3/10.7.1
1150 */
1151 struct partition_map_header {
1152 public:
1153         uint8 type() const { return _type; }
1154         uint8 length() const { return _length; }
1155         uint8 *map_data() { return _map_data; }
1156         const uint8 *map_data() const { return _map_data; }
1157
1158         entity_id& partition_type_id()
1159                 { return *reinterpret_cast<entity_id*>(&_map_data[2]); }
1160         const entity_id& partition_type_id() const
1161                 { return *reinterpret_cast<const entity_id*>(&_map_data[2]); }
1162
1163         void set_type(uint8 type) { _type = type; }
1164         void set_length(uint8 length) { _length = length; }
1165 private:
1166         uint8 _type;
1167         uint8 _length;
1168         uint8 _map_data[0];
1169 };// __attribute__((packed));
1170
1171
1172 /*! \brief Physical partition map (i.e. ECMA-167 Type 1 partition map)
1173
1174         See also: ECMA-167 3/10.7.2
1175 */
1176 struct physical_partition_map {
1177 public:
1178         void dump();
1179
1180         uint8 type() const { return _type; }
1181         uint8 length() const { return _length; }
1182
1183         uint16 volume_sequence_number() const {
1184                 return B_LENDIAN_TO_HOST_INT16(_volume_sequence_number); }
1185         uint16 partition_number() const {
1186                 return B_LENDIAN_TO_HOST_INT16(_partition_number); }
1187
1188         void set_type(uint8 type) { _type = type; }
1189         void set_length(uint8 length) { _length = length; }
1190         void set_volume_sequence_number(uint16 number) {
1191                 _volume_sequence_number = B_HOST_TO_LENDIAN_INT16(number); }
1192         void set_partition_number(uint16 number) {
1193                 _partition_number = B_HOST_TO_LENDIAN_INT16(number); }
1194 private:
1195         uint8 _type;
1196         uint8 _length;
1197         uint16 _volume_sequence_number;
1198         uint16 _partition_number;
1199 } __attribute__((packed));
1200
1201
1202 /* ----UDF Specific---- */
1203 /*! \brief Virtual partition map
1204
1205         Note that this map is a customization of the ECMA-167
1206         type 2 partition map.
1207
1208         See also: UDF-2.01 2.2.8
1209 */
1210 struct virtual_partition_map {
1211         uint8 type;
1212         uint8 length;
1213         uint8 reserved1[2];
1214
1215         /*! - flags: 0
1216             - identifier: "*UDF Virtual Partition"
1217             - identifier_suffix: per UDF-2.01 2.1.5.3
1218         */
1219         entity_id partition_type_id;
1220         uint16 volume_sequence_number;
1221
1222         /*! corresponding type 1 partition map in same logical volume
1223         */
1224         uint16 partition_number;
1225         uint8 reserved2[24];
1226 } __attribute__((packed));
1227
1228
1229 /*! \brief Maximum number of redundant sparing tables found in
1230         sparable_partition_map structures.
1231 */
1232 #define UDF_MAX_SPARING_TABLE_COUNT 4
1233
1234 /* ----UDF Specific---- */
1235 /*! \brief Sparable partition map
1236
1237         Note that this map is a customization of the ECMA-167
1238         type 2 partition map.
1239
1240         See also: UDF-2.01 2.2.9
1241 */
1242 struct sparable_partition_map {
1243 public:
1244         void dump();
1245
1246         uint8 type() const { return _type; }
1247         uint8 length() const { return _length; }
1248
1249         entity_id& partition_type_id() { return _partition_type_id; }
1250         const entity_id& partition_type_id() const { return _partition_type_id; }
1251
1252         uint16 volume_sequence_number() const {
1253                 return B_LENDIAN_TO_HOST_INT16(_volume_sequence_number); }
1254         uint16 partition_number() const {
1255                 return B_LENDIAN_TO_HOST_INT16(_partition_number); }
1256         uint16 packet_length() const {
1257                 return B_LENDIAN_TO_HOST_INT16(_packet_length); }
1258         uint8 sparing_table_count() const { return _sparing_table_count; }
1259         uint32 sparing_table_size() const {
1260                 return B_LENDIAN_TO_HOST_INT32(_sparing_table_size); }
1261         uint32 sparing_table_location(uint8 index) const {
1262                 return B_LENDIAN_TO_HOST_INT32(_sparing_table_locations[index]); }
1263
1264
1265         void set_type(uint8 type) { _type = type; }
1266         void set_length(uint8 length) { _length = length; }
1267         void set_volume_sequence_number(uint16 number) {
1268                 _volume_sequence_number = B_HOST_TO_LENDIAN_INT16(number); }
1269         void set_partition_number(uint16 number) {
1270                 _partition_number = B_HOST_TO_LENDIAN_INT16(number); }
1271         void set_packet_length(uint16 length) {
1272                 _packet_length = B_HOST_TO_LENDIAN_INT16(length); }
1273         void set_sparing_table_count(uint8 count) {
1274                 _sparing_table_count = count; }
1275         void set_sparing_table_size(uint32 size) {
1276                 _sparing_table_size = B_HOST_TO_LENDIAN_INT32(size); }
1277         void set_sparing_table_location(uint8 index, uint32 location) {
1278                 _sparing_table_locations[index] = B_HOST_TO_LENDIAN_INT32(location); }
1279 private:
1280         uint8 _type;
1281         uint8 _length;
1282         uint8 _reserved1[2];
1283
1284         /*! - flags: 0
1285             - identifier: "*UDF Sparable Partition"
1286             - identifier_suffix: per UDF-2.01 2.1.5.3
1287         */
1288         entity_id _partition_type_id;
1289         uint16 _volume_sequence_number;
1290
1291         //! partition number of corresponding partition descriptor
1292         uint16 _partition_number;
1293         uint16 _packet_length;
1294         uint8 _sparing_table_count;
1295         uint8 _reserved2;
1296         uint32 _sparing_table_size;
1297         uint32 _sparing_table_locations[UDF_MAX_SPARING_TABLE_COUNT];
1298 } __attribute__((packed));
1299
1300
1301 /* ----UDF Specific---- */
1302 /*! \brief Metadata partition map
1303
1304         Note that this map is a customization of the ECMA-167
1305         type 2 partition map.
1306
1307         See also: UDF-2.50 2.2.10
1308 */
1309 struct metadata_partition_map {
1310 public:
1311         entity_id& partition_type_id() { return _partition_type_id; }
1312         const entity_id& partition_type_id() const { return _partition_type_id; }
1313
1314         uint16 volume_sequence_number() const {
1315                 return B_LENDIAN_TO_HOST_INT16(_volume_sequence_number); }
1316         void set_volume_sequence_number(uint16 number) {
1317                 _volume_sequence_number = B_HOST_TO_LENDIAN_INT16(number); }
1318
1319         uint16 partition_number() const {
1320                 return B_LENDIAN_TO_HOST_INT16(_partition_number); }
1321         void set_partition_number(uint16 number) {
1322                 _partition_number = B_HOST_TO_LENDIAN_INT16(number); }
1323
1324         uint32 metadata_file_location() const {
1325                 return B_LENDIAN_TO_HOST_INT32(_metadata_file_location); }
1326         void set_metadata_file_location(uint32 location) {
1327                 _metadata_file_location = B_HOST_TO_LENDIAN_INT32(location); }
1328
1329         uint32 metadata_mirror_file_location() const {
1330                 return B_LENDIAN_TO_HOST_INT32(_metadata_mirror_file_location); }
1331         void set_metadata_mirror_file_location(uint32 location) {
1332                 _metadata_mirror_file_location = B_HOST_TO_LENDIAN_INT32(location); }
1333
1334         uint32 metadata_bitmap_file_location() const {
1335                 return B_LENDIAN_TO_HOST_INT32(_metadata_bitmap_file_location); }
1336         void set_metadata_bitmap_file_location(uint32 location) {
1337                 _metadata_bitmap_file_location = B_HOST_TO_LENDIAN_INT32(location); }
1338
1339         uint32 allocation_unit_size() const {
1340                 return B_LENDIAN_TO_HOST_INT32(_allocation_unit_size); }
1341         void set_allocation_unit_size(uint32 size) {
1342                 _allocation_unit_size = B_HOST_TO_LENDIAN_INT32(size); }
1343
1344         uint32 alignment_unit_size() const {
1345                 return B_LENDIAN_TO_HOST_INT32(_alignment_unit_size); }
1346         void set_alignment_unit_size(uint32 size) {
1347                 _alignment_unit_size = B_HOST_TO_LENDIAN_INT32(size); }
1348
1349         uint8 flags() const { return _flags; }
1350         void set_flags(uint8 flags) { _flags = flags; }
1351
1352 private:
1353         uint8 type;
1354         uint8 length;
1355         uint8 reserved1[2];
1356
1357         /*! - flags: 0
1358             - identifier: "*UDF Metadata Partition"
1359             - identifier_suffix: per UDF-2.50 2.1.5
1360         */
1361         entity_id _partition_type_id;
1362         uint16 _volume_sequence_number;
1363
1364         /*! corresponding type 1 or type 2 sparable partition
1365             map in same logical volume
1366         */
1367         uint16 _partition_number;
1368         uint32 _metadata_file_location;
1369         uint32 _metadata_mirror_file_location;
1370         uint32 _metadata_bitmap_file_location;
1371         uint32 _allocation_unit_size;
1372         uint16 _alignment_unit_size;
1373         uint8 _flags;
1374         uint8 reserved2[5];
1375 } __attribute__((packed));
1376
1377
1378 /*! \brief Unallocated space descriptor
1379
1380         See also: ECMA-167 3/10.8
1381 */
1382 struct unallocated_space_descriptor {
1383         void dump() const;
1384
1385         // Get functions
1386         const descriptor_tag & tag() const { return _tag; }
1387         descriptor_tag & tag() { return _tag; }
1388         uint32 vds_number() const { return B_LENDIAN_TO_HOST_INT32(_vds_number); }
1389         uint32 allocation_descriptor_count() const { return B_LENDIAN_TO_HOST_INT32(_allocation_descriptor_count); }
1390         extent_address* allocation_descriptors() { return _allocation_descriptors; }
1391
1392         // Set functions
1393         void set_vds_number(uint32 number) { _vds_number = B_HOST_TO_LENDIAN_INT32(number); }
1394         void set_allocation_descriptor_count(uint32 count) { _allocation_descriptor_count = B_HOST_TO_LENDIAN_INT32(count); }
1395 private:
1396         descriptor_tag  _tag;
1397         uint32 _vds_number;
1398         uint32 _allocation_descriptor_count;
1399         extent_address _allocation_descriptors[0];
1400 } __attribute__((packed));
1401
1402
1403 /*! \brief Terminating descriptor
1404
1405         See also: ECMA-167 3/10.9
1406 */
1407 struct terminating_descriptor {
1408         terminating_descriptor() { memset(_reserved.data, 0, _reserved.size()); }
1409         void dump() const;
1410
1411         // Get functions
1412         const descriptor_tag & tag() const { return _tag; }
1413         descriptor_tag & tag() { return _tag; }
1414 private:
1415         descriptor_tag  _tag;
1416         array<uint8, 496> _reserved;
1417 } __attribute__((packed));
1418
1419
1420 /*! \brief Logical volume integrity descriptor
1421
1422         See also: ECMA-167 3/10.10, UDF-2.50 2.2.6
1423 */
1424 struct logical_volume_integrity_descriptor {
1425 public:
1426         static const uint32 minimum_implementation_use_length = 46;
1427
1428         void dump() const;
1429         uint32 descriptor_size() const { return sizeof(*this)+implementation_use_length()
1430                                          + partition_count()*sizeof(uint32)*2; }
1431
1432         descriptor_tag& tag() { return _tag; }
1433         const descriptor_tag& tag() const { return _tag; }
1434
1435         timestamp& recording_time() { return _recording_time; }
1436         const timestamp& recording_time() const { return _recording_time; }
1437
1438         uint32 integrity_type() const { return B_LENDIAN_TO_HOST_INT32(_integrity_type); }
1439
1440         extent_address& next_integrity_extent() { return _next_integrity_extent; }
1441         const extent_address& next_integrity_extent() const { return _next_integrity_extent; }
1442
1443         array<uint8, 32>& logical_volume_contents_use() { return _logical_volume_contents_use; }
1444         const array<uint8, 32>& logical_volume_contents_use() const { return _logical_volume_contents_use; }
1445
1446         // next_unique_id() field is actually stored in the logical_volume_contents_use()
1447         // field, per UDF-2.50 3.2.1
1448         uint64 next_unique_id() const { return B_LENDIAN_TO_HOST_INT64(_next_unique_id()); }
1449
1450         uint32 partition_count() const { return B_LENDIAN_TO_HOST_INT32(_partition_count); }
1451         uint32 implementation_use_length() const { return B_LENDIAN_TO_HOST_INT32(_implementation_use_length); }
1452
1453         /*! \todo double-check the pointer arithmetic here. */
1454         uint32* free_space_table() { return reinterpret_cast<uint32*>(reinterpret_cast<uint8*>(this)+80); }
1455         const uint32* free_space_table() const { return reinterpret_cast<const uint32*>(reinterpret_cast<const uint8*>(this)+80); }
1456         uint32* size_table() { return reinterpret_cast<uint32*>(reinterpret_cast<uint8*>(free_space_table())+partition_count()*sizeof(uint32)); }
1457         const uint32* size_table() const { return reinterpret_cast<const uint32*>(reinterpret_cast<const uint8*>(free_space_table())+partition_count()*sizeof(uint32)); }
1458         uint8* implementation_use() { return reinterpret_cast<uint8*>(reinterpret_cast<uint8*>(size_table())+partition_count()*sizeof(uint32)); }
1459         const uint8* implementation_use() const { return reinterpret_cast<const uint8*>(reinterpret_cast<const uint8*>(size_table())+partition_count()*sizeof(uint32)); }
1460
1461         // accessors for fields stored in implementation_use() field per UDF-2.50 2.2.6.4
1462         entity_id& implementation_id() { return _accessor().id; }
1463         const entity_id& implementation_id() const { return _accessor().id; }
1464         uint32 file_count() const { return B_LENDIAN_TO_HOST_INT32(_accessor().file_count); }
1465         uint32 directory_count() const { return B_LENDIAN_TO_HOST_INT32(_accessor().directory_count); }
1466         uint16 minimum_udf_read_revision() const { return B_LENDIAN_TO_HOST_INT16(_accessor().minimum_udf_read_revision); }
1467         uint16 minimum_udf_write_revision() const { return B_LENDIAN_TO_HOST_INT16(_accessor().minimum_udf_write_revision); }
1468         uint16 maximum_udf_write_revision() const { return B_LENDIAN_TO_HOST_INT16(_accessor().maximum_udf_write_revision); }
1469
1470         // set functions
1471         void set_integrity_type(uint32 type) { _integrity_type = B_HOST_TO_LENDIAN_INT32(type); }
1472         void set_next_unique_id(uint64 id) { _next_unique_id() = B_HOST_TO_LENDIAN_INT64(id); }
1473         void set_partition_count(uint32 count) { _partition_count = B_HOST_TO_LENDIAN_INT32(count); }
1474         void set_implementation_use_length(uint32 length) { _implementation_use_length = B_HOST_TO_LENDIAN_INT32(length); }
1475
1476         // set functions for fields stored in implementation_use() field per UDF-2.50 2.2.6.4
1477         void set_file_count(uint32 count) { _accessor().file_count = B_HOST_TO_LENDIAN_INT32(count); }
1478         void set_directory_count(uint32 count) { _accessor().directory_count = B_HOST_TO_LENDIAN_INT32(count); }
1479         void set_minimum_udf_read_revision(uint16 revision) { _accessor().minimum_udf_read_revision = B_HOST_TO_LENDIAN_INT16(revision); }
1480         void set_minimum_udf_write_revision(uint16 revision) { _accessor().minimum_udf_write_revision = B_HOST_TO_LENDIAN_INT16(revision); }
1481         void set_maximum_udf_write_revision(uint16 revision) { _accessor().maximum_udf_write_revision = B_HOST_TO_LENDIAN_INT16(revision); }
1482
1483 private:
1484         struct _lvid_implementation_use_accessor {
1485                 entity_id id;
1486                 uint32 file_count;
1487                 uint32 directory_count;
1488                 uint16 minimum_udf_read_revision;
1489                 uint16 minimum_udf_write_revision;
1490                 uint16 maximum_udf_write_revision;
1491         };
1492
1493         _lvid_implementation_use_accessor& _accessor() {
1494                 return *reinterpret_cast<_lvid_implementation_use_accessor*>(implementation_use());
1495         }
1496         const _lvid_implementation_use_accessor& _accessor() const {
1497                 return *reinterpret_cast<const _lvid_implementation_use_accessor*>(implementation_use());
1498         }
1499
1500         uint64& _next_unique_id() { return *reinterpret_cast<uint64*>(logical_volume_contents_use().data); }
1501         const uint64& _next_unique_id() const { return *reinterpret_cast<const uint64*>(logical_volume_contents_use().data); }
1502
1503         descriptor_tag  _tag;
1504         timestamp _recording_time;
1505         uint32 _integrity_type;
1506         extent_address _next_integrity_extent;
1507         array<uint8, 32> _logical_volume_contents_use;
1508         uint32 _partition_count;
1509         uint32 _implementation_use_length;
1510
1511 } __attribute__((packed));
1512
1513 /*! \brief Logical volume integrity types
1514 */
1515 enum {
1516         INTEGRITY_OPEN = 0,
1517         INTEGRITY_CLOSED = 1,
1518 };
1519
1520 /*! \brief Highest currently supported UDF read revision.
1521 */
1522 #define UDF_MAX_READ_REVISION 0x0250
1523
1524 //----------------------------------------------------------------------
1525 // ECMA-167 Part 4
1526 //----------------------------------------------------------------------
1527
1528
1529
1530 /*! \brief File set descriptor
1531
1532         Contains all the pertinent info about a file set (i.e. a hierarchy of files)
1533
1534         According to UDF-2.01, only one file set descriptor shall be recorded,
1535         except on WORM media, where the following rules apply:
1536         - Multiple file sets are allowed only on WORM media
1537         - The default file set shall be the one with highest value \c file_set_number field.
1538         - Only the default file set may be flagged as writeable. All others shall be
1539           flagged as "hard write protect".
1540         - No writeable file set may reference metadata structures which are referenced
1541           (directly or indirectly) by any other file set. Writeable file sets may, however,
1542           reference actual file data extents that are also referenced by other file sets.
1543 */
1544 struct file_set_descriptor {
1545         void dump() const;
1546
1547         // Get functions
1548         const descriptor_tag & tag() const { return _tag; }
1549         descriptor_tag & tag() { return _tag; }
1550
1551         const timestamp& recording_date_and_time() const { return _recording_date_and_time; }
1552         timestamp& recording_date_and_time() { return _recording_date_and_time; }
1553
1554         uint16 interchange_level() const { return B_LENDIAN_TO_HOST_INT16(_interchange_level); }
1555         uint16 max_interchange_level() const { return B_LENDIAN_TO_HOST_INT16(_max_interchange_level); }
1556         uint32 character_set_list() const { return B_LENDIAN_TO_HOST_INT32(_character_set_list); }
1557         uint32 max_character_set_list() const { return B_LENDIAN_TO_HOST_INT32(_max_character_set_list); }
1558         uint32 file_set_number() const { return B_LENDIAN_TO_HOST_INT32(_file_set_number); }
1559         uint32 file_set_descriptor_number() const { return B_LENDIAN_TO_HOST_INT32(_file_set_descriptor_number); }
1560
1561         const charspec& logical_volume_id_character_set() const { return _logical_volume_id_character_set; }
1562         charspec& logical_volume_id_character_set() { return _logical_volume_id_character_set; }
1563
1564         const array<char, 128>& logical_volume_id() const { return _logical_volume_id; }
1565         array<char, 128>& logical_volume_id() { return _logical_volume_id; }
1566
1567         const charspec& file_set_id_character_set() const { return _file_set_id_character_set; }
1568         charspec& file_set_id_character_set() { return _file_set_id_character_set; }
1569
1570         const array<char, 32>& file_set_id() const { return _file_set_id; }
1571         array<char, 32>& file_set_id() { return _file_set_id; }
1572
1573         const array<char, 32>& copyright_file_id() const { return _copyright_file_id; }
1574         array<char, 32>& copyright_file_id() { return _copyright_file_id; }
1575
1576         const array<char, 32>& abstract_file_id() const { return _abstract_file_id; }
1577         array<char, 32>& abstract_file_id() { return _abstract_file_id; }
1578
1579         const long_address& root_directory_icb() const { return _root_directory_icb; }
1580         long_address& root_directory_icb() { return _root_directory_icb; }
1581
1582         const entity_id& domain_id() const { return _domain_id; }
1583         entity_id& domain_id() { return _domain_id; }
1584
1585         const long_address& next_extent() const { return _next_extent; }
1586         long_address& next_extent() { return _next_extent; }
1587
1588         const long_address& system_stream_directory_icb() const { return _system_stream_directory_icb; }
1589         long_address& system_stream_directory_icb() { return _system_stream_directory_icb; }
1590
1591         const array<uint8, 32>& reserved() const { return _reserved; }
1592         array<uint8, 32>& reserved() { return _reserved; }
1593
1594         // Set functions
1595         void set_interchange_level(uint16 level) { _interchange_level = B_HOST_TO_LENDIAN_INT16(level); }
1596         void set_max_interchange_level(uint16 level) { _max_interchange_level = B_HOST_TO_LENDIAN_INT16(level); }
1597         void set_character_set_list(uint32 list) { _character_set_list = B_HOST_TO_LENDIAN_INT32(list); }
1598         void set_max_character_set_list(uint32 list) { _max_character_set_list = B_HOST_TO_LENDIAN_INT32(list); }
1599         void set_file_set_number(uint32 number) { _file_set_number = B_HOST_TO_LENDIAN_INT32(number); }
1600         void set_file_set_descriptor_number(uint32 number) { _file_set_descriptor_number = B_HOST_TO_LENDIAN_INT32(number); }
1601 private:
1602         descriptor_tag  _tag;
1603         timestamp _recording_date_and_time;
1604         uint16 _interchange_level;                      //!< To be set to 3 (see UDF-2.01 2.3.2.1)
1605         uint16 _max_interchange_level;          //!< To be set to 3 (see UDF-2.01 2.3.2.2)
1606         uint32 _character_set_list;
1607         uint32 _max_character_set_list;
1608         uint32 _file_set_number;
1609         uint32 _file_set_descriptor_number;
1610         charspec _logical_volume_id_character_set;      //!< To be set to kCSOCharspec
1611         array<char, 128> _logical_volume_id;
1612         charspec _file_set_id_character_set;
1613         array<char, 32> _file_set_id;
1614         array<char, 32> _copyright_file_id;
1615         array<char, 32> _abstract_file_id;
1616         long_address _root_directory_icb;
1617         entity_id _domain_id;
1618         long_address _next_extent;
1619         long_address _system_stream_directory_icb;
1620         array<uint8, 32> _reserved;
1621 } __attribute__((packed));
1622
1623
1624 /*! \brief Partition header descriptor
1625
1626         Contains references to unallocated and freed space data structures.
1627
1628         Note that unallocated space is space ready to be written with no
1629         preprocessing. Freed space is space needing preprocessing (i.e.
1630         a special write pass) before use.
1631
1632         Per UDF-2.01 2.3.3, the use of tables or bitmaps shall be consistent,
1633         i.e. only one type or the other shall be used, not both.
1634
1635         To indicate disuse of a certain field, the fields of the allocation
1636         descriptor shall all be set to 0.
1637
1638         See also: ECMA-167 4/14.3, UDF-2.01 2.2.3
1639 */
1640 struct partition_header_descriptor {
1641         long_address unallocated_space_table;
1642         long_address unallocated_space_bitmap;
1643         /*! Unused, per UDF-2.01 2.2.3 */
1644         long_address partition_integrity_table;
1645         long_address freed_space_table;
1646         long_address freed_space_bitmap;
1647         uint8 reserved[88];
1648 } __attribute__((packed));
1649
1650 #define kMaxFileIdSize (sizeof(file_id_descriptor)+512+3)
1651
1652 /*! \brief File identifier descriptor
1653
1654         Identifies the name of a file entry, and the location of its corresponding
1655         ICB.
1656
1657         See also: ECMA-167 4/14.4, UDF-2.01 2.3.4
1658
1659         \todo Check pointer arithmetic
1660 */
1661 struct file_id_descriptor {
1662 public:
1663         uint32 descriptor_size() const { return total_length(); }
1664         void dump() const;
1665
1666         descriptor_tag & tag() { return _tag; }
1667         const descriptor_tag & tag() const { return _tag; }
1668
1669         uint16 version_number() const { return B_LENDIAN_TO_HOST_INT16(_version_number); }
1670
1671         uint8 characteristics() const { return _characteristics; }
1672
1673         bool may_be_hidden() const {
1674                 characteristics_accessor c;
1675                 c.all = characteristics();
1676                 return c.bits.may_be_hidden;
1677         }
1678
1679         bool is_directory() const {
1680                 characteristics_accessor c;
1681                 c.all = characteristics();
1682                 return c.bits.is_directory;
1683         }
1684
1685         bool is_deleted() const {
1686                 characteristics_accessor c;
1687                 c.all = characteristics();
1688                 return c.bits.is_deleted;
1689         }
1690
1691         bool is_parent() const {
1692                 characteristics_accessor c;
1693                 c.all = characteristics();
1694                 return c.bits.is_parent;
1695         }
1696
1697         bool is_metadata_stream() const {
1698                 characteristics_accessor c;
1699                 c.all = characteristics();
1700                 return c.bits.is_metadata_stream;
1701         }
1702
1703         uint8 id_length() const { return _id_length; }
1704
1705         long_address& icb() { return _icb; }
1706         const long_address& icb() const { return _icb; }
1707
1708         uint16 implementation_use_length() const { return B_LENDIAN_TO_HOST_INT16(_implementation_use_length); }
1709
1710         /*! If implementation_use_length is greater than 0, the first 32
1711                 bytes of implementation_use() shall be an entity_id identifying
1712                 the implementation that generated the rest of the data in the
1713                 implementation_use() field.
1714         */
1715         uint8* implementation_use() { return ((uint8*)this)+(38); }
1716         char* id() { return ((char*)this)+(38)+implementation_use_length(); }
1717         const char* id() const { return ((const char*)this)+(38)+implementation_use_length(); }
1718
1719         uint16 structure_length() const { return (38) + id_length() + implementation_use_length(); }
1720         uint16 padding_length() const { return ((structure_length()+3)/4)*4 - structure_length(); }
1721         uint16 total_length() const { return structure_length() + padding_length(); }
1722
1723         // Set functions
1724         void set_version_number(uint16 number) { _version_number = B_HOST_TO_LENDIAN_INT16(number); }
1725
1726         void set_characteristics(uint8 characteristics) { _characteristics = characteristics; }
1727
1728         void set_may_be_hidden(bool how) {
1729                 characteristics_accessor c;
1730                 c.all = characteristics();
1731                 c.bits.may_be_hidden = how;
1732                 set_characteristics(c.all);
1733         }
1734
1735         void set_is_directory(bool how) {
1736                 characteristics_accessor c;
1737                 c.all = characteristics();
1738                 c.bits.is_directory = how;
1739                 set_characteristics(c.all);
1740         }
1741
1742         void set_is_deleted(bool how) {
1743                 characteristics_accessor c;
1744                 c.all = characteristics();
1745                 c.bits.is_deleted = how;
1746                 set_characteristics(c.all);
1747         }
1748
1749         void set_is_parent(bool how) {
1750                 characteristics_accessor c;
1751                 c.all = characteristics();
1752                 c.bits.is_parent = how;
1753                 set_characteristics(c.all);
1754         }
1755
1756         void set_is_metadata_stream(bool how) {
1757                 characteristics_accessor c;
1758                 c.all = characteristics();
1759                 c.bits.is_metadata_stream = how;
1760                 set_characteristics(c.all);
1761         }
1762
1763
1764         void set_id_length(uint8 id_length) { _id_length = id_length; }
1765         void set_implementation_use_length(uint16 implementation_use_length) { _implementation_use_length = B_HOST_TO_LENDIAN_INT16(implementation_use_length); }
1766
1767
1768
1769 private:
1770         union characteristics_accessor {
1771                 uint8 all;
1772                 struct {
1773                         uint8   may_be_hidden:1,
1774                                         is_directory:1,
1775                                         is_deleted:1,
1776                                         is_parent:1,
1777                                         is_metadata_stream:1,
1778                                         reserved_characteristics:3;
1779                 } bits;
1780         };
1781
1782         descriptor_tag  _tag;
1783         /*! According to ECMA-167: 1 <= valid version_number <= 32767, 32768 <= reserved <= 65535.
1784
1785                 However, according to UDF-2.01, there shall be exactly one version of
1786                 a file, and it shall be 1.
1787          */
1788         uint16 _version_number;
1789         /*! \todo Check UDF-2.01 2.3.4.2 for some more restrictions. */
1790         uint8 _characteristics;
1791         uint8 _id_length;
1792         long_address _icb;
1793         uint16 _implementation_use_length;
1794 } __attribute__((packed));
1795
1796
1797 /*! \brief Allocation extent descriptor
1798
1799         See also: ECMA-167 4/14.5
1800 */
1801 struct allocation_extent_descriptor {
1802         descriptor_tag  tag;
1803         uint32 previous_allocation_extent_location;
1804         uint32 length_of_allocation_descriptors;
1805
1806         /*! \todo Check that this is really how things work: */
1807         uint8* allocation_descriptors() { return (uint8*)(reinterpret_cast<uint8*>(this)+sizeof(allocation_extent_descriptor)); }
1808 } __attribute__((packed));
1809
1810
1811 /*! \brief icb_tag::file_type values
1812
1813         See also ECMA-167 4/14.6.6
1814 */
1815 enum icb_file_types {
1816         ICB_TYPE_UNSPECIFIED = 0,
1817         ICB_TYPE_UNALLOCATED_SPACE_ENTRY,
1818         ICB_TYPE_PARTITION_INTEGRITY_ENTRY,
1819         ICB_TYPE_INDIRECT_ENTRY,
1820         ICB_TYPE_DIRECTORY,
1821         ICB_TYPE_REGULAR_FILE,
1822         ICB_TYPE_BLOCK_SPECIAL_DEVICE,
1823         ICB_TYPE_CHARACTER_SPECIAL_DEVICE,
1824         ICB_TYPE_EXTENDED_ATTRIBUTES_FILE,
1825         ICB_TYPE_FIFO,
1826         ICB_TYPE_ISSOCK,
1827         ICB_TYPE_TERMINAL,
1828         ICB_TYPE_SYMLINK,
1829         ICB_TYPE_STREAM_DIRECTORY,
1830
1831         ICB_TYPE_RESERVED_START = 14,
1832         ICB_TYPE_RESERVED_END = 247,
1833
1834         ICB_TYPE_CUSTOM_START = 248,
1835         ICB_TYPE_CUSTOM_END = 255,
1836 };
1837
1838 /*!     \brief idb_entry_tag::_flags::descriptor_flags() values
1839
1840         See also ECMA-167 4/14.6.8
1841 */
1842 enum icb_descriptor_types {
1843         ICB_DESCRIPTOR_TYPE_SHORT = 0,
1844         ICB_DESCRIPTOR_TYPE_LONG,
1845         ICB_DESCRIPTOR_TYPE_EXTENDED,
1846         ICB_DESCRIPTOR_TYPE_EMBEDDED,
1847 };
1848
1849 /*!     \brief idb_entry_tag::strategy_type() values
1850
1851         See also UDF-2.50 2.3.5.1
1852 */
1853 enum icb_strategy_types {
1854         ICB_STRATEGY_SINGLE = 4,
1855         ICB_STRATEGY_LINKED_LIST = 4096
1856 };
1857
1858 /*! \brief ICB entry tag
1859
1860         Common tag found in all ICB entries (in addition to, and immediately following,
1861         the descriptor tag).
1862
1863         See also: ECMA-167 4/14.6, UDF-2.01 2.3.5
1864 */
1865 struct icb_entry_tag {
1866 public:
1867         union flags_accessor {
1868                 uint16 all_flags;
1869                 struct {
1870                         uint16  descriptor_flags:3,
1871                                         if_directory_then_sort:1,       //!< To be set to 0 per UDF-2.01 2.3.5.4
1872                                         non_relocatable:1,
1873                                         archive:1,
1874                                         setuid:1,
1875                                         setgid:1,
1876                                         sticky:1,
1877                                         contiguous:1,
1878                                         system:1,
1879                                         transformed:1,
1880                                         multi_version:1,                        //!< To be set to 0 per UDF-2.01 2.3.5.4
1881                                         is_stream:1,
1882                                         reserved_icb_entry_flags:2;
1883                 } flags;
1884         };
1885
1886 public:
1887         void dump() const;
1888
1889         uint32 prior_recorded_number_of_direct_entries() const { return B_LENDIAN_TO_HOST_INT32(_prior_recorded_number_of_direct_entries); }
1890         uint16 strategy_type() const { return B_LENDIAN_TO_HOST_INT16(_strategy_type); }
1891
1892         array<uint8, 2>& strategy_parameters() { return _strategy_parameters; }
1893         const array<uint8, 2>& strategy_parameters() const { return _strategy_parameters; }
1894
1895         uint16 entry_count() const { return B_LENDIAN_TO_HOST_INT16(_entry_count); }
1896         uint8& reserved() { return _reserved; }
1897         uint8 file_type() const { return _file_type; }
1898         logical_block_address& parent_icb_location() { return _parent_icb_location; }
1899         const logical_block_address& parent_icb_location() const { return _parent_icb_location; }
1900
1901         uint16 flags() const { return B_LENDIAN_TO_HOST_INT16(_flags); }
1902         flags_accessor& flags_access() { return *reinterpret_cast<flags_accessor*>(&_flags); }
1903
1904         // flags accessor functions
1905         uint8 descriptor_flags() const {
1906                 flags_accessor f;
1907                 f.all_flags = flags();
1908                 return f.flags.descriptor_flags;
1909         }
1910 /*      void set_descriptor_flags(uint8 value) {
1911                 flags_accessor f;
1912                 f.all_flags = flags();
1913                 f.flags.descriptor_flags = value;
1914                 set_flags
1915 */
1916
1917         void set_prior_recorded_number_of_direct_entries(uint32 entries) { _prior_recorded_number_of_direct_entries = B_LENDIAN_TO_HOST_INT32(entries); }
1918         void set_strategy_type(uint16 type) { _strategy_type = B_HOST_TO_LENDIAN_INT16(type); }
1919
1920         void set_entry_count(uint16 count) { _entry_count = B_LENDIAN_TO_HOST_INT16(count); }
1921         void set_file_type(uint8 type) { _file_type = type; }
1922
1923         void set_flags(uint16 flags) { _flags = B_LENDIAN_TO_HOST_INT16(flags); }
1924
1925 private:
1926         uint32 _prior_recorded_number_of_direct_entries;
1927         /*! Per UDF-2.01 2.3.5.1, only strategy types 4 and 4096 shall be supported.
1928
1929                 \todo Describe strategy types here.
1930         */
1931         uint16 _strategy_type;
1932         array<uint8, 2> _strategy_parameters;
1933         uint16 _entry_count;
1934         uint8 _reserved;
1935         /*! \brief icb_file_type value identifying the type of this icb entry */
1936         uint8 _file_type;
1937         logical_block_address _parent_icb_location;
1938         uint16 _flags;
1939 } __attribute__((packed));
1940
1941 /*! \brief Header portion of an ICB entry.
1942 */
1943 struct icb_header {
1944 public:
1945         void dump() const;
1946
1947         descriptor_tag  &tag() { return _tag; }
1948         const descriptor_tag  &tag() const { return _tag; }
1949
1950         icb_entry_tag &icb_tag() { return _icb_tag; }
1951         const icb_entry_tag &icb_tag() const { return _icb_tag; }
1952 private:
1953         descriptor_tag  _tag;
1954         icb_entry_tag _icb_tag;
1955 };
1956
1957 /*! \brief Indirect ICB entry
1958 */
1959 struct indirect_icb_entry {
1960         descriptor_tag  tag;
1961         icb_entry_tag icb_tag;
1962         long_address indirect_icb;
1963 } __attribute__((packed));
1964
1965
1966 /*! \brief Terminal ICB entry
1967 */
1968 struct terminal_icb_entry {
1969         descriptor_tag  tag;
1970         icb_entry_tag icb_tag;
1971 } __attribute__((packed));
1972
1973 enum permissions {
1974         OTHER_EXECUTE           = 0x0001,
1975         OTHER_WRITE                     = 0x0002,
1976         OTHER_READ                      = 0x0004,
1977         OTHER_ATTRIBUTES        = 0x0008,
1978         OTHER_DELETE            = 0x0010,
1979         GROUP_EXECUTE           = 0x0020,
1980         GROUP_WRITE                     = 0x0040,
1981         GROUP_READ                      = 0x0080,
1982         GROUP_ATTRIBUTES        = 0x0100,
1983         GROUP_DELETE            = 0x0200,
1984         USER_EXECUTE            = 0x0400,
1985         USER_WRITE                      = 0x0800,
1986         USER_READ                       = 0x1000,
1987         USER_ATTRIBUTES         = 0x2000,
1988         USER_DELETE                     = 0x4000,
1989 };
1990
1991 /*! \brief File ICB entry
1992
1993         See also: ECMA-167 4/14.9
1994
1995         \todo Check pointer math.
1996 */
1997 struct file_icb_entry {
1998         void dump() const;
1999         uint32 descriptor_size() const { return sizeof(*this)+extended_attributes_length()
2000                                          +allocation_descriptors_length(); }
2001         const char* descriptor_name() const { return "file_icb_entry"; }
2002
2003         // get functions
2004         descriptor_tag & tag() { return _tag; }
2005         const descriptor_tag & tag() const { return _tag; }
2006
2007         icb_entry_tag& icb_tag() { return _icb_tag; }
2008         const icb_entry_tag& icb_tag() const { return _icb_tag; }
2009
2010         uint32 uid() const { return B_LENDIAN_TO_HOST_INT32(_uid); }
2011         uint32 gid() const { return B_LENDIAN_TO_HOST_INT32(_gid); }
2012         uint32 permissions() const { return B_LENDIAN_TO_HOST_INT32(_permissions); }
2013         uint16 file_link_count() const { return B_LENDIAN_TO_HOST_INT16(_file_link_count); }
2014         uint8 record_format() const { return _record_format; }
2015         uint8 record_display_attributes() const { return _record_display_attributes; }
2016         uint8 record_length() const { return _record_length; }
2017         uint64 information_length() const { return B_LENDIAN_TO_HOST_INT64(_information_length); }
2018         uint64 logical_blocks_recorded() const { return B_LENDIAN_TO_HOST_INT64(_logical_blocks_recorded); }
2019
2020         timestamp& access_date_and_time() { return _access_date_and_time; }
2021         const timestamp& access_date_and_time() const { return _access_date_and_time; }
2022
2023         timestamp& modification_date_and_time() { return _modification_date_and_time; }
2024         const timestamp& modification_date_and_time() const { return _modification_date_and_time; }
2025
2026         timestamp& attribute_date_and_time() { return _attribute_date_and_time; }
2027         const timestamp& attribute_date_and_time() const { return _attribute_date_and_time; }
2028
2029         uint32 checkpoint() const { return B_LENDIAN_TO_HOST_INT32(_checkpoint); }
2030
2031         long_address& extended_attribute_icb() { return _extended_attribute_icb; }
2032         const long_address& extended_attribute_icb() const { return _extended_attribute_icb; }
2033
2034         entity_id& implementation_id() { return _implementation_id; }
2035         const entity_id& implementation_id() const { return _implementation_id; }
2036
2037         uint64 unique_id() const { return B_LENDIAN_TO_HOST_INT64(_unique_id); }
2038         uint32 extended_attributes_length() const { return B_LENDIAN_TO_HOST_INT32(_extended_attributes_length); }
2039         uint32 allocation_descriptors_length() const { return B_LENDIAN_TO_HOST_INT32(_allocation_descriptors_length); }
2040
2041         uint8* extended_attributes() { return _end(); }
2042         const uint8* extended_attributes() const { return _end(); }
2043         uint8* allocation_descriptors() { return _end()+extended_attributes_length(); }
2044         const uint8* allocation_descriptors() const { return _end()+extended_attributes_length(); }
2045
2046         // set functions
2047         void set_uid(uint32 uid) { _uid = B_HOST_TO_LENDIAN_INT32(uid); }
2048         void set_gid(uint32 gid) { _gid = B_HOST_TO_LENDIAN_INT32(gid); }
2049         void set_permissions(uint32 permissions) { _permissions = B_HOST_TO_LENDIAN_INT32(permissions); }
2050
2051         void set_file_link_count(uint16 count) { _file_link_count = B_HOST_TO_LENDIAN_INT16(count); }
2052         void set_record_format(uint8 format) { _record_format = format; }
2053         void set_record_display_attributes(uint8 attributes) { _record_display_attributes = attributes; }
2054         void set_record_length(uint8 length) { _record_length = length; }
2055
2056         void set_information_length(uint64 length) { _information_length = B_HOST_TO_LENDIAN_INT64(length); }
2057         void set_logical_blocks_recorded(uint64 blocks) { _logical_blocks_recorded = B_HOST_TO_LENDIAN_INT64(blocks); }
2058
2059         void set_checkpoint(uint32 checkpoint) { _checkpoint = B_HOST_TO_LENDIAN_INT32(checkpoint); }
2060
2061         void set_unique_id(uint64 id) { _unique_id = B_HOST_TO_LENDIAN_INT64(id); }
2062
2063         void set_extended_attributes_length(uint32 length) { _extended_attributes_length = B_HOST_TO_LENDIAN_INT32(length); }
2064         void set_allocation_descriptors_length(uint32 length) { _allocation_descriptors_length = B_HOST_TO_LENDIAN_INT32(length); }
2065
2066         // extended_file_icb_entry compatability functions
2067         timestamp& creation_date_and_time() { return _attribute_date_and_time; }
2068         const timestamp& creation_date_and_time() const { return _attribute_date_and_time; }
2069
2070
2071         void set_object_size(uint64 size) { }
2072         void set_reserved(uint32 reserved) { }
2073         long_address& stream_directory_icb() { return _dummy_stream_directory_icb; }
2074         const long_address& stream_directory_icb() const { return _dummy_stream_directory_icb; }
2075
2076
2077 private:
2078         static const uint32 _descriptor_length = 176;
2079         static long_address _dummy_stream_directory_icb;
2080         uint8* _end() { return reinterpret_cast<uint8*>(this)+_descriptor_length; }
2081         const uint8* _end() const { return reinterpret_cast<const uint8*>(this)+_descriptor_length; }
2082
2083         descriptor_tag  _tag;
2084         icb_entry_tag _icb_tag;
2085         uint32 _uid;
2086         uint32 _gid;
2087         /*! \todo List perms in comment and add handy union thingy */
2088         uint32 _permissions;
2089         /*! Identifies the number of file identifier descriptors referencing
2090                 this icb.
2091         */
2092         uint16 _file_link_count;
2093         uint8 _record_format;                           //!< To be set to 0 per UDF-2.01 2.3.6.1
2094         uint8 _record_display_attributes;       //!< To be set to 0 per UDF-2.01 2.3.6.2
2095         uint8 _record_length;                           //!< To be set to 0 per UDF-2.01 2.3.6.3
2096         uint64 _information_length;
2097         uint64 _logical_blocks_recorded;                //!< To be 0 for files and dirs with embedded data
2098         timestamp _access_date_and_time;
2099         timestamp _modification_date_and_time;
2100
2101         // NOTE: data members following this point in the descriptor are in
2102         // different locations in extended file entries
2103
2104         timestamp _attribute_date_and_time;
2105         /*! \brief Initially 1, may be incremented upon user request. */
2106         uint32 _checkpoint;
2107         long_address _extended_attribute_icb;
2108         entity_id _implementation_id;
2109         /*! \brief The unique id identifying this file entry
2110
2111                 The id of the root directory of a file set shall be 0.
2112
2113                 \todo Detail the system specific requirements for unique ids from UDF-2.01
2114         */
2115         uint64 _unique_id;
2116         uint32 _extended_attributes_length;
2117         uint32 _allocation_descriptors_length;
2118
2119 };
2120
2121
2122 /*! \brief Extended file ICB entry
2123
2124         See also: ECMA-167 4/14.17
2125
2126         \todo Check pointer math.
2127 */
2128 struct extended_file_icb_entry {
2129         void dump() const;
2130         uint32 descriptor_size() const { return sizeof(*this)+extended_attributes_length()
2131                                          +allocation_descriptors_length(); }
2132         const char* descriptor_name() const { return "extended_file_icb_entry"; }
2133
2134         // get functions
2135         descriptor_tag & tag() { return _tag; }
2136         const descriptor_tag & tag() const { return _tag; }
2137
2138         icb_entry_tag& icb_tag() { return _icb_tag; }
2139         const icb_entry_tag& icb_tag() const { return _icb_tag; }
2140
2141         uint32 uid() const { return B_LENDIAN_TO_HOST_INT32(_uid); }
2142         uint32 gid() const { return B_LENDIAN_TO_HOST_INT32(_gid); }
2143         uint32 permissions() const { return B_LENDIAN_TO_HOST_INT32(_permissions); }
2144         uint16 file_link_count() const { return B_LENDIAN_TO_HOST_INT16(_file_link_count); }
2145         uint8 record_format() const { return _record_format; }
2146         uint8 record_display_attributes() const { return _record_display_attributes; }
2147         uint32 record_length() const { return _record_length; }
2148         uint64 information_length() const { return B_LENDIAN_TO_HOST_INT64(_information_length); }
2149         uint64 object_size() const { return B_LENDIAN_TO_HOST_INT64(_object_size); }
2150         uint64 logical_blocks_recorded() const { return B_LENDIAN_TO_HOST_INT64(_logical_blocks_recorded); }
2151
2152         timestamp& access_date_and_time() { return _access_date_and_time; }
2153         const timestamp& access_date_and_time() const { return _access_date_and_time; }
2154
2155         timestamp& modification_date_and_time() { return _modification_date_and_time; }
2156         const timestamp& modification_date_and_time() const { return _modification_date_and_time; }
2157
2158         timestamp& creation_date_and_time() { return _creation_date_and_time; }
2159         const timestamp& creation_date_and_time() const { return _creation_date_and_time; }
2160
2161         timestamp& attribute_date_and_time() { return _attribute_date_and_time; }
2162         const timestamp& attribute_date_and_time() const { return _attribute_date_and_time; }
2163
2164         uint32 checkpoint() const { return B_LENDIAN_TO_HOST_INT32(_checkpoint); }
2165
2166         long_address& extended_attribute_icb() { return _extended_attribute_icb; }
2167         const long_address& extended_attribute_icb() const { return _extended_attribute_icb; }
2168
2169         long_address& stream_directory_icb() { return _stream_directory_icb; }
2170         const long_address& stream_directory_icb() const { return _stream_directory_icb; }
2171
2172         entity_id& implementation_id() { return _implementation_id; }
2173         const entity_id& implementation_id() const { return _implementation_id; }
2174
2175         uint64 unique_id() const { return B_LENDIAN_TO_HOST_INT64(_unique_id); }
2176         uint32 extended_attributes_length() const { return B_LENDIAN_TO_HOST_INT32(_extended_attributes_length); }
2177         uint32 allocation_descriptors_length() const { return B_LENDIAN_TO_HOST_INT32(_allocation_descriptors_length); }
2178
2179         uint8* extended_attributes() { return _end(); }
2180         const uint8* extended_attributes() const { return _end(); }
2181         uint8* allocation_descriptors() { return _end()+extended_attributes_length(); }
2182         const uint8* allocation_descriptors() const { return _end()+extended_attributes_length(); }
2183
2184         // set functions
2185         void set_uid(uint32 uid) { _uid = B_HOST_TO_LENDIAN_INT32(uid); }
2186         void set_gid(uint32 gid) { _gid = B_HOST_TO_LENDIAN_INT32(gid); }
2187         void set_permissions(uint32 permissions) { _permissions = B_HOST_TO_LENDIAN_INT32(permissions); }
2188
2189         void set_file_link_count(uint16 count) { _file_link_count = B_HOST_TO_LENDIAN_INT16(count); }
2190         void set_record_format(uint8 format) { _record_format = format; }
2191         void set_record_display_attributes(uint8 attributes) { _record_display_attributes = attributes; }
2192         void set_record_length(uint32 length) { _record_length = B_HOST_TO_LENDIAN_INT32(length); }
2193
2194         void set_information_length(uint64 length) { _information_length = B_HOST_TO_LENDIAN_INT64(length); }
2195         void set_object_size(uint64 size) { _object_size = B_HOST_TO_LENDIAN_INT64(size); }
2196         void set_logical_blocks_recorded(uint64 blocks) { _logical_blocks_recorded = B_HOST_TO_LENDIAN_INT64(blocks); }
2197
2198         void set_checkpoint(uint32 checkpoint) { _checkpoint = B_HOST_TO_LENDIAN_INT32(checkpoint); }
2199         void set_reserved(uint32 reserved) { _reserved = B_HOST_TO_LENDIAN_INT32(reserved); }
2200
2201         void set_unique_id(uint64 id) { _unique_id = B_HOST_TO_LENDIAN_INT64(id); }
2202
2203         void set_extended_attributes_length(uint32 length) { _extended_attributes_length = B_HOST_TO_LENDIAN_INT32(length); }
2204         void set_allocation_descriptors_length(uint32 length) { _allocation_descriptors_length = B_HOST_TO_LENDIAN_INT32(length); }
2205
2206 private:
2207         static const uint32 _descriptor_length = 216;
2208         uint8* _end() { return reinterpret_cast<uint8*>(this)+_descriptor_length; }
2209         const uint8* _end() const { return reinterpret_cast<const uint8*>(this)+_descriptor_length; }
2210
2211         descriptor_tag  _tag;
2212         icb_entry_tag _icb_tag;
2213         uint32 _uid;
2214         uint32 _gid;
2215         /*! \todo List perms in comment and add handy union thingy */
2216         uint32 _permissions;
2217         /*! Identifies the number of file identifier descriptors referencing
2218                 this icb.
2219         */
2220         uint16 _file_link_count;
2221         uint8 _record_format;                           //!< To be set to 0 per UDF-2.01 2.3.6.1
2222         uint8 _record_display_attributes;       //!< To be set to 0 per UDF-2.01 2.3.6.2
2223         uint32 _record_length;                          //!< To be set to 0 per UDF-2.01 2.3.6.3
2224         uint64 _information_length;
2225         uint64 _object_size;
2226         uint64 _logical_blocks_recorded;                //!< To be 0 for files and dirs with embedded data
2227         timestamp _access_date_and_time;
2228         timestamp _modification_date_and_time;
2229         timestamp _creation_date_and_time;      // <== EXTENDED FILE ENTRY ONLY
2230         timestamp _attribute_date_and_time;
2231         /*! \brief Initially 1, may be incremented upon user request. */
2232         uint32 _checkpoint;
2233         uint32 _reserved;       // <== EXTENDED FILE ENTRY ONLY
2234         long_address _extended_attribute_icb;
2235         long_address _stream_directory_icb;     // <== EXTENDED FILE ENTRY ONLY
2236         entity_id _implementation_id;
2237         /*! \brief The unique id identifying this file entry
2238
2239                 The id of the root directory of a file set shall be 0.
2240
2241                 \todo Detail the system specific requirements for unique ids from UDF-2.01 3.2.1.1
2242         */
2243         uint64 _unique_id;
2244         uint32 _extended_attributes_length;
2245         uint32 _allocation_descriptors_length;
2246
2247 };
2248
2249
2250 #endif  // _UDF_DISK_STRUCTURES_H
2251