summaryrefslogtreecommitdiffstats
path: root/zutils.cc
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--zutils.cc301
1 files changed, 301 insertions, 0 deletions
diff --git a/zutils.cc b/zutils.cc
new file mode 100644
index 0000000..5451534
--- /dev/null
+++ b/zutils.cc
@@ -0,0 +1,301 @@
+/* Zutils - Utilities dealing with compressed files
+ Copyright (C) 2009, 2010 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 <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include "zutils.h"
+
+
+const char * invocation_name = 0;
+const char * util_name = program_name;
+
+int verbosity = 0;
+
+
+// Returns the number of bytes really read.
+// If (returned value < size) and (errno == 0), means EOF was reached.
+//
+int readblock( const int fd, uint8_t * const buf, const int size ) throw()
+ {
+ int rest = size;
+ errno = 0;
+ while( rest > 0 )
+ {
+ errno = 0;
+ const int n = read( fd, buf + size - rest, rest );
+ if( n > 0 ) rest -= n;
+ else if( n == 0 ) break;
+ else if( errno != EINTR && errno != EAGAIN ) break;
+ }
+ return ( rest > 0 ) ? size - rest : size;
+ }
+
+
+// Returns the number of bytes really written.
+// If (returned value < size), it is always an error.
+//
+int writeblock( const int fd, const uint8_t * const buf, const int size ) throw()
+ {
+ int rest = size;
+ errno = 0;
+ while( rest > 0 )
+ {
+ errno = 0;
+ const int n = write( fd, buf + size - rest, rest );
+ if( n > 0 ) rest -= n;
+ else if( errno && errno != EINTR && errno != EAGAIN ) break;
+ }
+ return ( rest > 0 ) ? size - rest : size;
+ }
+
+
+bool feed_data( const int infd, const int outfd,
+ const uint8_t * magic_data, const int magic_size )
+ {
+ if( writeblock( outfd, magic_data, magic_size ) != magic_size )
+ { show_error( "Write error", errno ); return false; }
+ enum { buffer_size = 4096 };
+ uint8_t buffer[buffer_size];
+ while( true )
+ {
+ const int size = readblock( infd, buffer, buffer_size );
+ if( size != buffer_size && errno )
+ { show_error( "Read error", errno ); return false; }
+ if( size > 0 && writeblock( outfd, buffer, size ) != size )
+ { show_error( "Write error", errno ); return false; }
+ if( size < buffer_size ) break;
+ }
+ return true;
+ }
+
+
+bool set_data_feeder( int * const infdp, pid_t * const pidp )
+ {
+ std::string file_type;
+ const uint8_t * magic_data;
+ int magic_size;
+ const bool compressed =
+ test_format( *infdp, file_type, &magic_data, &magic_size );
+
+ if( compressed ) // compressed with `file_type'
+ {
+ int fda[2]; // pipe from feeder
+ int fda2[2]; // pipe from decompressor
+ if( pipe( fda ) < 0 || pipe( fda2 ) < 0 )
+ { show_error( "Can't create pipe", errno ); return false; }
+ const int old_infd = *infdp;
+ *infdp = fda2[0];
+ const pid_t pid = fork();
+ if( pid == 0 ) // child (decompressor feeder)
+ {
+ const pid_t pid2 = fork();
+ if( pid2 == 0 ) // grandchild (decompressor)
+ {
+ if( dup2( fda[0], STDIN_FILENO ) >= 0 &&
+ dup2( fda2[1], STDOUT_FILENO ) >= 0 &&
+ close( fda[0] ) == 0 && close( fda[1] ) == 0 &&
+ close( fda2[0] ) == 0 && close( fda2[1] ) == 0 )
+ execlp( file_type.c_str(), file_type.c_str(), "-cdfq", (char *)0 );
+ if( verbosity >= 0 )
+ std::fprintf( stderr, "%s: Can't exec `%s': %s.\n",
+ util_name, file_type.c_str(), std::strerror( errno ) );
+ _exit( 2 );
+ }
+ if( pid2 < 0 )
+ {
+ if( verbosity >= 0 )
+ std::fprintf( stderr, "%s: Can't fork `%s': %s.\n",
+ util_name, file_type.c_str(), std::strerror( errno ) );
+ _exit( 2 );
+ }
+
+ if( close( fda[0] ) != 0 ||
+ close( fda2[0] ) != 0 || close( fda2[1] ) != 0 ||
+ !feed_data( old_infd, fda[1], magic_data, magic_size ) )
+ _exit( 2 );
+ if( close( fda[1] ) != 0 )
+ { show_error( "Can't close output of decompressor feeder", errno );
+ _exit( 2 ); }
+ _exit( wait_for_child( pid2, file_type.c_str() ) );
+ }
+ // parent
+ close( fda[0] ); close( fda[1] ); close( fda2[1] );
+ if( pid < 0 )
+ { show_error( "Can't fork decompressor feeder", errno ); return false; }
+ *pidp = pid;
+ }
+ else // not compressed
+ {
+ int fda[2]; // pipe from feeder
+ if( pipe( fda ) < 0 )
+ { show_error( "Can't create pipe", errno ); return false; }
+ const int old_infd = *infdp;
+ *infdp = fda[0];
+ const pid_t pid = fork();
+ if( pid == 0 ) // child (feeder)
+ {
+ if( close( fda[0] ) != 0 ||
+ !feed_data( old_infd, fda[1], magic_data, magic_size ) )
+ _exit( 2 );
+ if( close( fda[1] ) != 0 )
+ { show_error( "Can't close output of data feeder", errno );
+ _exit( 2 ); }
+ _exit( 0 );
+ }
+ // parent
+ close( fda[1] );
+ if( pid < 0 )
+ { show_error( "Can't fork data feeder", errno ); return false; }
+ *pidp = pid;
+ }
+ return true;
+ }
+
+
+void show_help_addr() throw()
+ {
+ std::printf( "\nReport bugs to zutils-bug@nongnu.org\n" );
+ std::printf( "Zutils home page: http://www.nongnu.org/zutils/zutils.html\n" );
+ }
+
+
+void show_version( const char * const Util_name ) throw()
+ {
+ if( !Util_name || !*Util_name )
+ std::printf( "%s %s\n", Program_name, PROGVERSION );
+ else
+ std::printf( "%s (%s) %s\n", Util_name, program_name, PROGVERSION );
+ std::printf( "Copyright (C) %s Antonio Diaz Diaz.\n", program_year );
+ std::printf( "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n" );
+ std::printf( "This is free software: you are free to change and redistribute it.\n" );
+ std::printf( "There is NO WARRANTY, to the extent permitted by law.\n" );
+ }
+
+
+void show_error( const char * const msg, const int errcode,
+ const bool help ) throw()
+ {
+ if( verbosity >= 0 )
+ {
+ if( msg && msg[0] )
+ {
+ std::fprintf( stderr, "%s: %s", util_name, msg );
+ if( errcode > 0 )
+ std::fprintf( stderr, ": %s", std::strerror( errcode ) );
+ std::fprintf( stderr, "\n" );
+ }
+ if( help && invocation_name && invocation_name[0] )
+ std::fprintf( stderr, "Try `%s --help' for more information.\n",
+ invocation_name );
+ }
+ }
+
+
+void internal_error( const char * const msg )
+ {
+ if( verbosity >= 0 )
+ std::fprintf( stderr, "%s: internal error: %s.\n", util_name, msg );
+ std::exit( 3 );
+ }
+
+
+unsigned char xdigit( const int value ) throw()
+ {
+ if( value >= 0 && value <= 9 ) return '0' + value;
+ if( value >= 10 && value <= 15 ) return 'A' + ( value - 10 );
+ return 0;
+ }
+
+
+bool test_format( const int infd, std::string & file_type,
+ const uint8_t ** const magic_datap, int * const magic_sizep )
+ {
+ enum { buf_size = 5 };
+ static uint8_t buf[buf_size];
+ int i = 0;
+ file_type.clear();
+ if( readblock( infd, buf, 1 ) == 1 )
+ {
+ ++i;
+ if( buf[0] == bzip2_magic[0] )
+ {
+ if( readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == bzip2_magic[1] &&
+ readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == bzip2_magic[2] )
+ { file_type = "bzip2";
+ *magic_datap = bzip2_magic; *magic_sizep = bzip2_magic_size; }
+ }
+ else if( buf[0] == gzip_magic[0] )
+ {
+ if( readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == gzip_magic[1] )
+ { file_type = "gzip";
+ *magic_datap = gzip_magic; *magic_sizep = gzip_magic_size; }
+ }
+ else if( buf[0] == lzip_magic[0] )
+ {
+ if( readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == lzip_magic[1] &&
+ readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == lzip_magic[2] &&
+ readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == lzip_magic[3] )
+ { file_type = "lzip";
+ *magic_datap = lzip_magic; *magic_sizep = lzip_magic_size; }
+ }
+ else if( buf[0] == xz_magic[0] )
+ {
+ if( readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == xz_magic[1] &&
+ readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == xz_magic[2] &&
+ readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == xz_magic[3] &&
+ readblock( infd, &buf[i], 1 ) == 1 && buf[i++] == xz_magic[4] )
+ { file_type = "xz";
+ *magic_datap = xz_magic; *magic_sizep = xz_magic_size; }
+ }
+ }
+ if( file_type.size() ) return true;
+ for( int j = 0; j < i; ++j )
+ {
+ file_type += xdigit( buf[j] >> 4 );
+ file_type += xdigit( buf[j] & 0x0F );
+ }
+ *magic_datap = buf; *magic_sizep = i;
+ return false;
+ }
+
+
+int wait_for_child( const pid_t pid, const char * const name )
+ {
+ int status;
+ while( waitpid( pid, &status, 0 ) == -1 )
+ {
+ if( errno != EINTR )
+ {
+ if( verbosity >= 0 )
+ std::fprintf( stderr, "%s: Error waiting termination of `%s': %s.\n",
+ util_name, name, std::strerror( errno ) );
+ _exit( 1 );
+ }
+ }
+
+ if( WIFEXITED( status ) ) return WEXITSTATUS( status );
+ else return 1;
+ }