2010-09-24 20:00:53 +00:00
|
|
|
#!/usr/bin/perl
|
2005-07-31 08:17:25 +00:00
|
|
|
#
|
2005-08-01 00:04:24 +00:00
|
|
|
# Copyright 2002,2005 Greg Kroah-Hartman <greg@kroah.com>
|
|
|
|
# Copyright 2005 Ryan Anderson <ryan@michonline.com>
|
2005-07-31 08:17:25 +00:00
|
|
|
#
|
|
|
|
# GPL v2 (See COPYING)
|
2005-08-01 06:05:16 +00:00
|
|
|
#
|
2005-07-31 08:17:25 +00:00
|
|
|
# Ported to support git "mbox" format files by Ryan Anderson <ryan@michonline.com>
|
|
|
|
#
|
2005-08-01 00:04:24 +00:00
|
|
|
# Sends a collection of emails to the given email addresses, disturbingly fast.
|
2005-08-01 06:05:16 +00:00
|
|
|
#
|
2005-08-01 00:04:24 +00:00
|
|
|
# Supports two formats:
|
|
|
|
# 1. mbox format files (ignoring most headers and MIME formatting - this is designed for sending patches)
|
|
|
|
# 2. The original format support by Greg's script:
|
2005-08-01 06:05:16 +00:00
|
|
|
# first line of the message is who to CC,
|
2005-08-01 00:04:24 +00:00
|
|
|
# and second line is the subject of the message.
|
2005-08-01 06:05:16 +00:00
|
|
|
#
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2010-09-24 20:00:52 +00:00
|
|
|
use 5.008;
|
2005-07-31 08:17:25 +00:00
|
|
|
use strict;
|
|
|
|
use warnings;
|
|
|
|
use Term::ReadLine;
|
|
|
|
use Getopt::Long;
|
2008-12-19 08:10:10 +00:00
|
|
|
use Text::ParseWords;
|
2005-07-31 08:17:25 +00:00
|
|
|
use Data::Dumper;
|
2007-08-17 21:38:25 +00:00
|
|
|
use Term::ANSIColor;
|
2009-02-15 04:32:13 +00:00
|
|
|
use File::Temp qw/ tempdir tempfile /;
|
2010-09-14 19:02:24 +00:00
|
|
|
use File::Spec::Functions qw(catfile);
|
2008-11-10 23:54:00 +00:00
|
|
|
use Error qw(:try);
|
2006-07-03 20:47:58 +00:00
|
|
|
use Git;
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2008-11-10 23:54:00 +00:00
|
|
|
Getopt::Long::Configure qw/ pass_through /;
|
|
|
|
|
2006-07-02 23:03:59 +00:00
|
|
|
package FakeTerm;
|
|
|
|
sub new {
|
|
|
|
my ($class, $reason) = @_;
|
|
|
|
return bless \$reason, shift;
|
|
|
|
}
|
|
|
|
sub readline {
|
|
|
|
my $self = shift;
|
|
|
|
die "Cannot use readline on FakeTerm: $$self";
|
|
|
|
}
|
|
|
|
package main;
|
|
|
|
|
2007-02-28 04:47:54 +00:00
|
|
|
|
|
|
|
sub usage {
|
|
|
|
print <<EOT;
|
2008-11-10 23:54:00 +00:00
|
|
|
git send-email [options] <file | directory | rev-list options >
|
2008-09-30 12:58:30 +00:00
|
|
|
|
|
|
|
Composing:
|
|
|
|
--from <str> * Email From:
|
2010-03-07 22:46:48 +00:00
|
|
|
--[no-]to <str> * Email To:
|
|
|
|
--[no-]cc <str> * Email Cc:
|
|
|
|
--[no-]bcc <str> * Email Bcc:
|
2008-09-30 12:58:30 +00:00
|
|
|
--subject <str> * Email "Subject:"
|
|
|
|
--in-reply-to <str> * Email "In-Reply-To:"
|
2014-03-24 21:38:27 +00:00
|
|
|
--[no-]xmailer * Add "X-Mailer:" header (default).
|
2013-04-07 07:10:27 +00:00
|
|
|
--[no-]annotate * Review each patch that will be sent in an editor.
|
2008-09-30 12:58:30 +00:00
|
|
|
--compose * Open an editor for introduction.
|
2012-10-09 23:02:56 +00:00
|
|
|
--compose-encoding <str> * Encoding to assume for introduction.
|
2010-06-17 20:10:39 +00:00
|
|
|
--8bit-encoding <str> * Encoding to assume 8bit mails if undeclared
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 14:00:27 +00:00
|
|
|
--transfer-encoding <str> * Transfer encoding to use (quoted-printable, 8bit, base64)
|
2008-09-30 12:58:30 +00:00
|
|
|
|
|
|
|
Sending:
|
|
|
|
--envelope-sender <str> * Email envelope sender.
|
|
|
|
--smtp-server <str:int> * Outgoing SMTP server to use. The port
|
|
|
|
is optional. Default 'localhost'.
|
2010-09-06 18:12:11 +00:00
|
|
|
--smtp-server-option <str> * Outgoing SMTP server option to use.
|
2008-09-30 12:58:30 +00:00
|
|
|
--smtp-server-port <int> * Outgoing SMTP server port.
|
|
|
|
--smtp-user <str> * Username for SMTP-AUTH.
|
|
|
|
--smtp-pass <str> * Password for SMTP-AUTH; not necessary.
|
|
|
|
--smtp-encryption <str> * tls or ssl; anything else disables.
|
|
|
|
--smtp-ssl * Deprecated. Use '--smtp-encryption ssl'.
|
2013-07-18 16:53:11 +00:00
|
|
|
--smtp-ssl-cert-path <str> * Path to ca-certificates (either directory or file).
|
|
|
|
Pass an empty string to disable certificate
|
|
|
|
verification.
|
2010-03-14 15:16:45 +00:00
|
|
|
--smtp-domain <str> * The domain name sent to HELO/EHLO handshake
|
2010-03-14 15:16:09 +00:00
|
|
|
--smtp-debug <0|1> * Disable, enable Net::SMTP debug.
|
2008-09-30 12:58:30 +00:00
|
|
|
|
|
|
|
Automating:
|
|
|
|
--identity <str> * Use the sendemail.<id> options.
|
2010-09-24 17:03:00 +00:00
|
|
|
--to-cmd <str> * Email To: via `<str> \$patch_path`
|
2008-09-30 12:58:30 +00:00
|
|
|
--cc-cmd <str> * Email Cc: via `<str> \$patch_path`
|
2009-02-15 04:32:15 +00:00
|
|
|
--suppress-cc <str> * author, self, sob, cc, cccmd, body, bodycc, all.
|
2014-04-29 05:41:16 +00:00
|
|
|
--[no-]cc-cover * Email Cc: addresses in the cover letter.
|
|
|
|
--[no-]to-cover * Email To: addresses in the cover letter.
|
2009-02-15 04:32:15 +00:00
|
|
|
--[no-]signed-off-by-cc * Send to Signed-off-by: addresses. Default on.
|
2008-09-30 12:58:30 +00:00
|
|
|
--[no-]suppress-from * Send to self. Default off.
|
2009-08-22 19:48:48 +00:00
|
|
|
--[no-]chain-reply-to * Chain In-Reply-To: fields. Default off.
|
2008-09-30 12:58:30 +00:00
|
|
|
--[no-]thread * Use In-Reply-To: field. Default on.
|
|
|
|
|
|
|
|
Administering:
|
2009-03-03 04:52:18 +00:00
|
|
|
--confirm <str> * Confirm recipients before sending;
|
|
|
|
auto, cc, compose, always, or never.
|
2008-09-30 12:58:30 +00:00
|
|
|
--quiet * Output one line of info per email.
|
|
|
|
--dry-run * Don't actually send the emails.
|
|
|
|
--[no-]validate * Perform patch sanity checks. Default on.
|
2008-11-10 23:54:00 +00:00
|
|
|
--[no-]format-patch * understand any non optional arguments as
|
|
|
|
`git format-patch` ones.
|
2009-06-08 21:34:12 +00:00
|
|
|
--force * Send even if safety checks would prevent it.
|
2008-01-18 14:20:10 +00:00
|
|
|
|
2007-02-28 04:47:54 +00:00
|
|
|
EOT
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2006-03-26 01:20:48 +00:00
|
|
|
# most mail servers generate the Date: header, but not all...
|
2006-07-07 18:57:55 +00:00
|
|
|
sub format_2822_time {
|
|
|
|
my ($time) = @_;
|
|
|
|
my @localtm = localtime($time);
|
|
|
|
my @gmttm = gmtime($time);
|
|
|
|
my $localmin = $localtm[1] + $localtm[2] * 60;
|
|
|
|
my $gmtmin = $gmttm[1] + $gmttm[2] * 60;
|
|
|
|
if ($localtm[0] != $gmttm[0]) {
|
|
|
|
die "local zone differs from GMT by a non-minute interval\n";
|
|
|
|
}
|
|
|
|
if ((($gmttm[6] + 1) % 7) == $localtm[6]) {
|
|
|
|
$localmin += 1440;
|
|
|
|
} elsif ((($gmttm[6] - 1) % 7) == $localtm[6]) {
|
|
|
|
$localmin -= 1440;
|
|
|
|
} elsif ($gmttm[6] != $localtm[6]) {
|
|
|
|
die "local time offset greater than or equal to 24 hours\n";
|
|
|
|
}
|
|
|
|
my $offset = $localmin - $gmtmin;
|
|
|
|
my $offhour = $offset / 60;
|
|
|
|
my $offmin = abs($offset % 60);
|
|
|
|
if (abs($offhour) >= 24) {
|
|
|
|
die ("local time offset greater than or equal to 24 hours\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return sprintf("%s, %2d %s %d %02d:%02d:%02d %s%02d%02d",
|
|
|
|
qw(Sun Mon Tue Wed Thu Fri Sat)[$localtm[6]],
|
|
|
|
$localtm[3],
|
|
|
|
qw(Jan Feb Mar Apr May Jun
|
|
|
|
Jul Aug Sep Oct Nov Dec)[$localtm[4]],
|
|
|
|
$localtm[5]+1900,
|
|
|
|
$localtm[2],
|
|
|
|
$localtm[1],
|
|
|
|
$localtm[0],
|
|
|
|
($offset >= 0) ? '+' : '-',
|
|
|
|
abs($offhour),
|
|
|
|
$offmin,
|
|
|
|
);
|
|
|
|
}
|
2006-03-26 01:20:48 +00:00
|
|
|
|
2006-03-26 00:47:12 +00:00
|
|
|
my $have_email_valid = eval { require Email::Valid; 1 };
|
2009-02-15 04:32:14 +00:00
|
|
|
my $have_mail_address = eval { require Mail::Address; 1 };
|
2006-03-26 01:20:48 +00:00
|
|
|
my $smtp;
|
2007-11-21 12:35:05 +00:00
|
|
|
my $auth;
|
2006-03-26 01:20:48 +00:00
|
|
|
|
2014-12-14 15:59:46 +00:00
|
|
|
# Regexes for RFC 2047 productions.
|
|
|
|
my $re_token = qr/[^][()<>@,;:\\"\/?.= \000-\037\177-\377]+/;
|
|
|
|
my $re_encoded_text = qr/[^? \000-\037\177-\377]+/;
|
|
|
|
my $re_encoded_word = qr/=\?($re_token)\?($re_token)\?($re_encoded_text)\?=/;
|
|
|
|
|
2005-07-31 08:17:25 +00:00
|
|
|
# Variables we fill in automatically, or via prompting:
|
2010-10-04 07:05:24 +00:00
|
|
|
my (@to,$no_to,@initial_to,@cc,$no_cc,@initial_cc,@bcclist,$no_bcc,@xh,
|
2008-11-10 23:54:01 +00:00
|
|
|
$initial_reply_to,$initial_subject,@files,
|
2014-03-24 21:38:27 +00:00
|
|
|
$author,$sender,$smtp_authpass,$annotate,$use_xmailer,$compose,$time);
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2007-04-26 02:37:22 +00:00
|
|
|
my $envelope_sender;
|
2005-08-01 00:04:24 +00:00
|
|
|
|
2005-08-01 00:04:24 +00:00
|
|
|
# Example reply to:
|
2005-07-31 08:17:25 +00:00
|
|
|
#$initial_reply_to = ''; #<20050203173208.GA23964@foobar.com>';
|
|
|
|
|
2008-03-14 17:29:30 +00:00
|
|
|
my $repo = eval { Git->repository() };
|
|
|
|
my @repo = $repo ? ($repo) : ();
|
2006-07-02 23:03:59 +00:00
|
|
|
my $term = eval {
|
2008-02-22 00:16:04 +00:00
|
|
|
$ENV{"GIT_SEND_EMAIL_NOTTY"}
|
|
|
|
? new Term::ReadLine 'git-send-email', \*STDIN, \*STDOUT
|
|
|
|
: new Term::ReadLine 'git-send-email';
|
2006-07-02 23:03:59 +00:00
|
|
|
};
|
|
|
|
if ($@) {
|
|
|
|
$term = new FakeTerm "$@: going non-interactive";
|
|
|
|
}
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2007-06-28 03:59:37 +00:00
|
|
|
# Behavior modification variables
|
|
|
|
my ($quiet, $dry_run) = (0, 0);
|
2008-11-10 23:54:00 +00:00
|
|
|
my $format_patch;
|
2009-02-23 18:51:37 +00:00
|
|
|
my $compose_filename;
|
2009-06-08 21:34:12 +00:00
|
|
|
my $force = 0;
|
2007-06-28 03:59:37 +00:00
|
|
|
|
2008-11-10 23:54:01 +00:00
|
|
|
# Handle interactive edition of files.
|
|
|
|
my $multiedit;
|
send-email: lazily assign editor variable
b4479f0 (add -i, send-email, svn, p4, etc: use "git var GIT_EDITOR",
2009-10-30) introduced the use of "git var GIT_EDITOR" to obtain the
preferred editor program, instead of reading environment variables
themselves.
However, "git var GIT_EDITOR" run without a tty (think "cron job") would
give a fatal error "Terminal is dumb, but EDITOR unset". This is not a
problem for add-i, svn, p4 and callers of git_editor() defined in
git-sh-setup, as all of these call it just before launching the editor.
At that point, we know the caller wants to edit.
But send-email ran this near the beginning of the program, even if it is
not going to use any editor (e.g. run without --compose). Fix this by
calling the command only when we edit a file.
Reported-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Michael J Gruber <git@drmicha.warpmail.net>
Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Acked-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-03-22 16:12:53 +00:00
|
|
|
my $editor;
|
2009-10-31 01:42:34 +00:00
|
|
|
|
2008-11-10 23:54:01 +00:00
|
|
|
sub do_edit {
|
send-email: lazily assign editor variable
b4479f0 (add -i, send-email, svn, p4, etc: use "git var GIT_EDITOR",
2009-10-30) introduced the use of "git var GIT_EDITOR" to obtain the
preferred editor program, instead of reading environment variables
themselves.
However, "git var GIT_EDITOR" run without a tty (think "cron job") would
give a fatal error "Terminal is dumb, but EDITOR unset". This is not a
problem for add-i, svn, p4 and callers of git_editor() defined in
git-sh-setup, as all of these call it just before launching the editor.
At that point, we know the caller wants to edit.
But send-email ran this near the beginning of the program, even if it is
not going to use any editor (e.g. run without --compose). Fix this by
calling the command only when we edit a file.
Reported-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Michael J Gruber <git@drmicha.warpmail.net>
Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Acked-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-03-22 16:12:53 +00:00
|
|
|
if (!defined($editor)) {
|
|
|
|
$editor = Git::command_oneline('var', 'GIT_EDITOR');
|
|
|
|
}
|
2008-11-10 23:54:01 +00:00
|
|
|
if (defined($multiedit) && !$multiedit) {
|
2008-11-10 23:54:02 +00:00
|
|
|
map {
|
|
|
|
system('sh', '-c', $editor.' "$@"', $editor, $_);
|
|
|
|
if (($? & 127) || ($? >> 8)) {
|
|
|
|
die("the editor exited uncleanly, aborting everything");
|
|
|
|
}
|
|
|
|
} @_;
|
2008-11-10 23:54:01 +00:00
|
|
|
} else {
|
|
|
|
system('sh', '-c', $editor.' "$@"', $editor, @_);
|
2008-11-10 23:54:02 +00:00
|
|
|
if (($? & 127) || ($? >> 8)) {
|
|
|
|
die("the editor exited uncleanly, aborting everything");
|
|
|
|
}
|
2008-11-10 23:54:01 +00:00
|
|
|
}
|
|
|
|
}
|
2007-06-28 03:59:37 +00:00
|
|
|
|
|
|
|
# Variables with corresponding config settings
|
2010-09-24 17:03:00 +00:00
|
|
|
my ($thread, $chain_reply_to, $suppress_from, $signed_off_by_cc);
|
2014-04-29 05:41:16 +00:00
|
|
|
my ($cover_cc, $cover_to);
|
2010-09-24 17:03:00 +00:00
|
|
|
my ($to_cmd, $cc_cmd);
|
2010-09-06 18:12:11 +00:00
|
|
|
my ($smtp_server, $smtp_server_port, @smtp_server_options);
|
2013-07-18 16:53:11 +00:00
|
|
|
my ($smtp_authuser, $smtp_encryption, $smtp_ssl_cert_path);
|
2010-09-06 18:12:10 +00:00
|
|
|
my ($identity, $aliasfiletype, @alias_files, $smtp_domain);
|
2009-03-03 04:52:18 +00:00
|
|
|
my ($validate, $confirm);
|
2007-12-26 03:56:29 +00:00
|
|
|
my (@suppress_cc);
|
2010-06-17 20:10:39 +00:00
|
|
|
my ($auto_8bit_encoding);
|
2012-10-09 23:02:56 +00:00
|
|
|
my ($compose_encoding);
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 14:00:27 +00:00
|
|
|
my ($target_xfer_encoding);
|
2007-06-28 03:59:37 +00:00
|
|
|
|
2010-03-14 15:16:09 +00:00
|
|
|
my ($debug_net_smtp) = 0; # Net::SMTP, see send_message()
|
|
|
|
|
2007-09-02 18:06:25 +00:00
|
|
|
my %config_bool_settings = (
|
2007-06-28 03:59:37 +00:00
|
|
|
"thread" => [\$thread, 1],
|
2013-05-25 03:44:52 +00:00
|
|
|
"chainreplyto" => [\$chain_reply_to, 0],
|
2007-12-26 03:56:29 +00:00
|
|
|
"suppressfrom" => [\$suppress_from, undef],
|
2008-09-30 12:58:32 +00:00
|
|
|
"signedoffbycc" => [\$signed_off_by_cc, undef],
|
2014-04-29 05:41:16 +00:00
|
|
|
"cccover" => [\$cover_cc, undef],
|
|
|
|
"tocover" => [\$cover_to, undef],
|
2008-09-30 12:58:32 +00:00
|
|
|
"signedoffcc" => [\$signed_off_by_cc, undef], # Deprecated
|
2008-09-30 12:58:27 +00:00
|
|
|
"validate" => [\$validate, 1],
|
2013-04-07 07:10:27 +00:00
|
|
|
"multiedit" => [\$multiedit, undef],
|
2014-03-24 21:38:27 +00:00
|
|
|
"annotate" => [\$annotate, undef],
|
|
|
|
"xmailer" => [\$use_xmailer, 1]
|
2007-06-26 22:48:30 +00:00
|
|
|
);
|
|
|
|
|
2007-09-02 18:06:25 +00:00
|
|
|
my %config_settings = (
|
|
|
|
"smtpserver" => \$smtp_server,
|
2007-09-26 00:27:54 +00:00
|
|
|
"smtpserverport" => \$smtp_server_port,
|
2010-09-06 18:12:11 +00:00
|
|
|
"smtpserveroption" => \@smtp_server_options,
|
2007-09-02 18:06:25 +00:00
|
|
|
"smtpuser" => \$smtp_authuser,
|
|
|
|
"smtppass" => \$smtp_authpass,
|
2013-07-18 16:53:11 +00:00
|
|
|
"smtpsslcertpath" => \$smtp_ssl_cert_path,
|
2010-09-06 18:12:09 +00:00
|
|
|
"smtpdomain" => \$smtp_domain,
|
2010-10-04 07:05:24 +00:00
|
|
|
"to" => \@initial_to,
|
2010-09-24 17:03:00 +00:00
|
|
|
"tocmd" => \$to_cmd,
|
2008-04-27 12:14:58 +00:00
|
|
|
"cc" => \@initial_cc,
|
2007-09-02 18:06:25 +00:00
|
|
|
"cccmd" => \$cc_cmd,
|
|
|
|
"aliasfiletype" => \$aliasfiletype,
|
|
|
|
"bcc" => \@bcclist,
|
2007-12-26 03:56:29 +00:00
|
|
|
"suppresscc" => \@suppress_cc,
|
2008-06-07 07:33:42 +00:00
|
|
|
"envelopesender" => \$envelope_sender,
|
2009-03-03 04:52:18 +00:00
|
|
|
"confirm" => \$confirm,
|
send-email: Add config option for sender address
The sender address, as specified with the '--from' command line option,
couldn't be set in the config file. So add a new config option,
'sendemail.from', which sets it. One can use 'sendemail.<identity>.from'
as well of course, which is likely the more useful case.
The sender address would default to GIT_AUTHOR_IDENT, which is usually the
right thing, but this doesn't allow switching based on the identity
selected. It's possible to switch the SMTP server and envelope sender by
using the '--identity' option, in which case one probably wants to use a
different from address as well, but this had to be manually specified.
The documentation for 'from' is also corrected somewhat. If '--from' is
specified (or the new sendemail.from option is used) then the user isn't
prompted. The default with no '--from' option (or sendemail.from option)
is GIT_AUTHOR_IDENT first then GIT_COMMITTER_IDENT, not just
GIT_COMMITTER_IDENT.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-05-12 22:48:56 +00:00
|
|
|
"from" => \$sender,
|
2010-06-17 20:10:39 +00:00
|
|
|
"assume8bitencoding" => \$auto_8bit_encoding,
|
2012-10-09 23:02:56 +00:00
|
|
|
"composeencoding" => \$compose_encoding,
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 14:00:27 +00:00
|
|
|
"transferencoding" => \$target_xfer_encoding,
|
2007-09-02 18:06:25 +00:00
|
|
|
);
|
2007-03-11 17:19:44 +00:00
|
|
|
|
2011-09-30 10:52:25 +00:00
|
|
|
my %config_path_settings = (
|
|
|
|
"aliasesfile" => \@alias_files,
|
|
|
|
);
|
|
|
|
|
2008-02-04 00:53:57 +00:00
|
|
|
# Handle Uncouth Termination
|
|
|
|
sub signal_handler {
|
|
|
|
|
|
|
|
# Make text normal
|
|
|
|
print color("reset"), "\n";
|
|
|
|
|
|
|
|
# SMTP password masked
|
|
|
|
system "stty echo";
|
|
|
|
|
|
|
|
# tmp files from --compose
|
2009-02-23 18:51:37 +00:00
|
|
|
if (defined $compose_filename) {
|
|
|
|
if (-e $compose_filename) {
|
|
|
|
print "'$compose_filename' contains an intermediate version of the email you were composing.\n";
|
|
|
|
}
|
|
|
|
if (-e ($compose_filename . ".final")) {
|
|
|
|
print "'$compose_filename.final' contains the composed email.\n"
|
|
|
|
}
|
2008-02-04 00:53:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
exit;
|
|
|
|
};
|
|
|
|
|
|
|
|
$SIG{TERM} = \&signal_handler;
|
|
|
|
$SIG{INT} = \&signal_handler;
|
|
|
|
|
2005-07-31 08:17:25 +00:00
|
|
|
# Begin by accumulating all the variables (defined above), that we will end up
|
|
|
|
# needing, first, from the command line:
|
|
|
|
|
2011-09-03 17:06:13 +00:00
|
|
|
my $help;
|
|
|
|
my $rc = GetOptions("h" => \$help,
|
|
|
|
"sender|from=s" => \$sender,
|
2005-07-31 08:17:25 +00:00
|
|
|
"in-reply-to=s" => \$initial_reply_to,
|
|
|
|
"subject=s" => \$initial_subject,
|
2010-10-04 07:05:24 +00:00
|
|
|
"to=s" => \@initial_to,
|
2010-09-24 17:03:00 +00:00
|
|
|
"to-cmd=s" => \$to_cmd,
|
2010-03-07 22:46:48 +00:00
|
|
|
"no-to" => \$no_to,
|
2006-02-13 08:05:15 +00:00
|
|
|
"cc=s" => \@initial_cc,
|
2010-03-07 22:46:48 +00:00
|
|
|
"no-cc" => \$no_cc,
|
2006-05-29 19:30:13 +00:00
|
|
|
"bcc=s" => \@bcclist,
|
2010-03-07 22:46:48 +00:00
|
|
|
"no-bcc" => \$no_bcc,
|
2005-08-01 00:04:24 +00:00
|
|
|
"chain-reply-to!" => \$chain_reply_to,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-chain-reply-to" => sub {$chain_reply_to = 0},
|
2005-08-01 00:04:24 +00:00
|
|
|
"smtp-server=s" => \$smtp_server,
|
2010-09-06 18:12:11 +00:00
|
|
|
"smtp-server-option=s" => \@smtp_server_options,
|
2007-09-26 00:27:54 +00:00
|
|
|
"smtp-server-port=s" => \$smtp_server_port,
|
2007-09-02 18:06:25 +00:00
|
|
|
"smtp-user=s" => \$smtp_authuser,
|
2008-02-04 00:53:56 +00:00
|
|
|
"smtp-pass:s" => \$smtp_authpass,
|
2008-06-25 19:42:43 +00:00
|
|
|
"smtp-ssl" => sub { $smtp_encryption = 'ssl' },
|
|
|
|
"smtp-encryption=s" => \$smtp_encryption,
|
2013-12-01 22:48:42 +00:00
|
|
|
"smtp-ssl-cert-path=s" => \$smtp_ssl_cert_path,
|
2010-03-14 15:16:09 +00:00
|
|
|
"smtp-debug:i" => \$debug_net_smtp,
|
2010-04-10 14:53:56 +00:00
|
|
|
"smtp-domain:s" => \$smtp_domain,
|
2007-09-02 18:06:25 +00:00
|
|
|
"identity=s" => \$identity,
|
2013-04-07 07:10:27 +00:00
|
|
|
"annotate!" => \$annotate,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-annotate" => sub {$annotate = 0},
|
2005-09-05 05:13:07 +00:00
|
|
|
"compose" => \$compose,
|
2006-02-02 16:56:06 +00:00
|
|
|
"quiet" => \$quiet,
|
2007-08-18 01:51:12 +00:00
|
|
|
"cc-cmd=s" => \$cc_cmd,
|
2007-06-28 03:59:37 +00:00
|
|
|
"suppress-from!" => \$suppress_from,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-suppress-from" => sub {$suppress_from = 0},
|
2007-12-26 03:56:29 +00:00
|
|
|
"suppress-cc=s" => \@suppress_cc,
|
2008-09-30 12:58:32 +00:00
|
|
|
"signed-off-cc|signed-off-by-cc!" => \$signed_off_by_cc,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-signed-off-cc|no-signed-off-by-cc" => sub {$signed_off_by_cc = 0},
|
2014-04-29 05:41:16 +00:00
|
|
|
"cc-cover|cc-cover!" => \$cover_cc,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-cc-cover" => sub {$cover_cc = 0},
|
2014-04-29 05:41:16 +00:00
|
|
|
"to-cover|to-cover!" => \$cover_to,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-to-cover" => sub {$cover_to = 0},
|
2009-03-03 04:52:18 +00:00
|
|
|
"confirm=s" => \$confirm,
|
2006-10-10 14:58:23 +00:00
|
|
|
"dry-run" => \$dry_run,
|
2007-04-26 02:37:22 +00:00
|
|
|
"envelope-sender=s" => \$envelope_sender,
|
2007-06-28 03:59:37 +00:00
|
|
|
"thread!" => \$thread,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-thread" => sub {$thread = 0},
|
2008-09-30 12:58:27 +00:00
|
|
|
"validate!" => \$validate,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-validate" => sub {$validate = 0},
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 14:00:27 +00:00
|
|
|
"transfer-encoding=s" => \$target_xfer_encoding,
|
2008-11-10 23:54:00 +00:00
|
|
|
"format-patch!" => \$format_patch,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-format-patch" => sub {$format_patch = 0},
|
2010-06-17 20:10:39 +00:00
|
|
|
"8bit-encoding=s" => \$auto_8bit_encoding,
|
2012-10-09 23:02:56 +00:00
|
|
|
"compose-encoding=s" => \$compose_encoding,
|
2009-06-08 21:34:12 +00:00
|
|
|
"force" => \$force,
|
2014-03-24 21:38:27 +00:00
|
|
|
"xmailer!" => \$use_xmailer,
|
2015-01-31 02:40:17 +00:00
|
|
|
"no-xmailer" => sub {$use_xmailer = 0},
|
2005-07-31 08:17:25 +00:00
|
|
|
);
|
|
|
|
|
2011-09-03 17:06:13 +00:00
|
|
|
usage() if $help;
|
2007-02-28 04:47:54 +00:00
|
|
|
unless ($rc) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
|
2009-02-15 04:32:13 +00:00
|
|
|
die "Cannot run git format-patch from outside a repository\n"
|
|
|
|
if $format_patch and not $repo;
|
|
|
|
|
2007-09-02 18:06:25 +00:00
|
|
|
# Now, let's fill any that aren't set in with defaults:
|
|
|
|
|
|
|
|
sub read_config {
|
|
|
|
my ($prefix) = @_;
|
|
|
|
|
|
|
|
foreach my $setting (keys %config_bool_settings) {
|
|
|
|
my $target = $config_bool_settings{$setting}->[0];
|
2008-03-14 17:29:30 +00:00
|
|
|
$$target = Git::config_bool(@repo, "$prefix.$setting") unless (defined $$target);
|
2007-09-02 18:06:25 +00:00
|
|
|
}
|
|
|
|
|
2011-09-30 10:52:25 +00:00
|
|
|
foreach my $setting (keys %config_path_settings) {
|
send-email: Fix %config_path_settings handling
cec5dae (use new Git::config_path() for aliasesfile, 2011-09-30) broke
the expansion of aliases.
This was caused by treating %config_path_settings, newly introduced in
said patch, like %config_bool_settings instead of like %config_settings.
Copy from %config_settings, making it more readable.
While at it add basic test for expansion of aliases, and for path
expansion, which would catch this error.
Nb. there were a few issues that were responsible for this error:
1. %config_bool_settings and %config_settings despite similar name have
different semantic.
%config_bool_settings values are arrays where the first element is
(reference to) the variable to set, and second element is default
value... which admittedly is a bit cryptic. More readable if more
verbose option would be to use hash reference, e.g.:
my %config_bool_settings = (
"thread" => { variable => \$thread, default => 1},
[...]
%config_settings values are either either reference to scalar variable
or reference to array. In second case it means that option (or config
option) is multi-valued. BTW. this is similar to what Getopt::Long does.
2. In cec5dae (use new Git::config_path() for aliasesfile, 2011-09-30)
the setting "aliasesfile" was moved from %config_settings to newly
introduced %config_path_settings. But the loop that parses settings
from %config_path_settings was copy'n'pasted *wrongly* from
%config_bool_settings instead of from %config_settings.
It looks like cec5dae author cargo-culted this change...
3. 994d6c6 (send-email: address expansion for common mailers, 2006-05-14)
didn't add test for alias expansion to t9001-send-email.sh
Signed-off-by: Cord Seele <cowose@gmail.com>
Tested-by: Michael J Gruber <git@drmicha.warpmail.net>
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-14 20:53:31 +00:00
|
|
|
my $target = $config_path_settings{$setting};
|
|
|
|
if (ref($target) eq "ARRAY") {
|
|
|
|
unless (@$target) {
|
|
|
|
my @values = Git::config_path(@repo, "$prefix.$setting");
|
|
|
|
@$target = @values if (@values && defined $values[0]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$$target = Git::config_path(@repo, "$prefix.$setting") unless (defined $$target);
|
|
|
|
}
|
2011-09-30 10:52:25 +00:00
|
|
|
}
|
|
|
|
|
2007-09-02 18:06:25 +00:00
|
|
|
foreach my $setting (keys %config_settings) {
|
|
|
|
my $target = $config_settings{$setting};
|
2010-03-07 22:46:48 +00:00
|
|
|
next if $setting eq "to" and defined $no_to;
|
|
|
|
next if $setting eq "cc" and defined $no_cc;
|
|
|
|
next if $setting eq "bcc" and defined $no_bcc;
|
2007-09-02 18:06:25 +00:00
|
|
|
if (ref($target) eq "ARRAY") {
|
|
|
|
unless (@$target) {
|
2008-03-14 17:29:30 +00:00
|
|
|
my @values = Git::config(@repo, "$prefix.$setting");
|
2007-09-02 18:06:25 +00:00
|
|
|
@$target = @values if (@values && defined $values[0]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2008-03-14 17:29:30 +00:00
|
|
|
$$target = Git::config(@repo, "$prefix.$setting") unless (defined $$target);
|
2007-09-02 18:06:25 +00:00
|
|
|
}
|
|
|
|
}
|
2008-06-25 19:42:43 +00:00
|
|
|
|
|
|
|
if (!defined $smtp_encryption) {
|
|
|
|
my $enc = Git::config(@repo, "$prefix.smtpencryption");
|
|
|
|
if (defined $enc) {
|
|
|
|
$smtp_encryption = $enc;
|
|
|
|
} elsif (Git::config_bool(@repo, "$prefix.smtpssl")) {
|
|
|
|
$smtp_encryption = 'ssl';
|
|
|
|
}
|
|
|
|
}
|
2007-09-02 18:06:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
# read configuration from [sendemail "$identity"], fall back on [sendemail]
|
2008-03-14 17:29:30 +00:00
|
|
|
$identity = Git::config(@repo, "sendemail.identity") unless (defined $identity);
|
2007-09-02 18:06:25 +00:00
|
|
|
read_config("sendemail.$identity") if (defined $identity);
|
|
|
|
read_config("sendemail");
|
|
|
|
|
|
|
|
# fall back on builtin bool defaults
|
|
|
|
foreach my $setting (values %config_bool_settings) {
|
|
|
|
${$setting->[0]} = $setting->[1] unless (defined (${$setting->[0]}));
|
|
|
|
}
|
|
|
|
|
2008-06-26 21:03:21 +00:00
|
|
|
# 'default' encryption is none -- this only prevents a warning
|
|
|
|
$smtp_encryption = '' unless (defined $smtp_encryption);
|
|
|
|
|
2007-12-26 03:56:29 +00:00
|
|
|
# Set CC suppressions
|
|
|
|
my(%suppress_cc);
|
|
|
|
if (@suppress_cc) {
|
|
|
|
foreach my $entry (@suppress_cc) {
|
|
|
|
die "Unknown --suppress-cc field: '$entry'\n"
|
2010-09-30 13:43:04 +00:00
|
|
|
unless $entry =~ /^(?:all|cccmd|cc|author|self|sob|body|bodycc)$/;
|
2007-12-26 03:56:29 +00:00
|
|
|
$suppress_cc{$entry} = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($suppress_cc{'all'}) {
|
2009-06-18 12:31:32 +00:00
|
|
|
foreach my $entry (qw (cccmd cc author self sob body bodycc)) {
|
2007-12-26 03:56:29 +00:00
|
|
|
$suppress_cc{$entry} = 1;
|
|
|
|
}
|
|
|
|
delete $suppress_cc{'all'};
|
|
|
|
}
|
|
|
|
|
|
|
|
# If explicit old-style ones are specified, they trump --suppress-cc.
|
|
|
|
$suppress_cc{'self'} = $suppress_from if defined $suppress_from;
|
2008-09-30 12:58:32 +00:00
|
|
|
$suppress_cc{'sob'} = !$signed_off_by_cc if defined $signed_off_by_cc;
|
2007-12-26 03:56:29 +00:00
|
|
|
|
2009-02-15 04:32:15 +00:00
|
|
|
if ($suppress_cc{'body'}) {
|
|
|
|
foreach my $entry (qw (sob bodycc)) {
|
|
|
|
$suppress_cc{$entry} = 1;
|
|
|
|
}
|
|
|
|
delete $suppress_cc{'body'};
|
|
|
|
}
|
|
|
|
|
2009-03-03 04:52:18 +00:00
|
|
|
# Set confirm's default value
|
|
|
|
my $confirm_unconfigured = !defined $confirm;
|
|
|
|
if ($confirm_unconfigured) {
|
|
|
|
$confirm = scalar %suppress_cc ? 'compose' : 'auto';
|
|
|
|
};
|
|
|
|
die "Unknown --confirm setting: '$confirm'\n"
|
|
|
|
unless $confirm =~ /^(?:auto|cc|compose|always|never)/;
|
|
|
|
|
2007-12-26 03:56:29 +00:00
|
|
|
# Debugging, print out the suppressions.
|
|
|
|
if (0) {
|
|
|
|
print "suppressions:\n";
|
|
|
|
foreach my $entry (keys %suppress_cc) {
|
|
|
|
printf " %-5s -> $suppress_cc{$entry}\n", $entry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-14 17:29:30 +00:00
|
|
|
my ($repoauthor, $repocommitter);
|
|
|
|
($repoauthor) = Git::ident_person(@repo, 'author');
|
|
|
|
($repocommitter) = Git::ident_person(@repo, 'committer');
|
2007-09-02 18:06:25 +00:00
|
|
|
|
2009-02-15 04:32:14 +00:00
|
|
|
sub parse_address_line {
|
|
|
|
if ($have_mail_address) {
|
|
|
|
return map { $_->format } Mail::Address->parse($_[0]);
|
|
|
|
} else {
|
2015-07-07 13:38:15 +00:00
|
|
|
return Git::parse_mailboxes($_[0]);
|
2009-02-15 04:32:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-19 08:10:10 +00:00
|
|
|
sub split_addrs {
|
2008-12-21 09:57:59 +00:00
|
|
|
return quotewords('\s*,\s*', 1, @_);
|
2008-12-19 08:10:10 +00:00
|
|
|
}
|
|
|
|
|
2006-05-15 02:13:44 +00:00
|
|
|
my %aliases;
|
2015-05-31 22:29:27 +00:00
|
|
|
|
|
|
|
sub parse_sendmail_alias {
|
|
|
|
local $_ = shift;
|
|
|
|
if (/"/) {
|
|
|
|
print STDERR "warning: sendmail alias with quotes is not supported: $_\n";
|
2015-06-01 18:22:36 +00:00
|
|
|
} elsif (/:include:/) {
|
|
|
|
print STDERR "warning: `:include:` not supported: $_\n";
|
|
|
|
} elsif (/[\/|]/) {
|
|
|
|
print STDERR "warning: `/file` or `|pipe` redirection not supported: $_\n";
|
2015-05-31 22:29:27 +00:00
|
|
|
} elsif (/^(\S+?)\s*:\s*(.+)$/) {
|
|
|
|
my ($alias, $addr) = ($1, $2);
|
|
|
|
$aliases{$alias} = [ split_addrs($addr) ];
|
|
|
|
} else {
|
|
|
|
print STDERR "warning: sendmail line is not recognized: $_\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sub parse_sendmail_aliases {
|
|
|
|
my $fh = shift;
|
2015-05-31 22:29:29 +00:00
|
|
|
my $s = '';
|
2015-05-31 22:29:27 +00:00
|
|
|
while (<$fh>) {
|
2015-05-31 22:29:29 +00:00
|
|
|
chomp;
|
2015-05-31 22:29:28 +00:00
|
|
|
next if /^\s*$/ || /^\s*#/;
|
2015-05-31 22:29:29 +00:00
|
|
|
$s .= $_, next if $s =~ s/\\$// || s/^\s+//;
|
|
|
|
parse_sendmail_alias($s) if $s;
|
|
|
|
$s = $_;
|
2015-05-31 22:29:27 +00:00
|
|
|
}
|
2015-05-31 22:29:29 +00:00
|
|
|
$s =~ s/\\$//; # silently tolerate stray '\' on last line
|
|
|
|
parse_sendmail_alias($s) if $s;
|
2015-05-31 22:29:27 +00:00
|
|
|
}
|
|
|
|
|
2006-05-15 02:13:44 +00:00
|
|
|
my %parse_alias = (
|
|
|
|
# multiline formats can be supported in the future
|
|
|
|
mutt => sub { my $fh = shift; while (<$fh>) {
|
2009-09-30 14:49:36 +00:00
|
|
|
if (/^\s*alias\s+(?:-group\s+\S+\s+)*(\S+)\s+(.*)$/) {
|
2006-05-15 02:13:44 +00:00
|
|
|
my ($alias, $addr) = ($1, $2);
|
|
|
|
$addr =~ s/#.*$//; # mutt allows # comments
|
|
|
|
# commas delimit multiple addresses
|
2008-12-19 08:10:10 +00:00
|
|
|
$aliases{$alias} = [ split_addrs($addr) ];
|
2006-05-15 02:13:44 +00:00
|
|
|
}}},
|
|
|
|
mailrc => sub { my $fh = shift; while (<$fh>) {
|
|
|
|
if (/^alias\s+(\S+)\s+(.*)$/) {
|
|
|
|
# spaces delimit multiple addresses
|
2009-05-21 02:45:53 +00:00
|
|
|
$aliases{$1} = [ quotewords('\s+', 0, $2) ];
|
2006-05-15 02:13:44 +00:00
|
|
|
}}},
|
2008-11-26 02:55:00 +00:00
|
|
|
pine => sub { my $fh = shift; my $f='\t[^\t]*';
|
|
|
|
for (my $x = ''; defined($x); $x = $_) {
|
|
|
|
chomp $x;
|
|
|
|
$x .= $1 while(defined($_ = <$fh>) && /^ +(.*)$/);
|
|
|
|
$x =~ /^(\S+)$f\t\(?([^\t]+?)\)?(:?$f){0,2}$/ or next;
|
2008-12-19 08:10:10 +00:00
|
|
|
$aliases{$1} = [ split_addrs($2) ];
|
2008-11-26 02:55:00 +00:00
|
|
|
}},
|
2009-04-22 13:41:29 +00:00
|
|
|
elm => sub { my $fh = shift;
|
|
|
|
while (<$fh>) {
|
|
|
|
if (/^(\S+)\s+=\s+[^=]+=\s(\S+)/) {
|
|
|
|
my ($alias, $addr) = ($1, $2);
|
|
|
|
$aliases{$alias} = [ split_addrs($addr) ];
|
|
|
|
}
|
|
|
|
} },
|
2015-05-31 22:29:27 +00:00
|
|
|
sendmail => \&parse_sendmail_aliases,
|
2006-05-15 02:13:44 +00:00
|
|
|
gnus => sub { my $fh = shift; while (<$fh>) {
|
|
|
|
if (/\(define-mail-alias\s+"(\S+?)"\s+"(\S+?)"\)/) {
|
|
|
|
$aliases{$1} = [ $2 ];
|
|
|
|
}}}
|
|
|
|
);
|
|
|
|
|
2006-07-03 20:47:58 +00:00
|
|
|
if (@alias_files and $aliasfiletype and defined $parse_alias{$aliasfiletype}) {
|
2006-05-15 02:13:44 +00:00
|
|
|
foreach my $file (@alias_files) {
|
|
|
|
open my $fh, '<', $file or die "opening $file: $!\n";
|
|
|
|
$parse_alias{$aliasfiletype}->($fh);
|
|
|
|
close $fh;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-01 01:40:41 +00:00
|
|
|
# is_format_patch_arg($f) returns 0 if $f names a patch, or 1 if
|
|
|
|
# $f is a revision list specification to be passed to format-patch.
|
|
|
|
sub is_format_patch_arg {
|
2009-02-15 04:32:13 +00:00
|
|
|
return unless $repo;
|
2008-11-10 23:54:00 +00:00
|
|
|
my $f = shift;
|
|
|
|
try {
|
|
|
|
$repo->command('rev-parse', '--verify', '--quiet', $f);
|
|
|
|
if (defined($format_patch)) {
|
|
|
|
return $format_patch;
|
|
|
|
}
|
|
|
|
die(<<EOF);
|
|
|
|
File '$f' exists but it could also be the range of commits
|
|
|
|
to produce patches for. Please disambiguate by...
|
|
|
|
|
|
|
|
* Saying "./$f" if you mean a file; or
|
|
|
|
* Giving --format-patch option if you mean a range.
|
|
|
|
EOF
|
|
|
|
} catch Git::Error::Command with {
|
2013-04-01 01:40:41 +00:00
|
|
|
# Not a valid revision. Treat it as a filename.
|
2008-11-10 23:54:00 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-18 14:19:36 +00:00
|
|
|
# Now that all the defaults are set, process the rest of the command line
|
|
|
|
# arguments and collect up the files that need to be processed.
|
2008-11-10 23:54:00 +00:00
|
|
|
my @rev_list_opts;
|
2008-12-01 06:38:20 +00:00
|
|
|
while (defined(my $f = shift @ARGV)) {
|
2008-11-10 23:54:00 +00:00
|
|
|
if ($f eq "--") {
|
|
|
|
push @rev_list_opts, "--", @ARGV;
|
|
|
|
@ARGV = ();
|
2013-04-01 01:40:41 +00:00
|
|
|
} elsif (-d $f and !is_format_patch_arg($f)) {
|
2010-09-30 13:42:54 +00:00
|
|
|
opendir my $dh, $f
|
2008-01-18 14:19:36 +00:00
|
|
|
or die "Failed to opendir $f: $!";
|
|
|
|
|
2010-09-14 19:02:24 +00:00
|
|
|
push @files, grep { -f $_ } map { catfile($f, $_) }
|
2010-09-30 13:42:54 +00:00
|
|
|
sort readdir $dh;
|
|
|
|
closedir $dh;
|
2013-04-01 01:40:41 +00:00
|
|
|
} elsif ((-f $f or -p $f) and !is_format_patch_arg($f)) {
|
2008-01-18 14:19:36 +00:00
|
|
|
push @files, $f;
|
|
|
|
} else {
|
2008-11-10 23:54:00 +00:00
|
|
|
push @rev_list_opts, $f;
|
2008-01-18 14:19:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-10 23:54:00 +00:00
|
|
|
if (@rev_list_opts) {
|
2009-02-15 04:32:13 +00:00
|
|
|
die "Cannot run git format-patch from outside a repository\n"
|
|
|
|
unless $repo;
|
2008-11-10 23:54:00 +00:00
|
|
|
push @files, $repo->command('format-patch', '-o', tempdir(CLEANUP => 1), @rev_list_opts);
|
|
|
|
}
|
|
|
|
|
2008-09-30 12:58:27 +00:00
|
|
|
if ($validate) {
|
2008-01-18 14:20:10 +00:00
|
|
|
foreach my $f (@files) {
|
2008-06-25 22:44:40 +00:00
|
|
|
unless (-p $f) {
|
|
|
|
my $error = validate_patch($f);
|
|
|
|
$error and die "fatal: $f: $error\nwarning: no patches were sent\n";
|
|
|
|
}
|
2008-01-18 14:20:10 +00:00
|
|
|
}
|
2008-01-18 14:19:48 +00:00
|
|
|
}
|
|
|
|
|
2008-01-18 14:19:36 +00:00
|
|
|
if (@files) {
|
|
|
|
unless ($quiet) {
|
|
|
|
print $_,"\n" for (@files);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
print STDERR "\nNo patch files specified!\n\n";
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
|
2010-09-30 13:42:57 +00:00
|
|
|
sub get_patch_subject {
|
2008-11-10 23:54:02 +00:00
|
|
|
my $fn = shift;
|
|
|
|
open (my $fh, '<', $fn);
|
|
|
|
while (my $line = <$fh>) {
|
|
|
|
next unless ($line =~ /^Subject: (.*)$/);
|
|
|
|
close $fh;
|
|
|
|
return "GIT: $1\n";
|
|
|
|
}
|
|
|
|
close $fh;
|
|
|
|
die "No subject line in $fn ?";
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($compose) {
|
|
|
|
# Note that this does not need to be secure, but we will make a small
|
|
|
|
# effort to have it be unique
|
2009-02-23 18:51:37 +00:00
|
|
|
$compose_filename = ($repo ?
|
|
|
|
tempfile(".gitsendemail.msg.XXXXXX", DIR => $repo->repo_path()) :
|
|
|
|
tempfile(".gitsendemail.msg.XXXXXX", DIR => "."))[1];
|
2010-09-30 13:42:55 +00:00
|
|
|
open my $c, ">", $compose_filename
|
2008-11-10 23:54:02 +00:00
|
|
|
or die "Failed to open for writing $compose_filename: $!";
|
|
|
|
|
|
|
|
|
|
|
|
my $tpl_sender = $sender || $repoauthor || $repocommitter || '';
|
|
|
|
my $tpl_subject = $initial_subject || '';
|
|
|
|
my $tpl_reply_to = $initial_reply_to || '';
|
|
|
|
|
2010-09-30 13:42:55 +00:00
|
|
|
print $c <<EOT;
|
2008-11-10 23:54:02 +00:00
|
|
|
From $tpl_sender # This line is ignored.
|
2009-04-13 18:23:50 +00:00
|
|
|
GIT: Lines beginning in "GIT:" will be removed.
|
2008-11-10 23:54:02 +00:00
|
|
|
GIT: Consider including an overall diffstat or table of contents
|
|
|
|
GIT: for the patch you are writing.
|
|
|
|
GIT:
|
|
|
|
GIT: Clear the body content if you don't wish to send a summary.
|
|
|
|
From: $tpl_sender
|
|
|
|
Subject: $tpl_subject
|
|
|
|
In-Reply-To: $tpl_reply_to
|
|
|
|
|
|
|
|
EOT
|
|
|
|
for my $f (@files) {
|
2010-09-30 13:42:55 +00:00
|
|
|
print $c get_patch_subject($f);
|
2008-11-10 23:54:02 +00:00
|
|
|
}
|
2010-09-30 13:42:55 +00:00
|
|
|
close $c;
|
2008-11-10 23:54:02 +00:00
|
|
|
|
|
|
|
if ($annotate) {
|
|
|
|
do_edit($compose_filename, @files);
|
|
|
|
} else {
|
|
|
|
do_edit($compose_filename);
|
|
|
|
}
|
|
|
|
|
2010-09-30 13:42:55 +00:00
|
|
|
open my $c2, ">", $compose_filename . ".final"
|
2008-11-10 23:54:02 +00:00
|
|
|
or die "Failed to open $compose_filename.final : " . $!;
|
|
|
|
|
2010-09-30 13:42:55 +00:00
|
|
|
open $c, "<", $compose_filename
|
2008-11-10 23:54:02 +00:00
|
|
|
or die "Failed to open $compose_filename : " . $!;
|
|
|
|
|
|
|
|
my $need_8bit_cte = file_has_nonascii($compose_filename);
|
|
|
|
my $in_body = 0;
|
|
|
|
my $summary_empty = 1;
|
2012-10-22 12:41:48 +00:00
|
|
|
if (!defined $compose_encoding) {
|
|
|
|
$compose_encoding = "UTF-8";
|
|
|
|
}
|
2010-09-30 13:42:55 +00:00
|
|
|
while(<$c>) {
|
2009-04-13 18:23:50 +00:00
|
|
|
next if m/^GIT:/;
|
2008-11-10 23:54:02 +00:00
|
|
|
if ($in_body) {
|
|
|
|
$summary_empty = 0 unless (/^\n$/);
|
|
|
|
} elsif (/^\n$/) {
|
|
|
|
$in_body = 1;
|
|
|
|
if ($need_8bit_cte) {
|
2010-09-30 13:42:55 +00:00
|
|
|
print $c2 "MIME-Version: 1.0\n",
|
2008-11-10 23:54:02 +00:00
|
|
|
"Content-Type: text/plain; ",
|
2012-10-09 23:02:56 +00:00
|
|
|
"charset=$compose_encoding\n",
|
2008-11-10 23:54:02 +00:00
|
|
|
"Content-Transfer-Encoding: 8bit\n";
|
|
|
|
}
|
|
|
|
} elsif (/^MIME-Version:/i) {
|
|
|
|
$need_8bit_cte = 0;
|
|
|
|
} elsif (/^Subject:\s*(.+)\s*$/i) {
|
|
|
|
$initial_subject = $1;
|
|
|
|
my $subject = $initial_subject;
|
|
|
|
$_ = "Subject: " .
|
2012-10-24 21:08:26 +00:00
|
|
|
quote_subject($subject, $compose_encoding) .
|
2008-11-10 23:54:02 +00:00
|
|
|
"\n";
|
|
|
|
} elsif (/^In-Reply-To:\s*(.+)\s*$/i) {
|
|
|
|
$initial_reply_to = $1;
|
|
|
|
next;
|
|
|
|
} elsif (/^From:\s*(.+)\s*$/i) {
|
|
|
|
$sender = $1;
|
|
|
|
next;
|
|
|
|
} elsif (/^(?:To|Cc|Bcc):/i) {
|
|
|
|
print "To/Cc/Bcc fields are not interpreted yet, they have been ignored\n";
|
|
|
|
next;
|
|
|
|
}
|
2010-09-30 13:42:55 +00:00
|
|
|
print $c2 $_;
|
2008-11-10 23:54:02 +00:00
|
|
|
}
|
2010-09-30 13:42:55 +00:00
|
|
|
close $c;
|
|
|
|
close $c2;
|
2008-11-10 23:54:02 +00:00
|
|
|
|
|
|
|
if ($summary_empty) {
|
|
|
|
print "Summary email is empty, skipping it\n";
|
|
|
|
$compose = -1;
|
|
|
|
}
|
|
|
|
} elsif ($annotate) {
|
|
|
|
do_edit(@files);
|
|
|
|
}
|
|
|
|
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
sub ask {
|
|
|
|
my ($prompt, %arg) = @_;
|
2009-04-05 03:23:21 +00:00
|
|
|
my $valid_re = $arg{valid_re};
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
my $default = $arg{default};
|
2012-08-14 22:15:53 +00:00
|
|
|
my $confirm_only = $arg{confirm_only};
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
my $resp;
|
|
|
|
my $i = 0;
|
2009-03-31 16:22:11 +00:00
|
|
|
return defined $default ? $default : undef
|
|
|
|
unless defined $term->IN and defined fileno($term->IN) and
|
|
|
|
defined $term->OUT and defined fileno($term->OUT);
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
while ($i++ < 10) {
|
|
|
|
$resp = $term->readline($prompt);
|
|
|
|
if (!defined $resp) { # EOF
|
|
|
|
print "\n";
|
|
|
|
return defined $default ? $default : undef;
|
|
|
|
}
|
|
|
|
if ($resp eq '' and defined $default) {
|
|
|
|
return $default;
|
|
|
|
}
|
2009-04-05 03:23:21 +00:00
|
|
|
if (!defined $valid_re or $resp =~ /$valid_re/) {
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
return $resp;
|
|
|
|
}
|
2012-08-14 22:15:53 +00:00
|
|
|
if ($confirm_only) {
|
|
|
|
my $yesno = $term->readline("Are you sure you want to use <$resp> [y/N]? ");
|
|
|
|
if (defined $yesno && $yesno =~ /y/i) {
|
|
|
|
return $resp;
|
|
|
|
}
|
|
|
|
}
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
}
|
2013-04-01 01:40:40 +00:00
|
|
|
return;
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
}
|
|
|
|
|
2010-06-17 20:10:39 +00:00
|
|
|
my %broken_encoding;
|
|
|
|
|
2010-09-30 13:42:58 +00:00
|
|
|
sub file_declares_8bit_cte {
|
2010-06-17 20:10:39 +00:00
|
|
|
my $fn = shift;
|
|
|
|
open (my $fh, '<', $fn);
|
|
|
|
while (my $line = <$fh>) {
|
|
|
|
last if ($line =~ /^$/);
|
|
|
|
return 1 if ($line =~ /^Content-Transfer-Encoding: .*8bit.*$/);
|
|
|
|
}
|
|
|
|
close $fh;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach my $f (@files) {
|
|
|
|
next unless (body_or_subject_has_nonascii($f)
|
|
|
|
&& !file_declares_8bit_cte($f));
|
|
|
|
$broken_encoding{$f} = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!defined $auto_8bit_encoding && scalar %broken_encoding) {
|
|
|
|
print "The following files are 8bit, but do not declare " .
|
|
|
|
"a Content-Transfer-Encoding.\n";
|
|
|
|
foreach my $f (sort keys %broken_encoding) {
|
|
|
|
print " $f\n";
|
|
|
|
}
|
|
|
|
$auto_8bit_encoding = ask("Which 8bit encoding should I declare [UTF-8]? ",
|
2015-02-13 20:20:25 +00:00
|
|
|
valid_re => qr/.{4}/, confirm_only => 1,
|
2010-06-17 20:10:39 +00:00
|
|
|
default => "UTF-8");
|
|
|
|
}
|
|
|
|
|
2009-06-08 21:34:12 +00:00
|
|
|
if (!$force) {
|
|
|
|
for my $f (@files) {
|
2010-09-30 13:43:01 +00:00
|
|
|
if (get_patch_subject($f) =~ /\Q*** SUBJECT HERE ***\E/) {
|
2009-06-08 21:34:12 +00:00
|
|
|
die "Refusing to send because the patch\n\t$f\n"
|
|
|
|
. "has the template subject '*** SUBJECT HERE ***'. "
|
|
|
|
. "Pass --force if you really want to send.\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-30 12:16:47 +00:00
|
|
|
if (defined $sender) {
|
2015-06-30 12:16:51 +00:00
|
|
|
$sender =~ s/^\s+|\s+$//g;
|
2015-06-30 12:16:47 +00:00
|
|
|
($sender) = expand_aliases($sender);
|
|
|
|
} else {
|
2008-03-14 17:29:30 +00:00
|
|
|
$sender = $repoauthor || $repocommitter || '';
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
|
|
|
|
2013-06-05 18:11:00 +00:00
|
|
|
# $sender could be an already sanitized address
|
|
|
|
# (e.g. sendemail.from could be manually sanitized by user).
|
|
|
|
# But it's a no-op to run sanitize_address on an already sanitized address.
|
|
|
|
$sender = sanitize_address($sender);
|
|
|
|
|
send-email: avoid questions when user has an ident
Currently we keep getting questions even when the user has properly
configured his full name and password:
Who should the emails appear to be from?
[Felipe Contreras <felipe.contreras@gmail.com>]
And once a question pops up, other questions are turned on. This is
annoying.
The reason it's safe to avoid this question is because currently the
script fails completely when the author (or committer) is not correct,
so we won't even be reaching this point in the code.
The scenarios, and the current situation:
1) No information at all, no fully qualified domain name
fatal: empty ident name (for <felipec@nysa.(none)>) not allowed
2) Only full name
fatal: unable to auto-detect email address (got 'felipec@nysa.(none)')
3) Full name + fqdm
Who should the emails appear to be from?
[Felipe Contreras <felipec@nysa.felipec.org>]
4) Full name + EMAIL
Who should the emails appear to be from?
[Felipe Contreras <felipe.contreras@gmail.com>]
5) User configured
6) GIT_COMMITTER
7) GIT_AUTHOR
All these are the same as 4)
After this patch:
1) 2) won't change: git send-email would still die
4) 5) 6) 7) will change: git send-email won't ask the user
This is good, that's what we would expect, because the identity is
explicit.
3) will change: git send-email won't ask the user
This is bad, because we will try with an address such as
'felipec@nysa.felipec.org', which is most likely not what the user
wants, but the user will get warned by default (confirm=auto), and if
not, most likely the sending won't work, which the user would readily
note and fix.
The worst possible scenario is that such mail address does work, and the
user sends an email from that address unintentionally, when in fact the
user expected to correct that address in the prompt. This is a very,
very, very unlikely scenario, with many dependencies:
1) No configured user.name/user.email
2) No specified $EMAIL
3) No configured sendemail.from
4) No specified --from argument
5) A fully qualified domain name
6) A full name in the geckos field
7) A sendmail configuration that allows sending from this domain name
8) confirm=never, or
8.1) confirm configuration not hitting, or
8.2) Getting the error, not being aware of it
9) The user expecting to correct this address in the prompt
In a more likely scenario where 7) is not the case (can't send from
nysa.felipec.org), the user will simply see the mail was not sent
properly, and fix the problem.
The much more likely scenario though, is where 5) is not the case
(nysa.(none)), and git send-email will fail right away like it does now.
So the likelihood of this affecting anybody seriously is very very slim,
and the chances of this affecting somebody slightly are still very
small. The vast majority, if not all, of git users won't be affected
negatively, and a lot will benefit from this.
Tests-by: Jeff King <peff@peff.net>
Signed-off-by: Felipe Contreras <felipe.contreras@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-24 11:16:19 +00:00
|
|
|
my $prompting = 0;
|
2010-10-27 05:02:03 +00:00
|
|
|
if (!@initial_to && !defined $to_cmd) {
|
2012-09-06 18:31:11 +00:00
|
|
|
my $to = ask("Who should the emails be sent to (if any)? ",
|
|
|
|
default => "",
|
2012-08-14 22:15:53 +00:00
|
|
|
valid_re => qr/\@.*\./, confirm_only => 1);
|
2010-10-04 07:05:24 +00:00
|
|
|
push @initial_to, parse_address_line($to) if defined $to; # sanitized/validated later
|
2005-09-05 05:13:07 +00:00
|
|
|
$prompting++;
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
|
|
|
|
2006-05-15 02:13:44 +00:00
|
|
|
sub expand_aliases {
|
2009-07-23 11:09:29 +00:00
|
|
|
return map { expand_one_alias($_) } @_;
|
|
|
|
}
|
|
|
|
|
|
|
|
my %EXPANDED_ALIASES;
|
|
|
|
sub expand_one_alias {
|
|
|
|
my $alias = shift;
|
|
|
|
if ($EXPANDED_ALIASES{$alias}) {
|
|
|
|
die "fatal: alias '$alias' expands to itself\n";
|
|
|
|
}
|
|
|
|
local $EXPANDED_ALIASES{$alias} = 1;
|
|
|
|
return $aliases{$alias} ? expand_aliases(@{$aliases{$alias}}) : $alias;
|
2006-05-15 02:13:44 +00:00
|
|
|
}
|
|
|
|
|
2015-06-30 12:16:45 +00:00
|
|
|
@initial_to = process_address_list(@initial_to);
|
|
|
|
@initial_cc = process_address_list(@initial_cc);
|
|
|
|
@bcclist = process_address_list(@bcclist);
|
2006-05-15 02:13:44 +00:00
|
|
|
|
2007-06-28 03:59:37 +00:00
|
|
|
if ($thread && !defined $initial_reply_to && $prompting) {
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
$initial_reply_to = ask(
|
2012-09-06 18:31:11 +00:00
|
|
|
"Message-ID to be used as In-Reply-To for the first email (if any)? ",
|
|
|
|
default => "",
|
2012-08-14 22:15:53 +00:00
|
|
|
valid_re => qr/\@.*\./, confirm_only => 1);
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
2008-02-20 05:55:07 +00:00
|
|
|
if (defined $initial_reply_to) {
|
2008-02-22 00:16:04 +00:00
|
|
|
$initial_reply_to =~ s/^\s*<?//;
|
|
|
|
$initial_reply_to =~ s/>?\s*$//;
|
|
|
|
$initial_reply_to = "<$initial_reply_to>" if $initial_reply_to ne '';
|
2007-12-11 05:44:42 +00:00
|
|
|
}
|
2007-12-09 17:17:28 +00:00
|
|
|
|
2007-09-02 18:06:25 +00:00
|
|
|
if (!defined $smtp_server) {
|
2006-05-15 09:34:44 +00:00
|
|
|
foreach (qw( /usr/sbin/sendmail /usr/lib/sendmail )) {
|
|
|
|
if (-x $_) {
|
|
|
|
$smtp_server = $_;
|
|
|
|
last;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$smtp_server ||= 'localhost'; # could be 127.0.0.1, too... *shrug*
|
2005-08-01 00:04:24 +00:00
|
|
|
}
|
|
|
|
|
2009-03-03 04:52:18 +00:00
|
|
|
if ($compose && $compose > 0) {
|
|
|
|
@files = ($compose_filename . ".final", @files);
|
2005-09-05 05:13:07 +00:00
|
|
|
}
|
|
|
|
|
2005-07-31 08:17:25 +00:00
|
|
|
# Variables we set as part of the loop over files
|
2009-03-03 04:52:18 +00:00
|
|
|
our ($message_id, %mail, $subject, $reply_to, $references, $message,
|
2009-03-31 16:22:12 +00:00
|
|
|
$needs_confirm, $message_num, $ask_default);
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2006-03-26 00:47:12 +00:00
|
|
|
sub extract_valid_address {
|
|
|
|
my $address = shift;
|
2010-09-30 19:03:31 +00:00
|
|
|
my $local_part_regexp = qr/[^<>"\s@]+/;
|
|
|
|
my $domain_regexp = qr/[^.<>"\s@]+(?:\.[^.<>"\s@]+)+/;
|
2006-05-15 09:41:01 +00:00
|
|
|
|
|
|
|
# check for a local address:
|
2006-06-06 07:05:56 +00:00
|
|
|
return $address if ($address =~ /^($local_part_regexp)$/);
|
2006-05-15 09:41:01 +00:00
|
|
|
|
2007-08-09 13:27:57 +00:00
|
|
|
$address =~ s/^\s*<(.*)>\s*$/$1/;
|
2006-03-26 00:47:12 +00:00
|
|
|
if ($have_email_valid) {
|
2006-06-06 07:05:56 +00:00
|
|
|
return scalar Email::Valid->address($address);
|
2006-03-26 00:47:12 +00:00
|
|
|
}
|
2012-11-22 18:12:09 +00:00
|
|
|
|
|
|
|
# less robust/correct than the monster regexp in Email::Valid,
|
|
|
|
# but still does a 99% job, and one less dependency
|
|
|
|
return $1 if $address =~ /($local_part_regexp\@$domain_regexp)/;
|
2013-04-01 01:40:40 +00:00
|
|
|
return;
|
2006-03-26 00:47:12 +00:00
|
|
|
}
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2012-11-22 18:12:10 +00:00
|
|
|
sub extract_valid_address_or_die {
|
|
|
|
my $address = shift;
|
|
|
|
$address = extract_valid_address($address);
|
|
|
|
die "error: unable to extract a valid address from: $address\n"
|
|
|
|
if !$address;
|
|
|
|
return $address;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub validate_address {
|
|
|
|
my $address = shift;
|
2012-11-22 18:12:12 +00:00
|
|
|
while (!extract_valid_address($address)) {
|
2012-11-22 18:12:11 +00:00
|
|
|
print STDERR "error: unable to extract a valid address from: $address\n";
|
2012-11-22 18:12:12 +00:00
|
|
|
$_ = ask("What to do with this address? ([q]uit|[d]rop|[e]dit): ",
|
|
|
|
valid_re => qr/^(?:quit|q|drop|d|edit|e)/i,
|
2012-11-22 18:12:11 +00:00
|
|
|
default => 'q');
|
|
|
|
if (/^d/i) {
|
|
|
|
return undef;
|
|
|
|
} elsif (/^q/i) {
|
|
|
|
cleanup_compose_files();
|
|
|
|
exit(0);
|
|
|
|
}
|
2012-11-22 18:12:12 +00:00
|
|
|
$address = ask("Who should the email be sent to (if any)? ",
|
|
|
|
default => "",
|
|
|
|
valid_re => qr/\@.*\./, confirm_only => 1);
|
2012-11-22 18:12:10 +00:00
|
|
|
}
|
|
|
|
return $address;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub validate_address_list {
|
|
|
|
return (grep { defined $_ }
|
|
|
|
map { validate_address($_) } @_);
|
2006-03-26 00:47:12 +00:00
|
|
|
}
|
2005-07-31 08:17:25 +00:00
|
|
|
|
|
|
|
# Usually don't need to change anything below here.
|
|
|
|
|
|
|
|
# we make a "fake" message id by taking the current number
|
|
|
|
# of seconds since the beginning of Unix time and tacking on
|
|
|
|
# a random number to the end, in case we are called quicker than
|
|
|
|
# 1 second since the last time we were called.
|
2005-08-01 00:04:24 +00:00
|
|
|
|
|
|
|
# We'll setup a template for the message id, using the "from" address:
|
|
|
|
|
2007-09-18 04:18:20 +00:00
|
|
|
my ($message_id_stamp, $message_id_serial);
|
2010-04-10 14:53:53 +00:00
|
|
|
sub make_message_id {
|
2007-09-18 04:18:20 +00:00
|
|
|
my $uniq;
|
|
|
|
if (!defined $message_id_stamp) {
|
|
|
|
$message_id_stamp = sprintf("%s-%s", time, $$);
|
|
|
|
$message_id_serial = 0;
|
|
|
|
}
|
|
|
|
$message_id_serial++;
|
|
|
|
$uniq = "$message_id_stamp-$message_id_serial";
|
|
|
|
|
2007-06-20 20:47:34 +00:00
|
|
|
my $du_part;
|
2007-08-09 13:27:58 +00:00
|
|
|
for ($sender, $repocommitter, $repoauthor) {
|
|
|
|
$du_part = extract_valid_address(sanitize_address($_));
|
|
|
|
last if (defined $du_part and $du_part ne '');
|
2007-06-20 20:47:34 +00:00
|
|
|
}
|
2007-08-09 13:27:58 +00:00
|
|
|
if (not defined $du_part or $du_part eq '') {
|
2010-09-30 13:43:08 +00:00
|
|
|
require Sys::Hostname;
|
2007-06-20 20:47:34 +00:00
|
|
|
$du_part = 'user@' . Sys::Hostname::hostname();
|
|
|
|
}
|
2007-09-18 04:18:20 +00:00
|
|
|
my $message_id_template = "<%s-git-send-email-%s>";
|
|
|
|
$message_id = sprintf($message_id_template, $uniq, $du_part);
|
2005-08-01 00:04:24 +00:00
|
|
|
#print "new message id = $message_id\n"; # Was useful for debugging
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-03-25 11:01:01 +00:00
|
|
|
$time = time - scalar $#files;
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2007-01-10 21:36:39 +00:00
|
|
|
sub unquote_rfc2047 {
|
|
|
|
local ($_) = @_;
|
2014-12-14 15:59:46 +00:00
|
|
|
my $charset;
|
2014-12-14 15:59:47 +00:00
|
|
|
my $sep = qr/[ \t]+/;
|
|
|
|
s{$re_encoded_word(?:$sep$re_encoded_word)*}{
|
|
|
|
my @words = split $sep, $&;
|
|
|
|
foreach (@words) {
|
|
|
|
m/$re_encoded_word/;
|
|
|
|
$charset = $1;
|
|
|
|
my $encoding = $2;
|
|
|
|
my $text = $3;
|
|
|
|
if ($encoding eq 'q' || $encoding eq 'Q') {
|
|
|
|
$_ = $text;
|
|
|
|
s/_/ /g;
|
|
|
|
s/=([0-9A-F]{2})/chr(hex($1))/egi;
|
|
|
|
} else {
|
|
|
|
# other encodings not supported yet
|
|
|
|
}
|
2014-12-14 15:59:46 +00:00
|
|
|
}
|
2014-12-14 15:59:47 +00:00
|
|
|
join '', @words;
|
2012-07-30 19:25:40 +00:00
|
|
|
}eg;
|
2014-12-14 15:59:46 +00:00
|
|
|
return wantarray ? ($_, $charset) : $_;
|
2007-01-10 21:36:39 +00:00
|
|
|
}
|
|
|
|
|
2008-03-28 21:29:01 +00:00
|
|
|
sub quote_rfc2047 {
|
|
|
|
local $_ = shift;
|
2009-06-07 01:12:31 +00:00
|
|
|
my $encoding = shift || 'UTF-8';
|
2008-03-28 21:29:01 +00:00
|
|
|
s/([^-a-zA-Z0-9!*+\/])/sprintf("=%02X", ord($1))/eg;
|
|
|
|
s/(.*)/=\?$encoding\?q\?$1\?=/;
|
|
|
|
return $_;
|
|
|
|
}
|
|
|
|
|
2009-06-08 00:25:58 +00:00
|
|
|
sub is_rfc2047_quoted {
|
|
|
|
my $s = shift;
|
|
|
|
length($s) <= 75 &&
|
2014-12-14 15:59:46 +00:00
|
|
|
$s =~ m/^(?:"[[:ascii:]]*"|$re_encoded_word)$/o;
|
2009-06-08 00:25:58 +00:00
|
|
|
}
|
|
|
|
|
2012-10-24 21:08:26 +00:00
|
|
|
sub subject_needs_rfc2047_quoting {
|
|
|
|
my $s = shift;
|
|
|
|
|
2012-10-24 21:28:29 +00:00
|
|
|
return ($s =~ /[^[:ascii:]]/) || ($s =~ /=\?/);
|
2012-10-24 21:08:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sub quote_subject {
|
|
|
|
local $subject = shift;
|
|
|
|
my $encoding = shift || 'UTF-8';
|
|
|
|
|
|
|
|
if (subject_needs_rfc2047_quoting($subject)) {
|
|
|
|
return quote_rfc2047($subject, $encoding);
|
|
|
|
}
|
|
|
|
return $subject;
|
|
|
|
}
|
|
|
|
|
2007-08-06 20:34:50 +00:00
|
|
|
# use the simplest quoting being able to handle the recipient
|
2010-04-10 14:53:53 +00:00
|
|
|
sub sanitize_address {
|
2007-04-26 02:37:19 +00:00
|
|
|
my ($recipient) = @_;
|
2012-11-22 18:12:08 +00:00
|
|
|
|
|
|
|
# remove garbage after email address
|
|
|
|
$recipient =~ s/(.*>).*$/$1/;
|
|
|
|
|
2007-08-06 20:34:50 +00:00
|
|
|
my ($recipient_name, $recipient_addr) = ($recipient =~ /^(.*?)\s*(<.*)/);
|
|
|
|
|
|
|
|
if (not $recipient_name) {
|
2010-09-30 13:43:02 +00:00
|
|
|
return $recipient;
|
2007-08-06 20:34:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
# if recipient_name is already quoted, do nothing
|
2009-06-08 00:25:58 +00:00
|
|
|
if (is_rfc2047_quoted($recipient_name)) {
|
2007-08-06 20:34:50 +00:00
|
|
|
return $recipient;
|
|
|
|
}
|
|
|
|
|
2015-06-30 12:16:49 +00:00
|
|
|
# remove non-escaped quotes
|
|
|
|
$recipient_name =~ s/(^|[^\\])"/$1/g;
|
|
|
|
|
2007-08-06 20:34:50 +00:00
|
|
|
# rfc2047 is needed if a non-ascii char is included
|
|
|
|
if ($recipient_name =~ /[^[:ascii:]]/) {
|
2008-03-28 21:29:01 +00:00
|
|
|
$recipient_name = quote_rfc2047($recipient_name);
|
2007-04-26 02:37:19 +00:00
|
|
|
}
|
2007-08-06 20:34:50 +00:00
|
|
|
|
|
|
|
# double quotes are needed if specials or CTLs are included
|
|
|
|
elsif ($recipient_name =~ /[][()<>@,;:\\".\000-\037\177]/) {
|
2015-06-30 12:16:49 +00:00
|
|
|
$recipient_name =~ s/([\\\r])/\\$1/g;
|
2010-09-30 13:43:03 +00:00
|
|
|
$recipient_name = qq["$recipient_name"];
|
2007-08-06 20:34:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return "$recipient_name $recipient_addr";
|
|
|
|
|
2007-04-26 02:37:19 +00:00
|
|
|
}
|
|
|
|
|
2012-11-22 18:12:10 +00:00
|
|
|
sub sanitize_address_list {
|
|
|
|
return (map { sanitize_address($_) } @_);
|
|
|
|
}
|
|
|
|
|
2015-06-30 12:16:45 +00:00
|
|
|
sub process_address_list {
|
2015-06-30 12:16:50 +00:00
|
|
|
my @addr_list = map { parse_address_line($_) } @_;
|
|
|
|
@addr_list = expand_aliases(@addr_list);
|
2015-06-30 12:16:45 +00:00
|
|
|
@addr_list = sanitize_address_list(@addr_list);
|
|
|
|
@addr_list = validate_address_list(@addr_list);
|
|
|
|
return @addr_list;
|
|
|
|
}
|
|
|
|
|
2010-03-14 15:16:45 +00:00
|
|
|
# Returns the local Fully Qualified Domain Name (FQDN) if available.
|
|
|
|
#
|
|
|
|
# Tightly configured MTAa require that a caller sends a real DNS
|
|
|
|
# domain name that corresponds the IP address in the HELO/EHLO
|
|
|
|
# handshake. This is used to verify the connection and prevent
|
|
|
|
# spammers from trying to hide their identity. If the DNS and IP don't
|
|
|
|
# match, the receiveing MTA may deny the connection.
|
|
|
|
#
|
|
|
|
# Here is a deny example of Net::SMTP with the default "localhost.localdomain"
|
|
|
|
#
|
|
|
|
# Net::SMTP=GLOB(0x267ec28)>>> EHLO localhost.localdomain
|
|
|
|
# Net::SMTP=GLOB(0x267ec28)<<< 550 EHLO argument does not match calling host
|
|
|
|
#
|
|
|
|
# This maildomain*() code is based on ideas in Perl library Test::Reporter
|
|
|
|
# /usr/share/perl5/Test/Reporter/Mail/Util.pm ==> sub _maildomain ()
|
|
|
|
|
2010-04-10 14:53:54 +00:00
|
|
|
sub valid_fqdn {
|
|
|
|
my $domain = shift;
|
2010-09-27 03:18:01 +00:00
|
|
|
return defined $domain && !($^O eq 'darwin' && $domain =~ /\.local$/) && $domain =~ /\./;
|
2010-04-10 14:53:54 +00:00
|
|
|
}
|
|
|
|
|
2010-04-10 14:53:53 +00:00
|
|
|
sub maildomain_net {
|
2010-03-14 15:16:45 +00:00
|
|
|
my $maildomain;
|
|
|
|
|
|
|
|
if (eval { require Net::Domain; 1 }) {
|
|
|
|
my $domain = Net::Domain::domainname();
|
2010-04-10 14:53:54 +00:00
|
|
|
$maildomain = $domain if valid_fqdn($domain);
|
2010-03-14 15:16:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return $maildomain;
|
|
|
|
}
|
|
|
|
|
2010-04-10 14:53:53 +00:00
|
|
|
sub maildomain_mta {
|
2010-03-14 15:16:45 +00:00
|
|
|
my $maildomain;
|
|
|
|
|
|
|
|
if (eval { require Net::SMTP; 1 }) {
|
|
|
|
for my $host (qw(mailhost localhost)) {
|
|
|
|
my $smtp = Net::SMTP->new($host);
|
|
|
|
if (defined $smtp) {
|
|
|
|
my $domain = $smtp->domain;
|
|
|
|
$smtp->quit;
|
|
|
|
|
2010-04-10 14:53:54 +00:00
|
|
|
$maildomain = $domain if valid_fqdn($domain);
|
2010-03-14 15:16:45 +00:00
|
|
|
|
|
|
|
last if $maildomain;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $maildomain;
|
|
|
|
}
|
|
|
|
|
2010-04-10 14:53:53 +00:00
|
|
|
sub maildomain {
|
2010-04-10 14:53:56 +00:00
|
|
|
return maildomain_net() || maildomain_mta() || 'localhost.localdomain';
|
2010-03-14 15:16:45 +00:00
|
|
|
}
|
|
|
|
|
2013-02-12 14:02:33 +00:00
|
|
|
sub smtp_host_string {
|
|
|
|
if (defined $smtp_server_port) {
|
|
|
|
return "$smtp_server:$smtp_server_port";
|
|
|
|
} else {
|
|
|
|
return $smtp_server;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
# Returns 1 if authentication succeeded or was not necessary
|
|
|
|
# (smtp_user was not specified), and 0 otherwise.
|
|
|
|
|
|
|
|
sub smtp_auth_maybe {
|
|
|
|
if (!defined $smtp_authuser || $auth) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Workaround AUTH PLAIN/LOGIN interaction defect
|
|
|
|
# with Authen::SASL::Cyrus
|
|
|
|
eval {
|
|
|
|
require Authen::SASL;
|
|
|
|
Authen::SASL->import(qw(Perl));
|
|
|
|
};
|
|
|
|
|
|
|
|
# TODO: Authentication may fail not because credentials were
|
|
|
|
# invalid but due to other reasons, in which we should not
|
|
|
|
# reject credentials.
|
|
|
|
$auth = Git::credential({
|
|
|
|
'protocol' => 'smtp',
|
|
|
|
'host' => smtp_host_string(),
|
|
|
|
'username' => $smtp_authuser,
|
|
|
|
# if there's no password, "git credential fill" will
|
|
|
|
# give us one, otherwise it'll just pass this one.
|
|
|
|
'password' => $smtp_authpass
|
|
|
|
}, sub {
|
|
|
|
my $cred = shift;
|
|
|
|
return !!$smtp->auth($cred->{'username'}, $cred->{'password'});
|
|
|
|
});
|
|
|
|
|
|
|
|
return $auth;
|
|
|
|
}
|
|
|
|
|
2013-07-18 16:53:11 +00:00
|
|
|
sub ssl_verify_params {
|
|
|
|
eval {
|
|
|
|
require IO::Socket::SSL;
|
|
|
|
IO::Socket::SSL->import(qw/SSL_VERIFY_PEER SSL_VERIFY_NONE/);
|
|
|
|
};
|
|
|
|
if ($@) {
|
|
|
|
print STDERR "Not using SSL_VERIFY_PEER due to out-of-date IO::Socket::SSL.\n";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!defined $smtp_ssl_cert_path) {
|
send-email: /etc/ssl/certs/ directory may not be usable as ca_path
When sending patches on Fedora rawhide with
git-1.8.5.2-1.fc21.x86_64 and perl-IO-Socket-SSL-1.962-1.fc21.noarch,
with the following
[sendemail]
smtpencryption = tls
smtpserver = smtp.gmail.com
smtpuser = ruben@rubenkerkhof.com
smtpserverport = 587
git-send-email fails with:
STARTTLS failed! SSL connect attempt failed with unknown error
error:14090086:SSL routines:SSL3_GET_SERVER_CERTIFICATE:certificate
verify failed at /usr/libexec/git-core/git-send-email line 1236.
The current code detects the presence of /etc/ssl/certs directory
(it actually is a symlink to another directory, but that does not
matter) and uses SSL_ca_path to point at it when initializing the
connection with IO::Socket::SSL or Net::SMTP::SSL. However, on the
said platform, it seems that this directory is not designed to be
used as SSL_ca_path. Using a single file inside that directory
(cert.pem, which is a Mozilla CA bundle) with SSL_ca_file does work,
and also not specifying any SSL_ca_file/SSL_ca_path (and letting the
library use its own default) and asking for peer verification does
work.
By removing the code that blindly defaults $smtp_ssl_cert_path to
"/etc/ssl/certs", we can prevent the codepath that treats any
directory specified with that variable as usable for SSL_ca_path
from incorrectly triggering.
This change could introduce a regression for people on a platform
whose certificate directory is /etc/ssl/certs but its IO::Socket:SSL
somehow fails to use it as SSL_ca_path without being told. Using
/etc/ssl/certs directory as SSL_ca_path by default like the current
code does would have been hiding such a broken installation without
its user needing to do anything. These users can still work around
such a platform bug by setting the configuration variable explicitly
to point at /etc/ssl/certs.
This change should not negate what 35035bbf (send-email: be explicit
with SSL certificate verification, 2013-07-18), which was the
original change that introduced the defaulting to /etc/ssl/certs/,
attempted to do, which is to make sure we do not communicate over
insecure connection by default, triggering warning from the library.
Cf. https://bugzilla.redhat.com/show_bug.cgi?id=1043194
Tested-by: Igor Gnatenko <i.gnatenko.brain@gmail.com>
Signed-off-by: Ruben Kerkhof <ruben@rubenkerkhof.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-01-15 17:31:11 +00:00
|
|
|
# use the OpenSSL defaults
|
|
|
|
return (SSL_verify_mode => SSL_VERIFY_PEER());
|
2013-07-18 16:53:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ($smtp_ssl_cert_path eq "") {
|
|
|
|
return (SSL_verify_mode => SSL_VERIFY_NONE());
|
|
|
|
} elsif (-d $smtp_ssl_cert_path) {
|
|
|
|
return (SSL_verify_mode => SSL_VERIFY_PEER(),
|
|
|
|
SSL_ca_path => $smtp_ssl_cert_path);
|
|
|
|
} elsif (-f $smtp_ssl_cert_path) {
|
|
|
|
return (SSL_verify_mode => SSL_VERIFY_PEER(),
|
|
|
|
SSL_ca_file => $smtp_ssl_cert_path);
|
|
|
|
} else {
|
|
|
|
print STDERR "Not using SSL_VERIFY_PEER because the CA path does not exist.\n";
|
|
|
|
return (SSL_verify_mode => SSL_VERIFY_NONE());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-16 08:08:18 +00:00
|
|
|
sub file_name_is_absolute {
|
|
|
|
my ($path) = @_;
|
|
|
|
|
|
|
|
# msys does not grok DOS drive-prefixes
|
|
|
|
if ($^O eq 'msys') {
|
2014-04-23 16:37:38 +00:00
|
|
|
return ($path =~ m#^/# || $path =~ m#^[a-zA-Z]\:#)
|
2014-04-16 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
require File::Spec::Functions;
|
|
|
|
return File::Spec::Functions::file_name_is_absolute($path);
|
|
|
|
}
|
|
|
|
|
2009-04-13 18:23:51 +00:00
|
|
|
# Returns 1 if the message was sent, and 0 otherwise.
|
2009-06-12 10:51:42 +00:00
|
|
|
# In actuality, the whole program dies when there
|
2009-04-13 18:23:51 +00:00
|
|
|
# is an error sending a message.
|
|
|
|
|
2010-04-10 14:53:53 +00:00
|
|
|
sub send_message {
|
2006-03-26 01:20:48 +00:00
|
|
|
my @recipients = unique_email_list(@to);
|
2012-11-22 18:12:10 +00:00
|
|
|
@cc = (grep { my $cc = extract_valid_address_or_die($_);
|
2010-11-20 23:06:05 +00:00
|
|
|
not grep { $cc eq $_ || $_ =~ /<\Q${cc}\E>$/ } @recipients
|
2007-11-19 11:00:26 +00:00
|
|
|
}
|
|
|
|
@cc);
|
2006-03-26 01:20:48 +00:00
|
|
|
my $to = join (",\n\t", @recipients);
|
2006-05-29 19:30:13 +00:00
|
|
|
@recipients = unique_email_list(@recipients,@cc,@bcclist);
|
2012-11-22 18:12:10 +00:00
|
|
|
@recipients = (map { extract_valid_address_or_die($_) } @recipients);
|
2006-07-07 18:57:55 +00:00
|
|
|
my $date = format_2822_time($time++);
|
2006-05-02 21:44:36 +00:00
|
|
|
my $gitversion = '@@GIT_VERSION@@';
|
|
|
|
if ($gitversion =~ m/..GIT_VERSION../) {
|
2006-07-03 20:47:58 +00:00
|
|
|
$gitversion = Git::version();
|
2006-05-02 21:44:36 +00:00
|
|
|
}
|
2006-03-26 01:20:48 +00:00
|
|
|
|
2009-10-08 17:03:26 +00:00
|
|
|
my $cc = join(",\n\t", unique_email_list(@cc));
|
2007-04-16 23:51:47 +00:00
|
|
|
my $ccline = "";
|
|
|
|
if ($cc ne '') {
|
|
|
|
$ccline = "\nCc: $cc";
|
|
|
|
}
|
2007-12-17 20:51:34 +00:00
|
|
|
make_message_id() unless defined($message_id);
|
2007-06-20 20:47:34 +00:00
|
|
|
|
2013-06-05 18:11:00 +00:00
|
|
|
my $header = "From: $sender
|
2007-04-16 23:51:47 +00:00
|
|
|
To: $to${ccline}
|
2006-03-26 01:20:48 +00:00
|
|
|
Subject: $subject
|
|
|
|
Date: $date
|
|
|
|
Message-Id: $message_id
|
|
|
|
";
|
2014-03-24 21:38:27 +00:00
|
|
|
if ($use_xmailer) {
|
|
|
|
$header .= "X-Mailer: git-send-email $gitversion\n";
|
|
|
|
}
|
2009-03-01 22:45:41 +00:00
|
|
|
if ($reply_to) {
|
2006-05-29 19:30:12 +00:00
|
|
|
|
|
|
|
$header .= "In-Reply-To: $reply_to\n";
|
|
|
|
$header .= "References: $references\n";
|
|
|
|
}
|
2006-10-05 23:36:49 +00:00
|
|
|
if (@xh) {
|
|
|
|
$header .= join("\n", @xh) . "\n";
|
|
|
|
}
|
2006-03-26 01:20:48 +00:00
|
|
|
|
2007-04-26 02:37:20 +00:00
|
|
|
my @sendmail_parameters = ('-i', @recipients);
|
2013-06-05 18:11:00 +00:00
|
|
|
my $raw_from = $sender;
|
2009-11-26 19:04:29 +00:00
|
|
|
if (defined $envelope_sender && $envelope_sender ne "auto") {
|
|
|
|
$raw_from = $envelope_sender;
|
|
|
|
}
|
2007-04-26 02:37:22 +00:00
|
|
|
$raw_from = extract_valid_address($raw_from);
|
|
|
|
unshift (@sendmail_parameters,
|
|
|
|
'-f', $raw_from) if(defined $envelope_sender);
|
2007-04-26 02:37:17 +00:00
|
|
|
|
2009-03-03 04:52:18 +00:00
|
|
|
if ($needs_confirm && !$dry_run) {
|
|
|
|
print "\n$header\n";
|
|
|
|
if ($needs_confirm eq "inform") {
|
|
|
|
$confirm_unconfigured = 0; # squelch this message for the rest of this run
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
$ask_default = "y"; # assume yes on EOF since user hasn't explicitly asked for confirmation
|
2009-03-03 04:52:18 +00:00
|
|
|
print " The Cc list above has been expanded by additional\n";
|
|
|
|
print " addresses found in the patch commit message. By default\n";
|
|
|
|
print " send-email prompts before sending whenever this occurs.\n";
|
|
|
|
print " This behavior is controlled by the sendemail.confirm\n";
|
|
|
|
print " configuration setting.\n";
|
|
|
|
print "\n";
|
|
|
|
print " For additional information, run 'git send-email --help'.\n";
|
|
|
|
print " To retain the current behavior, but squelch this message,\n";
|
|
|
|
print " run 'git config --global sendemail.confirm auto'.\n\n";
|
|
|
|
}
|
send-email: refactor and ensure prompting doesn't loop forever
Several places in send-email prompt for input, and will do so forever
when the input is EOF. This is poor behavior when send-email is run
unattended (say from cron).
This patch refactors the prompting to an ask() function which takes a
prompt, an optional default, and an optional regex to validate the
input. The function returns on EOF, or if a default is provided and the
user simply types return, or if the input passes the validating regex
(which accepts all input by default). The ask() function gives up after
10 tries in case of invalid input.
There are four callers of the function:
1) "Who should the emails appear to be from?" which provides a default
sender. Previously the user would have to type ctrl-d to accept the
default. Now the user can just hit return, or type ctrl-d.
2) "Who should the emails be sent to?". Previously this prompt passed a
second argument ("") to $term->readline() which was ignored. I believe
the intent was to allow the user to just hit return. Now the user
can do so, or type ctrl-d.
3) "Message-ID to be used as In-Reply-To for the first email?".
Previously this prompt passed a second argument (effectively undef) to
$term->readline() which was ignored. I believe the intent was the same
as for (2), to allow the user to just hit return. Now the user can do
so, or type ctrl-d.
4) "Send this email?". Previously this prompt would loop forever until
it got a valid reply. Now it stops prompting on EOF or a valid reply. In
the case where confirm = "inform", it now defaults to "y" on EOF or the
user hitting return, otherwise an invalid reply causes send-email to
terminate.
A followup patch adds tests for the new functionality.
Signed-off-by: Jay Soffian <jaysoffian@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-29 01:39:10 +00:00
|
|
|
$_ = ask("Send this email? ([y]es|[n]o|[q]uit|[a]ll): ",
|
|
|
|
valid_re => qr/^(?:yes|y|no|n|quit|q|all|a)/i,
|
|
|
|
default => $ask_default);
|
|
|
|
die "Send this email reply required" unless defined $_;
|
2009-03-03 04:52:18 +00:00
|
|
|
if (/^n/i) {
|
2009-04-13 18:23:51 +00:00
|
|
|
return 0;
|
2009-03-03 04:52:18 +00:00
|
|
|
} elsif (/^q/i) {
|
|
|
|
cleanup_compose_files();
|
|
|
|
exit(0);
|
|
|
|
} elsif (/^a/i) {
|
|
|
|
$confirm = 'never';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-06 18:12:11 +00:00
|
|
|
unshift (@sendmail_parameters, @smtp_server_options);
|
|
|
|
|
2006-10-10 14:58:23 +00:00
|
|
|
if ($dry_run) {
|
|
|
|
# We don't want to send the email.
|
2014-04-16 08:08:18 +00:00
|
|
|
} elsif (file_name_is_absolute($smtp_server)) {
|
2006-05-15 09:34:44 +00:00
|
|
|
my $pid = open my $sm, '|-';
|
|
|
|
defined $pid or die $!;
|
|
|
|
if (!$pid) {
|
2007-04-26 02:37:17 +00:00
|
|
|
exec($smtp_server, @sendmail_parameters) or die $!;
|
2006-05-15 09:34:44 +00:00
|
|
|
}
|
|
|
|
print $sm "$header\n$message";
|
2010-09-30 13:43:07 +00:00
|
|
|
close $sm or die $!;
|
2006-05-15 09:34:44 +00:00
|
|
|
} else {
|
2007-09-26 00:27:54 +00:00
|
|
|
|
|
|
|
if (!defined $smtp_server) {
|
|
|
|
die "The required SMTP server is not properly defined."
|
|
|
|
}
|
|
|
|
|
2008-06-25 19:42:43 +00:00
|
|
|
if ($smtp_encryption eq 'ssl') {
|
2007-09-26 00:27:54 +00:00
|
|
|
$smtp_server_port ||= 465; # ssmtp
|
2007-09-02 18:06:25 +00:00
|
|
|
require Net::SMTP::SSL;
|
2010-04-10 14:53:56 +00:00
|
|
|
$smtp_domain ||= maildomain();
|
2013-12-01 22:48:43 +00:00
|
|
|
require IO::Socket::SSL;
|
|
|
|
# Net::SMTP::SSL->new() does not forward any SSL options
|
|
|
|
IO::Socket::SSL::set_client_defaults(
|
|
|
|
ssl_verify_params());
|
2010-03-14 15:16:45 +00:00
|
|
|
$smtp ||= Net::SMTP::SSL->new($smtp_server,
|
2010-04-10 14:53:56 +00:00
|
|
|
Hello => $smtp_domain,
|
2013-07-18 16:53:11 +00:00
|
|
|
Port => $smtp_server_port,
|
2013-12-01 22:48:43 +00:00
|
|
|
Debug => $debug_net_smtp);
|
2007-09-02 18:06:25 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
require Net::SMTP;
|
2010-04-10 14:53:56 +00:00
|
|
|
$smtp_domain ||= maildomain();
|
2013-07-04 22:04:52 +00:00
|
|
|
$smtp_server_port ||= 25;
|
|
|
|
$smtp ||= Net::SMTP->new($smtp_server,
|
2010-04-10 14:53:56 +00:00
|
|
|
Hello => $smtp_domain,
|
2013-07-04 22:04:52 +00:00
|
|
|
Debug => $debug_net_smtp,
|
|
|
|
Port => $smtp_server_port);
|
2009-09-25 22:10:21 +00:00
|
|
|
if ($smtp_encryption eq 'tls' && $smtp) {
|
2008-06-25 19:42:43 +00:00
|
|
|
require Net::SMTP::SSL;
|
|
|
|
$smtp->command('STARTTLS');
|
|
|
|
$smtp->response();
|
|
|
|
if ($smtp->code == 220) {
|
2013-07-18 16:53:11 +00:00
|
|
|
$smtp = Net::SMTP::SSL->start_SSL($smtp,
|
|
|
|
ssl_verify_params())
|
2013-09-08 20:54:34 +00:00
|
|
|
or die "STARTTLS failed! ".IO::Socket::SSL::errstr();
|
2008-07-02 22:11:31 +00:00
|
|
|
$smtp_encryption = '';
|
2008-07-09 21:39:40 +00:00
|
|
|
# Send EHLO again to receive fresh
|
|
|
|
# supported commands
|
2011-10-15 08:44:52 +00:00
|
|
|
$smtp->hello($smtp_domain);
|
2008-06-25 19:42:43 +00:00
|
|
|
} else {
|
|
|
|
die "Server does not support STARTTLS! ".$smtp->message;
|
|
|
|
}
|
|
|
|
}
|
2007-09-26 00:27:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!$smtp) {
|
2010-03-14 15:16:09 +00:00
|
|
|
die "Unable to initialize SMTP properly. Check config and use --smtp-debug. ",
|
2010-03-14 15:15:33 +00:00
|
|
|
"VALUES: server=$smtp_server ",
|
|
|
|
"encryption=$smtp_encryption ",
|
2010-04-10 14:53:56 +00:00
|
|
|
"hello=$smtp_domain",
|
2011-04-29 18:23:24 +00:00
|
|
|
defined $smtp_server_port ? " port=$smtp_server_port" : "";
|
2007-09-26 00:27:54 +00:00
|
|
|
}
|
|
|
|
|
2013-02-12 14:02:33 +00:00
|
|
|
smtp_auth_maybe or die $smtp->message;
|
2008-02-04 00:53:56 +00:00
|
|
|
|
2007-04-26 02:37:21 +00:00
|
|
|
$smtp->mail( $raw_from ) or die $smtp->message;
|
2006-05-15 09:34:44 +00:00
|
|
|
$smtp->to( @recipients ) or die $smtp->message;
|
|
|
|
$smtp->data or die $smtp->message;
|
|
|
|
$smtp->datasend("$header\n$message") or die $smtp->message;
|
|
|
|
$smtp->dataend() or die $smtp->message;
|
2009-04-13 18:23:51 +00:00
|
|
|
$smtp->code =~ /250|200/ or die "Failed to send $subject\n".$smtp->message;
|
2006-05-15 09:34:44 +00:00
|
|
|
}
|
2006-02-06 01:13:52 +00:00
|
|
|
if ($quiet) {
|
2007-04-26 02:37:16 +00:00
|
|
|
printf (($dry_run ? "Dry-" : "")."Sent %s\n", $subject);
|
2006-02-06 01:13:52 +00:00
|
|
|
} else {
|
2007-11-19 04:14:55 +00:00
|
|
|
print (($dry_run ? "Dry-" : "")."OK. Log says:\n");
|
2014-04-16 08:08:18 +00:00
|
|
|
if (!file_name_is_absolute($smtp_server)) {
|
2006-05-15 09:34:44 +00:00
|
|
|
print "Server: $smtp_server\n";
|
2007-04-26 02:37:21 +00:00
|
|
|
print "MAIL FROM:<$raw_from>\n";
|
2009-10-08 17:03:26 +00:00
|
|
|
foreach my $entry (@recipients) {
|
|
|
|
print "RCPT TO:<$entry>\n";
|
|
|
|
}
|
2006-05-15 09:34:44 +00:00
|
|
|
} else {
|
2007-04-26 02:37:17 +00:00
|
|
|
print "Sendmail: $smtp_server ".join(' ',@sendmail_parameters)."\n";
|
2006-05-15 09:34:44 +00:00
|
|
|
}
|
2007-11-19 04:14:55 +00:00
|
|
|
print $header, "\n";
|
2006-05-15 09:34:44 +00:00
|
|
|
if ($smtp) {
|
|
|
|
print "Result: ", $smtp->code, ' ',
|
|
|
|
($smtp->message =~ /\n([^\n]+\n)$/s), "\n";
|
|
|
|
} else {
|
|
|
|
print "Result: OK\n";
|
|
|
|
}
|
2006-02-02 16:56:06 +00:00
|
|
|
}
|
2009-04-13 18:23:51 +00:00
|
|
|
|
|
|
|
return 1;
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
$reply_to = $initial_reply_to;
|
2006-05-30 06:53:13 +00:00
|
|
|
$references = $initial_reply_to || '';
|
2005-07-31 08:17:25 +00:00
|
|
|
$subject = $initial_subject;
|
2009-03-03 04:52:18 +00:00
|
|
|
$message_num = 0;
|
2005-07-31 08:17:25 +00:00
|
|
|
|
|
|
|
foreach my $t (@files) {
|
2010-09-30 13:42:56 +00:00
|
|
|
open my $fh, "<", $t or die "can't open file $t";
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2007-08-09 13:27:58 +00:00
|
|
|
my $author = undef;
|
2013-06-18 12:49:26 +00:00
|
|
|
my $sauthor = undef;
|
2007-11-16 10:49:09 +00:00
|
|
|
my $author_encoding;
|
|
|
|
my $has_content_type;
|
|
|
|
my $body_encoding;
|
2014-11-25 14:00:26 +00:00
|
|
|
my $xfer_encoding;
|
|
|
|
my $has_mime_version;
|
2010-10-04 07:05:24 +00:00
|
|
|
@to = ();
|
2009-03-03 04:52:18 +00:00
|
|
|
@cc = ();
|
2006-10-05 23:36:49 +00:00
|
|
|
@xh = ();
|
2006-10-07 10:09:05 +00:00
|
|
|
my $input_format = undef;
|
2009-02-15 04:32:14 +00:00
|
|
|
my @header = ();
|
2005-07-31 08:17:25 +00:00
|
|
|
$message = "";
|
2009-03-03 04:52:18 +00:00
|
|
|
$message_num++;
|
2009-02-15 04:32:14 +00:00
|
|
|
# First unfold multiline header fields
|
2010-09-30 13:42:56 +00:00
|
|
|
while(<$fh>) {
|
2009-02-15 04:32:14 +00:00
|
|
|
last if /^\s*$/;
|
|
|
|
if (/^\s+\S/ and @header) {
|
|
|
|
chomp($header[$#header]);
|
|
|
|
s/^\s+/ /;
|
|
|
|
$header[$#header] .= $_;
|
|
|
|
} else {
|
|
|
|
push(@header, $_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
# Now parse the header
|
|
|
|
foreach(@header) {
|
|
|
|
if (/^From /) {
|
|
|
|
$input_format = 'mbox';
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
chomp;
|
|
|
|
if (!defined $input_format && /^[-A-Za-z]+:\s/) {
|
|
|
|
$input_format = 'mbox';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (defined $input_format && $input_format eq 'mbox') {
|
2013-01-07 01:34:58 +00:00
|
|
|
if (/^Subject:\s+(.*)$/i) {
|
2009-02-15 04:32:14 +00:00
|
|
|
$subject = $1;
|
2006-10-07 10:09:05 +00:00
|
|
|
}
|
2013-01-07 01:34:58 +00:00
|
|
|
elsif (/^From:\s+(.*)$/i) {
|
2009-02-15 04:32:14 +00:00
|
|
|
($author, $author_encoding) = unquote_rfc2047($1);
|
2013-06-18 12:49:26 +00:00
|
|
|
$sauthor = sanitize_address($author);
|
2009-02-15 04:32:14 +00:00
|
|
|
next if $suppress_cc{'author'};
|
2013-06-05 18:11:00 +00:00
|
|
|
next if $suppress_cc{'self'} and $sauthor eq $sender;
|
2009-02-15 04:32:14 +00:00
|
|
|
printf("(mbox) Adding cc: %s from line '%s'\n",
|
|
|
|
$1, $_) unless $quiet;
|
|
|
|
push @cc, $1;
|
2006-10-07 10:09:05 +00:00
|
|
|
}
|
2013-01-07 01:34:58 +00:00
|
|
|
elsif (/^To:\s+(.*)$/i) {
|
2010-09-29 07:26:44 +00:00
|
|
|
foreach my $addr (parse_address_line($1)) {
|
|
|
|
printf("(mbox) Adding to: %s from line '%s'\n",
|
|
|
|
$addr, $_) unless $quiet;
|
2012-11-22 18:12:10 +00:00
|
|
|
push @to, $addr;
|
2010-09-29 07:26:44 +00:00
|
|
|
}
|
|
|
|
}
|
2013-01-07 01:34:58 +00:00
|
|
|
elsif (/^Cc:\s+(.*)$/i) {
|
2009-02-15 04:32:14 +00:00
|
|
|
foreach my $addr (parse_address_line($1)) {
|
2013-06-05 18:11:00 +00:00
|
|
|
my $qaddr = unquote_rfc2047($addr);
|
|
|
|
my $saddr = sanitize_address($qaddr);
|
|
|
|
if ($saddr eq $sender) {
|
2007-12-26 03:56:29 +00:00
|
|
|
next if ($suppress_cc{'self'});
|
|
|
|
} else {
|
|
|
|
next if ($suppress_cc{'cc'});
|
2006-03-24 07:43:52 +00:00
|
|
|
}
|
2005-07-31 08:17:25 +00:00
|
|
|
printf("(mbox) Adding cc: %s from line '%s'\n",
|
2009-02-15 04:32:14 +00:00
|
|
|
$addr, $_) unless $quiet;
|
|
|
|
push @cc, $addr;
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
2009-02-15 04:32:14 +00:00
|
|
|
}
|
|
|
|
elsif (/^Content-type:/i) {
|
|
|
|
$has_content_type = 1;
|
|
|
|
if (/charset="?([^ "]+)/) {
|
|
|
|
$body_encoding = $1;
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
2009-02-15 04:32:14 +00:00
|
|
|
push @xh, $_;
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
2014-11-25 14:00:26 +00:00
|
|
|
elsif (/^MIME-Version/i) {
|
|
|
|
$has_mime_version = 1;
|
|
|
|
push @xh, $_;
|
|
|
|
}
|
2009-02-15 04:32:14 +00:00
|
|
|
elsif (/^Message-Id: (.*)/i) {
|
|
|
|
$message_id = $1;
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
2014-11-25 14:00:26 +00:00
|
|
|
elsif (/^Content-Transfer-Encoding: (.*)/i) {
|
|
|
|
$xfer_encoding = $1 if not defined $xfer_encoding;
|
|
|
|
}
|
2013-01-07 01:34:58 +00:00
|
|
|
elsif (!/^Date:\s/i && /^[-A-Za-z]+:\s+\S/) {
|
2009-02-15 04:32:14 +00:00
|
|
|
push @xh, $_;
|
|
|
|
}
|
|
|
|
|
2005-07-31 08:17:25 +00:00
|
|
|
} else {
|
2009-02-15 04:32:14 +00:00
|
|
|
# In the traditional
|
|
|
|
# "send lots of email" format,
|
|
|
|
# line 1 = cc
|
|
|
|
# line 2 = subject
|
|
|
|
# So let's support that, too.
|
|
|
|
$input_format = 'lots';
|
|
|
|
if (@cc == 0 && !$suppress_cc{'cc'}) {
|
|
|
|
printf("(non-mbox) Adding cc: %s from line '%s'\n",
|
|
|
|
$_, $_) unless $quiet;
|
|
|
|
push @cc, $_;
|
|
|
|
} elsif (!defined $subject) {
|
|
|
|
$subject = $_;
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-02-15 04:32:14 +00:00
|
|
|
# Now parse the message body
|
2010-09-30 13:42:56 +00:00
|
|
|
while(<$fh>) {
|
2009-02-15 04:32:14 +00:00
|
|
|
$message .= $_;
|
|
|
|
if (/^(Signed-off-by|Cc): (.*)$/i) {
|
|
|
|
chomp;
|
2009-02-15 04:32:15 +00:00
|
|
|
my ($what, $c) = ($1, $2);
|
2009-02-15 04:32:14 +00:00
|
|
|
chomp $c;
|
2013-06-05 18:11:00 +00:00
|
|
|
my $sc = sanitize_address($c);
|
|
|
|
if ($sc eq $sender) {
|
2009-02-15 04:32:15 +00:00
|
|
|
next if ($suppress_cc{'self'});
|
|
|
|
} else {
|
|
|
|
next if $suppress_cc{'sob'} and $what =~ /Signed-off-by/i;
|
|
|
|
next if $suppress_cc{'bodycc'} and $what =~ /Cc/i;
|
|
|
|
}
|
2009-02-15 04:32:14 +00:00
|
|
|
push @cc, $c;
|
2009-02-15 04:32:15 +00:00
|
|
|
printf("(body) Adding cc: %s from line '%s'\n",
|
2009-02-15 04:32:14 +00:00
|
|
|
$c, $_) unless $quiet;
|
|
|
|
}
|
|
|
|
}
|
2010-09-30 13:42:56 +00:00
|
|
|
close $fh;
|
2007-08-18 01:51:12 +00:00
|
|
|
|
2010-09-24 17:03:00 +00:00
|
|
|
push @to, recipients_cmd("to-cmd", "to", $to_cmd, $t)
|
|
|
|
if defined $to_cmd;
|
|
|
|
push @cc, recipients_cmd("cc-cmd", "cc", $cc_cmd, $t)
|
|
|
|
if defined $cc_cmd && !$suppress_cc{'cccmd'};
|
2007-08-18 01:51:12 +00:00
|
|
|
|
2010-06-17 20:10:39 +00:00
|
|
|
if ($broken_encoding{$t} && !$has_content_type) {
|
2014-11-25 14:00:26 +00:00
|
|
|
$xfer_encoding = '8bit' if not defined $xfer_encoding;
|
2010-06-17 20:10:39 +00:00
|
|
|
$has_content_type = 1;
|
2014-11-25 14:00:26 +00:00
|
|
|
push @xh, "Content-Type: text/plain; charset=$auto_8bit_encoding";
|
2010-06-17 20:10:39 +00:00
|
|
|
$body_encoding = $auto_8bit_encoding;
|
|
|
|
}
|
|
|
|
|
2012-10-24 21:08:26 +00:00
|
|
|
if ($broken_encoding{$t} && !is_rfc2047_quoted($subject)) {
|
|
|
|
$subject = quote_subject($subject, $auto_8bit_encoding);
|
2010-06-17 20:10:39 +00:00
|
|
|
}
|
|
|
|
|
2013-06-18 12:49:26 +00:00
|
|
|
if (defined $sauthor and $sauthor ne $sender) {
|
2007-08-09 13:27:58 +00:00
|
|
|
$message = "From: $author\n\n$message";
|
2007-11-16 10:49:09 +00:00
|
|
|
if (defined $author_encoding) {
|
|
|
|
if ($has_content_type) {
|
|
|
|
if ($body_encoding eq $author_encoding) {
|
|
|
|
# ok, we already have the right encoding
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
# uh oh, we should re-encode
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2014-11-25 14:00:26 +00:00
|
|
|
$xfer_encoding = '8bit' if not defined $xfer_encoding;
|
2010-06-17 20:10:39 +00:00
|
|
|
$has_content_type = 1;
|
2007-11-16 10:49:09 +00:00
|
|
|
push @xh,
|
2014-11-25 14:00:26 +00:00
|
|
|
"Content-Type: text/plain; charset=$author_encoding";
|
2007-11-16 10:49:09 +00:00
|
|
|
}
|
|
|
|
}
|
2006-03-24 07:43:52 +00:00
|
|
|
}
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 14:00:27 +00:00
|
|
|
if (defined $target_xfer_encoding) {
|
|
|
|
$xfer_encoding = '8bit' if not defined $xfer_encoding;
|
|
|
|
$message = apply_transfer_encoding(
|
|
|
|
$message, $xfer_encoding, $target_xfer_encoding);
|
|
|
|
$xfer_encoding = $target_xfer_encoding;
|
|
|
|
}
|
2014-11-25 14:00:26 +00:00
|
|
|
if (defined $xfer_encoding) {
|
|
|
|
push @xh, "Content-Transfer-Encoding: $xfer_encoding";
|
|
|
|
}
|
|
|
|
if (defined $xfer_encoding or $has_content_type) {
|
|
|
|
unshift @xh, 'MIME-Version: 1.0' unless $has_mime_version;
|
|
|
|
}
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2009-03-03 04:52:18 +00:00
|
|
|
$needs_confirm = (
|
|
|
|
$confirm eq "always" or
|
|
|
|
($confirm =~ /^(?:auto|cc)$/ && @cc) or
|
|
|
|
($confirm =~ /^(?:auto|compose)$/ && $compose && $message_num == 1));
|
|
|
|
$needs_confirm = "inform" if ($needs_confirm && $confirm_unconfigured && @cc);
|
|
|
|
|
2015-06-30 12:16:45 +00:00
|
|
|
@to = process_address_list(@to);
|
|
|
|
@cc = process_address_list(@cc);
|
2012-11-22 18:12:10 +00:00
|
|
|
|
2010-10-04 07:05:24 +00:00
|
|
|
@to = (@initial_to, @to);
|
2009-03-03 04:52:18 +00:00
|
|
|
@cc = (@initial_cc, @cc);
|
|
|
|
|
2014-04-29 05:41:16 +00:00
|
|
|
if ($message_num == 1) {
|
|
|
|
if (defined $cover_cc and $cover_cc) {
|
|
|
|
@initial_cc = @cc;
|
|
|
|
}
|
|
|
|
if (defined $cover_to and $cover_to) {
|
|
|
|
@initial_to = @to;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-13 18:23:51 +00:00
|
|
|
my $message_was_sent = send_message();
|
2005-07-31 08:17:25 +00:00
|
|
|
|
|
|
|
# set up for the next message
|
2009-06-12 16:23:43 +00:00
|
|
|
if ($thread && $message_was_sent &&
|
2013-05-25 03:44:52 +00:00
|
|
|
($chain_reply_to || !defined $reply_to || length($reply_to) == 0 ||
|
2010-11-12 14:55:08 +00:00
|
|
|
$message_num == 1)) {
|
2005-08-01 00:04:24 +00:00
|
|
|
$reply_to = $message_id;
|
2006-05-29 19:30:12 +00:00
|
|
|
if (length $references > 0) {
|
2007-04-05 23:50:24 +00:00
|
|
|
$references .= "\n $message_id";
|
2006-05-29 19:30:12 +00:00
|
|
|
} else {
|
|
|
|
$references = "$message_id";
|
|
|
|
}
|
2005-08-01 00:04:24 +00:00
|
|
|
}
|
2007-12-17 20:51:34 +00:00
|
|
|
$message_id = undef;
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
2005-08-03 01:45:22 +00:00
|
|
|
|
2010-09-24 17:03:00 +00:00
|
|
|
# Execute a command (e.g. $to_cmd) to get a list of email addresses
|
|
|
|
# and return a results array
|
|
|
|
sub recipients_cmd {
|
|
|
|
my ($prefix, $what, $cmd, $file) = @_;
|
|
|
|
|
|
|
|
my @addresses = ();
|
send-email: use the three-arg form of open in recipients_cmd
Perlcritic does not want to see the trailing pipe in the two-args
form of open(), i.e.
open my $fh, "$cmd \Q$file\E |";
If $cmd were a single-token command name, it would make a lot more
sense to use four-or-more-args form "open FILEHANDLE,MODE,CMD,ARGS"
to avoid shell from expanding metacharacters in $file, but we do
expect multi-word string in $to_cmd and $cc_cmd to be expanded by
the shell, so we cannot rewrite it to
open my $fh, "-|", $cmd, $file;
for extra safety. At least, by using this in the three-arg form:
open my $fh, "-|", "$cmd \Q$file\E";
we can silence Perlcritic, even though we do not gain much safety by
doing so.
Signed-off-by: Ramkumar Ramachandra <artagnon@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-01 01:40:42 +00:00
|
|
|
open my $fh, "-|", "$cmd \Q$file\E"
|
2010-09-24 17:03:00 +00:00
|
|
|
or die "($prefix) Could not execute '$cmd'";
|
2010-10-27 05:02:52 +00:00
|
|
|
while (my $address = <$fh>) {
|
2010-09-24 17:03:00 +00:00
|
|
|
$address =~ s/^\s*//g;
|
|
|
|
$address =~ s/\s*$//g;
|
|
|
|
$address = sanitize_address($address);
|
2013-06-05 18:11:00 +00:00
|
|
|
next if ($address eq $sender and $suppress_cc{'self'});
|
2010-09-24 17:03:00 +00:00
|
|
|
push @addresses, $address;
|
|
|
|
printf("($prefix) Adding %s: %s from: '%s'\n",
|
|
|
|
$what, $address, $cmd) unless $quiet;
|
|
|
|
}
|
2010-10-27 05:02:52 +00:00
|
|
|
close $fh
|
2010-09-24 17:03:00 +00:00
|
|
|
or die "($prefix) failed to close pipe to '$cmd'";
|
|
|
|
return @addresses;
|
|
|
|
}
|
|
|
|
|
2009-03-03 04:52:18 +00:00
|
|
|
cleanup_compose_files();
|
2005-09-05 05:13:07 +00:00
|
|
|
|
2010-09-30 13:43:00 +00:00
|
|
|
sub cleanup_compose_files {
|
2009-03-03 04:52:18 +00:00
|
|
|
unlink($compose_filename, $compose_filename . ".final") if $compose;
|
2005-09-05 05:13:07 +00:00
|
|
|
}
|
|
|
|
|
2006-03-26 01:20:48 +00:00
|
|
|
$smtp->quit if $smtp;
|
2005-08-03 01:45:22 +00:00
|
|
|
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 14:00:27 +00:00
|
|
|
sub apply_transfer_encoding {
|
|
|
|
my $message = shift;
|
|
|
|
my $from = shift;
|
|
|
|
my $to = shift;
|
|
|
|
|
|
|
|
return $message if ($from eq $to and $from ne '7bit');
|
|
|
|
|
|
|
|
require MIME::QuotedPrint;
|
|
|
|
require MIME::Base64;
|
|
|
|
|
|
|
|
$message = MIME::QuotedPrint::decode($message)
|
|
|
|
if ($from eq 'quoted-printable');
|
|
|
|
$message = MIME::Base64::decode($message)
|
|
|
|
if ($from eq 'base64');
|
|
|
|
|
|
|
|
die "cannot send message as 7bit"
|
|
|
|
if ($to eq '7bit' and $message =~ /[^[:ascii:]]/);
|
|
|
|
return $message
|
|
|
|
if ($to eq '7bit' or $to eq '8bit');
|
|
|
|
return MIME::QuotedPrint::encode($message, "\n", 0)
|
|
|
|
if ($to eq 'quoted-printable');
|
|
|
|
return MIME::Base64::encode($message, "\n")
|
|
|
|
if ($to eq 'base64');
|
|
|
|
die "invalid transfer encoding";
|
|
|
|
}
|
|
|
|
|
2010-09-30 13:42:59 +00:00
|
|
|
sub unique_email_list {
|
2005-08-03 01:45:22 +00:00
|
|
|
my %seen;
|
|
|
|
my @emails;
|
|
|
|
|
|
|
|
foreach my $entry (@_) {
|
2012-11-22 18:12:10 +00:00
|
|
|
my $clean = extract_valid_address_or_die($entry);
|
|
|
|
$seen{$clean} ||= 0;
|
|
|
|
next if $seen{$clean}++;
|
|
|
|
push @emails, $entry;
|
2005-08-03 01:45:22 +00:00
|
|
|
}
|
|
|
|
return @emails;
|
|
|
|
}
|
2008-01-18 14:19:48 +00:00
|
|
|
|
|
|
|
sub validate_patch {
|
|
|
|
my $fn = shift;
|
|
|
|
open(my $fh, '<', $fn)
|
|
|
|
or die "unable to open $fn: $!\n";
|
|
|
|
while (my $line = <$fh>) {
|
|
|
|
if (length($line) > 998) {
|
|
|
|
return "$.: patch contains a line longer than 998 characters";
|
|
|
|
}
|
|
|
|
}
|
2013-04-01 01:40:40 +00:00
|
|
|
return;
|
2008-01-18 14:19:48 +00:00
|
|
|
}
|
2008-03-28 21:28:33 +00:00
|
|
|
|
|
|
|
sub file_has_nonascii {
|
|
|
|
my $fn = shift;
|
|
|
|
open(my $fh, '<', $fn)
|
|
|
|
or die "unable to open $fn: $!\n";
|
|
|
|
while (my $line = <$fh>) {
|
|
|
|
return 1 if $line =~ /[^[:ascii:]]/;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2010-06-17 20:10:39 +00:00
|
|
|
|
|
|
|
sub body_or_subject_has_nonascii {
|
|
|
|
my $fn = shift;
|
|
|
|
open(my $fh, '<', $fn)
|
|
|
|
or die "unable to open $fn: $!\n";
|
|
|
|
while (my $line = <$fh>) {
|
|
|
|
last if $line =~ /^$/;
|
|
|
|
return 1 if $line =~ /^Subject.*[^[:ascii:]]/;
|
|
|
|
}
|
|
|
|
while (my $line = <$fh>) {
|
|
|
|
return 1 if $line =~ /[^[:ascii:]]/;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|