/*

  Copyright (C) 2004-2006, 2008, 2012-2013, 2017 Rocky Bernstein <rocky@gnu.org>

  This program 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 3 of the License, or

  (at your option) any later version.

  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/* Program to read ISO-9660 images. */

#include "util.h"

#include "portable.h"

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#include <cdio/cdio.h>

#include <cdio/iso9660.h>

#include <cdio/udf.h>

#ifdef HAVE_STDIO_H

#include <stdio.h>

#endif

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include "getopt.h"

#define CEILING(x, y) ((x+(y-1))/y)

/* Used by `main' to communicate with `parse_opt'. And global options

 */

static struct arguments

{

  char          *file_name;

  char          *output_file;

  char          *iso9660_image;

  int            debug_level;

  int            no_header;

  int            ignore;

  int            udf;

} opts;

/* Parse a options. */

static bool

parse_options (int argc, char *argv[])

{

  int opt;

  int rc = EXIT_FAILURE;

  /* Configuration option codes */

  enum {

    OP_HANDLED = 0,

    OP_VERSION=1,

    OP_USAGE

  };

  static const char helpText[] =

    "Usage: %s [OPTION...]\n"

    "  -d, --debug=INT            Set debugging to LEVEL.\n"

    "  -i, --image=FILE           Read from ISO-9660 image. This option is mandatory\n"

    "  -e, --extract=FILE         Extract FILE from ISO-9660 image. This option is\n"

    "                             mandatory.\n"

    "  -k, --ignore               Ignore read error(s), i.e. keep going\n"

    "  --no-header                Don't display header and copyright (for\n"

    "                             regression testing)\n"

    "  -o, --output-file=FILE     Output file. This option is mandatory.\n"

    "  -U  --udf                  Contents are in UDF format\n"

    "  -V, --version              display version and copyright information and exit\n"

    "\n"

    "Help options:\n"

    "  -?, --help                 Show this help message\n"

    "  --usage                    Display brief usage message\n";

  static const char usageText[] =

    "Usage: %s [-d|--debug INT] [-i|--image FILE] [-e|--extract FILE]\n"

    "        [--no-header] [-o|--output-file FILE]  [-U|--udf]\n"

    "        [-V|--version] [-?|--help] [--usage]\n";

  /* Command-line options */

  static const char* optionsString = "d:i:e:o:VUk?";

  static const struct option optionsTable[] = {

    {"debug",       required_argument, NULL,   'd' },

    {"image",       required_argument, NULL,   'i' },

    {"extract",     required_argument, NULL,   'e' },

    {"no-header",   no_argument, &opts.no_header, 1 },

    {"ignore",      no_argument, &opts.ignore, 'k' },

    {"output-file", required_argument, NULL,   'o' },

    {"udf",         no_argument, &opts.udf,    'U' },

    {"version",     no_argument, NULL,         'V' },

    {"help", no_argument, NULL, '?' },

    {"usage", no_argument, NULL, OP_USAGE },

    { NULL, 0, NULL, 0 }

  };

  program_name = strrchr(argv[0],'/');

  program_name = program_name ? strdup(program_name+1) : strdup(argv[0]);

  while ((opt = getopt_long(argc, argv, optionsString, optionsTable, NULL)) != -1)

    switch (opt)

      {

      case 'd': opts.debug_level = atoi(optarg); break;

      case 'i': opts.iso9660_image = strdup(optarg); break;

      case 'k': opts.ignore        = 1; break;

      case 'e': opts.file_name = strdup(optarg); break;

      case 'o': opts.output_file = strdup(optarg); break;

      case 'U': opts.udf = 1; break;

      case 'V':

        print_version(program_name, CDIO_VERSION, 0, true);

	rc = EXIT_SUCCESS;

	goto error_exit;

      case '?':

        fprintf(stdout, helpText, program_name);

	rc = EXIT_INFO;

	goto error_exit;

      case OP_USAGE:

        fprintf(stderr, usageText, program_name);

	rc = EXIT_INFO;

	goto error_exit;

      case OP_HANDLED:

        break;

      }

  if (optind < argc) {

    const char *remaining_arg = argv[optind++];

    if (opts.iso9660_image != NULL) {

      report( stderr, "%s: Source specified as --image %s and as %s\n",

              program_name, opts.iso9660_image, remaining_arg );

      goto error_exit;

    }

    opts.iso9660_image = strdup(remaining_arg);

    if (optind < argc ) {

      report( stderr,

              "%s: use only one unnamed argument for the ISO 9660 "

              "image name\n",

              program_name );

      goto error_exit;

    }

  }

  if (NULL == opts.iso9660_image) {

    report( stderr, "%s: you need to specify an ISO-9660 image name.\n",

            program_name );

    report( stderr, "%s: Use option --image or try --help.\n",

            program_name );

    goto error_exit;

  }

  if (NULL == opts.file_name) {

    report( stderr, "%s: you need to specify a filename to extract.\n",

            program_name );

    report( stderr, "%s: Use option --extract or try --help.\n",

            program_name );

    goto error_exit;

  }

  if (NULL == opts.output_file) {

    report( stderr,

            "%s: you need to specify a place write filename extraction to.\n",

             program_name );

    report( stderr, "%s: Use option --output-file or try --help.\n",

            program_name );

    goto error_exit;

  }

  return true;

 error_exit:

  free(program_name);

  exit(rc);

}

