summaryrefslogtreecommitdiffstats
path: root/extract.cc
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--extract.cc561
1 files changed, 561 insertions, 0 deletions
diff --git a/extract.cc b/extract.cc
new file mode 100644
index 0000000..67f4a20
--- /dev/null
+++ b/extract.cc
@@ -0,0 +1,561 @@
+/* Tarlz - Archiver with multimember lzip compression
+ Copyright (C) 2013-2018 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 2 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 <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <stdint.h>
+#include <unistd.h>
+#include <utime.h>
+#include <sys/stat.h>
+#include <lzlib.h>
+
+#include "arg_parser.h"
+#include "lzip.h"
+#include "tarlz.h"
+
+
+namespace {
+
+int gretval = 0;
+
+bool make_path( const std::string & name )
+ {
+ const mode_t mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
+ unsigned end = name.size(); // first slash before last component
+
+ while( end > 0 && name[end-1] == '/' ) --end; // remove trailing slashes
+ while( end > 0 && name[end-1] != '/' ) --end; // remove last component
+ while( end > 0 && name[end-1] == '/' ) --end; // remove more slashes
+
+ unsigned index = 0;
+ while( index < end )
+ {
+ while( index < end && name[index] == '/' ) ++index;
+ unsigned first = index;
+ while( index < end && name[index] != '/' ) ++index;
+ if( first < index )
+ {
+ const std::string partial( name, 0, index );
+ struct stat st;
+ if( stat( partial.c_str(), &st ) == 0 )
+ { if( !S_ISDIR( st.st_mode ) ) return false; }
+ else if( mkdir( partial.c_str(), mode ) != 0 )
+ return false;
+ }
+ }
+ return true;
+ }
+
+
+// Returns in buf the first rd bytes of the second lzip member or
+// the first 512 bytes of the second tar member, and sets islz if lzip member
+bool skip_first_member( const int infd, uint8_t * const buf,
+ int & rd, bool & islz )
+ {
+ while( true )
+ {
+ for( int i = 0; i < rd; ++i )
+ if( buf[i] == 'L' && (*(Lzip_header *)( buf + i )).verify_prefix( rd - i ) )
+ {
+ const int ts = rd - i; // tail size
+ std::memmove( buf, buf + i, ts );
+ if( ts >= (int)sizeof lzip_magic )
+ { rd = ts; islz = true; return true; }
+ int rd2 = readblock( infd, buf + ts, header_size - ts );
+ if( rd2 != header_size - ts && errno )
+ { show_error( "Error reading archive", errno ); return false; }
+ if( ts + rd2 >= min_member_size &&
+ (*(Lzip_header *)buf).verify_magic() )
+ { rd = ts + rd2; islz = true; return true; }
+ std::memmove( buf, buf + ts, rd2 );
+ int rd3 = readblock( infd, buf + rd2, header_size - rd2 );
+ if( rd3 != header_size - rd2 && errno )
+ { show_error( "Error reading archive", errno ); return false; }
+ rd = rd2 + rd3; i = -1;
+ }
+ if( rd < header_size ) return false; // eof
+ if( rd == header_size && verify_ustar_chksum( buf ) )
+ { islz = false; return true; }
+ rd = readblock( infd, buf, header_size );
+ if( rd != header_size && errno )
+ { show_error( "Error reading archive", errno ); return false; }
+ }
+ }
+
+
+inline bool block_is_zero( const uint8_t * const buf, const int size )
+ {
+ for( int i = 0; i < size; ++i ) if( buf[i] != 0 ) return false;
+ return true;
+ }
+
+
+bool archive_read( const int infd, uint8_t * const buf, const int size )
+ {
+ static LZ_Decoder * decoder = 0;
+ static bool first_call = true;
+ static bool at_eof = false;
+
+ if( first_call ) // check format
+ {
+ first_call = false;
+ if( size != header_size )
+ internal_error( "size != header_size on first call." );
+ int rd = readblock( infd, buf, size );
+ if( rd != size && errno )
+ { show_error( "Error reading archive", errno ); return false; }
+ bool islz =
+ ( rd >= min_member_size && (*(Lzip_header *)buf).verify_magic() );
+ const bool istar = ( rd == size && verify_ustar_chksum( buf ) );
+ const bool iseof =
+ ( !islz && !istar && rd == size && block_is_zero( buf, size ) );
+ if( !islz && !istar && !iseof )
+ {
+ show_error( "This does not look like a tar archive." );
+ show_error( "Skipping to next header." );
+// std::fprintf( stderr, "%07o\n", ustar_chksum( buf ) );
+ gretval = 2;
+ if( !skip_first_member( infd, buf, rd, islz ) ) return false;
+ }
+ if( !islz ) return true; // uncompressed
+ decoder = LZ_decompress_open(); // compressed
+ if( !decoder || LZ_decompress_errno( decoder ) != LZ_ok )
+ { show_error( "Not enough memory." );
+ LZ_decompress_close( decoder ); return false; }
+ if( LZ_decompress_write( decoder, buf, rd ) != rd )
+ internal_error( "library error (LZ_decompress_write)." );
+ if( !archive_read( infd, buf, size ) ) return false;
+ if( verify_ustar_chksum( buf ) || block_is_zero( buf, size ) ) return true;
+ show_error( "This does not look like a tar archive." );
+ show_error( "Skipping to next header." );
+ gretval = 2;
+ if( LZ_decompress_sync_to_member( decoder ) < 0 )
+ internal_error( "library error (LZ_decompress_sync_to_member)." );
+ }
+
+ if( !decoder ) // uncompressed
+ { if( readblock( infd, buf, size ) == size ) return true;
+ show_error( "Archive ends unexpectedly." ); return false; }
+ const int ibuf_size = 16384;
+ uint8_t ibuf[ibuf_size];
+ int sz = 0;
+ while( sz < size )
+ {
+ if( !at_eof && LZ_decompress_write_size( decoder ) > 0 )
+ {
+ const int rsize = std::min( ibuf_size, LZ_decompress_write_size( decoder ) );
+ const int rd = readblock( infd, ibuf, rsize );
+ if( LZ_decompress_write( decoder, ibuf, rd ) != rd )
+ internal_error( "library error (LZ_decompress_write)." );
+ if( rd < rsize )
+ {
+ at_eof = true; LZ_decompress_finish( decoder );
+ if( errno )
+ { show_error( "Error reading archive", errno ); return false; }
+ }
+ }
+ const int rd = LZ_decompress_read( decoder, buf + sz, size - sz );
+ if( rd < 0 )
+ {
+ show_error( "Skipping to next header." );
+ gretval = 2;
+ if( LZ_decompress_sync_to_member( decoder ) < 0 )
+ internal_error( "library error (LZ_decompress_sync_to_member)." );
+ continue;
+ }
+ if( rd == 0 && LZ_decompress_finished( decoder ) == 1 )
+ { LZ_decompress_close( decoder );
+ show_error( "Archive ends unexpectedly." ); return false; }
+ sz += rd;
+ if( sz == size && LZ_decompress_finished( decoder ) == 1 &&
+ LZ_decompress_close( decoder ) < 0 )
+ { show_error( "LZ_decompress_close failed." ); return false; }
+ }
+ return true;
+ }
+
+
+const char * mode_string( const Tar_header header )
+ {
+ static char buf[11];
+ const Typeflag typeflag = (Typeflag)header[typeflag_o];
+
+ std::memcpy( buf, "----------", sizeof buf - 1 );
+ switch( typeflag )
+ {
+ case tf_regular: break;
+ case tf_link: buf[0] = 'h'; break;
+ case tf_symlink: buf[0] = 'l'; break;
+ case tf_chardev: buf[0] = 'c'; break;
+ case tf_blockdev: buf[0] = 'b'; break;
+ case tf_directory: buf[0] = 'd'; break;
+ case tf_fifo: buf[0] = 'p'; break;
+ case tf_hiperf: buf[0] = 'C'; break;
+ default: buf[0] = '?';
+ }
+ const mode_t mode = strtoul( header + mode_o, 0, 8 ); // 12 bits
+ const bool setuid = mode & S_ISUID;
+ const bool setgid = mode & S_ISGID;
+ const bool sticky = mode & S_ISVTX;
+ if( mode & S_IRUSR ) buf[1] = 'r';
+ if( mode & S_IWUSR ) buf[2] = 'w';
+ if( mode & S_IXUSR ) buf[3] = setuid ? 's' : 'x';
+ else if( setuid ) buf[3] = 'S';
+ if( mode & S_IRGRP ) buf[4] = 'r';
+ if( mode & S_IWGRP ) buf[5] = 'w';
+ if( mode & S_IXGRP ) buf[6] = setgid ? 's' : 'x';
+ else if( setgid ) buf[6] = 'S';
+ if( mode & S_IROTH ) buf[7] = 'r';
+ if( mode & S_IWOTH ) buf[8] = 'w';
+ if( mode & S_IXOTH ) buf[9] = sticky ? 't' : 'x';
+ else if( sticky ) buf[9] = 'T';
+ return buf;
+ }
+
+
+const char * user_group_string( const Tar_header header )
+ {
+ enum { bufsize = uname_l + 1 + gname_l + 1 };
+ static char buf[bufsize];
+
+ if( header[uname_o] && header[gname_o] )
+ snprintf( buf, bufsize, "%.32s/%.32s", header + uname_o, header + gname_o );
+ else
+ {
+ const int uid = strtoul( header + uid_o, 0, 8 );
+ const int gid = strtoul( header + gid_o, 0, 8 );
+ snprintf( buf, bufsize, "%u/%u", uid, gid );
+ }
+ return buf;
+ }
+
+
+const char * link_string( const Tar_header header )
+ {
+ enum { bufsize = 9 + linkname_l + 1 };
+ static char buf[bufsize];
+ const Typeflag typeflag = (Typeflag)header[typeflag_o];
+
+ if( typeflag == tf_link )
+ snprintf( buf, bufsize, " link to %.100s", header + linkname_o );
+ else if( typeflag == tf_symlink )
+ snprintf( buf, bufsize, " -> %.100s", header + linkname_o );
+ else buf[0] = 0;
+ return buf;
+ }
+
+
+void show_member_name( const char * const filename, const Tar_header header,
+ const int vlevel )
+ {
+ if( verbosity < vlevel ) return;
+ if( verbosity > vlevel )
+ {
+ const time_t mtime = strtoull( header + mtime_o, 0, 8 ); // 33 bits
+ struct tm * tm = localtime( &mtime );
+ std::printf( "%s %s %9llu %4d-%02u-%02u %02u:%02u %s%s\n",
+ mode_string( header ), user_group_string( header ),
+ strtoull( header + size_o, 0, 8 ), 1900 + tm->tm_year,
+ 1 + tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min,
+ filename, link_string( header ) );
+ }
+ else std::printf( "%s\n", filename );
+ std::fflush( stdout );
+ }
+
+
+int list_member( const int infd, const char * const filename,
+ const unsigned long long file_size, const Tar_header header,
+ const bool skip )
+ {
+ if( !skip ) show_member_name( filename, header, 0 );
+
+ const unsigned bufsize = 32 * header_size;
+ uint8_t buf[bufsize];
+ unsigned long long rest = file_size;
+ const int rem = file_size % header_size;
+ const int padding = rem ? header_size - rem : 0;
+ while( rest > 0 )
+ {
+ const int rsize = ( rest >= bufsize ) ? bufsize : rest + padding;
+ if( !archive_read( infd, buf, rsize ) ) return 2;
+ if( rest < bufsize ) break;
+ rest -= rsize;
+ }
+ return 0;
+ }
+
+
+bool contains_dotdot( const char * const filename )
+ {
+ for( int i = 0; filename[i]; ++i )
+ if( filename[i] == '.' && filename[i+1] == '.' &&
+ ( i == 0 || filename[i-1] == '/' ) &&
+ ( filename[i+2] == 0 || filename[i+2] == '/' ) ) return true;
+ return false;
+ }
+
+
+int extract_member( const int infd, const char * const filename,
+ const unsigned long long file_size, const Tar_header header )
+ {
+ if( contains_dotdot( filename ) )
+ {
+ show_file_error( filename, "Contains a '..' component, skipping." );
+ return list_member( infd, filename, file_size, header, true );
+ }
+ const mode_t mode = strtoul( header + mode_o, 0, 8 ); // 12 bits
+ const time_t mtime = strtoull( header + mtime_o, 0, 8 ); // 33 bits
+ const Typeflag typeflag = (Typeflag)header[typeflag_o];
+ const bool islink = ( typeflag == tf_link || typeflag == tf_symlink );
+ int outfd = -1;
+
+ show_member_name( filename, header, 1 );
+ std::remove( filename );
+ make_path( filename );
+ switch( typeflag )
+ {
+ case tf_regular:
+ case tf_hiperf:
+ outfd = open_outstream( filename );
+ if( outfd < 0 ) return 2;
+ chmod( filename, mode ); // ignore errors
+ break;
+ case tf_link:
+ case tf_symlink:
+ {
+ char linkname[linkname_l+1];
+ std::memcpy( linkname, header + linkname_o, linkname_l );
+ linkname[linkname_l] = 0;
+/* if( contains_dotdot( linkname ) )
+ {
+ show_file_error( filename,
+ "Link destination contains a '..' component, skipping." );
+ return list_member( infd, filename, file_size, header, false );
+ }*/
+ const bool hard = typeflag == tf_link;
+ if( ( hard && link( linkname, filename ) != 0 ) ||
+ ( !hard && symlink( linkname, filename ) != 0 ) )
+ {
+ if( verbosity >= 0 )
+ std::fprintf( stderr, "Can't %slink file '%s' to '%s': %s.\n",
+ hard ? "" : "sym", linkname, filename,
+ std::strerror( errno ) );
+ return 2;
+ }
+ } break;
+ case tf_directory:
+ if( mkdir( filename, mode ) != 0 && errno != EEXIST )
+ {
+ show_file_error( filename, "Can't create directory", errno );
+ return 2;
+ }
+ break;
+ case tf_chardev:
+ case tf_blockdev:
+ {
+ const unsigned dev = makedev( strtoul( header + devmajor_o, 0, 8 ),
+ strtoul( header + devminor_o, 0, 8 ) );
+ const int dmode = ( typeflag == tf_chardev ? S_IFCHR : S_IFBLK ) | mode;
+ if( mknod( filename, dmode, dev ) != 0 )
+ {
+ show_file_error( filename, "Can't create device node", errno );
+ return 2;
+ }
+ break;
+ }
+ case tf_fifo:
+ if( mkfifo( filename, mode ) != 0 && errno != EEXIST )
+ {
+ show_file_error( filename, "Can't create FIFO file", errno );
+ return 2;
+ }
+ break;
+ default:
+ if( verbosity >= 0 )
+ std::fprintf( stderr, "File type '%c' not supported for file '%s'.\n",
+ typeflag, filename );
+ return 2;
+ }
+
+ const uid_t uid = (uid_t)strtoul( header + uid_o, 0, 8 );
+ const gid_t gid = (gid_t)strtoul( header + gid_o, 0, 8 );
+ if( !islink && chown( filename, uid, gid ) != 0 &&
+ errno != EPERM && errno != EINVAL )
+ {
+ show_file_error( filename, "Can't change file owner", errno );
+ return 2;
+ }
+
+ const unsigned bufsize = 32 * header_size;
+ uint8_t buf[bufsize];
+ unsigned long long rest = file_size;
+ const int rem = file_size % header_size;
+ const int padding = rem ? header_size - rem : 0;
+ while( rest > 0 )
+ {
+ const int rsize = ( rest >= bufsize ) ? bufsize : rest + padding;
+ if( !archive_read( infd, buf, rsize ) )
+ { if( outfd >= 0 ) { close( outfd ); std::remove( filename ); }
+ return 2; }
+ const int wsize = ( rest >= bufsize ) ? bufsize : rest;
+ if( outfd >= 0 && writeblock( outfd, buf, wsize ) != wsize )
+ { show_file_error( filename, "Error writing file", errno ); return 2; }
+ rest -= wsize;
+ }
+ if( outfd >= 0 && close( outfd ) != 0 )
+ { show_file_error( filename, "Error closing file", errno ); return 2; }
+ if( !islink )
+ {
+ struct utimbuf t;
+ t.actime = mtime;
+ t.modtime = mtime;
+ utime( filename, &t ); // ignore errors
+ }
+ return 0;
+ }
+
+
+const char * remove_leading_slash( const char * const filename )
+ {
+ static bool first_post = true;
+ const char * p = filename;
+
+ while( *p == '/' || ( *p == '.' && p[1] == '/' ) ) ++p;
+ if( p != filename && first_post )
+ {
+ first_post = false;
+ std::string msg( "Removing leading '" );
+ msg.append( filename, p - filename );
+ msg += "' from member names.";
+ show_error( msg.c_str() );
+ }
+ if( *p == 0 ) p = ".";
+ return p;
+ }
+
+
+// return true if dir is a parent directory of name
+bool compare_prefix_dir( const char * const dir, const char * const name )
+ {
+ int len = 0;
+ while( dir[len] && dir[len] == name[len] ) ++len;
+ return ( !dir[len] && len > 0 && ( dir[len-1] == '/' || name[len] == '/' ) );
+ }
+
+
+// compare two file names ignoring trailing slashes
+bool compare_tslash( const char * const name1, const char * const name2 )
+ {
+ const char * p = name1;
+ const char * q = name2;
+ while( *p && *p == *q ) { ++p; ++q; }
+ while( *p == '/' ) ++p;
+ while( *q == '/' ) ++q;
+ return ( !*p && !*q );
+ }
+
+} // end namespace
+
+
+int decode( const std::string & archive_name, const Arg_parser & parser,
+ const int filenames, const bool listing )
+ {
+ const int infd = archive_name.size() ?
+ open_instream( archive_name ) : STDIN_FILENO;
+ if( infd < 0 ) return 1;
+
+ std::vector< bool > name_pending( parser.arguments(), false );
+ for( int i = 0; i < parser.arguments(); ++i )
+ {
+ const int code = parser.code( i );
+ if( code == 'C' && !listing )
+ {
+ const char * const filename = parser.argument( i ).c_str();
+ if( chdir( filename ) != 0 )
+ { show_file_error( filename, "Error changing working directory", errno );
+ return 1; }
+ }
+ if( !code ) name_pending[i] = true;
+ }
+
+ int retval = 0;
+ bool skipping = false;
+ while( true ) // process one member per iteration
+ {
+ uint8_t buf[header_size];
+ if( !archive_read( infd, buf, header_size ) ) return 2;
+ if( !verify_ustar_chksum( buf ) )
+ {
+ if( block_is_zero( buf, header_size ) ) break;
+ gretval = 2;
+ if( !skipping )
+ { skipping = true; show_error( "Skipping to next header." ); }
+ continue;
+ }
+ skipping = false;
+
+ const char * const header = (const char *)buf;
+ enum { max_filename_size = prefix_l + 1 + name_l + 1 };
+ char stored_name[max_filename_size];
+ int len = 0;
+ while( len < prefix_l && header[prefix_o+len] )
+ { stored_name[len] = header[prefix_o+len]; ++len; }
+ if( len && header[name_o] ) stored_name[len++] = '/';
+ for( int i = 0; i < name_l && header[name_o+i]; ++i )
+ { stored_name[len] = header[name_o+i]; ++len; }
+ while( len > 0 && stored_name[len-1] == '/' ) --len; // trailing '/'
+ stored_name[len] = 0;
+ const char * const filename = remove_leading_slash( stored_name );
+
+ bool skip = filenames > 0;
+ if( skip )
+ for( int i = 0; i < parser.arguments(); ++i )
+ if( parser.code( i ) == 0 &&
+ ( compare_prefix_dir( parser.argument( i ).c_str(), filename ) ||
+ compare_tslash( filename, parser.argument( i ).c_str() ) ) )
+ { skip = false; name_pending[i] = false; break; }
+
+ const Typeflag typeflag = (Typeflag)header[typeflag_o];
+ const unsigned long long file_size =
+ ( typeflag == tf_regular || typeflag == tf_hiperf ) ?
+ strtoull( header + size_o, 0, 8 ) : 0;
+ if( listing || skip )
+ retval = list_member( infd, filename, file_size, header, skip );
+ else
+ retval = extract_member( infd, filename, file_size, header );
+ if( retval ) return retval;
+ }
+
+ for( int i = 0; i < parser.arguments(); ++i )
+ if( parser.code( i ) == 0 && name_pending[i] )
+ {
+ show_file_error( parser.argument( i ).c_str(), "Not found in archive." );
+ if( gretval < 1 ) gretval = 1;
+ }
+ if( !retval && gretval )
+ { show_error( "Exiting with failure status due to previous errors." );
+ retval = gretval; }
+ return retval;
+ }