X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=dgit;h=9d2d8769974355e5fcd7135225295cbb589d1c87;hp=77a9bb6025306fda3d3661a82460c73542669d89;hb=25f567819dab569d2f9bbe31626f32197b799e7d;hpb=7c379b92923ec62699b0943831c9085c2e8e1821

diff --git a/dgit b/dgit
index 77a9bb60..9d2d8769 100755
--- a/dgit
+++ b/dgit
@@ -27,17 +27,25 @@ use File::Path;
 use File::Basename;
 use Dpkg::Version;
 use POSIX;
+use IPC::Open2;
+use File::Temp;
+
+our $our_version = 'UNRELEASED'; ###substituted###
 
 our $isuite = 'unstable';
 our $idistro;
 our $package;
+our @ropts;
 
 our $sign = 1;
 our $dryrun = 0;
 our $changesfile;
 our $new_package = 0;
+our $ignoredirty = 0;
+our $noquilt = 0;
 our $existing_package = 'dpkg';
 our $cleanmode = 'dpkg-source';
+our $we_are_responder;
 
 our %format_ok = map { $_=>1 } ("1.0","3.0 (native)","3.0 (quilt)");
 
@@ -45,7 +53,10 @@ our (@git) = qw(git);
 our (@dget) = qw(dget);
 our (@dput) = qw(dput);
 our (@debsign) = qw(debsign);
+our (@gpg) = qw(gpg);
 our (@sbuild) = qw(sbuild -A);
+our (@ssh) = qw(ssh);
+our (@dgit) = qw(dgit);
 our (@dpkgbuildpackage) = qw(dpkg-buildpackage -i\.git/ -I.git);
 our (@dpkgsource) = qw(dpkg-source -i\.git/ -I.git);
 our (@dpkggenchanges) = qw(dpkg-genchanges);
