git

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
}
330