/*

 * Copyright (C) 2001-2004 Billy Biggs <vektor@dumbterm.net>,

 *                         Håkan Hjort <d95hjort@dtek.chalmers.se>,

 *                         Björn Englund <d4bjorn@dtek.chalmers.se>

 *

 * This file is part of libdvdread.

 *

 * libdvdread is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * libdvdread is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along

 * with libdvdread; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#include "config.h"

#include <sys/types.h>      /* off_t */

#include <sys/stat.h>       /* stat */

#include <sys/time.h>       /* For the timing of dvdcss_title crack. */

#include <fcntl.h>          /* open */

#include <stdlib.h>         /* free */

#include <stdio.h>          /* fprintf */

#include <errno.h>          /* errno, EIN* */

#include <string.h>         /* memcpy, strlen */

#include <unistd.h>         /* chdir, getcwd */

#include <limits.h>         /* PATH_MAX */

#include <dirent.h>         /* opendir, readdir */

#include <ctype.h>          /* isalpha */

/* misc win32 helpers */

#ifdef WIN32

# ifndef HAVE_GETTIMEOFDAY

   /* replacement gettimeofday implementation */

#  include <sys/timeb.h>

static inline int _private_gettimeofday( struct timeval *tv, void *tz )

{

  struct timeb t;

  ftime( &t );

  tv->tv_sec = t.time;

  tv->tv_usec = t.millitm * 1000;

  return 0;

}

#  define gettimeofday(TV, TZ) _private_gettimeofday((TV), (TZ))

# endif

# include <io.h> /* read() */

# define lseek64 _lseeki64

#endif

#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__bsdi__) || defined(__APPLE__)

# define SYS_BSD 1

#endif

#if defined(__sun)

# include <sys/mnttab.h>

#elif defined(__APPLE__)

# include <sys/param.h>

# include <sys/ucred.h>

# include <sys/mount.h>

#elif defined(SYS_BSD)

# include <fstab.h>

#elif defined(__linux__)

# include <mntent.h>

# include <paths.h>

#endif

#include "dvdread/dvd_udf.h"

#include "dvdread/dvd_reader.h"

#include "dvd_input.h"

#include "dvdread_internal.h"

#include "md5.h"

#include "dvdread/ifo_read.h"

#define DEFAULT_UDF_CACHE_LEVEL 1

struct dvd_reader_s {

  /* Basic information. */

  int isImageFile;

  /* Hack for keeping track of the css status.

   * 0: no css, 1: perhaps (need init of keys), 2: have done init */

  int css_state;

  int css_title; /* Last title that we have called dvdinpute_title for. */

  /* Information required for an image file. */

  dvd_input_t dev;

  /* Information required for a directory path drive. */

  char *path_root;

  /* Filesystem cache */

  int udfcache_level; /* 0 - turned off, 1 - on */

  void *udfcache;

};

#define TITLES_MAX 9

struct dvd_file_s {

  /* Basic information. */

  dvd_reader_t *dvd;

  /* Hack for selecting the right css title. */

  int css_title;

  /* Information required for an image file. */

  uint32_t lb_start;

  uint32_t seek_pos;

  /* Information required for a directory path drive. */

  size_t title_sizes[ TITLES_MAX ];

  dvd_input_t title_devs[ TITLES_MAX ];

  /* Calculated at open-time, size in blocks. */

  ssize_t filesize;

  /* Cache of the dvd_file. If not NULL, the cache corresponds to the whole

   * dvd_file. Used only for IFO and BUP. */

  unsigned char *cache;

};

int InternalUDFReadBlocksRaw( const dvd_reader_t *device, uint32_t lb_number,

                      size_t block_count, unsigned char *data,

                      int encrypted );

/**

 * Set the level of caching on udf

 * level = 0 (no caching)

 * level = 1 (caching filesystem info)

 */

int DVDUDFCacheLevel(dvd_reader_t *device, int level)

{

  struct dvd_reader_s *dev = (struct dvd_reader_s *)device;

  if(level > 0) {

    level = 1;

  } else if(level < 0) {

    return dev->udfcache_level;

  }

  dev->udfcache_level = level;

  return level;

}

