2005-07-12 18:49:27 +00:00
|
|
|
/*
|
|
|
|
* ident.c
|
|
|
|
*
|
|
|
|
* create git identifier lines of the form "name <email> date"
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005 Linus Torvalds
|
|
|
|
*/
|
2023-02-24 00:09:29 +00:00
|
|
|
#include "git-compat-util.h"
|
|
|
|
#include "ident.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
date API: create a date.h, split from cache.h
Move the declaration of the date.c functions from cache.h, and adjust
the relevant users to include the new date.h header.
The show_ident_date() function belonged in pretty.h (it's defined in
pretty.c), its two users outside of pretty.c didn't strictly need to
include pretty.h, as they get it indirectly, but let's add it to them
anyway.
Similarly, the change to "builtin/{fast-import,show-branch,tag}.c"
isn't needed as far as the compiler is concerned, but since they all
use the "DATE_MODE()" macro we now define in date.h, let's have them
include it.
We could simply include this new header in "cache.h", but as this
change shows these functions weren't common enough to warrant
including in it in the first place. By moving them out of cache.h
changes to this API will no longer cause a (mostly) full re-build of
the project when "make" is run.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-02-16 08:14:02 +00:00
|
|
|
#include "date.h"
|
2023-02-24 00:09:29 +00:00
|
|
|
#include "gettext.h"
|
2022-07-18 19:51:00 +00:00
|
|
|
#include "mailmap.h"
|
2023-02-24 00:09:29 +00:00
|
|
|
#include "strbuf.h"
|
2005-07-12 18:49:27 +00:00
|
|
|
|
2012-05-21 23:10:17 +00:00
|
|
|
static struct strbuf git_default_name = STRBUF_INIT;
|
|
|
|
static struct strbuf git_default_email = STRBUF_INIT;
|
2014-08-27 07:57:08 +00:00
|
|
|
static struct strbuf git_default_date = STRBUF_INIT;
|
2019-02-04 18:48:50 +00:00
|
|
|
static struct strbuf git_author_name = STRBUF_INIT;
|
|
|
|
static struct strbuf git_author_email = STRBUF_INIT;
|
|
|
|
static struct strbuf git_committer_name = STRBUF_INIT;
|
|
|
|
static struct strbuf git_committer_email = STRBUF_INIT;
|
2015-12-10 21:35:36 +00:00
|
|
|
static int default_email_is_bogus;
|
ident: loosen getpwuid error in non-strict mode
If the user has not specified an identity and we have to
turn to getpwuid() to find the username or gecos field, we
die immediately when getpwuid fails (e.g., because the user
does not exist). This is OK for making a commit, where we
have set IDENT_STRICT and would want to bail on bogus input.
But for something like a reflog, where the ident is "best
effort", it can be pain. For instance, even running "git
clone" with a UID that is not in /etc/passwd will result in
git barfing, just because we can't find an ident to put in
the reflog.
Instead of dying in xgetpwuid_self, we can instead return a
fallback value, and set a "bogus" flag. For the username in
an email, we already have a "default_email_is_bogus" flag.
For the name field, we introduce (and check) a matching
"default_name_is_bogus" flag. As a bonus, this means you now
get the usual "tell me who you are" advice instead of just a
"no such user" error.
No tests, as this is dependent on configuration outside of
git's control. However, I did confirm that it behaves
sensibly when I delete myself from the local /etc/passwd
(reflogs get written, and commits complain).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-10 21:41:29 +00:00
|
|
|
static int default_name_is_bogus;
|
2012-11-15 00:34:05 +00:00
|
|
|
|
2016-02-06 06:23:36 +00:00
|
|
|
static int ident_use_config_only;
|
|
|
|
|
2012-11-15 00:34:05 +00:00
|
|
|
#define IDENT_NAME_GIVEN 01
|
|
|
|
#define IDENT_MAIL_GIVEN 02
|
|
|
|
#define IDENT_ALL_GIVEN (IDENT_NAME_GIVEN|IDENT_MAIL_GIVEN)
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
static int committer_ident_explicitly_given;
|
|
|
|
static int author_ident_explicitly_given;
|
2016-02-06 06:23:36 +00:00
|
|
|
static int ident_config_given;
|
2005-07-12 18:49:27 +00:00
|
|
|
|
2011-05-19 11:37:55 +00:00
|
|
|
#ifdef NO_GECOS_IN_PWENT
|
|
|
|
#define get_gecos(ignored) "&"
|
|
|
|
#else
|
|
|
|
#define get_gecos(struct_passwd) ((struct_passwd)->pw_gecos)
|
|
|
|
#endif
|
|
|
|
|
ident: loosen getpwuid error in non-strict mode
If the user has not specified an identity and we have to
turn to getpwuid() to find the username or gecos field, we
die immediately when getpwuid fails (e.g., because the user
does not exist). This is OK for making a commit, where we
have set IDENT_STRICT and would want to bail on bogus input.
But for something like a reflog, where the ident is "best
effort", it can be pain. For instance, even running "git
clone" with a UID that is not in /etc/passwd will result in
git barfing, just because we can't find an ident to put in
the reflog.
Instead of dying in xgetpwuid_self, we can instead return a
fallback value, and set a "bogus" flag. For the username in
an email, we already have a "default_email_is_bogus" flag.
For the name field, we introduce (and check) a matching
"default_name_is_bogus" flag. As a bonus, this means you now
get the usual "tell me who you are" advice instead of just a
"no such user" error.
No tests, as this is dependent on configuration outside of
git's control. However, I did confirm that it behaves
sensibly when I delete myself from the local /etc/passwd
(reflogs get written, and commits complain).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-10 21:41:29 +00:00
|
|
|
static struct passwd *xgetpwuid_self(int *is_bogus)
|
2015-12-10 21:33:05 +00:00
|
|
|
{
|
|
|
|
struct passwd *pw;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
pw = getpwuid(getuid());
|
ident: loosen getpwuid error in non-strict mode
If the user has not specified an identity and we have to
turn to getpwuid() to find the username or gecos field, we
die immediately when getpwuid fails (e.g., because the user
does not exist). This is OK for making a commit, where we
have set IDENT_STRICT and would want to bail on bogus input.
But for something like a reflog, where the ident is "best
effort", it can be pain. For instance, even running "git
clone" with a UID that is not in /etc/passwd will result in
git barfing, just because we can't find an ident to put in
the reflog.
Instead of dying in xgetpwuid_self, we can instead return a
fallback value, and set a "bogus" flag. For the username in
an email, we already have a "default_email_is_bogus" flag.
For the name field, we introduce (and check) a matching
"default_name_is_bogus" flag. As a bonus, this means you now
get the usual "tell me who you are" advice instead of just a
"no such user" error.
No tests, as this is dependent on configuration outside of
git's control. However, I did confirm that it behaves
sensibly when I delete myself from the local /etc/passwd
(reflogs get written, and commits complain).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-10 21:41:29 +00:00
|
|
|
if (!pw) {
|
|
|
|
static struct passwd fallback;
|
|
|
|
fallback.pw_name = "unknown";
|
|
|
|
#ifndef NO_GECOS_IN_PWENT
|
|
|
|
fallback.pw_gecos = "Unknown";
|
|
|
|
#endif
|
|
|
|
pw = &fallback;
|
|
|
|
if (is_bogus)
|
|
|
|
*is_bogus = 1;
|
|
|
|
}
|
2015-12-10 21:33:05 +00:00
|
|
|
return pw;
|
|
|
|
}
|
|
|
|
|
2012-05-21 23:10:17 +00:00
|
|
|
static void copy_gecos(const struct passwd *w, struct strbuf *name)
|
2005-09-19 23:06:56 +00:00
|
|
|
{
|
2012-05-21 23:10:17 +00:00
|
|
|
char *src;
|
2005-09-19 23:06:56 +00:00
|
|
|
|
|
|
|
/* Traditionally GECOS field had office phone numbers etc, separated
|
|
|
|
* with commas. Also & stands for capitalized form of the login name.
|
|
|
|
*/
|
|
|
|
|
2012-05-21 23:10:17 +00:00
|
|
|
for (src = get_gecos(w); *src && *src != ','; src++) {
|
2005-09-19 23:06:56 +00:00
|
|
|
int ch = *src;
|
2012-05-21 23:10:17 +00:00
|
|
|
if (ch != '&')
|
|
|
|
strbuf_addch(name, ch);
|
|
|
|
else {
|
2005-09-19 23:06:56 +00:00
|
|
|
/* Sorry, Mr. McDonald... */
|
2012-05-21 23:10:17 +00:00
|
|
|
strbuf_addch(name, toupper(*w->pw_name));
|
|
|
|
strbuf_addstr(name, w->pw_name + 1);
|
2005-09-19 23:06:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-21 23:10:17 +00:00
|
|
|
static int add_mailname_host(struct strbuf *buf)
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
{
|
|
|
|
FILE *mailname;
|
2013-01-24 23:21:46 +00:00
|
|
|
struct strbuf mailnamebuf = STRBUF_INIT;
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
|
2017-05-03 10:16:50 +00:00
|
|
|
mailname = fopen_or_warn("/etc/mailname", "r");
|
|
|
|
if (!mailname)
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
return -1;
|
2017-05-03 10:16:50 +00:00
|
|
|
|
2015-10-28 20:24:41 +00:00
|
|
|
if (strbuf_getline(&mailnamebuf, mailname) == EOF) {
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
if (ferror(mailname))
|
2016-05-08 09:47:49 +00:00
|
|
|
warning_errno("cannot read /etc/mailname");
|
2013-01-24 23:21:46 +00:00
|
|
|
strbuf_release(&mailnamebuf);
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
fclose(mailname);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* success! */
|
2013-01-24 23:21:46 +00:00
|
|
|
strbuf_addbuf(buf, &mailnamebuf);
|
|
|
|
strbuf_release(&mailnamebuf);
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
fclose(mailname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-27 14:08:27 +00:00
|
|
|
static int canonical_name(const char *host, struct strbuf *out)
|
|
|
|
{
|
|
|
|
int status = -1;
|
|
|
|
|
|
|
|
#ifndef NO_IPV6
|
|
|
|
struct addrinfo hints, *ai;
|
|
|
|
memset (&hints, '\0', sizeof (hints));
|
|
|
|
hints.ai_flags = AI_CANONNAME;
|
|
|
|
if (!getaddrinfo(host, NULL, &hints, &ai)) {
|
ident: handle NULL ai_canonname
We call getaddrinfo() to try to convert a short hostname
into a fully-qualified one (to use it as an email domain).
If there isn't a canonical name, getaddrinfo() will
generally return either a NULL addrinfo list, or one in
which ai->ai_canonname is a copy of the original name.
However, if the result of gethostname() looks like an IP
address, then getaddrinfo() behaves differently on some
systems. On OS X, it will return a "struct addrinfo" with a
NULL ai_canonname, and we segfault feeding it to strchr().
This is hard to test reliably because it involves not only a
system where we we have to fallback to gethostname() to come
up with an ident, but also where the hostname is a number
with no dots. But I was able to replicate the bug by faking
a hostname, like:
diff --git a/ident.c b/ident.c
index e20a772..b790d28 100644
--- a/ident.c
+++ b/ident.c
@@ -128,6 +128,7 @@ static void add_domainname(struct strbuf *out, int *is_bogus)
*is_bogus = 1;
return;
}
+ xsnprintf(buf, sizeof(buf), "1");
if (strchr(buf, '.'))
strbuf_addstr(out, buf);
else if (canonical_name(buf, out) < 0) {
and running "git var GIT_AUTHOR_IDENT" on an OS X system.
Before this patch it segfaults, and after we correctly
complain of the bogus "user@1.(none)" address (though this
bogus address would be suitable for non-object uses like
writing reflogs).
Reported-by: Jonas Thiel <jonas.lierschied@gmx.de>
Diagnosed-by: John Keeping <john@keeping.me.uk>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-23 04:37:53 +00:00
|
|
|
if (ai && ai->ai_canonname && strchr(ai->ai_canonname, '.')) {
|
2015-11-27 14:08:27 +00:00
|
|
|
strbuf_addstr(out, ai->ai_canonname);
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
freeaddrinfo(ai);
|
|
|
|
}
|
|
|
|
#else
|
2015-12-14 20:52:41 +00:00
|
|
|
struct hostent *he = gethostbyname(host);
|
2015-11-27 14:08:27 +00:00
|
|
|
if (he && strchr(he->h_name, '.')) {
|
|
|
|
strbuf_addstr(out, he->h_name);
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
#endif /* NO_IPV6 */
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2015-12-10 21:35:36 +00:00
|
|
|
static void add_domainname(struct strbuf *out, int *is_bogus)
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
{
|
2017-04-18 21:57:42 +00:00
|
|
|
char buf[HOST_NAME_MAX + 1];
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
|
2017-04-18 21:57:43 +00:00
|
|
|
if (xgethostname(buf, sizeof(buf))) {
|
2016-05-08 09:47:49 +00:00
|
|
|
warning_errno("cannot get host name");
|
2012-05-21 23:10:17 +00:00
|
|
|
strbuf_addstr(out, "(none)");
|
2015-12-10 21:35:36 +00:00
|
|
|
*is_bogus = 1;
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
return;
|
|
|
|
}
|
2012-05-21 23:10:17 +00:00
|
|
|
if (strchr(buf, '.'))
|
2012-05-21 23:10:23 +00:00
|
|
|
strbuf_addstr(out, buf);
|
2015-12-21 18:59:07 +00:00
|
|
|
else if (canonical_name(buf, out) < 0) {
|
2012-05-21 23:10:23 +00:00
|
|
|
strbuf_addf(out, "%s.(none)", buf);
|
2015-12-10 21:35:36 +00:00
|
|
|
*is_bogus = 1;
|
|
|
|
}
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
}
|
|
|
|
|
2015-12-10 21:35:36 +00:00
|
|
|
static void copy_email(const struct passwd *pw, struct strbuf *email,
|
|
|
|
int *is_bogus)
|
2005-07-12 18:49:27 +00:00
|
|
|
{
|
2007-01-28 08:50:53 +00:00
|
|
|
/*
|
|
|
|
* Make up a fake email address
|
|
|
|
* (name + '@' + hostname [+ '.' + domainname])
|
|
|
|
*/
|
2012-05-21 23:10:17 +00:00
|
|
|
strbuf_addstr(email, pw->pw_name);
|
|
|
|
strbuf_addch(email, '@');
|
|
|
|
|
|
|
|
if (!add_mailname_host(email))
|
ident: check /etc/mailname if email is unknown
Before falling back to gethostname(), check /etc/mailname if
GIT_AUTHOR_EMAIL is not set in the environment or through config
files. Only fall back if /etc/mailname cannot be opened or read.
The /etc/mailname convention comes from Debian policy section 11.6
("mail transport, delivery and user agents"), though maybe it could be
useful sometimes on other machines, too. The lack of this support was
noticed by various people in different ways:
- Ian observed that git was choosing the address
'ian@anarres.relativity.greenend.org.uk' rather than
'ian@davenant.greenend.org.uk' as it should have done.
- Jonathan noticed that operations like "git commit" were needlessly
slow when using a resolver that was slow to handle reverse DNS
lookups.
Alas, after this patch, if /etc/mailname is set up and the [user] name
and email configuration aren't, the committer email will not provide a
charming reminder of which machine commits were made on any more. But
I think it's worth it.
Mechanics: the functionality of reading mailname goes in its own
function, so people who care about other distros can easily add an
implementation to a similar location without making copy_email() too
long and losing clarity. While at it, we split out the fallback
default logic that does gethostname(), too (rearranging it a little
and adding a check for errors from gethostname while at it).
Based on a patch by Gerrit Pape <pape@smarden.org>.
Requested-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-03 06:16:33 +00:00
|
|
|
return; /* read from "/etc/mailname" (Debian) */
|
2015-12-10 21:35:36 +00:00
|
|
|
add_domainname(email, is_bogus);
|
2007-01-28 08:50:53 +00:00
|
|
|
}
|
|
|
|
|
2014-07-25 19:11:34 +00:00
|
|
|
const char *ident_default_name(void)
|
2007-01-28 08:50:53 +00:00
|
|
|
{
|
2017-02-23 08:17:08 +00:00
|
|
|
if (!(ident_config_given & IDENT_NAME_GIVEN) && !git_default_name.len) {
|
ident: loosen getpwuid error in non-strict mode
If the user has not specified an identity and we have to
turn to getpwuid() to find the username or gecos field, we
die immediately when getpwuid fails (e.g., because the user
does not exist). This is OK for making a commit, where we
have set IDENT_STRICT and would want to bail on bogus input.
But for something like a reflog, where the ident is "best
effort", it can be pain. For instance, even running "git
clone" with a UID that is not in /etc/passwd will result in
git barfing, just because we can't find an ident to put in
the reflog.
Instead of dying in xgetpwuid_self, we can instead return a
fallback value, and set a "bogus" flag. For the username in
an email, we already have a "default_email_is_bogus" flag.
For the name field, we introduce (and check) a matching
"default_name_is_bogus" flag. As a bonus, this means you now
get the usual "tell me who you are" advice instead of just a
"no such user" error.
No tests, as this is dependent on configuration outside of
git's control. However, I did confirm that it behaves
sensibly when I delete myself from the local /etc/passwd
(reflogs get written, and commits complain).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-10 21:41:29 +00:00
|
|
|
copy_gecos(xgetpwuid_self(&default_name_is_bogus), &git_default_name);
|
2012-05-21 23:10:29 +00:00
|
|
|
strbuf_trim(&git_default_name);
|
2007-01-28 08:50:53 +00:00
|
|
|
}
|
2012-05-21 23:10:17 +00:00
|
|
|
return git_default_name.buf;
|
2012-05-21 23:09:43 +00:00
|
|
|
}
|
2007-01-28 08:50:53 +00:00
|
|
|
|
2012-05-21 23:09:43 +00:00
|
|
|
const char *ident_default_email(void)
|
|
|
|
{
|
2017-02-23 08:17:08 +00:00
|
|
|
if (!(ident_config_given & IDENT_MAIL_GIVEN) && !git_default_email.len) {
|
2007-07-06 00:29:41 +00:00
|
|
|
const char *email = getenv("EMAIL");
|
|
|
|
|
2010-01-08 16:01:10 +00:00
|
|
|
if (email && email[0]) {
|
2012-05-21 23:10:17 +00:00
|
|
|
strbuf_addstr(&git_default_email, email);
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
|
|
|
|
author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
|
2018-10-15 09:47:08 +00:00
|
|
|
} else if ((email = query_user_email()) && email[0]) {
|
|
|
|
strbuf_addstr(&git_default_email, email);
|
|
|
|
free((char *)email);
|
2012-05-21 23:10:20 +00:00
|
|
|
} else
|
ident: loosen getpwuid error in non-strict mode
If the user has not specified an identity and we have to
turn to getpwuid() to find the username or gecos field, we
die immediately when getpwuid fails (e.g., because the user
does not exist). This is OK for making a commit, where we
have set IDENT_STRICT and would want to bail on bogus input.
But for something like a reflog, where the ident is "best
effort", it can be pain. For instance, even running "git
clone" with a UID that is not in /etc/passwd will result in
git barfing, just because we can't find an ident to put in
the reflog.
Instead of dying in xgetpwuid_self, we can instead return a
fallback value, and set a "bogus" flag. For the username in
an email, we already have a "default_email_is_bogus" flag.
For the name field, we introduce (and check) a matching
"default_name_is_bogus" flag. As a bonus, this means you now
get the usual "tell me who you are" advice instead of just a
"no such user" error.
No tests, as this is dependent on configuration outside of
git's control. However, I did confirm that it behaves
sensibly when I delete myself from the local /etc/passwd
(reflogs get written, and commits complain).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-10 21:41:29 +00:00
|
|
|
copy_email(xgetpwuid_self(&default_email_is_bogus),
|
|
|
|
&git_default_email, &default_email_is_bogus);
|
2012-05-21 23:10:29 +00:00
|
|
|
strbuf_trim(&git_default_email);
|
2007-01-28 08:50:53 +00:00
|
|
|
}
|
2012-05-21 23:10:17 +00:00
|
|
|
return git_default_email.buf;
|
2005-07-12 18:49:27 +00:00
|
|
|
}
|
|
|
|
|
2012-09-16 05:50:09 +00:00
|
|
|
static const char *ident_default_date(void)
|
2005-07-12 18:49:27 +00:00
|
|
|
{
|
2014-08-27 07:57:08 +00:00
|
|
|
if (!git_default_date.len)
|
|
|
|
datestamp(&git_default_date);
|
|
|
|
return git_default_date.buf;
|
2005-07-12 18:49:27 +00:00
|
|
|
}
|
|
|
|
|
am: reset cached ident date for each patch
When we compute the date to go in author/committer lines of
commits, or tagger lines of tags, we get the current date
once and then cache it for the rest of the program. This is
a good thing in some cases, like "git commit", because it
means we do not racily assign different times to the
author/committer fields of a single commit object.
But as more programs start to make many commits in a single
process (e.g., the recently builtin "git am"), it means that
you'll get long strings of commits with identical committer
timestamps (whereas before, we invoked "git commit" many
times and got true timestamps).
This patch addresses it by letting callers reset the cached
time, which means they'll get a fresh time on their next
call to git_committer_info() or git_author_info(). The first
caller to do so is "git am", which resets the time for each
patch it applies.
It would be nice if we could just do this automatically
before filling in the ident fields of commit and tag
objects. Unfortunately, it's hard to know where a particular
logical operation begins and ends.
For instance, if commit_tree_extended() were to call
reset_ident_date() before getting the committer/author
ident, that doesn't quite work; sometimes the author info is
passed in to us as a parameter, and it may or may not have
come from a previous call to ident_default_date(). So in
those cases, we lose the property that the committer and the
author timestamp always match.
You could similarly put a date-reset at the end of
commit_tree_extended(). That actually works in the current
code base, but it's fragile. It makes the assumption that
after commit_tree_extended() finishes, the caller has no
other operations that would logically want to fall into the
same timestamp.
So instead we provide the tool to easily do the reset, and
let the high-level callers use it to annotate their own
logical operations.
There's no automated test, because it would be inherently
racy (it depends on whether the program takes multiple
seconds to run). But you can see the effect with something
like:
# make a fake 100-patch series
top=$(git rev-parse HEAD)
bottom=$(git rev-list --first-parent -100 HEAD | tail -n 1)
git log --format=email --reverse --first-parent \
--binary -m -p $bottom..$top >patch
# now apply it; this presumably takes multiple seconds
git checkout --detach $bottom
git am <patch
# now count the number of distinct committer times;
# prior to this patch, there would only be one, but
# now we'd typically see several.
git log --format=%ct $bottom.. | sort -u
Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Helped-by: Paul Tan <pyokagan@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-08-01 19:37:00 +00:00
|
|
|
void reset_ident_date(void)
|
|
|
|
{
|
|
|
|
strbuf_reset(&git_default_date);
|
|
|
|
}
|
|
|
|
|
2005-07-12 18:49:27 +00:00
|
|
|
static int crud(unsigned char c)
|
|
|
|
{
|
2007-12-03 19:11:43 +00:00
|
|
|
return c <= 32 ||
|
|
|
|
c == '.' ||
|
|
|
|
c == ',' ||
|
|
|
|
c == ':' ||
|
|
|
|
c == ';' ||
|
|
|
|
c == '<' ||
|
|
|
|
c == '>' ||
|
|
|
|
c == '"' ||
|
2008-12-01 16:41:50 +00:00
|
|
|
c == '\\' ||
|
2007-12-03 19:11:43 +00:00
|
|
|
c == '\'';
|
2005-07-12 18:49:27 +00:00
|
|
|
}
|
|
|
|
|
2017-02-23 08:15:55 +00:00
|
|
|
static int has_non_crud(const char *str)
|
|
|
|
{
|
|
|
|
for (; *str; str++) {
|
|
|
|
if (!crud(*str))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-07-12 18:49:27 +00:00
|
|
|
/*
|
|
|
|
* Copy over a string to the destination, but avoid special
|
|
|
|
* characters ('\n', '<' and '>') and remove crud at the end
|
|
|
|
*/
|
2012-05-21 23:10:26 +00:00
|
|
|
static void strbuf_addstr_without_crud(struct strbuf *sb, const char *src)
|
2005-07-12 18:49:27 +00:00
|
|
|
{
|
2007-04-15 18:51:29 +00:00
|
|
|
size_t i, len;
|
2005-07-12 18:49:27 +00:00
|
|
|
unsigned char c;
|
|
|
|
|
|
|
|
/* Remove crud from the beginning.. */
|
|
|
|
while ((c = *src) != 0) {
|
|
|
|
if (!crud(c))
|
|
|
|
break;
|
|
|
|
src++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove crud from the end.. */
|
|
|
|
len = strlen(src);
|
|
|
|
while (len > 0) {
|
|
|
|
c = src[len-1];
|
|
|
|
if (!crud(c))
|
|
|
|
break;
|
|
|
|
--len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the rest to the buffer, but avoid the special
|
2005-12-29 09:30:08 +00:00
|
|
|
* characters '\n' '<' and '>' that act as delimiters on
|
2012-05-21 23:10:26 +00:00
|
|
|
* an identification line. We can only remove crud, never add it,
|
|
|
|
* so 'len' is our maximum.
|
2005-07-12 18:49:27 +00:00
|
|
|
*/
|
2012-05-21 23:10:26 +00:00
|
|
|
strbuf_grow(sb, len);
|
2005-07-12 18:49:27 +00:00
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
c = *src++;
|
|
|
|
switch (c) {
|
|
|
|
case '\n': case '<': case '>':
|
|
|
|
continue;
|
|
|
|
}
|
2012-05-21 23:10:26 +00:00
|
|
|
sb->buf[sb->len++] = c;
|
2005-07-12 18:49:27 +00:00
|
|
|
}
|
2012-05-21 23:10:26 +00:00
|
|
|
sb->buf[sb->len] = '\0';
|
2005-07-12 18:49:27 +00:00
|
|
|
}
|
|
|
|
|
2012-03-11 09:25:43 +00:00
|
|
|
/*
|
|
|
|
* Reverse of fmt_ident(); given an ident line, split the fields
|
|
|
|
* to allow the caller to parse it.
|
|
|
|
* Signal a success by returning 0, but date/tz fields of the result
|
|
|
|
* can still be NULL if the input line only has the name/email part
|
|
|
|
* (e.g. reading from a reflog entry).
|
|
|
|
*/
|
|
|
|
int split_ident_line(struct ident_split *split, const char *line, int len)
|
|
|
|
{
|
|
|
|
const char *cp;
|
|
|
|
size_t span;
|
|
|
|
int status = -1;
|
|
|
|
|
|
|
|
memset(split, 0, sizeof(*split));
|
|
|
|
|
|
|
|
split->name_begin = line;
|
|
|
|
for (cp = line; *cp && cp < line + len; cp++)
|
|
|
|
if (*cp == '<') {
|
|
|
|
split->mail_begin = cp + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!split->mail_begin)
|
|
|
|
return status;
|
|
|
|
|
2012-05-22 06:12:20 +00:00
|
|
|
for (cp = split->mail_begin - 2; line <= cp; cp--)
|
2012-03-11 09:25:43 +00:00
|
|
|
if (!isspace(*cp)) {
|
|
|
|
split->name_end = cp + 1;
|
|
|
|
break;
|
|
|
|
}
|
2012-08-31 21:54:18 +00:00
|
|
|
if (!split->name_end) {
|
|
|
|
/* no human readable name */
|
|
|
|
split->name_end = split->name_begin;
|
|
|
|
}
|
2012-03-11 09:25:43 +00:00
|
|
|
|
|
|
|
for (cp = split->mail_begin; cp < line + len; cp++)
|
|
|
|
if (*cp == '>') {
|
|
|
|
split->mail_end = cp;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!split->mail_end)
|
|
|
|
return status;
|
|
|
|
|
split_ident: parse timestamp from end of line
Split_ident currently parses left to right. Given this
input:
Your Name <email@example.com> 123456789 -0500\n
We assume the name starts the line and runs until the first
"<". That starts the email address, which runs until the
first ">". Everything after that is assumed to be the
timestamp.
This works fine in the normal case, but is easily broken by
corrupted ident lines that contain an extra ">". Some
examples seen in the wild are:
1. Name <email>-<> 123456789 -0500\n
2. Name <email> <Name<email>> 123456789 -0500\n
3. Name1 <email1>, Name2 <email2> 123456789 -0500\n
Currently each of these produces some email address (which
is not necessarily the one the user intended) and end up
with a NULL date (which is generally interpreted as the
epoch by "git log" and friends).
But in each case we could get the correct timestamp simply
by parsing from the right-hand side, looking backwards for
the final ">", and then reading the timestamp from there.
In general, it's a losing battle to try to automatically
guess what the user meant with their broken crud. But this
particular workaround is probably worth doing. One, it's
dirt simple, and can't impact non-broken cases. Two, it
doesn't catch a single breakage we've seen, but rather a
large class of errors (i.e., any breakage inside the email
angle brackets may affect the email, but won't spill over
into the timestamp parsing). And three, the timestamp is
arguably more valuable to get right, because it can affect
correctness (e.g., in --until cutoffs).
This patch implements the right-to-left scheme described
above. We adjust the tests in t4212, which generate a commit
with such a broken ident, and now gets the timestamp right.
We also add a test that fsck continues to detect the
breakage.
For reference, here are pointers to the breakages seen (as
numbered above):
[1] http://article.gmane.org/gmane.comp.version-control.git/221441
[2] http://article.gmane.org/gmane.comp.version-control.git/222362
[3] http://perl5.git.perl.org/perl.git/commit/13b79730adea97e660de84bbe67f9d7cbe344302
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-10-14 22:45:00 +00:00
|
|
|
/*
|
|
|
|
* Look from the end-of-line to find the trailing ">" of the mail
|
|
|
|
* address, even though we should already know it as split->mail_end.
|
|
|
|
* This can help in cases of broken idents with an extra ">" somewhere
|
|
|
|
* in the email address. Note that we are assuming the timestamp will
|
|
|
|
* never have a ">" in it.
|
|
|
|
*
|
|
|
|
* Note that we will always find some ">" before going off the front of
|
|
|
|
* the string, because will always hit the split->mail_end closing
|
|
|
|
* bracket.
|
|
|
|
*/
|
|
|
|
for (cp = line + len - 1; *cp != '>'; cp--)
|
|
|
|
;
|
|
|
|
|
|
|
|
for (cp = cp + 1; cp < line + len && isspace(*cp); cp++)
|
2012-03-11 09:25:43 +00:00
|
|
|
;
|
|
|
|
if (line + len <= cp)
|
|
|
|
goto person_only;
|
|
|
|
split->date_begin = cp;
|
|
|
|
span = strspn(cp, "0123456789");
|
|
|
|
if (!span)
|
|
|
|
goto person_only;
|
|
|
|
split->date_end = split->date_begin + span;
|
|
|
|
for (cp = split->date_end; cp < line + len && isspace(*cp); cp++)
|
|
|
|
;
|
|
|
|
if (line + len <= cp || (*cp != '+' && *cp != '-'))
|
|
|
|
goto person_only;
|
|
|
|
split->tz_begin = cp;
|
|
|
|
span = strspn(cp + 1, "0123456789");
|
|
|
|
if (!span)
|
|
|
|
goto person_only;
|
|
|
|
split->tz_end = split->tz_begin + 1 + span;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
person_only:
|
|
|
|
split->date_begin = NULL;
|
|
|
|
split->date_end = NULL;
|
|
|
|
split->tz_begin = NULL;
|
|
|
|
split->tz_end = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-07-18 19:51:00 +00:00
|
|
|
/*
|
|
|
|
* Returns the difference between the new and old length of the ident line.
|
|
|
|
*/
|
|
|
|
static ssize_t rewrite_ident_line(const char *person, size_t len,
|
|
|
|
struct strbuf *buf,
|
|
|
|
struct string_list *mailmap)
|
|
|
|
{
|
|
|
|
size_t namelen, maillen;
|
|
|
|
const char *name;
|
|
|
|
const char *mail;
|
|
|
|
struct ident_split ident;
|
|
|
|
|
|
|
|
if (split_ident_line(&ident, person, len))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
mail = ident.mail_begin;
|
|
|
|
maillen = ident.mail_end - ident.mail_begin;
|
|
|
|
name = ident.name_begin;
|
|
|
|
namelen = ident.name_end - ident.name_begin;
|
|
|
|
|
|
|
|
if (map_user(mailmap, &mail, &maillen, &name, &namelen)) {
|
|
|
|
struct strbuf namemail = STRBUF_INIT;
|
|
|
|
size_t newlen;
|
|
|
|
|
|
|
|
strbuf_addf(&namemail, "%.*s <%.*s>",
|
|
|
|
(int)namelen, name, (int)maillen, mail);
|
|
|
|
|
|
|
|
strbuf_splice(buf, ident.name_begin - buf->buf,
|
|
|
|
ident.mail_end - ident.name_begin + 1,
|
|
|
|
namemail.buf, namemail.len);
|
|
|
|
newlen = namemail.len;
|
|
|
|
|
|
|
|
strbuf_release(&namemail);
|
|
|
|
|
|
|
|
return newlen - (ident.mail_end - ident.name_begin);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-07-18 19:51:01 +00:00
|
|
|
void apply_mailmap_to_header(struct strbuf *buf, const char **header,
|
|
|
|
struct string_list *mailmap)
|
2022-07-18 19:51:00 +00:00
|
|
|
{
|
|
|
|
size_t buf_offset = 0;
|
|
|
|
|
|
|
|
if (!mailmap)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
const char *person, *line;
|
|
|
|
size_t i;
|
|
|
|
int found_header = 0;
|
|
|
|
|
|
|
|
line = buf->buf + buf_offset;
|
|
|
|
if (!*line || *line == '\n')
|
|
|
|
return; /* End of headers */
|
|
|
|
|
|
|
|
for (i = 0; header[i]; i++)
|
|
|
|
if (skip_prefix(line, header[i], &person)) {
|
|
|
|
const char *endp = strchrnul(person, '\n');
|
|
|
|
found_header = 1;
|
|
|
|
buf_offset += endp - line;
|
|
|
|
buf_offset += rewrite_ident_line(person, endp - person, buf, mailmap);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found_header) {
|
|
|
|
buf_offset = strchrnul(line, '\n') - buf->buf;
|
|
|
|
if (buf->buf[buf_offset] == '\n')
|
|
|
|
buf_offset++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-08-21 20:36:28 +00:00
|
|
|
|
|
|
|
static void ident_env_hint(enum want_ident whose_ident)
|
|
|
|
{
|
|
|
|
switch (whose_ident) {
|
|
|
|
case WANT_AUTHOR_IDENT:
|
|
|
|
fputs(_("Author identity unknown\n"), stderr);
|
|
|
|
break;
|
|
|
|
case WANT_COMMITTER_IDENT:
|
|
|
|
fputs(_("Committer identity unknown\n"), stderr);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
fputs(_("\n"
|
|
|
|
"*** Please tell me who you are.\n"
|
|
|
|
"\n"
|
|
|
|
"Run\n"
|
|
|
|
"\n"
|
|
|
|
" git config --global user.email \"you@example.com\"\n"
|
|
|
|
" git config --global user.name \"Your Name\"\n"
|
|
|
|
"\n"
|
|
|
|
"to set your account\'s default identity.\n"
|
|
|
|
"Omit --global to set the identity only in this repository.\n"
|
|
|
|
"\n"), stderr);
|
|
|
|
}
|
2006-02-19 04:31:05 +00:00
|
|
|
|
2007-12-09 01:32:08 +00:00
|
|
|
const char *fmt_ident(const char *name, const char *email,
|
2019-02-04 18:48:50 +00:00
|
|
|
enum want_ident whose_ident, const char *date_str, int flag)
|
2005-07-12 18:49:27 +00:00
|
|
|
{
|
2020-08-17 17:40:01 +00:00
|
|
|
static int index;
|
|
|
|
static struct strbuf ident_pool[2] = { STRBUF_INIT, STRBUF_INIT };
|
2012-05-24 23:28:40 +00:00
|
|
|
int strict = (flag & IDENT_STRICT);
|
2012-05-24 23:26:50 +00:00
|
|
|
int want_date = !(flag & IDENT_NO_DATE);
|
ident: let callers omit name with fmt_indent
Most callers want to see all of "$name <$email> $date", but
a few want only limited parts, omitting the date, or even
the name. We already have IDENT_NO_DATE to handle the date
part, but there's not a good option for getting just the
email. Callers have to done one of:
1. Call ident_default_email; this does not respect
environment variables, nor does it promise to trim
whitespace or other crud from the result.
2. Call git_{committer,author}_info; this returns the name
and email, leaving the caller to parse out the wanted
bits.
This patch adds IDENT_NO_NAME; it stops short of adding
IDENT_NO_EMAIL, as no callers want it (nor are likely to),
and it complicates the error handling of the function.
When no name is requested, the angle brackets (<>) around
the email address are also omitted.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-05-24 23:27:24 +00:00
|
|
|
int want_name = !(flag & IDENT_NO_NAME);
|
2005-07-12 18:49:27 +00:00
|
|
|
|
2020-08-17 17:40:01 +00:00
|
|
|
struct strbuf *ident = &ident_pool[index];
|
|
|
|
index = (index + 1) % ARRAY_SIZE(ident_pool);
|
|
|
|
|
2019-02-04 18:48:50 +00:00
|
|
|
if (!email) {
|
|
|
|
if (whose_ident == WANT_AUTHOR_IDENT && git_author_email.len)
|
|
|
|
email = git_author_email.buf;
|
|
|
|
else if (whose_ident == WANT_COMMITTER_IDENT && git_committer_email.len)
|
|
|
|
email = git_committer_email.buf;
|
|
|
|
}
|
ident: handle NULL email when complaining of empty name
If we see an empty name, we complain about and mention the
matching email in the error message (to give it some
context). However, the "email" pointer may be NULL here if
we were planning to fill it in later from ident_default_email().
This was broken by 59f929596 (fmt_ident: refactor strictness
checks, 2016-02-04). Prior to that commit, we would look up
the default name and email before doing any other actions.
So one solution would be to go back to that.
However, we can't just do so blindly. The logic for handling
the "!email" condition has grown since then. In particular,
looking up the default email can die if getpwuid() fails,
but there are other errors that should take precedence.
Commit 734c7789a (ident: check for useConfigOnly before
auto-detection of name/email, 2016-03-30) reordered the
checks so that we prefer the error message for
useConfigOnly.
Instead, we can observe that while the name-handling depends
on "email" being set, the reverse is not true. So we can
simply set up the email variable first.
This does mean that if both are bogus, we'll complain about
the email before the name. But between the two, there is no
reason to prefer one over the other.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-23 08:13:53 +00:00
|
|
|
if (!email) {
|
|
|
|
if (strict && ident_use_config_only
|
|
|
|
&& !(ident_config_given & IDENT_MAIL_GIVEN)) {
|
2020-08-21 20:36:28 +00:00
|
|
|
ident_env_hint(whose_ident);
|
ident: handle NULL email when complaining of empty name
If we see an empty name, we complain about and mention the
matching email in the error message (to give it some
context). However, the "email" pointer may be NULL here if
we were planning to fill it in later from ident_default_email().
This was broken by 59f929596 (fmt_ident: refactor strictness
checks, 2016-02-04). Prior to that commit, we would look up
the default name and email before doing any other actions.
So one solution would be to go back to that.
However, we can't just do so blindly. The logic for handling
the "!email" condition has grown since then. In particular,
looking up the default email can die if getpwuid() fails,
but there are other errors that should take precedence.
Commit 734c7789a (ident: check for useConfigOnly before
auto-detection of name/email, 2016-03-30) reordered the
checks so that we prefer the error message for
useConfigOnly.
Instead, we can observe that while the name-handling depends
on "email" being set, the reverse is not true. So we can
simply set up the email variable first.
This does mean that if both are bogus, we'll complain about
the email before the name. But between the two, there is no
reason to prefer one over the other.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-23 08:13:53 +00:00
|
|
|
die(_("no email was given and auto-detection is disabled"));
|
|
|
|
}
|
|
|
|
email = ident_default_email();
|
|
|
|
if (strict && default_email_is_bogus) {
|
2020-08-21 20:36:28 +00:00
|
|
|
ident_env_hint(whose_ident);
|
ident: handle NULL email when complaining of empty name
If we see an empty name, we complain about and mention the
matching email in the error message (to give it some
context). However, the "email" pointer may be NULL here if
we were planning to fill it in later from ident_default_email().
This was broken by 59f929596 (fmt_ident: refactor strictness
checks, 2016-02-04). Prior to that commit, we would look up
the default name and email before doing any other actions.
So one solution would be to go back to that.
However, we can't just do so blindly. The logic for handling
the "!email" condition has grown since then. In particular,
looking up the default email can die if getpwuid() fails,
but there are other errors that should take precedence.
Commit 734c7789a (ident: check for useConfigOnly before
auto-detection of name/email, 2016-03-30) reordered the
checks so that we prefer the error message for
useConfigOnly.
Instead, we can observe that while the name-handling depends
on "email" being set, the reverse is not true. So we can
simply set up the email variable first.
This does mean that if both are bogus, we'll complain about
the email before the name. But between the two, there is no
reason to prefer one over the other.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-23 08:13:53 +00:00
|
|
|
die(_("unable to auto-detect email address (got '%s')"), email);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-04 09:12:38 +00:00
|
|
|
if (want_name) {
|
|
|
|
int using_default = 0;
|
2019-02-04 18:48:50 +00:00
|
|
|
if (!name) {
|
|
|
|
if (whose_ident == WANT_AUTHOR_IDENT && git_author_name.len)
|
|
|
|
name = git_author_name.buf;
|
|
|
|
else if (whose_ident == WANT_COMMITTER_IDENT &&
|
|
|
|
git_committer_name.len)
|
|
|
|
name = git_committer_name.buf;
|
|
|
|
}
|
2016-02-04 09:12:38 +00:00
|
|
|
if (!name) {
|
2016-03-30 19:29:42 +00:00
|
|
|
if (strict && ident_use_config_only
|
2016-03-30 19:29:43 +00:00
|
|
|
&& !(ident_config_given & IDENT_NAME_GIVEN)) {
|
2020-08-21 20:36:28 +00:00
|
|
|
ident_env_hint(whose_ident);
|
2017-02-23 08:12:30 +00:00
|
|
|
die(_("no name was given and auto-detection is disabled"));
|
2016-03-30 19:29:43 +00:00
|
|
|
}
|
2016-02-04 09:12:38 +00:00
|
|
|
name = ident_default_name();
|
|
|
|
using_default = 1;
|
|
|
|
if (strict && default_name_is_bogus) {
|
2020-08-21 20:36:28 +00:00
|
|
|
ident_env_hint(whose_ident);
|
2017-02-23 08:12:30 +00:00
|
|
|
die(_("unable to auto-detect name (got '%s')"), name);
|
2016-02-04 09:12:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!*name) {
|
|
|
|
struct passwd *pw;
|
|
|
|
if (strict) {
|
|
|
|
if (using_default)
|
2020-08-21 20:36:28 +00:00
|
|
|
ident_env_hint(whose_ident);
|
2017-02-23 08:12:30 +00:00
|
|
|
die(_("empty ident name (for <%s>) not allowed"), email);
|
2016-02-04 09:12:38 +00:00
|
|
|
}
|
|
|
|
pw = xgetpwuid_self(NULL);
|
|
|
|
name = pw->pw_name;
|
2006-02-19 04:31:05 +00:00
|
|
|
}
|
2017-02-23 08:15:55 +00:00
|
|
|
if (strict && !has_non_crud(name))
|
|
|
|
die(_("name consists only of disallowed characters: %s"), name);
|
ident: loosen getpwuid error in non-strict mode
If the user has not specified an identity and we have to
turn to getpwuid() to find the username or gecos field, we
die immediately when getpwuid fails (e.g., because the user
does not exist). This is OK for making a commit, where we
have set IDENT_STRICT and would want to bail on bogus input.
But for something like a reflog, where the ident is "best
effort", it can be pain. For instance, even running "git
clone" with a UID that is not in /etc/passwd will result in
git barfing, just because we can't find an ident to put in
the reflog.
Instead of dying in xgetpwuid_self, we can instead return a
fallback value, and set a "bogus" flag. For the username in
an email, we already have a "default_email_is_bogus" flag.
For the name field, we introduce (and check) a matching
"default_name_is_bogus" flag. As a bonus, this means you now
get the usual "tell me who you are" advice instead of just a
"no such user" error.
No tests, as this is dependent on configuration outside of
git's control. However, I did confirm that it behaves
sensibly when I delete myself from the local /etc/passwd
(reflogs get written, and commits complain).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-10 21:41:29 +00:00
|
|
|
}
|
|
|
|
|
2020-08-17 17:40:01 +00:00
|
|
|
strbuf_reset(ident);
|
ident: let callers omit name with fmt_indent
Most callers want to see all of "$name <$email> $date", but
a few want only limited parts, omitting the date, or even
the name. We already have IDENT_NO_DATE to handle the date
part, but there's not a good option for getting just the
email. Callers have to done one of:
1. Call ident_default_email; this does not respect
environment variables, nor does it promise to trim
whitespace or other crud from the result.
2. Call git_{committer,author}_info; this returns the name
and email, leaving the caller to parse out the wanted
bits.
This patch adds IDENT_NO_NAME; it stops short of adding
IDENT_NO_EMAIL, as no callers want it (nor are likely to),
and it complicates the error handling of the function.
When no name is requested, the angle brackets (<>) around
the email address are also omitted.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-05-24 23:27:24 +00:00
|
|
|
if (want_name) {
|
2020-08-17 17:40:01 +00:00
|
|
|
strbuf_addstr_without_crud(ident, name);
|
|
|
|
strbuf_addstr(ident, " <");
|
2007-12-02 21:43:34 +00:00
|
|
|
}
|
2020-08-17 17:40:01 +00:00
|
|
|
strbuf_addstr_without_crud(ident, email);
|
ident: let callers omit name with fmt_indent
Most callers want to see all of "$name <$email> $date", but
a few want only limited parts, omitting the date, or even
the name. We already have IDENT_NO_DATE to handle the date
part, but there's not a good option for getting just the
email. Callers have to done one of:
1. Call ident_default_email; this does not respect
environment variables, nor does it promise to trim
whitespace or other crud from the result.
2. Call git_{committer,author}_info; this returns the name
and email, leaving the caller to parse out the wanted
bits.
This patch adds IDENT_NO_NAME; it stops short of adding
IDENT_NO_EMAIL, as no callers want it (nor are likely to),
and it complicates the error handling of the function.
When no name is requested, the angle brackets (<>) around
the email address are also omitted.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-05-24 23:27:24 +00:00
|
|
|
if (want_name)
|
2020-08-17 17:40:01 +00:00
|
|
|
strbuf_addch(ident, '>');
|
2012-05-24 23:26:50 +00:00
|
|
|
if (want_date) {
|
2020-08-17 17:40:01 +00:00
|
|
|
strbuf_addch(ident, ' ');
|
2014-08-27 07:57:08 +00:00
|
|
|
if (date_str && date_str[0]) {
|
2020-08-17 17:40:01 +00:00
|
|
|
if (parse_date(date_str, ident) < 0)
|
2017-02-23 08:12:30 +00:00
|
|
|
die(_("invalid date format: %s"), date_str);
|
2014-08-27 07:57:08 +00:00
|
|
|
}
|
|
|
|
else
|
2020-08-17 17:40:01 +00:00
|
|
|
strbuf_addstr(ident, ident_default_date());
|
2007-12-02 21:43:34 +00:00
|
|
|
}
|
2014-08-27 07:57:08 +00:00
|
|
|
|
2020-08-17 17:40:01 +00:00
|
|
|
return ident->buf;
|
2005-07-12 18:49:27 +00:00
|
|
|
}
|
2005-07-15 00:50:33 +00:00
|
|
|
|
2019-02-04 18:48:50 +00:00
|
|
|
const char *fmt_name(enum want_ident whose_ident)
|
2007-12-02 21:43:34 +00:00
|
|
|
{
|
2019-02-04 18:48:50 +00:00
|
|
|
char *name = NULL;
|
|
|
|
char *email = NULL;
|
|
|
|
|
|
|
|
switch (whose_ident) {
|
|
|
|
case WANT_BLANK_IDENT:
|
|
|
|
break;
|
|
|
|
case WANT_AUTHOR_IDENT:
|
|
|
|
name = getenv("GIT_AUTHOR_NAME");
|
|
|
|
email = getenv("GIT_AUTHOR_EMAIL");
|
|
|
|
break;
|
|
|
|
case WANT_COMMITTER_IDENT:
|
|
|
|
name = getenv("GIT_COMMITTER_NAME");
|
|
|
|
email = getenv("GIT_COMMITTER_EMAIL");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return fmt_ident(name, email, whose_ident, NULL,
|
|
|
|
IDENT_STRICT | IDENT_NO_DATE);
|
2007-12-02 21:43:34 +00:00
|
|
|
}
|
|
|
|
|
2007-12-09 01:32:08 +00:00
|
|
|
const char *git_author_info(int flag)
|
2005-07-15 00:50:33 +00:00
|
|
|
{
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
if (getenv("GIT_AUTHOR_NAME"))
|
|
|
|
author_ident_explicitly_given |= IDENT_NAME_GIVEN;
|
|
|
|
if (getenv("GIT_AUTHOR_EMAIL"))
|
|
|
|
author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
|
2007-02-05 01:50:14 +00:00
|
|
|
return fmt_ident(getenv("GIT_AUTHOR_NAME"),
|
2005-11-22 07:44:35 +00:00
|
|
|
getenv("GIT_AUTHOR_EMAIL"),
|
2019-02-04 18:48:50 +00:00
|
|
|
WANT_AUTHOR_IDENT,
|
2006-02-19 04:31:05 +00:00
|
|
|
getenv("GIT_AUTHOR_DATE"),
|
2007-12-09 01:32:08 +00:00
|
|
|
flag);
|
2005-07-15 00:50:33 +00:00
|
|
|
}
|
|
|
|
|
2007-12-09 01:32:08 +00:00
|
|
|
const char *git_committer_info(int flag)
|
2005-07-15 00:50:33 +00:00
|
|
|
{
|
2010-01-08 15:39:11 +00:00
|
|
|
if (getenv("GIT_COMMITTER_NAME"))
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
|
2010-01-08 15:39:11 +00:00
|
|
|
if (getenv("GIT_COMMITTER_EMAIL"))
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
|
2007-02-05 01:50:14 +00:00
|
|
|
return fmt_ident(getenv("GIT_COMMITTER_NAME"),
|
2005-11-22 07:44:35 +00:00
|
|
|
getenv("GIT_COMMITTER_EMAIL"),
|
2019-02-04 18:48:50 +00:00
|
|
|
WANT_COMMITTER_IDENT,
|
2006-02-19 04:31:05 +00:00
|
|
|
getenv("GIT_COMMITTER_DATE"),
|
2007-12-09 01:32:08 +00:00
|
|
|
flag);
|
2005-07-15 00:50:33 +00:00
|
|
|
}
|
2010-01-17 21:54:28 +00:00
|
|
|
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
static int ident_is_sufficient(int user_ident_explicitly_given)
|
2010-01-17 21:54:28 +00:00
|
|
|
{
|
|
|
|
#ifndef WINDOWS
|
|
|
|
return (user_ident_explicitly_given & IDENT_MAIL_GIVEN);
|
|
|
|
#else
|
|
|
|
return (user_ident_explicitly_given == IDENT_ALL_GIVEN);
|
|
|
|
#endif
|
|
|
|
}
|
2012-05-21 23:09:54 +00:00
|
|
|
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
int committer_ident_sufficiently_given(void)
|
|
|
|
{
|
|
|
|
return ident_is_sufficient(committer_ident_explicitly_given);
|
|
|
|
}
|
|
|
|
|
|
|
|
int author_ident_sufficiently_given(void)
|
|
|
|
{
|
|
|
|
return ident_is_sufficient(author_ident_explicitly_given);
|
|
|
|
}
|
|
|
|
|
2019-02-04 18:48:50 +00:00
|
|
|
static int set_ident(const char *var, const char *value)
|
2012-05-21 23:09:54 +00:00
|
|
|
{
|
2019-02-04 18:48:50 +00:00
|
|
|
if (!strcmp(var, "author.name")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
strbuf_reset(&git_author_name);
|
|
|
|
strbuf_addstr(&git_author_name, value);
|
|
|
|
author_ident_explicitly_given |= IDENT_NAME_GIVEN;
|
|
|
|
ident_config_given |= IDENT_NAME_GIVEN;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(var, "author.email")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
strbuf_reset(&git_author_email);
|
|
|
|
strbuf_addstr(&git_author_email, value);
|
|
|
|
author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
|
|
|
|
ident_config_given |= IDENT_MAIL_GIVEN;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(var, "committer.name")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
strbuf_reset(&git_committer_name);
|
|
|
|
strbuf_addstr(&git_committer_name, value);
|
|
|
|
committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
|
|
|
|
ident_config_given |= IDENT_NAME_GIVEN;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(var, "committer.email")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
strbuf_reset(&git_committer_email);
|
|
|
|
strbuf_addstr(&git_committer_email, value);
|
|
|
|
committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
|
|
|
|
ident_config_given |= IDENT_MAIL_GIVEN;
|
2016-02-06 06:23:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-21 23:09:54 +00:00
|
|
|
if (!strcmp(var, "user.name")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
2012-05-21 23:10:17 +00:00
|
|
|
strbuf_reset(&git_default_name);
|
|
|
|
strbuf_addstr(&git_default_name, value);
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
|
|
|
|
author_ident_explicitly_given |= IDENT_NAME_GIVEN;
|
2016-02-06 06:23:36 +00:00
|
|
|
ident_config_given |= IDENT_NAME_GIVEN;
|
2012-05-21 23:09:54 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(var, "user.email")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
2012-05-21 23:10:17 +00:00
|
|
|
strbuf_reset(&git_default_email);
|
|
|
|
strbuf_addstr(&git_default_email, value);
|
ident: keep separate "explicit" flags for author and committer
We keep track of whether the user ident was given to us
explicitly, or if we guessed at it from system parameters
like username and hostname. However, we kept only a single
variable. This covers the common cases (because the author
and committer will usually come from the same explicit
source), but can miss two cases:
1. GIT_COMMITTER_* is set explicitly, but we fallback for
GIT_AUTHOR. We claim the ident is explicit, even though
the author is not.
2. GIT_AUTHOR_* is set and we ask for author ident, but
not committer ident. We will claim the ident is
implicit, even though it is explicit.
This patch uses two variables instead of one, updates both
when we set the "fallback" values, and updates them
individually when we read from the environment.
Rather than keep user_ident_sufficiently_given as a
compatibility wrapper, we update the only two callers to
check the committer_ident, which matches their intent and
what was happening already.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-15 00:34:13 +00:00
|
|
|
committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
|
|
|
|
author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
|
2016-02-06 06:23:36 +00:00
|
|
|
ident_config_given |= IDENT_MAIL_GIVEN;
|
2012-05-21 23:09:54 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2013-09-20 10:16:28 +00:00
|
|
|
|
config: add ctx arg to config_fn_t
Add a new "const struct config_context *ctx" arg to config_fn_t to hold
additional information about the config iteration operation.
config_context has a "struct key_value_info kvi" member that holds
metadata about the config source being read (e.g. what kind of config
source it is, the filename, etc). In this series, we're only interested
in .kvi, so we could have just used "struct key_value_info" as an arg,
but config_context makes it possible to add/adjust members in the future
without changing the config_fn_t signature. We could also consider other
ways of organizing the args (e.g. moving the config name and value into
config_context or key_value_info), but in my experiments, the
incremental benefit doesn't justify the added complexity (e.g. a
config_fn_t will sometimes invoke another config_fn_t but with a
different config value).
In subsequent commits, the .kvi member will replace the global "struct
config_reader" in config.c, making config iteration a global-free
operation. It requires much more work for the machinery to provide
meaningful values of .kvi, so for now, merely change the signature and
call sites, pass NULL as a placeholder value, and don't rely on the arg
in any meaningful way.
Most of the changes are performed by
contrib/coccinelle/config_fn_ctx.pending.cocci, which, for every
config_fn_t:
- Modifies the signature to accept "const struct config_context *ctx"
- Passes "ctx" to any inner config_fn_t, if needed
- Adds UNUSED attributes to "ctx", if needed
Most config_fn_t instances are easily identified by seeing if they are
called by the various config functions. Most of the remaining ones are
manually named in the .cocci patch. Manual cleanups are still needed,
but the majority of it is trivial; it's either adjusting config_fn_t
that the .cocci patch didn't catch, or adding forward declarations of
"struct config_context ctx" to make the signatures make sense.
The non-trivial changes are in cases where we are invoking a config_fn_t
outside of config machinery, and we now need to decide what value of
"ctx" to pass. These cases are:
- trace2/tr2_cfg.c:tr2_cfg_set_fl()
This is indirectly called by git_config_set() so that the trace2
machinery can notice the new config values and update its settings
using the tr2 config parsing function, i.e. tr2_cfg_cb().
- builtin/checkout.c:checkout_main()
This calls git_xmerge_config() as a shorthand for parsing a CLI arg.
This might be worth refactoring away in the future, since
git_xmerge_config() can call git_default_config(), which can do much
more than just parsing.
Handle them by creating a KVI_INIT macro that initializes "struct
key_value_info" to a reasonable default, and use that to construct the
"ctx" arg.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 19:26:22 +00:00
|
|
|
int git_ident_config(const char *var, const char *value,
|
|
|
|
const struct config_context *ctx UNUSED,
|
|
|
|
void *data UNUSED)
|
2019-02-04 18:48:50 +00:00
|
|
|
{
|
|
|
|
if (!strcmp(var, "user.useconfigonly")) {
|
|
|
|
ident_use_config_only = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return set_ident(var, value);
|
|
|
|
}
|
|
|
|
|
2019-02-25 23:16:08 +00:00
|
|
|
static void set_env_if(const char *key, const char *value, int *given, int bit)
|
|
|
|
{
|
2019-03-06 22:09:11 +00:00
|
|
|
if ((*given & bit) || getenv(key))
|
2019-02-25 23:16:08 +00:00
|
|
|
return; /* nothing to do */
|
|
|
|
setenv(key, value, 0);
|
|
|
|
*given |= bit;
|
|
|
|
}
|
|
|
|
|
|
|
|
void prepare_fallback_ident(const char *name, const char *email)
|
|
|
|
{
|
|
|
|
set_env_if("GIT_AUTHOR_NAME", name,
|
|
|
|
&author_ident_explicitly_given, IDENT_NAME_GIVEN);
|
|
|
|
set_env_if("GIT_AUTHOR_EMAIL", email,
|
|
|
|
&author_ident_explicitly_given, IDENT_MAIL_GIVEN);
|
|
|
|
set_env_if("GIT_COMMITTER_NAME", name,
|
|
|
|
&committer_ident_explicitly_given, IDENT_NAME_GIVEN);
|
|
|
|
set_env_if("GIT_COMMITTER_EMAIL", email,
|
|
|
|
&committer_ident_explicitly_given, IDENT_MAIL_GIVEN);
|
|
|
|
}
|
|
|
|
|
2013-09-20 10:16:28 +00:00
|
|
|
static int buf_cmp(const char *a_begin, const char *a_end,
|
|
|
|
const char *b_begin, const char *b_end)
|
|
|
|
{
|
|
|
|
int a_len = a_end - a_begin;
|
|
|
|
int b_len = b_end - b_begin;
|
|
|
|
int min = a_len < b_len ? a_len : b_len;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
cmp = memcmp(a_begin, b_begin, min);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
|
|
|
|
return a_len - b_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ident_cmp(const struct ident_split *a,
|
|
|
|
const struct ident_split *b)
|
|
|
|
{
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
cmp = buf_cmp(a->mail_begin, a->mail_end,
|
|
|
|
b->mail_begin, b->mail_end);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
|
|
|
|
return buf_cmp(a->name_begin, a->name_end,
|
|
|
|
b->name_begin, b->name_end);
|
|
|
|
}
|