ident.c

   1 /*
   2  * ident.c
   3  *
   4  * create git identifier lines of the form "name <email> date"
   5  *
   6  * Copyright (C) 2005 Linus Torvalds
   7  */
   8 #include "cache.h"
   9 #include "config.h"
  10 #include "date.h"
  11
  12 static struct strbuf git_default_name = STRBUF_INIT;
  13 static struct strbuf git_default_email = STRBUF_INIT;
  14 static struct strbuf git_default_date = STRBUF_INIT;
  15 static struct strbuf git_author_name = STRBUF_INIT;
  16 static struct strbuf git_author_email = STRBUF_INIT;
  17 static struct strbuf git_committer_name = STRBUF_INIT;
  18 static struct strbuf git_committer_email = STRBUF_INIT;
  19 static int default_email_is_bogus;
  20 static int default_name_is_bogus;
  21
  22 static int ident_use_config_only;
  23
  24 #define IDENT_NAME_GIVEN 01
  25 #define IDENT_MAIL_GIVEN 02
  26 #define IDENT_ALL_GIVEN (IDENT_NAME_GIVEN|IDENT_MAIL_GIVEN)
  27 static int committer_ident_explicitly_given;
  28 static int author_ident_explicitly_given;
  29 static int ident_config_given;
  30
  31 #ifdef NO_GECOS_IN_PWENT
  32 #define get_gecos(ignored) "&"
  33 #else
  34 #define get_gecos(struct_passwd) ((struct_passwd)->pw_gecos)
  35 #endif
  36
  37 static struct passwd *xgetpwuid_self(int *is_bogus)
  38 {
  39         struct passwd *pw;
  40
  41         errno = 0;
  42         pw = getpwuid(getuid());
  43         if (!pw) {
  44                 static struct passwd fallback;
  45                 fallback.pw_name = "unknown";
  46 #ifndef NO_GECOS_IN_PWENT
  47                 fallback.pw_gecos = "Unknown";
  48 #endif
  49                 pw = &fallback;
  50                 if (is_bogus)
  51                         *is_bogus = 1;
  52         }
  53         return pw;
  54 }
  55
  56 static void copy_gecos(const struct passwd *w, struct strbuf *name)
  57 {
  58         char *src;
  59
  60         /* Traditionally GECOS field had office phone numbers etc, separated
  61          * with commas.  Also & stands for capitalized form of the login name.
  62          */
  63
  64         for (src = get_gecos(w); *src && *src != ','; src++) {
  65                 int ch = *src;
  66                 if (ch != '&')
  67                         strbuf_addch(name, ch);
  68                 else {
  69                         /* Sorry, Mr. McDonald... */
  70                         strbuf_addch(name, toupper(*w->pw_name));
  71                         strbuf_addstr(name, w->pw_name + 1);
  72                 }
  73         }
  74 }
  75
  76 static int add_mailname_host(struct strbuf *buf)
  77 {
  78         FILE *mailname;
  79         struct strbuf mailnamebuf = STRBUF_INIT;
  80
  81         mailname = fopen_or_warn("/etc/mailname", "r");
  82         if (!mailname)
  83                 return -1;
  84
  85         if (strbuf_getline(&mailnamebuf, mailname) == EOF) {
  86                 if (ferror(mailname))
  87                         warning_errno("cannot read /etc/mailname");
  88                 strbuf_release(&mailnamebuf);
  89                 fclose(mailname);
  90                 return -1;
  91         }
  92         /* success! */
  93         strbuf_addbuf(buf, &mailnamebuf);
  94         strbuf_release(&mailnamebuf);
  95         fclose(mailname);
  96         return 0;
  97 }
  98
  99 static int canonical_name(const char *host, struct strbuf *out)
 100 {
 101         int status = -1;
 102
 103 #ifndef NO_IPV6
 104         struct addrinfo hints, *ai;
 105         memset (&hints, '\0', sizeof (hints));
 106         hints.ai_flags = AI_CANONNAME;
 107         if (!getaddrinfo(host, NULL, &hints, &ai)) {
 108                 if (ai && ai->ai_canonname && strchr(ai->ai_canonname, '.')) {
 109                         strbuf_addstr(out, ai->ai_canonname);
 110                         status = 0;
 111                 }
 112                 freeaddrinfo(ai);
 113         }
 114 #else
 115         struct hostent *he = gethostbyname(host);
 116         if (he && strchr(he->h_name, '.')) {
 117                 strbuf_addstr(out, he->h_name);
 118                 status = 0;
 119         }
 120 #endif /* NO_IPV6 */
 121
 122         return status;
 123 }
 124
 125 static void add_domainname(struct strbuf *out, int *is_bogus)
 126 {
 127         char buf[HOST_NAME_MAX + 1];
 128
 129         if (xgethostname(buf, sizeof(buf))) {
 130                 warning_errno("cannot get host name");
 131                 strbuf_addstr(out, "(none)");
 132                 *is_bogus = 1;
 133                 return;
 134         }
 135         if (strchr(buf, '.'))
 136                 strbuf_addstr(out, buf);
 137         else if (canonical_name(buf, out) < 0) {
 138                 strbuf_addf(out, "%s.(none)", buf);
 139                 *is_bogus = 1;
 140         }
 141 }
 142
 143 static void copy_email(const struct passwd *pw, struct strbuf *email,
 144                        int *is_bogus)
 145 {
 146         /*
 147          * Make up a fake email address
 148          * (name + '@' + hostname [+ '.' + domainname])
 149          */
 150         strbuf_addstr(email, pw->pw_name);
 151         strbuf_addch(email, '@');
 152
 153         if (!add_mailname_host(email))
 154                 return; /* read from "/etc/mailname" (Debian) */
 155         add_domainname(email, is_bogus);
 156 }
 157
 158 const char *ident_default_name(void)
 159 {
 160         if (!(ident_config_given & IDENT_NAME_GIVEN) && !git_default_name.len) {
 161                 copy_gecos(xgetpwuid_self(&default_name_is_bogus), &git_default_name);
 162                 strbuf_trim(&git_default_name);
 163         }
 164         return git_default_name.buf;
 165 }
 166
 167 const char *ident_default_email(void)
 168 {
 169         if (!(ident_config_given & IDENT_MAIL_GIVEN) && !git_default_email.len) {
 170                 const char *email = getenv("EMAIL");
 171
 172                 if (email && email[0]) {
 173                         strbuf_addstr(&git_default_email, email);
 174                         committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 175                         author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 176                 } else if ((email = query_user_email()) && email[0]) {
 177                         strbuf_addstr(&git_default_email, email);
 178                         free((char *)email);
 179                 } else
 180                         copy_email(xgetpwuid_self(&default_email_is_bogus),
 181                                    &git_default_email, &default_email_is_bogus);
 182                 strbuf_trim(&git_default_email);
 183         }
 184         return git_default_email.buf;
 185 }
 186
 187 static const char *ident_default_date(void)
 188 {
 189         if (!git_default_date.len)
 190                 datestamp(&git_default_date);
 191         return git_default_date.buf;
 192 }
 193
 194 void reset_ident_date(void)
 195 {
 196         strbuf_reset(&git_default_date);
 197 }
 198
 199 static int crud(unsigned char c)
 200 {
 201         return  c <= 32  ||
 202                 c == '.' ||
 203                 c == ',' ||
 204                 c == ':' ||
 205                 c == ';' ||
 206                 c == '<' ||
 207                 c == '>' ||
 208                 c == '"' ||
 209                 c == '\\' ||
 210                 c == '\'';
 211 }
 212
 213 static int has_non_crud(const char *str)
 214 {
 215         for (; *str; str++) {
 216                 if (!crud(*str))
 217                         return 1;
 218         }
 219         return 0;
 220 }
 221
 222 /*
 223  * Copy over a string to the destination, but avoid special
 224  * characters ('\n', '<' and '>') and remove crud at the end
 225  */
 226 static void strbuf_addstr_without_crud(struct strbuf *sb, const char *src)
 227 {
 228         size_t i, len;
 229         unsigned char c;
 230
 231         /* Remove crud from the beginning.. */
 232         while ((c = *src) != 0) {
 233                 if (!crud(c))
 234                         break;
 235                 src++;
 236         }
 237
 238         /* Remove crud from the end.. */
 239         len = strlen(src);
 240         while (len > 0) {
 241                 c = src[len-1];
 242                 if (!crud(c))
 243                         break;
 244                 --len;
 245         }
 246
 247         /*
 248          * Copy the rest to the buffer, but avoid the special
 249          * characters '\n' '<' and '>' that act as delimiters on
 250          * an identification line. We can only remove crud, never add it,
 251          * so 'len' is our maximum.
 252          */
 253         strbuf_grow(sb, len);
 254         for (i = 0; i < len; i++) {
 255                 c = *src++;
 256                 switch (c) {
 257                 case '\n': case '<': case '>':
 258                         continue;
 259                 }
 260                 sb->buf[sb->len++] = c;
 261         }
 262         sb->buf[sb->len] = '\0';
 263 }
 264
 265 /*
 266  * Reverse of fmt_ident(); given an ident line, split the fields
 267  * to allow the caller to parse it.
 268  * Signal a success by returning 0, but date/tz fields of the result
 269  * can still be NULL if the input line only has the name/email part
 270  * (e.g. reading from a reflog entry).
 271  */
 272 int split_ident_line(struct ident_split *split, const char *line, int len)
 273 {
 274         const char *cp;
 275         size_t span;
 276         int status = -1;
 277
 278         memset(split, 0, sizeof(*split));
 279
 280         split->name_begin = line;
 281         for (cp = line; *cp && cp < line + len; cp++)
 282                 if (*cp == '<') {
 283                         split->mail_begin = cp + 1;
 284                         break;
 285                 }
 286         if (!split->mail_begin)
 287                 return status;
 288
 289         for (cp = split->mail_begin - 2; line <= cp; cp--)
 290                 if (!isspace(*cp)) {
 291                         split->name_end = cp + 1;
 292                         break;
 293                 }
 294         if (!split->name_end) {
 295                 /* no human readable name */
 296                 split->name_end = split->name_begin;
 297         }
 298
 299         for (cp = split->mail_begin; cp < line + len; cp++)
 300                 if (*cp == '>') {
 301                         split->mail_end = cp;
 302                         break;
 303                 }
 304         if (!split->mail_end)
 305                 return status;
 306
 307         /*
 308          * Look from the end-of-line to find the trailing ">" of the mail
 309          * address, even though we should already know it as split->mail_end.
 310          * This can help in cases of broken idents with an extra ">" somewhere
 311          * in the email address.  Note that we are assuming the timestamp will
 312          * never have a ">" in it.
 313          *
 314          * Note that we will always find some ">" before going off the front of
 315          * the string, because will always hit the split->mail_end closing
 316          * bracket.
 317          */
 318         for (cp = line + len - 1; *cp != '>'; cp--)
 319                 ;
 320
 321         for (cp = cp + 1; cp < line + len && isspace(*cp); cp++)
 322                 ;
 323         if (line + len <= cp)
 324                 goto person_only;
 325         split->date_begin = cp;
 326         span = strspn(cp, "0123456789");
 327         if (!span)
 328                 goto person_only;
 329         split->date_end = split->date_begin + span;
 330         for (cp = split->date_end; cp < line + len && isspace(*cp); cp++)
 331                 ;
 332         if (line + len <= cp || (*cp != '+' && *cp != '-'))
 333                 goto person_only;
 334         split->tz_begin = cp;
 335         span = strspn(cp + 1, "0123456789");
 336         if (!span)
 337                 goto person_only;
 338         split->tz_end = split->tz_begin + 1 + span;
 339         return 0;
 340
 341 person_only:
 342         split->date_begin = NULL;
 343         split->date_end = NULL;
 344         split->tz_begin = NULL;
 345         split->tz_end = NULL;
 346         return 0;
 347 }
 348
 349
 350 static void ident_env_hint(enum want_ident whose_ident)
 351 {
 352         switch (whose_ident) {
 353         case WANT_AUTHOR_IDENT:
 354                 fputs(_("Author identity unknown\n"), stderr);
 355                 break;
 356         case WANT_COMMITTER_IDENT:
 357                 fputs(_("Committer identity unknown\n"), stderr);
 358                 break;
 359         default:
 360                 break;
 361         }
 362
 363         fputs(_("\n"
 364                 "*** Please tell me who you are.\n"
 365                 "\n"
 366                 "Run\n"
 367                 "\n"
 368                 "  git config --global user.email \"you@example.com\"\n"
 369                 "  git config --global user.name \"Your Name\"\n"
 370                 "\n"
 371                 "to set your account\'s default identity.\n"
 372                 "Omit --global to set the identity only in this repository.\n"
 373                 "\n"), stderr);
 374 }
 375
 376 const char *fmt_ident(const char *name, const char *email,
 377                       enum want_ident whose_ident, const char *date_str, int flag)
 378 {
 379         static int index;
 380         static struct strbuf ident_pool[2] = { STRBUF_INIT, STRBUF_INIT };
 381         int strict = (flag & IDENT_STRICT);
 382         int want_date = !(flag & IDENT_NO_DATE);
 383         int want_name = !(flag & IDENT_NO_NAME);
 384
 385         struct strbuf *ident = &ident_pool[index];
 386         index = (index + 1) % ARRAY_SIZE(ident_pool);
 387
 388         if (!email) {
 389                 if (whose_ident == WANT_AUTHOR_IDENT && git_author_email.len)
 390                         email = git_author_email.buf;
 391                 else if (whose_ident == WANT_COMMITTER_IDENT && git_committer_email.len)
 392                         email = git_committer_email.buf;
 393         }
 394         if (!email) {
 395                 if (strict && ident_use_config_only
 396                     && !(ident_config_given & IDENT_MAIL_GIVEN)) {
 397                         ident_env_hint(whose_ident);
 398                         die(_("no email was given and auto-detection is disabled"));
 399                 }
 400                 email = ident_default_email();
 401                 if (strict && default_email_is_bogus) {
 402                         ident_env_hint(whose_ident);
 403                         die(_("unable to auto-detect email address (got '%s')"), email);
 404                 }
 405         }
 406
 407         if (want_name) {
 408                 int using_default = 0;
 409                 if (!name) {
 410                         if (whose_ident == WANT_AUTHOR_IDENT && git_author_name.len)
 411                                 name = git_author_name.buf;
 412                         else if (whose_ident == WANT_COMMITTER_IDENT &&
 413                                         git_committer_name.len)
 414                                 name = git_committer_name.buf;
 415                 }
 416                 if (!name) {
 417                         if (strict && ident_use_config_only
 418                             && !(ident_config_given & IDENT_NAME_GIVEN)) {
 419                                 ident_env_hint(whose_ident);
 420                                 die(_("no name was given and auto-detection is disabled"));
 421                         }
 422                         name = ident_default_name();
 423                         using_default = 1;
 424                         if (strict && default_name_is_bogus) {
 425                                 ident_env_hint(whose_ident);
 426                                 die(_("unable to auto-detect name (got '%s')"), name);
 427                         }
 428                 }
 429                 if (!*name) {
 430                         struct passwd *pw;
 431                         if (strict) {
 432                                 if (using_default)
 433                                         ident_env_hint(whose_ident);
 434                                 die(_("empty ident name (for <%s>) not allowed"), email);
 435                         }
 436                         pw = xgetpwuid_self(NULL);
 437                         name = pw->pw_name;
 438                 }
 439                 if (strict && !has_non_crud(name))
 440                         die(_("name consists only of disallowed characters: %s"), name);
 441         }
 442
 443         strbuf_reset(ident);
 444         if (want_name) {
 445                 strbuf_addstr_without_crud(ident, name);
 446                 strbuf_addstr(ident, " <");
 447         }
 448         strbuf_addstr_without_crud(ident, email);
 449         if (want_name)
 450                 strbuf_addch(ident, '>');
 451         if (want_date) {
 452                 strbuf_addch(ident, ' ');
 453                 if (date_str && date_str[0]) {
 454                         if (parse_date(date_str, ident) < 0)
 455                                 die(_("invalid date format: %s"), date_str);
 456                 }
 457                 else
 458                         strbuf_addstr(ident, ident_default_date());
 459         }
 460
 461         return ident->buf;
 462 }
 463
 464 const char *fmt_name(enum want_ident whose_ident)
 465 {
 466         char *name = NULL;
 467         char *email = NULL;
 468
 469         switch (whose_ident) {
 470         case WANT_BLANK_IDENT:
 471                 break;
 472         case WANT_AUTHOR_IDENT:
 473                 name = getenv("GIT_AUTHOR_NAME");
 474                 email = getenv("GIT_AUTHOR_EMAIL");
 475                 break;
 476         case WANT_COMMITTER_IDENT:
 477                 name = getenv("GIT_COMMITTER_NAME");
 478                 email = getenv("GIT_COMMITTER_EMAIL");
 479                 break;
 480         }
 481         return fmt_ident(name, email, whose_ident, NULL,
 482                         IDENT_STRICT | IDENT_NO_DATE);
 483 }
 484
 485 const char *git_author_info(int flag)
 486 {
 487         if (getenv("GIT_AUTHOR_NAME"))
 488                 author_ident_explicitly_given |= IDENT_NAME_GIVEN;
 489         if (getenv("GIT_AUTHOR_EMAIL"))
 490                 author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 491         return fmt_ident(getenv("GIT_AUTHOR_NAME"),
 492                          getenv("GIT_AUTHOR_EMAIL"),
 493                          WANT_AUTHOR_IDENT,
 494                          getenv("GIT_AUTHOR_DATE"),
 495                          flag);
 496 }
 497
 498 const char *git_committer_info(int flag)
 499 {
 500         if (getenv("GIT_COMMITTER_NAME"))
 501                 committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
 502         if (getenv("GIT_COMMITTER_EMAIL"))
 503                 committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 504         return fmt_ident(getenv("GIT_COMMITTER_NAME"),
 505                          getenv("GIT_COMMITTER_EMAIL"),
 506                          WANT_COMMITTER_IDENT,
 507                          getenv("GIT_COMMITTER_DATE"),
 508                          flag);
 509 }
 510
 511 static int ident_is_sufficient(int user_ident_explicitly_given)
 512 {
 513 #ifndef WINDOWS
 514         return (user_ident_explicitly_given & IDENT_MAIL_GIVEN);
 515 #else
 516         return (user_ident_explicitly_given == IDENT_ALL_GIVEN);
 517 #endif
 518 }
 519
 520 int committer_ident_sufficiently_given(void)
 521 {
 522         return ident_is_sufficient(committer_ident_explicitly_given);
 523 }
 524
 525 int author_ident_sufficiently_given(void)
 526 {
 527         return ident_is_sufficient(author_ident_explicitly_given);
 528 }
 529
 530 static int set_ident(const char *var, const char *value)
 531 {
 532         if (!strcmp(var, "author.name")) {
 533                 if (!value)
 534                         return config_error_nonbool(var);
 535                 strbuf_reset(&git_author_name);
 536                 strbuf_addstr(&git_author_name, value);
 537                 author_ident_explicitly_given |= IDENT_NAME_GIVEN;
 538                 ident_config_given |= IDENT_NAME_GIVEN;
 539                 return 0;
 540         }
 541
 542         if (!strcmp(var, "author.email")) {
 543                 if (!value)
 544                         return config_error_nonbool(var);
 545                 strbuf_reset(&git_author_email);
 546                 strbuf_addstr(&git_author_email, value);
 547                 author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 548                 ident_config_given |= IDENT_MAIL_GIVEN;
 549                 return 0;
 550         }
 551
 552         if (!strcmp(var, "committer.name")) {
 553                 if (!value)
 554                         return config_error_nonbool(var);
 555                 strbuf_reset(&git_committer_name);
 556                 strbuf_addstr(&git_committer_name, value);
 557                 committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
 558                 ident_config_given |= IDENT_NAME_GIVEN;
 559                 return 0;
 560         }
 561
 562         if (!strcmp(var, "committer.email")) {
 563                 if (!value)
 564                         return config_error_nonbool(var);
 565                 strbuf_reset(&git_committer_email);
 566                 strbuf_addstr(&git_committer_email, value);
 567                 committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 568                 ident_config_given |= IDENT_MAIL_GIVEN;
 569                 return 0;
 570         }
 571
 572         if (!strcmp(var, "user.name")) {
 573                 if (!value)
 574                         return config_error_nonbool(var);
 575                 strbuf_reset(&git_default_name);
 576                 strbuf_addstr(&git_default_name, value);
 577                 committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
 578                 author_ident_explicitly_given |= IDENT_NAME_GIVEN;
 579                 ident_config_given |= IDENT_NAME_GIVEN;
 580                 return 0;
 581         }
 582
 583         if (!strcmp(var, "user.email")) {
 584                 if (!value)
 585                         return config_error_nonbool(var);
 586                 strbuf_reset(&git_default_email);
 587                 strbuf_addstr(&git_default_email, value);
 588                 committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 589                 author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 590                 ident_config_given |= IDENT_MAIL_GIVEN;
 591                 return 0;
 592         }
 593
 594         return 0;
 595 }
 596
 597 int git_ident_config(const char *var, const char *value, void *data)
 598 {
 599         if (!strcmp(var, "user.useconfigonly")) {
 600                 ident_use_config_only = git_config_bool(var, value);
 601                 return 0;
 602         }
 603
 604         return set_ident(var, value);
 605 }
 606
 607 static void set_env_if(const char *key, const char *value, int *given, int bit)
 608 {
 609         if ((*given & bit) || getenv(key))
 610                 return; /* nothing to do */
 611         setenv(key, value, 0);
 612         *given |= bit;
 613 }
 614
 615 void prepare_fallback_ident(const char *name, const char *email)
 616 {
 617         set_env_if("GIT_AUTHOR_NAME", name,
 618                    &author_ident_explicitly_given, IDENT_NAME_GIVEN);
 619         set_env_if("GIT_AUTHOR_EMAIL", email,
 620                    &author_ident_explicitly_given, IDENT_MAIL_GIVEN);
 621         set_env_if("GIT_COMMITTER_NAME", name,
 622                    &committer_ident_explicitly_given, IDENT_NAME_GIVEN);
 623         set_env_if("GIT_COMMITTER_EMAIL", email,
 624                    &committer_ident_explicitly_given, IDENT_MAIL_GIVEN);
 625 }
 626
 627 static int buf_cmp(const char *a_begin, const char *a_end,
 628                    const char *b_begin, const char *b_end)
 629 {
 630         int a_len = a_end - a_begin;
 631         int b_len = b_end - b_begin;
 632         int min = a_len < b_len ? a_len : b_len;
 633         int cmp;
 634
 635         cmp = memcmp(a_begin, b_begin, min);
 636         if (cmp)
 637                 return cmp;
 638
 639         return a_len - b_len;
 640 }
 641
 642 int ident_cmp(const struct ident_split *a,
 643               const struct ident_split *b)
 644 {
 645         int cmp;
 646
 647         cmp = buf_cmp(a->mail_begin, a->mail_end,
 648                       b->mail_begin, b->mail_end);
 649         if (cmp)
 650                 return cmp;
 651
 652         return buf_cmp(a->name_begin, a->name_end,
 653                        b->name_begin, b->name_end);
 654 }