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 { 29my($class,$reason) =@_; 30returnbless \$reason,shift; 31} 32subreadline{ 33my$self=shift; 34die"Cannot use readline on FakeTerm:$$self"; 35} 36package main; 37 38 39sub usage { 40print<<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 \$VISUALto 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 110exit(1); 111} 112 113# most mail servers generate the Date: header, but not all... 114sub format_2822_time { 115my($time) =@_; 116my@localtm=localtime($time); 117my@gmttm=gmtime($time); 118my$localmin=$localtm[1] +$localtm[2] *60; 119my$gmtmin=$gmttm[1] +$gmttm[2] *60; 120if($localtm[0] !=$gmttm[0]) { 121die"local zone differs from GMT by a non-minute interval\n"; 122} 123if((($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]) { 128die"local time offset greater than or equal to 24 hours\n"; 129} 130my$offset=$localmin-$gmtmin; 131my$offhour=$offset/60; 132my$offmin=abs($offset%60); 133if(abs($offhour) >=24) { 134die("local time offset greater than or equal to 24 hours\n"); 135} 136 137returnsprintf("%s,%2d%s%d%02d:%02d:%02d%s%02d%02d", 138qw(Sun Mon Tue Wed Thu Fri Sat)[$localtm[6]], 139$localtm[3], 140qw(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) ?'+':'-', 147abs($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 214print color("reset"),"\n"; 215 216# SMTP password masked 217system"stty echo"; 218 219# tmp files from --compose 220if(-e $compose_filename) { 221print"'$compose_filename' contains an intermediate version of the email you were composing.\n"; 222} 223if(-e ($compose_filename.".final")) { 224print"'$compose_filename.final' contains the composed email.\n" 225} 226 227exit; 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 { 268my($prefix) =@_; 269 270foreachmy$setting(keys%config_bool_settings) { 271my$target=$config_bool_settings{$setting}->[0]; 272$$target=$repo->config_bool("$prefix.$setting")unless(defined$$target); 273} 274 275foreachmy$setting(keys%config_settings) { 276my$target=$config_settings{$setting}; 277if(ref($target)eq"ARRAY") { 278unless(@$target) { 279my@values=$repo->config("$prefix.$setting"); 280@$target=@valuesif(@values&&defined$values[0]); 281} 282} 283else{ 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 295foreachmy$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) { 302foreachmy$entry(@suppress_cc) { 303die"Unknown --suppress-cc field: '$entry'\n" 304unless$entry=~/^(all|cccmd|cc|author|self|sob)$/; 305$suppress_cc{$entry} =1; 306} 307} 308 309if($suppress_cc{'all'}) { 310foreachmy$entry(qw (ccmd cc author self sob)) { 311$suppress_cc{$entry} =1; 312} 313delete$suppress_cc{'all'}; 314} 315 316# If explicit old-style ones are specified, they trump --suppress-cc. 317$suppress_cc{'self'} =$suppress_fromifdefined$suppress_from; 318$suppress_cc{'sob'} =$signed_off_ccifdefined$signed_off_cc; 319 320# Debugging, print out the suppressions. 321if(0) { 322print"suppressions:\n"; 323foreachmy$entry(keys%suppress_cc) { 324printf" %-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 333foreachmy$entry(@to) { 334die"Comma in --to entry:$entry'\n"unless$entry!~m/,/; 335} 336 337foreachmy$entry(@initial_cc) { 338die"Comma in --cc entry:$entry'\n"unless$entry!~m/,/; 339} 340 341foreachmy$entry(@bcclist) { 342die"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>) { 349if(/^\s*alias\s+(\S+)\s+(.*)$/) { 350my($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>) { 356if(/^alias\s+(\S+)\s+(.*)$/) { 357# spaces delimit multiple addresses 358$aliases{$1} = [split(/\s+/,$2) ]; 359}}}, 360 pine =>sub{my$fh=shift;while(<$fh>) { 361if(/^(\S+)\t.*\t(.*)$/) { 362$aliases{$1} = [split(/\s*,\s*/,$2) ]; 363}}}, 364 gnus =>sub{my$fh=shift;while(<$fh>) { 365if(/\(define-mail-alias\s+"(\S+?)"\s+"(\S+?)"\)/) { 366$aliases{$1} = [$2]; 367}}} 368); 369 370if(@alias_filesand$aliasfiletypeand defined$parse_alias{$aliasfiletype}) { 371foreachmy$file(@alias_files) { 372open my$fh,'<',$fileor die"opening$file:$!\n"; 373$parse_alias{$aliasfiletype}->($fh); 374close$fh; 375} 376} 377 378($sender) = expand_aliases($sender)ifdefined$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. 382formy$f(@ARGV) { 383if(-d $f) { 384opendir(DH,$f) 385or die"Failed to opendir$f:$!"; 386 387push@files,grep{ -f $_}map{ +$f."/".$_} 388sort readdir(DH); 389 390}elsif(-f $f) { 391push@files,$f; 392 393}else{ 394print STDERR "Skipping$f- not found.\n"; 395} 396} 397 398if(!$no_validate) { 399foreachmy$f(@files) { 400my$error= validate_patch($f); 401$errorand die"fatal:$f:$error\nwarning: no patches were sent\n"; 402} 403} 404 405if(@files) { 406unless($quiet) { 407print$_,"\n"for(@files); 408} 409}else{ 410print STDERR "\nNo patch files specified!\n\n"; 411 usage(); 412} 413 414my$prompting=0; 415if(!defined$sender) { 416$sender=$repoauthor||$repocommitter; 417 418while(1) { 419$_=$term->readline("Who should the emails appear to be from? [$sender] "); 420last ifdefined$_; 421print"\n"; 422} 423 424$sender=$_if($_); 425print"Emails will be sent from: ",$sender,"\n"; 426$prompting++; 427} 428 429if(!@to) { 430 431 432while(1) { 433$_=$term->readline("Who should the emails be sent to? ",""); 434last ifdefined$_; 435print"\n"; 436} 437 438my$to=$_; 439push@to,split/,/,$to; 440$prompting++; 441} 442 443sub expand_aliases { 444my@cur=@_; 445my@last; 446do{ 447@last=@cur; 448@cur=map{$aliases{$_} ? @{$aliases{$_}} :$_}@last; 449}while(join(',',@cur)ne join(',',@last)); 450return@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) { 459while(1) { 460$_=$term->readline("What subject should the initial email start with? ",$initial_subject); 461last ifdefined$_; 462print"\n"; 463} 464 465$initial_subject=$_; 466$prompting++; 467} 468 469if($thread&& !defined$initial_reply_to&&$prompting) { 470while(1) { 471$_=$term->readline("Message-ID to be used as In-Reply-To for the first email? ",$initial_reply_to); 472last ifdefined$_; 473print"\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) { 484foreach(qw( /usr/sbin/sendmail /usr/lib/sendmail )) { 485if(-x $_) { 486$smtp_server=$_; 487last; 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 496open(C,">",$compose_filename) 497or die"Failed to open for writing$compose_filename:$!"; 498print C "From$sender# This line is ignored.\n"; 499printf C "Subject:%s\n\n",$initial_subject; 500printf 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 507close(C); 508 509my$editor=$ENV{GIT_EDITOR} ||$repo->config("core.editor") ||$ENV{VISUAL} ||$ENV{EDITOR} ||"vi"; 510system('sh','-c','$0$@',$editor,$compose_filename); 511 512open(C2,">",$compose_filename.".final") 513or die"Failed to open$compose_filename.final : ".$!; 514 515open(C,"<",$compose_filename) 516or die"Failed to open$compose_filename: ".$!; 517 518while(<C>) { 519next ifm/^GIT: /; 520print C2 $_; 521} 522close(C); 523close(C2); 524 525while(1) { 526$_=$term->readline("Send this email? (y|n) "); 527last ifdefined$_; 528print"\n"; 529} 530 531if(uc substr($_,0,1)ne'Y') { 532 cleanup_compose_files(); 533exit(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 { 543my$address=shift; 544my$local_part_regexp='[^<>"\s@]+'; 545my$domain_regexp='[^.<>"\s@]+(?:\.[^.<>"\s@]+)+'; 546 547# check for a local address: 548return$addressif($address=~/^($local_part_regexp)$/); 549 550$address=~s/^\s*<(.*)>\s*$/$1/; 551if($have_email_valid) { 552returnscalar 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)/; 557return$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{ 573my$uniq; 574if(!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 581my$du_part; 582for($sender,$repocommitter,$repoauthor) { 583$du_part= extract_valid_address(sanitize_address($_)); 584last if(defined$du_partand$du_partne''); 585} 586if(not defined$du_partor$du_parteq'') { 587use Sys::Hostname qw(); 588$du_part='user@'. Sys::Hostname::hostname(); 589} 590my$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 { 600local($_) =@_; 601my$encoding; 602if(s/=\?([^?]+)\?q\?(.*)\?=/$2/g) { 603$encoding=$1; 604s/_/ /g; 605s/=([0-9A-F]{2})/chr(hex($1))/eg; 606} 607returnwantarray? ($_,$encoding) :$_; 608} 609 610# use the simplest quoting being able to handle the recipient 611sub sanitize_address 612{ 613my($recipient) =@_; 614my($recipient_name,$recipient_addr) = ($recipient=~/^(.*?)\s*(<.*)/); 615 616if(not$recipient_name) { 617return"$recipient"; 618} 619 620# if recipient_name is already quoted, do nothing 621if($recipient_name=~/^(".*"|=\?utf-8\?q\?.*\?=)$/) { 622return$recipient; 623} 624 625# rfc2047 is needed if a non-ascii char is included 626if($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 632elsif($recipient_name=~/[][()<>@,;:\\".\000-\037\177]/) { 633$recipient_name=~s/(["\\\r])/\\$1/; 634$recipient_name="\"$recipient_name\""; 635} 636 637return"$recipient_name$recipient_addr"; 638 639} 640 641sub send_message 642{ 643my@recipients= unique_email_list(@to); 644@cc= (grep{my$cc= extract_valid_address($_); 645not grep{$cceq$_}@recipients 646} 647map{ sanitize_address($_) } 648@cc); 649my$to=join(",\n\t",@recipients); 650@recipients= unique_email_list(@recipients,@cc,@bcclist); 651@recipients= (map{ extract_valid_address($_) }@recipients); 652my$date= format_2822_time($time++); 653my$gitversion='@@GIT_VERSION@@'; 654if($gitversion=~m/..GIT_VERSION../) { 655$gitversion= Git::version(); 656} 657 658my$cc=join(", ", unique_email_list(@cc)); 659my$ccline=""; 660if($ccne'') { 661$ccline="\nCc:$cc"; 662} 663my$sanitized_sender= sanitize_address($sender); 664 make_message_id()unlessdefined($message_id); 665 666my$header="From:$sanitized_sender 667To:$to${ccline} 668Subject:$subject 669Date:$date 670Message-Id:$message_id 671X-Mailer: git-send-email$gitversion 672"; 673if($thread&&$reply_to) { 674 675$header.="In-Reply-To:$reply_to\n"; 676$header.="References:$references\n"; 677} 678if(@xh) { 679$header.=join("\n",@xh) ."\n"; 680} 681 682my@sendmail_parameters= ('-i',@recipients); 683my$raw_from=$sanitized_sender; 684$raw_from=$envelope_senderif(defined$envelope_sender); 685$raw_from= extract_valid_address($raw_from); 686unshift(@sendmail_parameters, 687'-f',$raw_from)if(defined$envelope_sender); 688 689if($dry_run) { 690# We don't want to send the email. 691}elsif($smtp_server=~ m#^/#) { 692my$pid=open my$sm,'|-'; 693defined$pidor die$!; 694if(!$pid) { 695exec($smtp_server,@sendmail_parameters)or die$!; 696} 697print$sm"$header\n$message"; 698close$smor die$?; 699}else{ 700 701if(!defined$smtp_server) { 702die"The required SMTP server is not properly defined." 703} 704 705if($smtp_ssl) { 706$smtp_server_port||=465;# ssmtp 707require Net::SMTP::SSL; 708$smtp||= Net::SMTP::SSL->new($smtp_server, Port =>$smtp_server_port); 709} 710else{ 711require Net::SMTP; 712$smtp||= Net::SMTP->new((defined$smtp_server_port) 713?"$smtp_server:$smtp_server_port" 714:$smtp_server); 715} 716 717if(!$smtp) { 718die"Unable to initialize SMTP properly. Is there something wrong with your config?"; 719} 720 721if(defined$smtp_authuser) { 722 723if(!defined$smtp_authpass) { 724 725system"stty -echo"; 726 727do{ 728print"Password: "; 729$_= <STDIN>; 730print"\n"; 731}while(!defined$_); 732 733chomp($smtp_authpass=$_); 734 735system"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->dataor die$smtp->message; 744$smtp->datasend("$header\n$message")or die$smtp->message; 745$smtp->dataend()or die$smtp->message; 746$smtp->okor die"Failed to send$subject\n".$smtp->message; 747} 748if($quiet) { 749printf(($dry_run?"Dry-":"")."Sent%s\n",$subject); 750}else{ 751print(($dry_run?"Dry-":"")."OK. Log says:\n"); 752if($smtp_server!~ m#^/#) { 753print"Server:$smtp_server\n"; 754print"MAIL FROM:<$raw_from>\n"; 755print"RCPT TO:".join(',',(map{"<$_>"}@recipients))."\n"; 756}else{ 757print"Sendmail:$smtp_server".join(' ',@sendmail_parameters)."\n"; 758} 759print$header,"\n"; 760if($smtp) { 761print"Result: ",$smtp->code,' ', 762($smtp->message=~/\n([^\n]+\n)$/s),"\n"; 763}else{ 764print"Result: OK\n"; 765} 766} 767} 768 769$reply_to=$initial_reply_to; 770$references=$initial_reply_to||''; 771$subject=$initial_subject; 772 773foreachmy$t(@files) { 774open(F,"<",$t)or die"can't open file$t"; 775 776my$author=undef; 777my$author_encoding; 778my$has_content_type; 779my$body_encoding; 780@cc=@initial_cc; 781@xh= (); 782my$input_format=undef; 783my$header_done=0; 784$message=""; 785while(<F>) { 786if(!$header_done) { 787if(/^From /) { 788$input_format='mbox'; 789next; 790} 791chomp; 792if(!defined$input_format&&/^[-A-Za-z]+:\s/) { 793$input_format='mbox'; 794} 795 796if(defined$input_format&&$input_formateq'mbox') { 797if(/^Subject:\s+(.*)$/) { 798$subject=$1; 799 800}elsif(/^(Cc|From):\s+(.*)$/) { 801if(unquote_rfc2047($2)eq$sender) { 802next if($suppress_cc{'self'}); 803} 804elsif($1eq'From') { 805($author,$author_encoding) 806= unquote_rfc2047($2); 807next if($suppress_cc{'author'}); 808}else{ 809next if($suppress_cc{'cc'}); 810} 811printf("(mbox) Adding cc:%sfrom line '%s'\n", 812$2,$_)unless$quiet; 813push@cc,$2; 814} 815elsif(/^Content-type:/i) { 816$has_content_type=1; 817if(/charset="?[^ "]+/) { 818$body_encoding=$1; 819} 820push@xh,$_; 821} 822elsif(/^Message-Id: (.*)/i) { 823$message_id=$1; 824} 825elsif(!/^Date:\s/&&/^[-A-Za-z]+:\s+\S/) { 826push@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'; 836if(@cc==0&& !$suppress_cc{'cc'}) { 837printf("(non-mbox) Adding cc:%sfrom line '%s'\n", 838$_,$_)unless$quiet; 839 840push@cc,$_; 841 842}elsif(!defined$subject) { 843$subject=$_; 844} 845} 846 847# A whitespace line will terminate the headers 848if(m/^\s*$/) { 849$header_done=1; 850} 851}else{ 852$message.=$_; 853if(/^(Signed-off-by|Cc): (.*)$/i) { 854next if($suppress_cc{'sob'}); 855my$c=$2; 856chomp$c; 857next if($ceq$senderand$suppress_cc{'self'}); 858push@cc,$c; 859printf("(sob) Adding cc:%sfrom line '%s'\n", 860$c,$_)unless$quiet; 861} 862} 863} 864close F; 865 866if(defined$cc_cmd&& !$suppress_cc{'cccmd'}) { 867open(F,"$cc_cmd$t|") 868or die"(cc-cmd) Could not execute '$cc_cmd'"; 869while(<F>) { 870my$c=$_; 871$c=~s/^\s*//g; 872$c=~s/\n$//g; 873next if($ceq$senderand$suppress_from); 874push@cc,$c; 875printf("(cc-cmd) Adding cc:%sfrom: '%s'\n", 876$c,$cc_cmd)unless$quiet; 877} 878close F 879or die"(cc-cmd) failed to close pipe to '$cc_cmd'"; 880} 881 882if(defined$author) { 883$message="From:$author\n\n$message"; 884if(defined$author_encoding) { 885if($has_content_type) { 886if($body_encodingeq$author_encoding) { 887# ok, we already have the right encoding 888} 889else{ 890# uh oh, we should re-encode 891} 892} 893else{ 894push@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 905if($chain_reply_to|| !defined$reply_to||length($reply_to) ==0) { 906$reply_to=$message_id; 907if(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() { 921unlink($compose_filename,$compose_filename.".final"); 922 923} 924 925$smtp->quitif$smtp; 926 927sub unique_email_list(@) { 928my%seen; 929my@emails; 930 931foreachmy$entry(@_) { 932if(my$clean= extract_valid_address($entry)) { 933$seen{$clean} ||=0; 934next if$seen{$clean}++; 935push@emails,$entry; 936}else{ 937print STDERR "W: unable to extract a valid address", 938" from:$entry\n"; 939} 940} 941return@emails; 942} 943 944sub validate_patch { 945my$fn=shift; 946open(my$fh,'<',$fn) 947or die"unable to open$fn:$!\n"; 948while(my$line= <$fh>) { 949if(length($line) >998) { 950return"$.: patch contains a line longer than 998 characters"; 951} 952} 953returnundef; 954}