git-cvsimport.perl

   1 #!/usr/bin/perl
   2
   3 # This tool is copyright (c) 2005, Matthias Urlichs.
   4 # It is released under the Gnu Public License, version 2.
   5 #
   6 # The basic idea is to aggregate CVS check-ins into related changes.
   7 # Fortunately, "cvsps" does that for us; all we have to do is to parse
   8 # its output.
   9 #
  10 # Checking out the files is done by a single long-running CVS connection
  11 # / server process.
  12 #
  13 # The head revision is on branch "origin" by default.
  14 # You can change that with the '-o' option.
  15
  16 use 5.008;
  17 use strict;
  18 use warnings;
  19 use Getopt::Long;
  20 use File::Spec;
  21 use File::Temp qw(tempfile tmpnam);
  22 use File::Path qw(mkpath);
  23 use File::Basename qw(basename dirname);
  24 use Time::Local;
  25 use IO::Socket;
  26 use IO::Pipe;
  27 use POSIX qw(strftime dup2 ENOENT);
  28 use IPC::Open2;
  29
  30 $SIG{'PIPE'}="IGNORE";
  31 $ENV{'TZ'}="UTC";
  32
  33 our ($opt_h,$opt_o,$opt_v,$opt_k,$opt_u,$opt_d,$opt_p,$opt_C,$opt_z,$opt_i,$opt_P, $opt_s,$opt_m,@opt_M,$opt_A,$opt_S,$opt_L, $opt_a, $opt_r, $opt_R);
  34 my (%conv_author_name, %conv_author_email);
  35
  36 sub usage(;$) {
  37         my $msg = shift;
  38         print(STDERR "Error: $msg\n") if $msg;
  39         print STDERR <<END;
  40 Usage: git cvsimport     # fetch/update GIT from CVS
  41        [-o branch-for-HEAD] [-h] [-v] [-d CVSROOT] [-A author-conv-file]
  42        [-p opts-for-cvsps] [-P file] [-C GIT_repository] [-z fuzz] [-i] [-k]
  43        [-u] [-s subst] [-a] [-m] [-M regex] [-S regex] [-L commitlimit]
  44        [-r remote] [-R] [CVS_module]
  45 END
  46         exit(1);
  47 }
  48
  49 sub read_author_info($) {
  50         my ($file) = @_;
  51         my $user;
  52         open my $f, '<', "$file" or die("Failed to open $file: $!\n");
  53
  54         while (<$f>) {
  55                 # Expected format is this:
  56                 #   exon=Andreas Ericsson <ae@op5.se>
  57                 if (m/^(\S+?)\s*=\s*(.+?)\s*<(.+)>\s*$/) {
  58                         $user = $1;
  59                         $conv_author_name{$user} = $2;
  60                         $conv_author_email{$user} = $3;
  61                 }
  62                 # However, we also read from CVSROOT/users format
  63                 # to ease migration.
  64                 elsif (/^(\w+):(['"]?)(.+?)\2\s*$/) {
  65                         my $mapped;
  66                         ($user, $mapped) = ($1, $3);
  67                         if ($mapped =~ /^\s*(.*?)\s*<(.*)>\s*$/) {
  68                                 $conv_author_name{$user} = $1;
  69                                 $conv_author_email{$user} = $2;
  70                         }
  71                         elsif ($mapped =~ /^<?(.*)>?$/) {
  72                                 $conv_author_name{$user} = $user;
  73                                 $conv_author_email{$user} = $1;
  74                         }
  75                 }
  76                 # NEEDSWORK: Maybe warn on unrecognized lines?
  77         }
  78         close ($f);
  79 }
  80
  81 sub write_author_info($) {
  82         my ($file) = @_;
  83         open my $f, '>', $file or
  84           die("Failed to open $file for writing: $!");
  85
  86         foreach (keys %conv_author_name) {
  87                 print $f "$_=$conv_author_name{$_} <$conv_author_email{$_}>\n";
  88         }
  89         close ($f);
  90 }
  91
  92 # convert getopts specs for use by git config
  93 my %longmap = (
  94         'A:' => 'authors-file',
  95         'M:' => 'merge-regex',
  96         'P:' => undef,
  97         'R' => 'track-revisions',
  98         'S:' => 'ignore-paths',
  99 );
 100
 101 sub read_repo_config {
 102         # Split the string between characters, unless there is a ':'
 103         # So "abc:de" becomes ["a", "b", "c:", "d", "e"]
 104         my @opts = split(/ *(?!:)/, shift);
 105         foreach my $o (@opts) {
 106                 my $key = $o;
 107                 $key =~ s/://g;
 108                 my $arg = 'git config';
 109                 $arg .= ' --bool' if ($o !~ /:$/);
 110                 my $ckey = $key;
 111
 112                 if (exists $longmap{$o}) {
 113                         # An uppercase option like -R cannot be
 114                         # expressed in the configuration, as the
 115                         # variable names are downcased.
 116                         $ckey = $longmap{$o};
 117                         next if (! defined $ckey);
 118                         $ckey =~ s/-//g;
 119                 }
 120                 chomp(my $tmp = `$arg --get cvsimport.$ckey`);
 121                 if ($tmp && !($arg =~ /--bool/ && $tmp eq 'false')) {
 122                         no strict 'refs';
 123                         my $opt_name = "opt_" . $key;
 124                         if (!$$opt_name) {
 125                                 $$opt_name = $tmp;
 126                         }
 127                 }
 128         }
 129 }
 130
 131 my $opts = "haivmkuo:d:p:r:C:z:s:M:P:A:S:L:R";
 132 read_repo_config($opts);
 133 Getopt::Long::Configure( 'no_ignore_case', 'bundling' );
 134
 135 # turn the Getopt::Std specification in a Getopt::Long one,
 136 # with support for multiple -M options
 137 GetOptions( map { s/:/=s/; /M/ ? "$_\@" : $_ } split( /(?!:)/, $opts ) )
 138     or usage();
 139 usage if $opt_h;
 140
 141 if (@ARGV == 0) {
 142                 chomp(my $module = `git config --get cvsimport.module`);
 143                 push(@ARGV, $module) if $? == 0;
 144 }
 145 @ARGV <= 1 or usage("You can't specify more than one CVS module");
 146
 147 if ($opt_d) {
 148         $ENV{"CVSROOT"} = $opt_d;
 149 } elsif (-f 'CVS/Root') {
 150         open my $f, '<', 'CVS/Root' or die 'Failed to open CVS/Root';
 151         $opt_d = <$f>;
 152         chomp $opt_d;
 153         close $f;
 154         $ENV{"CVSROOT"} = $opt_d;
 155 } elsif ($ENV{"CVSROOT"}) {
 156         $opt_d = $ENV{"CVSROOT"};
 157 } else {
 158         usage("CVSROOT needs to be set");
 159 }
 160 $opt_s ||= "-";
 161 $opt_a ||= 0;
 162
 163 my $git_tree = $opt_C;
 164 $git_tree ||= ".";
 165
 166 my $remote;
 167 if (defined $opt_r) {
 168         $remote = 'refs/remotes/' . $opt_r;
 169         $opt_o ||= "master";
 170 } else {
 171         $opt_o ||= "origin";
 172         $remote = 'refs/heads';
 173 }
 174
 175 my $cvs_tree;
 176 if ($#ARGV == 0) {
 177         $cvs_tree = $ARGV[0];
 178 } elsif (-f 'CVS/Repository') {
 179         open my $f, '<', 'CVS/Repository' or
 180             die 'Failed to open CVS/Repository';
 181         $cvs_tree = <$f>;
 182         chomp $cvs_tree;
 183         close $f;
 184 } else {
 185         usage("CVS module has to be specified");
 186 }
 187
 188 our @mergerx = ();
 189 if ($opt_m) {
 190         @mergerx = ( qr/\b(?:from|of|merge|merging|merged) ([-\w]+)/i );
 191 }
 192 if (@opt_M) {
 193         push (@mergerx, map { qr/$_/ } @opt_M);
 194 }
 195
 196 # Remember UTC of our starting time
 197 # we'll want to avoid importing commits
 198 # that are too recent
 199 our $starttime = time();
 200
 201 select(STDERR); $|=1; select(STDOUT);
 202
 203
 204 package CVSconn;
 205 # Basic CVS dialog.
 206 # We're only interested in connecting and downloading, so ...
 207
 208 use File::Spec;
 209 use File::Temp qw(tempfile);
 210 use POSIX qw(strftime dup2);
 211
 212 sub new {
 213         my ($what,$repo,$subdir) = @_;
 214         $what=ref($what) if ref($what);
 215
 216         my $self = {};
 217         $self->{'buffer'} = "";
 218         bless($self,$what);
 219
 220         $repo =~ s#/+$##;
 221         $self->{'fullrep'} = $repo;
 222         $self->conn();
 223
 224         $self->{'subdir'} = $subdir;
 225         $self->{'lines'} = undef;
 226
 227         return $self;
 228 }
 229
 230 sub find_password_entry {
 231         my ($cvspass, @cvsroot) = @_;
 232         my ($file, $delim) = @$cvspass;
 233         my $pass;
 234         local ($_);
 235
 236         if (open(my $fh, $file)) {
 237                 # :pserver:cvs@mea.tmt.tele.fi:/cvsroot/zmailer Ah<Z
 238                 CVSPASSFILE:
 239                 while (<$fh>) {
 240                         chomp;
 241                         s/^\/\d+\s+//;
 242                         my ($w, $p) = split($delim,$_,2);
 243                         for my $cvsroot (@cvsroot) {
 244                                 if ($w eq $cvsroot) {
 245                                         $pass = $p;
 246                                         last CVSPASSFILE;
 247                                 }
 248                         }
 249                 }
 250                 close($fh);
 251         }
 252         return $pass;
 253 }
 254
 255 sub conn {
 256         my $self = shift;
 257         my $repo = $self->{'fullrep'};
 258         if ($repo =~ s/^:pserver(?:([^:]*)):(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?//) {
 259                 my ($param,$user,$pass,$serv,$port) = ($1,$2,$3,$4,$5);
 260
 261                 my ($proxyhost,$proxyport);
 262                 if ($param && ($param =~ m/proxy=([^;]+)/)) {
 263                         $proxyhost = $1;
 264                         # Default proxyport, if not specified, is 8080.
 265                         $proxyport = 8080;
 266                         if ($ENV{"CVS_PROXY_PORT"}) {
 267                                 $proxyport = $ENV{"CVS_PROXY_PORT"};
 268                         }
 269                         if ($param =~ m/proxyport=([^;]+)/) {
 270                                 $proxyport = $1;
 271                         }
 272                 }
 273                 $repo ||= '/';
 274
 275                 # if username is not explicit in CVSROOT, then use current user, as cvs would
 276                 $user=(getlogin() || $ENV{'LOGNAME'} || $ENV{'USER'} || "anonymous") unless $user;
 277                 my $rr2 = "-";
 278                 unless ($port) {
 279                         $rr2 = ":pserver:$user\@$serv:$repo";
 280                         $port=2401;
 281                 }
 282                 my $rr = ":pserver:$user\@$serv:$port$repo";
 283
 284                 if ($pass) {
 285                         $pass = $self->_scramble($pass);
 286                 } else {
 287                         my @cvspass = ([$ENV{'HOME'}."/.cvspass", qr/\s/],
 288                                        [$ENV{'HOME'}."/.cvs/cvspass", qr/=/]);
 289                         my @loc = ();
 290                         foreach my $cvspass (@cvspass) {
 291                                 my $p = find_password_entry($cvspass, $rr, $rr2);
 292                                 if ($p) {
 293                                         push @loc, $cvspass->[0];
 294                                         $pass = $p;
 295                                 }
 296                         }
 297
 298                         if (1 < @loc) {
 299                                 die("Multiple cvs password files have ".
 300                                     "entries for CVSROOT $opt_d: @loc");
 301                         } elsif (!$pass) {
 302                                 $pass = "A";
 303                         }
 304                 }
 305
 306                 my ($s, $rep);
 307                 if ($proxyhost) {
 308
 309                         # Use a HTTP Proxy. Only works for HTTP proxies that
 310                         # don't require user authentication
 311                         #
 312                         # See: http://www.ietf.org/rfc/rfc2817.txt
 313
 314                         $s = IO::Socket::INET->new(PeerHost => $proxyhost, PeerPort => $proxyport);
 315                         die "Socket to $proxyhost: $!\n" unless defined $s;
 316                         $s->write("CONNECT $serv:$port HTTP/1.1\r\nHost: $serv:$port\r\n\r\n")
 317                                 or die "Write to $proxyhost: $!\n";
 318                         $s->flush();
 319
 320                         $rep = <$s>;
 321
 322                         # The answer should look like 'HTTP/1.x 2yy ....'
 323                         if (!($rep =~ m#^HTTP/1\.. 2[0-9][0-9]#)) {
 324                                 die "Proxy connect: $rep\n";
 325                         }
 326                         # Skip up to the empty line of the proxy server output
 327                         # including the response headers.
 328                         while ($rep = <$s>) {
 329                                 last if (!defined $rep ||
 330                                          $rep eq "\n" ||
 331                                          $rep eq "\r\n");
 332                         }
 333                 } else {
 334                         $s = IO::Socket::INET->new(PeerHost => $serv, PeerPort => $port);
 335                         die "Socket to $serv: $!\n" unless defined $s;
 336                 }
 337
 338                 $s->write("BEGIN AUTH REQUEST\n$repo\n$user\n$pass\nEND AUTH REQUEST\n")
 339                         or die "Write to $serv: $!\n";
 340                 $s->flush();
 341
 342                 $rep = <$s>;
 343
 344                 if ($rep ne "I LOVE YOU\n") {
 345                         $rep="<unknown>" unless $rep;
 346                         die "AuthReply: $rep\n";
 347                 }
 348                 $self->{'socketo'} = $s;
 349                 $self->{'socketi'} = $s;
 350         } else { # local or ext: Fork off our own cvs server.
 351                 my $pr = IO::Pipe->new();
 352                 my $pw = IO::Pipe->new();
 353                 my $pid = fork();
 354                 die "Fork: $!\n" unless defined $pid;
 355                 my $cvs = 'cvs';
 356                 $cvs = $ENV{CVS_SERVER} if exists $ENV{CVS_SERVER};
 357                 my $rsh = 'rsh';
 358                 $rsh = $ENV{CVS_RSH} if exists $ENV{CVS_RSH};
 359
 360                 my @cvs = ($cvs, 'server');
 361                 my ($local, $user, $host);
 362                 $local = $repo =~ s/:local://;
 363                 if (!$local) {
 364                     $repo =~ s/:ext://;
 365                     $local = !($repo =~ s/^(?:([^\@:]+)\@)?([^:]+)://);
 366                     ($user, $host) = ($1, $2);
 367                 }
 368                 if (!$local) {
 369                     if ($user) {
 370                         unshift @cvs, $rsh, '-l', $user, $host;
 371                     } else {
 372                         unshift @cvs, $rsh, $host;
 373                     }
 374                 }
 375
 376                 unless ($pid) {
 377                         $pr->writer();
 378                         $pw->reader();
 379                         dup2($pw->fileno(),0);
 380                         dup2($pr->fileno(),1);
 381                         $pr->close();
 382                         $pw->close();
 383                         exec(@cvs);
 384                 }
 385                 $pw->writer();
 386                 $pr->reader();
 387                 $self->{'socketo'} = $pw;
 388                 $self->{'socketi'} = $pr;
 389         }
 390         $self->{'socketo'}->write("Root $repo\n");
 391
 392         # Trial and error says that this probably is the minimum set
 393         $self->{'socketo'}->write("Valid-responses ok error Valid-requests Mode M Mbinary E Checked-in Created Updated Merged Removed\n");
 394
 395         $self->{'socketo'}->write("valid-requests\n");
 396         $self->{'socketo'}->flush();
 397
 398         my $rep=$self->readline();
 399         die "Failed to read from server" unless defined $rep;
 400         chomp($rep);
 401         if ($rep !~ s/^Valid-requests\s*//) {
 402                 $rep="<unknown>" unless $rep;
 403                 die "Expected Valid-requests from server, but got: $rep\n";
 404         }
 405         chomp(my $res=$self->readline());
 406         die "validReply: $res\n" if $res ne "ok";
 407
 408         $self->{'socketo'}->write("UseUnchanged\n") if $rep =~ /\bUseUnchanged\b/;
 409         $self->{'repo'} = $repo;
 410 }
 411
 412 sub readline {
 413         my ($self) = @_;
 414         return $self->{'socketi'}->getline();
 415 }
 416
 417 sub _file {
 418         # Request a file with a given revision.
 419         # Trial and error says this is a good way to do it. :-/
 420         my ($self,$fn,$rev) = @_;
 421         $self->{'socketo'}->write("Argument -N\n") or return undef;
 422         $self->{'socketo'}->write("Argument -P\n") or return undef;
 423         # -kk: Linus' version doesn't use it - defaults to off
 424         if ($opt_k) {
 425             $self->{'socketo'}->write("Argument -kk\n") or return undef;
 426         }
 427         $self->{'socketo'}->write("Argument -r\n") or return undef;
 428         $self->{'socketo'}->write("Argument $rev\n") or return undef;
 429         $self->{'socketo'}->write("Argument --\n") or return undef;
 430         $self->{'socketo'}->write("Argument $self->{'subdir'}/$fn\n") or return undef;
 431         $self->{'socketo'}->write("Directory .\n") or return undef;
 432         $self->{'socketo'}->write("$self->{'repo'}\n") or return undef;
 433         # $self->{'socketo'}->write("Sticky T1.0\n") or return undef;
 434         $self->{'socketo'}->write("co\n") or return undef;
 435         $self->{'socketo'}->flush() or return undef;
 436         $self->{'lines'} = 0;
 437         return 1;
 438 }
 439 sub _line {
 440         # Read a line from the server.
 441         # ... except that 'line' may be an entire file. ;-)
 442         my ($self, $fh) = @_;
 443         die "Not in lines" unless defined $self->{'lines'};
 444
 445         my $line;
 446         my $res=0;
 447         while (defined($line = $self->readline())) {
 448                 # M U gnupg-cvs-rep/AUTHORS
 449                 # Updated gnupg-cvs-rep/
 450                 # /daten/src/rsync/gnupg-cvs-rep/AUTHORS
 451                 # /AUTHORS/1.1///T1.1
 452                 # u=rw,g=rw,o=rw
 453                 # 0
 454                 # ok
 455
 456                 if ($line =~ s/^(?:Created|Updated) //) {
 457                         $line = $self->readline(); # path
 458                         $line = $self->readline(); # Entries line
 459                         my $mode = $self->readline(); chomp $mode;
 460                         $self->{'mode'} = $mode;
 461                         defined (my $cnt = $self->readline())
 462                                 or die "EOF from server after 'Changed'\n";
 463                         chomp $cnt;
 464                         die "Duh: Filesize $cnt" if $cnt !~ /^\d+$/;
 465                         $line="";
 466                         $res = $self->_fetchfile($fh, $cnt);
 467                 } elsif ($line =~ s/^ //) {
 468                         print $fh $line;
 469                         $res += length($line);
 470                 } elsif ($line =~ /^M\b/) {
 471                         # output, do nothing
 472                 } elsif ($line =~ /^Mbinary\b/) {
 473                         my $cnt;
 474                         die "EOF from server after 'Mbinary'" unless defined ($cnt = $self->readline());
 475                         chomp $cnt;
 476                         die "Duh: Mbinary $cnt" if $cnt !~ /^\d+$/ or $cnt<1;
 477                         $line="";
 478                         $res += $self->_fetchfile($fh, $cnt);
 479                 } else {
 480                         chomp $line;
 481                         if ($line eq "ok") {
 482                                 # print STDERR "S: ok (".length($res).")\n";
 483                                 return $res;
 484                         } elsif ($line =~ s/^E //) {
 485                                 # print STDERR "S: $line\n";
 486                         } elsif ($line =~ /^(Remove-entry|Removed) /i) {
 487                                 $line = $self->readline(); # filename
 488                                 $line = $self->readline(); # OK
 489                                 chomp $line;
 490                                 die "Unknown: $line" if $line ne "ok";
 491                                 return -1;
 492                         } else {
 493                                 die "Unknown: $line\n";
 494                         }
 495                 }
 496         }
 497         return undef;
 498 }
 499 sub file {
 500         my ($self,$fn,$rev) = @_;
 501         my $res;
 502
 503         my ($fh, $name) = tempfile('gitcvs.XXXXXX',
 504                     DIR => File::Spec->tmpdir(), UNLINK => 1);
 505
 506         $self->_file($fn,$rev) and $res = $self->_line($fh);
 507
 508         if (!defined $res) {
 509             print STDERR "Server has gone away while fetching $fn $rev, retrying...\n";
 510             truncate $fh, 0;
 511             $self->conn();
 512             $self->_file($fn,$rev) or die "No file command send";
 513             $res = $self->_line($fh);
 514             die "Retry failed" unless defined $res;
 515         }
 516         close ($fh);
 517
 518         return ($name, $res);
 519 }
 520 sub _fetchfile {
 521         my ($self, $fh, $cnt) = @_;
 522         my $res = 0;
 523         my $bufsize = 1024 * 1024;
 524         while ($cnt) {
 525             if ($bufsize > $cnt) {
 526                 $bufsize = $cnt;
 527             }
 528             my $buf;
 529             my $num = $self->{'socketi'}->read($buf,$bufsize);
 530             die "Server: Filesize $cnt: $num: $!\n" if not defined $num or $num<=0;
 531             print $fh $buf;
 532             $res += $num;
 533             $cnt -= $num;
 534         }
 535         return $res;
 536 }
 537
 538 sub _scramble {
 539         my ($self, $pass) = @_;
 540         my $scrambled = "A";
 541
 542         return $scrambled unless $pass;
 543
 544         my $pass_len = length($pass);
 545         my @pass_arr = split("", $pass);
 546         my $i;
 547
 548         # from cvs/src/scramble.c
 549         my @shifts = (
 550                   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 551                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 552                 114,120, 53, 79, 96,109, 72,108, 70, 64, 76, 67,116, 74, 68, 87,
 553                 111, 52, 75,119, 49, 34, 82, 81, 95, 65,112, 86,118,110,122,105,
 554                  41, 57, 83, 43, 46,102, 40, 89, 38,103, 45, 50, 42,123, 91, 35,
 555                 125, 55, 54, 66,124,126, 59, 47, 92, 71,115, 78, 88,107,106, 56,
 556                  36,121,117,104,101,100, 69, 73, 99, 63, 94, 93, 39, 37, 61, 48,
 557                  58,113, 32, 90, 44, 98, 60, 51, 33, 97, 62, 77, 84, 80, 85,223,
 558                 225,216,187,166,229,189,222,188,141,249,148,200,184,136,248,190,
 559                 199,170,181,204,138,232,218,183,255,234,220,247,213,203,226,193,
 560                 174,172,228,252,217,201,131,230,197,211,145,238,161,179,160,212,
 561                 207,221,254,173,202,146,224,151,140,196,205,130,135,133,143,246,
 562                 192,159,244,239,185,168,215,144,139,165,180,157,147,186,214,176,
 563                 227,231,219,169,175,156,206,198,129,164,150,210,154,177,134,127,
 564                 182,128,158,208,162,132,167,209,149,241,153,251,237,236,171,195,
 565                 243,233,253,240,194,250,191,155,142,137,245,235,163,242,178,152
 566         );
 567
 568         for ($i = 0; $i < $pass_len; $i++) {
 569                 $scrambled .= pack("C", $shifts[ord($pass_arr[$i])]);
 570         }
 571
 572         return $scrambled;
 573 }
 574
 575 package main;
 576
 577 my $cvs = CVSconn->new($opt_d, $cvs_tree);
 578
 579
 580 sub pdate($) {
 581         my ($d) = @_;
 582         m#(\d{2,4})/(\d\d)/(\d\d)\s(\d\d):(\d\d)(?::(\d\d))?#
 583                 or die "Unparseable date: $d\n";
 584         my $y=$1; $y-=1900 if $y>1900;
 585         return timegm($6||0,$5,$4,$3,$2-1,$y);
 586 }
 587
 588 sub pmode($) {
 589         my ($mode) = @_;
 590         my $m = 0;
 591         my $mm = 0;
 592         my $um = 0;
 593         for my $x(split(//,$mode)) {
 594                 if ($x eq ",") {
 595                         $m |= $mm&$um;
 596                         $mm = 0;
 597                         $um = 0;
 598                 } elsif ($x eq "u") { $um |= 0700;
 599                 } elsif ($x eq "g") { $um |= 0070;
 600                 } elsif ($x eq "o") { $um |= 0007;
 601                 } elsif ($x eq "r") { $mm |= 0444;
 602                 } elsif ($x eq "w") { $mm |= 0222;
 603                 } elsif ($x eq "x") { $mm |= 0111;
 604                 } elsif ($x eq "=") { # do nothing
 605                 } else { die "Unknown mode: $mode\n";
 606                 }
 607         }
 608         $m |= $mm&$um;
 609         return $m;
 610 }
 611
 612 sub getwd() {
 613         my $pwd = `pwd`;
 614         chomp $pwd;
 615         return $pwd;
 616 }
 617
 618 sub is_sha1 {
 619         my $s = shift;
 620         return $s =~ /^[a-f0-9]{40}$/;
 621 }
 622
 623 sub get_headref ($) {
 624         my $name = shift;
 625         my $r = `git rev-parse --verify '$name' 2>/dev/null`;
 626         return undef unless $? == 0;
 627         chomp $r;
 628         return $r;
 629 }
 630
 631 my $user_filename_prepend = '';
 632 sub munge_user_filename {
 633         my $name = shift;
 634         return File::Spec->file_name_is_absolute($name) ?
 635                 $name :
 636                 $user_filename_prepend . $name;
 637 }
 638
 639 -d $git_tree
 640         or mkdir($git_tree,0777)
 641         or die "Could not create $git_tree: $!";
 642 if ($git_tree ne '.') {
 643         $user_filename_prepend = getwd() . '/';
 644         chdir($git_tree);
 645 }
 646
 647 my $last_branch = "";
 648 my $orig_branch = "";
 649 my %branch_date;
 650 my $tip_at_start = undef;
 651
 652 my $git_dir = $ENV{"GIT_DIR"} || ".git";
 653 $git_dir = getwd()."/".$git_dir unless $git_dir =~ m#^/#;
 654 $ENV{"GIT_DIR"} = $git_dir;
 655 my $orig_git_index;
 656 $orig_git_index = $ENV{GIT_INDEX_FILE} if exists $ENV{GIT_INDEX_FILE};
 657
 658 my %index; # holds filenames of one index per branch
 659
 660 unless (-d $git_dir) {
 661         system(qw(git init));
 662         die "Cannot init the GIT db at $git_tree: $?\n" if $?;
 663         system(qw(git read-tree --empty));
 664         die "Cannot init an empty tree: $?\n" if $?;
 665
 666         $last_branch = $opt_o;
 667         $orig_branch = "";
 668 } else {
 669         open(F, "-|", qw(git symbolic-ref HEAD)) or
 670                 die "Cannot run git symbolic-ref: $!\n";
 671         chomp ($last_branch = <F>);
 672         $last_branch = basename($last_branch);
 673         close(F);
 674         unless ($last_branch) {
 675                 warn "Cannot read the last branch name: $! -- assuming 'master'\n";
 676                 $last_branch = "master";
 677         }
 678         $orig_branch = $last_branch;
 679         $tip_at_start = `git rev-parse --verify HEAD`;
 680
 681         # Get the last import timestamps
 682         my $fmt = '($ref, $author) = (%(refname), %(author));';
 683         my @cmd = ('git', 'for-each-ref', '--perl', "--format=$fmt", $remote);
 684         open(H, "-|", @cmd) or die "Cannot run git for-each-ref: $!\n";
 685         while (defined(my $entry = <H>)) {
 686                 my ($ref, $author);
 687                 eval($entry) || die "cannot eval refs list: $@";
 688                 my ($head) = ($ref =~ m|^$remote/(.*)|);
 689                 $author =~ /^.*\s(\d+)\s[-+]\d{4}$/;
 690                 $branch_date{$head} = $1;
 691         }
 692         close(H);
 693         if (!exists $branch_date{$opt_o}) {
 694                 die "Branch '$opt_o' does not exist.\n".
 695                        "Either use the correct '-o branch' option,\n".
 696                        "or import to a new repository.\n";
 697         }
 698 }
 699
 700 -d $git_dir
 701         or die "Could not create git subdir ($git_dir).\n";
 702
 703 # now we read (and possibly save) author-info as well
 704 -f "$git_dir/cvs-authors" and
 705   read_author_info("$git_dir/cvs-authors");
 706 if ($opt_A) {
 707         read_author_info(munge_user_filename($opt_A));
 708         write_author_info("$git_dir/cvs-authors");
 709 }
 710
 711 # open .git/cvs-revisions, if requested
 712 open my $revision_map, '>>', "$git_dir/cvs-revisions"
 713     or die "Can't open $git_dir/cvs-revisions for appending: $!\n"
 714         if defined $opt_R;
 715
 716
 717 #
 718 # run cvsps into a file unless we are getting
 719 # it passed as a file via $opt_P
 720 #
 721 my $cvspsfile;
 722 unless ($opt_P) {
 723         print "Running cvsps...\n" if $opt_v;
 724         my $pid = open(CVSPS,"-|");
 725         my $cvspsfh;
 726         die "Cannot fork: $!\n" unless defined $pid;
 727         unless ($pid) {
 728                 my @opt;
 729                 @opt = split(/,/,$opt_p) if defined $opt_p;
 730                 unshift @opt, '-z', $opt_z if defined $opt_z;
 731                 unshift @opt, '-q'         unless defined $opt_v;
 732                 unless (defined($opt_p) && $opt_p =~ m/--no-cvs-direct/) {
 733                         push @opt, '--cvs-direct';
 734                 }
 735                 exec("cvsps","--norc",@opt,"-u","-A",'--root',$opt_d,$cvs_tree);
 736                 die "Could not start cvsps: $!\n";
 737         }
 738         ($cvspsfh, $cvspsfile) = tempfile('gitXXXXXX', SUFFIX => '.cvsps',
 739                                           DIR => File::Spec->tmpdir());
 740         while (<CVSPS>) {
 741             print $cvspsfh $_;
 742         }
 743         close CVSPS;
 744         $? == 0 or die "git cvsimport: fatal: cvsps reported error\n";
 745         close $cvspsfh;
 746 } else {
 747         $cvspsfile = munge_user_filename($opt_P);
 748 }
 749
 750 open(CVS, "<$cvspsfile") or die $!;
 751
 752 ## cvsps output:
 753 #---------------------
 754 #PatchSet 314
 755 #Date: 1999/09/18 13:03:59
 756 #Author: wkoch
 757 #Branch: STABLE-BRANCH-1-0
 758 #Ancestor branch: HEAD
 759 #Tag: (none)
 760 #Log:
 761 #    See ChangeLog: Sat Sep 18 13:03:28 CEST 1999  Werner Koch
 762 #Members:
 763 #       README:1.57->1.57.2.1
 764 #       VERSION:1.96->1.96.2.1
 765 #
 766 #---------------------
 767
 768 my $state = 0;
 769
 770 sub update_index (\@\@) {
 771         my $old = shift;
 772         my $new = shift;
 773         open(my $fh, '|-', qw(git update-index -z --index-info))
 774                 or die "unable to open git update-index: $!";
 775         print $fh
 776                 (map { "0 0000000000000000000000000000000000000000\t$_\0" }
 777                         @$old),
 778                 (map { '100' . sprintf('%o', $_->[0]) . " $_->[1]\t$_->[2]\0" }
 779                         @$new)
 780                 or die "unable to write to git update-index: $!";
 781         close $fh
 782                 or die "unable to write to git update-index: $!";
 783         $? and die "git update-index reported error: $?";
 784 }
 785
 786 sub write_tree () {
 787         open(my $fh, '-|', qw(git write-tree))
 788                 or die "unable to open git write-tree: $!";
 789         chomp(my $tree = <$fh>);
 790         is_sha1($tree)
 791                 or die "Cannot get tree id ($tree): $!";
 792         close($fh)
 793                 or die "Error running git write-tree: $?\n";
 794         print "Tree ID $tree\n" if $opt_v;
 795         return $tree;
 796 }
 797
 798 my ($patchset,$date,$author_name,$author_email,$branch,$ancestor,$tag,$logmsg);
 799 my (@old,@new,@skipped,%ignorebranch,@commit_revisions);
 800
 801 # commits that cvsps cannot place anywhere...
 802 $ignorebranch{'#CVSPS_NO_BRANCH'} = 1;
 803
 804 sub commit {
 805         if ($branch eq $opt_o && !$index{branch} &&
 806                 !get_headref("$remote/$branch")) {
 807             # looks like an initial commit
 808             # use the index primed by git init
 809             $ENV{GIT_INDEX_FILE} = "$git_dir/index";
 810             $index{$branch} = "$git_dir/index";
 811         } else {
 812             # use an index per branch to speed up
 813             # imports of projects with many branches
 814             unless ($index{$branch}) {
 815                 $index{$branch} = tmpnam();
 816                 $ENV{GIT_INDEX_FILE} = $index{$branch};
 817                 if ($ancestor) {
 818                     system("git", "read-tree", "$remote/$ancestor");
 819                 } else {
 820                     system("git", "read-tree", "$remote/$branch");
 821                 }
 822                 die "read-tree failed: $?\n" if $?;
 823             }
 824         }
 825         $ENV{GIT_INDEX_FILE} = $index{$branch};
 826
 827         update_index(@old, @new);
 828         @old = @new = ();
 829         my $tree = write_tree();
 830         my $parent = get_headref("$remote/$last_branch");
 831         print "Parent ID " . ($parent ? $parent : "(empty)") . "\n" if $opt_v;
 832
 833         my @commit_args;
 834         push @commit_args, ("-p", $parent) if $parent;
 835
 836         # loose detection of merges
 837         # based on the commit msg
 838         foreach my $rx (@mergerx) {
 839                 next unless $logmsg =~ $rx && $1;
 840                 my $mparent = $1 eq 'HEAD' ? $opt_o : $1;
 841                 if (my $sha1 = get_headref("$remote/$mparent")) {
 842                         push @commit_args, '-p', "$remote/$mparent";
 843                         print "Merge parent branch: $mparent\n" if $opt_v;
 844                 }
 845         }
 846
 847         my $commit_date = strftime("+0000 %Y-%m-%d %H:%M:%S",gmtime($date));
 848         $ENV{GIT_AUTHOR_NAME} = $author_name;
 849         $ENV{GIT_AUTHOR_EMAIL} = $author_email;
 850         $ENV{GIT_AUTHOR_DATE} = $commit_date;
 851         $ENV{GIT_COMMITTER_NAME} = $author_name;
 852         $ENV{GIT_COMMITTER_EMAIL} = $author_email;
 853         $ENV{GIT_COMMITTER_DATE} = $commit_date;
 854         my $pid = open2(my $commit_read, my $commit_write,
 855                 'git', 'commit-tree', $tree, @commit_args);
 856
 857         # compatibility with git2cvs
 858         substr($logmsg,32767) = "" if length($logmsg) > 32767;
 859         $logmsg =~ s/[\s\n]+\z//;
 860
 861         if (@skipped) {
 862             $logmsg .= "\n\n\nSKIPPED:\n\t";
 863             $logmsg .= join("\n\t", @skipped) . "\n";
 864             @skipped = ();
 865         }
 866
 867         print($commit_write "$logmsg\n") && close($commit_write)
 868                 or die "Error writing to git commit-tree: $!\n";
 869
 870         print "Committed patch $patchset ($branch $commit_date)\n" if $opt_v;
 871         chomp(my $cid = <$commit_read>);
 872         is_sha1($cid) or die "Cannot get commit id ($cid): $!\n";
 873         print "Commit ID $cid\n" if $opt_v;
 874         close($commit_read);
 875
 876         waitpid($pid,0);
 877         die "Error running git commit-tree: $?\n" if $?;
 878
 879         system('git' , 'update-ref', "$remote/$branch", $cid) == 0
 880                 or die "Cannot write branch $branch for update: $!\n";
 881
 882         if ($revision_map) {
 883                 print $revision_map "@$_ $cid\n" for @commit_revisions;
 884         }
 885         @commit_revisions = ();
 886
 887         if ($tag) {
 888                 my ($xtag) = $tag;
 889                 $xtag =~ s/\s+\*\*.*$//; # Remove stuff like ** INVALID ** and ** FUNKY **
 890                 $xtag =~ tr/_/\./ if ( $opt_u );
 891                 $xtag =~ s/[\/]/$opt_s/g;
 892                 $xtag =~ s/\[//g;
 893
 894                 system('git' , 'tag', '-f', $xtag, $cid) == 0
 895                         or die "Cannot create tag $xtag: $!\n";
 896
 897                 print "Created tag '$xtag' on '$branch'\n" if $opt_v;
 898         }
 899 };
 900
 901 my $commitcount = 1;
 902 while (<CVS>) {
 903         chomp;
 904         if ($state == 0 and /^-+$/) {
 905                 $state = 1;
 906         } elsif ($state == 0) {
 907                 $state = 1;
 908                 redo;
 909         } elsif (($state==0 or $state==1) and s/^PatchSet\s+//) {
 910                 $patchset = 0+$_;
 911                 $state=2;
 912         } elsif ($state == 2 and s/^Date:\s+//) {
 913                 $date = pdate($_);
 914                 unless ($date) {
 915                         print STDERR "Could not parse date: $_\n";
 916                         $state=0;
 917                         next;
 918                 }
 919                 $state=3;
 920         } elsif ($state == 3 and s/^Author:\s+//) {
 921                 s/\s+$//;
 922                 if (/^(.*?)\s+<(.*)>/) {
 923                     ($author_name, $author_email) = ($1, $2);
 924                 } elsif ($conv_author_name{$_}) {
 925                         $author_name = $conv_author_name{$_};
 926                         $author_email = $conv_author_email{$_};
 927                 } else {
 928                     $author_name = $author_email = $_;
 929                 }
 930                 $state = 4;
 931         } elsif ($state == 4 and s/^Branch:\s+//) {
 932                 s/\s+$//;
 933                 tr/_/\./ if ( $opt_u );
 934                 s/[\/]/$opt_s/g;
 935                 $branch = $_;
 936                 $state = 5;
 937         } elsif ($state == 5 and s/^Ancestor branch:\s+//) {
 938                 s/\s+$//;
 939                 $ancestor = $_;
 940                 $ancestor = $opt_o if $ancestor eq "HEAD";
 941                 $state = 6;
 942         } elsif ($state == 5) {
 943                 $ancestor = undef;
 944                 $state = 6;
 945                 redo;
 946         } elsif ($state == 6 and s/^Tag:\s+//) {
 947                 s/\s+$//;
 948                 if ($_ eq "(none)") {
 949                         $tag = undef;
 950                 } else {
 951                         $tag = $_;
 952                 }
 953                 $state = 7;
 954         } elsif ($state == 7 and /^Log:/) {
 955                 $logmsg = "";
 956                 $state = 8;
 957         } elsif ($state == 8 and /^Members:/) {
 958                 $branch = $opt_o if $branch eq "HEAD";
 959                 if (defined $branch_date{$branch} and $branch_date{$branch} >= $date) {
 960                         # skip
 961                         print "skip patchset $patchset: $date before $branch_date{$branch}\n" if $opt_v;
 962                         $state = 11;
 963                         next;
 964                 }
 965                 if (!$opt_a && $starttime - 300 - (defined $opt_z ? $opt_z : 300) <= $date) {
 966                         # skip if the commit is too recent
 967                         # given that the cvsps default fuzz is 300s, we give ourselves another
 968                         # 300s just in case -- this also prevents skipping commits
 969                         # due to server clock drift
 970                         print "skip patchset $patchset: $date too recent\n" if $opt_v;
 971                         $state = 11;
 972                         next;
 973                 }
 974                 if (exists $ignorebranch{$branch}) {
 975                         print STDERR "Skipping $branch\n";
 976                         $state = 11;
 977                         next;
 978                 }
 979                 if ($ancestor) {
 980                         if ($ancestor eq $branch) {
 981                                 print STDERR "Branch $branch erroneously stems from itself -- changed ancestor to $opt_o\n";
 982                                 $ancestor = $opt_o;
 983                         }
 984                         if (defined get_headref("$remote/$branch")) {
 985                                 print STDERR "Branch $branch already exists!\n";
 986                                 $state=11;
 987                                 next;
 988                         }
 989                         my $id = get_headref("$remote/$ancestor");
 990                         if (!$id) {
 991                                 print STDERR "Branch $ancestor does not exist!\n";
 992                                 $ignorebranch{$branch} = 1;
 993                                 $state=11;
 994                                 next;
 995                         }
 996
 997                         system(qw(git update-ref -m cvsimport),
 998                                 "$remote/$branch", $id);
 999                         if($? != 0) {
1000                                 print STDERR "Could not create branch $branch\n";
1001                                 $ignorebranch{$branch} = 1;
1002                                 $state=11;
1003                                 next;
1004                         }
1005                 }
1006                 $last_branch = $branch if $branch ne $last_branch;
1007                 $state = 9;
1008         } elsif ($state == 8) {
1009                 $logmsg .= "$_\n";
1010         } elsif ($state == 9 and /^\s+(.+?):(INITIAL|\d+(?:\.\d+)+)->(\d+(?:\.\d+)+)\s*$/) {
1011 #       VERSION:1.96->1.96.2.1
1012                 my $init = ($2 eq "INITIAL");
1013                 my $fn = $1;
1014                 my $rev = $3;
1015                 $fn =~ s#^/+##;
1016                 if ($opt_S && $fn =~ m/$opt_S/) {
1017                     print "SKIPPING $fn v $rev\n";
1018                     push(@skipped, $fn);
1019                     next;
1020                 }
1021                 push @commit_revisions, [$fn, $rev];
1022                 print "Fetching $fn   v $rev\n" if $opt_v;
1023                 my ($tmpname, $size) = $cvs->file($fn,$rev);
1024                 if ($size == -1) {
1025                         push(@old,$fn);
1026                         print "Drop $fn\n" if $opt_v;
1027                 } else {
1028                         print "".($init ? "New" : "Update")." $fn: $size bytes\n" if $opt_v;
1029                         my $pid = open(my $F, '-|');
1030                         die $! unless defined $pid;
1031                         if (!$pid) {
1032                             exec("git", "hash-object", "-w", $tmpname)
1033                                 or die "Cannot create object: $!\n";
1034                         }
1035                         my $sha = <$F>;
1036                         chomp $sha;
1037                         close $F;
1038                         my $mode = pmode($cvs->{'mode'});
1039                         push(@new,[$mode, $sha, $fn]); # may be resurrected!
1040                 }
1041                 unlink($tmpname);
1042         } elsif ($state == 9 and /^\s+(.+?):\d+(?:\.\d+)+->(\d+(?:\.\d+)+)\(DEAD\)\s*$/) {
1043                 my $fn = $1;
1044                 my $rev = $2;
1045                 $fn =~ s#^/+##;
1046                 push @commit_revisions, [$fn, $rev];
1047                 push(@old,$fn);
1048                 print "Delete $fn\n" if $opt_v;
1049         } elsif ($state == 9 and /^\s*$/) {
1050                 $state = 10;
1051         } elsif (($state == 9 or $state == 10) and /^-+$/) {
1052                 $commitcount++;
1053                 if ($opt_L && $commitcount > $opt_L) {
1054                         last;
1055                 }
1056                 commit();
1057                 if (($commitcount & 1023) == 0) {
1058                         system(qw(git repack -a -d));
1059                 }
1060                 $state = 1;
1061         } elsif ($state == 11 and /^-+$/) {
1062                 $state = 1;
1063         } elsif (/^-+$/) { # end of unknown-line processing
1064                 $state = 1;
1065         } elsif ($state != 11) { # ignore stuff when skipping
1066                 print STDERR "* UNKNOWN LINE * $_\n";
1067         }
1068 }
1069 commit() if $branch and $state != 11;
1070
1071 unless ($opt_P) {
1072         unlink($cvspsfile);
1073 }
1074
1075 # The heuristic of repacking every 1024 commits can leave a
1076 # lot of unpacked data.  If there is more than 1MB worth of
1077 # not-packed objects, repack once more.
1078 my $line = `git count-objects`;
1079 if ($line =~ /^(\d+) objects, (\d+) kilobytes$/) {
1080   my ($n_objects, $kb) = ($1, $2);
1081   1024 < $kb
1082     and system(qw(git repack -a -d));
1083 }
1084
1085 foreach my $git_index (values %index) {
1086     if ($git_index ne "$git_dir/index") {
1087         unlink($git_index);
1088     }
1089 }
1090
1091 if (defined $orig_git_index) {
1092         $ENV{GIT_INDEX_FILE} = $orig_git_index;
1093 } else {
1094         delete $ENV{GIT_INDEX_FILE};
1095 }
1096
1097 # Now switch back to the branch we were in before all of this happened
1098 if ($orig_branch) {
1099         print "DONE.\n" if $opt_v;
1100         if ($opt_i) {
1101                 exit 0;
1102         }
1103         my $tip_at_end = `git rev-parse --verify HEAD`;
1104         if ($tip_at_start ne $tip_at_end) {
1105                 for ($tip_at_start, $tip_at_end) { chomp; }
1106                 print "Fetched into the current branch.\n" if $opt_v;
1107                 system(qw(git read-tree -u -m),
1108                        $tip_at_start, $tip_at_end);
1109                 die "Fast-forward update failed: $?\n" if $?;
1110         }
1111         else {
1112                 system(qw(git merge cvsimport HEAD), "$remote/$opt_o");
1113                 die "Could not merge $opt_o into the current branch.\n" if $?;
1114         }
1115 } else {
1116         $orig_branch = "master";
1117         print "DONE; creating $orig_branch branch\n" if $opt_v;
1118         system("git", "update-ref", "refs/heads/master", "$remote/$opt_o")
1119                 unless defined get_headref('refs/heads/master');
1120         system("git", "symbolic-ref", "$remote/HEAD", "$remote/$opt_o")
1121                 if ($opt_r && $opt_o ne 'HEAD');
1122         system('git', 'update-ref', 'HEAD', "$orig_branch");
1123         unless ($opt_i) {
1124                 system(qw(git checkout -f));
1125                 die "checkout failed: $?\n" if $?;
1126         }
1127 }