/*

 * This file has been modified for the cdrkit suite.

 *

 * The behaviour and appearence of the program code below can differ to a major

 * extent from the version distributed by the original author(s).

 *

 * For details, see Changelog file distributed with the cdrkit package. If you

 * received this file from another source then ask the distributing person for

 * a log of modifications.

 *

 */

/* $Id: mkzftree.c,v 1.18 2006/07/04 04:57:42 hpa Exp $ */

/* ----------------------------------------------------------------------- *

 *   

 *   Copyright 2001 H. Peter Anvin - All Rights Reserved

 *

 *   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, Inc., 675 Mass Ave, Cambridge MA 02139,

 *   USA; either version 2 of the License, or (at your option) any later

 *   version; incorporated herein by reference.

 *

 * ----------------------------------------------------------------------- */

/*

 * mkzffile.c

 *

 *	- Generate block-compression of files for use with

 *	  the "ZF" extension to the iso9660/RockRidge filesystem.

 *

 *	  The file compression technique used is the "deflate"

 *	  algorithm used by the zlib library; each block must have a

 *	  valid (12-byte) zlib header.  In addition, the file itself

 *	  has the following structure:

 *

 *	  Byte offset	iso9660 type	Contents

 *	    0		(8 bytes)	Magic number (37 E4 53 96 C9 DB D6 07)

 *	    8		7.3.1		Uncompressed file size

 *	   12		7.1.1		header_size >> 2 (currently 4)

 *	   13		7.1.1		log2(block_size)

 *	   14		(2 bytes)	Reserved, must be zero

 *

 * The header may get expanded in the future, at which point the

 * header size field will be used to increase the space for the

 * header.

 *

 * All implementations are required to support a block_size of 32K

 * (byte 13 == 15).

 *

 * Note that bytes 12 and 13 and the uncompressed length are also

 * present in the ZF record; THE TWO MUST BOTH BE CONSISTENT AND

 * CORRECT.

 *

 * Given the uncompressed size, block_size, and header_size:

 *

 *     Nblocks := ceil(size/block_size)

 *

 * After the header follow (nblock+1) 32-bit pointers, recorded as

 * iso9660 7.3.1 (littleendian); each indicate the byte offset (from

 * the start of the file) to one block and the first byte beyond the

 * end of the previous block; the first pointer thus point to the

 * start of the data area and the last pointer to the first byte

 * beyond it:

 *

 *     block_no := floor(byte_offset/block_size)

 *

 *     block_start := read_pointer_731( (header_size+block_no)*4 )

 *     block_end   := read_pointer_731( (header_size+block_no+1)*4 )

 *

 * The block data is compressed according to "zlib".

 */

#include "mkzftree.h"		/* Must be included first! */

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <unistd.h>

#include <limits.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/time.h>

#ifdef HAVE_GETOPT_H

#include <getopt.h>

#endif

#include "version.h"

/* Command line options */

struct cmdline_options opt = {

  0,				/* Force compression */

  9,				/* Compression level */

  0,				/* Parallelism (0 = strictly serial) */

  0,				/* One filesystem only */

  0,				/* One directory only */

  1,				/* Create stub directories */

  0,				/* Root may be a file */

  0,				/* Be paranoid about metadata */

  default_verbosity,		/* Default verbosity */

  block_compress_file		/* Default transformation function */

};

/* Program name */

const char *program;

/* Long options */

#define OPTSTRING "fz:up:xXC:lLFvqV:hw"

#ifdef HAVE_GETOPT_LONG

const struct option long_options[] = {

  { "force",	             0,  0,  'f' },

  { "level",                 1,  0,  'z' },

  { "uncompress",            0,  0,  'u' },

  { "parallelism",           1,  0,  'p' },

  { "one-filesystem",        0,  0,  'x' },

  { "strict-one-filesystem", 0,  0,  'X' },

  { "crib-tree",             1,  0,  'C' },

  { "local",                 0,  0,  'l' },

  { "strict-local",          0,  0,  'L' },

  { "file",                  0,  0,  'F' },

  { "verbose",               0,  0,  'v' },

  { "quiet",                 0,  0,  'q' },

  { "verbosity",             1,  0,  'V' },

  { "help",                  0,  0,  'h' },

  { "version",               0,  0,  'w' },

  { 0, 0, 0, 0 }

};

#define LO(X) X

#else

#define getopt_long(C,V,O,L,I) getopt(C,V,O)

#define LO(X)

#endif

static void usage(enum verbosity level, int err)