@@ -55,7 +66,10 @@ our (@changesopts) = ('');
 our %opts_opt_map = ('dget' => \@dget,
 		     'dput' => \@dput,
 		     'debsign' => \@debsign,
+                     'gpg' => \@gpg,
                      'sbuild' => \@sbuild,
+                     'ssh' => \@ssh,
+                     'dgit' => \@dgit,
                      'dpkg-source' => \@dpkgsource,
                      'dpkg-buildpackage' => \@dpkgbuildpackage,
                      'dpkg-genchanges' => \@dpkggenchanges,
@@ -83,7 +97,16 @@ sub debiantag ($) {
     return "debian/$v";
 }
 
-sub dscfn ($) { return "${package}_$_[0].dsc"; }
+sub stripepoch ($) {
+    my ($vsn) = @_;
+    $vsn =~ s/^\d+\://;
+    return $vsn;
+}
+
+sub dscfn ($) {
+    my ($vsn) = @_;
+    return "${package}_".(stripepoch $vsn).".dsc";
+}
 
 sub changesopts () { return @changesopts[1..$#changesopts]; }
 
@@ -103,6 +126,138 @@ sub fetchspec () {
     return  "+".rrref().":".lrref();
 }
 
+#---------- remote protocol support, common ----------
+
+# remote push initiator/responder protocol:
+#  < dgit-remote-push-ready [optional extra info ignored by old initiators]
+#
+#  > file begin parsed-changelog
+#  [indicates that output of dpkg-parsechangelog follows]
+#  > data-block NBYTES
+#  > [NBYTES bytes of data (no newline)]
+#  [maybe some more blocks]
+#  > data-end
+#
+#  > file begin dsc
+#  [etc]
+#
+#  > file begin changes
+#  [etc]
+#
+#  > want signed-tag
+#  [indicates that signed tag is wanted]
+#  < data-block NBYTES
+#  < [NBYTES bytes of data (no newline)]
+#  [maybe some more blocks]
+#  < data-end
+#  < files-end
+#
+#  > want signed-changes-dsc
+#  < data-block NBYTES    [transfer of signed changes]
+#  [etc]
+#  < data-block NBYTES    [transfer of signed dsc]
+#  [etc]
+#  < files-end
+#
+#  > complete
+
+sub badproto ($$) {
+    my ($fh, $m) = @_;
+    fail "connection lost: $!" if $fh->error;
+    fail "connection terminated" if $fh->eof;
+    fail "protocol violation; $m not expected";
+}
+
+sub protocol_expect ($&) {
+    my ($fh, $match) = @_;
+    local $_;
+    $_ = <$fh>;
+    defined && chomp or badproto $fh, "eof";
+    return if &$match;
+    badproto $fh, "\`$_'";
+}
+
+sub protocol_send_file ($$) {
+    my ($fh, $ourfn) = @_;
+    open PF, "<", $ourfn or die "$ourfn: $!";
+    for (;;) {
+	my $d;
+	my $got = read PF, $d, 65536;
+	die "$ourfn: $!" unless defined $got;
+	last if $got;
+	print $fh "data-block ".length($d)."\n" or die $!;
+	print $d or die $!;
+    }
+    print $fh "data-end\n" or die $!;
+    close PF;
+}
+
+sub protocol_read_bytes ($$) {
+    my ($fh, $nbytes) = @_;
+    $nbytes =~ m/^\d{1,6}$/ or badproto \*RO, "bad byte count";
+    my $d;
+    my $got = read $fh, $d, $nbytes;
+    $got==$nbytes or badproto $fh, "eof during data block";
+    return $d;
+}
+
+sub protocol_receive_file ($$) {
+    my ($fh, $ourfn) = @_;
+    open PF, ">", $ourfn or die "$ourfn: $!";
+    for (;;) {
+	protocol_expect \*STDIN, { m/^data-block (.*})$|data-end$/ };
+	length $1 or last;
+	my $d = protocol_read_bytes \*STDIN, $1;
+	print PF $d or die $!;
+    }
+}
+
+#---------- remote protocol support, responder ----------
+
+sub responder_send_command ($) {
+    my ($command) = @_;
+    return unless $we_are_responder;
+    # called even without $we_are_responder
+    print DEBUG "<< $command\n";
+    print $command, "\n" or die $!;
+}    
+
+sub responder_send_file ($$) {
+    my ($keyword, $ourfn) = @_;
+    return unless $we_are_responder;
+    responder_send_command "file-begin $keyword";
+    protocol_send_file \*STDOUT, $ourfn;
+}
+
+sub responder_receive_files ($@) {
+    my ($keyword, @ourfns) = @_;
+    die unless $we_are_responder;
+    responder_send_command "want $keyword";
+    foreach my $fn (@ourfns) {
+	protocol_receive_file \*STDIN, $fn;
+    }
+    protocol_expect \*STDIN, { m/^files-end$/ };
+}
+
+#---------- remote protocol support, initiator ----------
+
+sub initiator_expect (&) {
+    my ($match) = @_;
+    protocol_expect \*RO, &$match;
+}
+
+#---------- end remote code ----------
+
+sub progress {
+    if ($we_are_responder) {
+	my $m = join '', @_;
+	responder_send_command "progress ".length($m) or die $!;
+	print $m or die $!;
+    } else {
+	print @_, "\n";
+    }
+}
+
 our $ua;
 
 sub url_get {
@@ -111,28 +266,34 @@ sub url_get {
 	$ua->env_proxy;
     }
     my $what = $_[$#_];
-    print "downloading $what...\n";
+    progress "downloading $what...";
     my $r = $ua->get(@_) or die $!;
     return undef if $r->code == 404;
     $r->is_success or fail "failed to fetch $what: ".$r->status_line;
     return $r->decoded_content();
 }
 
-our ($dscdata,$dscurl,$dsc);
+our ($dscdata,$dscurl,$dsc,$skew_warning_vsn);
 
-sub printcmd {
-    my $fh = shift @_;
-    my $intro = shift @_;
-    print $fh $intro or die $!;
+sub shellquote {
+    my @out;
     local $_;
     foreach my $a (@_) {
 	$_ = $a;
 	if (s{['\\]}{\\$&}g || m{\s} || m{[^-_./0-9a-z]}i) {
-	    print $fh " '$_'" or die $!;
+	    push @out, "'$_'";
 	} else {
-	    print $fh " $_" or die $!;
+	    push @out, $_;
 	}
     }
+    return join '', @out;
+}
+
+sub printcmd {
+    my $fh = shift @_;
+    my $intro = shift @_;
+    print $fh $intro or die $!;
+    print $fh shellquote @_ or die $!;
     print $fh "\n" or die $!;
 }
 
@@ -157,9 +318,9 @@ sub runcmd {
 
 sub printdone {
     if (!$dryrun) {
-	print "dgit ok: @_\n";
+	progress "dgit ok: @_";
     } else {
-	print "would be ok: @_ (but dry run only)\n";
+	progress "would be ok: @_ (but dry run only)";
     }
 }
 
@@ -185,7 +346,7 @@ sub cmdoutput {
 }
 
 sub dryrun_report {
-    printcmd(\*STDOUT,"#",@_);
+    printcmd(\*STDERR,"#",@_);
 }
 
 sub runcmd_ordryrun {
@@ -196,6 +357,11 @@ sub runcmd_ordryrun {
     }
 }
 
+sub shell_cmd {
+    my ($first_shell, @cmd) = @_;
+    return qw(sh -ec), $first_shell.'; exec "$@"', 'x', @cmd;
+}
+
 our $helpmsg = <<END;
 main usages:
   dgit [dgit-opts] clone [dgit-opts] package [suite] [./dir|/dir]
@@ -219,7 +385,12 @@ sub badusage {
     exit 8;
 }
 
-sub helponly () {
+sub nextarg {
+    @ARGV or badusage "too few arguments";
+    return scalar shift @ARGV;
+}
+
+sub cmd_help () {
     print $helpmsg or die $!;
     exit 0;
 }
@@ -236,6 +407,7 @@ our %defcfg = ('dgit.default.distro' => 'debian',
 	       'dgit-distro.debian.sshdakls-host' => 'coccia.debian.org',
 	       'dgit-distro.debian.sshdakls-dir' =>
 	           '/srv/ftp-master.debian.org/ftp/dists',
+	       'dgit-distro.debian.upload-host' => 'ftp-master', # for dput
 	       'dgit-distro.debian.mirror' => 'http://ftp.debian.org/debian/');
 
 sub cfg {
@@ -321,7 +493,7 @@ sub getfield ($$) {
 sub parsechangelog {
     my $c = Dpkg::Control::Hash->new();
     my $p = new IO::Handle;
-    my @cmd = (qw(dpkg-parsechangelog));
+    my @cmd = (qw(dpkg-parsechangelog), @_);
     open $p, '-|', @cmd or die $!;
     $c->parse($p);
     $?=0; $!=0; close $p or failedcmd @cmd;
@@ -399,7 +571,7 @@ sub madison_parse ($) {
 	}
 	$5 eq 'source' or die "$rmad ?";
 	my $prefix = substr($package, 0, $package =~ m/^l/ ? 4 : 1);
-	my $subpath = "/pool/$component/$prefix/$package/${package}_$vsn.dsc";
+	my $subpath = "/pool/$component/$prefix/$package/".dscfn($vsn);
 	push @out, [$vsn,$subpath,$newsuite];
     }
     return sort { -version_compare_string($a->[0],$b->[0]); } @out;
@@ -415,10 +587,12 @@ sub canonicalise_suite_madison ($$) {
 }
 
 sub canonicalise_suite () {
+    return if defined $csuite;
+    fail "cannot operate on $isuite suite" if $isuite eq 'UNRELEASED';
     $csuite = archive_query('canonicalise_suite');
     if ($isuite ne $csuite) {
 	# madison canonicalises for us
-	print "canonical suite name for $isuite is $csuite\n";
+	progress "canonical suite name for $isuite is $csuite";
     }
 }
 
@@ -429,18 +603,19 @@ sub get_archive_dsc () {
 	my ($vsn,$subpath) = @$vinfo;
 	$dscurl = access_cfg('mirror').$subpath;
 	$dscdata = url_get($dscurl);
-	next unless defined $dscdata;
-	$dscurl = access_cfg('mirror').$subpath;
-	$dscdata = url_get($dscurl);
+	if (!$dscdata) {
+	    $skew_warning_vsn = $vsn if !defined $skew_warning_vsn;
+	    next;
+	}
 	my $dscfh = new IO::File \$dscdata, '<' or die $!;
 	print DEBUG Dumper($dscdata) if $debug>1;
 	$dsc = parsecontrolfh($dscfh,$dscurl, allow_pgp=>1);
 	print DEBUG Dumper($dsc) if $debug>1;
 	my $fmt = getfield $dsc, 'Format';
 	fail "unsupported source format $fmt, sorry" unless $format_ok{$fmt};
-	return $dsc;
+	return;
     }
-    return undef;
+    $dsc = undef;
 }
 
 sub check_for_git () {
@@ -471,7 +646,7 @@ sub create_remote_git_repo () {
     }
 }
 
-our ($dsc_hash,$upload_hash);
+our ($dsc_hash,$lastpush_hash);
 
 our $ud = '.git/dgit/unpack';
 
@@ -499,16 +674,35 @@ sub mktree_in_ud_from_only_subdir () {
     return ($tree,$dir);
 }
 
-sub dsc_files () {
-    my $field = $dsc->{'Checksums-Sha256'} || $dsc->{Files};
-    defined $field or
-	fail "missing both Checksums-Sha256 and Files in ".
+sub dsc_files_info () {
+    foreach my $csumi (['Checksums-Sha256','Digest::SHA', 'new(256)'],
+		       ['Checksums-Sha1',  'Digest::SHA', 'new(1)'],
+		       ['Files',           'Digest::MD5', 'new()']) {
+	my ($fname, $module, $method) = @$csumi;
+	my $field = $dsc->{$fname};
+	next unless defined $field;
+	eval "use $module; 1;" or die $@;
+	my @out;
+	foreach (split /\n/, $field) {
+	    next unless m/\S/;
+	    m/^(\w+) (\d+) (\S+)$/ or
+		fail "could not parse .dsc $fname line \`$_'";
+	    my $digester = eval "$module"."->$method;" or die $@;
+	    push @out, {
+		Hash => $1,
+		Bytes => $2,
+		Filename => $3,
+		Digester => $digester,
+	    };
+	}
+	return @out;
+    }
+    fail "missing any supported Checksums-* or Files field in ".
 	$dsc->get_option('name');
-    map {
-	m/^\w+ \d+ (\S+)$/ or
-	    fail "could not parse .dsc Files/Checksums line \`$_'";
-	$1;
-    } grep m/\S/, split /\n/, $field;
+}
+
+sub dsc_files () {
+    map { $_->{Filename} } dsc_files_info();
 }
 
 sub is_orig_file ($) {
@@ -521,6 +715,18 @@ sub make_commit ($) {
     return cmdoutput @git, qw(hash-object -w -t commit), $file;
 }
 
+sub clogp_authline ($) {
+    my ($clogp) = @_;
+    my $author = getfield $clogp, 'Maintainer';
+    $author =~ s#,.*##ms;
+    my $date = cmdoutput qw(date), '+%s %z', qw(-d), getfield($clogp,'Date');
+    my $authline = "$author $date";
+    $authline =~ m/^[^<>]+ \<\S+\> \d+ [-+]\d+$/ or
+	fail "unexpected commit author line format \`$authline'".
+	" (was generated from changelog Maintainer field)";
+    return $authline;
+}
+
 sub generate_commit_from_dsc () {
     prep_ud();
     chdir $ud or die $!;
@@ -541,13 +747,7 @@ sub generate_commit_from_dsc () {
     my ($tree,$dir) = mktree_in_ud_from_only_subdir();
     runcmd qw(sh -ec), 'dpkg-parsechangelog >../changelog.tmp';
     my $clogp = parsecontrol('../changelog.tmp',"commit's changelog");
-    my $date = cmdoutput qw(date), '+%s %z', qw(-d), getfield($clogp,'Date');
-    my $author = getfield $clogp, 'Maintainer';
-    $author =~ s#,.*##ms;
-    my $authline = "$author $date";
-    $authline =~ m/^[^<>]+ \<\S+\> \d+ [-+]\d+$/ or
-	fail "unexpected commit author line format \`$authline'".
-	    " (was generated from changelog Maintainer field)";
+    my $authline = clogp_authline $clogp;
     my $changes = getfield $clogp, 'Changes';
     open C, ">../commit.tmp" or die $!;
     print C <<END or die $!;
@@ -562,9 +762,9 @@ END
     close C or die $!;
     my $outputhash = make_commit qw(../commit.tmp);
     my $cversion = getfield $clogp, 'Version';
-    print "synthesised git commit from .dsc $cversion\n";
-    if ($upload_hash) {
-	runcmd @git, qw(reset --hard), $upload_hash;
+    progress "synthesised git commit from .dsc $cversion";
+    if ($lastpush_hash) {
+	runcmd @git, qw(reset --hard), $lastpush_hash;
 	runcmd qw(sh -ec), 'dpkg-parsechangelog >>../changelogold.tmp';
 	my $oldclogp = parsecontrol('../changelogold.tmp','previous changelog');
 	my $oversion = getfield $oldclogp, 'Version';
@@ -575,7 +775,7 @@ END
 	    open C, ">../commit2.tmp" or die $!;
 	    print C <<END or die $!;
 tree $tree
-parent $upload_hash
+parent $lastpush_hash
 parent $outputhash
 author $authline
 committer $authline
@@ -590,9 +790,9 @@ Version actually in archive:    $cversion (older)
 Last allegedly pushed/uploaded: $oversion (newer or same)
 $later_warning_msg
 END
-            $outputhash = $upload_hash;
+            $outputhash = $lastpush_hash;
         } else {
-	    $outputhash = $upload_hash;
+	    $outputhash = $lastpush_hash;
 	}
     }
     chdir '../../../..' or die $!;
@@ -605,10 +805,20 @@ END
 }
 
 sub ensure_we_have_orig () {
-    foreach my $f (dsc_files()) {
+    foreach my $fi (dsc_files_info()) {
+	my $f = $fi->{Filename};
 	next unless is_orig_file($f);
-	if (stat "../$f") {
-	    die "$f ?" unless -f _;
+	if (open F, "<", "../$f") {
+	    $fi->{Digester}->reset();
+	    $fi->{Digester}->addfile(*F);
+	    F->error and die $!;
+	    my $got = $fi->{Digester}->hexdigest();
+	    $got eq $fi->{Hash} or
+		fail "existing file $f has hash $got but .dsc".
+		    " demands hash $fi->{Hash}".
+		    " (perhaps you should delete this file?)";
+	    progress "using existing $f";
+	    next;
 	} else {
 	    die "$f $!" unless $!==&ENOENT;
 	}
@@ -617,8 +827,7 @@ sub ensure_we_have_orig () {
 	$origurl .= "/$f";
 	die "$f ?" unless $f =~ m/^${package}_/;
 	die "$f ?" if $f =~ m#/#;
-	runcmd_ordryrun qw(sh -ec),'cd ..; exec "$@"','x',
-	    @dget,'--',$origurl;
+	runcmd_ordryrun shell_cmd 'cd ..', @dget,'--',$origurl;
     }
 }
 
@@ -628,74 +837,123 @@ sub rev_parse ($) {
 
 sub is_fast_fwd ($$) {
     my ($ancestor,$child) = @_;
-    my $mb = cmdoutput @git, qw(merge-base), $ancestor, $child;
-    return rev_parse($mb) eq rev_parse($ancestor);
+    my @cmd = (@git, qw(merge-base), $ancestor, $child);
+    my $mb = cmdoutput_errok @cmd;
+    if (defined $mb) {
+	return rev_parse($mb) eq rev_parse($ancestor);
+    } else {
+	$?==256 or failedcmd @cmd;
+	return 0;
+    }
 }
 
 sub git_fetch_us () {
-    badusage "cannot dry run with fetch" if $dryrun;
-    runcmd @git, qw(fetch),access_giturl(),fetchspec();
+    runcmd_ordryrun @git, qw(fetch),access_giturl(),fetchspec();
 }
 
 sub fetch_from_archive () {
     # ensures that lrref() is what is actually in the archive,
     #  one way or another
-    get_archive_dsc() or return 0;
-    foreach my $field (@ourdscfield) {
-	$dsc_hash = $dsc->{$field};
-	last if defined $dsc_hash;
-    }
-    if (defined $dsc_hash) {
-	$dsc_hash =~ m/\w+/ or fail "invalid hash in .dsc \`$dsc_hash'";
-	$dsc_hash = $&;
-	print "last upload to archive specified git hash\n";
+    get_archive_dsc();
+
+    if ($dsc) {
+	foreach my $field (@ourdscfield) {
+	    $dsc_hash = $dsc->{$field};
+	    last if defined $dsc_hash;
+	}
+	if (defined $dsc_hash) {
+	    $dsc_hash =~ m/\w+/ or fail "invalid hash in .dsc \`$dsc_hash'";
+	    $dsc_hash = $&;
+	    progress "last upload to archive specified git hash";
+	} else {
+	    progress "last upload to archive has NO git hash";
+	}
     } else {
-	print "last upload to archive has NO git hash\n";
+	progress "no version available from the archive";
     }
 
     my $lrref_fn = ".git/".lrref();
     if (open H, $lrref_fn) {
-	$upload_hash = <H>;
-	chomp $upload_hash;
-	die "$lrref_fn $upload_hash ?" unless $upload_hash =~ m/^\w+$/;
+	$lastpush_hash = <H>;
+	chomp $lastpush_hash;
+	die "$lrref_fn $lastpush_hash ?" unless $lastpush_hash =~ m/^\w+$/;
     } elsif ($! == &ENOENT) {
-	$upload_hash = '';
+	$lastpush_hash = '';
     } else {
 	die "$lrref_fn $!";
     }
-    print DEBUG "previous reference hash=$upload_hash\n";
+    print DEBUG "previous reference hash=$lastpush_hash\n";
     my $hash;
     if (defined $dsc_hash) {
 	fail "missing git history even though dsc has hash -".
 	    " could not find commit $dsc_hash".
 	    " (should be in ".access_giturl()."#".rrref().")"
-	    unless $upload_hash;
+	    unless $lastpush_hash;
 	$hash = $dsc_hash;
 	ensure_we_have_orig();
-	if ($dsc_hash eq $upload_hash) {
-	} elsif (is_fast_fwd($dsc_hash,$upload_hash)) {
+	if ($dsc_hash eq $lastpush_hash) {
+	} elsif (is_fast_fwd($dsc_hash,$lastpush_hash)) {
 	    print STDERR <<END or die $!;
 
 Git commit in archive is behind the last version allegedly pushed/uploaded.
 Commit referred to by archive:  $dsc_hash
-Last allegedly pushed/uploaded: $upload_hash
+Last allegedly pushed/uploaded: $lastpush_hash
 $later_warning_msg
 END
-	    $hash = $upload_hash;
+	    $hash = $lastpush_hash;
 	} else {
 	    fail "archive's .dsc refers to ".$dsc_hash.
-		" but this is an ancestor of ".$upload_hash;
+		" but this is an ancestor of ".$lastpush_hash;
 	}
-    } else {
+    } elsif ($dsc) {
 	$hash = generate_commit_from_dsc();
+    } elsif ($lastpush_hash) {
+	# only in git, not in the archive yet
+	$hash = $lastpush_hash;
+	print STDERR <<END or die $!;
+
+Package not found in the archive, but has allegedly been pushed using dgit.
+$later_warning_msg
+END
+    } else {
+	print DEBUG "nothing found!\n";
+	if (defined $skew_warning_vsn) {
+	    print STDERR <<END or die $!;
+
+Warning: relevant archive skew detected.
+Archive allegedly contains $skew_warning_vsn
+But we were not able to obtain any version from the archive or git.
+
+END
+	}
+	return 0;
     }
     print DEBUG "current hash=$hash\n";
-    if ($upload_hash) {
+    if ($lastpush_hash) {
 	fail "not fast forward on last upload branch!".
 	    " (archive's version left in DGIT_ARCHIVE)"
-	    unless is_fast_fwd($upload_hash, $hash);
+	    unless is_fast_fwd($lastpush_hash, $hash);
+    }
+    if (defined $skew_warning_vsn) {
+	mkpath '.git/dgit';
+	print DEBUG "SKEW CHECK WANT $skew_warning_vsn\n";
+	my $clogf = ".git/dgit/changelog.tmp";
+	runcmd shell_cmd "exec >$clogf",
+	    @git, qw(cat-file blob), "$hash:debian/changelog";
+	my $gotclogp = parsechangelog("-l$clogf");
+	my $got_vsn = getfield $gotclogp, 'Version';
+	print DEBUG "SKEW CHECK GOT $got_vsn\n";
+	if (version_compare_string($got_vsn, $skew_warning_vsn) < 0) {
+	    print STDERR <<END or die $!;
+
+Warning: archive skew detected.  Using the available version:
+Archive allegedly contains    $skew_warning_vsn
+We were able to obtain only   $got_vsn
+
+END
+	}
     }
-    if ($upload_hash ne $hash) {
+    if ($lastpush_hash ne $hash) {
 	my @upd_cmd = (@git, qw(update-ref -m), 'dgit fetch', lrref(), $hash);
 	if (!$dryrun) {
 	    cmdoutput @upd_cmd;
@@ -719,11 +977,11 @@ sub clone ($) {
     close H or die $!;
     runcmd @git, qw(remote add), 'origin', access_giturl();
     if (check_for_git()) {
-	print "fetching existing git history\n";
+	progress "fetching existing git history";
 	git_fetch_us();
-	runcmd @git, qw(fetch origin);
+	runcmd_ordryrun @git, qw(fetch origin);
     } else {
-	print "starting new git history\n";
+	progress "starting new git history";
     }
     fetch_from_archive() or no_such_package;
     runcmd @git, qw(reset --hard), lrref();
@@ -746,6 +1004,7 @@ sub pull () {
 }
 
 sub check_not_dirty () {
+    return if $ignoredirty;
     my @cmd = (@git, qw(diff --quiet HEAD));
     printcmd(\*DEBUG,"+",@cmd) if $debug>0;
     $!=0; $?=0; system @cmd;
@@ -772,46 +1031,140 @@ sub commit_quilty_patch () {
     }
     fail "unexpected output from git status (is tree clean?)" if $bad;
     if (!%adds) {
-	print "nothing quilty to commit, ok.\n";
+	progress "nothing quilty to commit, ok.";
 	return;
     }
     runcmd_ordryrun @git, qw(add), sort keys %adds;
     my $m = "Commit Debian 3.0 (quilt) metadata";
-    print "$m\n";
+    progress "$m";
     runcmd_ordryrun @git, qw(commit -m), $m;
 }
 
 sub madformat ($) {
     my ($format) = @_;
     return 0 unless $format eq '3.0 (quilt)';
-    print "Format \`$format', urgh\n";
+    progress "Format \`$format', urgh";
+    if ($noquilt) {
+	progress "Not doing any fixup of \`$format' due to --no-quilt-fixup";
+	return 0;
+    }
     return 1;
 }
 
-sub dopush () {
-    print DEBUG "actually entering push\n";
-    my $clogp = parsechangelog();
+sub push_parse_changelog ($) {
+    my ($clogpfn) = @_;
+
+    my $clogp = Dpkg::Control::Hash->new();
+    $clogp->load($clogpfn);
+
     $package = getfield $clogp, 'Source';
     my $cversion = getfield $clogp, 'Version';
+    my $tag = debiantag($cversion);
+    runcmd @git, qw(check-ref-format), $tag;
+
     my $dscfn = dscfn($cversion);
-    stat "../$dscfn" or
-	fail "looked for .dsc $dscfn, but $!;".
-	    " maybe you forgot to build";
-    $dsc = parsecontrol("../$dscfn","$dscfn");
-    my $dscpackage = getfield $dsc, 'Source';
-    my $format = getfield $dsc, 'Format';
+
+    return ($clogp, $cversion, $tag, $dscfn);
+}
+
+sub push_parse_dsc ($$) {
+    my ($dscfn,$dscfnwhat, $cversion) = @_;
+    $dsc = parsecontrol($dscfn,$dscfnwhat);
     my $dversion = getfield $dsc, 'Version';
+    my $dscpackage = getfield $dsc, 'Source';
     ($dscpackage eq $package && $dversion eq $cversion) or
 	fail "$dsc is for $dscpackage $dversion".
 	    " but debian/changelog is for $package $cversion";
+}
+
+sub push_mktag ($$$$$$$$) {
+    my ($head,$clogp,$tag,
+	$dsc,$dscfn,
+	$changesfile,$changesfilewhat,
+	$tfn) = @_;
+
+    $dsc->{$ourdscfield[0]} = $head;
+    $dsc->save("$dscfn.tmp") or die $!;
+
+    my $changes = parsecontrol($changesfile,$changesfilewhat);
+    foreach my $field (qw(Source Distribution Version)) {
+	$changes->{$field} eq $clogp->{$field} or
+	    fail "changes field $field \`$changes->{$field}'".
+	        " does not match changelog \`$clogp->{$field}'";
+    }
+
+    # We make the git tag by hand because (a) that makes it easier
+    # to control the "tagger" (b) we can do remote signing
+    my $authline = clogp_authline $clogp;
+    open TO, '>', $tfn->('.tmp') or die $!;
+    print TO <<END or die $!;
+object $head
+type commit
+tag $tag
+tagger $authline
+
+$package release $cversion for $csuite [dgit]
+END
+    close TO or die $!;
+
+    my $tagobjfn = $tfn->('.tmp');
+    if ($sign) {
+	if (!defined $keyid) {
+	    $keyid = access_cfg('keyid','RETURN-UNDEF');
+	}
+	unlink $tfn->('.tmp.asc') or $!==&ENOENT or die $!;
+	my @sign_cmd = (@gpg, qw(--detach-sign --armor));
+	push @sign_cmd, qw(-u),$keyid if defined $keyid;
+	push @sign_cmd, $tfn->('.tmp');
+	runcmd_ordryrun @sign_cmd;
+	if (!$dryrun) {
+	    $tagobjfn = $tfn->('.signed.tmp');
+	    runcmd shell_cmd "exec >$tagobjfn", qw(cat --),
+	        $tfn->('.tmp'), $tfn->('.tmp.asc');
+	}
+    }
+
+    return ($tagobjfn);
+}
+
+sub sign_changes ($) {
+    my ($changesfile) = @_;
+    if ($sign) {
+	my @debsign_cmd = @debsign;
+	push @debsign_cmd, "-k$keyid" if defined $keyid;
+	push @debsign_cmd, $changesfile;
+	runcmd_ordryrun @debsign_cmd;
+    }
+}
+
+sub dopush () {
+    print DEBUG "actually entering push\n";
+    prep_ud();
+
+    my $clogpfn = ".git/dgit/changelog.822.tmp";
+    runcmd shell_cmd "exec >$clogpfn", qw(dpkg-parsechangelog);
+
+    responder_send_file('parsed-changelog', $clogpfn);
+
+    my ($clogp, $cversion, $tag, $dscfn) =
+	push_parse_changelog("$clogpfn");
+
+    stat "../$dscfn" or
+	fail "looked for .dsc $dscfn, but $!;".
+	    " maybe you forgot to build";
+
+    responder_send_file('dsc', "../$dscfn");
+
+    push_parse_dsc("../$dscfn", $dscfn, $cversion);
+
+    my $format = getfield $dsc, 'Format';
     print DEBUG "format $format\n";
     if (madformat($format)) {
 	commit_quilty_patch();
     }
     check_not_dirty();
-    prep_ud();
     chdir $ud or die $!;
-    print "checking that $dscfn corresponds to HEAD\n";
+    progress "checking that $dscfn corresponds to HEAD";
     runcmd qw(dpkg-source -x --), "../../../../$dscfn";
     my ($tree,$dir) = mktree_in_ud_from_only_subdir();
     chdir '../../../..' or die $!;
@@ -832,15 +1185,14 @@ sub dopush () {
 #    runcmd @git, qw(fetch -p ), "$alioth_git/$package.git",
 #        map { lref($_).":".rref($_) }
 #        (uploadbranch());
-    $dsc->{$ourdscfield[0]} = rev_parse('HEAD');
-    $dsc->save("../$dscfn.tmp") or die $!;
+    my $head = rev_parse('HEAD');
     if (!$changesfile) {
-	my $multi = "../${package}_${cversion}_multi.changes";
+	my $multi = "../${package}_".(stripepoch $cversion)."_multi.changes";
 	if (stat "$multi") {
 	    $changesfile = $multi;
 	} else {
 	    $!==&ENOENT or die "$multi: $!";
-	    my $pat = "${package}_${cversion}_*.changes";
+	    my $pat = "${package}_".(stripepoch $cversion)."_*.changes";
 	    my @cs = glob "../$pat";
 	    fail "failed to find unique changes file".
 		" (looked for $pat in .., or $multi);".
@@ -849,41 +1201,53 @@ sub dopush () {
 	    ($changesfile) = @cs;
 	}
     }
-    my $changes = parsecontrol($changesfile,$changesfile);
-    foreach my $field (qw(Source Distribution Version)) {
-	$changes->{$field} eq $clogp->{$field} or
-	    fail "changes field $field \`$changes->{$field}'".
-	        " does not match changelog \`$clogp->{$field}'";
-    }
-    my $tag = debiantag($dversion);
+
+    responder_send_file('changes',$changesfn);
+
+    my $tfn = sub { ".git/dgit/tag$_[0]"; };
+    my ($tagobjfn) =
+	$we_are_responder
+	? responder_receive_files('signed-tag', $tfn->('.signed.tmp'))
+	: push_mktag($head,$clogp,$tag,
+		     $dsc,"../$dscfn",
+		     $changesfile,$changesfile,
+				 $tfn);
+
+    my $tag_obj_hash = cmdoutput @git, qw(hash-object -w -t tag), $tagobjfn;
+    runcmd_ordryrun @git, qw(verify-tag), $tag_obj_hash;
+    runcmd_ordryrun @git, qw(update-ref), "refs/tags/$tag", $tag_obj_hash;
+    runcmd_ordryrun @git, qw(tag -v --), $tag;
+
     if (!check_for_git()) {
 	create_remote_git_repo();
     }
     runcmd_ordryrun @git, qw(push),access_giturl(),"HEAD:".rrref();
-    if (!$dryrun) {
-	rename "../$dscfn.tmp","../$dscfn" or die "$dscfn $!";
-    } else {
-	print "[new .dsc left in $dscfn.tmp]\n";
-    }
-    if ($sign) {
-	if (!defined $keyid) {
-	    $keyid = access_cfg('keyid','RETURN-UNDEF');
+    runcmd_ordryrun @git, qw(update-ref -m), 'dgit push', lrref(), 'HEAD';
+
+    if (!$we_are_responder) {
+	if (!$dryrun) {
+	    rename "../$dscfn.tmp","../$dscfn" or die "$dscfn $!";
+	} else {
+	    progress "[new .dsc left in $dscfn.tmp]";
 	}
-	my @tag_cmd = (@git, qw(tag -s -m),
-		       "Release $dversion for $csuite [dgit]");
-	push @tag_cmd, qw(-u),$keyid if defined $keyid;
-	push @tag_cmd, $tag;
-	runcmd_ordryrun @tag_cmd;
-	my @debsign_cmd = @debsign;
-	push @debsign_cmd, "-k$keyid" if defined $keyid;
-	push @debsign_cmd, $changesfile;
-	runcmd_ordryrun @debsign_cmd;
     }
+
+    if ($we_are_responder) {
+	my $dryrunsuffix = $dryrun ? ".tmp" : "";
+	responder_receive_files('signed-dsc-changes',
+				"../$dscfn$dryrunsuffix",
+				"$changesfile$dryrupnsuffix");
+    } else {
+	sign_changes $changesfile;
+    }
+
     runcmd_ordryrun @git, qw(push),access_giturl(),"refs/tags/$tag";
     my $host = access_cfg('upload-host','RETURN-UNDEF');
     my @hostarg = defined($host) ? ($host,) : ();
     runcmd_ordryrun @dput, @hostarg, $changesfile;
-    printdone "pushed and uploaded $dversion";
+    printdone "pushed and uploaded $cversion";
+
+    responder_send_command("complete");
 }
 
 sub cmd_clone {
@@ -927,7 +1291,7 @@ sub fetchpullargs () {
 	    $isuite = getfield $clogp, 'Distribution';
 	}
 	canonicalise_suite();
-	print "fetching from suite $csuite\n";
+	progress "fetching from suite $csuite";
     } elsif (@ARGV==1) {
 	($isuite) = @ARGV;
 	canonicalise_suite();
@@ -951,23 +1315,35 @@ sub cmd_pull {
 sub cmd_push {
     parseopts();
     badusage "-p is not allowed with dgit push" if defined $package;
-    runcmd @git, qw(diff --quiet HEAD);
+    check_not_dirty();
     my $clogp = parsechangelog();
     $package = getfield $clogp, 'Source';
+    my $specsuite;
     if (@ARGV==0) {
-	$isuite = getfield $clogp, 'Distribution';
-	if ($new_package) {
-	    local ($package) = $existing_package; # this is a hack
-	    canonicalise_suite();
-	}
+    } elsif (@ARGV==1) {
+	($specsuite) = (@ARGV);
     } else {
 	badusage "incorrect arguments to dgit push";
     }
+    $isuite = getfield $clogp, 'Distribution';
+    if ($new_package) {
+	local ($package) = $existing_package; # this is a hack
+	canonicalise_suite();
+    }
+    if (defined $specsuite && $specsuite ne $isuite) {
+	canonicalise_suite();
+	$csuite eq $specsuite or
+	    fail "dgit push: changelog specifies $isuite ($csuite)".
+	        " but command line specifies $specsuite";
+    }
     if (check_for_git()) {
 	git_fetch_us();
     }
     if (fetch_from_archive()) {
-	is_fast_fwd(lrref(), 'HEAD') or die;
+	is_fast_fwd(lrref(), 'HEAD') or
+	    fail "dgit push: HEAD is not a descendant".
+	        " of the archive's version.\n".
+		"$us: To overwrite it, use git-merge -s ours ".lrref().".";
     } else {
 	$new_package or
 	    fail "package appears to be new in this suite;".
@@ -976,6 +1352,109 @@ sub cmd_push {
     dopush();
 }
 
+#---------- remote commands' implementation ----------
+
+sub cmd_remote_push_responder {
+    my ($nrargs) = shift @ARGV;
+    my (@rargs) = @ARGV[0..$nrargs-1];
+    @ARGV = @ARGV[$nrargs..$#ARGV];
+    die unless @rargs;
+    my ($dir) = @rargs;
+    chdir $dir or die "$dir: $!";
+    $we_are_remote = 1;
+    $|=1;
+    responder_send_command("dgit-remote-push-ready");
+    &cmd_push;
+}
+
+our $i_tmp;
+
+sub i_cleanup {
+    local ($@);
+    return unless defined $i_tmp;
+    chdir "/" or die $!;
+    eval { rmtree $i_tmp; };
+}
+
+sub i_method {
+    my ($base,$selector,@args) = @_;
+    $selector =~ s/\-/_/g;
+    { no strict qw(refs); &{"${base}_${selector}"}(@args); }
+}
+
+sub cmd_rpush {
+    my $host = nextarg;
+    my $dir;
+    if ($host =~ m/^((?:[^][]|\[[^][]*\])*)\:/) {
+	$host = $1;
+	$dir = $'; #';
+    } else {
+	$dir = nextarg;
+    }
+    $dir =~ s{^-}{./-};
+    my @rargs = ($dir);
+    my @rdgit;
+    push @rdgit, @dgit
+    push @rdgit, @ropts;
+    push @rdgit, (scalar @rargs), @rargs;
+    push @rdgit, @ARGV;
+    my @cmd = (@ssh, $host, shellquote @rdgit);
+    my $pid = open2(\*RO, \*RI, @cmd);
+    eval {
+	$i_tmp = tempdir();
+	chdir $i_tmp or die "$i_tmp $!";
+	initiator_expect { m/^dgit-remote-push-ready/ };
+	for (;;) {
+	    initiator_expect { m/^(\S+)(?: (.*))?$/ };
+	    my ($icmd,$iargs) = ($1, $2);
+	    i_method "i_resp_", $icmd, $iargs;
+	}
+    };
+    i_cleanup();
+    die $@;
+}
+
+sub i_resp_progress ($) {
+    my ($rhs) = @_;
+    my $msg = protocol_read_bytes \*RO, $rhs;
+    progress $msg;
+}
+
+sub i_resp_complete {
+    i_cleanup();
+    exit 0;
+}
+
+sub i_resp_file ($) {
+    my ($keyword) = @_;
+    my $localname = i_method "i_localname_", $keyword;
+    my $localpath = "$i_tmp/$localname";
+    stat $localpath and badproto \*RO, "file $keyword ($localpath) twice";
+    protocol_receive_file \*RO, $localpath;
+}
+
+sub i_resp_want ($) {
+    my ($keyword) = @_;
+    my @localpaths = i_method "i_want_", $keyword;
+    foreach my $localpath (@localpaths) {
+	protocol_send_file \*RI, $localpath;
+    }
+    print RI "end-files\n" or die $!;
+}
+
+our ($i_clogp, $i_version, $i_tag, $i_dscfn);
+
+sub i_localname_parsed_changelog { return "remote-changelog.822"; }
+sub i_localname_changes { return "remote.changes"; }
+sub i_localname_dsc {
+    ($i_clogp, $i_version, $i_tag, $i_dscfn) =
+	push_parse_changelog 'remote-changelog.822';
+    die if $i_dscfn =~ m#/|^\W#;
+    return $dscfn;
+}
+
+#---------- building etc. ----------
+
 our $version;
 our $sourcechanges;
 our $dscfn;
@@ -1000,6 +1479,7 @@ sub build_maybe_quilt_fixup () {
     my $ncommits = 3;
     my $patchname = "auto-$version-$headref-$time";
     my $msg = cmdoutput @git, qw(log), "-n$ncommits";
+    mkpath '.git/dgit';
     my $descfn = ".git/dgit/quilt-description.tmp";
     open O, '>', $descfn or die "$descfn: $!";
     $msg =~ s/\n/\n /g;
@@ -1050,19 +1530,32 @@ sub quilt_fixup_editor () {
     exit 0;
 }
 
-sub cmd_build {
-    # we pass further options and args to git-buildpackage
-    badusage "-p is not allowed with dgit build" if defined $package;
-    badusage "dgit build implies --clean=dpkg-source" if defined $package;
+sub build_prep () {
+    badusage "-p is not allowed when building" if defined $package;
+    check_not_dirty();
     my $clogp = parsechangelog();
     $isuite = getfield $clogp, 'Distribution';
     $package = getfield $clogp, 'Source';
     $version = getfield $clogp, 'Version';
     build_maybe_quilt_fixup();
+}
+
+sub cmd_build {
+    badusage "dgit build implies --clean=dpkg-source"
+	if $cleanmode ne 'dpkg-source';
+    build_prep();
+    runcmd_ordryrun @dpkgbuildpackage, qw(-us -uc), changesopts(), @ARGV;
+    printdone "build successful\n";
+}
+
+sub cmd_git_build {
+    badusage "dgit git-build implies --clean=dpkg-source"
+	if $cleanmode ne 'dpkg-source';
+    build_prep();
     my @cmd =
 	(qw(git-buildpackage -us -uc --git-no-sign-tags),
 	 "--git-builder=@dpkgbuildpackage");
-    unless (grep { m/^--git-debian-branch/ } @ARGV) {
+    unless (grep { m/^--git-debian-branch|^--git-ignore-branch/ } @ARGV) {
 	canonicalise_suite();
 	push @cmd, "--git-debian-branch=".lbranch();
     }
@@ -1072,15 +1565,9 @@ sub cmd_build {
 }
 
 sub build_source {
-    badusage "-p is not allowed with this action" if defined $package;
-    check_not_dirty();
-    my $clogp = parsechangelog();
-    $package = getfield $clogp, 'Source';
-    $isuite = getfield $clogp, 'Distribution';
-    $version = getfield $clogp, 'Version';
-    $sourcechanges = "${package}_${version}_source.changes";
+    build_prep();
+    $sourcechanges = "${package}_".(stripepoch $version)."_source.changes";
     $dscfn = dscfn($version);
-    build_maybe_quilt_fixup();
     if ($cleanmode eq 'dpkg-source') {
 	runcmd_ordryrun (@dpkgbuildpackage, qw(-us -uc -S)), changesopts();
     } else {
@@ -1111,7 +1598,7 @@ sub cmd_build_source {
 sub cmd_sbuild {
     build_source();
     chdir ".." or die $!;
-    my $pat = "${package}_${version}_*.changes";
+    my $pat = "${package}_".(stripepoch $version)."_*.changes";
     if (!$dryrun) {
 	stat $dscfn or fail "$dscfn (in parent directory): $!";
 	stat $sourcechanges or fail "$sourcechanges (in parent directory): $!";
@@ -1122,7 +1609,7 @@ sub cmd_sbuild {
     }
     runcmd_ordryrun @sbuild, @ARGV, qw(-d), $isuite, $dscfn;
     runcmd_ordryrun @mergechanges, glob $pat;
-    my $multichanges = "${package}_${version}_multi.changes";
+    my $multichanges = "${package}_".(stripepoch $version)."_multi.changes";
     if (!$dryrun) {
 	stat $multichanges or fail "$multichanges: $!";
     }
@@ -1136,6 +1623,13 @@ sub cmd_quilt_fixup {
     build_maybe_quilt_fixup();
 }
 
+#---------- argument parsing and main program ----------
+
+sub cmd_version {
+    print "dgit version $our_version\n" or die $!;
+    exit 0;
+}
+
 sub parseopts () {
     my $om;
     while (@ARGV) {
@@ -1144,58 +1638,84 @@ sub parseopts () {
 	last if m/^--?$/;
 	if (m/^--/) {
 	    if (m/^--dry-run$/) {
+		push @ropts, $_;
 		$dryrun=1;
 	    } elsif (m/^--no-sign$/) {
+		push @ropts, $_;
 		$sign=0;
 	    } elsif (m/^--help$/) {
-		helponly();
+		cmd_help();
+	    } elsif (m/^--version$/) {
+		cmd_version();
 	    } elsif (m/^--new$/) {
+		push @ropts, $_;
 		$new_package=1;
 	    } elsif (m/^--(\w+)=(.*)/s &&
 		     ($om = $opts_opt_map{$1}) &&
 		     length $om->[0]) {
+		push @ropts, $_;
 		$om->[0] = $2;
 	    } elsif (m/^--(\w+):(.*)/s &&
 		     ($om = $opts_opt_map{$1})) {
+		push @ropts, $_;
 		push @$om, $2;
 	    } elsif (m/^--existing-package=(.*)/s) {
+		push @ropts, $_;
 		$existing_package = $1;
 	    } elsif (m/^--distro=(.*)/s) {
+		push @ropts, $_;
 		$idistro = $1;
 	    } elsif (m/^--clean=(dpkg-source|git|none)$/s) {
+		push @ropts, $_;
 		$cleanmode = $1;
 	    } elsif (m/^--clean=(.*)$/s) {
 		badusage "unknown cleaning mode \`$1'";
+	    } elsif (m/^--ignore-dirty$/s) {
+		push @ropts, $_;
+		$ignoredirty = 1;
+	    } elsif (m/^--no-quilt-fixup$/s) {
+		push @ropts, $_;
+		$noquilt = 1;
 	    } else {
 		badusage "unknown long option \`$_'";
 	    }
 	} else {
 	    while (m/^-./s) {
 		if (s/^-n/-/) {
+		    push @ropts, $_;
 		    $dryrun=1;
 		} elsif (s/^-h/-/) {
-		    helponly();
+		    cmd_help();
 		} elsif (s/^-D/-/) {
+		    push @ropts, $_;
 		    open DEBUG, ">&STDERR" or die $!;
 		    $debug++;
 		} elsif (s/^-N/-/) {
+		    push @ropts, $_;
 		    $new_package=1;
 		} elsif (m/^-[vm]/) {
+		    push @ropts, $_;
 		    push @changesopts, $_;
 		    $_ = '';
 		} elsif (s/^-c(.*=.*)//s) {
+		    push @ropts, $_;
 		    push @git, '-c', $1;
 		} elsif (s/^-d(.*)//s) {
+		    push @ropts, $_;
 		    $idistro = $1;
 		} elsif (s/^-C(.*)//s) {
+		    push @ropts, $_;
 		    $changesfile = $1;
 		} elsif (s/^-k(.*)//s) {
 		    $keyid=$1;
 		} elsif (s/^-wn//s) {
+		    push @ropts, $_;
 		    $cleanmode = 'none';
 		} elsif (s/^-wg//s) {
+		    push @ropts, $_;
 		    $cleanmode = 'git';
 		} elsif (s/^-wd//s) {
+		    push @ropts, $_;
 		    $cleanmode = 'dpkg-source';
 		} else {
 		    badusage "unknown short option \`$_'";
@@ -1209,6 +1729,8 @@ if ($ENV{$fakeeditorenv}) {
     quilt_fixup_editor();
 }
 
+delete $ENV{'DGET_UNPACK'};
+
 parseopts();
 print STDERR "DRY RUN ONLY\n" if $dryrun;
 if (!@ARGV) {