Andrew's git - gitweb.git/blob

   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
  10static char git_default_date[50];
  11
  12static void copy_gecos(const struct passwd *w, char *name, size_t sz)
  13{
  14        char *src, *dst;
  15        size_t len, nlen;
  16
  17        nlen = strlen(w->pw_name);
  18
  19        /* Traditionally GECOS field had office phone numbers etc, separated
  20         * with commas.  Also & stands for capitalized form of the login name.
  21         */
  22
  23        for (len = 0, dst = name, src = w->pw_gecos; len < sz; src++) {
  24                int ch = *src;
  25                if (ch != '&') {
  26                        *dst++ = ch;
  27                        if (ch == 0 || ch == ',')
  28                                break;
  29                        len++;
  30                        continue;
  31                }
  32                if (len + nlen < sz) {
  33                        /* Sorry, Mr. McDonald... */
  34                        *dst++ = toupper(*w->pw_name);
  35                        memcpy(dst, w->pw_name + 1, nlen - 1);
  36                        dst += nlen - 1;
  37                        len += nlen;
  38                }
  39        }
  40        if (len < sz)
  41                name[len] = 0;
  42        else
  43                die("Your parents must have hated you!");
  44
  45}
  46
  47static void copy_email(const struct passwd *pw)
  48{
  49        /*
  50         * Make up a fake email address
  51         * (name + '@' + hostname [+ '.' + domainname])
  52         */
  53        size_t len = strlen(pw->pw_name);
  54        if (len > sizeof(git_default_email)/2)
  55                die("Your sysadmin must hate you!");
  56        memcpy(git_default_email, pw->pw_name, len);
  57        git_default_email[len++] = '@';
  58        gethostname(git_default_email + len, sizeof(git_default_email) - len);
  59        if (!strchr(git_default_email+len, '.')) {
  60                struct hostent *he = gethostbyname(git_default_email + len);
  61                char *domainname;
  62
  63                len = strlen(git_default_email);
  64                git_default_email[len++] = '.';
  65                if (he && (domainname = strchr(he->h_name, '.')))
  66                        strlcpy(git_default_email + len, domainname + 1,
  67                                sizeof(git_default_email) - len);
  68                else
  69                        strlcpy(git_default_email + len, "(none)",
  70                                sizeof(git_default_email) - len);
  71        }
  72}
  73
  74static void setup_ident(void)
  75{
  76        struct passwd *pw = NULL;
  77
  78        /* Get the name ("gecos") */
  79        if (!git_default_name[0]) {
  80                pw = getpwuid(getuid());
  81                if (!pw)
  82                        die("You don't exist. Go away!");
  83                copy_gecos(pw, git_default_name, sizeof(git_default_name));
  84        }
  85
  86        if (!git_default_email[0]) {
  87                const char *email = getenv("EMAIL");
  88
  89                if (email && email[0]) {
  90                        strlcpy(git_default_email, email,
  91                                sizeof(git_default_email));
  92                        user_ident_explicitly_given |= IDENT_MAIL_GIVEN;
  93                } else {
  94                        if (!pw)
  95                                pw = getpwuid(getuid());
  96                        if (!pw)
  97                                die("You don't exist. Go away!");
  98                        copy_email(pw);
  99                }
 100        }
 101
 102        /* And set the default date */
 103        if (!git_default_date[0])
 104                datestamp(git_default_date, sizeof(git_default_date));
 105}
 106
 107static int add_raw(char *buf, size_t size, int offset, const char *str)
 108{
 109        size_t len = strlen(str);
 110        if (offset + len > size)
 111                return size;
 112        memcpy(buf + offset, str, len);
 113        return offset + len;
 114}
 115
 116static int crud(unsigned char c)
 117{
 118        return  c <= 32  ||
 119                c == '.' ||
 120                c == ',' ||
 121                c == ':' ||
 122                c == ';' ||
 123                c == '<' ||
 124                c == '>' ||
 125                c == '"' ||
 126                c == '\\' ||
 127                c == '\'';
 128}
 129
 130/*
 131 * Copy over a string to the destination, but avoid special
 132 * characters ('\n', '<' and '>') and remove crud at the end
 133 */
 134static int copy(char *buf, size_t size, int offset, const char *src)
 135{
 136        size_t i, len;
 137        unsigned char c;
 138
 139        /* Remove crud from the beginning.. */
 140        while ((c = *src) != 0) {
 141                if (!crud(c))
 142                        break;
 143                src++;
 144        }
 145
 146        /* Remove crud from the end.. */
 147        len = strlen(src);
 148        while (len > 0) {
 149                c = src[len-1];
 150                if (!crud(c))
 151                        break;
 152                --len;
 153        }
 154
 155        /*
 156         * Copy the rest to the buffer, but avoid the special
 157         * characters '\n' '<' and '>' that act as delimiters on
 158         * an identification line
 159         */
 160        for (i = 0; i < len; i++) {
 161                c = *src++;
 162                switch (c) {
 163                case '\n': case '<': case '>':
 164                        continue;
 165                }
 166                if (offset >= size)
 167                        return size;
 168                buf[offset++] = c;
 169        }
 170        return offset;
 171}
 172
 173static const char *env_hint =
 174"\n"
 175"*** Please tell me who you are.\n"
 176"\n"
 177"Run\n"
 178"\n"
 179"  git config --global user.email \"you@example.com\"\n"
 180"  git config --global user.name \"Your Name\"\n"
 181"\n"
 182"to set your account\'s default identity.\n"
 183"Omit --global to set the identity only in this repository.\n"
 184"\n";
 185
 186const char *fmt_ident(const char *name, const char *email,
 187                      const char *date_str, int flag)
 188{
 189        static char buffer[1000];
 190        char date[50];
 191        int i;
 192        int error_on_no_name = (flag & IDENT_ERROR_ON_NO_NAME);
 193        int warn_on_no_name = (flag & IDENT_WARN_ON_NO_NAME);
 194        int name_addr_only = (flag & IDENT_NO_DATE);
 195
 196        setup_ident();
 197        if (!name)
 198                name = git_default_name;
 199        if (!email)
 200                email = git_default_email;
 201
 202        if (!*name) {
 203                struct passwd *pw;
 204
 205                if ((warn_on_no_name || error_on_no_name) &&
 206                    name == git_default_name && env_hint) {
 207                        fputs(env_hint, stderr);
 208                        env_hint = NULL; /* warn only once */
 209                }
 210                if (error_on_no_name)
 211                        die("empty ident %s <%s> not allowed", name, email);
 212                pw = getpwuid(getuid());
 213                if (!pw)
 214                        die("You don't exist. Go away!");
 215                strlcpy(git_default_name, pw->pw_name,
 216                        sizeof(git_default_name));
 217                name = git_default_name;
 218        }
 219
 220        strcpy(date, git_default_date);
 221        if (!name_addr_only && date_str && date_str[0]) {
 222                if (parse_date(date_str, date, sizeof(date)) < 0)
 223                        die("invalid date format: %s", date_str);
 224        }
 225
 226        i = copy(buffer, sizeof(buffer), 0, name);
 227        i = add_raw(buffer, sizeof(buffer), i, " <");
 228        i = copy(buffer, sizeof(buffer), i, email);
 229        if (!name_addr_only) {
 230                i = add_raw(buffer, sizeof(buffer), i,  "> ");
 231                i = copy(buffer, sizeof(buffer), i, date);
 232        } else {
 233                i = add_raw(buffer, sizeof(buffer), i, ">");
 234        }
 235        if (i >= sizeof(buffer))
 236                die("Impossibly long personal identifier");
 237        buffer[i] = 0;
 238        return buffer;
 239}
 240
 241const char *fmt_name(const char *name, const char *email)
 242{
 243        return fmt_ident(name, email, NULL, IDENT_ERROR_ON_NO_NAME | IDENT_NO_DATE);
 244}
 245
 246const char *git_author_info(int flag)
 247{
 248        return fmt_ident(getenv("GIT_AUTHOR_NAME"),
 249                         getenv("GIT_AUTHOR_EMAIL"),
 250                         getenv("GIT_AUTHOR_DATE"),
 251                         flag);
 252}
 253
 254const char *git_committer_info(int flag)
 255{
 256        if (getenv("GIT_COMMITTER_NAME"))
 257                user_ident_explicitly_given |= IDENT_NAME_GIVEN;
 258        if (getenv("GIT_COMMITTER_EMAIL"))
 259                user_ident_explicitly_given |= IDENT_MAIL_GIVEN;
 260        return fmt_ident(getenv("GIT_COMMITTER_NAME"),
 261                         getenv("GIT_COMMITTER_EMAIL"),
 262                         getenv("GIT_COMMITTER_DATE"),
 263                         flag);
 264}
 265
 266int user_ident_sufficiently_given(void)
 267{
 268#ifndef WINDOWS
 269        return (user_ident_explicitly_given & IDENT_MAIL_GIVEN);
 270#else
 271        return (user_ident_explicitly_given == IDENT_ALL_GIVEN);
 272#endif
 273}