void *GetUDFCacheHandle(dvd_reader_t *device)

{

  struct dvd_reader_s *dev = (struct dvd_reader_s *)device;

  return dev->udfcache;

}

void SetUDFCacheHandle(dvd_reader_t *device, void *cache)

{

  struct dvd_reader_s *dev = (struct dvd_reader_s *)device;

  dev->udfcache = cache;

}

/* Loop over all titles and call dvdcss_title to crack the keys. */

static int initAllCSSKeys( dvd_reader_t *dvd )

{

  struct timeval all_s, all_e;

  struct timeval t_s, t_e;

  char filename[ MAX_UDF_FILE_NAME_LEN ];

  uint32_t start, len;

  int title;

  char *nokeys_str = getenv("DVDREAD_NOKEYS");

  if(nokeys_str != NULL)

    return 0;

  fprintf( stderr, "\n" );

  fprintf( stderr, "libdvdread: Attempting to retrieve all CSS keys\n" );

  fprintf( stderr, "libdvdread: This can take a _long_ time, "

           "please be patient\n\n" );

  gettimeofday(&all_s, NULL);

  for( title = 0; title < 100; title++ ) {

    gettimeofday( &t_s, NULL );

    if( title == 0 ) {

      sprintf( filename, "/VIDEO_TS/VIDEO_TS.VOB" );

    } else {

      sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, 0 );

    }

    start = UDFFindFile( dvd, filename, &len );

    if( start != 0 && len != 0 ) {

      /* Perform CSS key cracking for this title. */

      fprintf( stderr, "libdvdread: Get key for %s at 0x%08x\n",

               filename, start );

      if( dvdinput_title( dvd->dev, (int)start ) < 0 ) {

        fprintf( stderr, "libdvdread: Error cracking CSS key for %s (0x%08x)\n", filename, start);

      }

      gettimeofday( &t_e, NULL );

      fprintf( stderr, "libdvdread: Elapsed time %ld\n",

               (long int) t_e.tv_sec - t_s.tv_sec );

    }

    if( title == 0 ) continue;

    gettimeofday( &t_s, NULL );

    sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, 1 );

    start = UDFFindFile( dvd, filename, &len );

    if( start == 0 || len == 0 ) break;

    /* Perform CSS key cracking for this title. */

    fprintf( stderr, "libdvdread: Get key for %s at 0x%08x\n",

             filename, start );

    if( dvdinput_title( dvd->dev, (int)start ) < 0 ) {

      fprintf( stderr, "libdvdread: Error cracking CSS key for %s (0x%08x)!!\n", filename, start);

    }

    gettimeofday( &t_e, NULL );

    fprintf( stderr, "libdvdread: Elapsed time %ld\n",

             (long int) t_e.tv_sec - t_s.tv_sec );

  }

  title--;

  fprintf( stderr, "libdvdread: Found %d VTS's\n", title );

  gettimeofday(&all_e, NULL);

  fprintf( stderr, "libdvdread: Elapsed time %ld\n",

           (long int) all_e.tv_sec - all_s.tv_sec );

  return 0;

}

/**

 * Open a DVD image or block device file or use stream_cb functions.

 */

static dvd_reader_t *DVDOpenImageFile( const char *location,

                                       void *stream,

                                       dvd_reader_stream_cb *stream_cb,

                                       int have_css )

{

  dvd_reader_t *dvd;

  dvd_input_t dev;

  dev = dvdinput_open( location, stream, stream_cb );

  if( !dev ) {

    fprintf( stderr, "libdvdread: Can't open %s for reading\n", location );

    return NULL;

  }

  dvd = malloc( sizeof( dvd_reader_t ) );

  if( !dvd ) {

    dvdinput_close(dev);

    return NULL;

  }

  memset( dvd, 0, sizeof( dvd_reader_t ) );

  dvd->isImageFile = 1;

  dvd->dev = dev;

  dvd->path_root = NULL;

  dvd->udfcache_level = DEFAULT_UDF_CACHE_LEVEL;

  dvd->udfcache = NULL;

  if( have_css ) {

    /* Only if DVDCSS_METHOD = title, a bit if it's disc or if

     * DVDCSS_METHOD = key but region mismatch. Unfortunately we

     * don't have that information. */

    dvd->css_state = 1; /* Need key init. */

  }

  dvd->css_title = 0;

  return dvd;

}

