bloat

Bloat is a basic Perl script to allow you to easily decompress files from many formats.

			my @processedline = split(/\ .*\ /,$line);	# HACK ALERT!!!
			if ($processedline[1] !~ /\//) {		# Hack Alert!!!! Line 2
				$hasitgotstuffoutofsubdirs = 1;
				$lastfile = $processedline[1];
			} elsif (($processedline[1] =~ /^$lastfile/) && ($hasitgotstuffoutofsubdirs = 1)) {
				$hasitgotstuffoutofsubdirs = 0;
			}
		} elsif ($input[1] eq "infoziplike") {
			my @processedline = split(/\ .*\ /,$line);	# 2nd Hack Alert.....
			if (($processedline[1] !~ /\.zip/i) && ($processedline[1] !~ /\.war/i) && ($processedline[1] !~ /\.jar/i) && ($processedline[1] !~ /\.ear/i) && ($processedline[1] !~ /\.xpi/i) && ($processedline[1] !~ /Name/) && ($processedline[1] !~ /----/) && ($processedline[1] !~ /files/)) { # I conclude that InfoZIP was not designed to be used by scripts :/
				if ($processedline[1] !~ /\//) {	# Wheeeee!
					$hasitgotstuffoutofsubdirs = 1;
				}
			}
		} elsif ($input[1] eq "acelike") {
			if ($line =~ /^\d{2,2}\.\d{2,2}\.\d{2,2}/) {	# Checks for the date unace puts at the beginning of it.
				if ($line !~ /\//) {			# The only slashes are in the path.
					$hasitgotstuffoutofsubdirs = 1;
				}
			}	
		}	
	}
	return $hasitgotstuffoutofsubdirs;		
}

sub stripSlashes {
	# This sub strips slashes from a slashed filename.
	my $filename = $_[0];
	$filename =~ s/\\\\/\\/sg;	# Replace "\\" with "\"
	$filename =~ s/\\\(/\(/sg;	# Replace "\(" with "("
	$filename =~ s/\\\)/\)/sg;	# Replace "\)" with ")"
	$filename =~ s/\\ / /sg;	# Replace "\ " with " "
	$filename =~ s/\\\'/\'/sg;	# Replace "\'" with "'"
	$filename =~ s/\\\"/\"/sg;	# Replace '\"' with '"'
	$filename =~ s/\\\&/\&/sg;	# "\&", "&"...
	return $filename;
}

sub extractFile {
	my @input = @_;
	my $getcontents = $input[0];
	my $type = $input[1];
	my $longtype = $input[2];
	my $extractcmd = $input[3];
	my @fileext = split(/o_O/, $input[4]);				# Look, I told you before, let me have some fun damnit!
	my $checksdir = $input[5];
	my $custcmd = $input[6];
        my $mknewdir = $input[7];
	my $verbose = $input[8];
	my $filename = $input[9];

	my $shortfilename = &stripSlashes($filename);
	$shortfilename =~ s/.*\/(.+?)$/$1/;

	my $doneextract = 0;
	my $error = 0;

	if (!$verbose) {
		$devnull = ">/dev/null";						# Stop shutting up output!
	}

	$extractcmd =~ s/&&/$devnull &&/isg;

	if ($mknewdir) {
		my $dirname = $filename;
		$dirname = &stripSlashes($dirname);
		$dirname =~ s/.*\///sg;		# Cut out any paths
		foreach (@fileext) {
			$dirname =~ s/$_$//isg;
		}
		mkdir $dirname;
		chdir $dirname;
	}

	if (($checkforsubdirs) && ($checksdir)) {
		print $strings{$locale}{checkingarchive};
		my $hasnonsubdirs = &checkForSubdirs($getcontents, $type, $filename);
		if ($hasnonsubdirs) {
			my $dirname = $filename;			# Seems familiar?
			$dirname = &stripSlashes($dirname);
			$dirname =~ s/.*\///sg;		# Cut out any paths
			foreach (@fileext) {
				$dirname =~ s/$_$//isg;
			}
			mkdir $dirname;
			chdir $dirname;
			if ($custcmd) {
				print $strings{$locale}{custcmdnewdirextract}->($longtype,$dirname,$shortfilename);
				$filename = "";				# Appending filename is st00pid as it'll fsck it up. Yeah, I know, bloat fscking something up isn't uncommon, but you know what I mean...
			} else { 
				print $strings{$locale}{newdirextract}->($longtype,$dirname,$extractcmd,$shortfilename);
			}
			if (system("$extractcmd $filename $devnull") ne 0) {
				$doneextract = 0;
				$error = 1;
			} else {
				$doneextract = 1;
			}
		}
	}

	if (!$doneextract && !$error) {
		if ($custcmd) {
			print $strings{$locale}{custcmdextract}->($longtype,$shortfilename);
			$filename = "";
		} else {
			print $strings{$locale}{extract}->($longtype,$extractcmd,$shortfilename);
		}

		if (system("$extractcmd $filename $devnull") ne 0) {
			$doneextract = 0;
			$error = 1;
		} else {
			$doneextract = 1;
		}
	}

	if ($doneextract && !$error) {
		return 0;
	} else {
		return 1;
	}
}

