diff options
Diffstat (limited to '')
| -rwxr-xr-x | scripts/dpkg-source.pl | 671 |
1 files changed, 671 insertions, 0 deletions
diff --git a/scripts/dpkg-source.pl b/scripts/dpkg-source.pl new file mode 100755 index 0000000..63caeb2 --- /dev/null +++ b/scripts/dpkg-source.pl @@ -0,0 +1,671 @@ +#!/usr/bin/perl +# +# dpkg-source +# +# Copyright © 1996 Ian Jackson <ijackson@chiark.greenend.org.uk> +# Copyright © 1997 Klee Dienes <klee@debian.org> +# Copyright © 1999-2003 Wichert Akkerman <wakkerma@debian.org> +# Copyright © 1999 Ben Collins <bcollins@debian.org> +# Copyright © 2000-2003 Adam Heath <doogie@debian.org> +# Copyright © 2005 Brendan O'Dea <bod@debian.org> +# Copyright © 2006-2008 Frank Lichtenheld <djpig@debian.org> +# Copyright © 2006-2009,2012 Guillem Jover <guillem@debian.org> +# Copyright © 2008-2011 Raphaël Hertzog <hertzog@debian.org> +# +# 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 <https://www.gnu.org/licenses/>. + +use strict; +use warnings; + +use List::Util qw(any none); +use Cwd; +use File::Basename; +use File::Spec; + +use Dpkg (); +use Dpkg::Gettext; +use Dpkg::ErrorHandling; +use Dpkg::Arch qw(:operators); +use Dpkg::Deps; +use Dpkg::Compression; +use Dpkg::Conf; +use Dpkg::Control::Info; +use Dpkg::Control::Tests; +use Dpkg::Control::Fields; +use Dpkg::Substvars; +use Dpkg::Version; +use Dpkg::Vars; +use Dpkg::Changelog::Parse; +use Dpkg::Source::Format; +use Dpkg::Source::Package qw(get_default_diff_ignore_regex + set_default_diff_ignore_regex + get_default_tar_ignore_pattern); +use Dpkg::Vendor qw(run_vendor_hook); + +textdomain('dpkg-dev'); + +my $controlfile; +my $changelogformat; + +my $build_format; +my %options = ( + # Ignore files + tar_ignore => [], + diff_ignore_regex => '', + # Misc options + copy_orig_tarballs => 1, + no_check => 0, + no_overwrite_dir => 1, + require_valid_signature => 0, + require_strong_checksums => 0, +); + +# Fields to remove/override +my %remove; +my %override; + +my $substvars = Dpkg::Substvars->new(); +my $tar_ignore_default_pattern_done; +my $diff_ignore_regex = get_default_diff_ignore_regex(); + +my @options; +my @cmdline_options; +while (@ARGV && $ARGV[0] =~ m/^-/) { + my $arg = shift @ARGV; + + if ($arg eq '-b' or $arg eq '--build') { + setopmode('build'); + } elsif ($arg eq '-x' or $arg eq '--extract') { + setopmode('extract'); + } elsif ($arg eq '--before-build') { + setopmode('before-build'); + } elsif ($arg eq '--after-build') { + setopmode('after-build'); + } elsif ($arg eq '--commit') { + setopmode('commit'); + } elsif ($arg eq '--print-format') { + setopmode('print-format'); + report_options(info_fh => \*STDERR); # Avoid clutter on STDOUT + } else { + push @options, $arg; + } +} + +my $dir; +if (defined($options{opmode}) && + $options{opmode} =~ /^(build|print-format|(before|after)-build|commit)$/) { + if (not scalar(@ARGV)) { + usageerr(g_('--%s needs a directory'), $options{opmode}) + unless $1 eq 'commit'; + $dir = '.'; + } else { + $dir = File::Spec->catdir(shift(@ARGV)); + } + stat($dir) or syserr(g_('cannot stat directory %s'), $dir); + if (not -d $dir) { + error(g_('directory argument %s is not a directory'), $dir); + } + if ($dir eq '.') { + # . is never correct, adjust automatically + $dir = basename(getcwd()); + chdir '..' or syserr(g_("unable to chdir to '%s'"), '..'); + } + # --format options are not allowed, they would take precedence + # over real command line options, debian/source/format should be used + # instead + # --unapply-patches is only allowed in local-options as it's a matter + # of personal taste and the default should be to keep patches applied + my $forbidden_opts_re = { + 'options' => qr/^--(?:format=|unapply-patches$|abort-on-upstream-changes$)/, + 'local-options' => qr/^--format=/, + }; + foreach my $filename ('local-options', 'options') { + my $conf = Dpkg::Conf->new(); + my $optfile = File::Spec->catfile($dir, 'debian', 'source', $filename); + next unless -f $optfile; + $conf->load($optfile); + $conf->filter(remove => sub { $_[0] =~ $forbidden_opts_re->{$filename} }); + if (@$conf) { + info(g_('using options from %s: %s'), $optfile, join(' ', @$conf)) + unless $options{opmode} eq 'print-format'; + unshift @options, @$conf; + } + } +} + +while (@options) { + $_ = shift(@options); + if (m/^--format=(.*)$/) { + $build_format //= $1; + } elsif (m/^-(?:Z|-compression=)(.*)$/) { + my $compression = $1; + $options{compression} = $compression; + usageerr(g_('%s is not a supported compression'), $compression) + unless compression_is_supported($compression); + compression_set_default($compression); + } elsif (m/^-(?:z|-compression-level=)(.*)$/) { + my $comp_level = $1; + $options{comp_level} = $comp_level; + usageerr(g_('%s is not a compression level'), $comp_level) + unless compression_is_valid_level($comp_level); + compression_set_default_level($comp_level); + } elsif (m/^--threads-max=(.*)$/) { + my $threads = $1; + $options{comp_threads} = $threads; + compression_set_threads($threads); + } elsif (m/^-c(.*)$/) { + $controlfile = $1; + } elsif (m/^-l(.*)$/) { + $options{changelog_file} = $1; + } elsif (m/^-F([0-9a-z]+)$/) { + $changelogformat = $1; + } elsif (m/^-D([^\=:]+)[=:](.*)$/s) { + $override{$1} = $2; + } elsif (m/^-U([^\=:]+)$/) { + $remove{$1} = 1; + } elsif (m/^--diff-ignore$/) { + $options{diff_ignore_regex} = $diff_ignore_regex; + } elsif (m/^-(?:i|-diff-ignore=)(.*)$/) { + $options{diff_ignore_regex} = $1 ? $1 : $diff_ignore_regex; + } elsif (m/^--extend-diff-ignore=(.+)$/) { + $diff_ignore_regex .= "|$1"; + if ($options{diff_ignore_regex}) { + $options{diff_ignore_regex} .= "|$1"; + } + set_default_diff_ignore_regex($diff_ignore_regex); + } elsif (m/^-(?:I|-tar-ignore=)(.+)$/) { + push @{$options{tar_ignore}}, $1; + } elsif (m/^-(?:I|-tar-ignore)$/) { + unless ($tar_ignore_default_pattern_done) { + push @{$options{tar_ignore}}, get_default_tar_ignore_pattern(); + # Prevent adding multiple times + $tar_ignore_default_pattern_done = 1; + } + } elsif (m/^--no-copy$/) { + $options{copy_orig_tarballs} = 0; + } elsif (m/^--no-check$/) { + $options{no_check} = 1; + } elsif (m/^--no-overwrite-dir$/) { + $options{no_overwrite_dir} = 1; + } elsif (m/^--require-valid-signature$/) { + $options{require_valid_signature} = 1; + } elsif (m/^--require-strong-checksums$/) { + $options{require_strong_checksums} = 1; + } elsif (m/^-V(\w[-:0-9A-Za-z]*)[=:](.*)$/s) { + $substvars->set($1, $2); + } elsif (m/^-T(.*)$/) { + $substvars->load($1) if -e $1; + } elsif (m/^-(?:\?|-help)$/) { + usage(); + exit(0); + } elsif (m/^--version$/) { + version(); + exit(0); + } elsif (m/^-[EW]$/) { + # Deprecated option + warning(g_('-E and -W are deprecated, they are without effect')); + } elsif (m/^-q$/) { + report_options(quiet_warnings => 1); + $options{quiet} = 1; + } elsif (m/^--$/) { + last; + } else { + push @cmdline_options, $_; + } +} + +unless (defined($options{opmode})) { + usageerr(g_('need an action option')); +} + +if ($options{opmode} =~ /^(build|print-format|(before|after)-build|commit)$/) { + $options{ARGV} = \@ARGV; + $options{changelog_file} ||= "$dir/debian/changelog"; + $controlfile ||= "$dir/debian/control"; + + my %ch_options = (file => $options{changelog_file}); + $ch_options{changelogformat} = $changelogformat if $changelogformat; + my $changelog = changelog_parse(%ch_options); + my $control = Dpkg::Control::Info->new($controlfile); + + # <https://reproducible-builds.org/specs/source-date-epoch/> + $ENV{SOURCE_DATE_EPOCH} ||= $changelog->{timestamp} || time; + + # Select the format to use + if (not defined $build_format) { + my $format_file = "$dir/debian/source/format"; + if (-e $format_file) { + my $format = Dpkg::Source::Format->new(filename => $format_file); + $build_format = $format->get(); + } else { + warning(g_('no source format specified in %s, ' . + 'see dpkg-source(1)'), 'debian/source/format') + if $options{opmode} eq 'build'; + $build_format = '1.0'; + } + } + + my $srcpkg = Dpkg::Source::Package->new(format => $build_format, + options => \%options); + my $fields = $srcpkg->{fields}; + + $srcpkg->parse_cmdline_options(@cmdline_options); + + my @sourcearch; + my %archadded; + my @binarypackages; + + # Scan control info of source package + my $src_fields = $control->get_source(); + error(g_("%s doesn't contain any information about the source package"), + $controlfile) unless defined $src_fields; + my $src_sect = $src_fields->{'Section'} || 'unknown'; + my $src_prio = $src_fields->{'Priority'} || 'unknown'; + foreach (keys %{$src_fields}) { + my $v = $src_fields->{$_}; + if (m/^Source$/i) { + set_source_package($v); + $fields->{$_} = $v; + } elsif (m/^Uploaders$/i) { + ($fields->{$_} = $v) =~ s/\s*[\r\n]\s*/ /g; # Merge in a single-line + } elsif (m/^Build-(?:Depends|Conflicts)(?:-Arch|-Indep)?$/i) { + my $dep; + my $type = field_get_dep_type($_); + $dep = deps_parse($v, build_dep => 1, union => $type eq 'union'); + error(g_('cannot parse %s field'), $_) unless defined $dep; + my $facts = Dpkg::Deps::KnownFacts->new(); + $dep->simplify_deps($facts); + $dep->sort() if $type eq 'union'; + $fields->{$_} = $dep->output(); + } else { + field_transfer_single($src_fields, $fields); + } + } + + # Scan control info of binary packages + my @pkglist; + foreach my $pkg ($control->get_packages()) { + my $p = $pkg->{'Package'}; + my $sect = $pkg->{'Section'} || $src_sect; + my $prio = $pkg->{'Priority'} || $src_prio; + my $type = $pkg->{'Package-Type'} || + $pkg->get_custom_field('Package-Type') || 'deb'; + my $arch = $pkg->{'Architecture'}; + my $profile = $pkg->{'Build-Profiles'}; + + my $pkg_summary = sprintf('%s %s %s %s', $p, $type, $sect, $prio); + + $pkg_summary .= ' arch=' . join ',', split ' ', $arch; + + if (defined $profile) { + # Instead of splitting twice and then joining twice, we just do + # simple string replacements: + + # Remove the enclosing <> + $profile =~ s/^\s*<(.*)>\s*$/$1/; + # Join lists with a plus (OR) + $profile =~ s/>\s+</+/g; + # Join their elements with a comma (AND) + $profile =~ s/\s+/,/g; + $pkg_summary .= " profile=$profile"; + } + if (defined $pkg->{'Protected'} and $pkg->{'Protected'} eq 'yes') { + $pkg_summary .= ' protected=yes'; + } + if (defined $pkg->{'Essential'} and $pkg->{'Essential'} eq 'yes') { + $pkg_summary .= ' essential=yes'; + } + + push @pkglist, $pkg_summary; + push @binarypackages, $p; + foreach (keys %{$pkg}) { + my $v = $pkg->{$_}; + if (m/^Architecture$/) { + # Gather all binary architectures in one set. 'any' and 'all' + # are special-cased as they need to be the only ones in the + # current stanza if present. + if (debarch_eq($v, 'any') || debarch_eq($v, 'all')) { + push(@sourcearch, $v) unless $archadded{$v}++; + } else { + for my $a (split(/\s+/, $v)) { + error(g_("'%s' is not a legal architecture string " . + "in package '%s'"), $a, $p) + if debarch_is_illegal($a); + error(g_('architecture %s only allowed on its ' . + "own (list for package %s is '%s')"), + $a, $p, $a) + if $a eq 'any' or $a eq 'all'; + push(@sourcearch, $a) unless $archadded{$a}++; + } + } + } elsif (m/^(?:Homepage|Description)$/) { + # Do not overwrite the same field from the source entry + } else { + field_transfer_single($pkg, $fields); + } + } + } + unless (scalar(@pkglist)) { + error(g_("%s doesn't list any binary package"), $controlfile); + } + if (any { $_ eq 'any' } @sourcearch) { + # If we encounter one 'any' then the other arches become insignificant + # except for 'all' that must also be kept + if (any { $_ eq 'all' } @sourcearch) { + @sourcearch = qw(any all); + } else { + @sourcearch = qw(any); + } + } else { + # Minimize arch list, by removing arches already covered by wildcards + my @arch_wildcards = grep { debarch_is_wildcard($_) } @sourcearch; + my @mini_sourcearch = @arch_wildcards; + foreach my $arch (@sourcearch) { + if (none { debarch_is($arch, $_) } @arch_wildcards) { + push @mini_sourcearch, $arch; + } + } + @sourcearch = @mini_sourcearch; + } + $fields->{'Architecture'} = join(' ', @sourcearch); + $fields->{'Package-List'} = "\n" . join("\n", sort @pkglist); + + # Check if we have a testsuite, and handle manual and automatic values. + set_testsuite_fields($fields, @binarypackages); + + # Scan fields of dpkg-parsechangelog + foreach (keys %{$changelog}) { + my $v = $changelog->{$_}; + + if (m/^Source$/) { + set_source_package($v); + $fields->{$_} = $v; + } elsif (m/^Version$/) { + my ($ok, $error) = version_check($v); + error($error) unless $ok; + $fields->{$_} = $v; + } elsif (m/^Binary-Only$/) { + error(g_('building source for a binary-only release')) + if $v eq 'yes' and $options{opmode} eq 'build'; + } elsif (m/^Maintainer$/i) { + # Do not replace the field coming from the source entry + } else { + field_transfer_single($changelog, $fields); + } + } + + $fields->{'Binary'} = join(', ', @binarypackages); + # Avoid overly long line by splitting over multiple lines + if (length($fields->{'Binary'}) > 980) { + $fields->{'Binary'} =~ s/(.{0,980}), ?/$1,\n/g; + } + + if ($options{opmode} eq 'print-format') { + print $fields->{'Format'} . "\n"; + exit(0); + } elsif ($options{opmode} eq 'before-build') { + $srcpkg->before_build($dir); + exit(0); + } elsif ($options{opmode} eq 'after-build') { + $srcpkg->after_build($dir); + exit(0); + } elsif ($options{opmode} eq 'commit') { + $srcpkg->commit($dir); + exit(0); + } + + # Verify pre-requisites are met + my ($res, $msg) = $srcpkg->can_build($dir); + error(g_("can't build with source format '%s': %s"), $build_format, $msg) unless $res; + + # Only -b left + info(g_("using source format '%s'"), $fields->{'Format'}); + run_vendor_hook('before-source-build', $srcpkg); + # Build the files (.tar.gz, .diff.gz, etc) + $srcpkg->build($dir); + + # Write the .dsc + my $dscname = $srcpkg->get_basename(1) . '.dsc'; + info(g_('building %s in %s'), get_source_package(), $dscname); + $srcpkg->write_dsc(filename => $dscname, + remove => \%remove, + override => \%override, + substvars => $substvars); + exit(0); +} elsif ($options{opmode} eq 'extract') { + # Check command line + unless (scalar(@ARGV)) { + usageerr(g_('--%s needs at least one argument, the .dsc'), + $options{opmode}); + } + if (scalar(@ARGV) > 2) { + usageerr(g_('--%s takes no more than two arguments'), $options{opmode}); + } + my $dsc = shift(@ARGV); + if (-d $dsc) { + usageerr(g_('--%s needs the .dsc file as first argument, not a directory'), + $options{opmode}); + } + + # Create the object that does everything + my $srcpkg = Dpkg::Source::Package->new(filename => $dsc, + options => \%options); + + # Parse command line options + $srcpkg->parse_cmdline_options(@cmdline_options); + + # Decide where to unpack + my $newdirectory = $srcpkg->get_basename(); + $newdirectory =~ s/_/-/g; + if (@ARGV) { + $newdirectory = File::Spec->catdir(shift(@ARGV)); + if (-e $newdirectory) { + error(g_('unpack target exists: %s'), $newdirectory); + } + } + + # Various checks before unpacking + unless ($options{no_check}) { + if ($srcpkg->is_signed()) { + $srcpkg->check_signature(); + } else { + if ($options{require_valid_signature}) { + error(g_("%s doesn't contain a valid OpenPGP signature"), $dsc); + } else { + warning(g_('extracting unsigned source package (%s)'), $dsc); + } + } + $srcpkg->check_checksums(); + } + + # Unpack the source package (delegated to Dpkg::Source::Package::*) + info(g_('extracting %s in %s'), $srcpkg->{fields}{'Source'}, $newdirectory); + $srcpkg->extract($newdirectory); + + exit(0); +} + +sub set_testsuite_fields +{ + my ($fields, @binarypackages) = @_; + + my $testsuite_field = $fields->{'Testsuite'} // ''; + my %testsuite = map { $_ => 1 } split /\s*,\s*/, $testsuite_field; + if (-e "$dir/debian/tests/control") { + error(g_('test control %s is not a regular file'), + 'debian/tests/control') unless -f _; + $testsuite{autopkgtest} = 1; + + my $tests = Dpkg::Control::Tests->new(); + $tests->load("$dir/debian/tests/control"); + + set_testsuite_triggers_field($tests, $fields, @binarypackages); + } elsif ($testsuite{autopkgtest}) { + warning(g_('%s field contains value %s, but no tests control file %s'), + 'Testsuite', 'autopkgtest', 'debian/tests/control'); + delete $testsuite{autopkgtest}; + } + $fields->{'Testsuite'} = join ', ', sort keys %testsuite; +} + +sub set_testsuite_triggers_field +{ + my ($tests, $fields, @binarypackages) = @_; + my %testdeps; + + # Never overwrite a manually defined field. + return if $fields->{'Testsuite-Triggers'}; + + foreach my $test ($tests->get()) { + if (not exists $test->{Tests} and not exists $test->{'Test-Command'}) { + error(g_('test control %s is missing %s or %s field'), + 'debian/tests/control', 'Tests', 'Test-Command'); + } + + next unless $test->{Depends}; + + my $deps = deps_parse($test->{Depends}, use_arch => 0, tests_dep => 1); + deps_iterate($deps, sub { $testdeps{$_[0]->{package}} = 1 }); + } + + # Remove our own binaries and its meta-depends variant. + foreach my $pkg (@binarypackages, qw(@)) { + delete $testdeps{$pkg}; + } + $fields->{'Testsuite-Triggers'} = join ', ', sort keys %testdeps; +} + +sub setopmode { + my $opmode = shift; + + if (defined($options{opmode})) { + usageerr(g_('two commands specified: --%s and --%s'), + $options{opmode}, $opmode); + } + $options{opmode} = $opmode; +} + +sub print_option { + my $opt = shift; + + my $help = gettext($opt->{help}); + if (length $opt->{name} > 25) { + return sprintf " %-25s\n%s%s.\n", $opt->{name}, ' ' x 27, $help; + } else { + return sprintf " %-25s%s.\n", $opt->{name}, $help; + } +} + +sub get_format_help { + $build_format //= '1.0'; + + my $srcpkg = Dpkg::Source::Package->new(format => $build_format); + + my @cmdline = $srcpkg->describe_cmdline_options(); + return '' unless @cmdline; + + my $help_build = my $help_extract = ''; + my $help; + + foreach my $opt (@cmdline) { + $help_build .= print_option($opt) if $opt->{when} eq 'build'; + $help_extract .= print_option($opt) if $opt->{when} eq 'extract'; + } + + if ($help_build) { + $help .= "\n"; + $help .= "Build format $build_format options:\n"; + $help .= $help_build || C_('source options', '<none>'); + } + if ($help_extract) { + $help .= "\n"; + $help .= "Extract format $build_format options:\n"; + $help .= $help_extract || C_('source options', '<none>'); + } + + return $help; +} + +sub version { + printf g_("Debian %s version %s.\n"), $Dpkg::PROGNAME, $Dpkg::PROGVERSION; + + print g_(' +This is free software; see the GNU General Public License version 2 or +later for copying conditions. There is NO warranty. +'); +} + +sub usage { + printf g_( +'Usage: %s [<option>...] <command>') + . "\n\n" . g_( +'Commands: + -x, --extract <filename>.dsc [<output-dir>] + extract source package. + -b, --build <dir> build source package. + --print-format <dir> print the format to be used for the source package. + --before-build <dir> run the corresponding source package format hook. + --after-build <dir> run the corresponding source package format hook. + --commit [<dir> [<patch-name>]] + store upstream changes in a new patch.') + . "\n\n" . g_( +"Build options: + -c<control-file> get control info from this file. + -l<changelog-file> get per-version info from this file. + -F<changelog-format> force changelog format. + --format=<source-format> set the format to be used for the source package. + -V<name>=<value> set a substitution variable. + -T<substvars-file> read variables here. + -D<field>=<value> override or add a .dsc field and value. + -U<field> remove a field. + -i, --diff-ignore[=<regex>] + filter out files to ignore diffs of + (defaults to: '%s'). + -I, --tar-ignore[=<pattern>] + filter out files when building tarballs + (defaults to: %s). + -Z, --compression=<compression> + select compression to use (defaults to '%s', + supported are: %s). + -z, --compression-level=<level> + compression level to use (defaults to '%d', + supported are: '1'-'9', 'best', 'fast')") + . "\n\n" . g_( +"Extract options: + --no-copy don't copy .orig tarballs + --no-check don't check signature and checksums before unpacking + --no-overwrite-dir do not overwrite directory on extraction + --require-valid-signature abort if the package doesn't have a valid signature + --require-strong-checksums + abort if the package contains no strong checksums + --ignore-bad-version allow bad source package versions.") + . "\n" . + get_format_help() + . "\n" . g_( +'General options: + --threads-max=<threads> + use at most <threads> with compressor. + -q quiet mode. + -?, --help show this help message. + --version show the version.') + . "\n\n" . g_( +'Source format specific build and extract options are available; +use --format with --help to see them.') . "\n", + $Dpkg::PROGNAME, + get_default_diff_ignore_regex(), + join(' ', map { "-I$_" } get_default_tar_ignore_pattern()), + compression_get_default(), + join(' ', compression_get_list()), + compression_get_default_level(); +} |