static dvd_reader_t *DVDOpenPath( const char *path_root )

{

  dvd_reader_t *dvd;

  dvd = malloc( sizeof( dvd_reader_t ) );

  if( !dvd ) return NULL;

  dvd->isImageFile = 0;

  dvd->dev = 0;

  dvd->path_root = strdup( path_root );

  if(!dvd->path_root) {

    free(dvd);

    return NULL;

  }

  dvd->udfcache_level = DEFAULT_UDF_CACHE_LEVEL;

  dvd->udfcache = NULL;

  dvd->css_state = 0; /* Only used in the UDF path */

  dvd->css_title = 0; /* Only matters in the UDF path */

  return dvd;

}

#if defined(__sun)

/* /dev/rdsk/c0t6d0s0 (link to /devices/...)

   /vol/dev/rdsk/c0t6d0/??

   /vol/rdsk/<name> */

static char *sun_block2char( const char *path )

{

  char *new_path;

  /* Must contain "/dsk/" */

  if( !strstr( path, "/dsk/" ) ) return (char *) strdup( path );

  /* Replace "/dsk/" with "/rdsk/" */

  new_path = malloc( strlen(path) + 2 );

  if(!new_path) return NULL;

  strcpy( new_path, path );

  strcpy( strstr( new_path, "/dsk/" ), "" );

  strcat( new_path, "/rdsk/" );

  strcat( new_path, strstr( path, "/dsk/" ) + strlen( "/dsk/" ) );

  return new_path;

}

#endif

#if defined(SYS_BSD)

/* FreeBSD /dev/(r)(a)cd0c (a is for atapi), recommended to _not_ use r

   update: FreeBSD and DragonFly no longer uses the prefix so don't add it.

   OpenBSD /dev/rcd0c, it needs to be the raw device

   NetBSD  /dev/rcd0[d|c|..] d for x86, c (for non x86), perhaps others

   Darwin  /dev/rdisk0,  it needs to be the raw device

   BSD/OS  /dev/sr0c (if not mounted) or /dev/rsr0c ('c' any letter will do)

   returns a string allocated with strdup. It should be freed when no longer

   used. */

static char *bsd_block2char( const char *path )

{

#if defined(__FreeBSD__) || defined(__DragonFly__)

  return (char *) strdup( path );

#else

  char *new_path;

  /* If it doesn't start with "/dev/" or does start with "/dev/r" exit */

  if( strncmp( path, "/dev/",  5 ) || !strncmp( path, "/dev/r", 6 ) )

    return (char *) strdup( path );

  /* Replace "/dev/" with "/dev/r" */

  new_path = malloc( strlen(path) + 2 );

  if(!new_path) return NULL;

  strcpy( new_path, "/dev/r" );

  strcat( new_path, path + strlen( "/dev/" ) );

  return new_path;

#endif /* __FreeBSD__ || __DragonFly__ */

}

#endif

static dvd_reader_t *DVDOpenCommon( const char *ppath,

                                    void *stream,

                                    dvd_reader_stream_cb *stream_cb )

