mailmap.c

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