path: root/zdiff.cc

/*  Zdiff - decompress and compare two files line by line
    Copyright (C) 2010, 2011, 2012, 2013, 2014 Antonio Diaz Diaz.

    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/>.
*/

#define _FILE_OFFSET_BITS 64

#include <algorithm>
#include <cctype>
#include <cerrno>
#include <climits>
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <vector>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/stat.h>
#if defined(__MSVCRT__) || defined(__OS2__)
#include <io.h>
#endif

#include "arg_parser.h"
#include "rc.h"
#include "zutils.h"


namespace {

std::string fifonames[2];	// names of the two fifos passed to diff

#include "zcmpdiff.cc"

void show_help()
  {
  std::printf( "Zdiff compares two files (\"-\" means standard input), and if they\n"
               "differ, shows the differences line by line. If any given file is\n"
               "compressed, its decompressed content is used. Zdiff is a front end to\n"
               "the diff program and has the limitation that messages from diff refer to\n"
               "temporary filenames instead of those specified.\n"
               "\nThe supported formats are bzip2, gzip, lzip and xz.\n"
               "\nUsage: zdiff [options] file1 [file2]\n"
               "\nCompares <file1> to <file2>. If <file2> is omitted zdiff tries the\n"
               "following:\n"
               "\n  1. If <file1> is compressed, compares its decompressed contents with\n"
               "  the corresponding uncompressed file (the name of <file1> with the\n"
               "  extension removed).\n"
               "\n  2. If <file1> is uncompressed, compares it with the decompressed\n"
               "  contents of <file1>.[lz|bz2|gz|xz] (the first one that is found).\n"
               "\n  3. If no suitable file is found, compares <file1> with data read from\n"
               "  standard input.\n"
               "\nExit status is 0 if inputs are identical, 1 if different, 2 if trouble.\n"
               "\nOptions:\n"
               "  -h, --help                      display this help and exit\n"
               "  -V, --version                   output version information and exit\n"
               "  -a, --text                      treat all files as text\n"
               "  -b, --ignore-space-change       ignore changes in the amount of white space\n"
               "  -B, --ignore-blank-lines        ignore changes whose lines are all blank\n"
               "  -c                              use the context output format\n"
               "  -C, --context=<n>               same as -c but use <n> lines of context\n"
               "  -d, --minimal                   try hard to find a smaller set of changes\n"
               "  -E, --ignore-tab-expansion      ignore changes due to tab expansion\n"
               "      --format=[<fmt1>][,<fmt2>]  force given formats (bz2, gz, lz, xz)\n"
               "  -i, --ignore-case               ignore case differences in file contents\n"
               "  -N, --no-rcfile                 don't read runtime configuration file\n"
               "  -p, --show-c-function           show which C function each change is in\n"
               "  -q, --brief                     output only whether files differ\n"
               "  -s, --report-identical-files    report when two files are identical\n"
               "  -t, --expand-tabs               expand tabs to spaces in output\n"
               "  -T, --initial-tab               make tabs line up by prepending a tab\n"
               "  -u                              use the unified output format\n"
               "  -U, --unified=<n>               same as -u but use <n> lines of context\n"
               "  -w, --ignore-all-space          ignore all white space\n"
               "      --bz2=<command>             set compressor and options for bzip2 format\n"
               "      --gz=<command>              set compressor and options for gzip format\n"
               "      --lz=<command>              set compressor and options for lzip format\n"
               "      --xz=<command>              set compressor and options for xz format\n"
               "Numbers may be followed by a multiplier: k = kB = 10^3 = 1000,\n"
               "Ki = KiB = 2^10 = 1024, M = 10^6, Mi = 2^20, G = 10^9, Gi = 2^30, etc...\n" );
  show_help_addr();
  }


const char * my_basename( const char * filename )
  {
  const char * c = filename;
  while( *c ) { if( *c == '/' ) { filename = c + 1; } ++c; }
  return filename;
  }


extern "C" void remove_fifos()
  {
  if( fifonames[0].size() )
    { std::remove( fifonames[0].c_str() ); fifonames[0].clear(); }
  if( fifonames[1].size() )
    { std::remove( fifonames[1].c_str() ); fifonames[1].clear(); }
  }


// Set fifonames[i] to "${TMPDIR}/<coded_pid><i>_<basename(filenames[i])>"
// and create FIFOs.
bool set_fifonames( const std::string filenames[2] )
  {
  enum { num_codes = 36 };
  const char * const codes = "0123456789abcdefghijklmnopqrstuvwxyz";
  const char * p = std::getenv( "TMPDIR" );
  const int pid = getpid();

  for( int i = 0; i < 2; ++i )
    {
    if( p ) fifonames[i] = p; else fifonames[i] = "/tmp";
    fifonames[i] += '/';
    int n = ( 2 * pid ) + i;
    const unsigned pos = fifonames[i].size();
    do { fifonames[i].insert( pos, 1, codes[n % num_codes] );
         n /= num_codes; }
    while( n );
    fifonames[i] += '_';
    fifonames[i] += my_basename( filenames[i].c_str() );
    }

  for( int i = 0; i < 2; ++i )
    if( mkfifo( fifonames[i].c_str(), S_IRUSR | S_IWUSR ) != 0 )
      {
      if( errno == EEXIST )
        {
        std::remove( fifonames[i].c_str() );
        if( mkfifo( fifonames[i].c_str(), S_IRUSR | S_IWUSR ) == 0 )
          continue;
        }
      show_error2( "Can't create FIFO", fifonames[i].c_str() );
      return false;
      }
  return true;
  }


bool set_data_feeder( const std::string & fifoname, const int infd,
                      Children & children, int format_index )
  {
  const uint8_t * magic_data = 0;
  int magic_size = 0;
  if( format_index < 0 )
    format_index = test_format( infd, &magic_data, &magic_size );
  children.compressor_name = get_compressor_name( format_index );

  if( children.compressor_name )	// compressed
    {
    int fda[2];				// pipe from feeder to compressor
    if( pipe( fda ) < 0 )
      { show_error( "Can't create pipe", errno ); return false; }
    const pid_t pid = fork();
    if( pid == 0 )			// child 1 (compressor feeder)
      {
      if( close( fda[0] ) != 0 ||
          !feed_data( infd, fda[1], magic_data, magic_size ) )
        _exit( 2 );
      if( close( fda[1] ) != 0 )
        { show_close_error(); _exit( 2 ); }
      _exit( 0 );
      }
    if( pid < 0 )			// parent
      { show_fork_error( "data feeder" ); return false; }

    const pid_t pid2 = fork();
    if( pid2 == 0 )			// child 2 (compressor)
      {
      const int outfd = open( fifoname.c_str(), O_WRONLY | O_BINARY );
      if( outfd < 0 )
        {
        if( verbosity >= 0 )
          std::fprintf( stderr, "%s: Can't open FIFO '%s' for writing: %s.\n",
                        program_name, fifoname.c_str(), std::strerror( errno ) );
        _exit( 2 );
        }
      if( dup2( fda[0], STDIN_FILENO ) >= 0 &&
          dup2( outfd, STDOUT_FILENO ) >= 0 &&
          close( fda[0] ) == 0 && close( fda[1] ) == 0 &&
          close( outfd ) == 0 )
        {
        const std::vector< std::string > & compressor_args =
          get_compressor_args( format_index );
        const int size = compressor_args.size();
        const char ** const argv = new const char *[size+3];
        argv[0] = children.compressor_name;
        for( int i = 0; i < size; ++i )
          argv[i+1] = compressor_args[i].c_str();
        argv[size+1] = ( verbosity >= 0 ) ? "-d" : "-dq";
        argv[size+2] = 0;
        execvp( argv[0], (char **)argv );
        }
      show_exec_error( children.compressor_name );
      _exit( 2 );
      }
    if( pid2 < 0 )			// parent
      { show_fork_error( children.compressor_name ); return false; }

    close( fda[0] ); close( fda[1] );
    children.pid[0] = pid;
    children.pid[1] = pid2;
    }
  else					// uncompressed
    {
    const pid_t pid = fork();
    if( pid == 0 )			// child (feeder)
      {
      const int outfd = open( fifoname.c_str(), O_WRONLY | O_BINARY );
      if( outfd < 0 )
        {
        if( verbosity >= 0 )
          std::fprintf( stderr, "%s: Can't open FIFO '%s' for writing: %s.\n",
                        program_name, fifoname.c_str(), std::strerror( errno ) );
        _exit( 2 );
        }
      if( !feed_data( infd, outfd, magic_data, magic_size ) )
        _exit( 2 );
      if( close( outfd ) != 0 )
        { show_close_error(); _exit( 2 ); }
      _exit( 0 );
      }
    if( pid < 0 )			// parent
      { show_fork_error( "data feeder" ); return false; }
    children.pid[0] = pid;
    children.pid[1] = 0;
    }
  return true;
  }


extern "C" void signal_handler( int sig )
  {
  remove_fifos();
  std::signal( sig, SIG_DFL );
  std::raise( sig );
  }


void set_signals()
  {
  std::signal( SIGHUP, signal_handler );
  std::signal( SIGINT, signal_handler );
  std::signal( SIGTERM, signal_handler );
  }

} // end namespace