{

  struct stat fileinfo;

  int ret, have_css, retval, cdir = -1;

  dvd_reader_t *ret_val = NULL;

  char *dev_name = NULL;

  char *path = NULL, *new_path = NULL, *path_copy = NULL;

#if defined(_WIN32) || defined(__OS2__)

      int len;

#endif

  /* Try to open DVD using stream_cb functions */

  if( stream != NULL && stream_cb != NULL )

  {

    have_css = dvdinput_setup();

    return DVDOpenImageFile( NULL, stream, stream_cb, have_css );

  }

  if( ppath == NULL )

    goto DVDOpen_error;

      path = strdup(ppath);

  if( path == NULL )

    goto DVDOpen_error;

  /* Try to open libdvdcss or fall back to standard functions */

  have_css = dvdinput_setup();

#if defined(_WIN32) || defined(__OS2__)

  /* Strip off the trailing \ if it is not a drive */

  len = strlen(path);

  if ((len > 1) &&

      (path[len - 1] == '\\')  &&

      (path[len - 2] != ':'))

  {

    path[len-1] = '\0';

  }

#endif

  ret = stat( path, &fileinfo );

  if( ret < 0 ) {

    /* maybe "host:port" url? try opening it with acCeSS library */

    if( strchr(path,':') ) {

                    ret_val = DVDOpenImageFile( path, NULL, NULL, have_css );

                    free(path);

            return ret_val;

    }

    /* If we can't stat the file, give up */

    fprintf( stderr, "libdvdread: Can't stat %s\n", path );

    perror("");

    goto DVDOpen_error;

  }

  /* First check if this is a block/char device or a file*/

  if( S_ISBLK( fileinfo.st_mode ) ||

      S_ISCHR( fileinfo.st_mode ) ||

      S_ISREG( fileinfo.st_mode ) ) {

    /**

     * Block devices and regular files are assumed to be DVD-Video images.

     */

    dvd_reader_t *dvd = NULL;

#if defined(__sun)

    dev_name = sun_block2char( path );

#elif defined(SYS_BSD)

    dev_name = bsd_block2char( path );

#else

    dev_name = strdup( path );

#endif

    if(!dev_name)

        goto DVDOpen_error;

    dvd = DVDOpenImageFile( dev_name, NULL, NULL, have_css );

    free( dev_name );

    free(path);

    return dvd;

  } else if( S_ISDIR( fileinfo.st_mode ) ) {

    dvd_reader_t *auth_drive = 0;

#if defined(SYS_BSD)

    struct fstab* fe;

#elif defined(__sun) || defined(__linux__)

    FILE *mntfile;

#endif

    /* XXX: We should scream real loud here. */

    if( !(path_copy = strdup( path ) ) )

      goto DVDOpen_error;

#ifndef WIN32 /* don't have fchdir, and getcwd( NULL, ... ) is strange */

              /* Also WIN32 does not have symlinks, so we don't need this bit of code. */

    /* Resolve any symlinks and get the absolute dir name. */

    {

      if( ( cdir  = open( ".", O_RDONLY ) ) >= 0 ) {

        if( chdir( path_copy ) == -1 ) {

          goto DVDOpen_error;

        }

        new_path = malloc(PATH_MAX+1);

        if(!new_path) {

          goto DVDOpen_error;

        }

        if( getcwd( new_path, PATH_MAX ) == NULL ) {

          goto DVDOpen_error;

        }

        retval = fchdir( cdir );

        close( cdir );

        cdir = -1;

        if( retval == -1 ) {

          goto DVDOpen_error;

        }

        free(path_copy);

        path_copy = new_path;

        new_path = NULL;

      }

    }

#endif

    /**

     * If we're being asked to open a directory, check if that directory

     * is the mount point for a DVD-ROM which we can use instead.

     */

    if( strlen( path_copy ) > 1 ) {

      if( path_copy[ strlen( path_copy ) - 1 ] == '/' ) {

        path_copy[ strlen( path_copy ) - 1 ] = '\0';

      }

    }

#if defined(_WIN32) || defined(__OS2__)

    if(strlen(path_copy) > TITLES_MAX) {

      if(!strcasecmp(&(path_copy[strlen( path_copy ) - TITLES_MAX]),

                       "\\video_ts"))

        path_copy[strlen(path_copy) - (TITLES_MAX-1)] = '\0';

    }

#endif

    if( strlen( path_copy ) > TITLES_MAX ) {

      if( !strcasecmp( &(path_copy[ strlen( path_copy ) - TITLES_MAX ]),

                       "/video_ts" ) ) {

        path_copy[ strlen( path_copy ) - TITLES_MAX ] = '\0';

      }

    }

    if(path_copy[0] == '\0') {

      path_copy[0] = '/';

      path_copy[1] = '\0';

    }

#if defined(__APPLE__)

    struct statfs s[128];

    int r = getfsstat(NULL, 0, MNT_NOWAIT);

    if (r > 0) {

        if (r > 128)

            r = 128;

        r = getfsstat(s, r * sizeof(s[0]), MNT_NOWAIT);

        int i;

        for (i=0; i

            if (!strcmp(path_copy, s[i].f_mntonname)) {

                dev_name = bsd_block2char(s[i].f_mntfromname);

                fprintf( stderr,

                        "libdvdread: Attempting to use device %s"

                        " mounted on %s for CSS authentication\n",

                        dev_name,

                        s[i].f_mntonname);

                auth_drive = DVDOpenImageFile( dev_name, NULL, NULL, have_css );

                break;

            }

        }

    }

#elif defined(SYS_BSD)

    if( ( fe = getfsfile( path_copy ) ) ) {

      dev_name = bsd_block2char( fe->fs_spec );

      fprintf( stderr,

               "libdvdread: Attempting to use device %s"

               " mounted on %s for CSS authentication\n",

               dev_name,

               fe->fs_file );

      auth_drive = DVDOpenImageFile( dev_name, NULL, NULL, have_css );

    }

#elif defined(__sun)

    mntfile = fopen( MNTTAB, "r" );

    if( mntfile ) {

      struct mnttab mp;

      int res;

      while( ( res = getmntent( mntfile, &mp ) ) != -1 ) {

        if( res == 0 && !strcmp( mp.mnt_mountp, path_copy ) ) {

          dev_name = sun_block2char( mp.mnt_special );

          fprintf( stderr,

                   "libdvdread: Attempting to use device %s"

                   " mounted on %s for CSS authentication\n",

                   dev_name,

                   mp.mnt_mountp );

          auth_drive = DVDOpenImageFile( dev_name, NULL, NULL, have_css );

          break;

        }

      }

      fclose( mntfile );

    }

#elif defined(__linux__)

    mntfile = fopen( _PATH_MOUNTED, "r" );

    if( mntfile ) {

      struct mntent *me;

      while( ( me = getmntent( mntfile ) ) ) {

        if( !strcmp( me->mnt_dir, path_copy ) ) {

          fprintf( stderr,

                   "libdvdread: Attempting to use device %s"

                   " mounted on %s for CSS authentication\n",

                   me->mnt_fsname,

                   me->mnt_dir );

          auth_drive = DVDOpenImageFile( me->mnt_fsname, NULL, NULL, have_css );

          dev_name = strdup(me->mnt_fsname);

          break;

        }

      }

      fclose( mntfile );

    }

#elif defined(_WIN32) || defined(__OS2__)

#ifdef __OS2__

    /* Use DVDOpenImageFile() only if it is a drive */

    if(isalpha(path[0]) && path[1] == ':' &&

        ( !path[2] ||

          ((path[2] == '\\' || path[2] == '/') && !path[3])))

#endif

    auth_drive = DVDOpenImageFile( path, NULL, NULL, have_css );

#endif

#if !defined(_WIN32) && !defined(__OS2__)

    if( !dev_name ) {

      fprintf( stderr, "libdvdread: Couldn't find device name.\n" );

    } else if( !auth_drive ) {

      fprintf( stderr, "libdvdread: Device %s inaccessible, "

               "CSS authentication not available.\n", dev_name );

    }

#else

    if( !auth_drive ) {

        fprintf( stderr, "libdvdread: Device %s inaccessible, "

                 "CSS authentication not available.\n", path );

    }

#endif

    free( dev_name );

    dev_name = NULL;

    free( path_copy );

    path_copy = NULL;

    /**

     * If we've opened a drive, just use that.

     */

    if( auth_drive ) {

      free(path);

      return auth_drive;

    }

    /**

     * Otherwise, we now try to open the directory tree instead.

     */

    ret_val = DVDOpenPath( path );

      free( path );

      return ret_val;

  }

DVDOpen_error:

  /* If it's none of the above, screw it. */

  fprintf( stderr, "libdvdread: Could not open %s\n", path );

  free( path );

  free( path_copy );

  if ( cdir >= 0 )

    close( cdir );

  free( new_path );

  return NULL;

}

