mailmap.con commit Merge branch 'jk/vreport-sanitize' (daf75f2)
   1#include "cache.h"
   2#include "string-list.h"
   3#include "mailmap.h"
   4
   5#define DEBUG_MAILMAP 0
   6#if DEBUG_MAILMAP
   7#define debug_mm(...) fprintf(stderr, __VA_ARGS__)
   8#define debug_str(X) ((X) ? (X) : "(none)")
   9#else
  10static inline void debug_mm(const char *format, ...) {}
  11static inline const char *debug_str(const char *s) { return s; }
  12#endif
  13
  14const char *git_mailmap_file;
  15const char *git_mailmap_blob;
  16
  17struct mailmap_info {
  18        char *name;
  19        char *email;
  20};
  21
  22struct mailmap_entry {
  23        /* name and email for the simple mail-only case */
  24        char *name;
  25        char *email;
  26
  27        /* name and email for the complex mail and name matching case */
  28        struct string_list namemap;
  29};
  30
  31static void free_mailmap_info(void *p, const char *s)
  32{
  33        struct mailmap_info *mi = (struct mailmap_info *)p;
  34        debug_mm("mailmap: -- complex: '%s' -> '%s' <%s>\n",
  35                 s, debug_str(mi->name), debug_str(mi->email));
  36        free(mi->name);
  37        free(mi->email);
  38}
  39
  40static void free_mailmap_entry(void *p, const char *s)
  41{
  42        struct mailmap_entry *me = (struct mailmap_entry *)p;
  43        debug_mm("mailmap: removing entries for <%s>, with %d sub-entries\n",
  44                 s, me->namemap.nr);
  45        debug_mm("mailmap: - simple: '%s' <%s>\n",
  46                 debug_str(me->name), debug_str(me->email));
  47
  48        free(me->name);
  49        free(me->email);
  50
  51        me->namemap.strdup_strings = 1;
  52        string_list_clear_func(&me->namemap, free_mailmap_info);
  53}
  54
  55/*
  56 * On some systems (e.g. MinGW 4.0), string.h has _only_ inline
  57 * definition of strcasecmp and no non-inline implementation is
  58 * supplied anywhere, which is, eh, "unusual"; we cannot take an
  59 * address of such a function to store it in namemap.cmp.  This is
  60 * here as a workaround---do not assign strcasecmp directly to
  61 * namemap.cmp until we know no systems that matter have such an
  62 * "unusual" string.h.
  63 */
  64static int namemap_cmp(const char *a, const char *b)
  65{
  66        return strcasecmp(a, b);
  67}
  68
  69static void add_mapping(struct string_list *map,
  70                        char *new_name, char *new_email,
  71                        char *old_name, char *old_email)
  72{
  73        struct mailmap_entry *me;
  74        struct string_list_item *item;
  75
  76        if (old_email == NULL) {
  77                old_email = new_email;
  78                new_email = NULL;
  79        }
  80
  81        item = string_list_insert(map, old_email);
  82        if (item->util) {
  83                me = (struct mailmap_entry *)item->util;
  84        } else {
  85                me = xcalloc(1, sizeof(struct mailmap_entry));
  86                me->namemap.strdup_strings = 1;
  87                me->namemap.cmp = namemap_cmp;
  88                item->util = me;
  89        }
  90
  91        if (old_name == NULL) {
  92                debug_mm("mailmap: adding (simple) entry for '%s'\n", old_email);
  93
  94                /* Replace current name and new email for simple entry */
  95                if (new_name) {
  96                        free(me->name);
  97                        me->name = xstrdup(new_name);
  98                }
  99                if (new_email) {
 100                        free(me->email);
 101                        me->email = xstrdup(new_email);
 102                }
 103        } else {
 104                struct mailmap_info *mi = xcalloc(1, sizeof(struct mailmap_info));
 105                debug_mm("mailmap: adding (complex) entry for '%s'\n", old_email);
 106                mi->name = xstrdup_or_null(new_name);
 107                mi->email = xstrdup_or_null(new_email);
 108                string_list_insert(&me->namemap, old_name)->util = mi;
 109        }
 110
 111        debug_mm("mailmap:  '%s' <%s> -> '%s' <%s>\n",
 112                 debug_str(old_name), old_email,
 113                 debug_str(new_name), debug_str(new_email));
 114}
 115
 116static char *parse_name_and_email(char *buffer, char **name,
 117                                  char **email, int allow_empty_email)
 118{
 119        char *left, *right, *nstart, *nend;
 120        *name = *email = NULL;
 121
 122        if ((left = strchr(buffer, '<')) == NULL)
 123                return NULL;
 124        if ((right = strchr(left+1, '>')) == NULL)
 125                return NULL;
 126        if (!allow_empty_email && (left+1 == right))
 127                return NULL;
 128
 129        /* remove whitespace from beginning and end of name */
 130        nstart = buffer;
 131        while (isspace(*nstart) && nstart < left)
 132                ++nstart;
 133        nend = left-1;
 134        while (nend > nstart && isspace(*nend))
 135                --nend;
 136
 137        *name = (nstart <= nend ? nstart : NULL);
 138        *email = left+1;
 139        *(nend+1) = '\0';
 140        *right++ = '\0';
 141
 142        return (*right == '\0' ? NULL : right);
 143}
 144
 145static void read_mailmap_line(struct string_list *map, char *buffer,
 146                              char **repo_abbrev)
 147{
 148        char *name1 = NULL, *email1 = NULL, *name2 = NULL, *email2 = NULL;
 149        if (buffer[0] == '#') {
 150                static const char abbrev[] = "# repo-abbrev:";
 151                int abblen = sizeof(abbrev) - 1;
 152                int len = strlen(buffer);
 153
 154                if (!repo_abbrev)
 155                        return;
 156
 157                if (len && buffer[len - 1] == '\n')
 158                        buffer[--len] = 0;
 159                if (!strncmp(buffer, abbrev, abblen)) {
 160                        char *cp;
 161
 162                        free(*repo_abbrev);
 163
 164                        for (cp = buffer + abblen; isspace(*cp); cp++)
 165                                ; /* nothing */
 166                        *repo_abbrev = xstrdup(cp);
 167                }
 168                return;
 169        }
 170        if ((name2 = parse_name_and_email(buffer, &name1, &email1, 0)) != NULL)
 171                parse_name_and_email(name2, &name2, &email2, 1);
 172
 173        if (email1)
 174                add_mapping(map, name1, email1, name2, email2);
 175}
 176
 177static int read_mailmap_file(struct string_list *map, const char *filename,
 178                             char **repo_abbrev)
 179{
 180        char buffer[1024];
 181        FILE *f;
 182
 183        if (!filename)
 184                return 0;
 185
 186        f = fopen(filename, "r");
 187        if (!f) {
 188                if (errno == ENOENT)
 189                        return 0;
 190                return error_errno("unable to open mailmap at %s", filename);
 191        }
 192
 193        while (fgets(buffer, sizeof(buffer), f) != NULL)
 194                read_mailmap_line(map, buffer, repo_abbrev);
 195        fclose(f);
 196        return 0;
 197}
 198
 199static void read_mailmap_string(struct string_list *map, char *buf,
 200                                char **repo_abbrev)
 201{
 202        while (*buf) {
 203                char *end = strchrnul(buf, '\n');
 204
 205                if (*end)
 206                        *end++ = '\0';
 207
 208                read_mailmap_line(map, buf, repo_abbrev);
 209                buf = end;
 210        }
 211}
 212
 213static int read_mailmap_blob(struct string_list *map,
 214                             const char *name,
 215                             char **repo_abbrev)
 216{
 217        unsigned char sha1[20];
 218        char *buf;
 219        unsigned long size;
 220        enum object_type type;
 221
 222        if (!name)
 223                return 0;
 224        if (get_sha1(name, sha1) < 0)
 225                return 0;
 226
 227        buf = read_sha1_file(sha1, &type, &size);
 228        if (!buf)
 229                return error("unable to read mailmap object at %s", name);
 230        if (type != OBJ_BLOB)
 231                return error("mailmap is not a blob: %s", name);
 232
 233        read_mailmap_string(map, buf, repo_abbrev);
 234
 235        free(buf);
 236        return 0;
 237}
 238
 239int read_mailmap(struct string_list *map, char **repo_abbrev)
 240{
 241        int err = 0;
 242
 243        map->strdup_strings = 1;
 244        map->cmp = namemap_cmp;
 245
 246        if (!git_mailmap_blob && is_bare_repository())
 247                git_mailmap_blob = "HEAD:.mailmap";
 248
 249        err |= read_mailmap_file(map, ".mailmap", repo_abbrev);
 250        if (startup_info->have_repository)
 251                err |= read_mailmap_blob(map, git_mailmap_blob, repo_abbrev);
 252        err |= read_mailmap_file(map, git_mailmap_file, repo_abbrev);
 253        return err;
 254}
 255
 256void clear_mailmap(struct string_list *map)
 257{
 258        debug_mm("mailmap: clearing %d entries...\n", map->nr);
 259        map->strdup_strings = 1;
 260        string_list_clear_func(map, free_mailmap_entry);
 261        debug_mm("mailmap: cleared\n");
 262}
 263
 264/*
 265 * Look for an entry in map that match string[0:len]; string[len]
 266 * does not have to be NUL (but it could be).
 267 */
 268static struct string_list_item *lookup_prefix(struct string_list *map,
 269                                              const char *string, size_t len)
 270{
 271        int i = string_list_find_insert_index(map, string, 1);
 272        if (i < 0) {
 273                /* exact match */
 274                i = -1 - i;
 275                if (!string[len])
 276                        return &map->items[i];
 277                /*
 278                 * that map entry matches exactly to the string, including
 279                 * the cruft at the end beyond "len".  That is not a match
 280                 * with string[0:len] that we are looking for.
 281                 */
 282        } else if (!string[len]) {
 283                /*
 284                 * asked with the whole string, and got nothing.  No
 285                 * matching entry can exist in the map.
 286                 */
 287                return NULL;
 288        }
 289
 290        /*
 291         * i is at the exact match to an overlong key, or location the
 292         * overlong key would be inserted, which must come after the
 293         * real location of the key if one exists.
 294         */
 295        while (0 <= --i && i < map->nr) {
 296                int cmp = strncasecmp(map->items[i].string, string, len);
 297                if (cmp < 0)
 298                        /*
 299                         * "i" points at a key definitely below the prefix;
 300                         * the map does not have string[0:len] in it.
 301                         */
 302                        break;
 303                else if (!cmp && !map->items[i].string[len])
 304                        /* found it */
 305                        return &map->items[i];
 306                /*
 307                 * otherwise, the string at "i" may be string[0:len]
 308                 * followed by a string that sorts later than string[len:];
 309                 * keep trying.
 310                 */
 311        }
 312        return NULL;
 313}
 314
 315int map_user(struct string_list *map,
 316             const char **email, size_t *emaillen,
 317             const char **name, size_t *namelen)
 318{
 319        struct string_list_item *item;
 320        struct mailmap_entry *me;
 321
 322        debug_mm("map_user: map '%.*s' <%.*s>\n",
 323                 (int)*namelen, debug_str(*name),
 324                 (int)*emaillen, debug_str(*email));
 325
 326        item = lookup_prefix(map, *email, *emaillen);
 327        if (item != NULL) {
 328                me = (struct mailmap_entry *)item->util;
 329                if (me->namemap.nr) {
 330                        /*
 331                         * The item has multiple items, so we'll look up on
 332                         * name too. If the name is not found, we choose the
 333                         * simple entry.
 334                         */
 335                        struct string_list_item *subitem;
 336                        subitem = lookup_prefix(&me->namemap, *name, *namelen);
 337                        if (subitem)
 338                                item = subitem;
 339                }
 340        }
 341        if (item != NULL) {
 342                struct mailmap_info *mi = (struct mailmap_info *)item->util;
 343                if (mi->name == NULL && mi->email == NULL) {
 344                        debug_mm("map_user:  -- (no simple mapping)\n");
 345                        return 0;
 346                }
 347                if (mi->email) {
 348                                *email = mi->email;
 349                                *emaillen = strlen(*email);
 350                }
 351                if (mi->name) {
 352                                *name = mi->name;
 353                                *namelen = strlen(*name);
 354                }
 355                debug_mm("map_user:  to '%.*s' <%.*s>\n",
 356                         (int)*namelen, debug_str(*name),
 357                         (int)*emaillen, debug_str(*email));
 358                return 1;
 359        }
 360        debug_mm("map_user:  --\n");
 361        return 0;
 362}