fink-virtual-pkgs.in

#! /usr/bin/perl -w
#
# fink-virtual-pkgs
# Copyright (c) 2001 Christoph Pfisterer
# Copyright (c) 2001-2020 The Fink Package Manager Team
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA.
#

require 5.008_001;  # perl 5.8.1 or newer required
use strict;
use Getopt::Long;
use File::Temp qw/ tempfile /;
use Fcntl;

my $standalone = 0;
my $basepath = "@BASEPATH@";
my $libpath = "@LIBPATH@";
my $tmpfile = 0;
my $config;

our $VERSION = 1.28;

UseFinkModules();
Getopt::Long::Configure(qw(bundling ignore_case require_order));
my ($dlist, $hash, $pkgname, @versions, $field, $provides);
my %options = 
   (
		"apt" => 0,
		"debug" => 0,
		"dpkg" => 0,
		"outfile" => undef,
   );
GetOptions(
	'apt|a' => \$options{apt},
	'debug' => \$options{debug},
	'dpkg|d' => \$options{dpkg},
	'outfile|o=s' => \$options{outfile},
	'help|h' => \&usage,
	'version|v' => \&version,
	) or die "Unknown option\n";
if ($options{dpkg} and $options{apt}) {
	die "Can only specify one option dpkg or apt\n";
}
if (defined $options{outfile}) {
	# "-" as explicit request for stdout
	undef $options{outfile} if $options{outfile} eq '-';
} else {
	# legacy default behavior for apt mode
	$options{outfile} = '/tmp/finkaptstatus' if $options{apt};
}
if (defined $options{outfile}) {
	$tmpfile = tempfile();
	sysopen(FH, $tmpfile, O_WRONLY | O_EXCL | O_CREAT) || die "Can not open file $tmpfile for writing: $!\n";
	select FH;
}
if ($standalone == 0) {
	$dlist = Fink::VirtPackage->list(%options);
	foreach $pkgname (sort keys %$dlist) {
		$hash = $dlist->{$pkgname};
		next unless (exists $hash->{status} and $hash->{status} =~ /^\S+\s+ok\s+virtual$/i);
		if ($options{dpkg}) {
			if (@versions = parse_fullversion($hash->{version}) and exists $hash->{status} and $hash->{status} =~ /^\S+\s+ok\s+virtual$/i) {
				# columns: package, epoch, version, revision
				printf "%s\t%lu\t%s\t%s\n",$hash->{package},$versions[0],$versions[1],$versions[2];
				# for provides we tell dpkg about them with the version as zero
				if (exists $hash->{provides})
				{
					foreach $provides (split /,/,$hash->{provides})
					{
						$provides =~ s/\s+//gs;
						print "$provides\t0\t0\t0\n";
					}
				}
			}
		} else {
			# The following code tries very hard to exactly match the output in the dpkg
			# status file. This is necessary to make sure that (the new) apt works
			# correctly. Thus, be very careful when changing any of this code.
			print "Package: ".$hash->{package}."\n";
			print "Status: ".$hash->{status}."\n";
			print "Priority: optional\n";
			print "Architecture: ".$config->param('Debarch')."\n";
			print "Version: ".$hash->{version}."\n";
			print "Maintainer: ".$hash->{maintainer}."\n";
			foreach $field (keys %$hash)
			{
				next if ($field =~ /^(package|status|version|descdetail|compilescript|homepage|maintainer)$/);
				if ($field eq "description") {
					print "Description: ".$hash->{'description'}."\n";
					if ($hash->{'descdetail'}) {
						my $descdetail = $hash->{'descdetail'};
						chomp($descdetail);
						my @descdetails;
						foreach my $line (split("\n", $descdetail)) {
							if ($line eq "" || $line =~ /^[\s|\t]+?$/) {
								$line = ".";
							}
							$line = " ".$line;
							push @descdetails, $line;
						}
						$descdetail = join("\n", @descdetails);
						print $descdetail."\n";
					}
					if ($hash->{'homepage'}) {
						print " .\n";
						print " Web site: ".$hash->{'homepage'}."\n";
					}
					printf " .\n";
					printf " Maintainer: ".$hash->{'maintainer'}."\n";
				} else {
					printf ucfirst $field.": ".$hash->{$field}."\n";
				}
			}
			print "\n";
		}
	}
}
else
{
# We are running without fink modules, so just kernel and macOS pkgs
	my $macosx_version = 0;
	if (-x "/usr/bin/sw_vers") {
		open(SW_VERS, "/usr/bin/sw_vers |") or die "Couldn't determine system version: $!\n";
		while (<SW_VERS>) {
			chomp;
			if (/(ProductVersion\:)\s*([^\s]*)/) {
				$macosx_version = $2;
				last;
			}
		}
	}
	if ($options{dpkg})
	{
		# columns: package, epoch, version, revision
		# for provides we tell dpkg about them with the version as zero
		printf "%s\t0\t%s\t1\n", lc((uname())[0]), lc((uname())[2]);
		print "kernel\t0\t0\t0\n";
		if ($macosx_version ne 0) {
			printf "macosx\t0\t%s\t1\n",$macosx_version;
		}
	}
	else
	{
		print "Package: ".lc((uname())[0])."\n";
		print "Status: install ok virtual\n";
		print "Version: ".lc((uname())[2])."-1\n", ;
		print "Provides: kernel\n\n";
		if ($macosx_version ne 0) {
			print "Package: macosx\n";
			print "Status: install ok virtual\n";
			print "Version: ".$macosx_version."-1\n", ;
		}
	}
}
if (defined $options{outfile}) {
	select STDOUT;
	close FH;

	if ($tmpfile) {
		rename $tmpfile, $options{outfile} || die "Can not rename $tmpfile to $options{outfile}: $!\n";
	}
}

sub version {
	print "$0 revision $VERSION\n";
	if ($standalone) {
		print "\t(running in standalone mode, no Fink/Fink::VirtPackage available)\n";
	} else {
		print "\tFink version ", Fink::FinkVersion->fink_version(), "\n";
		print "\tFink::VirtPackage revision ", $Fink::VirtPackage::VERSION, "\n";
	}

	exit 0;
}

sub usage {
	print <<END;
usage: $0 [--debug] [-a|--apt] [-d|--dpkg] [-o|--outfile <filename>] [-h|--help] [-v|--version]

	--debug       Print debugging info to STDERR
	-a/--apt      [called by apt, for internal use only]
	-d/--dpkg     [called by dpkg, for internal use only]
	-o/--outfile  Send output to given filename ("-" to force stdout)
	-h/--help     This help
	-v/--version  Print the version

END
	exit 0;
}

sub UseFinkModules {
	# Be careful about using fink modules
	eval { 
        die unless -d "$libpath";
        require lib;
        import lib "$libpath";

		require Fink::FinkVersion;
		require Fink::VirtPackage;
		require Fink::Services;
		import Fink::Services qw(parse_fullversion read_config)
	};

	$standalone = 1 if $@;

	# read the configuration file
	if ($standalone != 1)
	{
		my $configpath = "$basepath/etc/fink.conf";
		if (-f $configpath) {
			$config = read_config($configpath,
                                              { Basepath => "$basepath" }
                                             );
		} else {
			$standalone=1;
		}
	}

	if ($standalone == 1)
	{
		require POSIX;
		import POSIX qw(uname);
	}

}