dvd_reader_t *DVDOpen( const char *ppath )

{

    return DVDOpenCommon( ppath, NULL, NULL );

}

dvd_reader_t *DVDOpenStream( void *stream,

                             dvd_reader_stream_cb *stream_cb )

{

    return DVDOpenCommon( NULL, stream, stream_cb );

}

void DVDClose( dvd_reader_t *dvd )

{

  if( dvd ) {

    if( dvd->dev ) dvdinput_close( dvd->dev );

    if( dvd->path_root ) free( dvd->path_root );

    if( dvd->udfcache ) FreeUDFCache( dvd->udfcache );

    free( dvd );

  }

}

/**

 * Open an unencrypted file on a DVD image file.

 */

static dvd_file_t *DVDOpenFileUDF( dvd_reader_t *dvd, char *filename,

                                   int do_cache )

{

  uint32_t start, len;

  dvd_file_t *dvd_file;

  start = UDFFindFile( dvd, filename, &len );

  if( !start ) {

    fprintf( stderr, "libdvdread:DVDOpenFileUDF:UDFFindFile %s failed\n", filename );

    return NULL;

  }

  dvd_file = malloc( sizeof( dvd_file_t ) );

  if( !dvd_file ) {

    fprintf( stderr, "libdvdread:DVDOpenFileUDF:malloc failed\n" );

    return NULL;

  }

  dvd_file->dvd = dvd;

  dvd_file->lb_start = start;

  dvd_file->seek_pos = 0;

  memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );

  memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );

  dvd_file->filesize = len / DVD_VIDEO_LB_LEN;

  dvd_file->cache = NULL;

  /* Read the whole file in cache (unencrypted) if asked and if it doesn't

   * exceed 128KB */

  if( do_cache && len < 64 * DVD_VIDEO_LB_LEN ) {

    int ret;

    dvd_file->cache = malloc( len );

    if( !dvd_file->cache )

        return dvd_file;

    ret = InternalUDFReadBlocksRaw( dvd, dvd_file->lb_start,

                                    dvd_file->filesize, dvd_file->cache,

                                    DVDINPUT_NOFLAGS );

    if( ret != dvd_file->filesize ) {

        free( dvd_file->cache );

        dvd_file->cache = NULL;

    }

  }

  return dvd_file;

}

