mailmap.c

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