Andrew's git - gitweb.git/blob

acb3a0843f40a10a730a80e7fcbf896660184a42
   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
  10#define MAX_GITNAME (1000)
  11static char git_default_name[MAX_GITNAME];
  12static char git_default_email[MAX_GITNAME];
  13static char git_default_date[50];
  14int user_ident_explicitly_given;
  15
  16#ifdef NO_GECOS_IN_PWENT
  17#define get_gecos(ignored) "&"
  18#else
  19#define get_gecos(struct_passwd) ((struct_passwd)->pw_gecos)
  20#endif
  21
  22static void copy_gecos(const struct passwd *w, char *name, size_t sz)
  23{
  24        char *src, *dst;
  25        size_t len, nlen;
  26
  27        nlen = strlen(w->pw_name);
  28
  29        /* Traditionally GECOS field had office phone numbers etc, separated
  30         * with commas.  Also & stands for capitalized form of the login name.
  31         */
  32
  33        for (len = 0, dst = name, src = get_gecos(w); len < sz; src++) {
  34                int ch = *src;
  35                if (ch != '&') {
  36                        *dst++ = ch;
  37                        if (ch == 0 || ch == ',')
  38                                break;
  39                        len++;
  40                        continue;
  41                }
  42                if (len + nlen < sz) {
  43                        /* Sorry, Mr. McDonald... */
  44                        *dst++ = toupper(*w->pw_name);
  45                        memcpy(dst, w->pw_name + 1, nlen - 1);
  46                        dst += nlen - 1;
  47                        len += nlen;
  48                }
  49        }
  50        if (len < sz)
  51                name[len] = 0;
  52        else
  53                die("Your parents must have hated you!");
  54
  55}
  56
  57static int add_mailname_host(char *buf, size_t len)
  58{
  59        FILE *mailname;
  60
  61        mailname = fopen("/etc/mailname", "r");
  62        if (!mailname) {
  63                if (errno != ENOENT)
  64                        warning("cannot open /etc/mailname: %s",
  65                                strerror(errno));
  66                return -1;
  67        }
  68        if (!fgets(buf, len, mailname)) {
  69                if (ferror(mailname))
  70                        warning("cannot read /etc/mailname: %s",
  71                                strerror(errno));
  72                fclose(mailname);
  73                return -1;
  74        }
  75        /* success! */
  76        fclose(mailname);
  77
  78        len = strlen(buf);
  79        if (len && buf[len-1] == '\n')
  80                buf[len-1] = '\0';
  81        return 0;
  82}
  83
  84static void add_domainname(char *buf, size_t len)
  85{
  86        struct hostent *he;
  87        size_t namelen;
  88        const char *domainname;
  89
  90        if (gethostname(buf, len)) {
  91                warning("cannot get host name: %s", strerror(errno));
  92                strlcpy(buf, "(none)", len);
  93                return;
  94        }
  95        namelen = strlen(buf);
  96        if (memchr(buf, '.', namelen))
  97                return;
  98
  99        he = gethostbyname(buf);
 100        buf[namelen++] = '.';
 101        buf += namelen;
 102        len -= namelen;
 103        if (he && (domainname = strchr(he->h_name, '.')))
 104                strlcpy(buf, domainname + 1, len);
 105        else
 106                strlcpy(buf, "(none)", len);
 107}
 108
 109static void copy_email(const struct passwd *pw)
 110{
 111        /*
 112         * Make up a fake email address
 113         * (name + '@' + hostname [+ '.' + domainname])
 114         */
 115        size_t len = strlen(pw->pw_name);
 116        if (len > sizeof(git_default_email)/2)
 117                die("Your sysadmin must hate you!");
 118        memcpy(git_default_email, pw->pw_name, len);
 119        git_default_email[len++] = '@';
 120
 121        if (!add_mailname_host(git_default_email + len,
 122                                sizeof(git_default_email) - len))
 123                return; /* read from "/etc/mailname" (Debian) */
 124        add_domainname(git_default_email + len,
 125                        sizeof(git_default_email) - len);
 126}
 127
 128const char *ident_default_name(void)
 129{
 130        if (!git_default_name[0]) {
 131                struct passwd *pw = getpwuid(getuid());
 132                if (!pw)
 133                        die("You don't exist. Go away!");
 134                copy_gecos(pw, git_default_name, sizeof(git_default_name));
 135        }
 136        return git_default_name;
 137}
 138
 139const char *ident_default_email(void)
 140{
 141        if (!git_default_email[0]) {
 142                const char *email = getenv("EMAIL");
 143
 144                if (email && email[0]) {
 145                        strlcpy(git_default_email, email,
 146                                sizeof(git_default_email));
 147                        user_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 148                } else {
 149                        struct passwd *pw = getpwuid(getuid());
 150                        if (!pw)
 151                                die("You don't exist. Go away!");
 152                        copy_email(pw);
 153                }
 154        }
 155        return git_default_email;
 156}
 157
 158const char *ident_default_date(void)
 159{
 160        if (!git_default_date[0])
 161                datestamp(git_default_date, sizeof(git_default_date));
 162        return git_default_date;
 163}
 164
 165static int add_raw(char *buf, size_t size, int offset, const char *str)
 166{
 167        size_t len = strlen(str);
 168        if (offset + len > size)
 169                return size;
 170        memcpy(buf + offset, str, len);
 171        return offset + len;
 172}
 173
 174static int crud(unsigned char c)
 175{
 176        return  c <= 32  ||
 177                c == '.' ||
 178                c == ',' ||
 179                c == ':' ||
 180                c == ';' ||
 181                c == '<' ||
 182                c == '>' ||
 183                c == '"' ||
 184                c == '\\' ||
 185                c == '\'';
 186}
 187
 188/*
 189 * Copy over a string to the destination, but avoid special
 190 * characters ('\n', '<' and '>') and remove crud at the end
 191 */
 192static int copy(char *buf, size_t size, int offset, const char *src)
 193{
 194        size_t i, len;
 195        unsigned char c;
 196
 197        /* Remove crud from the beginning.. */
 198        while ((c = *src) != 0) {
 199                if (!crud(c))
 200                        break;
 201                src++;
 202        }
 203
 204        /* Remove crud from the end.. */
 205        len = strlen(src);
 206        while (len > 0) {
 207                c = src[len-1];
 208                if (!crud(c))
 209                        break;
 210                --len;
 211        }
 212
 213        /*
 214         * Copy the rest to the buffer, but avoid the special
 215         * characters '\n' '<' and '>' that act as delimiters on
 216         * an identification line
 217         */
 218        for (i = 0; i < len; i++) {
 219                c = *src++;
 220                switch (c) {
 221                case '\n': case '<': case '>':
 222                        continue;
 223                }
 224                if (offset >= size)
 225                        return size;
 226                buf[offset++] = c;
 227        }
 228        return offset;
 229}
 230
 231/*
 232 * Reverse of fmt_ident(); given an ident line, split the fields
 233 * to allow the caller to parse it.
 234 * Signal a success by returning 0, but date/tz fields of the result
 235 * can still be NULL if the input line only has the name/email part
 236 * (e.g. reading from a reflog entry).
 237 */
 238int split_ident_line(struct ident_split *split, const char *line, int len)
 239{
 240        const char *cp;
 241        size_t span;
 242        int status = -1;
 243
 244        memset(split, 0, sizeof(*split));
 245
 246        split->name_begin = line;
 247        for (cp = line; *cp && cp < line + len; cp++)
 248                if (*cp == '<') {
 249                        split->mail_begin = cp + 1;
 250                        break;
 251                }
 252        if (!split->mail_begin)
 253                return status;
 254
 255        for (cp = split->mail_begin - 2; line < cp; cp--)
 256                if (!isspace(*cp)) {
 257                        split->name_end = cp + 1;
 258                        break;
 259                }
 260        if (!split->name_end)
 261                return status;
 262
 263        for (cp = split->mail_begin; cp < line + len; cp++)
 264                if (*cp == '>') {
 265                        split->mail_end = cp;
 266                        break;
 267                }
 268        if (!split->mail_end)
 269                return status;
 270
 271        for (cp = split->mail_end + 1; cp < line + len && isspace(*cp); cp++)
 272                ;
 273        if (line + len <= cp)
 274                goto person_only;
 275        split->date_begin = cp;
 276        span = strspn(cp, "0123456789");
 277        if (!span)
 278                goto person_only;
 279        split->date_end = split->date_begin + span;
 280        for (cp = split->date_end; cp < line + len && isspace(*cp); cp++)
 281                ;
 282        if (line + len <= cp || (*cp != '+' && *cp != '-'))
 283                goto person_only;
 284        split->tz_begin = cp;
 285        span = strspn(cp + 1, "0123456789");
 286        if (!span)
 287                goto person_only;
 288        split->tz_end = split->tz_begin + 1 + span;
 289        return 0;
 290
 291person_only:
 292        split->date_begin = NULL;
 293        split->date_end = NULL;
 294        split->tz_begin = NULL;
 295        split->tz_end = NULL;
 296        return 0;
 297}
 298
 299static const char *env_hint =
 300"\n"
 301"*** Please tell me who you are.\n"
 302"\n"
 303"Run\n"
 304"\n"
 305"  git config --global user.email \"you@example.com\"\n"
 306"  git config --global user.name \"Your Name\"\n"
 307"\n"
 308"to set your account\'s default identity.\n"
 309"Omit --global to set the identity only in this repository.\n"
 310"\n";
 311
 312const char *fmt_ident(const char *name, const char *email,
 313                      const char *date_str, int flag)
 314{
 315        static char buffer[1000];
 316        char date[50];
 317        int i;
 318        int error_on_no_name = (flag & IDENT_ERROR_ON_NO_NAME);
 319        int warn_on_no_name = (flag & IDENT_WARN_ON_NO_NAME);
 320        int name_addr_only = (flag & IDENT_NO_DATE);
 321
 322        if (!name)
 323                name = ident_default_name();
 324        if (!email)
 325                email = ident_default_email();
 326
 327        if (!*name) {
 328                struct passwd *pw;
 329
 330                if ((warn_on_no_name || error_on_no_name) &&
 331                    name == git_default_name && env_hint) {
 332                        fputs(env_hint, stderr);
 333                        env_hint = NULL; /* warn only once */
 334                }
 335                if (error_on_no_name)
 336                        die("empty ident %s <%s> not allowed", name, email);
 337                pw = getpwuid(getuid());
 338                if (!pw)
 339                        die("You don't exist. Go away!");
 340                strlcpy(git_default_name, pw->pw_name,
 341                        sizeof(git_default_name));
 342                name = git_default_name;
 343        }
 344
 345        strcpy(date, ident_default_date());
 346        if (!name_addr_only && date_str && date_str[0]) {
 347                if (parse_date(date_str, date, sizeof(date)) < 0)
 348                        die("invalid date format: %s", date_str);
 349        }
 350
 351        i = copy(buffer, sizeof(buffer), 0, name);
 352        i = add_raw(buffer, sizeof(buffer), i, " <");
 353        i = copy(buffer, sizeof(buffer), i, email);
 354        if (!name_addr_only) {
 355                i = add_raw(buffer, sizeof(buffer), i,  "> ");
 356                i = copy(buffer, sizeof(buffer), i, date);
 357        } else {
 358                i = add_raw(buffer, sizeof(buffer), i, ">");
 359        }
 360        if (i >= sizeof(buffer))
 361                die("Impossibly long personal identifier");
 362        buffer[i] = 0;
 363        return buffer;
 364}
 365
 366const char *fmt_name(const char *name, const char *email)
 367{
 368        return fmt_ident(name, email, NULL, IDENT_ERROR_ON_NO_NAME | IDENT_NO_DATE);
 369}
 370
 371const char *git_author_info(int flag)
 372{
 373        return fmt_ident(getenv("GIT_AUTHOR_NAME"),
 374                         getenv("GIT_AUTHOR_EMAIL"),
 375                         getenv("GIT_AUTHOR_DATE"),
 376                         flag);
 377}
 378
 379const char *git_committer_info(int flag)
 380{
 381        if (getenv("GIT_COMMITTER_NAME"))
 382                user_ident_explicitly_given |= IDENT_NAME_GIVEN;
 383        if (getenv("GIT_COMMITTER_EMAIL"))
 384                user_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 385        return fmt_ident(getenv("GIT_COMMITTER_NAME"),
 386                         getenv("GIT_COMMITTER_EMAIL"),
 387                         getenv("GIT_COMMITTER_DATE"),
 388                         flag);
 389}
 390
 391int user_ident_sufficiently_given(void)
 392{
 393#ifndef WINDOWS
 394        return (user_ident_explicitly_given & IDENT_MAIL_GIVEN);
 395#else
 396        return (user_ident_explicitly_given == IDENT_ALL_GIVEN);
 397#endif
 398}
 399
 400int git_ident_config(const char *var, const char *value, void *data)
 401{
 402        if (!strcmp(var, "user.name")) {
 403                if (!value)
 404                        return config_error_nonbool(var);
 405                strlcpy(git_default_name, value, sizeof(git_default_name));
 406                user_ident_explicitly_given |= IDENT_NAME_GIVEN;
 407                return 0;
 408        }
 409
 410        if (!strcmp(var, "user.email")) {
 411                if (!value)
 412                        return config_error_nonbool(var);
 413                strlcpy(git_default_email, value, sizeof(git_default_email));
 414                user_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 415                return 0;
 416        }
 417
 418        return 0;
 419}