static void

init(void)

{

  opts.debug_level   = 0;

  opts.ignore        = 0;

  opts.file_name     = NULL;

  opts.output_file   = NULL;

  opts.iso9660_image = NULL;

}

static int read_iso_file(const char *iso_name, const char *src,

                         FILE *outfd, size_t *bytes_written)

{

  iso9660_stat_t *statbuf;

  int i;

  iso9660_t *iso;

  iso = iso9660_open (iso_name);

  if (NULL == iso) {

    report(stderr,

           "%s: Sorry, couldn't open ISO-9660 image file '%s'.\n",

           program_name, src);

    return 1;

  }

  statbuf = iso9660_ifs_stat_translate (iso, src);

  if (NULL == statbuf)

    {

      report(stderr,

             "%s: Could not get ISO-9660 file information out of %s"

             " for file %s.\n",

             program_name, iso_name, src);

      report(stderr,

             "%s: iso-info may be able to show the contents of %s.\n",

             program_name, iso_name);

      return 2;

    }

  /* Copy the blocks from the ISO-9660 filesystem to the local filesystem. */

  for (i = 0; i < statbuf->size; i += ISO_BLOCKSIZE)

    {

      char buf[ISO_BLOCKSIZE];

      memset (buf, 0, ISO_BLOCKSIZE);

      if ( ISO_BLOCKSIZE != iso9660_iso_seek_read (iso, buf, statbuf->lsn

                                                   + (i / ISO_BLOCKSIZE),

                                                   1) )

      {

        report(stderr, "Error reading ISO 9660 file at lsn %lu\n",

               (long unsigned int) statbuf->lsn + (i / ISO_BLOCKSIZE));

        if (!opts.ignore) return 4;

      }

      fwrite (buf, ISO_BLOCKSIZE, 1, outfd);

      if (ferror (outfd))

        {

          perror ("fwrite()");

          return 5;

        }

    }

  iso9660_close(iso);

  *bytes_written = statbuf->size;

  return 0;

}

static int read_udf_file(const char *iso_name, const char *src,

                         FILE *outfd, size_t *bytes_written)

{

  udf_t *p_udf;

  p_udf = udf_open (iso_name);

  if (NULL == p_udf) {

    fprintf(stderr, "Sorry, couldn't open %s as something using UDF\n",

            iso_name);

    return 1;

  } else {

    udf_dirent_t *p_udf_root = udf_get_root(p_udf, true, 0);

    udf_dirent_t *p_udf_file = NULL;

    if (NULL == p_udf_root) {

      fprintf(stderr, "Sorry, couldn't find / in %s\n",

              iso_name);

      return 1;

    }

    p_udf_file = udf_fopen(p_udf_root, src);

    if (!p_udf_file) {

      fprintf(stderr, "Sorry, couldn't find %s in %s\n",

              src, iso_name);

      udf_dirent_free(p_udf_root);

      return 2;

    }

    {

      uint64_t i_file_length = udf_get_file_length(p_udf_file);

      const unsigned int i_blocks = (unsigned int) CEILING(i_file_length, UDF_BLOCKSIZE);

      unsigned int i;

      for (i = 0; i < i_blocks ; i++) {

        char buf[UDF_BLOCKSIZE] = {'\0',};

        ssize_t i_read = udf_read_block(p_udf_file, buf, 1);

        if ( i_read < 0 ) {

          fprintf(stderr, "Error reading UDF file %s at block %u\n",

                  src, i);

	  free(p_udf_file);

	  udf_dirent_free(p_udf_root);

          return 4;

        }

        fwrite (buf, i_read, 1, outfd);

        if (ferror (outfd)) {

          perror ("fwrite()");

	  free(p_udf_file);

	  udf_dirent_free(p_udf_root);

          return 5;

        }

      }

      free(p_udf_file);

      udf_dirent_free(p_udf_root);

      udf_close(p_udf);

      *bytes_written = i_file_length;

    }

  }

  return 0;

}

int

main(int argc, char *argv[])

{

  FILE *outfd;

  int ret;

  size_t bytes_written = 0;

  init();

  /* Parse our arguments; every option seen by `parse_opt' will

     be reflected in `arguments'. */

  if (!parse_options(argc, argv)) {

    report(stderr,

           "error while parsing command line - try --help\n");

    return 2;

  }

  if (!(outfd = fopen (opts.output_file, "wb")))

    {

      report(stderr,

             "%s: Could not open %s for writing: %s\n",

             program_name, opts.output_file, strerror(errno));

      return 3;

    }

  if (opts.udf) {

      ret = read_udf_file (opts.iso9660_image, opts.file_name,

			   outfd, &bytes_written);

  } else  {

      ret = read_iso_file (opts.iso9660_image, opts.file_name,

                           outfd, &bytes_written);

  }

  if (ret != 0) return ret;

  fflush (outfd);

  /* Make sure the file size has the exact same byte size. Without the

     truncate below, the file will a multiple of ISO_BLOCKSIZE.

   */

  if (ftruncate (fileno (outfd), bytes_written))

    perror ("ftruncate()");

  fclose (outfd);

  return 0;

}