git.oblomov.eu Git - git/blob - mailmap.c

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