sub getFileType {
	my $filetype = $_[0];
	my $filetypecheck = 0;

	# Symbols!
	if ($filetype =~ s/.*_$/mscompress/is)		{ $filetypecheck = 1 };	# MS Compress
	# Numbers!
	if ($filetype =~ s/.*\.7z$/7z/is)		{ $filetypecheck = 1 };	# 7-Zip.
	# A
	if ($filetype =~ s/.*\.a$/ar/is)		{ $filetypecheck = 1 };	# GNU AR file
	if ($filetype =~ s/.*\.ace$/ace/is)		{ $filetypecheck = 1 };	# ACE archive.
	if ($filetype =~ s/.*\.arj/arj/is) 		{ $filetypecheck = 1 };	# ARJ format.
	# B

	# C

	# D
	if ($filetype =~ s/.*\.deb$/deb/is) 		{ $filetypecheck = 1 };	# Debian package
	# E
	if ($filetype =~ s/.*\.ear$/zip/is) 		{ $filetypecheck = 1 };	# Enterprise Archive -> Zip
	if ($filetype =~ s/.*\.exe$/exe/is) 		{ $filetypecheck = 1 };	# EXE. Hmm. Let's treat as zip, as that is the most common format.
	# F

	# G

	# H

	# I

	# J
	if ($filetype =~ s/.*\.jar$/zip/is) 		{ $filetypecheck = 1 };	# JAR file (well, it's a ZIP :P)
	# K

	# L
	if ($filetype =~ s/.*\.lha/lha/is) 		{ $filetypecheck = 1 };	# LHA
	if ($filetype =~ s/.*\.lzh/lha/is) 		{ $filetypecheck = 1 };	# LHA, again
	# M

	# N

	# O

	# P
	if ($filetype =~ s/.*\.package$/autopackage/is) { $filetypecheck = 1 };	# Autopackage File.
	if ($filetype =~ s/.*\.pk4$/zip/is) { $filetypecheck = 1 };	# Doom 3 resources
	# Q

	# R
	if ($filetype =~ s/.*\.r\d{2}$/rar/is)		{ $filetypecheck = 1 }; # Multi-part RAR archives because HauntedUnix is lazy.
	if ($filetype =~ s/.*\.rar$/rar/is) 		{ $filetypecheck = 1 };	# Listen to the lion RAR! *ahem* sorry
	if ($filetype =~ s/.*\.rpm$/rpm/is) 		{ $filetypecheck = 1 };	# RPM!
	# S

	# T
	if ($filetype =~ s/.*\.tar/tar/is) 		{ $filetypecheck = 1 };	# Get rid of the crap before tar
	    if ($filetype =~ s/tar\./tar\//is) 		{ $filetypecheck = 1 };	# Make tar.xx change to tar/xx 
	if ($filetype =~ s/tar\/bz2/tar\/bzip2/is) 	{ $filetypecheck = 1 };	# tar/bz2 2 tar/bzip2
	if ($filetype =~ s/tar\/gz$/tar\/gzip/is) 	{ $filetypecheck = 1 };	# tar/gz changes to tar/gzip
	if ($filetype =~ s/.*\.taz$/tar\/z/is) 		{ $filetypecheck = 1 };	# .taz -> .tar.Z
	if ($filetype =~ s/.*\.tbz$/tar\/bzip2/is) 	{ $filetypecheck = 1 };	# tbz = tar/bzip2, apparently
	if ($filetype =~ s/.*\.tbz2$/tar\/bzip2/is) 	{ $filetypecheck = 1 };	# tbz2 = tar/bzip2 as well.....
	if ($filetype =~ s/.*\.tgz$/tar\/gzip/is) 	{ $filetypecheck = 1 };	# Change .tgz to tar/gzip
	# U
	if ($filetype =~ s/.*\.umod/u1mod/is) 		{ $filetypecheck = 1 };	# Unreal 1 [UT] mod
	if ($filetype =~ s/.*\.uz2/uz2/is)		{ $filetypecheck = 1 }; # UT2003/4 compressed file
	# V

	# W
	if ($filetype =~ s/.*\.war$/zip/is) 		{ $filetypecheck = 1 };	# Web Application Archive - a JAR
	if ($filetype =~ s/.*\.wbm$/webmin/is) 		{ $filetypecheck = 1 };	# Webmin Module - it's USUALLY a Tar/GZ file...
	if ($filetype =~ s/.*\.wbt$/webmin/is) 		{ $filetypecheck = 1 };	# Webmin Theme - see above :P
	if ($filetype =~ s/.*\.wsz$/zip/is)		{ $filetypecheck = 1 };	# Winamp Skin - zip.
	# X
	if ($filetype =~ s/.*\.xpi$/zip/is) 		{ $filetypecheck = 1 };	# Mozilla Installer; a ZIP file
	# Y

	# Z
	if ($filetype =~ s/.*\.z$/compress/is) 		{ $filetypecheck = 1 };	# A .Z (compress) file
	if ($filetype =~ s/.*\.zip$/zip/is) 		{ $filetypecheck = 1 };	# PKZip file...
	if ($filetype =~ s/.*\.zoo$/zoo/is) 		{ $filetypecheck = 1 };	# The third Google result for "zoo archive" (at time of writing) was a great source of help!
	# END
	if ($filetype =~ s/.*\.bz2$/bzip2/is) 		{ $filetypecheck = 1 };	# BZip2 = bzip2
	if ($filetype =~ s/.*\.gz$/gzip/is) 		{ $filetypecheck = 1 };	# GNUZip = gzip

	if (!$dontusemimetypedetection && !$filetypecheck) {
		$filetype = &getMimeType($filetype);	# Ooh, mime-type, shiny
	}

	return $filetype;
}

sub getMimeType {
	my $mimename = shift;
	my $mimetype = `file -i $mimename 2>/dev/null`;
	if ($mimetype =~ /application\/x-gzip/) {	# Can `file` look inside any other archives?
		$mimetype = `$loc{file} -i -z $mimename 2> /dev/null`;		# Looks inside gzipped files
	}
	chomp($mimetype);
	$mimetype =~ s/$filename: //s;

	if ($mimetype =~ /application\/x-tar.*application\/x-gzip/) {	# Tar/GZ, yay.
		$mimetype = "tar/gzip";
	} elsif ($mimetype =~ /application\/x-arj/) {	# ARJ. _MUST_ be above ar.
		$mimetype = "arj";
	} elsif ($mimetype =~ /application\/x-ar/) {	# RH 7.2 - application/x-ar. Slack 9.0 - application/x-archive. Bah. This matches 'em both.
		$mimetype = "ar";
	} elsif ($mimetype =~ /application\/x-autopackage/) {
		$mimetype = "autopackage";
	} elsif (($mimetype =~ /application\/x-tar/) || ($mimetype =~ /application\/x-gtar/)) {
		$mimetype = "tar";
	} elsif ($mimetype =~ /application\/x-gzip/) {	# GNUzip has a phobia of anything except files ending in .gz...
		$mimetype = "gzip";
	} elsif ($mimetype =~ /application\/x-zip/) {	# Zip. Yay.
		$mimetype = "zip";
	} elsif ($mimetype =~ /application\/x-rar/) {	# RAR!
		$mimetype = "rar";
	} elsif ($mimetype =~ /application\/x-lha/) {	# See if you can guess?
		$mimetype = "lha";
	} elsif ($mimetype =~ /application\/x-rpm/) {	# RPM, wheee....
		$mimetype = "rpm";
	} elsif ($mimetype =~ /application\/x-compress/) {		# Compressed file. Kinda like bzip2 below...
		if ($gofortar) {
			$mimetype = "tar/compress";
		} else {
			$mimetype = "compress";
		}

		$dodgyresult = 1;
	} elsif ($mimetype =~ /application\/x-bzip2/) {
		if ($gofortar) {
			$mimetype = "tar/bzip2";
		} else {
			$mimetype = "bzip2";
		}

		$dodgyresult = 1;
	} elsif ($mimetype =~ /application\/octet-stream/) {		# *sigh*
		$mimetype = `$loc{file} $mimename 2>/dev/null`;
		if ($mimetype =~ /bzip2/) {		
			if ($gofortar) {
				$mimetype = "tar/bzip2";		# Go for tar!
			} else {
				$mimetype = "bzip2";			# Will work all the time, but can leave odd files
			}

			$dodgyresult = 1;
		} elsif ($mimetype =~ /rar/i) {
			$mimetype = "rar";
		}
	}

	return($mimetype);
}
		
sub getExtractor {					# Find out t3h 3xtract0rz
							# Ordered by utility name

	my $filetype = $_[0];

	### Always Checked ### 
	# Meow...
	if (`echo "OMG" | $loc{cat}` =~ /OMG/) {
	} elsif (`echo "OMG" | /bin/cat` =~ /OMG/) {
		$loc{cat} = "/bin/cat";
	} elsif (!$nowarn || $check) {
		$loc{cat} = "/bin/true";
		$stop = 1;
		$util = "cat";
		print STDERR $strings{$locale}{cmdnotfound}->($util);
		print STDERR $strings{$locale}{cmdlocdontknow}->($util);
	}

	# File
	if (`$loc{file} -v 2> /dev/null`) {
	} elsif (`/usr/bin/file -v 2> /dev/null`) {
		$loc{file} = "/usr/bin/file";
	} elsif (!$nowarn || $check) {
		$loc{file} = "/bin/true";
		$stop = 1;
		$util = "file";
		print STDERR $strings{$locale}{cmdnotfound}->($util);
		print STDERR $strings{$locale}{cmdlocdontknow}->($util);
	}

	### # ###
	# 7zip
	if (($filetype =~ /^7z$/is) || ($check)) {