/**

 * Searches for <file> in directory <path>, ignoring case.

 * Returns 0 and full filename in <filename>.

 *     or -1 on file not found.

 *     or -2 on path not found.

 */

static int findDirFile( const char *path, const char *file, char *filename )

{

  DIR *dir;

  struct dirent *ent;

  dir = opendir( path );

  if( !dir ) return -2;

  while( ( ent = readdir( dir ) ) != NULL ) {

    if( !strcasecmp( ent->d_name, file ) ) {

      sprintf( filename, "%s%s%s", path,

               ( ( path[ strlen( path ) - 1 ] == '/' ) ? "" : "/" ),

               ent->d_name );

      closedir(dir);

      return 0;

    }

  }

  closedir(dir);

  return -1;

}

static int findDVDFile( dvd_reader_t *dvd, const char *file, char *filename )

{

  const char *nodirfile;

  int ret;

  /* Strip off the directory for our search */

  if( !strncasecmp( "/VIDEO_TS/", file, 10 ) ) {

    nodirfile = &(file[ 10 ]);

  } else {

    nodirfile = file;

  }

  ret = findDirFile( dvd->path_root, nodirfile, filename );

  if( ret < 0 ) {

    char video_path[ PATH_MAX + 1 ];

    /* Try also with adding the path, just in case. */

    sprintf( video_path, "%s/VIDEO_TS/", dvd->path_root );

    ret = findDirFile( video_path, nodirfile, filename );

    if( ret < 0 ) {

      /* Try with the path, but in lower case. */

      sprintf( video_path, "%s/video_ts/", dvd->path_root );

      ret = findDirFile( video_path, nodirfile, filename );

      if( ret < 0 ) {

        return 0;

      }

    }

  }

  return 1;

}

/**

 * Open an unencrypted file from a DVD directory tree.

 */

static dvd_file_t *DVDOpenFilePath( dvd_reader_t *dvd, char *filename )

