libdvdread4/dvd_udf.c

   1 /*
   2  * This code is based on dvdudf by:
   3  *   Christian Wolff <scarabaeus@convergence.de>.
   4  *
   5  * Modifications by:
   6  *   Billy Biggs <vektor@dumbterm.net>.
   7  *   Björn Englund <d4bjorn@dtek.chalmers.se>.
   8  *
   9  * dvdudf: parse and read the UDF volume information of a DVD Video
  10  * Copyright (C) 1999 Christian Wolff for convergence integrated media
  11  * GmbH The author can be reached at scarabaeus@convergence.de, the
  12  * project's page is at http://linuxtv.org/dvd/
  13  *
  14  * This file is part of libdvdread.
  15  *
  16  * libdvdread is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * libdvdread is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License along
  27  * with libdvdread; if not, write to the Free Software Foundation, Inc.,
  28  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  29  */
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <unistd.h>
  38 #include <inttypes.h>
  39
  40 #include "dvdread/dvd_reader.h"
  41 #include "dvdread/dvd_udf.h"
  42
  43 /* Private but located in/shared with dvd_reader.c */
  44 extern int UDFReadBlocksRaw( dvd_reader_t *device, uint32_t lb_number,
  45                              size_t block_count, unsigned char *data,
  46                              int encrypted );
  47
  48 /* It's required to either fail or deliver all the blocks asked for. */
  49 static int DVDReadLBUDF( dvd_reader_t *device, uint32_t lb_number,
  50                          size_t block_count, unsigned char *data,
  51                          int encrypted )
  52 {
  53   int ret;
  54   size_t count = block_count;
  55
  56   while(count > 0) {
  57
  58     ret = UDFReadBlocksRaw(device, lb_number, count, data, encrypted);
  59
  60     if(ret <= 0) {
  61       /* One of the reads failed or nothing more to read, too bad.
  62        * We won't even bother returning the reads that went ok. */
  63       return ret;
  64     }
  65
  66     count -= (size_t)ret;
  67     lb_number += (uint32_t)ret;
  68   }
  69
  70   return block_count;
  71 }
  72
  73
  74 #ifndef NULL
  75 #define NULL ((void *)0)
  76 #endif
  77
  78 struct Partition {
  79   int valid;
  80   char VolumeDesc[128];
  81   uint16_t Flags;
  82   uint16_t Number;
  83   char Contents[32];
  84   uint32_t AccessType;
  85   uint32_t Start;
  86   uint32_t Length;
  87 };
  88
  89 struct AD {
  90   uint32_t Location;
  91   uint32_t Length;
  92   uint8_t  Flags;
  93   uint16_t Partition;
  94 };
  95
  96 struct extent_ad {
  97   uint32_t location;
  98   uint32_t length;
  99 };
 100
 101 struct avdp_t {
 102   struct extent_ad mvds;
 103   struct extent_ad rvds;
 104 };
 105
 106 struct pvd_t {
 107   uint8_t VolumeIdentifier[32];
 108   uint8_t VolumeSetIdentifier[128];
 109 };
 110
 111 struct lbudf {
 112   uint32_t lb;
 113   uint8_t *data;
 114   /* needed for proper freeing */
 115   uint8_t *data_base;
 116 };
 117
 118 struct icbmap {
 119   uint32_t lbn;
 120   struct AD file;
 121   uint8_t filetype;
 122 };
 123
 124 struct udf_cache {
 125   int avdp_valid;
 126   struct avdp_t avdp;
 127   int pvd_valid;
 128   struct pvd_t pvd;
 129   int partition_valid;
 130   struct Partition partition;
 131   int rooticb_valid;
 132   struct AD rooticb;
 133   int lb_num;
 134   struct lbudf *lbs;
 135   int map_num;
 136   struct icbmap *maps;
 137 };
 138
 139 typedef enum {
 140   PartitionCache, RootICBCache, LBUDFCache, MapCache, AVDPCache, PVDCache
 141 } UDFCacheType;
 142
 143 void FreeUDFCache(void *cache)
 144 {
 145   struct udf_cache *c = (struct udf_cache *)cache;
 146   if(c == NULL)
 147     return;
 148
 149   if(c->lbs) {
 150     int n;
 151     for(n = 0; n < c->lb_num; n++)
 152       free(c->lbs[n].data_base);
 153     free(c->lbs);
 154   }
 155   if(c->maps)
 156     free(c->maps);
 157   free(c);
 158 }
 159
 160
 161 static int GetUDFCache(dvd_reader_t *device, UDFCacheType type,
 162                        uint32_t nr, void *data)
 163 {
 164   int n;
 165   struct udf_cache *c;
 166
 167   if(DVDUDFCacheLevel(device, -1) <= 0)
 168     return 0;
 169
 170   c = (struct udf_cache *)GetUDFCacheHandle(device);
 171
 172   if(c == NULL)
 173     return 0;
 174
 175   switch(type) {
 176   case AVDPCache:
 177     if(c->avdp_valid) {
 178       *(struct avdp_t *)data = c->avdp;
 179       return 1;
 180     }
 181     break;
 182   case PVDCache:
 183     if(c->pvd_valid) {
 184       *(struct pvd_t *)data = c->pvd;
 185       return 1;
 186     }
 187     break;
 188   case PartitionCache:
 189     if(c->partition_valid) {
 190       *(struct Partition *)data = c->partition;
 191       return 1;
 192     }
 193     break;
 194   case RootICBCache:
 195     if(c->rooticb_valid) {
 196       *(struct AD *)data = c->rooticb;
 197       return 1;
 198     }
 199     break;
 200   case LBUDFCache:
 201     for(n = 0; n < c->lb_num; n++) {
 202       if(c->lbs[n].lb == nr) {
 203         *(uint8_t **)data = c->lbs[n].data;
 204         return 1;
 205       }
 206     }
 207     break;
 208   case MapCache:
 209     for(n = 0; n < c->map_num; n++) {
 210       if(c->maps[n].lbn == nr) {
 211         *(struct icbmap *)data = c->maps[n];
 212         return 1;
 213       }
 214     }
 215     break;
 216   default:
 217     break;
 218   }
 219
 220   return 0;
 221 }
 222
 223 static int SetUDFCache(dvd_reader_t *device, UDFCacheType type,
 224                        uint32_t nr, void *data)
 225 {
 226   int n;
 227   struct udf_cache *c;
 228   void *tmp;
 229
 230   if(DVDUDFCacheLevel(device, -1) <= 0)
 231     return 0;
 232
 233   c = (struct udf_cache *)GetUDFCacheHandle(device);
 234
 235   if(c == NULL) {
 236     c = calloc(1, sizeof(struct udf_cache));
 237     /* fprintf(stderr, "calloc: %d\n", sizeof(struct udf_cache)); */
 238     if(c == NULL)
 239       return 0;
 240     SetUDFCacheHandle(device, c);
 241   }
 242
 243
 244   switch(type) {
 245   case AVDPCache:
 246     c->avdp = *(struct avdp_t *)data;
 247     c->avdp_valid = 1;
 248     break;
 249   case PVDCache:
 250     c->pvd = *(struct pvd_t *)data;
 251     c->pvd_valid = 1;
 252     break;
 253   case PartitionCache:
 254     c->partition = *(struct Partition *)data;
 255     c->partition_valid = 1;
 256     break;
 257   case RootICBCache:
 258     c->rooticb = *(struct AD *)data;
 259     c->rooticb_valid = 1;
 260     break;
 261   case LBUDFCache:
 262     for(n = 0; n < c->lb_num; n++) {
 263       if(c->lbs[n].lb == nr) {
 264         /* replace with new data */
 265         c->lbs[n].data_base = ((uint8_t **)data)[0];
 266         c->lbs[n].data = ((uint8_t **)data)[1];
 267         c->lbs[n].lb = nr;
 268         return 1;
 269       }
 270     }
 271     c->lb_num++;
 272     tmp = realloc(c->lbs, c->lb_num * sizeof(struct lbudf));
 273     /*
 274     fprintf(stderr, "realloc lb: %d * %d = %d\n",
 275     c->lb_num, sizeof(struct lbudf),
 276     c->lb_num * sizeof(struct lbudf));
 277     */
 278     if(tmp == NULL) {
 279       if(c->lbs) free(c->lbs);
 280       c->lb_num = 0;
 281       return 0;
 282     }
 283     c->lbs = tmp;
 284     c->lbs[n].data_base = ((uint8_t **)data)[0];
 285     c->lbs[n].data = ((uint8_t **)data)[1];
 286     c->lbs[n].lb = nr;
 287     break;
 288   case MapCache:
 289     for(n = 0; n < c->map_num; n++) {
 290       if(c->maps[n].lbn == nr) {
 291         /* replace with new data */
 292         c->maps[n] = *(struct icbmap *)data;
 293         c->maps[n].lbn = nr;
 294         return 1;
 295       }
 296     }
 297     c->map_num++;
 298     tmp = realloc(c->maps, c->map_num * sizeof(struct icbmap));
 299     /*
 300     fprintf(stderr, "realloc maps: %d * %d = %d\n",
 301       c->map_num, sizeof(struct icbmap),
 302       c->map_num * sizeof(struct icbmap));
 303     */
 304     if(tmp == NULL) {
 305       if(c->maps) free(c->maps);
 306       c->map_num = 0;
 307       return 0;
 308     }
 309     c->maps = tmp;
 310     c->maps[n] = *(struct icbmap *)data;
 311     c->maps[n].lbn = nr;
 312     break;
 313   default:
 314     return 0;
 315   }
 316
 317   return 1;
 318 }
 319
 320
 321 /* For direct data access, LSB first */
 322 #define GETN1(p) ((uint8_t)data[p])
 323 #define GETN2(p) ((uint16_t)data[p] | ((uint16_t)data[(p) + 1] << 8))
 324 #define GETN3(p) ((uint32_t)data[p] | ((uint32_t)data[(p) + 1] << 8)    \
 325                   | ((uint32_t)data[(p) + 2] << 16))
 326 #define GETN4(p) ((uint32_t)data[p]                     \
 327                   | ((uint32_t)data[(p) + 1] << 8)      \
 328                   | ((uint32_t)data[(p) + 2] << 16)     \
 329                   | ((uint32_t)data[(p) + 3] << 24))
 330 /* This is wrong with regard to endianess */
 331 #define GETN(p, n, target) memcpy(target, &data[p], n)
 332
 333 static int Unicodedecode( uint8_t *data, int len, char *target )
 334 {
 335   int p = 1, i = 0;
 336
 337   if( ( data[ 0 ] == 8 ) || ( data[ 0 ] == 16 ) ) do {
 338     if( data[ 0 ] == 16 ) p++;  /* Ignore MSB of unicode16 */
 339     if( p < len ) {
 340       target[ i++ ] = data[ p++ ];
 341     }
 342   } while( p < len );
 343
 344   target[ i ] = '\0';
 345   return 0;
 346 }
 347
 348 static int UDFDescriptor( uint8_t *data, uint16_t *TagID )
 349 {
 350   *TagID = GETN2(0);
 351   /* TODO: check CRC 'n stuff */
 352   return 0;
 353 }
 354
 355 static int UDFExtentAD( uint8_t *data, uint32_t *Length, uint32_t *Location )
 356 {
 357   *Length   = GETN4(0);
 358   *Location = GETN4(4);
 359   return 0;
 360 }
 361
 362 static int UDFShortAD( uint8_t *data, struct AD *ad,
 363                        struct Partition *partition )
 364 {
 365   ad->Length = GETN4(0);
 366   ad->Flags = ad->Length >> 30;
 367   ad->Length &= 0x3FFFFFFF;
 368   ad->Location = GETN4(4);
 369   ad->Partition = partition->Number; /* use number of current partition */
 370   return 0;
 371 }
 372
 373 static int UDFLongAD( uint8_t *data, struct AD *ad )
 374 {
 375   ad->Length = GETN4(0);
 376   ad->Flags = ad->Length >> 30;
 377   ad->Length &= 0x3FFFFFFF;
 378   ad->Location = GETN4(4);
 379   ad->Partition = GETN2(8);
 380   /* GETN(10, 6, Use); */
 381   return 0;
 382 }
 383
 384 static int UDFExtAD( uint8_t *data, struct AD *ad )
 385 {
 386   ad->Length = GETN4(0);
 387   ad->Flags = ad->Length >> 30;
 388   ad->Length &= 0x3FFFFFFF;
 389   ad->Location = GETN4(12);
 390   ad->Partition = GETN2(16);
 391   /* GETN(10, 6, Use); */
 392   return 0;
 393 }
 394
 395 static int UDFICB( uint8_t *data, uint8_t *FileType, uint16_t *Flags )
 396 {
 397   *FileType = GETN1(11);
 398   *Flags = GETN2(18);
 399   return 0;
 400 }
 401
 402
 403 static int UDFPartition( uint8_t *data, uint16_t *Flags, uint16_t *Number,
 404                          char *Contents, uint32_t *Start, uint32_t *Length )
 405 {
 406   *Flags = GETN2(20);
 407   *Number = GETN2(22);
 408   GETN(24, 32, Contents);
 409   *Start = GETN4(188);
 410   *Length = GETN4(192);
 411   return 0;
 412 }
 413
 414 /**
 415  * Reads the volume descriptor and checks the parameters.  Returns 0 on OK, 1
 416  * on error.
 417  */
 418 static int UDFLogVolume( uint8_t *data, char *VolumeDescriptor )
 419 {
 420   uint32_t lbsize, MT_L, N_PM;
 421   Unicodedecode(&data[84], 128, VolumeDescriptor);
 422   lbsize = GETN4(212);  /* should be 2048 */
 423   MT_L = GETN4(264);    /* should be 6 */
 424   N_PM = GETN4(268);    /* should be 1 */
 425   if (lbsize != DVD_VIDEO_LB_LEN) return 1;
 426   return 0;
 427 }
 428
 429 static int UDFFileEntry( uint8_t *data, uint8_t *FileType,
 430                          struct Partition *partition, struct AD *ad )
 431 {
 432   uint16_t flags;
 433   uint32_t L_EA, L_AD;
 434   unsigned int p;
 435
 436   UDFICB( &data[ 16 ], FileType, &flags );
 437
 438   /* Init ad for an empty file (i.e. there isn't a AD, L_AD == 0 ) */
 439   ad->Length = GETN4( 60 ); /* Really 8 bytes a 56 */
 440   ad->Flags = 0;
 441   ad->Location = 0; /* what should we put here?  */
 442   ad->Partition = partition->Number; /* use number of current partition */
 443
 444   L_EA = GETN4( 168 );
 445   L_AD = GETN4( 172 );
 446   p = 176 + L_EA;
 447   while( p < 176 + L_EA + L_AD ) {
 448     switch( flags & 0x0007 ) {
 449     case 0:
 450       UDFShortAD( &data[ p ], ad, partition );
 451       p += 8;
 452       break;
 453     case 1:
 454       UDFLongAD( &data[ p ], ad );
 455       p += 16;
 456       break;
 457     case 2:
 458       UDFExtAD( &data[ p ], ad );
 459       p += 20;
 460       break;
 461     case 3:
 462       switch( L_AD ) {
 463       case 8:
 464         UDFShortAD( &data[ p ], ad, partition );
 465         break;
 466       case 16:
 467         UDFLongAD( &data[ p ], ad );
 468         break;
 469       case 20:
 470         UDFExtAD( &data[ p ], ad );
 471         break;
 472       }
 473       p += L_AD;
 474       break;
 475     default:
 476       p += L_AD;
 477       break;
 478     }
 479   }
 480   return 0;
 481 }
 482
 483 static int UDFFileIdentifier( uint8_t *data, uint8_t *FileCharacteristics,
 484                               char *FileName, struct AD *FileICB )
 485 {
 486   uint8_t L_FI;
 487   uint16_t L_IU;
 488
 489   *FileCharacteristics = GETN1(18);
 490   L_FI = GETN1(19);
 491   UDFLongAD(&data[20], FileICB);
 492   L_IU = GETN2(36);
 493   if (L_FI) Unicodedecode(&data[38 + L_IU], L_FI, FileName);
 494   else FileName[0] = '\0';
 495   return 4 * ((38 + L_FI + L_IU + 3) / 4);
 496 }
 497
 498 /**
 499  * Maps ICB to FileAD
 500  * ICB: Location of ICB of directory to scan
 501  * FileType: Type of the file
 502  * File: Location of file the ICB is pointing to
 503  * return 1 on success, 0 on error;
 504  */
 505 static int UDFMapICB( dvd_reader_t *device, struct AD ICB, uint8_t *FileType,
 506                       struct Partition *partition, struct AD *File )
 507 {
 508   uint8_t LogBlock_base[DVD_VIDEO_LB_LEN + 2048];
 509   uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
 510   uint32_t lbnum;
 511   uint16_t TagID;
 512   struct icbmap tmpmap;
 513
 514   lbnum = partition->Start + ICB.Location;
 515   tmpmap.lbn = lbnum;
 516   if(GetUDFCache(device, MapCache, lbnum, &tmpmap)) {
 517     *FileType = tmpmap.filetype;
 518     memcpy(File, &tmpmap.file, sizeof(tmpmap.file));
 519     return 1;
 520   }
 521
 522   do {
 523     if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
 524       TagID = 0;
 525     else
 526       UDFDescriptor( LogBlock, &TagID );
 527
 528     if( TagID == 261 ) {
 529       UDFFileEntry( LogBlock, FileType, partition, File );
 530       memcpy(&tmpmap.file, File, sizeof(tmpmap.file));
 531       tmpmap.filetype = *FileType;
 532       SetUDFCache(device, MapCache, tmpmap.lbn, &tmpmap);
 533       return 1;
 534     };
 535   } while( ( lbnum <= partition->Start + ICB.Location + ( ICB.Length - 1 )
 536              / DVD_VIDEO_LB_LEN ) && ( TagID != 261 ) );
 537
 538   return 0;
 539 }
 540
 541 /**
 542  * Dir: Location of directory to scan
 543  * FileName: Name of file to look for
 544  * FileICB: Location of ICB of the found file
 545  * return 1 on success, 0 on error;
 546  */
 547 static int UDFScanDir( dvd_reader_t *device, struct AD Dir, char *FileName,
 548                        struct Partition *partition, struct AD *FileICB,
 549                        int cache_file_info)
 550 {
 551   char filename[ MAX_UDF_FILE_NAME_LEN ];
 552   uint8_t directory_base[ 2 * DVD_VIDEO_LB_LEN + 2048];
 553   uint8_t *directory = (uint8_t *)(((uintptr_t)directory_base & ~((uintptr_t)2047)) + 2048);
 554   uint32_t lbnum;
 555   uint16_t TagID;
 556   uint8_t filechar;
 557   unsigned int p;
 558   uint8_t *cached_dir_base = NULL, *cached_dir;
 559   uint32_t dir_lba;
 560   struct AD tmpICB;
 561   int found = 0;
 562   int in_cache = 0;
 563
 564   /* Scan dir for ICB of file */
 565   lbnum = partition->Start + Dir.Location;
 566
 567   if(DVDUDFCacheLevel(device, -1) > 0) {
 568     /* caching */
 569
 570     if(!GetUDFCache(device, LBUDFCache, lbnum, &cached_dir)) {
 571       dir_lba = (Dir.Length + DVD_VIDEO_LB_LEN) / DVD_VIDEO_LB_LEN;
 572       if((cached_dir_base = malloc(dir_lba * DVD_VIDEO_LB_LEN + 2048)) == NULL)
 573         return 0;
 574       cached_dir = (uint8_t *)(((uintptr_t)cached_dir_base & ~((uintptr_t)2047)) + 2048);
 575       if( DVDReadLBUDF( device, lbnum, dir_lba, cached_dir, 0) <= 0 ) {
 576         free(cached_dir_base);
 577         cached_dir_base = NULL;
 578         cached_dir = NULL;
 579       }
 580       /*
 581       if(cached_dir) {
 582         fprintf(stderr, "malloc dir: %d\n",  dir_lba * DVD_VIDEO_LB_LEN);
 583       }
 584       */
 585       {
 586         uint8_t *data[2];
 587         data[0] = cached_dir_base;
 588         data[1] = cached_dir;
 589         SetUDFCache(device, LBUDFCache, lbnum, data);
 590       }
 591     } else
 592       in_cache = 1;
 593
 594     if(cached_dir == NULL)
 595       return 0;
 596
 597     p = 0;
 598
 599     while( p < Dir.Length ) {
 600       UDFDescriptor( &cached_dir[ p ], &TagID );
 601       if( TagID == 257 ) {
 602         p += UDFFileIdentifier( &cached_dir[ p ], &filechar,
 603                                 filename, &tmpICB );
 604         if(cache_file_info && !in_cache) {
 605           uint8_t tmpFiletype;
 606           struct AD tmpFile;
 607
 608           if( !strcasecmp( FileName, filename ) ) {
 609             memcpy(FileICB, &tmpICB, sizeof(tmpICB));
 610             found = 1;
 611           }
 612           UDFMapICB(device, tmpICB, &tmpFiletype, partition, &tmpFile);
 613         } else {
 614           if( !strcasecmp( FileName, filename ) ) {
 615             memcpy(FileICB, &tmpICB, sizeof(tmpICB));
 616             return 1;
 617           }
 618         }
 619       } else {
 620         if(cache_file_info && (!in_cache) && found)
 621           return 1;
 622         return 0;
 623       }
 624     }
 625     if(cache_file_info && (!in_cache) && found)
 626       return 1;
 627     return 0;
 628   }
 629
 630   if( DVDReadLBUDF( device, lbnum, 2, directory, 0 ) <= 0 )
 631     return 0;
 632
 633   p = 0;
 634   while( p < Dir.Length ) {
 635     if( p > DVD_VIDEO_LB_LEN ) {
 636       ++lbnum;
 637       p -= DVD_VIDEO_LB_LEN;
 638       Dir.Length -= DVD_VIDEO_LB_LEN;
 639       if( DVDReadLBUDF( device, lbnum, 2, directory, 0 ) <= 0 ) {
 640         return 0;
 641       }
 642     }
 643     UDFDescriptor( &directory[ p ], &TagID );
 644     if( TagID == 257 ) {
 645       p += UDFFileIdentifier( &directory[ p ], &filechar,
 646                               filename, FileICB );
 647       if( !strcasecmp( FileName, filename ) ) {
 648         return 1;
 649       }
 650     } else
 651       return 0;
 652   }
 653
 654   return 0;
 655 }
 656
 657
 658 static int UDFGetAVDP( dvd_reader_t *device,
 659                        struct avdp_t *avdp)
 660 {
 661   uint8_t Anchor_base[ DVD_VIDEO_LB_LEN + 2048 ];
 662   uint8_t *Anchor = (uint8_t *)(((uintptr_t)Anchor_base & ~((uintptr_t)2047)) + 2048);
 663   uint32_t lbnum, MVDS_location, MVDS_length;
 664   uint16_t TagID;
 665   uint32_t lastsector;
 666   int terminate;
 667   struct avdp_t;
 668
 669   if(GetUDFCache(device, AVDPCache, 0, avdp))
 670     return 1;
 671
 672   /* Find Anchor */
 673   lastsector = 0;
 674   lbnum = 256;   /* Try #1, prime anchor */
 675   terminate = 0;
 676
 677   for(;;) {
 678     if( DVDReadLBUDF( device, lbnum, 1, Anchor, 0 ) > 0 ) {
 679       UDFDescriptor( Anchor, &TagID );
 680     } else {
 681       TagID = 0;
 682     }
 683     if (TagID != 2) {
 684       /* Not an anchor */
 685       if( terminate ) return 0; /* Final try failed */
 686
 687       if( lastsector ) {
 688         /* We already found the last sector.  Try #3, alternative
 689          * backup anchor.  If that fails, don't try again.
 690          */
 691         lbnum = lastsector;
 692         terminate = 1;
 693       } else {
 694         /* TODO: Find last sector of the disc (this is optional). */
 695         if( lastsector )
 696           /* Try #2, backup anchor */
 697           lbnum = lastsector - 256;
 698         else
 699           /* Unable to find last sector */
 700           return 0;
 701       }
 702     } else
 703       /* It's an anchor! We can leave */
 704       break;
 705   }
 706   /* Main volume descriptor */
 707   UDFExtentAD( &Anchor[ 16 ], &MVDS_length, &MVDS_location );
 708   avdp->mvds.location = MVDS_location;
 709   avdp->mvds.length = MVDS_length;
 710
 711   /* Backup volume descriptor */
 712   UDFExtentAD( &Anchor[ 24 ], &MVDS_length, &MVDS_location );
 713   avdp->rvds.location = MVDS_location;
 714   avdp->rvds.length = MVDS_length;
 715
 716   SetUDFCache(device, AVDPCache, 0, avdp);
 717
 718   return 1;
 719 }
 720
 721 /**
 722  * Looks for partition on the disc.  Returns 1 if partition found, 0 on error.
 723  *   partnum: Number of the partition, starting at 0.
 724  *   part: structure to fill with the partition information
 725  */
 726 static int UDFFindPartition( dvd_reader_t *device, int partnum,
 727                              struct Partition *part )
 728 {
 729   uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ];
 730   uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
 731   uint32_t lbnum, MVDS_location, MVDS_length;
 732   uint16_t TagID;
 733   int i, volvalid;
 734   struct avdp_t avdp;
 735
 736   if(!UDFGetAVDP(device, &avdp))
 737     return 0;
 738
 739   /* Main volume descriptor */
 740   MVDS_location = avdp.mvds.location;
 741   MVDS_length = avdp.mvds.length;
 742
 743   part->valid = 0;
 744   volvalid = 0;
 745   part->VolumeDesc[ 0 ] = '\0';
 746   i = 1;
 747   do {
 748     /* Find Volume Descriptor */
 749     lbnum = MVDS_location;
 750     do {
 751
 752       if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
 753         TagID = 0;
 754       else
 755         UDFDescriptor( LogBlock, &TagID );
 756
 757       if( ( TagID == 5 ) && ( !part->valid ) ) {
 758         /* Partition Descriptor */
 759         UDFPartition( LogBlock, &part->Flags, &part->Number,
 760                       part->Contents, &part->Start, &part->Length );
 761         part->valid = ( partnum == part->Number );
 762       } else if( ( TagID == 6 ) && ( !volvalid ) ) {
 763         /* Logical Volume Descriptor */
 764         if( UDFLogVolume( LogBlock, part->VolumeDesc ) ) {
 765           /* TODO: sector size wrong! */
 766         } else
 767           volvalid = 1;
 768       }
 769
 770     } while( ( lbnum <= MVDS_location + ( MVDS_length - 1 )
 771                / DVD_VIDEO_LB_LEN ) && ( TagID != 8 )
 772              && ( ( !part->valid ) || ( !volvalid ) ) );
 773
 774     if( ( !part->valid) || ( !volvalid ) ) {
 775       /* Backup volume descriptor */
 776       MVDS_location = avdp.mvds.location;
 777       MVDS_length = avdp.mvds.length;
 778     }
 779   } while( i-- && ( ( !part->valid ) || ( !volvalid ) ) );
 780
 781   /* We only care for the partition, not the volume */
 782   return part->valid;
 783 }
 784
 785 uint32_t UDFFindFile( dvd_reader_t *device, char *filename,
 786                       uint32_t *filesize )
 787 {
 788   uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ];
 789   uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
 790   uint32_t lbnum;
 791   uint16_t TagID;
 792   struct Partition partition;
 793   struct AD RootICB, File, ICB;
 794   char tokenline[ MAX_UDF_FILE_NAME_LEN ];
 795   char *token;
 796   uint8_t filetype;
 797
 798   *filesize = 0;
 799   tokenline[0] = '\0';
 800   strncat(tokenline, filename, MAX_UDF_FILE_NAME_LEN - 1);
 801   memset(&ICB, 0, sizeof(ICB));
 802
 803   if(!(GetUDFCache(device, PartitionCache, 0, &partition) &&
 804        GetUDFCache(device, RootICBCache, 0, &RootICB))) {
 805     /* Find partition, 0 is the standard location for DVD Video.*/
 806     if( !UDFFindPartition( device, 0, &partition ) ) return 0;
 807     SetUDFCache(device, PartitionCache, 0, &partition);
 808
 809     /* Find root dir ICB */
 810     lbnum = partition.Start;
 811     do {
 812       if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
 813         TagID = 0;
 814       else
 815         UDFDescriptor( LogBlock, &TagID );
 816
 817       /* File Set Descriptor */
 818       if( TagID == 256 )  /* File Set Descriptor */
 819         UDFLongAD( &LogBlock[ 400 ], &RootICB );
 820     } while( ( lbnum < partition.Start + partition.Length )
 821              && ( TagID != 8 ) && ( TagID != 256 ) );
 822
 823     /* Sanity checks. */
 824     if( TagID != 256 )
 825       return 0;
 826     if( RootICB.Partition != 0 )
 827       return 0;
 828     SetUDFCache(device, RootICBCache, 0, &RootICB);
 829   }
 830
 831   /* Find root dir */
 832   if( !UDFMapICB( device, RootICB, &filetype, &partition, &File ) )
 833     return 0;
 834   if( filetype != 4 )
 835     return 0;  /* Root dir should be dir */
 836   {
 837     int cache_file_info = 0;
 838     /* Tokenize filepath */
 839     token = strtok(tokenline, "/");
 840
 841     while( token != NULL ) {
 842       if( !UDFScanDir( device, File, token, &partition, &ICB,
 843                        cache_file_info))
 844         return 0;
 845       if( !UDFMapICB( device, ICB, &filetype, &partition, &File ) )
 846         return 0;
 847       if(!strcmp(token, "VIDEO_TS"))
 848         cache_file_info = 1;
 849       token = strtok( NULL, "/" );
 850     }
 851   }
 852
 853   /* Sanity check. */
 854   if( File.Partition != 0 )
 855     return 0;
 856   *filesize = File.Length;
 857   /* Hack to not return partition.Start for empty files. */
 858   if( !File.Location )
 859     return 0;
 860   else
 861     return partition.Start + File.Location;
 862 }
 863
 864
 865
 866 /**
 867  * Gets a Descriptor .
 868  * Returns 1 if descriptor found, 0 on error.
 869  * id, tagid of descriptor
 870  * bufsize, size of BlockBuf (must be >= DVD_VIDEO_LB_LEN).
 871  */
 872 static int UDFGetDescriptor( dvd_reader_t *device, int id,
 873                              uint8_t *descriptor, int bufsize)
 874 {
 875   uint32_t lbnum, MVDS_location, MVDS_length;
 876   struct avdp_t avdp;
 877   uint16_t TagID;
 878   uint32_t lastsector;
 879   int i, terminate;
 880   int desc_found = 0;
 881   /* Find Anchor */
 882   lastsector = 0;
 883   lbnum = 256;   /* Try #1, prime anchor */
 884   terminate = 0;
 885   if(bufsize < DVD_VIDEO_LB_LEN)
 886     return 0;
 887
 888   if(!UDFGetAVDP(device, &avdp))
 889     return 0;
 890
 891   /* Main volume descriptor */
 892   MVDS_location = avdp.mvds.location;
 893   MVDS_length = avdp.mvds.length;
 894
 895   i = 1;
 896   do {
 897     /* Find  Descriptor */
 898     lbnum = MVDS_location;
 899     do {
 900       if( DVDReadLBUDF( device, lbnum++, 1, descriptor, 0 ) <= 0 )
 901         TagID = 0;
 902       else
 903         UDFDescriptor( descriptor, &TagID );
 904       if( (TagID == id) && ( !desc_found ) )
 905         /* Descriptor */
 906         desc_found = 1;
 907     } while( ( lbnum <= MVDS_location + ( MVDS_length - 1 )
 908                / DVD_VIDEO_LB_LEN ) && ( TagID != 8 )
 909              && ( !desc_found) );
 910
 911     if( !desc_found ) {
 912       /* Backup volume descriptor */
 913       MVDS_location = avdp.rvds.location;
 914       MVDS_length = avdp.rvds.length;
 915     }
 916   } while( i-- && ( !desc_found )  );
 917
 918   return desc_found;
 919 }
 920
 921
 922 static int UDFGetPVD(dvd_reader_t *device, struct pvd_t *pvd)
 923 {
 924   uint8_t pvd_buf_base[DVD_VIDEO_LB_LEN + 2048];
 925   uint8_t *pvd_buf = (uint8_t *)(((uintptr_t)pvd_buf_base & ~((uintptr_t)2047)) + 2048);
 926   if(GetUDFCache(device, PVDCache, 0, pvd))
 927     return 1;
 928
 929   if(!UDFGetDescriptor( device, 1, pvd_buf, sizeof(pvd_buf)))
 930     return 0;
 931
 932   memcpy(pvd->VolumeIdentifier, &pvd_buf[24], 32);
 933   memcpy(pvd->VolumeSetIdentifier, &pvd_buf[72], 128);
 934   SetUDFCache(device, PVDCache, 0, pvd);
 935   return 1;
 936 }
 937
 938 /**
 939  * Gets the Volume Identifier string, in 8bit unicode (latin-1)
 940  * volid, place to put the string
 941  * volid_size, size of the buffer volid points to
 942  * returns the size of buffer needed for all data
 943  */
 944 int UDFGetVolumeIdentifier(dvd_reader_t *device, char *volid,
 945                            unsigned int volid_size)
 946 {
 947   struct pvd_t pvd;
 948   unsigned int volid_len;
 949
 950   /* get primary volume descriptor */
 951   if(!UDFGetPVD(device, &pvd))
 952     return 0;
 953
 954   volid_len = pvd.VolumeIdentifier[31];
 955   if(volid_len > 31)
 956     /* this field is only 32 bytes something is wrong */
 957     volid_len = 31;
 958   if(volid_size > volid_len)
 959     volid_size = volid_len;
 960   Unicodedecode(pvd.VolumeIdentifier, volid_size, volid);
 961
 962   return volid_len;
 963 }
 964
 965 /**
 966  * Gets the Volume Set Identifier, as a 128-byte dstring (not decoded)
 967  * WARNING This is not a null terminated string
 968  * volsetid, place to put the data
 969  * volsetid_size, size of the buffer volsetid points to
 970  * the buffer should be >=128 bytes to store the whole volumesetidentifier
 971  * returns the size of the available volsetid information (128)
 972  * or 0 on error
 973  */
 974 int UDFGetVolumeSetIdentifier(dvd_reader_t *device, uint8_t *volsetid,
 975                               unsigned int volsetid_size)
 976 {
 977   struct pvd_t pvd;
 978
 979   /* get primary volume descriptor */
 980   if(!UDFGetPVD(device, &pvd))
 981     return 0;
 982
 983
 984   if(volsetid_size > 128)
 985     volsetid_size = 128;
 986
 987   memcpy(volsetid, pvd.VolumeSetIdentifier, volsetid_size);
 988
 989   return 128;
 990 }