Adding upstream version 1:2.43.0.upstream/1%2.43.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 732 insertions, 0 deletions

diff --git a/ident.c b/ident.c
new file mode 100644
index 0000000..cc7afdb
--- /dev/null
+++ b/ident.c
@@ -0,0 +1,732 @@
+/*
+ * ident.c
+ *
+ * create git identifier lines of the form "name <email> date"
+ *
+ * Copyright (C) 2005 Linus Torvalds
+ */
+#include "git-compat-util.h"
+#include "ident.h"
+#include "config.h"
+#include "date.h"
+#include "gettext.h"
+#include "mailmap.h"
+#include "strbuf.h"
+
+static struct strbuf git_default_name = STRBUF_INIT;
+static struct strbuf git_default_email = STRBUF_INIT;
+static struct strbuf git_default_date = STRBUF_INIT;
+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;
+static int default_email_is_bogus;
+static int default_name_is_bogus;
+
+static int ident_use_config_only;
+
+#define IDENT_NAME_GIVEN 01
+#define IDENT_MAIL_GIVEN 02
+#define IDENT_ALL_GIVEN (IDENT_NAME_GIVEN|IDENT_MAIL_GIVEN)
+static int committer_ident_explicitly_given;
+static int author_ident_explicitly_given;
+static int ident_config_given;
+
+#ifdef NO_GECOS_IN_PWENT
+#define get_gecos(ignored) "&"
+#else
+#define get_gecos(struct_passwd) ((struct_passwd)->pw_gecos)
+#endif
+
+static struct passwd *xgetpwuid_self(int *is_bogus)
+{
+	struct passwd *pw;
+
+	errno = 0;
+	pw = getpwuid(getuid());
+	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;
+	}
+	return pw;
+}
+
+static void copy_gecos(const struct passwd *w, struct strbuf *name)
+{
+	char *src;
+
+	/* Traditionally GECOS field had office phone numbers etc, separated
+	 * with commas.  Also & stands for capitalized form of the login name.
+	 */
+
+	for (src = get_gecos(w); *src && *src != ','; src++) {
+		int ch = *src;
+		if (ch != '&')
+			strbuf_addch(name, ch);
+		else {
+			/* Sorry, Mr. McDonald... */
+			strbuf_addch(name, toupper(*w->pw_name));
+			strbuf_addstr(name, w->pw_name + 1);
+		}
+	}
+}
+
+static int add_mailname_host(struct strbuf *buf)
+{
+	FILE *mailname;
+	struct strbuf mailnamebuf = STRBUF_INIT;
+
+	mailname = fopen_or_warn("/etc/mailname", "r");
+	if (!mailname)
+		return -1;
+
+	if (strbuf_getline(&mailnamebuf, mailname) == EOF) {
+		if (ferror(mailname))
+			warning_errno("cannot read /etc/mailname");
+		strbuf_release(&mailnamebuf);
+		fclose(mailname);
+		return -1;
+	}
+	/* success! */
+	strbuf_addbuf(buf, &mailnamebuf);
+	strbuf_release(&mailnamebuf);
+	fclose(mailname);
+	return 0;
+}
+
+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)) {
+		if (ai && ai->ai_canonname && strchr(ai->ai_canonname, '.')) {
+			strbuf_addstr(out, ai->ai_canonname);
+			status = 0;
+		}
+		freeaddrinfo(ai);
+	}
+#else
+	struct hostent *he = gethostbyname(host);
+	if (he && strchr(he->h_name, '.')) {
+		strbuf_addstr(out, he->h_name);
+		status = 0;
+	}
+#endif /* NO_IPV6 */
+
+	return status;
+}
+
+static void add_domainname(struct strbuf *out, int *is_bogus)
+{
+	char buf[HOST_NAME_MAX + 1];
+
+	if (xgethostname(buf, sizeof(buf))) {
+		warning_errno("cannot get host name");
+		strbuf_addstr(out, "(none)");
+		*is_bogus = 1;
+		return;
+	}
+	if (strchr(buf, '.'))
+		strbuf_addstr(out, buf);
+	else if (canonical_name(buf, out) < 0) {
+		strbuf_addf(out, "%s.(none)", buf);
+		*is_bogus = 1;
+	}
+}
+
+static void copy_email(const struct passwd *pw, struct strbuf *email,
+		       int *is_bogus)
+{
+	/*
+	 * Make up a fake email address
+	 * (name + '@' + hostname [+ '.' + domainname])
+	 */
+	strbuf_addstr(email, pw->pw_name);
+	strbuf_addch(email, '@');
+
+	if (!add_mailname_host(email))
+		return;	/* read from "/etc/mailname" (Debian) */
+	add_domainname(email, is_bogus);
+}
+
+const char *ident_default_name(void)
+{
+	if (!(ident_config_given & IDENT_NAME_GIVEN) && !git_default_name.len) {
+		copy_gecos(xgetpwuid_self(&default_name_is_bogus), &git_default_name);
+		strbuf_trim(&git_default_name);
+	}
+	return git_default_name.buf;
+}
+
+const char *ident_default_email(void)
+{
+	if (!(ident_config_given & IDENT_MAIL_GIVEN) && !git_default_email.len) {
+		const char *email = getenv("EMAIL");
+
+		if (email && email[0]) {
+			strbuf_addstr(&git_default_email, email);
+			committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
+			author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
+		} else if ((email = query_user_email()) && email[0]) {
+			strbuf_addstr(&git_default_email, email);
+			free((char *)email);
+		} else
+			copy_email(xgetpwuid_self(&default_email_is_bogus),
+				   &git_default_email, &default_email_is_bogus);
+		strbuf_trim(&git_default_email);
+	}
+	return git_default_email.buf;
+}
+
+static const char *ident_default_date(void)
+{
+	if (!git_default_date.len)
+		datestamp(&git_default_date);
+	return git_default_date.buf;
+}
+
+void reset_ident_date(void)
+{
+	strbuf_reset(&git_default_date);
+}
+
+static int crud(unsigned char c)
+{
+	return  c <= 32  ||
+		c == ',' ||
+		c == ':' ||
+		c == ';' ||
+		c == '<' ||
+		c == '>' ||
+		c == '"' ||
+		c == '\\' ||
+		c == '\'';
+}
+
+static int has_non_crud(const char *str)
+{
+	for (; *str; str++) {
+		if (!crud(*str))
+			return 1;
+	}
+	return 0;
+}
+
+/*
+ * Copy over a string to the destination, but avoid special
+ * characters ('\n', '<' and '>') and remove crud at the end
+ */
+static void strbuf_addstr_without_crud(struct strbuf *sb, const char *src)
+{
+	size_t i, len;
+	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
+	 * characters '\n' '<' and '>' that act as delimiters on
+	 * an identification line. We can only remove crud, never add it,
+	 * so 'len' is our maximum.
+	 */
+	strbuf_grow(sb, len);
+	for (i = 0; i < len; i++) {
+		c = *src++;
+		switch (c) {
+		case '\n': case '<': case '>':
+			continue;
+		}
+		sb->buf[sb->len++] = c;
+	}
+	sb->buf[sb->len] = '\0';
+}
+
+/*
+ * 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;
+
+	for (cp = split->mail_begin - 2; line <= cp; cp--)
+		if (!isspace(*cp)) {
+			split->name_end = cp + 1;
+			break;
+		}
+	if (!split->name_end) {
+		/* no human readable name */
+		split->name_end = split->name_begin;
+	}
+
+	for (cp = split->mail_begin; cp < line + len; cp++)
+		if (*cp == '>') {
+			split->mail_end = cp;
+			break;
+		}
+	if (!split->mail_end)
+		return status;
+
+	/*
+	 * 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++)
+		;
+	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;
+}
+
+/*
+ * 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;
+}
+
+void apply_mailmap_to_header(struct strbuf *buf, const char **header,
+			       struct string_list *mailmap)
+{
+	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++;
+		}
+	}
+}
+
+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);
+}
+
+const char *fmt_ident(const char *name, const char *email,
+		      enum want_ident whose_ident, const char *date_str, int flag)
+{
+	static int index;
+	static struct strbuf ident_pool[2] = { STRBUF_INIT, STRBUF_INIT };
+	int strict = (flag & IDENT_STRICT);
+	int want_date = !(flag & IDENT_NO_DATE);
+	int want_name = !(flag & IDENT_NO_NAME);
+
+	struct strbuf *ident = &ident_pool[index];
+	index = (index + 1) % ARRAY_SIZE(ident_pool);
+
+	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;
+	}
+	if (!email) {
+		if (strict && ident_use_config_only
+		    && !(ident_config_given & IDENT_MAIL_GIVEN)) {
+			ident_env_hint(whose_ident);
+			die(_("no email was given and auto-detection is disabled"));
+		}
+		email = ident_default_email();
+		if (strict && default_email_is_bogus) {
+			ident_env_hint(whose_ident);
+			die(_("unable to auto-detect email address (got '%s')"), email);
+		}
+	}
+
+	if (want_name) {
+		int using_default = 0;
+		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;
+		}
+		if (!name) {
+			if (strict && ident_use_config_only
+			    && !(ident_config_given & IDENT_NAME_GIVEN)) {
+				ident_env_hint(whose_ident);
+				die(_("no name was given and auto-detection is disabled"));
+			}
+			name = ident_default_name();
+			using_default = 1;
+			if (strict && default_name_is_bogus) {
+				ident_env_hint(whose_ident);
+				die(_("unable to auto-detect name (got '%s')"), name);
+			}
+		}
+		if (!*name) {
+			struct passwd *pw;
+			if (strict) {
+				if (using_default)
+					ident_env_hint(whose_ident);
+				die(_("empty ident name (for <%s>) not allowed"), email);
+			}
+			pw = xgetpwuid_self(NULL);
+			name = pw->pw_name;
+		}
+		if (strict && !has_non_crud(name))
+			die(_("name consists only of disallowed characters: %s"), name);
+	}
+
+	strbuf_reset(ident);
+	if (want_name) {
+		strbuf_addstr_without_crud(ident, name);
+		strbuf_addstr(ident, " <");
+	}
+	strbuf_addstr_without_crud(ident, email);
+	if (want_name)
+		strbuf_addch(ident, '>');
+	if (want_date) {
+		strbuf_addch(ident, ' ');
+		if (date_str && date_str[0]) {
+			if (parse_date(date_str, ident) < 0)
+				die(_("invalid date format: %s"), date_str);
+		}
+		else
+			strbuf_addstr(ident, ident_default_date());
+	}
+
+	return ident->buf;
+}
+
+const char *fmt_name(enum want_ident whose_ident)
+{
+	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);
+}
+
+const char *git_author_info(int flag)
+{
+	if (getenv("GIT_AUTHOR_NAME"))
+		author_ident_explicitly_given |= IDENT_NAME_GIVEN;
+	if (getenv("GIT_AUTHOR_EMAIL"))
+		author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
+	return fmt_ident(getenv("GIT_AUTHOR_NAME"),
+			 getenv("GIT_AUTHOR_EMAIL"),
+			 WANT_AUTHOR_IDENT,
+			 getenv("GIT_AUTHOR_DATE"),
+			 flag);
+}
+
+const char *git_committer_info(int flag)
+{
+	if (getenv("GIT_COMMITTER_NAME"))
+		committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
+	if (getenv("GIT_COMMITTER_EMAIL"))
+		committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
+	return fmt_ident(getenv("GIT_COMMITTER_NAME"),
+			 getenv("GIT_COMMITTER_EMAIL"),
+			 WANT_COMMITTER_IDENT,
+			 getenv("GIT_COMMITTER_DATE"),
+			 flag);
+}
+
+static int ident_is_sufficient(int user_ident_explicitly_given)
+{
+#ifndef WINDOWS
+	return (user_ident_explicitly_given & IDENT_MAIL_GIVEN);
+#else
+	return (user_ident_explicitly_given == IDENT_ALL_GIVEN);
+#endif
+}
+
+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);
+}
+
+static int set_ident(const char *var, const char *value)
+{
+	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;
+		return 0;
+	}
+
+	if (!strcmp(var, "user.name")) {
+		if (!value)
+			return config_error_nonbool(var);
+		strbuf_reset(&git_default_name);
+		strbuf_addstr(&git_default_name, value);
+		committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
+		author_ident_explicitly_given |= IDENT_NAME_GIVEN;
+		ident_config_given |= IDENT_NAME_GIVEN;
+		return 0;
+	}
+
+	if (!strcmp(var, "user.email")) {
+		if (!value)
+			return config_error_nonbool(var);
+		strbuf_reset(&git_default_email);
+		strbuf_addstr(&git_default_email, value);
+		committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
+		author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
+		ident_config_given |= IDENT_MAIL_GIVEN;
+		return 0;
+	}
+
+	return 0;
+}
+
+int git_ident_config(const char *var, const char *value,
+		     const struct config_context *ctx UNUSED,
+		     void *data UNUSED)
+{
+	if (!strcmp(var, "user.useconfigonly")) {
+		ident_use_config_only = git_config_bool(var, value);
+		return 0;
+	}
+
+	return set_ident(var, value);
+}
+
+static void set_env_if(const char *key, const char *value, int *given, int bit)
+{
+	if ((*given & bit) || getenv(key))
+		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);
+}
+
+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);
+}