git-send-email.perlon commit expose a helper function peel_to_type(). (8177631)
   1#!/usr/bin/perl -w
   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 strict;
  20use warnings;
  21use Term::ReadLine;
  22use Getopt::Long;
  23use Data::Dumper;
  24use Term::ANSIColor;
  25use Git;
  26
  27package FakeTerm;
  28sub new {
  29        my ($class, $reason) = @_;
  30        return bless \$reason, shift;
  31}
  32sub readline {
  33        my $self = shift;
  34        die "Cannot use readline on FakeTerm: $$self";
  35}
  36package main;
  37
  38
  39sub usage {
  40        print <<EOT;
  41git-send-email [options] <file | directory>...
  42Options:
  43   --from         Specify the "From:" line of the email to be sent.
  44
  45   --to           Specify the primary "To:" line of the email.
  46
  47   --cc           Specify an initial "Cc:" list for the entire series
  48                  of emails.
  49
  50   --cc-cmd       Specify a command to execute per file which adds
  51                  per file specific cc address entries
  52
  53   --bcc          Specify a list of email addresses that should be Bcc:
  54                  on all the emails.
  55
  56   --compose      Use \$GIT_EDITOR, core.editor, \$EDITOR, or \$VISUAL to edit
  57                  an introductory message for the patch series.
  58
  59   --subject      Specify the initial "Subject:" line.
  60                  Only necessary if --compose is also set.  If --compose
  61                  is not set, this will be prompted for.
  62
  63   --in-reply-to  Specify the first "In-Reply-To:" header line.
  64                  Only used if --compose is also set.  If --compose is not
  65                  set, this will be prompted for.
  66
  67   --chain-reply-to If set, the replies will all be to the previous
  68                  email sent, rather than to the first email sent.
  69                  Defaults to on.
  70
  71   --signed-off-cc Automatically add email addresses that appear in
  72                 Signed-off-by: or Cc: lines to the cc: list. Defaults to on.
  73
  74   --identity     The configuration identity, a subsection to prioritise over
  75                  the default section.
  76
  77   --smtp-server  If set, specifies the outgoing SMTP server to use.
  78                  Defaults to localhost.  Port number can be specified here with
  79                  hostname:port format or by using --smtp-server-port option.
  80
  81   --smtp-server-port Specify a port on the outgoing SMTP server to connect to.
  82
  83   --smtp-user    The username for SMTP-AUTH.
  84
  85   --smtp-pass    The password for SMTP-AUTH.
  86
  87   --smtp-ssl     If set, connects to the SMTP server using SSL.
  88
  89   --suppress-cc  Suppress the specified category of auto-CC.  The category
  90                  can be one of 'author' for the patch author, 'self' to
  91                  avoid copying yourself, 'sob' for Signed-off-by lines,
  92                  'cccmd' for the output of the cccmd, or 'all' to suppress
  93                  all of these.
  94
  95   --suppress-from Suppress sending emails to yourself. Defaults to off.
  96
  97   --thread       Specify that the "In-Reply-To:" header should be set on all
  98                  emails. Defaults to on.
  99
 100   --quiet        Make git-send-email less verbose.  One line per email
 101                  should be all that is output.
 102
 103   --dry-run      Do everything except actually send the emails.
 104
 105   --envelope-sender    Specify the envelope sender used to send the emails.
 106
 107   --no-validate        Don't perform any sanity checks on patches.
 108
 109EOT
 110        exit(1);
 111}
 112
 113# most mail servers generate the Date: header, but not all...
 114sub format_2822_time {
 115        my ($time) = @_;
 116        my @localtm = localtime($time);
 117        my @gmttm = gmtime($time);
 118        my $localmin = $localtm[1] + $localtm[2] * 60;
 119        my $gmtmin = $gmttm[1] + $gmttm[2] * 60;
 120        if ($localtm[0] != $gmttm[0]) {
 121                die "local zone differs from GMT by a non-minute interval\n";
 122        }
 123        if ((($gmttm[6] + 1) % 7) == $localtm[6]) {
 124                $localmin += 1440;
 125        } elsif ((($gmttm[6] - 1) % 7) == $localtm[6]) {
 126                $localmin -= 1440;
 127        } elsif ($gmttm[6] != $localtm[6]) {
 128                die "local time offset greater than or equal to 24 hours\n";
 129        }
 130        my $offset = $localmin - $gmtmin;
 131        my $offhour = $offset / 60;
 132        my $offmin = abs($offset % 60);
 133        if (abs($offhour) >= 24) {
 134                die ("local time offset greater than or equal to 24 hours\n");
 135        }
 136
 137        return sprintf("%s, %2d %s %d %02d:%02d:%02d %s%02d%02d",
 138                       qw(Sun Mon Tue Wed Thu Fri Sat)[$localtm[6]],
 139                       $localtm[3],
 140                       qw(Jan Feb Mar Apr May Jun
 141                          Jul Aug Sep Oct Nov Dec)[$localtm[4]],
 142                       $localtm[5]+1900,
 143                       $localtm[2],
 144                       $localtm[1],
 145                       $localtm[0],
 146                       ($offset >= 0) ? '+' : '-',
 147                       abs($offhour),
 148                       $offmin,
 149                       );
 150}
 151
 152my $have_email_valid = eval { require Email::Valid; 1 };
 153my $smtp;
 154my $auth;
 155
 156sub unique_email_list(@);
 157sub cleanup_compose_files();
 158
 159# Constants (essentially)
 160my $compose_filename = ".msg.$$";
 161
 162# Variables we fill in automatically, or via prompting:
 163my (@to,@cc,@initial_cc,@bcclist,@xh,
 164        $initial_reply_to,$initial_subject,@files,$author,$sender,$smtp_authpass,$compose,$time);
 165
 166my $envelope_sender;
 167
 168# Example reply to:
 169#$initial_reply_to = ''; #<20050203173208.GA23964@foobar.com>';
 170
 171my $repo = Git->repository();
 172my $term = eval {
 173        new Term::ReadLine 'git-send-email';
 174};
 175if ($@) {
 176        $term = new FakeTerm "$@: going non-interactive";
 177}
 178
 179# Behavior modification variables
 180my ($quiet, $dry_run) = (0, 0);
 181
 182# Variables with corresponding config settings
 183my ($thread, $chain_reply_to, $suppress_from, $signed_off_cc, $cc_cmd);
 184my ($smtp_server, $smtp_server_port, $smtp_authuser, $smtp_ssl);
 185my ($identity, $aliasfiletype, @alias_files, @smtp_host_parts);
 186my ($no_validate);
 187my (@suppress_cc);
 188
 189my %config_bool_settings = (
 190    "thread" => [\$thread, 1],
 191    "chainreplyto" => [\$chain_reply_to, 1],
 192    "suppressfrom" => [\$suppress_from, undef],
 193    "signedoffcc" => [\$signed_off_cc, undef],
 194    "smtpssl" => [\$smtp_ssl, 0],
 195);
 196
 197my %config_settings = (
 198    "smtpserver" => \$smtp_server,
 199    "smtpserverport" => \$smtp_server_port,
 200    "smtpuser" => \$smtp_authuser,
 201    "smtppass" => \$smtp_authpass,
 202    "to" => \@to,
 203    "cccmd" => \$cc_cmd,
 204    "aliasfiletype" => \$aliasfiletype,
 205    "bcc" => \@bcclist,
 206    "aliasesfile" => \@alias_files,
 207    "suppresscc" => \@suppress_cc,
 208);
 209
 210# Handle Uncouth Termination
 211sub signal_handler {
 212
 213        # Make text normal
 214        print color("reset"), "\n";
 215
 216        # SMTP password masked
 217        system "stty echo";
 218
 219        # tmp files from --compose
 220        if (-e $compose_filename) {
 221                print "'$compose_filename' contains an intermediate version of the email you were composing.\n";
 222        }
 223        if (-e ($compose_filename . ".final")) {
 224                print "'$compose_filename.final' contains the composed email.\n"
 225        }
 226
 227        exit;
 228};
 229
 230$SIG{TERM} = \&signal_handler;
 231$SIG{INT}  = \&signal_handler;
 232
 233# Begin by accumulating all the variables (defined above), that we will end up
 234# needing, first, from the command line:
 235
 236my $rc = GetOptions("sender|from=s" => \$sender,
 237                    "in-reply-to=s" => \$initial_reply_to,
 238                    "subject=s" => \$initial_subject,
 239                    "to=s" => \@to,
 240                    "cc=s" => \@initial_cc,
 241                    "bcc=s" => \@bcclist,
 242                    "chain-reply-to!" => \$chain_reply_to,
 243                    "smtp-server=s" => \$smtp_server,
 244                    "smtp-server-port=s" => \$smtp_server_port,
 245                    "smtp-user=s" => \$smtp_authuser,
 246                    "smtp-pass:s" => \$smtp_authpass,
 247                    "smtp-ssl!" => \$smtp_ssl,
 248                    "identity=s" => \$identity,
 249                    "compose" => \$compose,
 250                    "quiet" => \$quiet,
 251                    "cc-cmd=s" => \$cc_cmd,
 252                    "suppress-from!" => \$suppress_from,
 253                    "suppress-cc=s" => \@suppress_cc,
 254                    "signed-off-cc|signed-off-by-cc!" => \$signed_off_cc,
 255                    "dry-run" => \$dry_run,
 256                    "envelope-sender=s" => \$envelope_sender,
 257                    "thread!" => \$thread,
 258                    "no-validate" => \$no_validate,
 259         );
 260
 261unless ($rc) {
 262    usage();
 263}
 264
 265# Now, let's fill any that aren't set in with defaults:
 266
 267sub read_config {
 268        my ($prefix) = @_;
 269
 270        foreach my $setting (keys %config_bool_settings) {
 271                my $target = $config_bool_settings{$setting}->[0];
 272                $$target = $repo->config_bool("$prefix.$setting") unless (defined $$target);
 273        }
 274
 275        foreach my $setting (keys %config_settings) {
 276                my $target = $config_settings{$setting};
 277                if (ref($target) eq "ARRAY") {
 278                        unless (@$target) {
 279                                my @values = $repo->config("$prefix.$setting");
 280                                @$target = @values if (@values && defined $values[0]);
 281                        }
 282                }
 283                else {
 284                        $$target = $repo->config("$prefix.$setting") unless (defined $$target);
 285                }
 286        }
 287}
 288
 289# read configuration from [sendemail "$identity"], fall back on [sendemail]
 290$identity = $repo->config("sendemail.identity") unless (defined $identity);
 291read_config("sendemail.$identity") if (defined $identity);
 292read_config("sendemail");
 293
 294# fall back on builtin bool defaults
 295foreach my $setting (values %config_bool_settings) {
 296        ${$setting->[0]} = $setting->[1] unless (defined (${$setting->[0]}));
 297}
 298
 299# Set CC suppressions
 300my(%suppress_cc);
 301if (@suppress_cc) {
 302        foreach my $entry (@suppress_cc) {
 303                die "Unknown --suppress-cc field: '$entry'\n"
 304                        unless $entry =~ /^(all|cccmd|cc|author|self|sob)$/;
 305                $suppress_cc{$entry} = 1;
 306        }
 307}
 308
 309if ($suppress_cc{'all'}) {
 310        foreach my $entry (qw (ccmd cc author self sob)) {
 311                $suppress_cc{$entry} = 1;
 312        }
 313        delete $suppress_cc{'all'};
 314}
 315
 316# If explicit old-style ones are specified, they trump --suppress-cc.
 317$suppress_cc{'self'} = $suppress_from if defined $suppress_from;
 318$suppress_cc{'sob'} = $signed_off_cc if defined $signed_off_cc;
 319
 320# Debugging, print out the suppressions.
 321if (0) {
 322        print "suppressions:\n";
 323        foreach my $entry (keys %suppress_cc) {
 324                printf "  %-5s -> $suppress_cc{$entry}\n", $entry;
 325        }
 326}
 327
 328my ($repoauthor) = $repo->ident_person('author');
 329my ($repocommitter) = $repo->ident_person('committer');
 330
 331# Verify the user input
 332
 333foreach my $entry (@to) {
 334        die "Comma in --to entry: $entry'\n" unless $entry !~ m/,/;
 335}
 336
 337foreach my $entry (@initial_cc) {
 338        die "Comma in --cc entry: $entry'\n" unless $entry !~ m/,/;
 339}
 340
 341foreach my $entry (@bcclist) {
 342        die "Comma in --bcclist entry: $entry'\n" unless $entry !~ m/,/;
 343}
 344
 345my %aliases;
 346my %parse_alias = (
 347        # multiline formats can be supported in the future
 348        mutt => sub { my $fh = shift; while (<$fh>) {
 349                if (/^\s*alias\s+(\S+)\s+(.*)$/) {
 350                        my ($alias, $addr) = ($1, $2);
 351                        $addr =~ s/#.*$//; # mutt allows # comments
 352                         # commas delimit multiple addresses
 353                        $aliases{$alias} = [ split(/\s*,\s*/, $addr) ];
 354                }}},
 355        mailrc => sub { my $fh = shift; while (<$fh>) {
 356                if (/^alias\s+(\S+)\s+(.*)$/) {
 357                        # spaces delimit multiple addresses
 358                        $aliases{$1} = [ split(/\s+/, $2) ];
 359                }}},
 360        pine => sub { my $fh = shift; while (<$fh>) {
 361                if (/^(\S+)\t.*\t(.*)$/) {
 362                        $aliases{$1} = [ split(/\s*,\s*/, $2) ];
 363                }}},
 364        gnus => sub { my $fh = shift; while (<$fh>) {
 365                if (/\(define-mail-alias\s+"(\S+?)"\s+"(\S+?)"\)/) {
 366                        $aliases{$1} = [ $2 ];
 367                }}}
 368);
 369
 370if (@alias_files and $aliasfiletype and defined $parse_alias{$aliasfiletype}) {
 371        foreach my $file (@alias_files) {
 372                open my $fh, '<', $file or die "opening $file: $!\n";
 373                $parse_alias{$aliasfiletype}->($fh);
 374                close $fh;
 375        }
 376}
 377
 378($sender) = expand_aliases($sender) if defined $sender;
 379
 380# Now that all the defaults are set, process the rest of the command line
 381# arguments and collect up the files that need to be processed.
 382for my $f (@ARGV) {
 383        if (-d $f) {
 384                opendir(DH,$f)
 385                        or die "Failed to opendir $f: $!";
 386
 387                push @files, grep { -f $_ } map { +$f . "/" . $_ }
 388                                sort readdir(DH);
 389
 390        } elsif (-f $f) {
 391                push @files, $f;
 392
 393        } else {
 394                print STDERR "Skipping $f - not found.\n";
 395        }
 396}
 397
 398if (!$no_validate) {
 399        foreach my $f (@files) {
 400                my $error = validate_patch($f);
 401                $error and die "fatal: $f: $error\nwarning: no patches were sent\n";
 402        }
 403}
 404
 405if (@files) {
 406        unless ($quiet) {
 407                print $_,"\n" for (@files);
 408        }
 409} else {
 410        print STDERR "\nNo patch files specified!\n\n";
 411        usage();
 412}
 413
 414my $prompting = 0;
 415if (!defined $sender) {
 416        $sender = $repoauthor || $repocommitter;
 417
 418        while (1) {
 419                $_ = $term->readline("Who should the emails appear to be from? [$sender] ");
 420                last if defined $_;
 421                print "\n";
 422        }
 423
 424        $sender = $_ if ($_);
 425        print "Emails will be sent from: ", $sender, "\n";
 426        $prompting++;
 427}
 428
 429if (!@to) {
 430
 431
 432        while (1) {
 433                $_ = $term->readline("Who should the emails be sent to? ", "");
 434                last if defined $_;
 435                print "\n";
 436        }
 437
 438        my $to = $_;
 439        push @to, split /,/, $to;
 440        $prompting++;
 441}
 442
 443sub expand_aliases {
 444        my @cur = @_;
 445        my @last;
 446        do {
 447                @last = @cur;
 448                @cur = map { $aliases{$_} ? @{$aliases{$_}} : $_ } @last;
 449        } while (join(',',@cur) ne join(',',@last));
 450        return @cur;
 451}
 452
 453@to = expand_aliases(@to);
 454@to = (map { sanitize_address($_) } @to);
 455@initial_cc = expand_aliases(@initial_cc);
 456@bcclist = expand_aliases(@bcclist);
 457
 458if (!defined $initial_subject && $compose) {
 459        while (1) {
 460                $_ = $term->readline("What subject should the initial email start with? ", $initial_subject);
 461                last if defined $_;
 462                print "\n";
 463        }
 464
 465        $initial_subject = $_;
 466        $prompting++;
 467}
 468
 469if ($thread && !defined $initial_reply_to && $prompting) {
 470        while (1) {
 471                $_= $term->readline("Message-ID to be used as In-Reply-To for the first email? ", $initial_reply_to);
 472                last if defined $_;
 473                print "\n";
 474        }
 475
 476        $initial_reply_to = $_;
 477}
 478if (defined $initial_reply_to && $_ ne "") {
 479        $initial_reply_to =~ s/^\s*<?/</;
 480        $initial_reply_to =~ s/>?\s*$/>/;
 481}
 482
 483if (!defined $smtp_server) {
 484        foreach (qw( /usr/sbin/sendmail /usr/lib/sendmail )) {
 485                if (-x $_) {
 486                        $smtp_server = $_;
 487                        last;
 488                }
 489        }
 490        $smtp_server ||= 'localhost'; # could be 127.0.0.1, too... *shrug*
 491}
 492
 493if ($compose) {
 494        # Note that this does not need to be secure, but we will make a small
 495        # effort to have it be unique
 496        open(C,">",$compose_filename)
 497                or die "Failed to open for writing $compose_filename: $!";
 498        print C "From $sender # This line is ignored.\n";
 499        printf C "Subject: %s\n\n", $initial_subject;
 500        printf C <<EOT;
 501GIT: Please enter your email below.
 502GIT: Lines beginning in "GIT: " will be removed.
 503GIT: Consider including an overall diffstat or table of contents
 504GIT: for the patch you are writing.
 505
 506EOT
 507        close(C);
 508
 509        my $editor = $ENV{GIT_EDITOR} || $repo->config("core.editor") || $ENV{VISUAL} || $ENV{EDITOR} || "vi";
 510        system('sh', '-c', '$0 $@', $editor, $compose_filename);
 511
 512        open(C2,">",$compose_filename . ".final")
 513                or die "Failed to open $compose_filename.final : " . $!;
 514
 515        open(C,"<",$compose_filename)
 516                or die "Failed to open $compose_filename : " . $!;
 517
 518        while(<C>) {
 519                next if m/^GIT: /;
 520                print C2 $_;
 521        }
 522        close(C);
 523        close(C2);
 524
 525        while (1) {
 526                $_ = $term->readline("Send this email? (y|n) ");
 527                last if defined $_;
 528                print "\n";
 529        }
 530
 531        if (uc substr($_,0,1) ne 'Y') {
 532                cleanup_compose_files();
 533                exit(0);
 534        }
 535
 536        @files = ($compose_filename . ".final", @files);
 537}
 538
 539# Variables we set as part of the loop over files
 540our ($message_id, %mail, $subject, $reply_to, $references, $message);
 541
 542sub extract_valid_address {
 543        my $address = shift;
 544        my $local_part_regexp = '[^<>"\s@]+';
 545        my $domain_regexp = '[^.<>"\s@]+(?:\.[^.<>"\s@]+)+';
 546
 547        # check for a local address:
 548        return $address if ($address =~ /^($local_part_regexp)$/);
 549
 550        $address =~ s/^\s*<(.*)>\s*$/$1/;
 551        if ($have_email_valid) {
 552                return scalar Email::Valid->address($address);
 553        } else {
 554                # less robust/correct than the monster regexp in Email::Valid,
 555                # but still does a 99% job, and one less dependency
 556                $address =~ /($local_part_regexp\@$domain_regexp)/;
 557                return $1;
 558        }
 559}
 560
 561# Usually don't need to change anything below here.
 562
 563# we make a "fake" message id by taking the current number
 564# of seconds since the beginning of Unix time and tacking on
 565# a random number to the end, in case we are called quicker than
 566# 1 second since the last time we were called.
 567
 568# We'll setup a template for the message id, using the "from" address:
 569
 570my ($message_id_stamp, $message_id_serial);
 571sub make_message_id
 572{
 573        my $uniq;
 574        if (!defined $message_id_stamp) {
 575                $message_id_stamp = sprintf("%s-%s", time, $$);
 576                $message_id_serial = 0;
 577        }
 578        $message_id_serial++;
 579        $uniq = "$message_id_stamp-$message_id_serial";
 580
 581        my $du_part;
 582        for ($sender, $repocommitter, $repoauthor) {
 583                $du_part = extract_valid_address(sanitize_address($_));
 584                last if (defined $du_part and $du_part ne '');
 585        }
 586        if (not defined $du_part or $du_part eq '') {
 587                use Sys::Hostname qw();
 588                $du_part = 'user@' . Sys::Hostname::hostname();
 589        }
 590        my $message_id_template = "<%s-git-send-email-%s>";
 591        $message_id = sprintf($message_id_template, $uniq, $du_part);
 592        #print "new message id = $message_id\n"; # Was useful for debugging
 593}
 594
 595
 596
 597$time = time - scalar $#files;
 598
 599sub unquote_rfc2047 {
 600        local ($_) = @_;
 601        my $encoding;
 602        if (s/=\?([^?]+)\?q\?(.*)\?=/$2/g) {
 603                $encoding = $1;
 604                s/_/ /g;
 605                s/=([0-9A-F]{2})/chr(hex($1))/eg;
 606        }
 607        return wantarray ? ($_, $encoding) : $_;
 608}
 609
 610# use the simplest quoting being able to handle the recipient
 611sub sanitize_address
 612{
 613        my ($recipient) = @_;
 614        my ($recipient_name, $recipient_addr) = ($recipient =~ /^(.*?)\s*(<.*)/);
 615
 616        if (not $recipient_name) {
 617                return "$recipient";
 618        }
 619
 620        # if recipient_name is already quoted, do nothing
 621        if ($recipient_name =~ /^(".*"|=\?utf-8\?q\?.*\?=)$/) {
 622                return $recipient;
 623        }
 624
 625        # rfc2047 is needed if a non-ascii char is included
 626        if ($recipient_name =~ /[^[:ascii:]]/) {
 627                $recipient_name =~ s/([^-a-zA-Z0-9!*+\/])/sprintf("=%02X", ord($1))/eg;
 628                $recipient_name =~ s/(.*)/=\?utf-8\?q\?$1\?=/;
 629        }
 630
 631        # double quotes are needed if specials or CTLs are included
 632        elsif ($recipient_name =~ /[][()<>@,;:\\".\000-\037\177]/) {
 633                $recipient_name =~ s/(["\\\r])/\\$1/;
 634                $recipient_name = "\"$recipient_name\"";
 635        }
 636
 637        return "$recipient_name $recipient_addr";
 638
 639}
 640
 641sub send_message
 642{
 643        my @recipients = unique_email_list(@to);
 644        @cc = (grep { my $cc = extract_valid_address($_);
 645                      not grep { $cc eq $_ } @recipients
 646                    }
 647               map { sanitize_address($_) }
 648               @cc);
 649        my $to = join (",\n\t", @recipients);
 650        @recipients = unique_email_list(@recipients,@cc,@bcclist);
 651        @recipients = (map { extract_valid_address($_) } @recipients);
 652        my $date = format_2822_time($time++);
 653        my $gitversion = '@@GIT_VERSION@@';
 654        if ($gitversion =~ m/..GIT_VERSION../) {
 655            $gitversion = Git::version();
 656        }
 657
 658        my $cc = join(", ", unique_email_list(@cc));
 659        my $ccline = "";
 660        if ($cc ne '') {
 661                $ccline = "\nCc: $cc";
 662        }
 663        my $sanitized_sender = sanitize_address($sender);
 664        make_message_id() unless defined($message_id);
 665
 666        my $header = "From: $sanitized_sender
 667To: $to${ccline}
 668Subject: $subject
 669Date: $date
 670Message-Id: $message_id
 671X-Mailer: git-send-email $gitversion
 672";
 673        if ($thread && $reply_to) {
 674
 675                $header .= "In-Reply-To: $reply_to\n";
 676                $header .= "References: $references\n";
 677        }
 678        if (@xh) {
 679                $header .= join("\n", @xh) . "\n";
 680        }
 681
 682        my @sendmail_parameters = ('-i', @recipients);
 683        my $raw_from = $sanitized_sender;
 684        $raw_from = $envelope_sender if (defined $envelope_sender);
 685        $raw_from = extract_valid_address($raw_from);
 686        unshift (@sendmail_parameters,
 687                        '-f', $raw_from) if(defined $envelope_sender);
 688
 689        if ($dry_run) {
 690                # We don't want to send the email.
 691        } elsif ($smtp_server =~ m#^/#) {
 692                my $pid = open my $sm, '|-';
 693                defined $pid or die $!;
 694                if (!$pid) {
 695                        exec($smtp_server, @sendmail_parameters) or die $!;
 696                }
 697                print $sm "$header\n$message";
 698                close $sm or die $?;
 699        } else {
 700
 701                if (!defined $smtp_server) {
 702                        die "The required SMTP server is not properly defined."
 703                }
 704
 705                if ($smtp_ssl) {
 706                        $smtp_server_port ||= 465; # ssmtp
 707                        require Net::SMTP::SSL;
 708                        $smtp ||= Net::SMTP::SSL->new($smtp_server, Port => $smtp_server_port);
 709                }
 710                else {
 711                        require Net::SMTP;
 712                        $smtp ||= Net::SMTP->new((defined $smtp_server_port)
 713                                                 ? "$smtp_server:$smtp_server_port"
 714                                                 : $smtp_server);
 715                }
 716
 717                if (!$smtp) {
 718                        die "Unable to initialize SMTP properly.  Is there something wrong with your config?";
 719                }
 720
 721                if (defined $smtp_authuser) {
 722
 723                        if (!defined $smtp_authpass) {
 724
 725                                system "stty -echo";
 726
 727                                do {
 728                                        print "Password: ";
 729                                        $_ = <STDIN>;
 730                                        print "\n";
 731                                } while (!defined $_);
 732
 733                                chomp($smtp_authpass = $_);
 734
 735                                system "stty echo";
 736                        }
 737
 738                        $auth ||= $smtp->auth( $smtp_authuser, $smtp_authpass ) or die $smtp->message;
 739                }
 740
 741                $smtp->mail( $raw_from ) or die $smtp->message;
 742                $smtp->to( @recipients ) or die $smtp->message;
 743                $smtp->data or die $smtp->message;
 744                $smtp->datasend("$header\n$message") or die $smtp->message;
 745                $smtp->dataend() or die $smtp->message;
 746                $smtp->ok or die "Failed to send $subject\n".$smtp->message;
 747        }
 748        if ($quiet) {
 749                printf (($dry_run ? "Dry-" : "")."Sent %s\n", $subject);
 750        } else {
 751                print (($dry_run ? "Dry-" : "")."OK. Log says:\n");
 752                if ($smtp_server !~ m#^/#) {
 753                        print "Server: $smtp_server\n";
 754                        print "MAIL FROM:<$raw_from>\n";
 755                        print "RCPT TO:".join(',',(map { "<$_>" } @recipients))."\n";
 756                } else {
 757                        print "Sendmail: $smtp_server ".join(' ',@sendmail_parameters)."\n";
 758                }
 759                print $header, "\n";
 760                if ($smtp) {
 761                        print "Result: ", $smtp->code, ' ',
 762                                ($smtp->message =~ /\n([^\n]+\n)$/s), "\n";
 763                } else {
 764                        print "Result: OK\n";
 765                }
 766        }
 767}
 768
 769$reply_to = $initial_reply_to;
 770$references = $initial_reply_to || '';
 771$subject = $initial_subject;
 772
 773foreach my $t (@files) {
 774        open(F,"<",$t) or die "can't open file $t";
 775
 776        my $author = undef;
 777        my $author_encoding;
 778        my $has_content_type;
 779        my $body_encoding;
 780        @cc = @initial_cc;
 781        @xh = ();
 782        my $input_format = undef;
 783        my $header_done = 0;
 784        $message = "";
 785        while(<F>) {
 786                if (!$header_done) {
 787                        if (/^From /) {
 788                                $input_format = 'mbox';
 789                                next;
 790                        }
 791                        chomp;
 792                        if (!defined $input_format && /^[-A-Za-z]+:\s/) {
 793                                $input_format = 'mbox';
 794                        }
 795
 796                        if (defined $input_format && $input_format eq 'mbox') {
 797                                if (/^Subject:\s+(.*)$/) {
 798                                        $subject = $1;
 799
 800                                } elsif (/^(Cc|From):\s+(.*)$/) {
 801                                        if (unquote_rfc2047($2) eq $sender) {
 802                                                next if ($suppress_cc{'self'});
 803                                        }
 804                                        elsif ($1 eq 'From') {
 805                                                ($author, $author_encoding)
 806                                                  = unquote_rfc2047($2);
 807                                                next if ($suppress_cc{'author'});
 808                                        } else {
 809                                                next if ($suppress_cc{'cc'});
 810                                        }
 811                                        printf("(mbox) Adding cc: %s from line '%s'\n",
 812                                                $2, $_) unless $quiet;
 813                                        push @cc, $2;
 814                                }
 815                                elsif (/^Content-type:/i) {
 816                                        $has_content_type = 1;
 817                                        if (/charset="?[^ "]+/) {
 818                                                $body_encoding = $1;
 819                                        }
 820                                        push @xh, $_;
 821                                }
 822                                elsif (/^Message-Id: (.*)/i) {
 823                                        $message_id = $1;
 824                                }
 825                                elsif (!/^Date:\s/ && /^[-A-Za-z]+:\s+\S/) {
 826                                        push @xh, $_;
 827                                }
 828
 829                        } else {
 830                                # In the traditional
 831                                # "send lots of email" format,
 832                                # line 1 = cc
 833                                # line 2 = subject
 834                                # So let's support that, too.
 835                                $input_format = 'lots';
 836                                if (@cc == 0 && !$suppress_cc{'cc'}) {
 837                                        printf("(non-mbox) Adding cc: %s from line '%s'\n",
 838                                                $_, $_) unless $quiet;
 839
 840                                        push @cc, $_;
 841
 842                                } elsif (!defined $subject) {
 843                                        $subject = $_;
 844                                }
 845                        }
 846
 847                        # A whitespace line will terminate the headers
 848                        if (m/^\s*$/) {
 849                                $header_done = 1;
 850                        }
 851                } else {
 852                        $message .=  $_;
 853                        if (/^(Signed-off-by|Cc): (.*)$/i) {
 854                                next if ($suppress_cc{'sob'});
 855                                my $c = $2;
 856                                chomp $c;
 857                                next if ($c eq $sender and $suppress_cc{'self'});
 858                                push @cc, $c;
 859                                printf("(sob) Adding cc: %s from line '%s'\n",
 860                                        $c, $_) unless $quiet;
 861                        }
 862                }
 863        }
 864        close F;
 865
 866        if (defined $cc_cmd && !$suppress_cc{'cccmd'}) {
 867                open(F, "$cc_cmd $t |")
 868                        or die "(cc-cmd) Could not execute '$cc_cmd'";
 869                while(<F>) {
 870                        my $c = $_;
 871                        $c =~ s/^\s*//g;
 872                        $c =~ s/\n$//g;
 873                        next if ($c eq $sender and $suppress_from);
 874                        push @cc, $c;
 875                        printf("(cc-cmd) Adding cc: %s from: '%s'\n",
 876                                $c, $cc_cmd) unless $quiet;
 877                }
 878                close F
 879                        or die "(cc-cmd) failed to close pipe to '$cc_cmd'";
 880        }
 881
 882        if (defined $author) {
 883                $message = "From: $author\n\n$message";
 884                if (defined $author_encoding) {
 885                        if ($has_content_type) {
 886                                if ($body_encoding eq $author_encoding) {
 887                                        # ok, we already have the right encoding
 888                                }
 889                                else {
 890                                        # uh oh, we should re-encode
 891                                }
 892                        }
 893                        else {
 894                                push @xh,
 895                                  'MIME-Version: 1.0',
 896                                  "Content-Type: text/plain; charset=$author_encoding",
 897                                  'Content-Transfer-Encoding: 8bit';
 898                        }
 899                }
 900        }
 901
 902        send_message();
 903
 904        # set up for the next message
 905        if ($chain_reply_to || !defined $reply_to || length($reply_to) == 0) {
 906                $reply_to = $message_id;
 907                if (length $references > 0) {
 908                        $references .= "\n $message_id";
 909                } else {
 910                        $references = "$message_id";
 911                }
 912        }
 913        $message_id = undef;
 914}
 915
 916if ($compose) {
 917        cleanup_compose_files();
 918}
 919
 920sub cleanup_compose_files() {
 921        unlink($compose_filename, $compose_filename . ".final");
 922
 923}
 924
 925$smtp->quit if $smtp;
 926
 927sub unique_email_list(@) {
 928        my %seen;
 929        my @emails;
 930
 931        foreach my $entry (@_) {
 932                if (my $clean = extract_valid_address($entry)) {
 933                        $seen{$clean} ||= 0;
 934                        next if $seen{$clean}++;
 935                        push @emails, $entry;
 936                } else {
 937                        print STDERR "W: unable to extract a valid address",
 938                                        " from: $entry\n";
 939                }
 940        }
 941        return @emails;
 942}
 943
 944sub validate_patch {
 945        my $fn = shift;
 946        open(my $fh, '<', $fn)
 947                or die "unable to open $fn: $!\n";
 948        while (my $line = <$fh>) {
 949                if (length($line) > 998) {
 950                        return "$.: patch contains a line longer than 998 characters";
 951                }
 952        }
 953        return undef;
 954}