git-verify-pack: more careful path handling
[git/jrn.git] / git-send-email.perl
bloba83c7e90948fc3fe1b1ac82335704d66d060edab
1 #!/usr/bin/perl -w
3 # Copyright 2002,2005 Greg Kroah-Hartman <greg@kroah.com>
4 # Copyright 2005 Ryan Anderson <ryan@michonline.com>
6 # GPL v2 (See COPYING)
8 # Ported to support git "mbox" format files by Ryan Anderson <ryan@michonline.com>
10 # Sends a collection of emails to the given email addresses, disturbingly fast.
12 # Supports two formats:
13 # 1. mbox format files (ignoring most headers and MIME formatting - this is designed for sending patches)
14 # 2. The original format support by Greg's script:
15 # first line of the message is who to CC,
16 # and second line is the subject of the message.
19 use strict;
20 use warnings;
21 use Term::ReadLine;
22 use Getopt::Long;
23 use Data::Dumper;
25 package FakeTerm;
26 sub new {
27 my ($class, $reason) = @_;
28 return bless \$reason, shift;
30 sub readline {
31 my $self = shift;
32 die "Cannot use readline on FakeTerm: $$self";
34 package main;
36 # most mail servers generate the Date: header, but not all...
37 sub format_2822_time {
38 my ($time) = @_;
39 my @localtm = localtime($time);
40 my @gmttm = gmtime($time);
41 my $localmin = $localtm[1] + $localtm[2] * 60;
42 my $gmtmin = $gmttm[1] + $gmttm[2] * 60;
43 if ($localtm[0] != $gmttm[0]) {
44 die "local zone differs from GMT by a non-minute interval\n";
46 if ((($gmttm[6] + 1) % 7) == $localtm[6]) {
47 $localmin += 1440;
48 } elsif ((($gmttm[6] - 1) % 7) == $localtm[6]) {
49 $localmin -= 1440;
50 } elsif ($gmttm[6] != $localtm[6]) {
51 die "local time offset greater than or equal to 24 hours\n";
53 my $offset = $localmin - $gmtmin;
54 my $offhour = $offset / 60;
55 my $offmin = abs($offset % 60);
56 if (abs($offhour) >= 24) {
57 die ("local time offset greater than or equal to 24 hours\n");
60 return sprintf("%s, %2d %s %d %02d:%02d:%02d %s%02d%02d",
61 qw(Sun Mon Tue Wed Thu Fri Sat)[$localtm[6]],
62 $localtm[3],
63 qw(Jan Feb Mar Apr May Jun
64 Jul Aug Sep Oct Nov Dec)[$localtm[4]],
65 $localtm[5]+1900,
66 $localtm[2],
67 $localtm[1],
68 $localtm[0],
69 ($offset >= 0) ? '+' : '-',
70 abs($offhour),
71 $offmin,
75 my $have_email_valid = eval { require Email::Valid; 1 };
76 my $smtp;
78 sub unique_email_list(@);
79 sub cleanup_compose_files();
81 # Constants (essentially)
82 my $compose_filename = ".msg.$$";
84 # Variables we fill in automatically, or via prompting:
85 my (@to,@cc,@initial_cc,@bcclist,
86 $initial_reply_to,$initial_subject,@files,$from,$compose,$time);
88 # Behavior modification variables
89 my ($chain_reply_to, $quiet, $suppress_from, $no_signed_off_cc) = (1, 0, 0, 0);
90 my $smtp_server;
92 # Example reply to:
93 #$initial_reply_to = ''; #<20050203173208.GA23964@foobar.com>';
95 my $term = eval {
96 new Term::ReadLine 'git-send-email';
98 if ($@) {
99 $term = new FakeTerm "$@: going non-interactive";
102 # Begin by accumulating all the variables (defined above), that we will end up
103 # needing, first, from the command line:
105 my $rc = GetOptions("from=s" => \$from,
106 "in-reply-to=s" => \$initial_reply_to,
107 "subject=s" => \$initial_subject,
108 "to=s" => \@to,
109 "cc=s" => \@initial_cc,
110 "bcc=s" => \@bcclist,
111 "chain-reply-to!" => \$chain_reply_to,
112 "smtp-server=s" => \$smtp_server,
113 "compose" => \$compose,
114 "quiet" => \$quiet,
115 "suppress-from" => \$suppress_from,
116 "no-signed-off-cc|no-signed-off-by-cc" => \$no_signed_off_cc,
119 # Verify the user input
121 foreach my $entry (@to) {
122 die "Comma in --to entry: $entry'\n" unless $entry !~ m/,/;
125 foreach my $entry (@initial_cc) {
126 die "Comma in --cc entry: $entry'\n" unless $entry !~ m/,/;
129 foreach my $entry (@bcclist) {
130 die "Comma in --bcclist entry: $entry'\n" unless $entry !~ m/,/;
133 # Now, let's fill any that aren't set in with defaults:
135 sub gitvar {
136 my ($var) = @_;
137 my $fh;
138 my $pid = open($fh, '-|');
139 die "$!" unless defined $pid;
140 if (!$pid) {
141 exec('git-var', $var) or die "$!";
143 my ($val) = <$fh>;
144 close $fh or die "$!";
145 chomp($val);
146 return $val;
149 sub gitvar_ident {
150 my ($name) = @_;
151 my $val = gitvar($name);
152 my @field = split(/\s+/, $val);
153 return join(' ', @field[0...(@field-3)]);
156 my ($author) = gitvar_ident('GIT_AUTHOR_IDENT');
157 my ($committer) = gitvar_ident('GIT_COMMITTER_IDENT');
159 my %aliases;
160 chomp(my @alias_files = `git-repo-config --get-all sendemail.aliasesfile`);
161 chomp(my $aliasfiletype = `git-repo-config sendemail.aliasfiletype`);
162 my %parse_alias = (
163 # multiline formats can be supported in the future
164 mutt => sub { my $fh = shift; while (<$fh>) {
165 if (/^alias\s+(\S+)\s+(.*)$/) {
166 my ($alias, $addr) = ($1, $2);
167 $addr =~ s/#.*$//; # mutt allows # comments
168 # commas delimit multiple addresses
169 $aliases{$alias} = [ split(/\s*,\s*/, $addr) ];
170 }}},
171 mailrc => sub { my $fh = shift; while (<$fh>) {
172 if (/^alias\s+(\S+)\s+(.*)$/) {
173 # spaces delimit multiple addresses
174 $aliases{$1} = [ split(/\s+/, $2) ];
175 }}},
176 pine => sub { my $fh = shift; while (<$fh>) {
177 if (/^(\S+)\s+(.*)$/) {
178 $aliases{$1} = [ split(/\s*,\s*/, $2) ];
179 }}},
180 gnus => sub { my $fh = shift; while (<$fh>) {
181 if (/\(define-mail-alias\s+"(\S+?)"\s+"(\S+?)"\)/) {
182 $aliases{$1} = [ $2 ];
186 if (@alias_files && defined $parse_alias{$aliasfiletype}) {
187 foreach my $file (@alias_files) {
188 open my $fh, '<', $file or die "opening $file: $!\n";
189 $parse_alias{$aliasfiletype}->($fh);
190 close $fh;
194 my $prompting = 0;
195 if (!defined $from) {
196 $from = $author || $committer;
197 do {
198 $_ = $term->readline("Who should the emails appear to be from? ",
199 $from);
200 } while (!defined $_);
202 $from = $_;
203 print "Emails will be sent from: ", $from, "\n";
204 $prompting++;
207 if (!@to) {
208 do {
209 $_ = $term->readline("Who should the emails be sent to? ",
210 "");
211 } while (!defined $_);
212 my $to = $_;
213 push @to, split /,/, $to;
214 $prompting++;
217 sub expand_aliases {
218 my @cur = @_;
219 my @last;
220 do {
221 @last = @cur;
222 @cur = map { $aliases{$_} ? @{$aliases{$_}} : $_ } @last;
223 } while (join(',',@cur) ne join(',',@last));
224 return @cur;
227 @to = expand_aliases(@to);
228 @initial_cc = expand_aliases(@initial_cc);
229 @bcclist = expand_aliases(@bcclist);
231 if (!defined $initial_subject && $compose) {
232 do {
233 $_ = $term->readline("What subject should the emails start with? ",
234 $initial_subject);
235 } while (!defined $_);
236 $initial_subject = $_;
237 $prompting++;
240 if (!defined $initial_reply_to && $prompting) {
241 do {
242 $_= $term->readline("Message-ID to be used as In-Reply-To for the first email? ",
243 $initial_reply_to);
244 } while (!defined $_);
246 $initial_reply_to = $_;
247 $initial_reply_to =~ s/(^\s+|\s+$)//g;
250 if (!$smtp_server) {
251 foreach (qw( /usr/sbin/sendmail /usr/lib/sendmail )) {
252 if (-x $_) {
253 $smtp_server = $_;
254 last;
257 $smtp_server ||= 'localhost'; # could be 127.0.0.1, too... *shrug*
260 if ($compose) {
261 # Note that this does not need to be secure, but we will make a small
262 # effort to have it be unique
263 open(C,">",$compose_filename)
264 or die "Failed to open for writing $compose_filename: $!";
265 print C "From $from # This line is ignored.\n";
266 printf C "Subject: %s\n\n", $initial_subject;
267 printf C <<EOT;
268 GIT: Please enter your email below.
269 GIT: Lines beginning in "GIT: " will be removed.
270 GIT: Consider including an overall diffstat or table of contents
271 GIT: for the patch you are writing.
274 close(C);
276 my $editor = $ENV{EDITOR};
277 $editor = 'vi' unless defined $editor;
278 system($editor, $compose_filename);
280 open(C2,">",$compose_filename . ".final")
281 or die "Failed to open $compose_filename.final : " . $!;
283 open(C,"<",$compose_filename)
284 or die "Failed to open $compose_filename : " . $!;
286 while(<C>) {
287 next if m/^GIT: /;
288 print C2 $_;
290 close(C);
291 close(C2);
293 do {
294 $_ = $term->readline("Send this email? (y|n) ");
295 } while (!defined $_);
297 if (uc substr($_,0,1) ne 'Y') {
298 cleanup_compose_files();
299 exit(0);
302 @files = ($compose_filename . ".final");
306 # Now that all the defaults are set, process the rest of the command line
307 # arguments and collect up the files that need to be processed.
308 for my $f (@ARGV) {
309 if (-d $f) {
310 opendir(DH,$f)
311 or die "Failed to opendir $f: $!";
313 push @files, grep { -f $_ } map { +$f . "/" . $_ }
314 sort readdir(DH);
316 } elsif (-f $f) {
317 push @files, $f;
319 } else {
320 print STDERR "Skipping $f - not found.\n";
324 if (@files) {
325 unless ($quiet) {
326 print $_,"\n" for (@files);
328 } else {
329 print <<EOT;
330 git-send-email [options] <file | directory> [... file | directory ]
331 Options:
332 --from Specify the "From:" line of the email to be sent.
334 --to Specify the primary "To:" line of the email.
336 --cc Specify an initial "Cc:" list for the entire series
337 of emails.
339 --bcc Specify a list of email addresses that should be Bcc:
340 on all the emails.
342 --compose Use \$EDITOR to edit an introductory message for the
343 patch series.
345 --subject Specify the initial "Subject:" line.
346 Only necessary if --compose is also set. If --compose
347 is not set, this will be prompted for.
349 --in-reply-to Specify the first "In-Reply-To:" header line.
350 Only used if --compose is also set. If --compose is not
351 set, this will be prompted for.
353 --chain-reply-to If set, the replies will all be to the previous
354 email sent, rather than to the first email sent.
355 Defaults to on.
357 --no-signed-off-cc Suppress the automatic addition of email addresses
358 that appear in a Signed-off-by: line, to the cc: list.
359 Note: Using this option is not recommended.
361 --smtp-server If set, specifies the outgoing SMTP server to use.
362 Defaults to localhost.
364 --suppress-from Suppress sending emails to yourself if your address
365 appears in a From: line.
367 --quiet Make git-send-email less verbose. One line per email should be
368 all that is output.
370 Error: Please specify a file or a directory on the command line.
372 exit(1);
375 # Variables we set as part of the loop over files
376 our ($message_id, $cc, %mail, $subject, $reply_to, $references, $message);
378 sub extract_valid_address {
379 my $address = shift;
380 my $local_part_regexp = '[^<>"\s@]+';
381 my $domain_regexp = '[^.<>"\s@]+(?:\.[^.<>"\s@]+)+';
383 # check for a local address:
384 return $address if ($address =~ /^($local_part_regexp)$/);
386 if ($have_email_valid) {
387 return scalar Email::Valid->address($address);
388 } else {
389 # less robust/correct than the monster regexp in Email::Valid,
390 # but still does a 99% job, and one less dependency
391 $address =~ /($local_part_regexp\@$domain_regexp)/;
392 return $1;
396 # Usually don't need to change anything below here.
398 # we make a "fake" message id by taking the current number
399 # of seconds since the beginning of Unix time and tacking on
400 # a random number to the end, in case we are called quicker than
401 # 1 second since the last time we were called.
403 # We'll setup a template for the message id, using the "from" address:
404 my $message_id_from = extract_valid_address($from);
405 my $message_id_template = "<%s-git-send-email-$message_id_from>";
407 sub make_message_id
409 my $date = time;
410 my $pseudo_rand = int (rand(4200));
411 $message_id = sprintf $message_id_template, "$date$pseudo_rand";
412 #print "new message id = $message_id\n"; # Was useful for debugging
417 $cc = "";
418 $time = time - scalar $#files;
420 sub send_message
422 my @recipients = unique_email_list(@to);
423 my $to = join (",\n\t", @recipients);
424 @recipients = unique_email_list(@recipients,@cc,@bcclist);
425 my $date = format_2822_time($time++);
426 my $gitversion = '@@GIT_VERSION@@';
427 if ($gitversion =~ m/..GIT_VERSION../) {
428 $gitversion = `git --version`;
429 chomp $gitversion;
430 # keep only what's after the last space
431 $gitversion =~ s/^.* //;
434 my $header = "From: $from
435 To: $to
436 Cc: $cc
437 Subject: $subject
438 Date: $date
439 Message-Id: $message_id
440 X-Mailer: git-send-email $gitversion
442 if ($reply_to) {
444 $header .= "In-Reply-To: $reply_to\n";
445 $header .= "References: $references\n";
448 if ($smtp_server =~ m#^/#) {
449 my $pid = open my $sm, '|-';
450 defined $pid or die $!;
451 if (!$pid) {
452 exec($smtp_server,'-i',
453 map { extract_valid_address($_) }
454 @recipients) or die $!;
456 print $sm "$header\n$message";
457 close $sm or die $?;
458 } else {
459 require Net::SMTP;
460 $smtp ||= Net::SMTP->new( $smtp_server );
461 $smtp->mail( $from ) or die $smtp->message;
462 $smtp->to( @recipients ) or die $smtp->message;
463 $smtp->data or die $smtp->message;
464 $smtp->datasend("$header\n$message") or die $smtp->message;
465 $smtp->dataend() or die $smtp->message;
466 $smtp->ok or die "Failed to send $subject\n".$smtp->message;
468 if ($quiet) {
469 printf "Sent %s\n", $subject;
470 } else {
471 print "OK. Log says:\nDate: $date\n";
472 if ($smtp) {
473 print "Server: $smtp_server\n";
474 } else {
475 print "Sendmail: $smtp_server\n";
477 print "From: $from\nSubject: $subject\nCc: $cc\nTo: $to\n\n";
478 if ($smtp) {
479 print "Result: ", $smtp->code, ' ',
480 ($smtp->message =~ /\n([^\n]+\n)$/s), "\n";
481 } else {
482 print "Result: OK\n";
487 $reply_to = $initial_reply_to;
488 $references = $initial_reply_to || '';
489 make_message_id();
490 $subject = $initial_subject;
492 foreach my $t (@files) {
493 open(F,"<",$t) or die "can't open file $t";
495 my $author_not_sender = undef;
496 @cc = @initial_cc;
497 my $found_mbox = 0;
498 my $header_done = 0;
499 $message = "";
500 while(<F>) {
501 if (!$header_done) {
502 $found_mbox = 1, next if (/^From /);
503 chomp;
505 if ($found_mbox) {
506 if (/^Subject:\s+(.*)$/) {
507 $subject = $1;
509 } elsif (/^(Cc|From):\s+(.*)$/) {
510 if ($2 eq $from) {
511 next if ($suppress_from);
513 else {
514 $author_not_sender = $2;
516 printf("(mbox) Adding cc: %s from line '%s'\n",
517 $2, $_) unless $quiet;
518 push @cc, $2;
521 } else {
522 # In the traditional
523 # "send lots of email" format,
524 # line 1 = cc
525 # line 2 = subject
526 # So let's support that, too.
527 if (@cc == 0) {
528 printf("(non-mbox) Adding cc: %s from line '%s'\n",
529 $_, $_) unless $quiet;
531 push @cc, $_;
533 } elsif (!defined $subject) {
534 $subject = $_;
538 # A whitespace line will terminate the headers
539 if (m/^\s*$/) {
540 $header_done = 1;
542 } else {
543 $message .= $_;
544 if (/^Signed-off-by: (.*)$/i && !$no_signed_off_cc) {
545 my $c = $1;
546 chomp $c;
547 push @cc, $c;
548 printf("(sob) Adding cc: %s from line '%s'\n",
549 $c, $_) unless $quiet;
553 close F;
554 if (defined $author_not_sender) {
555 $message = "From: $author_not_sender\n\n$message";
558 $cc = join(", ", unique_email_list(@cc));
560 send_message();
562 # set up for the next message
563 if ($chain_reply_to || length($reply_to) == 0) {
564 $reply_to = $message_id;
565 if (length $references > 0) {
566 $references .= " $message_id";
567 } else {
568 $references = "$message_id";
571 make_message_id();
574 if ($compose) {
575 cleanup_compose_files();
578 sub cleanup_compose_files() {
579 unlink($compose_filename, $compose_filename . ".final");
583 $smtp->quit if $smtp;
585 sub unique_email_list(@) {
586 my %seen;
587 my @emails;
589 foreach my $entry (@_) {
590 if (my $clean = extract_valid_address($entry)) {
591 $seen{$clean} ||= 0;
592 next if $seen{$clean}++;
593 push @emails, $entry;
594 } else {
595 print STDERR "W: unable to extract a valid address",
596 " from: $entry\n";
599 return @emails;