genisoimage/udf.c

   1 /*
   2  * This file has been modified for the cdrkit suite.
   3  *
   4  * The behaviour and appearence of the program code below can differ to a major
   5  * extent from the version distributed by the original author(s).
   6  *
   7  * For details, see Changelog file distributed with the cdrkit package. If you
   8  * received this file from another source then ask the distributing person for
   9  * a log of modifications.
  10  *
  11  */
  12
  13 /* @(#)udf.c    1.14 04/04/15 Copyright 2001 J. Schilling */
  14 /*
  15  * udf.c - UDF support for genisoimage
  16  *
  17  * Written by Ben Rudiak-Gould (2001).
  18  *
  19  * Copyright 2001 J. Schilling.
  20  */
  21 /*
  22  * This program is free software; you can redistribute it and/or modify
  23  * it under the terms of the GNU General Public License version 2
  24  * as published by the Free Software Foundation.
  25  *
  26  * This program is distributed in the hope that it will be useful,
  27  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29  * GNU General Public License for more details.
  30  *
  31  * You should have received a copy of the GNU General Public License along with
  32  * this program; see the file COPYING.  If not, write to the Free Software
  33  * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  34  */
  35
  36 /*
  37  * Some remaining issues:
  38  *
  39  * - Do not forget to edit joliet.c and remove the VIDEO_TS lines after
  40  *   we did implement a decent own file name handling for UDF.
  41  *
  42  * - UDF supports UNIX-style file permissions and uid/gid, but currently
  43  *   this code just sets them to default values and ignores their Rock
  44  *   Ridge counterparts. This would be easy to fix.
  45  *
  46  * - There's no support for symlinks, Mac type/creator, or Mac resource
  47  *   forks. Hard links and followed symlinks may work, but if so, it's
  48  *   only by accident.
  49  *
  50  * - The file system mirrors the Joliet file system, so files excluded
  51  *   from Joliet will also be excluded from UDF, the -jcharset option
  52  *   also applies to UDF, file names too long for Joliet will also be
  53  *   truncated on UDF, and characters not allowed by Joliet will also
  54  *   be translated on UDF. (Fortunately, Joliet is pretty lenient.)
  55  *
  56  * - convert_to_unicode is always called with in_nls, not hfs_nls. This
  57  *   may lead to incorrect name conversion sometimes when using a Mac
  58  *   filesystem. See joliet.c for an example of what's supposed to be
  59  *   done.
  60  *
  61  * - DVD-Video discs are supposed to have Copyright Management Information
  62  *   in both the ISO and UDF filesystems. This is not implemented in ISO,
  63  *   and the code to do it in UDF is currently #ifdef'd out. I'm not sure
  64  *   whether discs without this information are actually DVD-Video
  65  *   compliant. The Copyright Management Information is described in ECMA
  66  *   Technical Report TR/71.
  67  *
  68  * - Most of the space before sector 256 on the disc (~480K) is wasted,
  69  *   because UDF Bridge requires a pointer block at sector 256. ISO 9660
  70  *   structures could be moved below sector 256 if they're small enough, but
  71  *   this would be ugly to implement since it breaks the output_fragment
  72  *   abstraction.
  73  *
  74  * - Each file must have a File Entry, and each File Entry seems to
  75  *   require its own 2K sector. As a result, there is an overhead of more
  76  *   than 2K *per file* when using UDF. I couldn't see any way to avoid
  77  *   this.
  78  *
  79  * - Read performance would probably be improved by placing the File Entry
  80  *   for each file just before the file itself, instead of at the beginning
  81  *   of the disc. But this would not work for DVD-Video files, which have
  82  *   to be stored contiguously. So there would have to be an override
  83  *   mechanism to handle this case. I don't know if it's worth the trouble.
  84  */
  85
  86 #ifdef UDF
  87
  88 #include "config.h"
  89 #include "genisoimage.h"
  90 #include <timedefs.h>
  91 #include <schily.h>
  92
  93 #include "udf.h"
  94 #include "udf_fs.h"
  95
  96 extern  int     use_sparcboot;
  97
  98 extern struct directory *root;
  99 extern time_t           begun;
 100
 101 static unsigned lba_main_seq;
 102 static unsigned lba_main_seq_copy;
 103 static unsigned lba_integ_seq;
 104 static unsigned lba_udf_partition_start;
 105 static unsigned lba_last_file_entry;
 106 static unsigned lba_end_anchor_vol_desc;
 107
 108 static unsigned num_udf_files;
 109 static unsigned num_udf_directories;
 110
 111 static unsigned volume_set_id[2];
 112
 113 #define UDF_MAIN_SEQ_LENGTH (16)
 114 #define UDF_INTEG_SEQ_LENGTH (2)
 115
 116 /* only works for granularity a power of 2! */
 117 #define PAD(val, granularity)   (((val)+(granularity)-1)&~((granularity)-1))
 118
 119 #define read_733(field) ((0[field]&255)+(1[field]&255)*256+(2[field]&255)*65536+(3[field]&255)*16777216)
 120
 121
 122 /**************** SIZE ****************/
 123
 124 static int set_file_ident_desc(unsigned char *, unsigned, char *, int,
 125                                                                                  unsigned, unsigned);
 126
 127 static unsigned
 128 directory_size(struct directory *dpnt)
 129 {
 130         unsigned size_in_bytes;
 131         struct directory_entry *de;
 132         Uchar dummy_buf[SECTOR_SIZE];
 133
 134         /* parent directory */
 135         size_in_bytes = set_file_ident_desc(dummy_buf, 0, 0, 0, 0, 0);
 136
 137         /* directory contents */
 138         for (de = dpnt->jcontents; de; de = de->jnext) {
 139                 if (!(de->de_flags & INHIBIT_JOLIET_ENTRY)) {
 140                         char *name = USE_MAC_NAME(de) ? de->hfs_ent->name : de->name;
 141                         /* skip . and .. */
 142                         if (name[0] == '.' && (name[1] == 0 || (name[1] == '.' && name[2] == 0)))
 143                                 continue;
 144                         size_in_bytes += set_file_ident_desc(dummy_buf, 0, name, 0, 0, 0);
 145                 }
 146         }
 147         return (size_in_bytes);
 148 }
 149
 150 static void
 151 assign_udf_directory_addresses(struct directory *dpnt)
 152 {
 153         if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY)) {
 154                 dpnt->self->udf_file_entry_sector = last_extent;
 155                 last_extent += 1 + ISO_BLOCKS(directory_size(dpnt));
 156                 ++num_udf_directories;
 157         }
 158         if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) || dpnt == reloc_dir) {
 159                 for (dpnt = dpnt->subdir; dpnt; dpnt = dpnt->next) {
 160                         assign_udf_directory_addresses(dpnt);
 161                 }
 162         }
 163 }
 164
 165 static void
 166 assign_udf_file_entry_addresses(struct directory *dpnt)
 167 {
 168         if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY)) {
 169                 struct directory_entry *de;
 170                 for (de = dpnt->jcontents; de; de = de->jnext) {
 171                         if (!(de->de_flags & RELOCATED_DIRECTORY) &&
 172                             !(de->isorec.flags[0] & ISO_DIRECTORY)) {
 173                                 de->udf_file_entry_sector = last_extent++;
 174                                 ++num_udf_files;
 175                         }
 176                 }
 177         }
 178         if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) || dpnt == reloc_dir) {
 179                 for (dpnt = dpnt->subdir; dpnt; dpnt = dpnt->next) {
 180                         assign_udf_file_entry_addresses(dpnt);
 181                 }
 182         }
 183 }
 184
 185 /****************************/
 186
 187 static int
 188 udf_vol_recognition_area_size(int starting_extent)
 189 {
 190         last_extent = starting_extent+3;
 191         return (0);
 192 }
 193
 194 static int
 195 udf_main_seq_size(int starting_extent)
 196 {
 197         lba_main_seq = starting_extent;
 198         last_extent = starting_extent + UDF_MAIN_SEQ_LENGTH;
 199         return (0);
 200 }
 201
 202 static int
 203 udf_main_seq_copy_size(int starting_extent)
 204 {
 205         lba_main_seq_copy = starting_extent;
 206         last_extent = starting_extent + UDF_MAIN_SEQ_LENGTH;
 207         return (0);
 208 }
 209
 210 static int
 211 udf_integ_seq_size(int starting_extent)
 212 {
 213         lba_integ_seq = starting_extent;
 214         last_extent = starting_extent + UDF_INTEG_SEQ_LENGTH;
 215         return (0);
 216 }
 217
 218 static int
 219 udf_end_anchor_vol_desc_size(int starting_extent)
 220 {
 221         lba_end_anchor_vol_desc = starting_extent;
 222         last_extent = starting_extent+1;
 223         return (0);
 224 }
 225
 226 static int
 227 udf_file_set_desc_size(int starting_extent)
 228 {
 229         lba_udf_partition_start = starting_extent;
 230         last_extent = starting_extent+2;
 231         return (0);
 232 }
 233
 234 static int
 235 udf_dirtree_size(int starting_extent)
 236 {
 237         num_udf_directories = 0;
 238         assign_udf_directory_addresses(root);
 239         return (0);
 240 }
 241
 242 static int
 243 udf_file_entries_size(int starting_extent)
 244 {
 245         num_udf_files = 0;
 246         assign_udf_file_entry_addresses(root);
 247         lba_last_file_entry = last_extent-1;
 248         return (0);
 249 }
 250
 251 static int
 252 udf_pad_to_sector_32_size(int starting_extent)
 253 {
 254         if (last_extent < session_start+32)
 255                 last_extent = session_start+32;
 256         return (0);
 257 }
 258
 259 static int
 260 udf_pad_to_sector_256_size(int starting_extent)
 261 {
 262         if (last_extent < session_start+256)
 263                 last_extent = session_start+256;
 264         return (0);
 265 }
 266
 267 static int
 268 udf_padend_avdp_size(int starting_extent)
 269 {
 270         lba_end_anchor_vol_desc = starting_extent;
 271
 272         /* add at least 16 and at most 31 sectors, ending at a mult. of 16 */
 273         last_extent = (starting_extent+31) & ~15;
 274         if (!use_sparcboot)
 275                 last_extent = starting_extent + 150;
 276         return (0);
 277 }
 278
 279 extern int oneblock_size(int);
 280
 281 /**************** WRITE ****************/
 282
 283 static unsigned
 284 crc_ccitt(unsigned char *buf, unsigned len)
 285 {
 286         const unsigned poly = 0x11021;
 287         static unsigned short lookup[256];
 288         unsigned int r;
 289         unsigned int i;
 290
 291         if (lookup[1] == 0) {
 292                 unsigned int j, k;
 293                 for (j = 0; j < 256; ++j) {
 294                         unsigned int temp = j << 8;
 295                         for (k = 0; k < 8; ++k) {
 296                                 unsigned int hibit = temp & 32768;
 297                                 temp <<= 1;
 298                                 if (hibit)
 299                                         temp ^= poly;
 300                         }
 301                         lookup[j] = temp;
 302                 }
 303         }
 304
 305         r = 0;
 306         for (i = 0; i < len; ++i) {
 307                 r = (r << 8) ^ lookup[((r >> 8) ^ buf[i]) & 255];
 308         }
 309
 310         return (r & 65535);
 311 }
 312
 313 #define set8(dst, src)  do { *(dst) = (src); } while (0)
 314
 315 static void
 316 set16(udf_Uint16 *dst, unsigned int src)
 317 {
 318         dst->l = (char)(src);
 319         dst->h = (char)(src>>8);
 320 }
 321
 322 static void
 323 set32(udf_Uint32 *dst, unsigned src)
 324 {
 325         dst->l  = (char)(src);
 326         dst->ml = (char)(src>>8);
 327         dst->mh = (char)(src>>16);
 328         dst->h  = (char)(src>>24);
 329 }
 330
 331 static void
 332 set64(udf_Uint64 *dst, uint64_t src)
 333 {
 334         set32(&dst->l, src);
 335         set32(&dst->h, src>>32);
 336 }
 337
 338 static int
 339 set_ostaunicode(unsigned char *dst, int dst_size, char *src)
 340 {
 341         unsigned char buf[1024];
 342         int i;
 343         int expanded_length;
 344
 345         expanded_length = joliet_strlen(src, in_nls);
 346         if (expanded_length > 1024)
 347                 expanded_length = 1024;
 348         if (expanded_length > (dst_size-1)*2)
 349                 expanded_length = (dst_size-1)*2;
 350
 351         convert_to_unicode(buf, expanded_length, src, in_nls);
 352         dst[0] = 8;     /* use 8-bit representation by default */
 353         for (i = 0; i < (expanded_length>>1); ++i) {
 354                 dst[i + 1] = buf[i*2+1];
 355                 if (buf[i*2] != 0) {
 356                         /*
 357                          * There's a Unicode character with value >=256.
 358                          * Use 16-bit representation instead.
 359                          */
 360                         int length_to_copy = (dst_size-1) & ~1;
 361                         if (length_to_copy > expanded_length)
 362                                 length_to_copy = expanded_length;
 363                         dst[0] = 16;
 364                         memcpy(dst+1, buf, length_to_copy);
 365                         return (length_to_copy + 1);
 366                 }
 367         }
 368         return ((expanded_length>>1) + 1);
 369 }
 370
 371 static void
 372 set_extent(udf_extent_ad *ext, unsigned lba, unsigned length_bytes)
 373 {
 374         set32(&ext->extent_length, length_bytes);
 375         set32(&ext->extent_location, lba);
 376 }
 377
 378 static void
 379 set_dstring(udf_dstring *dst, char *src, int n)
 380 {
 381         dst[n-1] = set_ostaunicode((Uchar *)dst, n-1, src);
 382 }
 383
 384 static void
 385 set_charspec(udf_charspec *dst)
 386 {
 387         /*set8(&dst->character_set_type, 0);*/
 388         memcpy(dst->character_set_info, "OSTA Compressed Unicode", 23);
 389 }
 390
 391 static void
 392 set_impl_ident(udf_EntityID *ent)
 393 {
 394         strcpy((char *)ent->ident, "*genisoimage");
 395 }
 396
 397 static void
 398 set_tag(udf_tag *t, unsigned tid, unsigned lba, int crc_length)
 399 {
 400         unsigned char checksum;
 401         int i;
 402
 403         set16(&t->tag_ident, tid);
 404         set16(&t->desc_version, 2);
 405         set16(&t->desc_crc, crc_ccitt((unsigned char *)t+16, crc_length-16));
 406         set16(&t->desc_crc_length, crc_length-16);
 407         set32(&t->tag_location, lba);
 408         set8(&t->tag_checksum, 0);
 409         checksum = 0;
 410         for (i = 0; i < 16; ++i)
 411                 checksum += ((unsigned char *)t)[i];
 412         set8(&t->tag_checksum, checksum);
 413 }
 414
 415 static void
 416 set_timestamp_from_iso_date(udf_timestamp *ts, const char *iso_date_raw)
 417 {
 418         struct {
 419                 unsigned char years_since_1900;
 420                 unsigned char month, day;
 421                 unsigned char hour, minute, second;
 422                 signed char offset_from_gmt;
 423         } *iso_date = (void *)iso_date_raw;
 424
 425         set16(&ts->type_and_time_zone,
 426                 4096 + ((iso_date->offset_from_gmt * 15) & 4095));
 427         set16(&ts->year, 1900 + iso_date->years_since_1900);
 428         set8(&ts->month, iso_date->month);
 429         set8(&ts->day, iso_date->day);
 430         set8(&ts->hour, iso_date->hour);
 431         set8(&ts->minute, iso_date->minute);
 432         set8(&ts->second, iso_date->second);
 433         /*set8(&ts->centiseconds, 0);*/
 434         /*set8(&ts->hundreds_of_microseconds, 0);*/
 435         /*set8(&ts->microseconds, 0);*/
 436 }
 437
 438 static void
 439 set_timestamp_from_time_t(udf_timestamp *ts, time_t t)
 440 {
 441         char iso_date[7];
 442         iso9660_date(iso_date, t);
 443         set_timestamp_from_iso_date(ts, iso_date);
 444 }
 445
 446
 447 static void
 448 set_anchor_volume_desc_pointer(unsigned char *buf, unsigned lba)
 449 {
 450         udf_anchor_volume_desc_ptr *avdp = (udf_anchor_volume_desc_ptr *)buf;
 451         set_extent(&avdp->main_volume_desc_seq_extent,
 452                 lba_main_seq, SECTOR_SIZE*UDF_MAIN_SEQ_LENGTH);
 453         set_extent(&avdp->reserve_volume_desc_seq_extent,
 454                 lba_main_seq_copy, SECTOR_SIZE*UDF_MAIN_SEQ_LENGTH);
 455         set_tag(&avdp->desc_tag, UDF_TAGID_ANCHOR_VOLUME_DESC_PTR, lba, 512);
 456 }
 457
 458 static void
 459 set_primary_vol_desc(unsigned char *buf, unsigned lba)
 460 {
 461         char temp[17];
 462
 463         udf_primary_volume_desc *pvd = (udf_primary_volume_desc *)buf;
 464         /*set32(&pvd->volume_desc_seq_number, 0);*/
 465         /*set32(&pvd->primary_volume_desc_number, 0);*/
 466         set_dstring(pvd->volume_ident, volume_id, sizeof (pvd->volume_ident));
 467         set16(&pvd->volume_seq_number, 1);
 468         set16(&pvd->maximum_volume_seq_number, 1);
 469         set16(&pvd->interchange_level, 2);
 470         set16(&pvd->maximum_interchange_level, 2);
 471         set32(&pvd->character_set_list, 1);
 472         set32(&pvd->maximum_character_set_list, 1);
 473         sprintf(temp, "%08X%08X", volume_set_id[0], volume_set_id[1]);
 474         set_dstring(pvd->volume_set_ident, temp,
 475                                         sizeof (pvd->volume_set_ident));
 476         set_charspec(&pvd->desc_character_set);
 477         set_charspec(&pvd->explanatory_character_set);
 478         /*pvd->volume_abstract;*/
 479         /*pvd->volume_copyright_notice;*/
 480         /*pvd->application_ident;*/
 481         set_timestamp_from_time_t(&pvd->recording_date_and_time, begun);
 482         set_impl_ident(&pvd->impl_ident);
 483         set_tag(&pvd->desc_tag, UDF_TAGID_PRIMARY_VOLUME_DESC, lba, 512);
 484 }
 485
 486 static void
 487 set_impl_use_vol_desc(unsigned char *buf, unsigned lba)
 488 {
 489         udf_impl_use_volume_desc *iuvd = (udf_impl_use_volume_desc *)buf;
 490         set32(&iuvd->volume_desc_seq_number, 1);
 491         strcpy((char *)iuvd->impl_ident.ident, "*UDF LV Info");
 492         iuvd->impl_ident.ident_suffix[0] = 2;
 493         iuvd->impl_ident.ident_suffix[1] = 1;
 494         set_charspec(&iuvd->impl_use.lvi_charset);
 495         set_dstring(iuvd->impl_use.logical_volume_ident, volume_id,
 496                 sizeof (iuvd->impl_use.logical_volume_ident));
 497         /*set_dstring(iuvd->impl_use.lv_info1, "", sizeof (iuvd->impl_use.lv_info1));*/
 498         /*set_dstring(iuvd->impl_use.lv_info2, "", sizeof (iuvd->impl_use.lv_info2));*/
 499         /*set_dstring(iuvd->impl_use.lv_info3, "", sizeof (iuvd->impl_use.lv_info3));*/
 500         set_impl_ident(&iuvd->impl_use.impl_id);
 501         set_tag(&iuvd->desc_tag, UDF_TAGID_IMPL_USE_VOLUME_DESC, lba, 512);
 502 }
 503
 504 static void
 505 set_partition_desc(unsigned char *buf, unsigned lba)
 506 {
 507         udf_partition_desc *pd = (udf_partition_desc *)buf;
 508         set32(&pd->volume_desc_seq_number, 2);
 509         set16(&pd->partition_flags, UDF_PARTITION_FLAG_ALLOCATED);
 510         /*set16(&pd->partition_number, 0);*/
 511         set8(&pd->partition_contents.flags, UDF_ENTITYID_FLAG_PROTECTED);       /*???*/
 512         strcpy((char *)pd->partition_contents.ident, "+NSR02");
 513         set32(&pd->access_type, UDF_ACCESSTYPE_READONLY);
 514         set32(&pd->partition_starting_location, lba_udf_partition_start);
 515         set32(&pd->partition_length,
 516                         lba_end_anchor_vol_desc - lba_udf_partition_start);
 517         set_impl_ident(&pd->impl_ident);
 518         set_tag(&pd->desc_tag, UDF_TAGID_PARTITION_DESC, lba, 512);
 519 }
 520
 521 static void
 522 set_domain_ident(udf_EntityID *ent)
 523 {
 524         strcpy((char *)ent->ident, "*OSTA UDF Compliant");
 525         memcpy(ent->ident_suffix, "\002\001\003", 3);
 526 }
 527
 528 static void
 529 set_logical_vol_desc(unsigned char *buf, unsigned lba)
 530 {
 531         udf_logical_volume_desc *lvd = (udf_logical_volume_desc *)buf;
 532         set32(&lvd->volume_desc_seq_number, 3);
 533         set_charspec(&lvd->desc_character_set);
 534         set_dstring(lvd->logical_volume_ident, volume_id,
 535                                         sizeof (lvd->logical_volume_ident));
 536         set32(&lvd->logical_block_size, SECTOR_SIZE);
 537         set_domain_ident(&lvd->domain_ident);
 538         set32(&lvd->logical_volume_contents_use.extent_length, 2*SECTOR_SIZE);
 539         /*set32(&lvd->logical_volume_contents_use.extent_location.logical_block_number, 0);*/
 540         /*set16(&lvd->logical_volume_contents_use.extent_location.partition_reference_number, 0);*/
 541         set32(&lvd->map_table_length, 6);
 542         set32(&lvd->number_of_partition_maps, 1);
 543         set_impl_ident(&lvd->impl_ident);
 544         set_extent(&lvd->integrity_seq_extent, lba_integ_seq,
 545                                         SECTOR_SIZE*UDF_INTEG_SEQ_LENGTH);
 546         set8(&lvd->partition_map[0].partition_map_type,
 547                                         UDF_PARTITION_MAP_TYPE_1);
 548         set8(&lvd->partition_map[0].partition_map_length, 6);
 549         set16(&lvd->partition_map[0].volume_seq_number, 1);
 550         /*set16(&lvd->partition_map[0].partition_number, 0);*/
 551         set_tag(&lvd->desc_tag, UDF_TAGID_LOGICAL_VOLUME_DESC, lba, 446);
 552 }
 553
 554 static void
 555 set_unallocated_space_desc(unsigned char *buf, unsigned lba)
 556 {
 557         udf_unallocated_space_desc *usd = (udf_unallocated_space_desc *)buf;
 558         set32(&usd->volume_desc_seq_number, 4);
 559         /*set32(&usd->number_of_allocation_descs, 0);*/
 560         set_tag(&usd->desc_tag, UDF_TAGID_UNALLOCATED_SPACE_DESC, lba, 24);
 561 }
 562
 563 static void
 564 set_terminating_desc(unsigned char *buf, unsigned lba)
 565 {
 566         udf_terminating_desc *td = (udf_terminating_desc *)buf;
 567         set_tag(&td->desc_tag, UDF_TAGID_TERMINATING_DESC, lba, 512);
 568 }
 569
 570 static void
 571 set_logical_vol_integrity_desc(unsigned char *buf, unsigned lba)
 572 {
 573         udf_logical_volume_integrity_desc *lvid =
 574                                 (udf_logical_volume_integrity_desc *)buf;
 575
 576         set_timestamp_from_time_t(&lvid->recording_date, begun);
 577         set32(&lvid->integrity_type, UDF_INTEGRITY_TYPE_CLOSE);
 578         /*lvid->next_integrity_extent;*/
 579         set64(&lvid->logical_volume_contents_use.unique_id,
 580                                                 lba_last_file_entry+1);
 581         set32(&lvid->number_of_partitions, 1);
 582         set32(&lvid->length_of_impl_use, 46);
 583         /*set32(&lvid->free_space_table, 0);*/
 584         set32(&lvid->size_table,
 585                         lba_end_anchor_vol_desc - lba_udf_partition_start);
 586         set_impl_ident(&lvid->impl_use.impl_id);
 587         set32(&lvid->impl_use.number_of_files, num_udf_files);
 588         set32(&lvid->impl_use.number_of_directories, num_udf_directories);
 589         set16(&lvid->impl_use.minimum_udf_read_revision, 0x102);
 590         set16(&lvid->impl_use.minimum_udf_write_revision, 0x102);
 591         set16(&lvid->impl_use.maximum_udf_write_revision, 0x102);
 592         set_tag(&lvid->desc_tag, UDF_TAGID_LOGICAL_VOLUME_INTEGRITY_DESC,
 593                                                                 lba, 88+46);
 594 }
 595
 596 static void
 597 set_file_set_desc(unsigned char *buf, unsigned rba)
 598 {
 599         udf_file_set_desc *fsd = (udf_file_set_desc *)buf;
 600
 601         set_timestamp_from_time_t(&fsd->recording_date_and_time, begun);
 602         set16(&fsd->interchange_level, 3);
 603         set16(&fsd->maximum_interchange_level, 3);
 604         set32(&fsd->character_set_list, 1);
 605         set32(&fsd->maximum_character_set_list, 1);
 606         /*set32(&fsd->file_set_number, 0);*/
 607         /*set32(&fsd->file_set_desc_number, 0);*/
 608         set_charspec(&fsd->logical_volume_ident_character_set);
 609         set_dstring(fsd->logical_volume_ident, volume_id,
 610                                         sizeof (fsd->logical_volume_ident));
 611         set_charspec(&fsd->file_set_character_set);
 612         set_dstring(fsd->file_set_ident, volume_id,
 613                                         sizeof (fsd->file_set_ident));
 614         /*fsd->copyright_file_ident;*/
 615         /*fsd->abstract_file_ident;*/
 616         set32(&fsd->root_directory_icb.extent_length, SECTOR_SIZE);
 617         set32(&fsd->root_directory_icb.extent_location.logical_block_number,
 618                 root->self->udf_file_entry_sector - lba_udf_partition_start);
 619         set_domain_ident(&fsd->domain_ident);
 620         /*fsd->next_extent;*/
 621         set_tag(&fsd->desc_tag, UDF_TAGID_FILE_SET_DESC, rba, 512);
 622 }
 623
 624 static int
 625 set_file_ident_desc(unsigned char *buf, unsigned rba, char *name,
 626                                                   int is_directory, unsigned file_entry_rba,
 627                                                   unsigned unique_id)
 628 {
 629         udf_file_ident_desc *fid = (udf_file_ident_desc *)buf;
 630         int length_of_file_ident, length, padded_length;
 631         set16(&fid->file_version_number, 1);
 632         set8(&fid->file_characteristics,
 633                 (is_directory ? UDF_FILE_CHARACTERISTIC_DIRECTORY : 0)
 634                 + (name == 0) * UDF_FILE_CHARACTERISTIC_PARENT);
 635         set32(&fid->icb.extent_length, SECTOR_SIZE);
 636         set32(&fid->icb.extent_location.logical_block_number, file_entry_rba);
 637         set16(&fid->icb.extent_location.partition_reference_number, 0);
 638         set32(&fid->icb.impl_use.unique_id, unique_id);
 639         set16(&fid->length_of_impl_use, 0);
 640         if (name) {
 641                 length_of_file_ident =
 642                         set_ostaunicode((Uchar *)fid->file_ident, 512, name);
 643         } else {
 644                 length_of_file_ident = 0;
 645         }
 646         set8(&fid->length_of_file_ident, length_of_file_ident);
 647         length = 38 + length_of_file_ident;
 648         padded_length = PAD(length, 4);
 649         while (length < padded_length) {
 650                 buf[length++] = 0;
 651         }
 652         set_tag(&fid->desc_tag, UDF_TAGID_FILE_IDENT_DESC, rba, length);
 653         return (length);
 654 }
 655
 656 static void
 657 set_file_entry(unsigned char *buf, unsigned rba, unsigned file_rba,
 658                                         uint64_t length, const char *iso_date, int is_directory,
 659                                         unsigned link_count, unsigned unique_id)
 660 {
 661         udf_short_ad    *allocation_desc;
 662         unsigned        chunk;
 663
 664         udf_file_entry *fe = (udf_file_entry *)buf;
 665
 666         /*set32(&fe->icb_tag.prior_recorded_number_of_direct_entries, 0);*/
 667         set16(&fe->icb_tag.strategy_type, 4);
 668         /*set16(&fe->icb_tag.strategy_parameter, 0);*/
 669         set16(&fe->icb_tag.maximum_number_of_entries, 1);
 670         set8(&fe->icb_tag.file_type, is_directory
 671                 ? UDF_ICBTAG_FILETYPE_DIRECTORY : UDF_ICBTAG_FILETYPE_BYTESEQ);
 672         /*fe->icb_tag.parent_icb_location;*/
 673         set16(&fe->icb_tag.flags, UDF_ICBTAG_FLAG_NONRELOCATABLE
 674                 | UDF_ICBTAG_FLAG_ARCHIVE | UDF_ICBTAG_FLAG_CONTIGUOUS);
 675         if (rationalize_uid)
 676                 set32(&fe->uid, uid_to_use);
 677         else
 678                 set32(&fe->uid, -1);
 679         if (rationalize_gid)
 680                 set32(&fe->gid, gid_to_use);
 681         else
 682                 set32(&fe->gid, -1);
 683         if (is_directory) {
 684                 set32(&fe->permissions,
 685                     UDF_FILEENTRY_PERMISSION_OR | UDF_FILEENTRY_PERMISSION_OX |
 686                     UDF_FILEENTRY_PERMISSION_GR | UDF_FILEENTRY_PERMISSION_GX |
 687                     UDF_FILEENTRY_PERMISSION_UR | UDF_FILEENTRY_PERMISSION_UX);
 688         } else {
 689                 set32(&fe->permissions, UDF_FILEENTRY_PERMISSION_OR
 690                 | UDF_FILEENTRY_PERMISSION_GR | UDF_FILEENTRY_PERMISSION_UR);
 691         }
 692         set16(&fe->file_link_count, link_count);
 693         /*fe->record_format;*/
 694         /*fe->record_display_attributes;*/
 695         /*fe->record_length;*/
 696         set64(&fe->info_length, length);
 697         set64(&fe->logical_blocks_recorded, ISO_BLOCKS(length));
 698         if (iso_date) {
 699                 set_timestamp_from_iso_date(&fe->access_time, iso_date);
 700                 fe->modification_time = fe->access_time;
 701                 fe->attribute_time = fe->access_time;
 702         }
 703         set32(&fe->checkpoint, 1);
 704         /*fe->ext_attribute_icb;*/
 705         set_impl_ident(&fe->impl_ident);
 706         set64(&fe->unique_id, unique_id);
 707         /*
 708          * Extended attributes that may (?) be required for DVD-Video
 709          * compliance
 710          */
 711 #if 0
 712         set32(&fe->length_of_ext_attributes, 24+52+56);
 713         set32(&fe->ext_attribute_header.impl_attributes_location, 24);
 714         set32(&fe->ext_attribute_header.application_attributes_location,
 715                                                                 24+52+56);
 716         set_tag(&fe->ext_attribute_header.desc_tag,
 717                         UDF_TAGID_EXT_ATTRIBUTE_HEADER_DESC, rba, 24 /*???*/);
 718         set32(&fe->ext_attribute_free_ea_space.attribute_type, SECTOR_SIZE);
 719         set8(&fe->ext_attribute_free_ea_space.attribute_subtype, 1);
 720         set32(&fe->ext_attribute_free_ea_space.attribute_length, 52);
 721         set32(&fe->ext_attribute_free_ea_space.impl_use_length, 4);
 722         strcpy((char *)fe->ext_attribute_free_ea_space.impl_ident.ident,
 723                                                         "*UDF FreeAppEASpace");
 724         set32(&fe->ext_attribute_dvd_cgms_info.attribute_type, SECTOR_SIZE);
 725         set8(&fe->ext_attribute_dvd_cgms_info.attribute_subtype, 1);
 726         set32(&fe->ext_attribute_dvd_cgms_info.attribute_length, 56);
 727         set32(&fe->ext_attribute_dvd_cgms_info.impl_use_length, 8);
 728         strcpy((char *)fe->ext_attribute_free_ea_space.impl_ident.ident,
 729                                                         "*UDF DVD CGMS Info");
 730         fe->ext_attribute_free_ea_space.impl_ident.ident_suffix[0] = 2;
 731         fe->ext_attribute_free_ea_space.impl_ident.ident_suffix[1] = 1;
 732 #else
 733         /*set32(&fe->length_of_ext_attributes, 0);*/
 734 #endif
 735
 736         allocation_desc = &fe->allocation_desc;
 737         /*
 738          * Only a file size less than 1GB can be expressed by a single
 739          * AllocationDescriptor. When the size of a file is larger than 1GB,
 740          * 2 or more AllocationDescriptors should be used. We don't know
 741          * whether a singl 8-byte AllocationDescriptor should be written or no
 742          * one should be written if the size of a file is 0 byte. - FIXME.
 743          *
 744          * XXX We get called with buf[2048]. This allows a max. file size of
 745          * XXX 234 GB. With more we would cause a buffer overflow.
 746          * XXX We need to check whether UDF would allow files > 234 GB.
 747          */
 748         for (; length > 0; length -= chunk) {
 749                 chunk = (length > 0x3ffff800) ? 0x3ffff800 : length;
 750                 set32(&allocation_desc->extent_length, chunk);
 751                 set32(&allocation_desc->extent_position, file_rba);
 752                 file_rba += chunk >> 11;
 753                 allocation_desc++;
 754         }
 755         set32(&fe->length_of_allocation_descs,
 756                                 (unsigned char *) allocation_desc -
 757                                 (unsigned char *) &fe->allocation_desc);
 758         set_tag(&fe->desc_tag, UDF_TAGID_FILE_ENTRY, rba,
 759                 (unsigned char *) allocation_desc - buf);
 760 }
 761
 762 static unsigned
 763 directory_link_count(struct directory *dpnt)
 764 {
 765         /*
 766          * The link count is equal to 1 (for the parent) plus the
 767          * number of subdirectories.
 768          */
 769         unsigned link_count = 1;
 770         struct directory_entry *de;
 771
 772         /* count relocated subdirectories */
 773         for (de = dpnt->jcontents; de; de = de->jnext) {
 774                 if ((de->de_flags &
 775                     (INHIBIT_JOLIET_ENTRY | RELOCATED_DIRECTORY)) ==
 776                                                         RELOCATED_DIRECTORY) {
 777                         link_count++;
 778                 }
 779         }
 780         /* count ordinary subdirectories */
 781         for (dpnt = dpnt->subdir; dpnt; dpnt = dpnt->next) {
 782                 if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY)) {
 783                         link_count++;
 784                 }
 785         }
 786         return (link_count);
 787 }
 788
 789 static void
 790 write_one_udf_directory(struct directory *dpnt, FILE *outfile)
 791 {
 792         unsigned size_in_bytes, padded_size_in_bytes;
 793         struct directory_entry *de;
 794         unsigned ident_size;
 795         unsigned base_sector;
 796         struct directory *parent;
 797         Uchar buf[SECTOR_SIZE];
 798
 799         memset(buf, 0, SECTOR_SIZE);
 800         set_file_entry(
 801                 buf,
 802                 last_extent_written - lba_udf_partition_start,
 803                 last_extent_written+1 - lba_udf_partition_start,
 804                 directory_size(dpnt),
 805                 dpnt->self->isorec.date,
 806                 1,      /* is_directory */
 807                 directory_link_count(dpnt),
 808                 (dpnt == root) ? 0 : dpnt->self->udf_file_entry_sector);
 809         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 810         xfwrite(buf, SECTOR_SIZE, 1, outfile, 0, FALSE);
 811         last_extent_written++;
 812
 813         base_sector = last_extent_written - lba_udf_partition_start;
 814
 815         /* parent directory */
 816         parent = dpnt->parent;
 817         if (parent == reloc_dir) {
 818                 parent = dpnt->self->parent_rec->filedir;
 819         }
 820         ident_size = set_file_ident_desc(
 821                 buf,
 822                 base_sector,
 823                 0,
 824                 1,
 825                 parent->self->udf_file_entry_sector - lba_udf_partition_start,
 826                 (parent == root) ? 0 : parent->self->udf_file_entry_sector);
 827         jtwrite(buf, ident_size, 1, 0, FALSE);
 828         xfwrite(buf, ident_size, 1, outfile, 0, FALSE);
 829         size_in_bytes = ident_size;
 830
 831         /* directory contents */
 832         for (de = dpnt->jcontents; de; de = de->jnext) {
 833                 char *name;
 834                 struct directory_entry *de1;
 835
 836                 if (de->de_flags & INHIBIT_JOLIET_ENTRY)
 837                         continue;
 838
 839                 name = USE_MAC_NAME(de) ? de->hfs_ent->name : de->name;
 840
 841                 /* skip . and .. */
 842                 if (name[0] == '.' && (name[1] == 0 ||
 843                     (name[1] == '.' && name[2] == 0)))
 844                         continue;
 845
 846                 /* look in RR_MOVED for relocated directories */
 847                 de1 = de;
 848                 if (de->de_flags & RELOCATED_DIRECTORY) {
 849                         for (de1 = reloc_dir->contents; de1; de1 = de1->next) {
 850                                 if (de1->parent_rec == de) {
 851                                         break;
 852                                 }
 853                         }
 854                         if (!de1) {
 855 #ifdef  USE_LIBSCHILY
 856                                 comerrno(EX_BAD,
 857                                 "Unable to locate relocated directory\n");
 858 #else
 859                                 fprintf(stderr,
 860                                 "Unable to locate relocated directory\n");
 861                                 exit(1);
 862 #endif
 863                         }
 864                 }
 865
 866                 ident_size = set_file_ident_desc(
 867                         buf,
 868                         base_sector + (size_in_bytes / SECTOR_SIZE),
 869                         name,
 870                         !!(de1->isorec.flags[0] & ISO_DIRECTORY),
 871                         de1->udf_file_entry_sector - lba_udf_partition_start,
 872                         de1->udf_file_entry_sector);
 873                 jtwrite(buf, ident_size, 1, 0, FALSE);
 874                 xfwrite(buf, ident_size, 1, outfile, 0, FALSE);
 875                 size_in_bytes += ident_size;
 876         }
 877
 878         padded_size_in_bytes = PAD(size_in_bytes, SECTOR_SIZE);
 879         if (size_in_bytes < padded_size_in_bytes) {
 880                 memset(buf, 0, padded_size_in_bytes - size_in_bytes);
 881                 jtwrite(buf, padded_size_in_bytes - size_in_bytes, 1, 0, FALSE);
 882                 xfwrite(buf, padded_size_in_bytes - size_in_bytes, 1, outfile, 0, FALSE);
 883         }
 884
 885         last_extent_written += padded_size_in_bytes / SECTOR_SIZE;
 886 }
 887
 888 static void
 889 write_udf_directories(struct directory *dpnt, FILE *outfile)
 890 {
 891         if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY)) {
 892                 write_one_udf_directory(dpnt, outfile);
 893         }
 894         if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) || dpnt == reloc_dir) {
 895                 for (dpnt = dpnt->subdir; dpnt; dpnt = dpnt->next) {
 896                         write_udf_directories(dpnt, outfile);
 897                 }
 898         }
 899 }
 900
 901 static void
 902 write_udf_file_entries(struct directory *dpnt, FILE *outfile)
 903 {
 904         Uchar buf[SECTOR_SIZE];
 905
 906         memset(buf, 0, SECTOR_SIZE);
 907
 908         if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY)) {
 909                 struct directory_entry *de;
 910                 for (de = dpnt->jcontents; de; de = de->jnext) {
 911                         if (!(de->de_flags & RELOCATED_DIRECTORY) &&
 912                             !(de->isorec.flags[0] & ISO_DIRECTORY)) {
 913
 914                                 memset(buf, 0, 512);
 915                                 set_file_entry(
 916                                         buf,
 917                                         (last_extent_written++) - lba_udf_partition_start,
 918                                         read_733(de->isorec.extent) - lba_udf_partition_start,
 919                                         de->realsize,
 920                                         de->isorec.date,
 921                                         0,      /* is_directory */
 922                                         1,      /* link_count */
 923                                         de->udf_file_entry_sector);
 924                                 jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 925                                 xfwrite(buf, SECTOR_SIZE, 1, outfile, 0, FALSE);
 926                         }
 927                 }
 928         }
 929         if (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) || dpnt == reloc_dir) {
 930                 for (dpnt = dpnt->subdir; dpnt; dpnt = dpnt->next) {
 931                         write_udf_file_entries(dpnt, outfile);
 932                 }
 933         }
 934 }
 935
 936 /****************************/
 937
 938 static int
 939 udf_vol_recognition_area_write(FILE *out)
 940 {
 941         static const char *identifiers[3] = { "BEA01", "NSR02", "TEA01" };
 942         int i;
 943         char buf[SECTOR_SIZE];
 944         udf_volume_recognition_desc *vsd = (udf_volume_recognition_desc *)buf;
 945
 946         memset(buf, 0, sizeof (buf));
 947         /*set8(&vsd->structure_type, 0);*/
 948         set8(&vsd->structure_version, 1);
 949         for (i = 0; i < 3; ++i) {
 950                 memcpy(vsd->standard_identifier, identifiers[i], 5);
 951                 jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 952                 xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
 953         }
 954         last_extent_written += 3;
 955         return (0);
 956 }
 957
 958 static int
 959 udf_main_seq_write(FILE *out)
 960 {
 961         Uchar buf[SECTOR_SIZE];
 962         int i;
 963
 964         /*
 965          * volume_set_id needs to be set to a (64-bit) "unique" number.
 966          * This will have to do for now.
 967          */
 968         volume_set_id[0] = begun;
 969         volume_set_id[1] = (unsigned)clock();   /* XXX Maybe non-portable */
 970
 971         memset(buf, 0, sizeof (buf));
 972         set_primary_vol_desc(buf, last_extent_written++);
 973         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 974         xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
 975
 976         memset(buf, 0, sizeof (buf));
 977         set_impl_use_vol_desc(buf, last_extent_written++);
 978         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 979         xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
 980
 981         memset(buf, 0, sizeof (buf));
 982         set_partition_desc(buf, last_extent_written++);
 983         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 984         xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
 985
 986         memset(buf, 0, sizeof (buf));
 987         set_logical_vol_desc(buf, last_extent_written++);
 988         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 989         xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
 990
 991         memset(buf, 0, sizeof (buf));
 992         set_unallocated_space_desc(buf, last_extent_written++);
 993         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 994         xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
 995
 996         memset(buf, 0, sizeof (buf));
 997         set_terminating_desc(buf, last_extent_written++);
 998         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
 999         xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
1000
1001         memset(buf, 0, sizeof (buf));
1002         for (i = 6; i < UDF_MAIN_SEQ_LENGTH; ++i) {
1003         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
1004                 xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
1005                 last_extent_written++;
1006         }
1007
1008         return (0);
1009 }
1010
1011 static int
1012 udf_integ_seq_write(FILE *out)
1013 {
1014         Uchar buf[SECTOR_SIZE*UDF_INTEG_SEQ_LENGTH];
1015
1016         memset(buf, 0, sizeof (buf));
1017
1018         set_logical_vol_integrity_desc(buf+0*SECTOR_SIZE,
1019                                                 last_extent_written++);
1020         set_terminating_desc(buf+1*SECTOR_SIZE, last_extent_written++);
1021
1022         jtwrite(buf, SECTOR_SIZE, UDF_INTEG_SEQ_LENGTH, 0, FALSE);
1023         xfwrite(buf, SECTOR_SIZE, UDF_INTEG_SEQ_LENGTH, out, 0, FALSE);
1024         return (0);
1025 }
1026
1027 static int
1028 udf_anchor_vol_desc_write(FILE *out)
1029 {
1030         Uchar buf[SECTOR_SIZE];
1031
1032         memset(buf, 0, sizeof (buf));
1033         set_anchor_volume_desc_pointer(buf, last_extent_written++);
1034         jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
1035         xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
1036         return (0);
1037 }
1038
1039 static int
1040 udf_file_set_desc_write(FILE *out)
1041 {
1042         Uchar buf[SECTOR_SIZE*2];
1043
1044         memset(buf, 0, sizeof (buf));
1045
1046         set_file_set_desc(buf+0*SECTOR_SIZE,
1047                         (last_extent_written++) - lba_udf_partition_start);
1048         set_terminating_desc(buf+1*SECTOR_SIZE,
1049                         (last_extent_written++) - lba_udf_partition_start);
1050
1051         jtwrite(buf, SECTOR_SIZE, 2, 0, FALSE);
1052         xfwrite(buf, SECTOR_SIZE, 2, out, 0, FALSE);
1053
1054         return (0);
1055 }
1056
1057 static int
1058 udf_dirtree_write(FILE *out)
1059 {
1060         write_udf_directories(root, out);
1061         return (0);
1062 }
1063
1064 static int
1065 udf_file_entries_write(FILE *out)
1066 {
1067         write_udf_file_entries(root, out);
1068         return (0);
1069 }
1070
1071 static int
1072 pad_to(unsigned last_extent_to_write, FILE *out)
1073 {
1074         char buf[SECTOR_SIZE];
1075         memset(buf, 0, sizeof (buf));
1076         while (last_extent_written < last_extent_to_write) {
1077                 jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
1078                 xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
1079                 ++last_extent_written;
1080         }
1081         return (0);
1082 }
1083
1084 static int
1085 udf_pad_to_sector_32_write(FILE *out)
1086 {
1087         return (pad_to(session_start+32, out));
1088 }
1089
1090 static int
1091 udf_pad_to_sector_256_write(FILE *out)
1092 {
1093         return (pad_to(session_start+256, out));
1094 }
1095
1096 static int
1097 udf_padend_avdp_write(FILE *out)
1098 {
1099         Uchar buf[SECTOR_SIZE];
1100         unsigned last_extent_to_write = (last_extent_written+31) & ~15;
1101
1102         if (!use_sparcboot)
1103                 last_extent_to_write = last_extent_written + 150;
1104
1105         memset(buf, 0, sizeof (buf));
1106         while (last_extent_written < last_extent_to_write) {
1107                 set_anchor_volume_desc_pointer(buf, last_extent_written++);
1108                 jtwrite(buf, SECTOR_SIZE, 1, 0, FALSE);
1109                 xfwrite(buf, SECTOR_SIZE, 1, out, 0, FALSE);
1110         }
1111         return (0);
1112 }
1113
1114
1115 struct output_fragment udf_vol_recognition_area_frag = { NULL, udf_vol_recognition_area_size, NULL, udf_vol_recognition_area_write, "UDF volume recognition area" };
1116 struct output_fragment udf_main_seq_frag = { NULL, udf_main_seq_size, NULL, udf_main_seq_write, "UDF main seq" };
1117 struct output_fragment udf_main_seq_copy_frag = { NULL, udf_main_seq_copy_size, NULL, udf_main_seq_write, "UDF second seq" };
1118 struct output_fragment udf_integ_seq_frag = { NULL, udf_integ_seq_size, NULL, udf_integ_seq_write, "UDF integ seq" };
1119 struct output_fragment udf_anchor_vol_desc_frag = { NULL, oneblock_size, NULL, udf_anchor_vol_desc_write, "UDF Anchor volume" };
1120 struct output_fragment udf_file_set_desc_frag = { NULL, udf_file_set_desc_size, NULL, udf_file_set_desc_write, "UDF file set" };
1121 struct output_fragment udf_dirtree_frag = { NULL, udf_dirtree_size, NULL, udf_dirtree_write, "UDF directory tree" };
1122 struct output_fragment udf_file_entries_frag = { NULL, udf_file_entries_size, NULL, udf_file_entries_write, "UDF file entries" };
1123 struct output_fragment udf_end_anchor_vol_desc_frag = { NULL, udf_end_anchor_vol_desc_size, NULL, udf_anchor_vol_desc_write, "UDF Anchor end volume" };
1124
1125 struct output_fragment udf_pad_to_sector_32_frag = { NULL, udf_pad_to_sector_32_size, NULL, udf_pad_to_sector_32_write, "UDF pad to sector 32" };
1126 struct output_fragment udf_pad_to_sector_256_frag = { NULL, udf_pad_to_sector_256_size, NULL, udf_pad_to_sector_256_write, "UDF pad to sector 256" };
1127 struct output_fragment udf_padend_avdp_frag = { NULL, udf_padend_avdp_size, NULL, udf_padend_avdp_write, "UDF Pad end" };
1128
1129 /*
1130  * This function assigns weights as follows:
1131  *
1132  * /VIDEO_TS/VIDEO_TS.IFO   11199
1133  * /VIDEO_TS/VIDEO_TS.VOB   11198
1134  * /VIDEO_TS/VIDEO_TS.BUP   11188
1135  * /VIDEO_TS/VTS_01_0.IFO   11187
1136  * /VIDEO_TS/VTS_01_0.VOB   11186
1137  *            :               :
1138  * /VIDEO_TS/VTS_01_9.VOB   11177
1139  * /VIDEO_TS/VTS_01_0.BUP   11176
1140  *            :               :
1141  * /VIDEO_TS/VTS_99_0.BUP   10000
1142  *
1143  * This ensures that DVD-Video files are laid out properly on the disc.
1144  * The same thing is done for AUDIO_TS files, except in the 20000 range
1145  * instead of the 10000 range.
1146  *
1147  * Question: what about JACKET_P files?
1148  *
1149  * Answer: At least as far as I know :)
1150  * JACKET_P files are still images (single frame mpeg video .i.e mp2
1151  * format). The DVD Jacket pictures will be displayed on the TV screen
1152  * when the player is in a stop/resume mode.
1153  * The location is not dependent on IFO information and the only must
1154  * as far as I know is that they are in upper case (both dir and files).
1155  * This sparce information makes me conclude that they don't need any
1156  * weight. This obviously needs to be tested.
1157  */
1158 int
1159 assign_dvd_weights(char *name, struct directory *this_dir, int val)
1160 {
1161         int ts_number;
1162         int segment;
1163         int audio;
1164
1165         if (name[0] != 'A' && name[0] != 'V')
1166                 return (val);
1167
1168         if (memcmp(name, "VIDEO_TS", 8) == 0) {
1169                 ts_number = 0;
1170                 audio = 0;
1171         } else if (memcmp(name, "VTS_", 4) == 0) {
1172                 ts_number = 1;
1173                 audio = 0;
1174         } else if (memcmp(name, "AUDIO_TS", 8) == 0) {
1175                 ts_number = 0;
1176                 audio = 1;
1177         } else if (memcmp(name, "ATS_", 4) == 0) {
1178                 ts_number = 1;
1179                 audio = 1;
1180         } else {
1181                 return (val);
1182         }
1183
1184         if (this_dir->parent != root ||
1185             strcmp(this_dir->de_name, "VIDEO_TS") != 0)
1186                 return (val);
1187
1188         if (ts_number == 0) {
1189                 segment = 0;
1190         } else {
1191                 if (name[4] >= '0' && name[4] <= '9' &&
1192                     name[5] >= '0' && name[5] <= '9' &&
1193                     name[6] == '_' &&
1194                     name[7] >= '0' && name[7] <= '9') {
1195                         ts_number = name[4] * 10 + name[5] - ('0' * 11);
1196                         segment = name[7] - '0';
1197                 } else {
1198                         return (val);
1199                 }
1200         }
1201
1202         if (strcmp(name+8, audio ? ".AOB" : ".VOB") == 0) {
1203                 return (audio * 10000 - ts_number * 12 - segment + 11198);
1204         } else if (strcmp(name+8, ".IFO") == 0) {
1205                 return (audio * 10000 - ts_number * 12 + 11199);
1206         } else if (strcmp(name+8, ".BUP") == 0) {
1207                 return (audio * 10000 - ts_number * 12 + 11188);
1208         } else {
1209                 return (val);
1210         }
1211 }
1212
1213 #endif  /* UDF */