{

  char full_path[ PATH_MAX + 1 ];

  dvd_file_t *dvd_file;

  struct stat fileinfo;

  dvd_input_t dev;

  /* Get the full path of the file. */

  if( !findDVDFile( dvd, filename, full_path ) ) {

    fprintf( stderr, "libdvdread:DVDOpenFilePath:findDVDFile %s failed\n", filename );

    return NULL;

  }

  dev = dvdinput_open( full_path, NULL, NULL );

  if( !dev ) {

    fprintf( stderr, "libdvdread:DVDOpenFilePath:dvdinput_open %s failed\n", full_path );

    return NULL;

  }

  dvd_file = malloc( sizeof( dvd_file_t ) );

  if( !dvd_file ) {

    fprintf( stderr, "libdvdread:DVDOpenFilePath:dvd_file malloc failed\n" );

    dvdinput_close(dev);

    return NULL;

  }

  dvd_file->dvd = dvd;

  dvd_file->lb_start = 0;

  dvd_file->seek_pos = 0;

  memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );

  memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );

  dvd_file->filesize = 0;

  dvd_file->cache = NULL;

  if( stat( full_path, &fileinfo ) < 0 ) {

    fprintf( stderr, "libdvdread: Can't stat() %s.\n", filename );

    free( dvd_file );

    dvdinput_close( dev );

    return NULL;

  }

  dvd_file->title_sizes[ 0 ] = fileinfo.st_size / DVD_VIDEO_LB_LEN;

  dvd_file->title_devs[ 0 ] = dev;

  dvd_file->filesize = dvd_file->title_sizes[ 0 ];

  return dvd_file;

}

static dvd_file_t *DVDOpenVOBUDF( dvd_reader_t *dvd, int title, int menu )

{

  char filename[ MAX_UDF_FILE_NAME_LEN ];

  uint32_t start, len;

  dvd_file_t *dvd_file;

  if( title == 0 ) {

    sprintf( filename, "/VIDEO_TS/VIDEO_TS.VOB" );

  } else {

    sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, menu ? 0 : 1 );

  }

  start = UDFFindFile( dvd, filename, &len );

  if( start == 0 ) return NULL;

  dvd_file = malloc( sizeof( dvd_file_t ) );

  if( !dvd_file ) return NULL;

  dvd_file->dvd = dvd;

  /*Hack*/ dvd_file->css_title = title << 1 | menu;

  dvd_file->lb_start = start;

  dvd_file->seek_pos = 0;

  memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );

  memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );

  dvd_file->filesize = len / DVD_VIDEO_LB_LEN;

  dvd_file->cache = NULL;

  /* Calculate the complete file size for every file in the VOBS */

  if( !menu ) {

    int cur;

    for( cur = 2; cur < 10; cur++ ) {

      sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, cur );

      if( !UDFFindFile( dvd, filename, &len ) ) break;

      dvd_file->filesize += len / DVD_VIDEO_LB_LEN;

    }

  }

  if( dvd->css_state == 1 /* Need key init */ ) {

    initAllCSSKeys( dvd );

    dvd->css_state = 2;

  }

  /*

  if( dvdinput_title( dvd_file->dvd->dev, (int)start ) < 0 ) {

      fprintf( stderr, "libdvdread: Error cracking CSS key for %s\n",

               filename );

  }

  */

  return dvd_file;

}

static dvd_file_t *DVDOpenVOBPath( dvd_reader_t *dvd, int title, int menu )

{

  char filename[ MAX_UDF_FILE_NAME_LEN ];

  char full_path[ PATH_MAX + 1 ];

  struct stat fileinfo;

  dvd_file_t *dvd_file;

  dvd_file = malloc( sizeof( dvd_file_t ) );

  if( !dvd_file ) return NULL;

  dvd_file->dvd = dvd;

  /*Hack*/ dvd_file->css_title = title << 1 | menu;

  dvd_file->lb_start = 0;

  dvd_file->seek_pos = 0;

  memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );

  memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );

  dvd_file->filesize = 0;

  dvd_file->cache = NULL;

  if( menu ) {

    dvd_input_t dev;

    if( title == 0 ) {

      sprintf( filename, "VIDEO_TS.VOB" );