int main( const int argc, const char * const argv[] )
  {
  enum { format_opt = 256, bz2_opt, gz_opt, lz_opt, xz_opt };
  std::vector< const char * > diff_args;	// args to diff, maybe empty
  int format_types[2] = { -1, -1 };
  invocation_name = argv[0];
  program_name = "zdiff";

  const Arg_parser::Option options[] =
    {
    { 'a', "text",                   Arg_parser::no  },
    { 'b', "ignore-space-change",    Arg_parser::no  },
    { 'B', "ignore-blank-lines",     Arg_parser::no  },
    { 'c',  0,                       Arg_parser::no  },
    { 'C', "context",                Arg_parser::yes },
    { 'd', "minimal",                Arg_parser::no  },
    { 'E', "ignore-tab-expansion",   Arg_parser::no  },
    { 'h', "help",                   Arg_parser::no  },
    { 'i', "ignore-case",            Arg_parser::no  },
    { 'N', "no-rcfile",              Arg_parser::no  },
    { 'p', "show-c-function",        Arg_parser::no  },
    { 'q', "brief",                  Arg_parser::no  },
    { 's', "report-identical-files", Arg_parser::no  },
    { 't', "expand-tabs",            Arg_parser::no  },
    { 'T', "initial-tab",            Arg_parser::no  },
    { 'u',  0,                       Arg_parser::no  },
    { 'U', "unified",                Arg_parser::yes },
    { 'V', "version",                Arg_parser::no  },
    { 'w', "ignore-all-space",       Arg_parser::no  },
    { format_opt, "format",          Arg_parser::yes },
    { bz2_opt,    "bz2",             Arg_parser::yes },
    { gz_opt,     "gz",              Arg_parser::yes },
    { lz_opt,     "lz",              Arg_parser::yes },
    { xz_opt,     "xz",              Arg_parser::yes },
    {  0 ,  0,                       Arg_parser::no  } };

  const Arg_parser parser( argc, argv, options );
  if( parser.error().size() )				// bad option
    { show_error( parser.error().c_str(), 0, true ); return 2; }

  maybe_process_config_file( parser );

  int argind = 0;
  for( ; argind < parser.arguments(); ++argind )
    {
    const int code = parser.code( argind );
    if( !code ) break;					// no more options
    const char * const arg = parser.argument( argind ).c_str();
    switch( code )
      {
      case 'a': diff_args.push_back( "-a" ); break;
      case 'b': diff_args.push_back( "-b" ); break;
      case 'B': diff_args.push_back( "-B" ); break;
      case 'c': diff_args.push_back( "-c" ); break;
      case 'C': diff_args.push_back( "-C" ); diff_args.push_back( arg ); break;
      case 'd': diff_args.push_back( "-d" ); break;
      case 'E': diff_args.push_back( "-E" ); break;
      case 'h': show_help(); return 0;
      case 'i': diff_args.push_back( "-i" ); break;
      case 'N': break;
      case 'p': diff_args.push_back( "-p" ); break;
      case 'q': diff_args.push_back( "-q" ); break;
      case 's': diff_args.push_back( "-s" ); break;
      case 't': diff_args.push_back( "-t" ); break;
      case 'T': diff_args.push_back( "-T" ); break;
      case 'u': diff_args.push_back( "-u" ); break;
      case 'U': diff_args.push_back( "-U" ); diff_args.push_back( arg ); break;
      case 'V': show_version( "Zdiff" ); return 0;
      case 'w': diff_args.push_back( "-w" ); break;
      case format_opt: parse_format_types( arg, format_types ); break;
      case bz2_opt: parse_compressor( arg, fmt_bz2 ); break;
      case gz_opt: parse_compressor( arg, fmt_gz ); break;
      case lz_opt: parse_compressor( arg, fmt_lz ); break;
      case xz_opt: parse_compressor( arg, fmt_xz ); break;
      default : internal_error( "uncaught option" );
      }
    } // end process options

#if defined(__MSVCRT__) || defined(__OS2__)
  setmode( STDIN_FILENO, O_BINARY );
  setmode( STDOUT_FILENO, O_BINARY );
#endif

  if( argind >= parser.arguments() )
    { show_error( "No files given.", 0, true ); return 2; }
  if( argind + 2 < parser.arguments() )
    { show_error( "Too many files.", 0, true ); return 2; }

  const int files = parser.arguments() - argind;
  std::string filenames[2];		// file names of the two input files
  filenames[0] = parser.argument( argind );
  if( files == 2 ) filenames[1] = parser.argument( argind + 1 );

  int infd[2];				// file descriptors of the two files
  infd[0] = ( filenames[0] == "-" ) ?
    STDIN_FILENO : open_instream( filenames[0] );
  if( infd[0] < 0 ) return 2;

  if( ( files == 1 && filenames[0] == "-" ) ||
      ( files == 2 && check_identical( filenames[0].c_str(),
                                       filenames[1].c_str() ) ) )
    return 0;

  if( files == 2 )
    {
    infd[1] = ( filenames[1] == "-" ) ?
      STDIN_FILENO : open_instream( filenames[1] );
    if( infd[1] < 0 ) return 2;
    }
  else
    {
    if( format_types[0] >= 0 || format_types[1] >= 0 )
      { show_error( "Two files must be given when format is specified.", 0, true );
        return 2; }
    filenames[1] = filenames[0];
    infd[1] = open_other_instream( filenames[1] );
    if( infd[1] < 0 ) { infd[1] = STDIN_FILENO; filenames[1] = "-"; }
    }

  std::atexit( remove_fifos );
  set_signals();
  if( !set_fifonames( filenames ) ) return 2;

  Children children[2];
  if( !set_data_feeder( fifonames[0], infd[0], children[0], format_types[0] ) ||
      !set_data_feeder( fifonames[1], infd[1], children[1], format_types[1] ) )
    return 2;

  const pid_t diff_pid = fork();
  if( diff_pid == 0 )			// child (diff)
    {
    const char ** const argv = new const char *[diff_args.size()+5];
    argv[0] = DIFF;
    for( unsigned i = 0; i < diff_args.size(); ++i )
      argv[i+1] = diff_args[i];
    argv[diff_args.size()+1] = "--";
    argv[diff_args.size()+2] = fifonames[0].c_str();
    argv[diff_args.size()+3] = fifonames[1].c_str();
    argv[diff_args.size()+4] = 0;
    execvp( argv[0], (char **)argv );
    show_exec_error( DIFF );
    _exit( 2 );
    }
  if( diff_pid < 0 )			// parent
    { show_fork_error( DIFF ); return 2; }

  int retval = wait_for_child( diff_pid, DIFF );

  for( int i = 0; i < 2; ++i )
    if( !good_status( children[i], retval == 0 ) ) retval = 2;

  for( int i = 0; i < 2; ++i )
    if( filenames[i] != "-" && close( infd[i] ) != 0 )
      {
      show_error2( "Can't close input file", filenames[i].c_str() );
      retval = 2;
      }

  return retval;
  }