git-send-email.perlon commit Merge branch 'rs/apply-avoid-over-reading' (6fee4ca)
   1#!/usr/bin/perl
   2#
   3# Copyright 2002,2005 Greg Kroah-Hartman <greg@kroah.com>
   4# Copyright 2005 Ryan Anderson <ryan@michonline.com>
   5#
   6# GPL v2 (See COPYING)
   7#
   8# Ported to support git "mbox" format files by Ryan Anderson <ryan@michonline.com>
   9#
  10# Sends a collection of emails to the given email addresses, disturbingly fast.
  11#
  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.
  17#
  18
  19use 5.008;
  20use strict;
  21use warnings;
  22use POSIX qw/strftime/;
  23use Term::ReadLine;
  24use Getopt::Long;
  25use Text::ParseWords;
  26use Term::ANSIColor;
  27use File::Temp qw/ tempdir tempfile /;
  28use File::Spec::Functions qw(catdir catfile);
  29use Error qw(:try);
  30use Cwd qw(abs_path cwd);
  31use Git;
  32use Git::I18N;
  33
  34Getopt::Long::Configure qw/ pass_through /;
  35
  36package FakeTerm;
  37sub new {
  38        my ($class, $reason) = @_;
  39        return bless \$reason, shift;
  40}
  41sub readline {
  42        my $self = shift;
  43        die "Cannot use readline on FakeTerm: $$self";
  44}
  45package main;
  46
  47
  48sub usage {
  49        print <<EOT;
  50git send-email [options] <file | directory | rev-list options >
  51git send-email --dump-aliases
  52
  53  Composing:
  54    --from                  <str>  * Email From:
  55    --[no-]to               <str>  * Email To:
  56    --[no-]cc               <str>  * Email Cc:
  57    --[no-]bcc              <str>  * Email Bcc:
  58    --subject               <str>  * Email "Subject:"
  59    --in-reply-to           <str>  * Email "In-Reply-To:"
  60    --[no-]xmailer                 * Add "X-Mailer:" header (default).
  61    --[no-]annotate                * Review each patch that will be sent in an editor.
  62    --compose                      * Open an editor for introduction.
  63    --compose-encoding      <str>  * Encoding to assume for introduction.
  64    --8bit-encoding         <str>  * Encoding to assume 8bit mails if undeclared
  65    --transfer-encoding     <str>  * Transfer encoding to use (quoted-printable, 8bit, base64)
  66
  67  Sending:
  68    --envelope-sender       <str>  * Email envelope sender.
  69    --smtp-server       <str:int>  * Outgoing SMTP server to use. The port
  70                                     is optional. Default 'localhost'.
  71    --smtp-server-option    <str>  * Outgoing SMTP server option to use.
  72    --smtp-server-port      <int>  * Outgoing SMTP server port.
  73    --smtp-user             <str>  * Username for SMTP-AUTH.
  74    --smtp-pass             <str>  * Password for SMTP-AUTH; not necessary.
  75    --smtp-encryption       <str>  * tls or ssl; anything else disables.
  76    --smtp-ssl                     * Deprecated. Use '--smtp-encryption ssl'.
  77    --smtp-ssl-cert-path    <str>  * Path to ca-certificates (either directory or file).
  78                                     Pass an empty string to disable certificate
  79                                     verification.
  80    --smtp-domain           <str>  * The domain name sent to HELO/EHLO handshake
  81    --smtp-auth             <str>  * Space-separated list of allowed AUTH mechanisms.
  82                                     This setting forces to use one of the listed mechanisms.
  83    --smtp-debug            <0|1>  * Disable, enable Net::SMTP debug.
  84
  85    --batch-size            <int>  * send max <int> message per connection.
  86    --relogin-delay         <int>  * delay <int> seconds between two successive login.
  87                                     This option can only be used with --batch-size
  88
  89  Automating:
  90    --identity              <str>  * Use the sendemail.<id> options.
  91    --to-cmd                <str>  * Email To: via `<str> \$patch_path`
  92    --cc-cmd                <str>  * Email Cc: via `<str> \$patch_path`
  93    --suppress-cc           <str>  * author, self, sob, cc, cccmd, body, bodycc, all.
  94    --[no-]cc-cover                * Email Cc: addresses in the cover letter.
  95    --[no-]to-cover                * Email To: addresses in the cover letter.
  96    --[no-]signed-off-by-cc        * Send to Signed-off-by: addresses. Default on.
  97    --[no-]suppress-from           * Send to self. Default off.
  98    --[no-]chain-reply-to          * Chain In-Reply-To: fields. Default off.
  99    --[no-]thread                  * Use In-Reply-To: field. Default on.
 100
 101  Administering:
 102    --confirm               <str>  * Confirm recipients before sending;
 103                                     auto, cc, compose, always, or never.
 104    --quiet                        * Output one line of info per email.
 105    --dry-run                      * Don't actually send the emails.
 106    --[no-]validate                * Perform patch sanity checks. Default on.
 107    --[no-]format-patch            * understand any non optional arguments as
 108                                     `git format-patch` ones.
 109    --force                        * Send even if safety checks would prevent it.
 110
 111  Information:
 112    --dump-aliases                 * Dump configured aliases and exit.
 113
 114EOT
 115        exit(1);
 116}
 117
 118# most mail servers generate the Date: header, but not all...
 119sub format_2822_time {
 120        my ($time) = @_;
 121        my @localtm = localtime($time);
 122        my @gmttm = gmtime($time);
 123        my $localmin = $localtm[1] + $localtm[2] * 60;
 124        my $gmtmin = $gmttm[1] + $gmttm[2] * 60;
 125        if ($localtm[0] != $gmttm[0]) {
 126                die __("local zone differs from GMT by a non-minute interval\n");
 127        }
 128        if ((($gmttm[6] + 1) % 7) == $localtm[6]) {
 129                $localmin += 1440;
 130        } elsif ((($gmttm[6] - 1) % 7) == $localtm[6]) {
 131                $localmin -= 1440;
 132        } elsif ($gmttm[6] != $localtm[6]) {
 133                die __("local time offset greater than or equal to 24 hours\n");
 134        }
 135        my $offset = $localmin - $gmtmin;
 136        my $offhour = $offset / 60;
 137        my $offmin = abs($offset % 60);
 138        if (abs($offhour) >= 24) {
 139                die __("local time offset greater than or equal to 24 hours\n");
 140        }
 141
 142        return sprintf("%s, %2d %s %d %02d:%02d:%02d %s%02d%02d",
 143                       qw(Sun Mon Tue Wed Thu Fri Sat)[$localtm[6]],
 144                       $localtm[3],
 145                       qw(Jan Feb Mar Apr May Jun
 146                          Jul Aug Sep Oct Nov Dec)[$localtm[4]],
 147                       $localtm[5]+1900,
 148                       $localtm[2],
 149                       $localtm[1],
 150                       $localtm[0],
 151                       ($offset >= 0) ? '+' : '-',
 152                       abs($offhour),
 153                       $offmin,
 154                       );
 155}
 156
 157my $have_email_valid = eval { require Email::Valid; 1 };
 158my $have_mail_address = eval { require Mail::Address; 1 };
 159my $smtp;
 160my $auth;
 161my $num_sent = 0;
 162
 163# Regexes for RFC 2047 productions.
 164my $re_token = qr/[^][()<>@,;:\\"\/?.= \000-\037\177-\377]+/;
 165my $re_encoded_text = qr/[^? \000-\037\177-\377]+/;
 166my $re_encoded_word = qr/=\?($re_token)\?($re_token)\?($re_encoded_text)\?=/;
 167
 168# Variables we fill in automatically, or via prompting:
 169my (@to,$no_to,@initial_to,@cc,$no_cc,@initial_cc,@bcclist,$no_bcc,@xh,
 170        $initial_reply_to,$initial_subject,@files,
 171        $author,$sender,$smtp_authpass,$annotate,$use_xmailer,$compose,$time);
 172
 173my $envelope_sender;
 174
 175# Example reply to:
 176#$initial_reply_to = ''; #<20050203173208.GA23964@foobar.com>';
 177
 178my $repo = eval { Git->repository() };
 179my @repo = $repo ? ($repo) : ();
 180my $term = eval {
 181        $ENV{"GIT_SEND_EMAIL_NOTTY"}
 182                ? new Term::ReadLine 'git-send-email', \*STDIN, \*STDOUT
 183                : new Term::ReadLine 'git-send-email';
 184};
 185if ($@) {
 186        $term = new FakeTerm "$@: going non-interactive";
 187}
 188
 189# Behavior modification variables
 190my ($quiet, $dry_run) = (0, 0);
 191my $format_patch;
 192my $compose_filename;
 193my $force = 0;
 194my $dump_aliases = 0;
 195
 196# Handle interactive edition of files.
 197my $multiedit;
 198my $editor;
 199
 200sub do_edit {
 201        if (!defined($editor)) {
 202                $editor = Git::command_oneline('var', 'GIT_EDITOR');
 203        }
 204        if (defined($multiedit) && !$multiedit) {
 205                map {
 206                        system('sh', '-c', $editor.' "$@"', $editor, $_);
 207                        if (($? & 127) || ($? >> 8)) {
 208                                die(__("the editor exited uncleanly, aborting everything"));
 209                        }
 210                } @_;
 211        } else {
 212                system('sh', '-c', $editor.' "$@"', $editor, @_);
 213                if (($? & 127) || ($? >> 8)) {
 214                        die(__("the editor exited uncleanly, aborting everything"));
 215                }
 216        }
 217}
 218
 219# Variables with corresponding config settings
 220my ($thread, $chain_reply_to, $suppress_from, $signed_off_by_cc);
 221my ($cover_cc, $cover_to);
 222my ($to_cmd, $cc_cmd);
 223my ($smtp_server, $smtp_server_port, @smtp_server_options);
 224my ($smtp_authuser, $smtp_encryption, $smtp_ssl_cert_path);
 225my ($batch_size, $relogin_delay);
 226my ($identity, $aliasfiletype, @alias_files, $smtp_domain, $smtp_auth);
 227my ($validate, $confirm);
 228my (@suppress_cc);
 229my ($auto_8bit_encoding);
 230my ($compose_encoding);
 231my ($target_xfer_encoding);
 232
 233my ($debug_net_smtp) = 0;               # Net::SMTP, see send_message()
 234
 235my %config_bool_settings = (
 236    "thread" => [\$thread, 1],
 237    "chainreplyto" => [\$chain_reply_to, 0],
 238    "suppressfrom" => [\$suppress_from, undef],
 239    "signedoffbycc" => [\$signed_off_by_cc, undef],
 240    "cccover" => [\$cover_cc, undef],
 241    "tocover" => [\$cover_to, undef],
 242    "signedoffcc" => [\$signed_off_by_cc, undef],      # Deprecated
 243    "validate" => [\$validate, 1],
 244    "multiedit" => [\$multiedit, undef],
 245    "annotate" => [\$annotate, undef],
 246    "xmailer" => [\$use_xmailer, 1]
 247);
 248
 249my %config_settings = (
 250    "smtpserver" => \$smtp_server,
 251    "smtpserverport" => \$smtp_server_port,
 252    "smtpserveroption" => \@smtp_server_options,
 253    "smtpuser" => \$smtp_authuser,
 254    "smtppass" => \$smtp_authpass,
 255    "smtpdomain" => \$smtp_domain,
 256    "smtpauth" => \$smtp_auth,
 257    "smtpbatchsize" => \$batch_size,
 258    "smtprelogindelay" => \$relogin_delay,
 259    "to" => \@initial_to,
 260    "tocmd" => \$to_cmd,
 261    "cc" => \@initial_cc,
 262    "cccmd" => \$cc_cmd,
 263    "aliasfiletype" => \$aliasfiletype,
 264    "bcc" => \@bcclist,
 265    "suppresscc" => \@suppress_cc,
 266    "envelopesender" => \$envelope_sender,
 267    "confirm"   => \$confirm,
 268    "from" => \$sender,
 269    "assume8bitencoding" => \$auto_8bit_encoding,
 270    "composeencoding" => \$compose_encoding,
 271    "transferencoding" => \$target_xfer_encoding,
 272);
 273
 274my %config_path_settings = (
 275    "aliasesfile" => \@alias_files,
 276    "smtpsslcertpath" => \$smtp_ssl_cert_path,
 277);
 278
 279# Handle Uncouth Termination
 280sub signal_handler {
 281
 282        # Make text normal
 283        print color("reset"), "\n";
 284
 285        # SMTP password masked
 286        system "stty echo";
 287
 288        # tmp files from --compose
 289        if (defined $compose_filename) {
 290                if (-e $compose_filename) {
 291                        printf __("'%s' contains an intermediate version ".
 292                                  "of the email you were composing.\n"),
 293                                  $compose_filename;
 294                }
 295                if (-e ($compose_filename . ".final")) {
 296                        printf __("'%s.final' contains the composed email.\n"),
 297                                  $compose_filename;
 298                }
 299        }
 300
 301        exit;
 302};
 303
 304$SIG{TERM} = \&signal_handler;
 305$SIG{INT}  = \&signal_handler;
 306
 307# Begin by accumulating all the variables (defined above), that we will end up
 308# needing, first, from the command line:
 309
 310my $help;
 311my $rc = GetOptions("h" => \$help,
 312                    "dump-aliases" => \$dump_aliases);
 313usage() unless $rc;
 314die __("--dump-aliases incompatible with other options\n")
 315    if !$help and $dump_aliases and @ARGV;
 316$rc = GetOptions(
 317                    "sender|from=s" => \$sender,
 318                    "in-reply-to=s" => \$initial_reply_to,
 319                    "subject=s" => \$initial_subject,
 320                    "to=s" => \@initial_to,
 321                    "to-cmd=s" => \$to_cmd,
 322                    "no-to" => \$no_to,
 323                    "cc=s" => \@initial_cc,
 324                    "no-cc" => \$no_cc,
 325                    "bcc=s" => \@bcclist,
 326                    "no-bcc" => \$no_bcc,
 327                    "chain-reply-to!" => \$chain_reply_to,
 328                    "no-chain-reply-to" => sub {$chain_reply_to = 0},
 329                    "smtp-server=s" => \$smtp_server,
 330                    "smtp-server-option=s" => \@smtp_server_options,
 331                    "smtp-server-port=s" => \$smtp_server_port,
 332                    "smtp-user=s" => \$smtp_authuser,
 333                    "smtp-pass:s" => \$smtp_authpass,
 334                    "smtp-ssl" => sub { $smtp_encryption = 'ssl' },
 335                    "smtp-encryption=s" => \$smtp_encryption,
 336                    "smtp-ssl-cert-path=s" => \$smtp_ssl_cert_path,
 337                    "smtp-debug:i" => \$debug_net_smtp,
 338                    "smtp-domain:s" => \$smtp_domain,
 339                    "smtp-auth=s" => \$smtp_auth,
 340                    "identity=s" => \$identity,
 341                    "annotate!" => \$annotate,
 342                    "no-annotate" => sub {$annotate = 0},
 343                    "compose" => \$compose,
 344                    "quiet" => \$quiet,
 345                    "cc-cmd=s" => \$cc_cmd,
 346                    "suppress-from!" => \$suppress_from,
 347                    "no-suppress-from" => sub {$suppress_from = 0},
 348                    "suppress-cc=s" => \@suppress_cc,
 349                    "signed-off-cc|signed-off-by-cc!" => \$signed_off_by_cc,
 350                    "no-signed-off-cc|no-signed-off-by-cc" => sub {$signed_off_by_cc = 0},
 351                    "cc-cover|cc-cover!" => \$cover_cc,
 352                    "no-cc-cover" => sub {$cover_cc = 0},
 353                    "to-cover|to-cover!" => \$cover_to,
 354                    "no-to-cover" => sub {$cover_to = 0},
 355                    "confirm=s" => \$confirm,
 356                    "dry-run" => \$dry_run,
 357                    "envelope-sender=s" => \$envelope_sender,
 358                    "thread!" => \$thread,
 359                    "no-thread" => sub {$thread = 0},
 360                    "validate!" => \$validate,
 361                    "no-validate" => sub {$validate = 0},
 362                    "transfer-encoding=s" => \$target_xfer_encoding,
 363                    "format-patch!" => \$format_patch,
 364                    "no-format-patch" => sub {$format_patch = 0},
 365                    "8bit-encoding=s" => \$auto_8bit_encoding,
 366                    "compose-encoding=s" => \$compose_encoding,
 367                    "force" => \$force,
 368                    "xmailer!" => \$use_xmailer,
 369                    "no-xmailer" => sub {$use_xmailer = 0},
 370                    "batch-size=i" => \$batch_size,
 371                    "relogin-delay=i" => \$relogin_delay,
 372         );
 373
 374usage() if $help;
 375unless ($rc) {
 376    usage();
 377}
 378
 379die __("Cannot run git format-patch from outside a repository\n")
 380        if $format_patch and not $repo;
 381
 382# Now, let's fill any that aren't set in with defaults:
 383
 384sub read_config {
 385        my ($prefix) = @_;
 386
 387        foreach my $setting (keys %config_bool_settings) {
 388                my $target = $config_bool_settings{$setting}->[0];
 389                $$target = Git::config_bool(@repo, "$prefix.$setting") unless (defined $$target);
 390        }
 391
 392        foreach my $setting (keys %config_path_settings) {
 393                my $target = $config_path_settings{$setting};
 394                if (ref($target) eq "ARRAY") {
 395                        unless (@$target) {
 396                                my @values = Git::config_path(@repo, "$prefix.$setting");
 397                                @$target = @values if (@values && defined $values[0]);
 398                        }
 399                }
 400                else {
 401                        $$target = Git::config_path(@repo, "$prefix.$setting") unless (defined $$target);
 402                }
 403        }
 404
 405        foreach my $setting (keys %config_settings) {
 406                my $target = $config_settings{$setting};
 407                next if $setting eq "to" and defined $no_to;
 408                next if $setting eq "cc" and defined $no_cc;
 409                next if $setting eq "bcc" and defined $no_bcc;
 410                if (ref($target) eq "ARRAY") {
 411                        unless (@$target) {
 412                                my @values = Git::config(@repo, "$prefix.$setting");
 413                                @$target = @values if (@values && defined $values[0]);
 414                        }
 415                }
 416                else {
 417                        $$target = Git::config(@repo, "$prefix.$setting") unless (defined $$target);
 418                }
 419        }
 420
 421        if (!defined $smtp_encryption) {
 422                my $enc = Git::config(@repo, "$prefix.smtpencryption");
 423                if (defined $enc) {
 424                        $smtp_encryption = $enc;
 425                } elsif (Git::config_bool(@repo, "$prefix.smtpssl")) {
 426                        $smtp_encryption = 'ssl';
 427                }
 428        }
 429}
 430
 431# read configuration from [sendemail "$identity"], fall back on [sendemail]
 432$identity = Git::config(@repo, "sendemail.identity") unless (defined $identity);
 433read_config("sendemail.$identity") if (defined $identity);
 434read_config("sendemail");
 435
 436# fall back on builtin bool defaults
 437foreach my $setting (values %config_bool_settings) {
 438        ${$setting->[0]} = $setting->[1] unless (defined (${$setting->[0]}));
 439}
 440
 441# 'default' encryption is none -- this only prevents a warning
 442$smtp_encryption = '' unless (defined $smtp_encryption);
 443
 444# Set CC suppressions
 445my(%suppress_cc);
 446if (@suppress_cc) {
 447        foreach my $entry (@suppress_cc) {
 448                die sprintf(__("Unknown --suppress-cc field: '%s'\n"), $entry)
 449                        unless $entry =~ /^(?:all|cccmd|cc|author|self|sob|body|bodycc)$/;
 450                $suppress_cc{$entry} = 1;
 451        }
 452}
 453
 454if ($suppress_cc{'all'}) {
 455        foreach my $entry (qw (cccmd cc author self sob body bodycc)) {
 456                $suppress_cc{$entry} = 1;
 457        }
 458        delete $suppress_cc{'all'};
 459}
 460
 461# If explicit old-style ones are specified, they trump --suppress-cc.
 462$suppress_cc{'self'} = $suppress_from if defined $suppress_from;
 463$suppress_cc{'sob'} = !$signed_off_by_cc if defined $signed_off_by_cc;
 464
 465if ($suppress_cc{'body'}) {
 466        foreach my $entry (qw (sob bodycc)) {
 467                $suppress_cc{$entry} = 1;
 468        }
 469        delete $suppress_cc{'body'};
 470}
 471
 472# Set confirm's default value
 473my $confirm_unconfigured = !defined $confirm;
 474if ($confirm_unconfigured) {
 475        $confirm = scalar %suppress_cc ? 'compose' : 'auto';
 476};
 477die sprintf(__("Unknown --confirm setting: '%s'\n"), $confirm)
 478        unless $confirm =~ /^(?:auto|cc|compose|always|never)/;
 479
 480# Debugging, print out the suppressions.
 481if (0) {
 482        print "suppressions:\n";
 483        foreach my $entry (keys %suppress_cc) {
 484                printf "  %-5s -> $suppress_cc{$entry}\n", $entry;
 485        }
 486}
 487
 488my ($repoauthor, $repocommitter);
 489($repoauthor) = Git::ident_person(@repo, 'author');
 490($repocommitter) = Git::ident_person(@repo, 'committer');
 491
 492sub parse_address_line {
 493        if ($have_mail_address) {
 494                return map { $_->format } Mail::Address->parse($_[0]);
 495        } else {
 496                return Git::parse_mailboxes($_[0]);
 497        }
 498}
 499
 500sub split_addrs {
 501        return quotewords('\s*,\s*', 1, @_);
 502}
 503
 504my %aliases;
 505
 506sub parse_sendmail_alias {
 507        local $_ = shift;
 508        if (/"/) {
 509                printf STDERR __("warning: sendmail alias with quotes is not supported: %s\n"), $_;
 510        } elsif (/:include:/) {
 511                printf STDERR __("warning: `:include:` not supported: %s\n"), $_;
 512        } elsif (/[\/|]/) {
 513                printf STDERR __("warning: `/file` or `|pipe` redirection not supported: %s\n"), $_;
 514        } elsif (/^(\S+?)\s*:\s*(.+)$/) {
 515                my ($alias, $addr) = ($1, $2);
 516                $aliases{$alias} = [ split_addrs($addr) ];
 517        } else {
 518                printf STDERR __("warning: sendmail line is not recognized: %s\n"), $_;
 519        }
 520}
 521
 522sub parse_sendmail_aliases {
 523        my $fh = shift;
 524        my $s = '';
 525        while (<$fh>) {
 526                chomp;
 527                next if /^\s*$/ || /^\s*#/;
 528                $s .= $_, next if $s =~ s/\\$// || s/^\s+//;
 529                parse_sendmail_alias($s) if $s;
 530                $s = $_;
 531        }
 532        $s =~ s/\\$//; # silently tolerate stray '\' on last line
 533        parse_sendmail_alias($s) if $s;
 534}
 535
 536my %parse_alias = (
 537        # multiline formats can be supported in the future
 538        mutt => sub { my $fh = shift; while (<$fh>) {
 539                if (/^\s*alias\s+(?:-group\s+\S+\s+)*(\S+)\s+(.*)$/) {
 540                        my ($alias, $addr) = ($1, $2);
 541                        $addr =~ s/#.*$//; # mutt allows # comments
 542                        # commas delimit multiple addresses
 543                        my @addr = split_addrs($addr);
 544
 545                        # quotes may be escaped in the file,
 546                        # unescape them so we do not double-escape them later.
 547                        s/\\"/"/g foreach @addr;
 548                        $aliases{$alias} = \@addr
 549                }}},
 550        mailrc => sub { my $fh = shift; while (<$fh>) {
 551                if (/^alias\s+(\S+)\s+(.*?)\s*$/) {
 552                        # spaces delimit multiple addresses
 553                        $aliases{$1} = [ quotewords('\s+', 0, $2) ];
 554                }}},
 555        pine => sub { my $fh = shift; my $f='\t[^\t]*';
 556                for (my $x = ''; defined($x); $x = $_) {
 557                        chomp $x;
 558                        $x .= $1 while(defined($_ = <$fh>) && /^ +(.*)$/);
 559                        $x =~ /^(\S+)$f\t\(?([^\t]+?)\)?(:?$f){0,2}$/ or next;
 560                        $aliases{$1} = [ split_addrs($2) ];
 561                }},
 562        elm => sub  { my $fh = shift;
 563                      while (<$fh>) {
 564                          if (/^(\S+)\s+=\s+[^=]+=\s(\S+)/) {
 565                              my ($alias, $addr) = ($1, $2);
 566                               $aliases{$alias} = [ split_addrs($addr) ];
 567                          }
 568                      } },
 569        sendmail => \&parse_sendmail_aliases,
 570        gnus => sub { my $fh = shift; while (<$fh>) {
 571                if (/\(define-mail-alias\s+"(\S+?)"\s+"(\S+?)"\)/) {
 572                        $aliases{$1} = [ $2 ];
 573                }}}
 574);
 575
 576if (@alias_files and $aliasfiletype and defined $parse_alias{$aliasfiletype}) {
 577        foreach my $file (@alias_files) {
 578                open my $fh, '<', $file or die "opening $file: $!\n";
 579                $parse_alias{$aliasfiletype}->($fh);
 580                close $fh;
 581        }
 582}
 583
 584if ($dump_aliases) {
 585    print "$_\n" for (sort keys %aliases);
 586    exit(0);
 587}
 588
 589# is_format_patch_arg($f) returns 0 if $f names a patch, or 1 if
 590# $f is a revision list specification to be passed to format-patch.
 591sub is_format_patch_arg {
 592        return unless $repo;
 593        my $f = shift;
 594        try {
 595                $repo->command('rev-parse', '--verify', '--quiet', $f);
 596                if (defined($format_patch)) {
 597                        return $format_patch;
 598                }
 599                die sprintf(__ <<EOF, $f, $f);
 600File '%s' exists but it could also be the range of commits
 601to produce patches for.  Please disambiguate by...
 602
 603    * Saying "./%s" if you mean a file; or
 604    * Giving --format-patch option if you mean a range.
 605EOF
 606        } catch Git::Error::Command with {
 607                # Not a valid revision.  Treat it as a filename.
 608                return 0;
 609        }
 610}
 611
 612# Now that all the defaults are set, process the rest of the command line
 613# arguments and collect up the files that need to be processed.
 614my @rev_list_opts;
 615while (defined(my $f = shift @ARGV)) {
 616        if ($f eq "--") {
 617                push @rev_list_opts, "--", @ARGV;
 618                @ARGV = ();
 619        } elsif (-d $f and !is_format_patch_arg($f)) {
 620                opendir my $dh, $f
 621                        or die sprintf(__("Failed to opendir %s: %s"), $f, $!);
 622
 623                push @files, grep { -f $_ } map { catfile($f, $_) }
 624                                sort readdir $dh;
 625                closedir $dh;
 626        } elsif ((-f $f or -p $f) and !is_format_patch_arg($f)) {
 627                push @files, $f;
 628        } else {
 629                push @rev_list_opts, $f;
 630        }
 631}
 632
 633if (@rev_list_opts) {
 634        die __("Cannot run git format-patch from outside a repository\n")
 635                unless $repo;
 636        push @files, $repo->command('format-patch', '-o', tempdir(CLEANUP => 1), @rev_list_opts);
 637}
 638
 639@files = handle_backup_files(@files);
 640
 641if ($validate) {
 642        foreach my $f (@files) {
 643                unless (-p $f) {
 644                        my $error = validate_patch($f);
 645                        $error and die sprintf(__("fatal: %s: %s\nwarning: no patches were sent\n"),
 646                                                  $f, $error);
 647                }
 648        }
 649}
 650
 651if (@files) {
 652        unless ($quiet) {
 653                print $_,"\n" for (@files);
 654        }
 655} else {
 656        print STDERR __("\nNo patch files specified!\n\n");
 657        usage();
 658}
 659
 660sub get_patch_subject {
 661        my $fn = shift;
 662        open (my $fh, '<', $fn);
 663        while (my $line = <$fh>) {
 664                next unless ($line =~ /^Subject: (.*)$/);
 665                close $fh;
 666                return "GIT: $1\n";
 667        }
 668        close $fh;
 669        die sprintf(__("No subject line in %s?"), $fn);
 670}
 671
 672if ($compose) {
 673        # Note that this does not need to be secure, but we will make a small
 674        # effort to have it be unique
 675        $compose_filename = ($repo ?
 676                tempfile(".gitsendemail.msg.XXXXXX", DIR => $repo->repo_path()) :
 677                tempfile(".gitsendemail.msg.XXXXXX", DIR => "."))[1];
 678        open my $c, ">", $compose_filename
 679                or die sprintf(__("Failed to open for writing %s: %s"), $compose_filename, $!);
 680
 681
 682        my $tpl_sender = $sender || $repoauthor || $repocommitter || '';
 683        my $tpl_subject = $initial_subject || '';
 684        my $tpl_reply_to = $initial_reply_to || '';
 685
 686        print $c <<EOT1, Git::prefix_lines("GIT: ", __ <<EOT2), <<EOT3;
 687From $tpl_sender # This line is ignored.
 688EOT1
 689Lines beginning in "GIT:" will be removed.
 690Consider including an overall diffstat or table of contents
 691for the patch you are writing.
 692
 693Clear the body content if you don't wish to send a summary.
 694EOT2
 695From: $tpl_sender
 696Subject: $tpl_subject
 697In-Reply-To: $tpl_reply_to
 698
 699EOT3
 700        for my $f (@files) {
 701                print $c get_patch_subject($f);
 702        }
 703        close $c;
 704
 705        if ($annotate) {
 706                do_edit($compose_filename, @files);
 707        } else {
 708                do_edit($compose_filename);
 709        }
 710
 711        open my $c2, ">", $compose_filename . ".final"
 712                or die sprintf(__("Failed to open %s.final: %s"), $compose_filename, $!);
 713
 714        open $c, "<", $compose_filename
 715                or die sprintf(__("Failed to open %s: %s"), $compose_filename, $!);
 716
 717        my $need_8bit_cte = file_has_nonascii($compose_filename);
 718        my $in_body = 0;
 719        my $summary_empty = 1;
 720        if (!defined $compose_encoding) {
 721                $compose_encoding = "UTF-8";
 722        }
 723        while(<$c>) {
 724                next if m/^GIT:/;
 725                if ($in_body) {
 726                        $summary_empty = 0 unless (/^\n$/);
 727                } elsif (/^\n$/) {
 728                        $in_body = 1;
 729                        if ($need_8bit_cte) {
 730                                print $c2 "MIME-Version: 1.0\n",
 731                                         "Content-Type: text/plain; ",
 732                                           "charset=$compose_encoding\n",
 733                                         "Content-Transfer-Encoding: 8bit\n";
 734                        }
 735                } elsif (/^MIME-Version:/i) {
 736                        $need_8bit_cte = 0;
 737                } elsif (/^Subject:\s*(.+)\s*$/i) {
 738                        $initial_subject = $1;
 739                        my $subject = $initial_subject;
 740                        $_ = "Subject: " .
 741                                quote_subject($subject, $compose_encoding) .
 742                                "\n";
 743                } elsif (/^In-Reply-To:\s*(.+)\s*$/i) {
 744                        $initial_reply_to = $1;
 745                        next;
 746                } elsif (/^From:\s*(.+)\s*$/i) {
 747                        $sender = $1;
 748                        next;
 749                } elsif (/^(?:To|Cc|Bcc):/i) {
 750                        print __("To/Cc/Bcc fields are not interpreted yet, they have been ignored\n");
 751                        next;
 752                }
 753                print $c2 $_;
 754        }
 755        close $c;
 756        close $c2;
 757
 758        if ($summary_empty) {
 759                print __("Summary email is empty, skipping it\n");
 760                $compose = -1;
 761        }
 762} elsif ($annotate) {
 763        do_edit(@files);
 764}
 765
 766sub ask {
 767        my ($prompt, %arg) = @_;
 768        my $valid_re = $arg{valid_re};
 769        my $default = $arg{default};
 770        my $confirm_only = $arg{confirm_only};
 771        my $resp;
 772        my $i = 0;
 773        return defined $default ? $default : undef
 774                unless defined $term->IN and defined fileno($term->IN) and
 775                       defined $term->OUT and defined fileno($term->OUT);
 776        while ($i++ < 10) {
 777                $resp = $term->readline($prompt);
 778                if (!defined $resp) { # EOF
 779                        print "\n";
 780                        return defined $default ? $default : undef;
 781                }
 782                if ($resp eq '' and defined $default) {
 783                        return $default;
 784                }
 785                if (!defined $valid_re or $resp =~ /$valid_re/) {
 786                        return $resp;
 787                }
 788                if ($confirm_only) {
 789                        my $yesno = $term->readline(
 790                                # TRANSLATORS: please keep [y/N] as is.
 791                                sprintf(__("Are you sure you want to use <%s> [y/N]? "), $resp));
 792                        if (defined $yesno && $yesno =~ /y/i) {
 793                                return $resp;
 794                        }
 795                }
 796        }
 797        return;
 798}
 799
 800my %broken_encoding;
 801
 802sub file_declares_8bit_cte {
 803        my $fn = shift;
 804        open (my $fh, '<', $fn);
 805        while (my $line = <$fh>) {
 806                last if ($line =~ /^$/);
 807                return 1 if ($line =~ /^Content-Transfer-Encoding: .*8bit.*$/);
 808        }
 809        close $fh;
 810        return 0;
 811}
 812
 813foreach my $f (@files) {
 814        next unless (body_or_subject_has_nonascii($f)
 815                     && !file_declares_8bit_cte($f));
 816        $broken_encoding{$f} = 1;
 817}
 818
 819if (!defined $auto_8bit_encoding && scalar %broken_encoding) {
 820        print __("The following files are 8bit, but do not declare " .
 821                 "a Content-Transfer-Encoding.\n");
 822        foreach my $f (sort keys %broken_encoding) {
 823                print "    $f\n";
 824        }
 825        $auto_8bit_encoding = ask(__("Which 8bit encoding should I declare [UTF-8]? "),
 826                                  valid_re => qr/.{4}/, confirm_only => 1,
 827                                  default => "UTF-8");
 828}
 829
 830if (!$force) {
 831        for my $f (@files) {
 832                if (get_patch_subject($f) =~ /\Q*** SUBJECT HERE ***\E/) {
 833                        die sprintf(__("Refusing to send because the patch\n\t%s\n"
 834                                . "has the template subject '*** SUBJECT HERE ***'. "
 835                                . "Pass --force if you really want to send.\n"), $f);
 836                }
 837        }
 838}
 839
 840if (defined $sender) {
 841        $sender =~ s/^\s+|\s+$//g;
 842        ($sender) = expand_aliases($sender);
 843} else {
 844        $sender = $repoauthor || $repocommitter || '';
 845}
 846
 847# $sender could be an already sanitized address
 848# (e.g. sendemail.from could be manually sanitized by user).
 849# But it's a no-op to run sanitize_address on an already sanitized address.
 850$sender = sanitize_address($sender);
 851
 852my $to_whom = __("To whom should the emails be sent (if anyone)?");
 853my $prompting = 0;
 854if (!@initial_to && !defined $to_cmd) {
 855        my $to = ask("$to_whom ",
 856                     default => "",
 857                     valid_re => qr/\@.*\./, confirm_only => 1);
 858        push @initial_to, parse_address_line($to) if defined $to; # sanitized/validated later
 859        $prompting++;
 860}
 861
 862sub expand_aliases {
 863        return map { expand_one_alias($_) } @_;
 864}
 865
 866my %EXPANDED_ALIASES;
 867sub expand_one_alias {
 868        my $alias = shift;
 869        if ($EXPANDED_ALIASES{$alias}) {
 870                die sprintf(__("fatal: alias '%s' expands to itself\n"), $alias);
 871        }
 872        local $EXPANDED_ALIASES{$alias} = 1;
 873        return $aliases{$alias} ? expand_aliases(@{$aliases{$alias}}) : $alias;
 874}
 875
 876@initial_to = process_address_list(@initial_to);
 877@initial_cc = process_address_list(@initial_cc);
 878@bcclist = process_address_list(@bcclist);
 879
 880if ($thread && !defined $initial_reply_to && $prompting) {
 881        $initial_reply_to = ask(
 882                __("Message-ID to be used as In-Reply-To for the first email (if any)? "),
 883                default => "",
 884                valid_re => qr/\@.*\./, confirm_only => 1);
 885}
 886if (defined $initial_reply_to) {
 887        $initial_reply_to =~ s/^\s*<?//;
 888        $initial_reply_to =~ s/>?\s*$//;
 889        $initial_reply_to = "<$initial_reply_to>" if $initial_reply_to ne '';
 890}
 891
 892if (!defined $smtp_server) {
 893        foreach (qw( /usr/sbin/sendmail /usr/lib/sendmail )) {
 894                if (-x $_) {
 895                        $smtp_server = $_;
 896                        last;
 897                }
 898        }
 899        $smtp_server ||= 'localhost'; # could be 127.0.0.1, too... *shrug*
 900}
 901
 902if ($compose && $compose > 0) {
 903        @files = ($compose_filename . ".final", @files);
 904}
 905
 906# Variables we set as part of the loop over files
 907our ($message_id, %mail, $subject, $reply_to, $references, $message,
 908        $needs_confirm, $message_num, $ask_default);
 909
 910sub extract_valid_address {
 911        my $address = shift;
 912        my $local_part_regexp = qr/[^<>"\s@]+/;
 913        my $domain_regexp = qr/[^.<>"\s@]+(?:\.[^.<>"\s@]+)+/;
 914
 915        # check for a local address:
 916        return $address if ($address =~ /^($local_part_regexp)$/);
 917
 918        $address =~ s/^\s*<(.*)>\s*$/$1/;
 919        if ($have_email_valid) {
 920                return scalar Email::Valid->address($address);
 921        }
 922
 923        # less robust/correct than the monster regexp in Email::Valid,
 924        # but still does a 99% job, and one less dependency
 925        return $1 if $address =~ /($local_part_regexp\@$domain_regexp)/;
 926        return;
 927}
 928
 929sub extract_valid_address_or_die {
 930        my $address = shift;
 931        $address = extract_valid_address($address);
 932        die sprintf(__("error: unable to extract a valid address from: %s\n"), $address)
 933                if !$address;
 934        return $address;
 935}
 936
 937sub validate_address {
 938        my $address = shift;
 939        while (!extract_valid_address($address)) {
 940                printf STDERR __("error: unable to extract a valid address from: %s\n"), $address;
 941                # TRANSLATORS: Make sure to include [q] [d] [e] in your
 942                # translation. The program will only accept English input
 943                # at this point.
 944                $_ = ask(__("What to do with this address? ([q]uit|[d]rop|[e]dit): "),
 945                        valid_re => qr/^(?:quit|q|drop|d|edit|e)/i,
 946                        default => 'q');
 947                if (/^d/i) {
 948                        return undef;
 949                } elsif (/^q/i) {
 950                        cleanup_compose_files();
 951                        exit(0);
 952                }
 953                $address = ask("$to_whom ",
 954                        default => "",
 955                        valid_re => qr/\@.*\./, confirm_only => 1);
 956        }
 957        return $address;
 958}
 959
 960sub validate_address_list {
 961        return (grep { defined $_ }
 962                map { validate_address($_) } @_);
 963}
 964
 965# Usually don't need to change anything below here.
 966
 967# we make a "fake" message id by taking the current number
 968# of seconds since the beginning of Unix time and tacking on
 969# a random number to the end, in case we are called quicker than
 970# 1 second since the last time we were called.
 971
 972# We'll setup a template for the message id, using the "from" address:
 973
 974my ($message_id_stamp, $message_id_serial);
 975sub make_message_id {
 976        my $uniq;
 977        if (!defined $message_id_stamp) {
 978                $message_id_stamp = strftime("%Y%m%d%H%M%S.$$", gmtime(time));
 979                $message_id_serial = 0;
 980        }
 981        $message_id_serial++;
 982        $uniq = "$message_id_stamp-$message_id_serial";
 983
 984        my $du_part;
 985        for ($sender, $repocommitter, $repoauthor) {
 986                $du_part = extract_valid_address(sanitize_address($_));
 987                last if (defined $du_part and $du_part ne '');
 988        }
 989        if (not defined $du_part or $du_part eq '') {
 990                require Sys::Hostname;
 991                $du_part = 'user@' . Sys::Hostname::hostname();
 992        }
 993        my $message_id_template = "<%s-%s>";
 994        $message_id = sprintf($message_id_template, $uniq, $du_part);
 995        #print "new message id = $message_id\n"; # Was useful for debugging
 996}
 997
 998
 999
1000$time = time - scalar $#files;
1001
1002sub unquote_rfc2047 {
1003        local ($_) = @_;
1004        my $charset;
1005        my $sep = qr/[ \t]+/;
1006        s{$re_encoded_word(?:$sep$re_encoded_word)*}{
1007                my @words = split $sep, $&;
1008                foreach (@words) {
1009                        m/$re_encoded_word/;
1010                        $charset = $1;
1011                        my $encoding = $2;
1012                        my $text = $3;
1013                        if ($encoding eq 'q' || $encoding eq 'Q') {
1014                                $_ = $text;
1015                                s/_/ /g;
1016                                s/=([0-9A-F]{2})/chr(hex($1))/egi;
1017                        } else {
1018                                # other encodings not supported yet
1019                        }
1020                }
1021                join '', @words;
1022        }eg;
1023        return wantarray ? ($_, $charset) : $_;
1024}
1025
1026sub quote_rfc2047 {
1027        local $_ = shift;
1028        my $encoding = shift || 'UTF-8';
1029        s/([^-a-zA-Z0-9!*+\/])/sprintf("=%02X", ord($1))/eg;
1030        s/(.*)/=\?$encoding\?q\?$1\?=/;
1031        return $_;
1032}
1033
1034sub is_rfc2047_quoted {
1035        my $s = shift;
1036        length($s) <= 75 &&
1037        $s =~ m/^(?:"[[:ascii:]]*"|$re_encoded_word)$/o;
1038}
1039
1040sub subject_needs_rfc2047_quoting {
1041        my $s = shift;
1042
1043        return ($s =~ /[^[:ascii:]]/) || ($s =~ /=\?/);
1044}
1045
1046sub quote_subject {
1047        local $subject = shift;
1048        my $encoding = shift || 'UTF-8';
1049
1050        if (subject_needs_rfc2047_quoting($subject)) {
1051                return quote_rfc2047($subject, $encoding);
1052        }
1053        return $subject;
1054}
1055
1056# use the simplest quoting being able to handle the recipient
1057sub sanitize_address {
1058        my ($recipient) = @_;
1059
1060        # remove garbage after email address
1061        $recipient =~ s/(.*>).*$/$1/;
1062
1063        my ($recipient_name, $recipient_addr) = ($recipient =~ /^(.*?)\s*(<.*)/);
1064
1065        if (not $recipient_name) {
1066                return $recipient;
1067        }
1068
1069        # if recipient_name is already quoted, do nothing
1070        if (is_rfc2047_quoted($recipient_name)) {
1071                return $recipient;
1072        }
1073
1074        # remove non-escaped quotes
1075        $recipient_name =~ s/(^|[^\\])"/$1/g;
1076
1077        # rfc2047 is needed if a non-ascii char is included
1078        if ($recipient_name =~ /[^[:ascii:]]/) {
1079                $recipient_name = quote_rfc2047($recipient_name);
1080        }
1081
1082        # double quotes are needed if specials or CTLs are included
1083        elsif ($recipient_name =~ /[][()<>@,;:\\".\000-\037\177]/) {
1084                $recipient_name =~ s/([\\\r])/\\$1/g;
1085                $recipient_name = qq["$recipient_name"];
1086        }
1087
1088        return "$recipient_name $recipient_addr";
1089
1090}
1091
1092sub sanitize_address_list {
1093        return (map { sanitize_address($_) } @_);
1094}
1095
1096sub process_address_list {
1097        my @addr_list = map { parse_address_line($_) } @_;
1098        @addr_list = expand_aliases(@addr_list);
1099        @addr_list = sanitize_address_list(@addr_list);
1100        @addr_list = validate_address_list(@addr_list);
1101        return @addr_list;
1102}
1103
1104# Returns the local Fully Qualified Domain Name (FQDN) if available.
1105#
1106# Tightly configured MTAa require that a caller sends a real DNS
1107# domain name that corresponds the IP address in the HELO/EHLO
1108# handshake. This is used to verify the connection and prevent
1109# spammers from trying to hide their identity. If the DNS and IP don't
1110# match, the receiveing MTA may deny the connection.
1111#
1112# Here is a deny example of Net::SMTP with the default "localhost.localdomain"
1113#
1114# Net::SMTP=GLOB(0x267ec28)>>> EHLO localhost.localdomain
1115# Net::SMTP=GLOB(0x267ec28)<<< 550 EHLO argument does not match calling host
1116#
1117# This maildomain*() code is based on ideas in Perl library Test::Reporter
1118# /usr/share/perl5/Test/Reporter/Mail/Util.pm ==> sub _maildomain ()
1119
1120sub valid_fqdn {
1121        my $domain = shift;
1122        return defined $domain && !($^O eq 'darwin' && $domain =~ /\.local$/) && $domain =~ /\./;
1123}
1124
1125sub maildomain_net {
1126        my $maildomain;
1127
1128        if (eval { require Net::Domain; 1 }) {
1129                my $domain = Net::Domain::domainname();
1130                $maildomain = $domain if valid_fqdn($domain);
1131        }
1132
1133        return $maildomain;
1134}
1135
1136sub maildomain_mta {
1137        my $maildomain;
1138
1139        if (eval { require Net::SMTP; 1 }) {
1140                for my $host (qw(mailhost localhost)) {
1141                        my $smtp = Net::SMTP->new($host);
1142                        if (defined $smtp) {
1143                                my $domain = $smtp->domain;
1144                                $smtp->quit;
1145
1146                                $maildomain = $domain if valid_fqdn($domain);
1147
1148                                last if $maildomain;
1149                        }
1150                }
1151        }
1152
1153        return $maildomain;
1154}
1155
1156sub maildomain {
1157        return maildomain_net() || maildomain_mta() || 'localhost.localdomain';
1158}
1159
1160sub smtp_host_string {
1161        if (defined $smtp_server_port) {
1162                return "$smtp_server:$smtp_server_port";
1163        } else {
1164                return $smtp_server;
1165        }
1166}
1167
1168# Returns 1 if authentication succeeded or was not necessary
1169# (smtp_user was not specified), and 0 otherwise.
1170
1171sub smtp_auth_maybe {
1172        if (!defined $smtp_authuser || $auth) {
1173                return 1;
1174        }
1175
1176        # Workaround AUTH PLAIN/LOGIN interaction defect
1177        # with Authen::SASL::Cyrus
1178        eval {
1179                require Authen::SASL;
1180                Authen::SASL->import(qw(Perl));
1181        };
1182
1183        # Check mechanism naming as defined in:
1184        # https://tools.ietf.org/html/rfc4422#page-8
1185        if ($smtp_auth && $smtp_auth !~ /^(\b[A-Z0-9-_]{1,20}\s*)*$/) {
1186                die "invalid smtp auth: '${smtp_auth}'";
1187        }
1188
1189        # TODO: Authentication may fail not because credentials were
1190        # invalid but due to other reasons, in which we should not
1191        # reject credentials.
1192        $auth = Git::credential({
1193                'protocol' => 'smtp',
1194                'host' => smtp_host_string(),
1195                'username' => $smtp_authuser,
1196                # if there's no password, "git credential fill" will
1197                # give us one, otherwise it'll just pass this one.
1198                'password' => $smtp_authpass
1199        }, sub {
1200                my $cred = shift;
1201
1202                if ($smtp_auth) {
1203                        my $sasl = Authen::SASL->new(
1204                                mechanism => $smtp_auth,
1205                                callback => {
1206                                        user => $cred->{'username'},
1207                                        pass => $cred->{'password'},
1208                                        authname => $cred->{'username'},
1209                                }
1210                        );
1211
1212                        return !!$smtp->auth($sasl);
1213                }
1214
1215                return !!$smtp->auth($cred->{'username'}, $cred->{'password'});
1216        });
1217
1218        return $auth;
1219}
1220
1221sub ssl_verify_params {
1222        eval {
1223                require IO::Socket::SSL;
1224                IO::Socket::SSL->import(qw/SSL_VERIFY_PEER SSL_VERIFY_NONE/);
1225        };
1226        if ($@) {
1227                print STDERR "Not using SSL_VERIFY_PEER due to out-of-date IO::Socket::SSL.\n";
1228                return;
1229        }
1230
1231        if (!defined $smtp_ssl_cert_path) {
1232                # use the OpenSSL defaults
1233                return (SSL_verify_mode => SSL_VERIFY_PEER());
1234        }
1235
1236        if ($smtp_ssl_cert_path eq "") {
1237                return (SSL_verify_mode => SSL_VERIFY_NONE());
1238        } elsif (-d $smtp_ssl_cert_path) {
1239                return (SSL_verify_mode => SSL_VERIFY_PEER(),
1240                        SSL_ca_path => $smtp_ssl_cert_path);
1241        } elsif (-f $smtp_ssl_cert_path) {
1242                return (SSL_verify_mode => SSL_VERIFY_PEER(),
1243                        SSL_ca_file => $smtp_ssl_cert_path);
1244        } else {
1245                die sprintf(__("CA path \"%s\" does not exist"), $smtp_ssl_cert_path);
1246        }
1247}
1248
1249sub file_name_is_absolute {
1250        my ($path) = @_;
1251
1252        # msys does not grok DOS drive-prefixes
1253        if ($^O eq 'msys') {
1254                return ($path =~ m#^/# || $path =~ m#^[a-zA-Z]\:#)
1255        }
1256
1257        require File::Spec::Functions;
1258        return File::Spec::Functions::file_name_is_absolute($path);
1259}
1260
1261# Returns 1 if the message was sent, and 0 otherwise.
1262# In actuality, the whole program dies when there
1263# is an error sending a message.
1264
1265sub send_message {
1266        my @recipients = unique_email_list(@to);
1267        @cc = (grep { my $cc = extract_valid_address_or_die($_);
1268                      not grep { $cc eq $_ || $_ =~ /<\Q${cc}\E>$/ } @recipients
1269                    }
1270               @cc);
1271        my $to = join (",\n\t", @recipients);
1272        @recipients = unique_email_list(@recipients,@cc,@bcclist);
1273        @recipients = (map { extract_valid_address_or_die($_) } @recipients);
1274        my $date = format_2822_time($time++);
1275        my $gitversion = '@@GIT_VERSION@@';
1276        if ($gitversion =~ m/..GIT_VERSION../) {
1277            $gitversion = Git::version();
1278        }
1279
1280        my $cc = join(",\n\t", unique_email_list(@cc));
1281        my $ccline = "";
1282        if ($cc ne '') {
1283                $ccline = "\nCc: $cc";
1284        }
1285        make_message_id() unless defined($message_id);
1286
1287        my $header = "From: $sender
1288To: $to${ccline}
1289Subject: $subject
1290Date: $date
1291Message-Id: $message_id
1292";
1293        if ($use_xmailer) {
1294                $header .= "X-Mailer: git-send-email $gitversion\n";
1295        }
1296        if ($reply_to) {
1297
1298                $header .= "In-Reply-To: $reply_to\n";
1299                $header .= "References: $references\n";
1300        }
1301        if (@xh) {
1302                $header .= join("\n", @xh) . "\n";
1303        }
1304
1305        my @sendmail_parameters = ('-i', @recipients);
1306        my $raw_from = $sender;
1307        if (defined $envelope_sender && $envelope_sender ne "auto") {
1308                $raw_from = $envelope_sender;
1309        }
1310        $raw_from = extract_valid_address($raw_from);
1311        unshift (@sendmail_parameters,
1312                        '-f', $raw_from) if(defined $envelope_sender);
1313
1314        if ($needs_confirm && !$dry_run) {
1315                print "\n$header\n";
1316                if ($needs_confirm eq "inform") {
1317                        $confirm_unconfigured = 0; # squelch this message for the rest of this run
1318                        $ask_default = "y"; # assume yes on EOF since user hasn't explicitly asked for confirmation
1319                        print __ <<EOF ;
1320    The Cc list above has been expanded by additional
1321    addresses found in the patch commit message. By default
1322    send-email prompts before sending whenever this occurs.
1323    This behavior is controlled by the sendemail.confirm
1324    configuration setting.
1325
1326    For additional information, run 'git send-email --help'.
1327    To retain the current behavior, but squelch this message,
1328    run 'git config --global sendemail.confirm auto'.
1329
1330EOF
1331                }
1332                # TRANSLATORS: Make sure to include [y] [n] [q] [a] in your
1333                # translation. The program will only accept English input
1334                # at this point.
1335                $_ = ask(__("Send this email? ([y]es|[n]o|[q]uit|[a]ll): "),
1336                         valid_re => qr/^(?:yes|y|no|n|quit|q|all|a)/i,
1337                         default => $ask_default);
1338                die __("Send this email reply required") unless defined $_;
1339                if (/^n/i) {
1340                        return 0;
1341                } elsif (/^q/i) {
1342                        cleanup_compose_files();
1343                        exit(0);
1344                } elsif (/^a/i) {
1345                        $confirm = 'never';
1346                }
1347        }
1348
1349        unshift (@sendmail_parameters, @smtp_server_options);
1350
1351        if ($dry_run) {
1352                # We don't want to send the email.
1353        } elsif (file_name_is_absolute($smtp_server)) {
1354                my $pid = open my $sm, '|-';
1355                defined $pid or die $!;
1356                if (!$pid) {
1357                        exec($smtp_server, @sendmail_parameters) or die $!;
1358                }
1359                print $sm "$header\n$message";
1360                close $sm or die $!;
1361        } else {
1362
1363                if (!defined $smtp_server) {
1364                        die __("The required SMTP server is not properly defined.")
1365                }
1366
1367                require Net::SMTP;
1368                my $use_net_smtp_ssl = version->parse($Net::SMTP::VERSION) < version->parse("2.34");
1369                $smtp_domain ||= maildomain();
1370
1371                if ($smtp_encryption eq 'ssl') {
1372                        $smtp_server_port ||= 465; # ssmtp
1373                        require IO::Socket::SSL;
1374
1375                        # Suppress "variable accessed once" warning.
1376                        {
1377                                no warnings 'once';
1378                                $IO::Socket::SSL::DEBUG = 1;
1379                        }
1380
1381                        # Net::SMTP::SSL->new() does not forward any SSL options
1382                        IO::Socket::SSL::set_client_defaults(
1383                                ssl_verify_params());
1384
1385                        if ($use_net_smtp_ssl) {
1386                                require Net::SMTP::SSL;
1387                                $smtp ||= Net::SMTP::SSL->new($smtp_server,
1388                                                              Hello => $smtp_domain,
1389                                                              Port => $smtp_server_port,
1390                                                              Debug => $debug_net_smtp);
1391                        }
1392                        else {
1393                                $smtp ||= Net::SMTP->new($smtp_server,
1394                                                         Hello => $smtp_domain,
1395                                                         Port => $smtp_server_port,
1396                                                         Debug => $debug_net_smtp,
1397                                                         SSL => 1);
1398                        }
1399                }
1400                else {
1401                        $smtp_server_port ||= 25;
1402                        $smtp ||= Net::SMTP->new($smtp_server,
1403                                                 Hello => $smtp_domain,
1404                                                 Debug => $debug_net_smtp,
1405                                                 Port => $smtp_server_port);
1406                        if ($smtp_encryption eq 'tls' && $smtp) {
1407                                if ($use_net_smtp_ssl) {
1408                                        $smtp->command('STARTTLS');
1409                                        $smtp->response();
1410                                        if ($smtp->code != 220) {
1411                                                die sprintf(__("Server does not support STARTTLS! %s"), $smtp->message);
1412                                        }
1413                                        require Net::SMTP::SSL;
1414                                        $smtp = Net::SMTP::SSL->start_SSL($smtp,
1415                                                                          ssl_verify_params())
1416                                                or die sprintf(__("STARTTLS failed! %s"), IO::Socket::SSL::errstr());
1417                                }
1418                                else {
1419                                        $smtp->starttls(ssl_verify_params())
1420                                                or die sprintf(__("STARTTLS failed! %s"), IO::Socket::SSL::errstr());
1421                                }
1422                                $smtp_encryption = '';
1423                                # Send EHLO again to receive fresh
1424                                # supported commands
1425                                $smtp->hello($smtp_domain);
1426                        }
1427                }
1428
1429                if (!$smtp) {
1430                        die __("Unable to initialize SMTP properly. Check config and use --smtp-debug."),
1431                            " VALUES: server=$smtp_server ",
1432                            "encryption=$smtp_encryption ",
1433                            "hello=$smtp_domain",
1434                            defined $smtp_server_port ? " port=$smtp_server_port" : "";
1435                }
1436
1437                smtp_auth_maybe or die $smtp->message;
1438
1439                $smtp->mail( $raw_from ) or die $smtp->message;
1440                $smtp->to( @recipients ) or die $smtp->message;
1441                $smtp->data or die $smtp->message;
1442                $smtp->datasend("$header\n") or die $smtp->message;
1443                my @lines = split /^/, $message;
1444                foreach my $line (@lines) {
1445                        $smtp->datasend("$line") or die $smtp->message;
1446                }
1447                $smtp->dataend() or die $smtp->message;
1448                $smtp->code =~ /250|200/ or die sprintf(__("Failed to send %s\n"), $subject).$smtp->message;
1449        }
1450        if ($quiet) {
1451                printf($dry_run ? __("Dry-Sent %s\n") : __("Sent %s\n"), $subject);
1452        } else {
1453                print($dry_run ? __("Dry-OK. Log says:\n") : __("OK. Log says:\n"));
1454                if (!file_name_is_absolute($smtp_server)) {
1455                        print "Server: $smtp_server\n";
1456                        print "MAIL FROM:<$raw_from>\n";
1457                        foreach my $entry (@recipients) {
1458                            print "RCPT TO:<$entry>\n";
1459                        }
1460                } else {
1461                        print "Sendmail: $smtp_server ".join(' ',@sendmail_parameters)."\n";
1462                }
1463                print $header, "\n";
1464                if ($smtp) {
1465                        print __("Result: "), $smtp->code, ' ',
1466                                ($smtp->message =~ /\n([^\n]+\n)$/s), "\n";
1467                } else {
1468                        print __("Result: OK\n");
1469                }
1470        }
1471
1472        return 1;
1473}
1474
1475$reply_to = $initial_reply_to;
1476$references = $initial_reply_to || '';
1477$subject = $initial_subject;
1478$message_num = 0;
1479
1480foreach my $t (@files) {
1481        open my $fh, "<", $t or die sprintf(__("can't open file %s"), $t);
1482
1483        my $author = undef;
1484        my $sauthor = undef;
1485        my $author_encoding;
1486        my $has_content_type;
1487        my $body_encoding;
1488        my $xfer_encoding;
1489        my $has_mime_version;
1490        @to = ();
1491        @cc = ();
1492        @xh = ();
1493        my $input_format = undef;
1494        my @header = ();
1495        $message = "";
1496        $message_num++;
1497        # First unfold multiline header fields
1498        while(<$fh>) {
1499                last if /^\s*$/;
1500                if (/^\s+\S/ and @header) {
1501                        chomp($header[$#header]);
1502                        s/^\s+/ /;
1503                        $header[$#header] .= $_;
1504            } else {
1505                        push(@header, $_);
1506                }
1507        }
1508        # Now parse the header
1509        foreach(@header) {
1510                if (/^From /) {
1511                        $input_format = 'mbox';
1512                        next;
1513                }
1514                chomp;
1515                if (!defined $input_format && /^[-A-Za-z]+:\s/) {
1516                        $input_format = 'mbox';
1517                }
1518
1519                if (defined $input_format && $input_format eq 'mbox') {
1520                        if (/^Subject:\s+(.*)$/i) {
1521                                $subject = $1;
1522                        }
1523                        elsif (/^From:\s+(.*)$/i) {
1524                                ($author, $author_encoding) = unquote_rfc2047($1);
1525                                $sauthor = sanitize_address($author);
1526                                next if $suppress_cc{'author'};
1527                                next if $suppress_cc{'self'} and $sauthor eq $sender;
1528                                printf(__("(mbox) Adding cc: %s from line '%s'\n"),
1529                                        $1, $_) unless $quiet;
1530                                push @cc, $1;
1531                        }
1532                        elsif (/^To:\s+(.*)$/i) {
1533                                foreach my $addr (parse_address_line($1)) {
1534                                        printf(__("(mbox) Adding to: %s from line '%s'\n"),
1535                                                $addr, $_) unless $quiet;
1536                                        push @to, $addr;
1537                                }
1538                        }
1539                        elsif (/^Cc:\s+(.*)$/i) {
1540                                foreach my $addr (parse_address_line($1)) {
1541                                        my $qaddr = unquote_rfc2047($addr);
1542                                        my $saddr = sanitize_address($qaddr);
1543                                        if ($saddr eq $sender) {
1544                                                next if ($suppress_cc{'self'});
1545                                        } else {
1546                                                next if ($suppress_cc{'cc'});
1547                                        }
1548                                        printf(__("(mbox) Adding cc: %s from line '%s'\n"),
1549                                                $addr, $_) unless $quiet;
1550                                        push @cc, $addr;
1551                                }
1552                        }
1553                        elsif (/^Content-type:/i) {
1554                                $has_content_type = 1;
1555                                if (/charset="?([^ "]+)/) {
1556                                        $body_encoding = $1;
1557                                }
1558                                push @xh, $_;
1559                        }
1560                        elsif (/^MIME-Version/i) {
1561                                $has_mime_version = 1;
1562                                push @xh, $_;
1563                        }
1564                        elsif (/^Message-Id: (.*)/i) {
1565                                $message_id = $1;
1566                        }
1567                        elsif (/^Content-Transfer-Encoding: (.*)/i) {
1568                                $xfer_encoding = $1 if not defined $xfer_encoding;
1569                        }
1570                        elsif (!/^Date:\s/i && /^[-A-Za-z]+:\s+\S/) {
1571                                push @xh, $_;
1572                        }
1573
1574                } else {
1575                        # In the traditional
1576                        # "send lots of email" format,
1577                        # line 1 = cc
1578                        # line 2 = subject
1579                        # So let's support that, too.
1580                        $input_format = 'lots';
1581                        if (@cc == 0 && !$suppress_cc{'cc'}) {
1582                                printf(__("(non-mbox) Adding cc: %s from line '%s'\n"),
1583                                        $_, $_) unless $quiet;
1584                                push @cc, $_;
1585                        } elsif (!defined $subject) {
1586                                $subject = $_;
1587                        }
1588                }
1589        }
1590        # Now parse the message body
1591        while(<$fh>) {
1592                $message .=  $_;
1593                if (/^(Signed-off-by|Cc): ([^>]*>?)/i) {
1594                        chomp;
1595                        my ($what, $c) = ($1, $2);
1596                        chomp $c;
1597                        my $sc = sanitize_address($c);
1598                        if ($sc eq $sender) {
1599                                next if ($suppress_cc{'self'});
1600                        } else {
1601                                next if $suppress_cc{'sob'} and $what =~ /Signed-off-by/i;
1602                                next if $suppress_cc{'bodycc'} and $what =~ /Cc/i;
1603                        }
1604                        push @cc, $c;
1605                        printf(__("(body) Adding cc: %s from line '%s'\n"),
1606                                $c, $_) unless $quiet;
1607                }
1608        }
1609        close $fh;
1610
1611        push @to, recipients_cmd("to-cmd", "to", $to_cmd, $t)
1612                if defined $to_cmd;
1613        push @cc, recipients_cmd("cc-cmd", "cc", $cc_cmd, $t)
1614                if defined $cc_cmd && !$suppress_cc{'cccmd'};
1615
1616        if ($broken_encoding{$t} && !$has_content_type) {
1617                $xfer_encoding = '8bit' if not defined $xfer_encoding;
1618                $has_content_type = 1;
1619                push @xh, "Content-Type: text/plain; charset=$auto_8bit_encoding";
1620                $body_encoding = $auto_8bit_encoding;
1621        }
1622
1623        if ($broken_encoding{$t} && !is_rfc2047_quoted($subject)) {
1624                $subject = quote_subject($subject, $auto_8bit_encoding);
1625        }
1626
1627        if (defined $sauthor and $sauthor ne $sender) {
1628                $message = "From: $author\n\n$message";
1629                if (defined $author_encoding) {
1630                        if ($has_content_type) {
1631                                if ($body_encoding eq $author_encoding) {
1632                                        # ok, we already have the right encoding
1633                                }
1634                                else {
1635                                        # uh oh, we should re-encode
1636                                }
1637                        }
1638                        else {
1639                                $xfer_encoding = '8bit' if not defined $xfer_encoding;
1640                                $has_content_type = 1;
1641                                push @xh,
1642                                  "Content-Type: text/plain; charset=$author_encoding";
1643                        }
1644                }
1645        }
1646        if (defined $target_xfer_encoding) {
1647                $xfer_encoding = '8bit' if not defined $xfer_encoding;
1648                $message = apply_transfer_encoding(
1649                        $message, $xfer_encoding, $target_xfer_encoding);
1650                $xfer_encoding = $target_xfer_encoding;
1651        }
1652        if (defined $xfer_encoding) {
1653                push @xh, "Content-Transfer-Encoding: $xfer_encoding";
1654        }
1655        if (defined $xfer_encoding or $has_content_type) {
1656                unshift @xh, 'MIME-Version: 1.0' unless $has_mime_version;
1657        }
1658
1659        $needs_confirm = (
1660                $confirm eq "always" or
1661                ($confirm =~ /^(?:auto|cc)$/ && @cc) or
1662                ($confirm =~ /^(?:auto|compose)$/ && $compose && $message_num == 1));
1663        $needs_confirm = "inform" if ($needs_confirm && $confirm_unconfigured && @cc);
1664
1665        @to = process_address_list(@to);
1666        @cc = process_address_list(@cc);
1667
1668        @to = (@initial_to, @to);
1669        @cc = (@initial_cc, @cc);
1670
1671        if ($message_num == 1) {
1672                if (defined $cover_cc and $cover_cc) {
1673                        @initial_cc = @cc;
1674                }
1675                if (defined $cover_to and $cover_to) {
1676                        @initial_to = @to;
1677                }
1678        }
1679
1680        my $message_was_sent = send_message();
1681
1682        # set up for the next message
1683        if ($thread && $message_was_sent &&
1684                ($chain_reply_to || !defined $reply_to || length($reply_to) == 0 ||
1685                $message_num == 1)) {
1686                $reply_to = $message_id;
1687                if (length $references > 0) {
1688                        $references .= "\n $message_id";
1689                } else {
1690                        $references = "$message_id";
1691                }
1692        }
1693        $message_id = undef;
1694        $num_sent++;
1695        if (defined $batch_size && $num_sent == $batch_size) {
1696                $num_sent = 0;
1697                $smtp->quit if defined $smtp;
1698                undef $smtp;
1699                undef $auth;
1700                sleep($relogin_delay) if defined $relogin_delay;
1701        }
1702}
1703
1704# Execute a command (e.g. $to_cmd) to get a list of email addresses
1705# and return a results array
1706sub recipients_cmd {
1707        my ($prefix, $what, $cmd, $file) = @_;
1708
1709        my @addresses = ();
1710        open my $fh, "-|", "$cmd \Q$file\E"
1711            or die sprintf(__("(%s) Could not execute '%s'"), $prefix, $cmd);
1712        while (my $address = <$fh>) {
1713                $address =~ s/^\s*//g;
1714                $address =~ s/\s*$//g;
1715                $address = sanitize_address($address);
1716                next if ($address eq $sender and $suppress_cc{'self'});
1717                push @addresses, $address;
1718                printf(__("(%s) Adding %s: %s from: '%s'\n"),
1719                       $prefix, $what, $address, $cmd) unless $quiet;
1720                }
1721        close $fh
1722            or die sprintf(__("(%s) failed to close pipe to '%s'"), $prefix, $cmd);
1723        return @addresses;
1724}
1725
1726cleanup_compose_files();
1727
1728sub cleanup_compose_files {
1729        unlink($compose_filename, $compose_filename . ".final") if $compose;
1730}
1731
1732$smtp->quit if $smtp;
1733
1734sub apply_transfer_encoding {
1735        my $message = shift;
1736        my $from = shift;
1737        my $to = shift;
1738
1739        return $message if ($from eq $to and $from ne '7bit');
1740
1741        require MIME::QuotedPrint;
1742        require MIME::Base64;
1743
1744        $message = MIME::QuotedPrint::decode($message)
1745                if ($from eq 'quoted-printable');
1746        $message = MIME::Base64::decode($message)
1747                if ($from eq 'base64');
1748
1749        die __("cannot send message as 7bit")
1750                if ($to eq '7bit' and $message =~ /[^[:ascii:]]/);
1751        return $message
1752                if ($to eq '7bit' or $to eq '8bit');
1753        return MIME::QuotedPrint::encode($message, "\n", 0)
1754                if ($to eq 'quoted-printable');
1755        return MIME::Base64::encode($message, "\n")
1756                if ($to eq 'base64');
1757        die __("invalid transfer encoding");
1758}
1759
1760sub unique_email_list {
1761        my %seen;
1762        my @emails;
1763
1764        foreach my $entry (@_) {
1765                my $clean = extract_valid_address_or_die($entry);
1766                $seen{$clean} ||= 0;
1767                next if $seen{$clean}++;
1768                push @emails, $entry;
1769        }
1770        return @emails;
1771}
1772
1773sub validate_patch {
1774        my $fn = shift;
1775
1776        if ($repo) {
1777                my $validate_hook = catfile(catdir($repo->repo_path(), 'hooks'),
1778                                            'sendemail-validate');
1779                my $hook_error;
1780                if (-x $validate_hook) {
1781                        my $target = abs_path($fn);
1782                        # The hook needs a correct cwd and GIT_DIR.
1783                        my $cwd_save = cwd();
1784                        chdir($repo->wc_path() or $repo->repo_path())
1785                                or die("chdir: $!");
1786                        local $ENV{"GIT_DIR"} = $repo->repo_path();
1787                        $hook_error = "rejected by sendemail-validate hook"
1788                                if system($validate_hook, $target);
1789                        chdir($cwd_save) or die("chdir: $!");
1790                }
1791                return $hook_error if $hook_error;
1792        }
1793
1794        open(my $fh, '<', $fn)
1795                or die sprintf(__("unable to open %s: %s\n"), $fn, $!);
1796        while (my $line = <$fh>) {
1797                if (length($line) > 998) {
1798                        return sprintf(__("%s: patch contains a line longer than 998 characters"), $.);
1799                }
1800        }
1801        return;
1802}
1803
1804sub handle_backup {
1805        my ($last, $lastlen, $file, $known_suffix) = @_;
1806        my ($suffix, $skip);
1807
1808        $skip = 0;
1809        if (defined $last &&
1810            ($lastlen < length($file)) &&
1811            (substr($file, 0, $lastlen) eq $last) &&
1812            ($suffix = substr($file, $lastlen)) !~ /^[a-z0-9]/i) {
1813                if (defined $known_suffix && $suffix eq $known_suffix) {
1814                        printf(__("Skipping %s with backup suffix '%s'.\n"), $file, $known_suffix);
1815                        $skip = 1;
1816                } else {
1817                        # TRANSLATORS: please keep "[y|N]" as is.
1818                        my $answer = ask(sprintf(__("Do you really want to send %s? [y|N]: "), $file),
1819                                         valid_re => qr/^(?:y|n)/i,
1820                                         default => 'n');
1821                        $skip = ($answer ne 'y');
1822                        if ($skip) {
1823                                $known_suffix = $suffix;
1824                        }
1825                }
1826        }
1827        return ($skip, $known_suffix);
1828}
1829
1830sub handle_backup_files {
1831        my @file = @_;
1832        my ($last, $lastlen, $known_suffix, $skip, @result);
1833        for my $file (@file) {
1834                ($skip, $known_suffix) = handle_backup($last, $lastlen,
1835                                                       $file, $known_suffix);
1836                push @result, $file unless $skip;
1837                $last = $file;
1838                $lastlen = length($file);
1839        }
1840        return @result;
1841}
1842
1843sub file_has_nonascii {
1844        my $fn = shift;
1845        open(my $fh, '<', $fn)
1846                or die sprintf(__("unable to open %s: %s\n"), $fn, $!);
1847        while (my $line = <$fh>) {
1848                return 1 if $line =~ /[^[:ascii:]]/;
1849        }
1850        return 0;
1851}
1852
1853sub body_or_subject_has_nonascii {
1854        my $fn = shift;
1855        open(my $fh, '<', $fn)
1856                or die sprintf(__("unable to open %s: %s\n"), $fn, $!);
1857        while (my $line = <$fh>) {
1858                last if $line =~ /^$/;
1859                return 1 if $line =~ /^Subject.*[^[:ascii:]]/;
1860        }
1861        while (my $line = <$fh>) {
1862                return 1 if $line =~ /[^[:ascii:]]/;
1863        }
1864        return 0;
1865}