{

  message(level,

	  "zisofs-tools " ZISOFS_TOOLS_VERSION "\n"

	  "Usage: %s [options] intree outtree\n"

	  LO("  --force                ")"  -f    Always compress, even if result is larger\n"

	  LO("  --level #              ")"  -z #  Set compression level (1-9)\n"

	  LO("  --uncompress           ")"  -u    Uncompress an already compressed tree\n"

	  LO("  --parallelism #        ")"  -p #  Process up to # files in parallel\n"

	  LO("  --one-filesystem       ")"  -x    Do not cross filesystem boundaries\n"

	  LO("  --strict-one-filesystem")"  -X    Same as -x, but don't create stubs dirs\n"

	  LO("  --crib-tree            ")"  -C    Steal \"crib\" files from an old tree\n"

	  LO("  --local                ")"  -l    Do not recurse into subdirectoires\n"

	  LO("  --strict-local         ")"  -L    Same as -l, but don't create stubs dirs\n"

	  LO("  --file                 ")"  -F    Operate possibly on a single file\n"

	  LO("  --sloppy               ")"  -s    Don't abort if metadata cannot be set\n"

	  LO("  --verbose              ")"  -v    Increase message verbosity\n"

	  LO("  --verbosity #          ")"  -V #  Set message verbosity to # (default = %d)\n"

	  LO("  --quiet                ")"  -q    No messages, not even errors (-V 0)\n"

	  LO("  --help                 ")"  -h    Display this message\n"

	  LO("  --version              ")"  -w    Display the program version\n"

	  ,program, (int)default_verbosity);

  exit(err);

}

static int opt_atoi(const char *str)

{

  char *endptr;

  long out;

  out = strtol(str, &endptr, 10);

  if ( *endptr )

    usage(vl_error, EX_USAGE);

  return (int)out;

}

int main(int argc, char *argv[])

{

  const char *in, *out, *crib = NULL;

  struct stat st;

  int optch, err;

  program = argv[0];

  while ( (optch = getopt_long(argc, argv, OPTSTRING, long_options, NULL))

	  != EOF ) {

    switch(optch) {

    case 'f':

      opt.force = 1;		/* Always compress */

      break;

    case 'z':

      opt.level = opt_atoi(optarg);

      if ( opt.level < 1 || opt.level > 9 ) {

	message(vl_error, "%s: invalid compression level: %d\n",

		program, optarg);

	exit(EX_USAGE);

      }

      break;

    case 'v':

      opt.verbosity++;

      break;

    case 'V':

      opt.verbosity = opt_atoi(optarg);

      break;

    case 'q':

      opt.verbosity = vl_quiet;

      break;

    case 'u':

      opt.munger = block_uncompress_file;

      break;

    case 'C':

      crib = optarg;

      break;

    case 'p':

      opt.parallel = opt_atoi(optarg);

      break;

    case 'x':

      opt.onefs = 1;  opt.do_mkdir = 1;

      break;

    case 'l':

      opt.onedir = 1; opt.do_mkdir = 1;

      break;

    case 'X':

      opt.onefs = 1;  opt.do_mkdir = 0;

      break;

    case 'L':

      opt.onedir = 1; opt.do_mkdir = 0;

      break;

    case 'F':

      opt.file_root = 1;

      break;

    case 's':

      opt.sloppy = 1;

      break;

    case 'h':

      usage(vl_quiet, 0);

      break;

    case 'w':

      message(vl_quiet, "zisofs-tools " ZISOFS_TOOLS_VERSION "\n");

      exit(0);

    default:

      usage(vl_error, EX_USAGE);

      break;

    }

  }

  if ( (argc-optind) != 2 )

    usage(vl_error, EX_USAGE);

  in  = argv[optind];		/* Input tree */

  out = argv[optind+1];		/* Output tree */

  umask(077);

  if ( opt.file_root ) {

    if ( lstat(in, &st) ) {

      message(vl_error, "%s: %s: %s\n", program, in, strerror(errno));

      exit(EX_NOINPUT);

    }

    err = munge_entry(in, out, crib, NULL);

  } else {

    /* Special case: we use stat() for the root, not lstat() */

    if ( stat(in, &st) ) {

      message(vl_error, "%s: %s: %s\n", program, in, strerror(errno));

      exit(EX_NOINPUT);

    }

    if ( !S_ISDIR(st.st_mode) ) {

      message(vl_error, "%s: %s: Not a directory\n", program, in);

      exit(EX_DATAERR);

    }

    err = munge_tree(in, out, crib);

  }    

  wait_for_all_workers();

  if ( err )

    exit(err);

  if ( !opt.file_root ) {

    if ( chown(out, st.st_uid, st.st_gid) && !opt.sloppy ) {

      message(vl_error, "%s: %s: %s", program, out, strerror(errno));

      err = EX_CANTCREAT;

    }

    if ( chmod(out, st.st_mode) && !opt.sloppy && !err ) {

      message(vl_error, "%s: %s: %s", program, out, strerror(errno));

      err = EX_CANTCREAT;

    }

    if ( copytime(out, &st) && !opt.sloppy && !err ) {

      message(vl_error, "%s: %s: %s", program, out, strerror(errno));

      err = EX_CANTCREAT;

    }

  }

  return err;

}