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;
|
2021-05-28 09:23:40 +00:00
|
|
|
use warnings $ENV{GIT_PERL_FATAL_WARNINGS} ? qw(FATAL all) : ();
|
2005-07-31 08:17:25 +00:00
|
|
|
use Getopt::Long;
|
2018-03-03 15:38:13 +00:00
|
|
|
use Git::LoadCPAN::Error qw(:try);
|
2006-07-03 20:47:58 +00:00
|
|
|
use Git;
|
2016-12-14 12:54:35 +00:00
|
|
|
use Git::I18N;
|
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;
|
2021-10-25 21:27:07 +00:00
|
|
|
git send-email' [<options>] <file|directory>
|
|
|
|
git send-email' [<options>] <format-patch options>
|
2015-11-19 22:52:11 +00:00
|
|
|
git send-email --dump-aliases
|
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:"
|
2018-03-03 23:58:14 +00:00
|
|
|
--reply-to <str> * Email "Reply-To:"
|
2008-09-30 12:58:30 +00:00
|
|
|
--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.
|
2021-05-14 15:15:53 +00:00
|
|
|
--sendmail-cmd <str> * Command to run to send email.
|
2008-09-30 12:58:30 +00:00
|
|
|
--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
|
2018-10-23 03:24:25 +00:00
|
|
|
--smtp-auth <str> * Space-separated list of allowed AUTH mechanisms, or
|
|
|
|
"none" to disable authentication.
|
2015-08-11 23:39:44 +00:00
|
|
|
This setting forces to use one of the listed mechanisms.
|
2018-10-23 03:24:25 +00:00
|
|
|
--no-smtp-auth Disable SMTP authentication. Shorthand for
|
|
|
|
`--smtp-auth=none`
|
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
|
|
|
|
2017-05-21 12:59:50 +00:00
|
|
|
--batch-size <int> * send max <int> message per connection.
|
|
|
|
--relogin-delay <int> * delay <int> seconds between two successive login.
|
|
|
|
This option can only be used with --batch-size
|
|
|
|
|
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`
|
2018-10-16 07:39:23 +00:00
|
|
|
--suppress-cc <str> * author, self, sob, cc, cccmd, body, bodycc, misc-by, 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
|
|
|
|
2015-11-19 22:52:11 +00:00
|
|
|
Information:
|
|
|
|
--dump-aliases * Dump configured aliases and exit.
|
|
|
|
|
2007-02-28 04:47:54 +00:00
|
|
|
EOT
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2021-10-25 21:27:06 +00:00
|
|
|
sub uniq {
|
|
|
|
my %seen;
|
|
|
|
grep !$seen{$_}++, @_;
|
|
|
|
}
|
|
|
|
|
2018-11-03 06:03:18 +00:00
|
|
|
sub completion_helper {
|
2021-10-25 21:27:06 +00:00
|
|
|
my ($original_opts) = @_;
|
|
|
|
my %not_for_completion = (
|
|
|
|
"git-completion-helper" => undef,
|
|
|
|
"h" => undef,
|
|
|
|
);
|
|
|
|
my @send_email_opts = ();
|
|
|
|
|
|
|
|
foreach my $key (keys %$original_opts) {
|
|
|
|
unless (exists $not_for_completion{$key}) {
|
|
|
|
$key =~ s/!$//;
|
|
|
|
|
|
|
|
if ($key =~ /[:=][si]$/) {
|
|
|
|
$key =~ s/[:=][si]$//;
|
|
|
|
push (@send_email_opts, "--$_=") foreach (split (/\|/, $key));
|
|
|
|
} else {
|
|
|
|
push (@send_email_opts, "--$_") foreach (split (/\|/, $key));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
my @format_patch_opts = split(/ /, Git::command('format-patch', '--git-completion-helper'));
|
|
|
|
my @opts = (@send_email_opts, @format_patch_opts);
|
|
|
|
@opts = uniq (grep !/^$/, @opts);
|
|
|
|
# There's an implicit '\n' here already, no need to add an explicit one.
|
|
|
|
print "@opts";
|
|
|
|
exit(0);
|
2018-11-03 06:03:18 +00:00
|
|
|
}
|
|
|
|
|
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]) {
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("local zone differs from GMT by a non-minute interval\n");
|
2006-07-07 18:57:55 +00:00
|
|
|
}
|
|
|
|
if ((($gmttm[6] + 1) % 7) == $localtm[6]) {
|
|
|
|
$localmin += 1440;
|
|
|
|
} elsif ((($gmttm[6] - 1) % 7) == $localtm[6]) {
|
|
|
|
$localmin -= 1440;
|
|
|
|
} elsif ($gmttm[6] != $localtm[6]) {
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("local time offset greater than or equal to 24 hours\n");
|
2006-07-07 18:57:55 +00:00
|
|
|
}
|
|
|
|
my $offset = $localmin - $gmtmin;
|
|
|
|
my $offhour = $offset / 60;
|
|
|
|
my $offmin = abs($offset % 60);
|
|
|
|
if (abs($offhour) >= 24) {
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("local time offset greater than or equal to 24 hours\n");
|
2006-07-07 18:57:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
my $smtp;
|
2007-11-21 12:35:05 +00:00
|
|
|
my $auth;
|
2017-05-21 12:59:50 +00:00
|
|
|
my $num_sent = 0;
|
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:
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
my (@to,@cc,@xh,$envelope_sender,
|
2018-03-03 23:58:14 +00:00
|
|
|
$initial_in_reply_to,$reply_to,$initial_subject,@files,
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
$author,$sender,$smtp_authpass,$annotate,$compose,$time);
|
|
|
|
# Things we either get from config, *or* are overridden on the
|
|
|
|
# command-line.
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
my ($no_cc, $no_to, $no_bcc, $no_identity);
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
my (@config_to, @getopt_to);
|
|
|
|
my (@config_cc, @getopt_cc);
|
|
|
|
my (@config_bcc, @getopt_bcc);
|
2005-08-01 00:04:24 +00:00
|
|
|
|
2005-08-01 00:04:24 +00:00
|
|
|
# Example reply to:
|
2018-03-03 23:58:13 +00:00
|
|
|
#$initial_in_reply_to = ''; #<20050203173208.GA23964@foobar.com>';
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2008-03-14 17:29:30 +00:00
|
|
|
my $repo = eval { Git->repository() };
|
|
|
|
my @repo = $repo ? ($repo) : ();
|
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;
|
2015-11-19 22:52:11 +00:00
|
|
|
my $dump_aliases = 0;
|
2007-06-28 03:59:37 +00:00
|
|
|
|
send-email: relay '-v N' to format-patch
send-email relays unrecognized arguments to its format-patch call.
Passing '-v N' leads to an error because -v is consumed as
send-email's --validate. For example,
git send-email -v 3 @{u}
fails with
fatal: ambiguous argument '3': unknown revision or path not in the
working tree. [...]
To prevent this, add the short --reroll-count option to send-email's
main option list and explicitly provide it to the format-patch call.
There other format-patch options that send-email doesn't relay
properly, including at least -n, -N, and the diff option -D. Punt on
these because dealing with them is more complicated:
* they would require configuring send-email to not ignore option case
* send-email makes three GetOptions() calls with different sets of
options, the last being the main set of options. Unlike -v, which
is consumed by the last GetOptions call, the -n, -N, and -D options
are consumed as abbreviations by the earlier calls.
Signed-off-by: Kyle Meyer <kyle@kyleam.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-11-26 20:21:23 +00:00
|
|
|
# Variables to prevent short format-patch options from being captured
|
|
|
|
# as abbreviated send-email options
|
|
|
|
my $reroll_count;
|
|
|
|
|
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
|
|
|
|
2021-04-06 14:00:36 +00:00
|
|
|
sub system_or_msg {
|
2021-12-22 03:59:38 +00:00
|
|
|
my ($args, $msg, $cmd_name) = @_;
|
2021-04-06 14:00:36 +00:00
|
|
|
system(@$args);
|
|
|
|
my $signalled = $? & 127;
|
|
|
|
my $exit_code = $? >> 8;
|
|
|
|
return unless $signalled or $exit_code;
|
|
|
|
|
2021-12-22 03:59:38 +00:00
|
|
|
my @sprintf_args = ($cmd_name ? $cmd_name : $args->[0], $exit_code);
|
2021-05-24 23:14:24 +00:00
|
|
|
if (defined $msg) {
|
|
|
|
# Quiet the 'redundant' warning category, except we
|
|
|
|
# need to support down to Perl 5.8, so we can't do a
|
|
|
|
# "no warnings 'redundant'", since that category was
|
|
|
|
# introduced in perl 5.22, and asking for it will die
|
|
|
|
# on older perls.
|
|
|
|
no warnings;
|
|
|
|
return sprintf($msg, @sprintf_args);
|
|
|
|
}
|
2021-04-06 14:00:37 +00:00
|
|
|
return sprintf(__("fatal: command '%s' died with exit code %d"),
|
2021-05-24 23:14:24 +00:00
|
|
|
@sprintf_args);
|
2021-04-06 14:00:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sub system_or_die {
|
|
|
|
my $msg = system_or_msg(@_);
|
|
|
|
die $msg if $msg;
|
|
|
|
}
|
|
|
|
|
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');
|
|
|
|
}
|
2021-04-06 14:00:36 +00:00
|
|
|
my $die_msg = __("the editor exited uncleanly, aborting everything");
|
2008-11-10 23:54:01 +00:00
|
|
|
if (defined($multiedit) && !$multiedit) {
|
2021-04-06 14:00:36 +00:00
|
|
|
system_or_die(['sh', '-c', $editor.' "$@"', $editor, $_], $die_msg) for @_;
|
2008-11-10 23:54:01 +00:00
|
|
|
} else {
|
2021-04-06 14:00:36 +00:00
|
|
|
system_or_die(['sh', '-c', $editor.' "$@"', $editor, @_], $die_msg);
|
2008-11-10 23:54:01 +00:00
|
|
|
}
|
|
|
|
}
|
2007-06-28 03:59:37 +00:00
|
|
|
|
|
|
|
# Variables with corresponding config settings
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
my ($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);
|
2017-05-21 12:59:50 +00:00
|
|
|
my ($batch_size, $relogin_delay);
|
2015-08-11 23:39:44 +00:00
|
|
|
my ($identity, $aliasfiletype, @alias_files, $smtp_domain, $smtp_auth);
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
my ($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);
|
2021-05-14 15:15:53 +00:00
|
|
|
my ($sendmail_cmd);
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
# Variables with corresponding config settings & hardcoded defaults
|
2010-03-14 15:16:09 +00:00
|
|
|
my ($debug_net_smtp) = 0; # Net::SMTP, see send_message()
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
my $thread = 1;
|
|
|
|
my $chain_reply_to = 0;
|
|
|
|
my $use_xmailer = 1;
|
|
|
|
my $validate = 1;
|
|
|
|
my $target_xfer_encoding = 'auto';
|
2020-07-24 00:44:32 +00:00
|
|
|
my $forbid_sendmail_variables = 1;
|
2010-03-14 15:16:09 +00:00
|
|
|
|
2007-09-02 18:06:25 +00:00
|
|
|
my %config_bool_settings = (
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
"thread" => \$thread,
|
|
|
|
"chainreplyto" => \$chain_reply_to,
|
|
|
|
"suppressfrom" => \$suppress_from,
|
|
|
|
"signedoffbycc" => \$signed_off_by_cc,
|
|
|
|
"cccover" => \$cover_cc,
|
|
|
|
"tocover" => \$cover_to,
|
|
|
|
"signedoffcc" => \$signed_off_by_cc,
|
|
|
|
"validate" => \$validate,
|
|
|
|
"multiedit" => \$multiedit,
|
|
|
|
"annotate" => \$annotate,
|
|
|
|
"xmailer" => \$use_xmailer,
|
2020-07-24 00:44:32 +00:00
|
|
|
"forbidsendmailvariables" => \$forbid_sendmail_variables,
|
2007-06-26 22:48:30 +00:00
|
|
|
);
|
|
|
|
|
2007-09-02 18:06:25 +00:00
|
|
|
my %config_settings = (
|
2021-05-28 09:23:43 +00:00
|
|
|
"smtpencryption" => \$smtp_encryption,
|
2007-09-02 18:06:25 +00:00
|
|
|
"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,
|
2010-09-06 18:12:09 +00:00
|
|
|
"smtpdomain" => \$smtp_domain,
|
2015-08-11 23:39:44 +00:00
|
|
|
"smtpauth" => \$smtp_auth,
|
2017-05-21 12:59:50 +00:00
|
|
|
"smtpbatchsize" => \$batch_size,
|
|
|
|
"smtprelogindelay" => \$relogin_delay,
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
"to" => \@config_to,
|
2010-09-24 17:03:00 +00:00
|
|
|
"tocmd" => \$to_cmd,
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
"cc" => \@config_cc,
|
2007-09-02 18:06:25 +00:00
|
|
|
"cccmd" => \$cc_cmd,
|
|
|
|
"aliasfiletype" => \$aliasfiletype,
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
"bcc" => \@config_bcc,
|
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,
|
2021-05-14 15:15:53 +00:00
|
|
|
"sendmailcmd" => \$sendmail_cmd,
|
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,
|
2015-11-17 22:01:05 +00:00
|
|
|
"smtpsslcertpath" => \$smtp_ssl_cert_path,
|
2011-09-30 10:52:25 +00:00
|
|
|
);
|
|
|
|
|
2008-02-04 00:53:57 +00:00
|
|
|
# Handle Uncouth Termination
|
|
|
|
sub signal_handler {
|
|
|
|
# Make text normal
|
2021-05-28 09:23:49 +00:00
|
|
|
require Term::ANSIColor;
|
|
|
|
print Term::ANSIColor::color("reset"), "\n";
|
2008-02-04 00:53:57 +00:00
|
|
|
|
|
|
|
# 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) {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf __("'%s' contains an intermediate version ".
|
|
|
|
"of the email you were composing.\n"),
|
|
|
|
$compose_filename;
|
2009-02-23 18:51:37 +00:00
|
|
|
}
|
|
|
|
if (-e ($compose_filename . ".final")) {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf __("'%s.final' contains the composed email.\n"),
|
|
|
|
$compose_filename;
|
2009-02-23 18:51:37 +00:00
|
|
|
}
|
2008-02-04 00:53:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
exit;
|
|
|
|
};
|
|
|
|
|
|
|
|
$SIG{TERM} = \&signal_handler;
|
|
|
|
$SIG{INT} = \&signal_handler;
|
|
|
|
|
2019-05-09 11:48:28 +00:00
|
|
|
# Read our sendemail.* config
|
|
|
|
sub read_config {
|
2021-05-28 09:23:45 +00:00
|
|
|
my ($known_keys, $configured, $prefix) = @_;
|
2019-05-09 11:48:28 +00:00
|
|
|
|
|
|
|
foreach my $setting (keys %config_bool_settings) {
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
my $target = $config_bool_settings{$setting};
|
2021-05-28 09:23:45 +00:00
|
|
|
my $key = "$prefix.$setting";
|
|
|
|
next unless exists $known_keys->{$key};
|
2021-05-28 09:23:51 +00:00
|
|
|
my $v = (@{$known_keys->{$key}} == 1 &&
|
|
|
|
(defined $known_keys->{$key}->[0] &&
|
|
|
|
$known_keys->{$key}->[0] =~ /^(?:true|false)$/s))
|
|
|
|
? $known_keys->{$key}->[0] eq 'true'
|
|
|
|
: Git::config_bool(@repo, $key);
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
next unless defined $v;
|
|
|
|
next if $configured->{$setting}++;
|
|
|
|
$$target = $v;
|
2019-05-09 11:48:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
foreach my $setting (keys %config_path_settings) {
|
|
|
|
my $target = $config_path_settings{$setting};
|
2021-05-28 09:23:45 +00:00
|
|
|
my $key = "$prefix.$setting";
|
|
|
|
next unless exists $known_keys->{$key};
|
2019-05-09 11:48:28 +00:00
|
|
|
if (ref($target) eq "ARRAY") {
|
2021-05-28 09:23:45 +00:00
|
|
|
my @values = Git::config_path(@repo, $key);
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
next unless @values;
|
|
|
|
next if $configured->{$setting}++;
|
|
|
|
@$target = @values;
|
2019-05-09 11:48:28 +00:00
|
|
|
}
|
|
|
|
else {
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
my $v = Git::config_path(@repo, "$prefix.$setting");
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
next unless defined $v;
|
|
|
|
next if $configured->{$setting}++;
|
|
|
|
$$target = $v;
|
2019-05-09 11:48:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach my $setting (keys %config_settings) {
|
|
|
|
my $target = $config_settings{$setting};
|
2021-05-28 09:23:45 +00:00
|
|
|
my $key = "$prefix.$setting";
|
|
|
|
next unless exists $known_keys->{$key};
|
2019-05-09 11:48:28 +00:00
|
|
|
if (ref($target) eq "ARRAY") {
|
2021-05-28 09:23:51 +00:00
|
|
|
my @values = @{$known_keys->{$key}};
|
|
|
|
@values = grep { defined } @values;
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
next if $configured->{$setting}++;
|
|
|
|
@$target = @values;
|
2019-05-09 11:48:28 +00:00
|
|
|
}
|
|
|
|
else {
|
send-email: fix a "first config key wins" regression in v2.33.0
Fix a regression in my c95e3a3f0b8 (send-email: move trivial config
handling to Perl, 2021-05-28) where we'd pick the first config key out
of multiple defined ones, instead of using the normal "last key wins"
semantics of "git config --get".
This broke e.g. cases where a .git/config would have a different
sendemail.smtpServer than ~/.gitconfig. We'd pick the ~/.gitconfig
over .git/config, instead of preferring the repository-local
version. The same would go for /etc/gitconfig etc.
The full list of impacted config keys (the %config_settings values
which are references to scalars, not arrays) is:
sendemail.smtpencryption
sendemail.smtpserver
sendemail.smtpserverport
sendemail.smtpuser
sendemail.smtppass
sendemail.smtpdomain
sendemail.smtpauth
sendemail.smtpbatchsize
sendemail.smtprelogindelay
sendemail.tocmd
sendemail.cccmd
sendemail.aliasfiletype
sendemail.envelopesender
sendemail.confirm
sendemail.from
sendemail.assume8bitencoding
sendemail.composeencoding
sendemail.transferencoding
sendemail.sendmailcmd
I.e. having any of these set in say ~/.gitconfig and in-repo
.git/config regressed in v2.33.0 to prefer the --global one over the
--local.
To test this add a test of config priority to one of these config
variables, most don't have tests at all, but there was an existing one
for sendemail.8bitEncoding.
The "git config" (instead of "test_config") is somewhat of an
anti-pattern, but follows established conventions in
t9001-send-email.sh, likewise with any other pattern or idiom in this
test.
The populating of home/.gitconfig and setting of HOME= is copied from
a test in t0017-env-helper.sh added in 1ff750b128e (tests: make
GIT_TEST_GETTEXT_POISON a boolean, 2019-06-21). This test fails
without this bugfix, but now it works.
Reported-by: Eli Schwartz <eschwartz@archlinux.org>
Tested-by: Eli Schwartz <eschwartz@archlinux.org>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-09-06 07:33:29 +00:00
|
|
|
my $v = $known_keys->{$key}->[-1];
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
next unless defined $v;
|
|
|
|
next if $configured->{$setting}++;
|
|
|
|
$$target = $v;
|
2019-05-09 11:48:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-28 09:23:44 +00:00
|
|
|
sub config_regexp {
|
|
|
|
my ($regex) = @_;
|
|
|
|
my @ret;
|
|
|
|
eval {
|
2021-05-28 09:23:51 +00:00
|
|
|
my $ret = Git::command(
|
2021-05-28 09:23:44 +00:00
|
|
|
'config',
|
2021-05-28 09:23:51 +00:00
|
|
|
'--null',
|
2021-05-28 09:23:44 +00:00
|
|
|
'--get-regexp',
|
|
|
|
$regex,
|
|
|
|
);
|
2021-05-28 09:23:51 +00:00
|
|
|
@ret = map {
|
|
|
|
# We must always return ($k, $v) here, since
|
|
|
|
# empty config values will be just "key\0",
|
|
|
|
# not "key\nvalue\0".
|
|
|
|
my ($k, $v) = split /\n/, $_, 2;
|
|
|
|
($k, $v);
|
|
|
|
} split /\0/, $ret;
|
2021-05-28 09:23:44 +00:00
|
|
|
1;
|
|
|
|
} or do {
|
|
|
|
# If we have no keys we're OK, otherwise re-throw
|
|
|
|
die $@ if $@->value != 1;
|
|
|
|
};
|
|
|
|
return @ret;
|
|
|
|
}
|
|
|
|
|
2021-05-28 09:23:45 +00:00
|
|
|
# Save ourselves a lot of work of shelling out to 'git config' (it
|
|
|
|
# parses 'bool' etc.) by only doing so for config keys that exist.
|
|
|
|
my %known_config_keys;
|
|
|
|
{
|
2021-05-28 09:23:51 +00:00
|
|
|
my @kv = config_regexp("^sende?mail[.]");
|
|
|
|
while (my ($k, $v) = splice @kv, 0, 2) {
|
|
|
|
push @{$known_config_keys{$k}} => $v;
|
2019-05-09 11:48:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
# sendemail.identity yields to --identity. We must parse this
|
|
|
|
# special-case first before the rest of the config is read.
|
2021-05-28 09:23:45 +00:00
|
|
|
{
|
|
|
|
my $key = "sendemail.identity";
|
|
|
|
$identity = Git::config(@repo, $key) if exists $known_config_keys{$key};
|
|
|
|
}
|
2021-10-25 21:27:06 +00:00
|
|
|
my %identity_options = (
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
"identity=s" => \$identity,
|
|
|
|
"no-identity" => \$no_identity,
|
|
|
|
);
|
2021-10-25 21:27:06 +00:00
|
|
|
my $rc = GetOptions(%identity_options);
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
usage() unless $rc;
|
|
|
|
undef $identity if $no_identity;
|
|
|
|
|
|
|
|
# Now we know enough to read the config
|
|
|
|
{
|
|
|
|
my %configured;
|
2021-05-28 09:23:45 +00:00
|
|
|
read_config(\%known_config_keys, \%configured, "sendemail.$identity") if defined $identity;
|
|
|
|
read_config(\%known_config_keys, \%configured, "sendemail");
|
send-email: fix regression in sendemail.identity parsing
Fix a regression in my recent 3494dfd3ee ("send-email: do defaults ->
config -> getopt in that order", 2019-05-09). I missed that the
$identity variable needs to be extracted from the command-line before
we do the config reading, as it determines which config variable we
should read first. See [1] for the report.
The sendemail.identity feature was added back in
34cc60ce2b ("send-email: Add support for SSL and SMTP-AUTH",
2007-09-03), there were no tests to assert that it worked properly.
So let's fix both the regression, and add some tests to assert that
this is being parsed properly. While I'm at it I'm adding a
--no-identity option to go with --[to|cc|bcc] variable, since the
semantics are similar. It's like to/cc/bcc except that unlike those we
don't support multiple identities, but we could now easily add it
support for it if anyone cares.
In just fixing the --identity command-line parsing bug I discovered
that a narrow fix to that wouldn't do. In read_config() we had a state
machine that would only set config values if they weren't set already,
and thus by proxy we wouldn't e.g. set "to" based on sendemail.to if
we'd seen sendemail.gmail.to before, with --identity=gmail.
I'd modified some of the relevant code in 3494dfd3ee, but just
reverting to that wouldn't do, since it would bring back the
regression fixed in that commit.
Refactor read_config() do what we actually mean here. We don't want to
set a given sendemail.VAR if a sendemail.$identity.VAR previously set
it. The old code was conflating this desire with the hardcoded
defaults for these variables, and as discussed in 3494dfd3ee that was
never going to work. Instead pass along the state of whether an
identity config set something before, as distinguished from the state
of the default just being false, or the default being a non-bool or
true (e.g. --transferencoding).
I'm still not happy with the test coverage here, e.g. there's nothing
testing sendemail.smtpEncryption, but I only have so much time to fix
this code.
1. https://public-inbox.org/git/5cddeb61.1c69fb81.47ed4.e648@mx.google.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-17 19:55:44 +00:00
|
|
|
}
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
|
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;
|
2018-11-03 06:03:18 +00:00
|
|
|
my $git_completion_helper;
|
2021-10-25 21:27:06 +00:00
|
|
|
my %dump_aliases_options = (
|
|
|
|
"h" => \$help,
|
|
|
|
"dump-aliases" => \$dump_aliases,
|
|
|
|
);
|
|
|
|
$rc = GetOptions(%dump_aliases_options);
|
2015-11-19 22:52:11 +00:00
|
|
|
usage() unless $rc;
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("--dump-aliases incompatible with other options\n")
|
2015-11-19 22:52:11 +00:00
|
|
|
if !$help and $dump_aliases and @ARGV;
|
2021-10-25 21:27:06 +00:00
|
|
|
my %options = (
|
2011-09-03 17:06:13 +00:00
|
|
|
"sender|from=s" => \$sender,
|
2021-10-25 21:27:06 +00:00
|
|
|
"in-reply-to=s" => \$initial_in_reply_to,
|
2018-03-03 23:58:14 +00:00
|
|
|
"reply-to=s" => \$reply_to,
|
2005-07-31 08:17:25 +00:00
|
|
|
"subject=s" => \$initial_subject,
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
"to=s" => \@getopt_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,
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
"cc=s" => \@getopt_cc,
|
2010-03-07 22:46:48 +00:00
|
|
|
"no-cc" => \$no_cc,
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
"bcc=s" => \@getopt_bcc,
|
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},
|
2021-05-14 15:15:53 +00:00
|
|
|
"sendmail-cmd=s" => \$sendmail_cmd,
|
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,
|
2015-08-11 23:39:44 +00:00
|
|
|
"smtp-auth=s" => \$smtp_auth,
|
2018-10-23 03:24:25 +00:00
|
|
|
"no-smtp-auth" => sub {$smtp_auth = 'none'},
|
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},
|
2017-05-21 12:59:50 +00:00
|
|
|
"batch-size=i" => \$batch_size,
|
|
|
|
"relogin-delay=i" => \$relogin_delay,
|
2018-11-03 06:03:18 +00:00
|
|
|
"git-completion-helper" => \$git_completion_helper,
|
send-email: relay '-v N' to format-patch
send-email relays unrecognized arguments to its format-patch call.
Passing '-v N' leads to an error because -v is consumed as
send-email's --validate. For example,
git send-email -v 3 @{u}
fails with
fatal: ambiguous argument '3': unknown revision or path not in the
working tree. [...]
To prevent this, add the short --reroll-count option to send-email's
main option list and explicitly provide it to the format-patch call.
There other format-patch options that send-email doesn't relay
properly, including at least -n, -N, and the diff option -D. Punt on
these because dealing with them is more complicated:
* they would require configuring send-email to not ignore option case
* send-email makes three GetOptions() calls with different sets of
options, the last being the main set of options. Unlike -v, which
is consumed by the last GetOptions call, the -n, -N, and -D options
are consumed as abbreviations by the earlier calls.
Signed-off-by: Kyle Meyer <kyle@kyleam.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-11-26 20:21:23 +00:00
|
|
|
"v=s" => \$reroll_count,
|
2021-10-25 21:27:06 +00:00
|
|
|
);
|
|
|
|
$rc = GetOptions(%options);
|
2005-07-31 08:17:25 +00:00
|
|
|
|
send-email: do defaults -> config -> getopt in that order
Change the git-send-email command-line argument parsing and config
reading code to parse those two in the right order. I.e. first we set
our hardcoded defaults, then we read our config, and finally we read
the command-line, with later sets overriding earlier sets.
This fixes a bug introduced in e67a228cd8 ("send-email:
automatically determine transfer-encoding", 2018-07-08). That change
broke the reading of sendmail.transferencoding because it wasn't
careful to update the code to parse them in the previous "defaults
-> getopt -> config" order.
But as we can see from the history for this file doing it this way was
never what we actually wanted, it's just something we grew organically
as of 5483c71d7a ("git-send-email: make options easier to configure.",
2007-06-27) and have been dealing with the fallout since, e.g. in
463b0ea22b ("send-email: Fix %config_path_settings handling",
2011-10-14).
As can be seen in this change the only place where we actually want to
do something clever is with the to/cc/bcc variables, where setting
them on the command-line (or using --no-{to,cc,bcc}) should clear out
values we grab from the config.
All the rest are things where the command-line should simply override
the config values, and by reading the config first the config code
doesn't need all this "let's not set it, if it was on the command-line"
special-casing, as [1] shows we'd otherwise need to care about the
difference between whether something was a default or present in
config to fix the bug in e67a228cd8.
1. https://public-inbox.org/git/20190508105607.178244-2-gitster@pobox.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-09 11:48:30 +00:00
|
|
|
# Munge any "either config or getopt, not both" variables
|
|
|
|
my @initial_to = @getopt_to ? @getopt_to : ($no_to ? () : @config_to);
|
|
|
|
my @initial_cc = @getopt_cc ? @getopt_cc : ($no_cc ? () : @config_cc);
|
|
|
|
my @initial_bcc = @getopt_bcc ? @getopt_bcc : ($no_bcc ? () : @config_bcc);
|
|
|
|
|
2011-09-03 17:06:13 +00:00
|
|
|
usage() if $help;
|
2021-10-25 21:27:06 +00:00
|
|
|
my %all_options = (%options, %dump_aliases_options, %identity_options);
|
|
|
|
completion_helper(\%all_options) if $git_completion_helper;
|
2007-02-28 04:47:54 +00:00
|
|
|
unless ($rc) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
|
2021-05-28 09:23:45 +00:00
|
|
|
if ($forbid_sendmail_variables && grep { /^sendmail/s } keys %known_config_keys) {
|
2020-07-24 00:44:32 +00:00
|
|
|
die __("fatal: found configuration options for 'sendmail'\n" .
|
|
|
|
"git-send-email is configured with the sendemail.* options - note the 'e'.\n" .
|
|
|
|
"Set sendemail.forbidSendmailVariables to false to disable this check.\n");
|
|
|
|
}
|
|
|
|
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("Cannot run git format-patch from outside a repository\n")
|
2009-02-15 04:32:13 +00:00
|
|
|
if $format_patch and not $repo;
|
|
|
|
|
2018-02-12 19:44:04 +00:00
|
|
|
die __("`batch-size` and `relogin` must be specified together " .
|
|
|
|
"(via command-line or configuration option)\n")
|
|
|
|
if defined $relogin_delay and not defined $batch_size;
|
|
|
|
|
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) {
|
2019-02-16 11:24:41 +00:00
|
|
|
# Please update $__git_send_email_suppresscc_options
|
|
|
|
# in git-completion.bash when you add new options.
|
2016-12-14 12:54:37 +00:00
|
|
|
die sprintf(__("Unknown --suppress-cc field: '%s'\n"), $entry)
|
2018-10-16 07:39:23 +00:00
|
|
|
unless $entry =~ /^(?:all|cccmd|cc|author|self|sob|body|bodycc|misc-by)$/;
|
2007-12-26 03:56:29 +00:00
|
|
|
$suppress_cc{$entry} = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($suppress_cc{'all'}) {
|
2018-10-16 07:39:23 +00:00
|
|
|
foreach my $entry (qw (cccmd cc author self sob body bodycc misc-by)) {
|
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'}) {
|
2018-10-16 07:39:23 +00:00
|
|
|
foreach my $entry (qw (sob bodycc misc-by)) {
|
2009-02-15 04:32:15 +00:00
|
|
|
$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';
|
|
|
|
};
|
2019-02-16 11:24:41 +00:00
|
|
|
# Please update $__git_send_email_confirm_options in
|
|
|
|
# git-completion.bash when you add new options.
|
2016-12-14 12:54:37 +00:00
|
|
|
die sprintf(__("Unknown --confirm setting: '%s'\n"), $confirm)
|
2009-03-03 04:52:18 +00:00
|
|
|
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);
|
2021-05-28 09:23:46 +00:00
|
|
|
{
|
|
|
|
my %cache;
|
|
|
|
my ($author, $committer);
|
|
|
|
my $common = sub {
|
|
|
|
my ($what) = @_;
|
|
|
|
return $cache{$what} if exists $cache{$what};
|
|
|
|
($cache{$what}) = Git::ident_person(@repo, $what);
|
|
|
|
return $cache{$what};
|
|
|
|
};
|
|
|
|
$repoauthor = sub { $common->('author') };
|
|
|
|
$repocommitter = sub { $common->('committer') };
|
|
|
|
}
|
2007-09-02 18:06:25 +00:00
|
|
|
|
2009-02-15 04:32:14 +00:00
|
|
|
sub parse_address_line {
|
2021-05-28 09:23:49 +00:00
|
|
|
require Git::LoadCPAN::Mail::Address;
|
send-email: add and use a local copy of Mail::Address
We used to have two versions of the email parsing code. Our
parse_mailboxes (in Git.pm), and Mail::Address which we used if
installed. Unfortunately, both versions have different sets of bugs, and
changing the behavior of git depending on whether Mail::Address is
installed was a bad idea.
A first attempt to solve this was cc90750 (send-email: don't use
Mail::Address, even if available, 2017-08-23), but it turns out our
parse_mailboxes is too buggy for some uses. For example the lack of
nested comments support breaks get_maintainer.pl in the Linux kernel
tree:
https://public-inbox.org/git/20171116154814.23785-1-alex.bennee@linaro.org/
This patch goes the other way: use Mail::Address anyway, but have a
local copy from CPAN as a fallback, when the system one is not
available.
The duplicated script is small (276 lines of code) and stable in time.
Maintaining the local copy should not be an issue, and will certainly be
less burden than maintaining our own parse_mailboxes.
Another option would be to consider Mail::Address as a hard dependency,
but it's easy enough to save the trouble of extra-dependency to the end
user or packager.
Signed-off-by: Matthieu Moy <git@matthieu-moy.fr>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-01-05 18:36:51 +00:00
|
|
|
return map { $_->format } Mail::Address->parse($_[0]);
|
2009-02-15 04:32:14 +00:00
|
|
|
}
|
|
|
|
|
2008-12-19 08:10:10 +00:00
|
|
|
sub split_addrs {
|
2021-05-28 09:23:49 +00:00
|
|
|
require Text::ParseWords;
|
|
|
|
return Text::ParseWords::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 (/"/) {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf STDERR __("warning: sendmail alias with quotes is not supported: %s\n"), $_;
|
2015-06-01 18:22:36 +00:00
|
|
|
} elsif (/:include:/) {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf STDERR __("warning: `:include:` not supported: %s\n"), $_;
|
2015-06-01 18:22:36 +00:00
|
|
|
} elsif (/[\/|]/) {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf STDERR __("warning: `/file` or `|pipe` redirection not supported: %s\n"), $_;
|
2015-05-31 22:29:27 +00:00
|
|
|
} elsif (/^(\S+?)\s*:\s*(.+)$/) {
|
|
|
|
my ($alias, $addr) = ($1, $2);
|
|
|
|
$aliases{$alias} = [ split_addrs($addr) ];
|
|
|
|
} else {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf STDERR __("warning: sendmail line is not recognized: %s\n"), $_;
|
2015-05-31 22:29:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2016-01-04 20:53:30 +00:00
|
|
|
# commas delimit multiple addresses
|
|
|
|
my @addr = split_addrs($addr);
|
|
|
|
|
|
|
|
# quotes may be escaped in the file,
|
|
|
|
# unescape them so we do not double-escape them later.
|
|
|
|
s/\\"/"/g foreach @addr;
|
|
|
|
$aliases{$alias} = \@addr
|
2006-05-15 02:13:44 +00:00
|
|
|
}}},
|
2021-05-28 09:23:49 +00:00
|
|
|
mailrc => sub { my $fh = shift; while (<$fh>) {
|
2016-03-17 23:58:22 +00:00
|
|
|
if (/^alias\s+(\S+)\s+(.*?)\s*$/) {
|
2021-05-28 09:23:49 +00:00
|
|
|
require Text::ParseWords;
|
2006-05-15 02:13:44 +00:00
|
|
|
# spaces delimit multiple addresses
|
2021-05-28 09:23:49 +00:00
|
|
|
$aliases{$1} = [ Text::ParseWords::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 ];
|
|
|
|
}}}
|
2019-02-16 11:24:41 +00:00
|
|
|
# Please update _git_config() in git-completion.bash when you
|
|
|
|
# add new MUAs.
|
2006-05-15 02:13:44 +00:00
|
|
|
);
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-19 22:52:11 +00:00
|
|
|
if ($dump_aliases) {
|
|
|
|
print "$_\n" for (sort keys %aliases);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
2021-05-28 09:23:47 +00:00
|
|
|
die sprintf(__(<<EOF), $f, $f);
|
2016-12-14 12:54:37 +00:00
|
|
|
File '%s' exists but it could also be the range of commits
|
2008-11-10 23:54:00 +00:00
|
|
|
to produce patches for. Please disambiguate by...
|
|
|
|
|
2016-12-14 12:54:37 +00:00
|
|
|
* Saying "./%s" if you mean a file; or
|
2008-11-10 23:54:00 +00:00
|
|
|
* 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
|
2016-12-14 12:54:37 +00:00
|
|
|
or die sprintf(__("Failed to opendir %s: %s"), $f, $!);
|
2008-01-18 14:19:36 +00:00
|
|
|
|
2021-05-28 09:23:49 +00:00
|
|
|
require File::Spec;
|
|
|
|
push @files, grep { -f $_ } map { File::Spec->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) {
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("Cannot run git format-patch from outside a repository\n")
|
2009-02-15 04:32:13 +00:00
|
|
|
unless $repo;
|
2021-05-28 09:23:49 +00:00
|
|
|
require File::Temp;
|
send-email: relay '-v N' to format-patch
send-email relays unrecognized arguments to its format-patch call.
Passing '-v N' leads to an error because -v is consumed as
send-email's --validate. For example,
git send-email -v 3 @{u}
fails with
fatal: ambiguous argument '3': unknown revision or path not in the
working tree. [...]
To prevent this, add the short --reroll-count option to send-email's
main option list and explicitly provide it to the format-patch call.
There other format-patch options that send-email doesn't relay
properly, including at least -n, -N, and the diff option -D. Punt on
these because dealing with them is more complicated:
* they would require configuring send-email to not ignore option case
* send-email makes three GetOptions() calls with different sets of
options, the last being the main set of options. Unlike -v, which
is consumed by the last GetOptions call, the -n, -N, and -D options
are consumed as abbreviations by the earlier calls.
Signed-off-by: Kyle Meyer <kyle@kyleam.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-11-26 20:21:23 +00:00
|
|
|
push @files, $repo->command('format-patch', '-o', File::Temp::tempdir(CLEANUP => 1),
|
|
|
|
defined $reroll_count ? ('-v', $reroll_count) : (),
|
|
|
|
@rev_list_opts);
|
2008-11-10 23:54:00 +00:00
|
|
|
}
|
|
|
|
|
2016-03-18 05:40:05 +00:00
|
|
|
@files = handle_backup_files(@files);
|
|
|
|
|
2008-09-30 12:58:27 +00:00
|
|
|
if ($validate) {
|
2023-04-14 15:52:49 +00:00
|
|
|
# FIFOs can only be read once, exclude them from validation.
|
|
|
|
my @real_files = ();
|
2008-01-18 14:20:10 +00:00
|
|
|
foreach my $f (@files) {
|
2008-06-25 22:44:40 +00:00
|
|
|
unless (-p $f) {
|
2023-04-14 15:52:49 +00:00
|
|
|
push(@real_files, $f);
|
2008-06-25 22:44:40 +00:00
|
|
|
}
|
2008-01-18 14:20:10 +00:00
|
|
|
}
|
2023-04-14 15:52:49 +00:00
|
|
|
|
|
|
|
# Run the loop once again to avoid gaps in the counter due to FIFO
|
|
|
|
# arguments provided by the user.
|
|
|
|
my $num = 1;
|
|
|
|
my $num_files = scalar @real_files;
|
|
|
|
$ENV{GIT_SENDEMAIL_FILE_TOTAL} = "$num_files";
|
|
|
|
foreach my $r (@real_files) {
|
|
|
|
$ENV{GIT_SENDEMAIL_FILE_COUNTER} = "$num";
|
|
|
|
validate_patch($r, $target_xfer_encoding);
|
|
|
|
$num += 1;
|
|
|
|
}
|
|
|
|
delete $ENV{GIT_SENDEMAIL_FILE_COUNTER};
|
|
|
|
delete $ENV{GIT_SENDEMAIL_FILE_TOTAL};
|
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 {
|
2016-12-14 12:54:36 +00:00
|
|
|
print STDERR __("\nNo patch files specified!\n\n");
|
2008-01-18 14:19:36 +00:00
|
|
|
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;
|
2016-12-14 12:54:37 +00:00
|
|
|
die sprintf(__("No subject line in %s?"), $fn);
|
2008-11-10 23:54:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ($compose) {
|
|
|
|
# Note that this does not need to be secure, but we will make a small
|
|
|
|
# effort to have it be unique
|
2021-05-28 09:23:49 +00:00
|
|
|
require File::Temp;
|
2009-02-23 18:51:37 +00:00
|
|
|
$compose_filename = ($repo ?
|
2021-05-28 09:23:49 +00:00
|
|
|
File::Temp::tempfile(".gitsendemail.msg.XXXXXX", DIR => $repo->repo_path()) :
|
|
|
|
File::Temp::tempfile(".gitsendemail.msg.XXXXXX", DIR => "."))[1];
|
2010-09-30 13:42:55 +00:00
|
|
|
open my $c, ">", $compose_filename
|
2016-12-14 12:54:37 +00:00
|
|
|
or die sprintf(__("Failed to open for writing %s: %s"), $compose_filename, $!);
|
2008-11-10 23:54:02 +00:00
|
|
|
|
|
|
|
|
2021-05-28 09:23:46 +00:00
|
|
|
my $tpl_sender = $sender || $repoauthor->() || $repocommitter->() || '';
|
2008-11-10 23:54:02 +00:00
|
|
|
my $tpl_subject = $initial_subject || '';
|
2018-03-03 23:58:13 +00:00
|
|
|
my $tpl_in_reply_to = $initial_in_reply_to || '';
|
2018-03-03 23:58:14 +00:00
|
|
|
my $tpl_reply_to = $reply_to || '';
|
2008-11-10 23:54:02 +00:00
|
|
|
|
2021-05-28 09:23:47 +00:00
|
|
|
print $c <<EOT1, Git::prefix_lines("GIT: ", __(<<EOT2)), <<EOT3;
|
2008-11-10 23:54:02 +00:00
|
|
|
From $tpl_sender # This line is ignored.
|
2016-12-14 12:54:38 +00:00
|
|
|
EOT1
|
|
|
|
Lines beginning in "GIT:" will be removed.
|
|
|
|
Consider including an overall diffstat or table of contents
|
|
|
|
for the patch you are writing.
|
|
|
|
|
|
|
|
Clear the body content if you don't wish to send a summary.
|
|
|
|
EOT2
|
2008-11-10 23:54:02 +00:00
|
|
|
From: $tpl_sender
|
2018-03-03 23:58:14 +00:00
|
|
|
Reply-To: $tpl_reply_to
|
2008-11-10 23:54:02 +00:00
|
|
|
Subject: $tpl_subject
|
2018-03-03 23:58:13 +00:00
|
|
|
In-Reply-To: $tpl_in_reply_to
|
2008-11-10 23:54:02 +00:00
|
|
|
|
2016-12-14 12:54:38 +00:00
|
|
|
EOT3
|
2008-11-10 23:54:02 +00:00
|
|
|
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 $c, "<", $compose_filename
|
2016-12-14 12:54:37 +00:00
|
|
|
or die sprintf(__("Failed to open %s: %s"), $compose_filename, $!);
|
2008-11-10 23:54:02 +00:00
|
|
|
|
2012-10-22 12:41:48 +00:00
|
|
|
if (!defined $compose_encoding) {
|
|
|
|
$compose_encoding = "UTF-8";
|
|
|
|
}
|
2017-12-15 15:33:39 +00:00
|
|
|
|
|
|
|
my %parsed_email;
|
|
|
|
while (my $line = <$c>) {
|
|
|
|
next if $line =~ m/^GIT:/;
|
|
|
|
parse_header_line($line, \%parsed_email);
|
|
|
|
if ($line =~ /^$/) {
|
|
|
|
$parsed_email{'body'} = filter_body($c);
|
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
|
|
|
|
2017-12-15 15:33:39 +00:00
|
|
|
open my $c2, ">", $compose_filename . ".final"
|
|
|
|
or die sprintf(__("Failed to open %s.final: %s"), $compose_filename, $!);
|
|
|
|
|
|
|
|
|
|
|
|
if ($parsed_email{'From'}) {
|
|
|
|
$sender = delete($parsed_email{'From'});
|
|
|
|
}
|
|
|
|
if ($parsed_email{'In-Reply-To'}) {
|
2018-03-03 23:58:13 +00:00
|
|
|
$initial_in_reply_to = delete($parsed_email{'In-Reply-To'});
|
2017-12-15 15:33:39 +00:00
|
|
|
}
|
2018-03-03 23:58:14 +00:00
|
|
|
if ($parsed_email{'Reply-To'}) {
|
|
|
|
$reply_to = delete($parsed_email{'Reply-To'});
|
2017-12-15 15:33:39 +00:00
|
|
|
}
|
|
|
|
if ($parsed_email{'Subject'}) {
|
|
|
|
$initial_subject = delete($parsed_email{'Subject'});
|
|
|
|
print $c2 "Subject: " .
|
|
|
|
quote_subject($initial_subject, $compose_encoding) .
|
|
|
|
"\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($parsed_email{'MIME-Version'}) {
|
|
|
|
print $c2 "MIME-Version: $parsed_email{'MIME-Version'}\n",
|
|
|
|
"Content-Type: $parsed_email{'Content-Type'};\n",
|
|
|
|
"Content-Transfer-Encoding: $parsed_email{'Content-Transfer-Encoding'}\n";
|
|
|
|
delete($parsed_email{'MIME-Version'});
|
|
|
|
delete($parsed_email{'Content-Type'});
|
|
|
|
delete($parsed_email{'Content-Transfer-Encoding'});
|
|
|
|
} elsif (file_has_nonascii($compose_filename)) {
|
|
|
|
my $content_type = (delete($parsed_email{'Content-Type'}) or
|
|
|
|
"text/plain; charset=$compose_encoding");
|
|
|
|
print $c2 "MIME-Version: 1.0\n",
|
|
|
|
"Content-Type: $content_type\n",
|
|
|
|
"Content-Transfer-Encoding: 8bit\n";
|
|
|
|
}
|
|
|
|
# Preserve unknown headers
|
|
|
|
foreach my $key (keys %parsed_email) {
|
|
|
|
next if $key eq 'body';
|
|
|
|
print $c2 "$key: $parsed_email{$key}";
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($parsed_email{'body'}) {
|
|
|
|
print $c2 "\n$parsed_email{'body'}\n";
|
|
|
|
delete($parsed_email{'body'});
|
|
|
|
} else {
|
2016-12-14 12:54:36 +00:00
|
|
|
print __("Summary email is empty, skipping it\n");
|
2008-11-10 23:54:02 +00:00
|
|
|
$compose = -1;
|
|
|
|
}
|
2017-12-15 15:33:39 +00:00
|
|
|
|
|
|
|
close $c2;
|
|
|
|
|
2008-11-10 23:54:02 +00:00
|
|
|
} elsif ($annotate) {
|
|
|
|
do_edit(@files);
|
|
|
|
}
|
|
|
|
|
2021-05-28 09:23:49 +00:00
|
|
|
sub term {
|
|
|
|
my $term = eval {
|
|
|
|
require Term::ReadLine;
|
|
|
|
$ENV{"GIT_SEND_EMAIL_NOTTY"}
|
|
|
|
? Term::ReadLine->new('git-send-email', \*STDIN, \*STDOUT)
|
|
|
|
: Term::ReadLine->new('git-send-email');
|
|
|
|
};
|
|
|
|
if ($@) {
|
|
|
|
$term = FakeTerm->new("$@: going non-interactive");
|
|
|
|
}
|
|
|
|
return $term;
|
|
|
|
}
|
|
|
|
|
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;
|
2021-05-28 09:23:49 +00:00
|
|
|
my $term = term();
|
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) {
|
2016-12-14 12:54:37 +00:00
|
|
|
my $yesno = $term->readline(
|
|
|
|
# TRANSLATORS: please keep [y/N] as is.
|
|
|
|
sprintf(__("Are you sure you want to use <%s> [y/N]? "), $resp));
|
2012-08-14 22:15:53 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2017-12-15 15:33:39 +00:00
|
|
|
sub parse_header_line {
|
|
|
|
my $lines = shift;
|
|
|
|
my $parsed_line = shift;
|
|
|
|
my $addr_pat = join "|", qw(To Cc Bcc);
|
|
|
|
|
|
|
|
foreach (split(/\n/, $lines)) {
|
|
|
|
if (/^($addr_pat):\s*(.+)$/i) {
|
|
|
|
$parsed_line->{$1} = [ parse_address_line($2) ];
|
|
|
|
} elsif (/^([^:]*):\s*(.+)\s*$/i) {
|
|
|
|
$parsed_line->{$1} = $2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sub filter_body {
|
|
|
|
my $c = shift;
|
|
|
|
my $body = "";
|
|
|
|
while (my $body_line = <$c>) {
|
|
|
|
if ($body_line !~ m/^GIT:/) {
|
|
|
|
$body .= $body_line;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $body;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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) {
|
2016-12-14 12:54:35 +00:00
|
|
|
print __("The following files are 8bit, but do not declare " .
|
|
|
|
"a Content-Transfer-Encoding.\n");
|
2010-06-17 20:10:39 +00:00
|
|
|
foreach my $f (sort keys %broken_encoding) {
|
|
|
|
print " $f\n";
|
|
|
|
}
|
2016-12-14 12:54:35 +00:00
|
|
|
$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/) {
|
2016-12-14 12:54:37 +00:00
|
|
|
die sprintf(__("Refusing to send because the patch\n\t%s\n"
|
2009-06-08 21:34:12 +00:00
|
|
|
. "has the template subject '*** SUBJECT HERE ***'. "
|
2016-12-14 12:54:37 +00:00
|
|
|
. "Pass --force if you really want to send.\n"), $f);
|
2009-06-08 21:34:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 {
|
2021-05-28 09:23:46 +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);
|
|
|
|
|
2016-12-14 12:54:35 +00:00
|
|
|
my $to_whom = __("To whom should the emails be sent (if anyone)?");
|
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) {
|
2016-04-24 19:31:44 +00:00
|
|
|
my $to = ask("$to_whom ",
|
2012-09-06 18:31:11 +00:00
|
|
|
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}) {
|
2016-12-14 12:54:37 +00:00
|
|
|
die sprintf(__("fatal: alias '%s' expands to itself\n"), $alias);
|
2009-07-23 11:09:29 +00:00
|
|
|
}
|
|
|
|
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);
|
2019-05-09 11:48:29 +00:00
|
|
|
@initial_bcc = process_address_list(@initial_bcc);
|
2006-05-15 02:13:44 +00:00
|
|
|
|
2018-03-03 23:58:13 +00:00
|
|
|
if ($thread && !defined $initial_in_reply_to && $prompting) {
|
|
|
|
$initial_in_reply_to = ask(
|
2016-12-14 12:54:35 +00:00
|
|
|
__("Message-ID to be used as In-Reply-To for the first email (if any)? "),
|
2012-09-06 18:31:11 +00:00
|
|
|
default => "",
|
2012-08-14 22:15:53 +00:00
|
|
|
valid_re => qr/\@.*\./, confirm_only => 1);
|
2005-07-31 08:17:25 +00:00
|
|
|
}
|
2018-03-03 23:58:13 +00:00
|
|
|
if (defined $initial_in_reply_to) {
|
|
|
|
$initial_in_reply_to =~ s/^\s*<?//;
|
|
|
|
$initial_in_reply_to =~ s/>?\s*$//;
|
|
|
|
$initial_in_reply_to = "<$initial_in_reply_to>" if $initial_in_reply_to ne '';
|
2007-12-11 05:44:42 +00:00
|
|
|
}
|
2007-12-09 17:17:28 +00:00
|
|
|
|
2018-03-03 23:58:14 +00:00
|
|
|
if (defined $reply_to) {
|
|
|
|
$reply_to =~ s/^\s+|\s+$//g;
|
|
|
|
($reply_to) = expand_aliases($reply_to);
|
|
|
|
$reply_to = sanitize_address($reply_to);
|
2007-12-11 05:44:42 +00:00
|
|
|
}
|
2007-12-09 17:17:28 +00:00
|
|
|
|
2021-05-14 15:15:53 +00:00
|
|
|
if (!defined $sendmail_cmd && !defined $smtp_server) {
|
2017-11-28 00:49:04 +00:00
|
|
|
my @sendmail_paths = qw( /usr/sbin/sendmail /usr/lib/sendmail );
|
|
|
|
push @sendmail_paths, map {"$_/sendmail"} split /:/, $ENV{PATH};
|
|
|
|
foreach (@sendmail_paths) {
|
2006-05-15 09:34:44 +00:00
|
|
|
if (-x $_) {
|
2021-05-14 15:15:53 +00:00
|
|
|
$sendmail_cmd = $_;
|
2006-05-15 09:34:44 +00:00
|
|
|
last;
|
|
|
|
}
|
|
|
|
}
|
2021-05-14 15:15:53 +00:00
|
|
|
|
|
|
|
if (!defined $sendmail_cmd) {
|
|
|
|
$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
|
2018-03-03 23:58:13 +00:00
|
|
|
our ($message_id, %mail, $subject, $in_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/;
|
2021-05-28 09:23:49 +00:00
|
|
|
my $have_email_valid = eval { require Email::Valid; 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);
|
2016-12-14 12:54:37 +00:00
|
|
|
die sprintf(__("error: unable to extract a valid address from: %s\n"), $address)
|
2012-11-22 18:12:10 +00:00
|
|
|
if !$address;
|
|
|
|
return $address;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub validate_address {
|
|
|
|
my $address = shift;
|
2012-11-22 18:12:12 +00:00
|
|
|
while (!extract_valid_address($address)) {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf STDERR __("error: unable to extract a valid address from: %s\n"), $address;
|
2016-12-14 12:54:35 +00:00
|
|
|
# TRANSLATORS: Make sure to include [q] [d] [e] in your
|
|
|
|
# translation. The program will only accept English input
|
|
|
|
# at this point.
|
|
|
|
$_ = ask(__("What to do with this address? ([q]uit|[d]rop|[e]dit): "),
|
2012-11-22 18:12:12 +00:00
|
|
|
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);
|
|
|
|
}
|
2016-04-24 19:31:44 +00:00
|
|
|
$address = ask("$to_whom ",
|
2012-11-22 18:12:12 +00:00
|
|
|
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) {
|
2021-05-28 09:23:49 +00:00
|
|
|
require POSIX;
|
|
|
|
$message_id_stamp = POSIX::strftime("%Y%m%d%H%M%S.$$", gmtime(time));
|
2007-09-18 04:18:20 +00:00
|
|
|
$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;
|
2021-05-28 09:23:46 +00:00
|
|
|
for ($sender, $repocommitter->(), $repoauthor->()) {
|
2007-08-09 13:27:58 +00:00
|
|
|
$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();
|
|
|
|
}
|
2016-04-06 20:07:14 +00:00
|
|
|
my $message_id_template = "<%s-%s>";
|
2007-09-18 04:18:20 +00:00
|
|
|
$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
|
|
|
}
|
|
|
|
|
2017-08-23 10:21:01 +00:00
|
|
|
sub strip_garbage_one_address {
|
|
|
|
my ($addr) = @_;
|
|
|
|
chomp $addr;
|
|
|
|
if ($addr =~ /^(("[^"]*"|[^"<]*)? *<[^>]*>).*/) {
|
|
|
|
# "Foo Bar" <foobar@example.com> [possibly garbage here]
|
|
|
|
# Foo Bar <foobar@example.com> [possibly garbage here]
|
|
|
|
return $1;
|
|
|
|
}
|
|
|
|
if ($addr =~ /^(<[^>]*>).*/) {
|
|
|
|
# <foo@example.com> [possibly garbage here]
|
|
|
|
# if garbage contains other addresses, they are ignored.
|
|
|
|
return $1;
|
|
|
|
}
|
|
|
|
if ($addr =~ /^([^"#,\s]*)/) {
|
|
|
|
# address without quoting: remove anything after the address
|
|
|
|
return $1;
|
|
|
|
}
|
|
|
|
return $addr;
|
|
|
|
}
|
|
|
|
|
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
|
2019-11-05 17:07:23 +00:00
|
|
|
# match, the receiving MTA may deny the connection.
|
2010-03-14 15:16:45 +00:00
|
|
|
#
|
|
|
|
# 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;
|
|
|
|
|
2021-05-28 09:23:49 +00:00
|
|
|
require Net::Domain;
|
git-send-email: unconditionally use Net::{SMTP,Domain}
The Net::SMTP and Net::Domain were both first released with perl
v5.7.3[1], since my d48b284183 ("perl: bump the required Perl version
to 5.8 from 5.6.[21]", 2010-09-24) we've depended on 5.8, so there's
no reason to conditionally require them anymore.
This conditional loading was initially added in
87840620fd ("send-email: only 'require' instead of 'use' Net::SMTP",
2006-06-01) for Net::SMTP and 134550fe21 ("git-send-email.perl - try
to give real name of the calling host to HELO/EHLO", 2010-03-14) for
Net::Domain, both of which predate the hard dependency on 5.8.
Since they're guaranteed to be installed now let's "use" them
instead. The cost of loading them both is trivial given what
git-send-email does (~15ms on my system), and it's better to not defer
any potential loading errors until runtime.
This patch is better viewed with -w, which shows that the only change
in the last two hunks is removing the "if eval" wrapper block.
1. $ parallel 'corelist {}' ::: Net::{SMTP,Domain}
Data for 2015-02-14
Net::SMTP was first released with perl v5.7.3
Data for 2015-02-14
Net::Domain was first released with perl v5.7.3
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-03 15:38:10 +00:00
|
|
|
my $domain = Net::Domain::domainname();
|
|
|
|
$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;
|
|
|
|
|
git-send-email: unconditionally use Net::{SMTP,Domain}
The Net::SMTP and Net::Domain were both first released with perl
v5.7.3[1], since my d48b284183 ("perl: bump the required Perl version
to 5.8 from 5.6.[21]", 2010-09-24) we've depended on 5.8, so there's
no reason to conditionally require them anymore.
This conditional loading was initially added in
87840620fd ("send-email: only 'require' instead of 'use' Net::SMTP",
2006-06-01) for Net::SMTP and 134550fe21 ("git-send-email.perl - try
to give real name of the calling host to HELO/EHLO", 2010-03-14) for
Net::Domain, both of which predate the hard dependency on 5.8.
Since they're guaranteed to be installed now let's "use" them
instead. The cost of loading them both is trivial given what
git-send-email does (~15ms on my system), and it's better to not defer
any potential loading errors until runtime.
This patch is better viewed with -w, which shows that the only change
in the last two hunks is removing the "if eval" wrapper block.
1. $ parallel 'corelist {}' ::: Net::{SMTP,Domain}
Data for 2015-02-14
Net::SMTP was first released with perl v5.7.3
Data for 2015-02-14
Net::Domain was first released with perl v5.7.3
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-03 15:38:10 +00:00
|
|
|
for my $host (qw(mailhost localhost)) {
|
2021-05-28 09:23:49 +00:00
|
|
|
require Net::SMTP;
|
git-send-email: unconditionally use Net::{SMTP,Domain}
The Net::SMTP and Net::Domain were both first released with perl
v5.7.3[1], since my d48b284183 ("perl: bump the required Perl version
to 5.8 from 5.6.[21]", 2010-09-24) we've depended on 5.8, so there's
no reason to conditionally require them anymore.
This conditional loading was initially added in
87840620fd ("send-email: only 'require' instead of 'use' Net::SMTP",
2006-06-01) for Net::SMTP and 134550fe21 ("git-send-email.perl - try
to give real name of the calling host to HELO/EHLO", 2010-03-14) for
Net::Domain, both of which predate the hard dependency on 5.8.
Since they're guaranteed to be installed now let's "use" them
instead. The cost of loading them both is trivial given what
git-send-email does (~15ms on my system), and it's better to not defer
any potential loading errors until runtime.
This patch is better viewed with -w, which shows that the only change
in the last two hunks is removing the "if eval" wrapper block.
1. $ parallel 'corelist {}' ::: Net::{SMTP,Domain}
Data for 2015-02-14
Net::SMTP was first released with perl v5.7.3
Data for 2015-02-14
Net::Domain was first released with perl v5.7.3
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-03 15:38:10 +00:00
|
|
|
my $smtp = Net::SMTP->new($host);
|
|
|
|
if (defined $smtp) {
|
|
|
|
my $domain = $smtp->domain;
|
|
|
|
$smtp->quit;
|
2010-03-14 15:16:45 +00:00
|
|
|
|
git-send-email: unconditionally use Net::{SMTP,Domain}
The Net::SMTP and Net::Domain were both first released with perl
v5.7.3[1], since my d48b284183 ("perl: bump the required Perl version
to 5.8 from 5.6.[21]", 2010-09-24) we've depended on 5.8, so there's
no reason to conditionally require them anymore.
This conditional loading was initially added in
87840620fd ("send-email: only 'require' instead of 'use' Net::SMTP",
2006-06-01) for Net::SMTP and 134550fe21 ("git-send-email.perl - try
to give real name of the calling host to HELO/EHLO", 2010-03-14) for
Net::Domain, both of which predate the hard dependency on 5.8.
Since they're guaranteed to be installed now let's "use" them
instead. The cost of loading them both is trivial given what
git-send-email does (~15ms on my system), and it's better to not defer
any potential loading errors until runtime.
This patch is better viewed with -w, which shows that the only change
in the last two hunks is removing the "if eval" wrapper block.
1. $ parallel 'corelist {}' ::: Net::{SMTP,Domain}
Data for 2015-02-14
Net::SMTP was first released with perl v5.7.3
Data for 2015-02-14
Net::Domain was first released with perl v5.7.3
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-03 15:38:10 +00:00
|
|
|
$maildomain = $domain if valid_fqdn($domain);
|
2010-03-14 15:16:45 +00:00
|
|
|
|
git-send-email: unconditionally use Net::{SMTP,Domain}
The Net::SMTP and Net::Domain were both first released with perl
v5.7.3[1], since my d48b284183 ("perl: bump the required Perl version
to 5.8 from 5.6.[21]", 2010-09-24) we've depended on 5.8, so there's
no reason to conditionally require them anymore.
This conditional loading was initially added in
87840620fd ("send-email: only 'require' instead of 'use' Net::SMTP",
2006-06-01) for Net::SMTP and 134550fe21 ("git-send-email.perl - try
to give real name of the calling host to HELO/EHLO", 2010-03-14) for
Net::Domain, both of which predate the hard dependency on 5.8.
Since they're guaranteed to be installed now let's "use" them
instead. The cost of loading them both is trivial given what
git-send-email does (~15ms on my system), and it's better to not defer
any potential loading errors until runtime.
This patch is better viewed with -w, which shows that the only change
in the last two hunks is removing the "if eval" wrapper block.
1. $ parallel 'corelist {}' ::: Net::{SMTP,Domain}
Data for 2015-02-14
Net::SMTP was first released with perl v5.7.3
Data for 2015-02-14
Net::Domain was first released with perl v5.7.3
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-03 15:38:10 +00:00
|
|
|
last if $maildomain;
|
2010-03-14 15:16:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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 {
|
2018-10-23 03:24:25 +00:00
|
|
|
if (!defined $smtp_authuser || $auth || (defined $smtp_auth && $smtp_auth eq "none")) {
|
2013-02-12 14:02:33 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Workaround AUTH PLAIN/LOGIN interaction defect
|
|
|
|
# with Authen::SASL::Cyrus
|
|
|
|
eval {
|
|
|
|
require Authen::SASL;
|
|
|
|
Authen::SASL->import(qw(Perl));
|
|
|
|
};
|
|
|
|
|
2015-08-11 23:39:44 +00:00
|
|
|
# Check mechanism naming as defined in:
|
|
|
|
# https://tools.ietf.org/html/rfc4422#page-8
|
2015-09-18 22:12:50 +00:00
|
|
|
if ($smtp_auth && $smtp_auth !~ /^(\b[A-Z0-9-_]{1,20}\s*)*$/) {
|
2015-08-11 23:39:44 +00:00
|
|
|
die "invalid smtp auth: '${smtp_auth}'";
|
|
|
|
}
|
|
|
|
|
2013-02-12 14:02:33 +00:00
|
|
|
# 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;
|
2015-08-11 23:39:44 +00:00
|
|
|
|
|
|
|
if ($smtp_auth) {
|
|
|
|
my $sasl = Authen::SASL->new(
|
|
|
|
mechanism => $smtp_auth,
|
|
|
|
callback => {
|
|
|
|
user => $cred->{'username'},
|
|
|
|
pass => $cred->{'password'},
|
|
|
|
authname => $cred->{'username'},
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
|
|
|
return !!$smtp->auth($sasl);
|
|
|
|
}
|
|
|
|
|
2013-02-12 14:02:33 +00:00
|
|
|
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 {
|
2016-12-14 12:54:37 +00:00
|
|
|
die sprintf(__("CA path \"%s\" does not exist"), $smtp_ssl_cert_path);
|
2013-07-18 16:53:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-05-04 13:08:11 +00:00
|
|
|
# Prepares the email, then asks the user what to do.
|
|
|
|
#
|
|
|
|
# If the user chooses to send the email, it's sent and 1 is returned.
|
|
|
|
# If the user chooses not to send the email, 0 is returned.
|
|
|
|
# If the user decides they want to make further edits, -1 is returned and the
|
|
|
|
# caller is expected to call send_message again after the edits are performed.
|
|
|
|
#
|
|
|
|
# If an error occurs sending the email, this just dies.
|
2009-04-13 18:23:51 +00:00
|
|
|
|
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);
|
2019-05-09 11:48:29 +00:00
|
|
|
@recipients = unique_email_list(@recipients,@cc,@initial_bcc);
|
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
|
2022-12-16 01:47:19 +00:00
|
|
|
Message-ID: $message_id
|
2006-03-26 01:20:48 +00:00
|
|
|
";
|
2014-03-24 21:38:27 +00:00
|
|
|
if ($use_xmailer) {
|
|
|
|
$header .= "X-Mailer: git-send-email $gitversion\n";
|
|
|
|
}
|
2018-03-03 23:58:13 +00:00
|
|
|
if ($in_reply_to) {
|
2006-05-29 19:30:12 +00:00
|
|
|
|
2018-03-03 23:58:13 +00:00
|
|
|
$header .= "In-Reply-To: $in_reply_to\n";
|
2006-05-29 19:30:12 +00:00
|
|
|
$header .= "References: $references\n";
|
|
|
|
}
|
2018-03-03 23:58:14 +00:00
|
|
|
if ($reply_to) {
|
|
|
|
$header .= "Reply-To: $reply_to\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
|
2016-12-14 12:54:35 +00:00
|
|
|
print __ <<EOF ;
|
|
|
|
The Cc list above has been expanded by additional
|
|
|
|
addresses found in the patch commit message. By default
|
|
|
|
send-email prompts before sending whenever this occurs.
|
|
|
|
This behavior is controlled by the sendemail.confirm
|
|
|
|
configuration setting.
|
|
|
|
|
|
|
|
For additional information, run 'git send-email --help'.
|
|
|
|
To retain the current behavior, but squelch this message,
|
|
|
|
run 'git config --global sendemail.confirm auto'.
|
|
|
|
|
|
|
|
EOF
|
2009-03-03 04:52:18 +00:00
|
|
|
}
|
2018-05-04 13:08:11 +00:00
|
|
|
# TRANSLATORS: Make sure to include [y] [n] [e] [q] [a] in your
|
2016-12-14 12:54:35 +00:00
|
|
|
# translation. The program will only accept English input
|
|
|
|
# at this point.
|
2018-05-04 13:08:11 +00:00
|
|
|
$_ = ask(__("Send this email? ([y]es|[n]o|[e]dit|[q]uit|[a]ll): "),
|
|
|
|
valid_re => qr/^(?:yes|y|no|n|edit|e|quit|q|all|a)/i,
|
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
|
|
|
default => $ask_default);
|
2016-12-14 12:54:36 +00:00
|
|
|
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;
|
2018-05-04 13:08:11 +00:00
|
|
|
} elsif (/^e/i) {
|
|
|
|
return -1;
|
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.
|
2021-05-14 15:15:53 +00:00
|
|
|
} elsif (defined $sendmail_cmd || 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) {
|
2021-05-14 15:15:53 +00:00
|
|
|
if (defined $sendmail_cmd) {
|
|
|
|
exec ("sh", "-c", "$sendmail_cmd \"\$@\"", "-", @sendmail_parameters)
|
|
|
|
or die $!;
|
|
|
|
} else {
|
|
|
|
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) {
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("The required SMTP server is not properly defined.")
|
2007-09-26 00:27:54 +00:00
|
|
|
}
|
|
|
|
|
2017-03-24 21:37:32 +00:00
|
|
|
require Net::SMTP;
|
2017-06-01 00:17:43 +00:00
|
|
|
my $use_net_smtp_ssl = version->parse($Net::SMTP::VERSION) < version->parse("2.34");
|
2017-03-24 21:37:32 +00:00
|
|
|
$smtp_domain ||= maildomain();
|
|
|
|
|
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
|
2013-12-01 22:48:43 +00:00
|
|
|
require IO::Socket::SSL;
|
2015-12-03 21:47:18 +00:00
|
|
|
|
|
|
|
# Suppress "variable accessed once" warning.
|
|
|
|
{
|
|
|
|
no warnings 'once';
|
|
|
|
$IO::Socket::SSL::DEBUG = 1;
|
|
|
|
}
|
|
|
|
|
2013-12-01 22:48:43 +00:00
|
|
|
# Net::SMTP::SSL->new() does not forward any SSL options
|
|
|
|
IO::Socket::SSL::set_client_defaults(
|
|
|
|
ssl_verify_params());
|
2017-03-24 21:37:32 +00:00
|
|
|
|
|
|
|
if ($use_net_smtp_ssl) {
|
|
|
|
require Net::SMTP::SSL;
|
|
|
|
$smtp ||= Net::SMTP::SSL->new($smtp_server,
|
|
|
|
Hello => $smtp_domain,
|
|
|
|
Port => $smtp_server_port,
|
|
|
|
Debug => $debug_net_smtp);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$smtp ||= Net::SMTP->new($smtp_server,
|
|
|
|
Hello => $smtp_domain,
|
|
|
|
Port => $smtp_server_port,
|
|
|
|
Debug => $debug_net_smtp,
|
|
|
|
SSL => 1);
|
|
|
|
}
|
2007-09-02 18:06:25 +00:00
|
|
|
}
|
2018-07-14 08:58:48 +00:00
|
|
|
elsif (!$smtp) {
|
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) {
|
2017-03-24 21:37:32 +00:00
|
|
|
if ($use_net_smtp_ssl) {
|
|
|
|
$smtp->command('STARTTLS');
|
|
|
|
$smtp->response();
|
|
|
|
if ($smtp->code != 220) {
|
|
|
|
die sprintf(__("Server does not support STARTTLS! %s"), $smtp->message);
|
|
|
|
}
|
|
|
|
require Net::SMTP::SSL;
|
2013-07-18 16:53:11 +00:00
|
|
|
$smtp = Net::SMTP::SSL->start_SSL($smtp,
|
|
|
|
ssl_verify_params())
|
2017-03-24 21:37:32 +00:00
|
|
|
or die sprintf(__("STARTTLS failed! %s"), IO::Socket::SSL::errstr());
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$smtp->starttls(ssl_verify_params())
|
|
|
|
or die sprintf(__("STARTTLS failed! %s"), IO::Socket::SSL::errstr());
|
2008-06-25 19:42:43 +00:00
|
|
|
}
|
2017-03-24 21:37:32 +00:00
|
|
|
# Send EHLO again to receive fresh
|
|
|
|
# supported commands
|
|
|
|
$smtp->hello($smtp_domain);
|
2008-06-25 19:42:43 +00:00
|
|
|
}
|
2007-09-26 00:27:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!$smtp) {
|
2016-12-14 12:54:37 +00:00
|
|
|
die __("Unable to initialize SMTP properly. Check config and use --smtp-debug."),
|
|
|
|
" VALUES: server=$smtp_server ",
|
2010-03-14 15:15:33 +00:00
|
|
|
"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;
|
2015-09-30 07:26:09 +00:00
|
|
|
$smtp->datasend("$header\n") or die $smtp->message;
|
|
|
|
my @lines = split /^/, $message;
|
|
|
|
foreach my $line (@lines) {
|
|
|
|
$smtp->datasend("$line") or die $smtp->message;
|
|
|
|
}
|
2006-05-15 09:34:44 +00:00
|
|
|
$smtp->dataend() or die $smtp->message;
|
2016-12-14 12:54:37 +00:00
|
|
|
$smtp->code =~ /250|200/ or die sprintf(__("Failed to send %s\n"), $subject).$smtp->message;
|
2006-05-15 09:34:44 +00:00
|
|
|
}
|
2006-02-06 01:13:52 +00:00
|
|
|
if ($quiet) {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf($dry_run ? __("Dry-Sent %s\n") : __("Sent %s\n"), $subject);
|
2006-02-06 01:13:52 +00:00
|
|
|
} else {
|
2016-12-14 12:54:35 +00:00
|
|
|
print($dry_run ? __("Dry-OK. Log says:\n") : __("OK. Log says:\n"));
|
2021-05-14 15:15:53 +00:00
|
|
|
if (!defined $sendmail_cmd && !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 {
|
2021-05-14 15:15:53 +00:00
|
|
|
my $sm;
|
|
|
|
if (defined $sendmail_cmd) {
|
|
|
|
$sm = $sendmail_cmd;
|
|
|
|
} else {
|
|
|
|
$sm = $smtp_server;
|
|
|
|
}
|
|
|
|
|
|
|
|
print "Sendmail: $sm ".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) {
|
2016-12-14 12:54:36 +00:00
|
|
|
print __("Result: "), $smtp->code, ' ',
|
2006-05-15 09:34:44 +00:00
|
|
|
($smtp->message =~ /\n([^\n]+\n)$/s), "\n";
|
|
|
|
} else {
|
2016-12-14 12:54:36 +00:00
|
|
|
print __("Result: OK\n");
|
2006-05-15 09:34:44 +00:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2018-03-03 23:58:13 +00:00
|
|
|
$in_reply_to = $initial_in_reply_to;
|
|
|
|
$references = $initial_in_reply_to || '';
|
2009-03-03 04:52:18 +00:00
|
|
|
$message_num = 0;
|
2005-07-31 08:17:25 +00:00
|
|
|
|
2018-05-04 13:08:11 +00:00
|
|
|
# Prepares the email, prompts the user, sends it out
|
|
|
|
# Returns 0 if an edit was done and the function should be called again, or 1
|
|
|
|
# otherwise.
|
|
|
|
sub process_file {
|
|
|
|
my ($t) = @_;
|
|
|
|
|
2016-12-14 12:54:37 +00:00
|
|
|
open my $fh, "<", $t or die sprintf(__("can't open file %s"), $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 = ();
|
2021-08-30 15:30:01 +00:00
|
|
|
$subject = $initial_subject;
|
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;
|
2016-12-14 12:54:35 +00:00
|
|
|
printf(__("(mbox) Adding cc: %s from line '%s'\n"),
|
2009-02-15 04:32:14 +00:00
|
|
|
$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)) {
|
2016-12-14 12:54:35 +00:00
|
|
|
printf(__("(mbox) Adding to: %s from line '%s'\n"),
|
2010-09-29 07:26:44 +00:00
|
|
|
$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
|
|
|
}
|
2016-12-14 12:54:35 +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, $_;
|
|
|
|
}
|
2022-12-16 01:47:19 +00:00
|
|
|
elsif (/^Message-ID: (.*)/i) {
|
2009-02-15 04:32:14 +00:00
|
|
|
$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;
|
|
|
|
}
|
2018-04-17 21:16:30 +00:00
|
|
|
elsif (/^In-Reply-To: (.*)/i) {
|
2020-06-29 14:11:04 +00:00
|
|
|
if (!$initial_in_reply_to || $thread) {
|
|
|
|
$in_reply_to = $1;
|
|
|
|
}
|
2018-04-17 21:16:30 +00:00
|
|
|
}
|
|
|
|
elsif (/^References: (.*)/i) {
|
2020-06-29 14:11:04 +00:00
|
|
|
if (!$initial_in_reply_to || $thread) {
|
|
|
|
$references = $1;
|
|
|
|
}
|
2018-04-17 21:16:30 +00:00
|
|
|
}
|
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'}) {
|
2016-12-14 12:54:35 +00:00
|
|
|
printf(__("(non-mbox) Adding cc: %s from line '%s'\n"),
|
2009-02-15 04:32:14 +00:00
|
|
|
$_, $_) 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 .= $_;
|
2019-03-16 19:26:50 +00:00
|
|
|
if (/^([a-z][a-z-]*-by|Cc): (.*)/i) {
|
2009-02-15 04:32:14 +00:00
|
|
|
chomp;
|
2009-02-15 04:32:15 +00:00
|
|
|
my ($what, $c) = ($1, $2);
|
2017-08-23 10:21:01 +00:00
|
|
|
# strip garbage for the address we'll use:
|
|
|
|
$c = strip_garbage_one_address($c);
|
|
|
|
# sanitize a bit more to decide whether to suppress the address:
|
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 {
|
2018-10-16 07:39:23 +00:00
|
|
|
if ($what =~ /^Signed-off-by$/i) {
|
|
|
|
next if $suppress_cc{'sob'};
|
|
|
|
} elsif ($what =~ /-by$/i) {
|
|
|
|
next if $suppress_cc{'misc-by'};
|
|
|
|
} elsif ($what =~ /Cc/i) {
|
|
|
|
next if $suppress_cc{'bodycc'};
|
|
|
|
}
|
2009-02-15 04:32:15 +00:00
|
|
|
}
|
send-email: only consider lines containing @ or <> for automatic Cc'ing
While the address sanitizations routines do accept local addresses, that
is almost never what is meant in a Cc or Signed-off-by trailer.
Looking through all the signed-off-by lines in the linux kernel tree
without a @, there are mostly two patterns: Either just a full name, or
a full name followed by <user at domain.com> (i.e., with the word at
instead of a @), and minor variations. For cc lines, the same patterns
appear, along with lots of "cc stable" variations that do not actually
name stable@vger.kernel.org
Cc: stable # introduced pre-git times
cc: stable.kernel.org
In the <user at domain.com> cases, one gets a chance to interactively
fix it. But when there is no <> pair, it seems we end up just using the
first word as a (local) address.
As the number of cases where a local address really was meant is
likely (and anecdotally) quite small compared to the number of cases
where we end up cc'ing a garbage address, insist on at least a @ or a <>
pair being present.
This is also preparation for the next patch, where we are likely to
encounter even more non-addresses in -by lines, such as
Reported-by: Coverity
Patch-generated-by: Coccinelle
Signed-off-by: Rasmus Villemoes <rv@rasmusvillemoes.dk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-10 11:13:50 +00:00
|
|
|
if ($c !~ /.+@.+|<.+>/) {
|
|
|
|
printf("(body) Ignoring %s from line '%s'\n",
|
|
|
|
$what, $_) unless $quiet;
|
|
|
|
next;
|
|
|
|
}
|
2009-02-15 04:32:14 +00:00
|
|
|
push @cc, $c;
|
2016-12-14 12:54:35 +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
|
|
|
}
|
send-email: automatically determine transfer-encoding
git send-email, when invoked without a --transfer-encoding option, sends
8bit data without a MIME version or a transfer encoding. This has
several downsides.
First, unless the transfer encoding is specified, it defaults to 7bit,
meaning that non-ASCII data isn't allowed. Second, if lines longer than
998 bytes are used, we will send an message that is invalid according to
RFC 5322. The --validate option, which is the default, catches this
issue, but it isn't clear to many people how to resolve this.
To solve these issues, default the transfer encoding to "auto", so that
we explicitly specify 8bit encoding when lines don't exceed 998 bytes
and quoted-printable otherwise. This means that we now always emit
Content-Transfer-Encoding and MIME-Version headers, so remove the
conditionals from this portion of the code.
It is unlikely that the unconditional inclusion of these two headers
will affect the deliverability of messages in anything but a positive
way, since MIME is already widespread and well understood by most email
programs.
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-08 22:17:12 +00:00
|
|
|
$xfer_encoding = '8bit' if not defined $xfer_encoding;
|
|
|
|
($message, $xfer_encoding) = apply_transfer_encoding(
|
|
|
|
$message, $xfer_encoding, $target_xfer_encoding);
|
|
|
|
push @xh, "Content-Transfer-Encoding: $xfer_encoding";
|
|
|
|
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();
|
2018-05-04 13:08:11 +00:00
|
|
|
if ($message_was_sent == -1) {
|
|
|
|
do_edit($t);
|
|
|
|
return 0;
|
|
|
|
}
|
2005-07-31 08:17:25 +00:00
|
|
|
|
|
|
|
# set up for the next message
|
2021-08-30 15:30:01 +00:00
|
|
|
if ($thread) {
|
|
|
|
if ($message_was_sent &&
|
|
|
|
($chain_reply_to || !defined $in_reply_to || length($in_reply_to) == 0 ||
|
|
|
|
$message_num == 1)) {
|
|
|
|
$in_reply_to = $message_id;
|
|
|
|
if (length $references > 0) {
|
|
|
|
$references .= "\n $message_id";
|
|
|
|
} else {
|
|
|
|
$references = "$message_id";
|
|
|
|
}
|
2006-05-29 19:30:12 +00:00
|
|
|
}
|
2021-08-30 15:30:01 +00:00
|
|
|
} elsif (!defined $initial_in_reply_to) {
|
|
|
|
# --thread and --in-reply-to manage the "In-Reply-To" header and by
|
|
|
|
# extension the "References" header. If these commands are not used, reset
|
|
|
|
# the header values to their defaults.
|
|
|
|
$in_reply_to = undef;
|
|
|
|
$references = '';
|
2005-08-01 00:04:24 +00:00
|
|
|
}
|
2007-12-17 20:51:34 +00:00
|
|
|
$message_id = undef;
|
2017-05-21 12:59:50 +00:00
|
|
|
$num_sent++;
|
|
|
|
if (defined $batch_size && $num_sent == $batch_size) {
|
|
|
|
$num_sent = 0;
|
|
|
|
$smtp->quit if defined $smtp;
|
|
|
|
undef $smtp;
|
|
|
|
undef $auth;
|
|
|
|
sleep($relogin_delay) if defined $relogin_delay;
|
|
|
|
}
|
2018-05-04 13:08:11 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach my $t (@files) {
|
|
|
|
while (!process_file($t)) {
|
|
|
|
# user edited the file
|
|
|
|
}
|
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"
|
2016-12-14 12:54:37 +00:00
|
|
|
or die sprintf(__("(%s) Could not execute '%s'"), $prefix, $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;
|
2016-12-14 12:54:37 +00:00
|
|
|
printf(__("(%s) Adding %s: %s from: '%s'\n"),
|
|
|
|
$prefix, $what, $address, $cmd) unless $quiet;
|
2010-09-24 17:03:00 +00:00
|
|
|
}
|
2010-10-27 05:02:52 +00:00
|
|
|
close $fh
|
2016-12-14 12:54:37 +00:00
|
|
|
or die sprintf(__("(%s) failed to close pipe to '%s'"), $prefix, $cmd);
|
2010-09-24 17:03:00 +00:00
|
|
|
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;
|
|
|
|
|
2018-11-02 09:52:38 +00:00
|
|
|
return ($message, $to) if ($from eq $to and $from ne '7bit');
|
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
|
|
|
|
|
|
|
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');
|
|
|
|
|
2019-04-13 22:45:51 +00:00
|
|
|
$to = ($message =~ /(?:.{999,}|\r)/) ? 'quoted-printable' : '8bit'
|
2018-07-08 22:17:10 +00:00
|
|
|
if $to eq 'auto';
|
|
|
|
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("cannot send message as 7bit")
|
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 ($to eq '7bit' and $message =~ /[^[:ascii:]]/);
|
2018-07-08 22:17:10 +00:00
|
|
|
return ($message, $to)
|
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 ($to eq '7bit' or $to eq '8bit');
|
2018-07-08 22:17:10 +00:00
|
|
|
return (MIME::QuotedPrint::encode($message, "\n", 0), $to)
|
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 ($to eq 'quoted-printable');
|
2018-07-08 22:17:10 +00:00
|
|
|
return (MIME::Base64::encode($message, "\n"), $to)
|
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 ($to eq 'base64');
|
2016-12-14 12:54:36 +00:00
|
|
|
die __("invalid transfer 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
|
|
|
}
|
|
|
|
|
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 {
|
2018-07-08 22:17:11 +00:00
|
|
|
my ($fn, $xfer_encoding) = @_;
|
2017-05-12 22:38:26 +00:00
|
|
|
|
2017-06-01 23:50:55 +00:00
|
|
|
if ($repo) {
|
2021-12-22 03:59:38 +00:00
|
|
|
my $hook_name = 'sendemail-validate';
|
2021-05-26 11:21:07 +00:00
|
|
|
my $hooks_path = $repo->command_oneline('rev-parse', '--git-path', 'hooks');
|
2021-05-28 09:23:49 +00:00
|
|
|
require File::Spec;
|
2021-12-22 03:59:38 +00:00
|
|
|
my $validate_hook = File::Spec->catfile($hooks_path, $hook_name);
|
2017-06-01 23:50:55 +00:00
|
|
|
my $hook_error;
|
|
|
|
if (-x $validate_hook) {
|
2021-05-28 09:23:49 +00:00
|
|
|
require Cwd;
|
|
|
|
my $target = Cwd::abs_path($fn);
|
2017-06-01 23:50:55 +00:00
|
|
|
# The hook needs a correct cwd and GIT_DIR.
|
2021-05-28 09:23:52 +00:00
|
|
|
my $cwd_save = Cwd::getcwd();
|
2017-06-01 23:50:55 +00:00
|
|
|
chdir($repo->wc_path() or $repo->repo_path())
|
|
|
|
or die("chdir: $!");
|
|
|
|
local $ENV{"GIT_DIR"} = $repo->repo_path();
|
2021-12-22 03:59:38 +00:00
|
|
|
my @cmd = ("git", "hook", "run", "--ignore-missing",
|
|
|
|
$hook_name, "--");
|
|
|
|
my @cmd_msg = (@cmd, "<patch>");
|
|
|
|
my @cmd_run = (@cmd, $target);
|
|
|
|
$hook_error = system_or_msg(\@cmd_run, undef, "@cmd_msg");
|
2017-06-01 23:50:55 +00:00
|
|
|
chdir($cwd_save) or die("chdir: $!");
|
|
|
|
}
|
2021-04-06 14:00:36 +00:00
|
|
|
if ($hook_error) {
|
2022-04-11 19:23:30 +00:00
|
|
|
$hook_error = sprintf(
|
|
|
|
__("fatal: %s: rejected by %s hook\n%s\nwarning: no patches were sent\n"),
|
|
|
|
$fn, $hook_name, $hook_error);
|
2021-12-22 03:59:38 +00:00
|
|
|
die $hook_error;
|
2021-04-06 14:00:36 +00:00
|
|
|
}
|
2017-06-01 23:50:55 +00:00
|
|
|
}
|
2017-05-12 22:38:26 +00:00
|
|
|
|
2018-07-08 22:17:11 +00:00
|
|
|
# Any long lines will be automatically fixed if we use a suitable transfer
|
|
|
|
# encoding.
|
|
|
|
unless ($xfer_encoding =~ /^(?:auto|quoted-printable|base64)$/) {
|
|
|
|
open(my $fh, '<', $fn)
|
|
|
|
or die sprintf(__("unable to open %s: %s\n"), $fn, $!);
|
|
|
|
while (my $line = <$fh>) {
|
|
|
|
if (length($line) > 998) {
|
2021-04-06 14:00:37 +00:00
|
|
|
die sprintf(__("fatal: %s:%d is longer than 998 characters\n" .
|
|
|
|
"warning: no patches were sent\n"), $fn, $.);
|
2018-07-08 22:17:11 +00:00
|
|
|
}
|
2008-01-18 14:19:48 +00:00
|
|
|
}
|
|
|
|
}
|
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
|
|
|
|
2016-03-18 05:40:05 +00:00
|
|
|
sub handle_backup {
|
|
|
|
my ($last, $lastlen, $file, $known_suffix) = @_;
|
|
|
|
my ($suffix, $skip);
|
|
|
|
|
|
|
|
$skip = 0;
|
|
|
|
if (defined $last &&
|
|
|
|
($lastlen < length($file)) &&
|
|
|
|
(substr($file, 0, $lastlen) eq $last) &&
|
|
|
|
($suffix = substr($file, $lastlen)) !~ /^[a-z0-9]/i) {
|
|
|
|
if (defined $known_suffix && $suffix eq $known_suffix) {
|
2016-12-14 12:54:37 +00:00
|
|
|
printf(__("Skipping %s with backup suffix '%s'.\n"), $file, $known_suffix);
|
2016-03-18 05:40:05 +00:00
|
|
|
$skip = 1;
|
|
|
|
} else {
|
2016-12-14 12:54:37 +00:00
|
|
|
# TRANSLATORS: please keep "[y|N]" as is.
|
|
|
|
my $answer = ask(sprintf(__("Do you really want to send %s? [y|N]: "), $file),
|
2016-03-18 05:40:05 +00:00
|
|
|
valid_re => qr/^(?:y|n)/i,
|
|
|
|
default => 'n');
|
|
|
|
$skip = ($answer ne 'y');
|
|
|
|
if ($skip) {
|
|
|
|
$known_suffix = $suffix;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ($skip, $known_suffix);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub handle_backup_files {
|
|
|
|
my @file = @_;
|
|
|
|
my ($last, $lastlen, $known_suffix, $skip, @result);
|
|
|
|
for my $file (@file) {
|
|
|
|
($skip, $known_suffix) = handle_backup($last, $lastlen,
|
|
|
|
$file, $known_suffix);
|
|
|
|
push @result, $file unless $skip;
|
|
|
|
$last = $file;
|
|
|
|
$lastlen = length($file);
|
|
|
|
}
|
|
|
|
return @result;
|
|
|
|
}
|
|
|
|
|
2008-03-28 21:28:33 +00:00
|
|
|
sub file_has_nonascii {
|
|
|
|
my $fn = shift;
|
|
|
|
open(my $fh, '<', $fn)
|
2016-12-14 12:54:37 +00:00
|
|
|
or die sprintf(__("unable to open %s: %s\n"), $fn, $!);
|
2008-03-28 21:28:33 +00:00
|
|
|
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)
|
2016-12-14 12:54:37 +00:00
|
|
|
or die sprintf(__("unable to open %s: %s\n"), $fn, $!);
|
2010-06-17 20:10:39 +00:00
|
|
|
while (my $line = <$fh>) {
|
|
|
|
last if $line =~ /^$/;
|
|
|
|
return 1 if $line =~ /^Subject.*[^[:ascii:]]/;
|
|
|
|
}
|
|
|
|
while (my $line = <$fh>) {
|
|
|
|
return 1 if $line =~ /[^[:ascii:]]/;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|