op public repos

Blob

Date:: Mon Feb 4 09:48:23 2019 UTC
Message:: make got_ref_list() return a sorted list
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/types.h>
18 #include <sys/queue.h>
19 
20 #include <dirent.h>
21 #include <sha1.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <util.h>
26 #include <zlib.h>
27 #include <time.h>
28 
29 #include "got_error.h"
30 #include "got_object.h"
31 #include "got_repository.h"
32 #include "got_reference.h"
33 
34 #include "got_lib_sha1.h"
35 #include "got_lib_path.h"
36 #include "got_lib_delta.h"
37 #include "got_lib_inflate.h"
38 #include "got_lib_object.h"
39 
40 #ifndef nitems
41 #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
42 #endif
43 
44 #define GOT_REF_HEADS	"heads"
45 #define GOT_REF_TAGS	"tags"
46 #define GOT_REF_REMOTES	"remotes"
47 
48 /* A symbolic reference. */
49 struct got_symref {
50 	char *name;
51 	char *ref;
52 };
53 
54 /* A non-symbolic reference (there is no better designation). */
55 struct got_ref {
56 	char *name;
57 	u_int8_t sha1[SHA1_DIGEST_LENGTH];
58 };
59 
60 /* A reference which points to an arbitrary object. */
61 struct got_reference {
62 	unsigned int flags;
63 #define GOT_REF_IS_SYMBOLIC	0x01
64 
65 	union {
66 		struct got_ref ref;
67 		struct got_symref symref;
68 	} ref;
69 };
70 
71 static const struct got_error *
72 parse_symref(struct got_reference **ref, const char *name, const char *line)
73 {
74 	struct got_symref *symref;
75 	char *symref_name;
76 	char *symref_ref;
77 
78 	if (line[0] == '\0')
79 		return got_error(GOT_ERR_BAD_REF_DATA);
80 
81 	symref_name = strdup(name);
82 	if (symref_name == NULL)
83 		return got_error_from_errno();
84 	symref_ref = strdup(line);
85 	if (symref_ref == NULL) {
86 		const struct got_error *err = got_error_from_errno();
87 		free(symref_name);
88 		return err;
89 	}
90 
91 	*ref = calloc(1, sizeof(**ref));
92 	if (*ref == NULL)
93 		return got_error_from_errno();
94 	(*ref)->flags |= GOT_REF_IS_SYMBOLIC;
95 	symref = &((*ref)->ref.symref);
96 	symref->name = symref_name;
97 	symref->ref = symref_ref;
98 	return NULL;
99 }
100 
101 static const struct got_error *
102 parse_ref_line(struct got_reference **ref, const char *name, const char *line)
103 {
104 	uint8_t digest[SHA1_DIGEST_LENGTH];
105 	char *ref_name;
106 
107 	if (strncmp(line, "ref: ", 5) == 0) {
108 		line += 5;
109 		return parse_symref(ref, name, line);
110 	}
111 
112 	ref_name = strdup(name);
113 	if (ref_name == NULL)
114 		return got_error_from_errno();
115 
116 	if (!got_parse_sha1_digest(digest, line))
117 		return got_error(GOT_ERR_BAD_REF_DATA);
118 
119 	*ref = calloc(1, sizeof(**ref));
120 	if (*ref == NULL)
121 		return got_error_from_errno();
122 	(*ref)->ref.ref.name = ref_name;
123 	memcpy(&(*ref)->ref.ref.sha1, digest, SHA1_DIGEST_LENGTH);
124 	return NULL;
125 }
126 
127 static const struct got_error *
128 parse_ref_file(struct got_reference **ref, const char *name,
129     const char *abspath)
130 {
131 	const struct got_error *err = NULL;
132 	FILE *f = fopen(abspath, "rb");
133 	char *line;
134 	size_t len;
135 	const char delim[3] = {'\0', '\0', '\0'};
136 
137 	if (f == NULL)
138 		return NULL;
139 
140 	line = fparseln(f, &len, NULL, delim, 0);
141 	if (line == NULL) {
142 		err = got_error(GOT_ERR_BAD_REF_DATA);
143 		goto done;
144 	}
145 
146 	err = parse_ref_line(ref, name, line);
147 done:
148 	free(line);
149 	fclose(f);
150 	return err;
151 }
152 
153 static int
154 is_well_known_ref(const char *refname)
155 {
156 	return (strcmp(refname, GOT_REF_HEAD) == 0 ||
157 	    strcmp(refname, GOT_REF_ORIG_HEAD) == 0 ||
158 	    strcmp(refname, GOT_REF_MERGE_HEAD) == 0 ||
159 	    strcmp(refname, GOT_REF_FETCH_HEAD) == 0);
160 }
161 
162 static char *
163 get_refs_dir_path(struct got_repository *repo, const char *refname)
164 {
165 	if (is_well_known_ref(refname) || strncmp(refname, "refs/", 5) == 0)
166 		return strdup(got_repo_get_path_git_dir(repo));
167 
168 	return got_repo_get_path_refs(repo);
169 }
170 
171 static const struct got_error *
172 parse_packed_ref_line(struct got_reference **ref, const char *abs_refname,
173     const char *line)
174 {
175 	uint8_t digest[SHA1_DIGEST_LENGTH];
176 	char *name;
177 
178 	*ref = NULL;
179 
180 	if (line[0] == '#' || line[0] == '^')
181 		return NULL;
182 
183 	if (!got_parse_sha1_digest(digest, line))
184 		return got_error(GOT_ERR_BAD_REF_DATA);
185 
186 	if (abs_refname) {
187 		if (strcmp(line + SHA1_DIGEST_STRING_LENGTH, abs_refname) != 0)
188 			return NULL;
189 
190 		name = strdup(abs_refname);
191 		if (name == NULL)
192 			return got_error_from_errno();
193 	} else
194 		name = strdup(line + SHA1_DIGEST_STRING_LENGTH);
195 
196 	*ref = calloc(1, sizeof(**ref));
197 	if (*ref == NULL)
198 		return got_error_from_errno();
199 	(*ref)->ref.ref.name = name;;
200 	memcpy(&(*ref)->ref.ref.sha1, digest, SHA1_DIGEST_LENGTH);
201 	return NULL;
202 }
203 
204 static const struct got_error *
205 open_packed_ref(struct got_reference **ref, FILE *f, const char **subdirs,
206     int nsubdirs, const char *refname)
207 {
208 	const struct got_error *err = NULL;
209 	char *abs_refname;
210 	char *line;
211 	size_t len;
212 	const char delim[3] = {'\0', '\0', '\0'};
213 	int i, ref_is_absolute = (strncmp(refname, "refs/", 5) == 0);
214 
215 	*ref = NULL;
216 
217 	if (ref_is_absolute)
218 		abs_refname = (char *)refname;
219 	do {
220 		line = fparseln(f, &len, NULL, delim, 0);
221 		if (line == NULL)
222 			break;
223 		for (i = 0; i < nsubdirs; i++) {
224 			if (!ref_is_absolute &&
225 			    asprintf(&abs_refname, "refs/%s/%s", subdirs[i],
226 			    refname) == -1)
227 				return got_error_from_errno();
228 			err = parse_packed_ref_line(ref, abs_refname, line);
229 			if (!ref_is_absolute)
230 				free(abs_refname);
231 			if (err || *ref != NULL)
232 				break;
233 		}
234 		free(line);
235 		if (err)
236 			break;
237 	} while (*ref == NULL);
238 
239 	return err;
240 }
241 
242 static const struct got_error *
243 open_ref(struct got_reference **ref, const char *path_refs, const char *subdir,
244     const char *name)
245 {
246 	const struct got_error *err = NULL;
247 	char *path = NULL;
248 	char *normpath = NULL;
249 	char *absname = NULL;
250 	int ref_is_absolute = (strncmp(name, "refs/", 5) == 0);
251 	int ref_is_well_known = is_well_known_ref(name);
252 
253 	*ref = NULL;
254 
255 	if (ref_is_absolute || ref_is_well_known) {
256 		if (asprintf(&path, "%s/%s", path_refs, name) == -1)
257 			return got_error_from_errno();
258 		absname = (char *)name;
259 	} else {
260 		if (asprintf(&path, "%s/%s/%s", path_refs, subdir, name) == -1)
261 			return got_error_from_errno();
262 
263 		if (asprintf(&absname, "refs/%s/%s", subdir, name) == -1) {
264 			err = got_error_from_errno();
265 			goto done;
266 		}
267 	}
268 
269 	normpath = got_path_normalize(path);
270 	if (normpath == NULL) {
271 		err = got_error_from_errno();
272 		goto done;
273 	}
274 
275 	err = parse_ref_file(ref, absname, normpath);
276 done:
277 	if (!ref_is_absolute && !ref_is_well_known)
278 		free(absname);
279 	free(path);
280 	free(normpath);
281 	return err;
282 }
283 
284 const struct got_error *
285 got_ref_open(struct got_reference **ref, struct got_repository *repo,
286    const char *refname)
287 {
288 	const struct got_error *err = NULL;
289 	char *path_refs = NULL;
290 	const char *subdirs[] = {
291 	    GOT_REF_HEADS, GOT_REF_TAGS, GOT_REF_REMOTES
292 	};
293 	int i, well_known = is_well_known_ref(refname);
294 
295 	*ref = NULL;
296 
297 	if (!well_known) {
298 		char *packed_refs_path;
299 		FILE *f;
300 
301 		packed_refs_path = got_repo_get_path_packed_refs(repo);
302 		if (packed_refs_path == NULL)
303 			return got_error_from_errno();
304 
305 		f = fopen(packed_refs_path, "rb");
306 		free(packed_refs_path);
307 		if (f != NULL) {
308 			err = open_packed_ref(ref, f, subdirs, nitems(subdirs),
309 			    refname);
310 			fclose(f);
311 			if (err || *ref)
312 				goto done;
313 		}
314 	}
315 
316 	path_refs = get_refs_dir_path(repo, refname);
317 	if (path_refs == NULL) {
318 		err = got_error_from_errno();
319 		goto done;
320 	}
321 
322 	if (!well_known) {
323 		for (i = 0; i < nitems(subdirs); i++) {
324 			err = open_ref(ref, path_refs, subdirs[i], refname);
325 			if (err || *ref)
326 				goto done;
327 		}
328 	}
329 
330 	err = open_ref(ref, path_refs, "", refname);
331 	if (err)
332 		goto done;
333 	if (*ref == NULL)
334 		err = got_error_not_ref(refname);
335 done:
336 	free(path_refs);
337 	return err;
338 }
339 
340 void
341 got_ref_close(struct got_reference *ref)
342 {
343 	if (ref->flags & GOT_REF_IS_SYMBOLIC)
344 		free(ref->ref.symref.name);
345 	else
346 		free(ref->ref.ref.name);
347 	free(ref);
348 }
349 
350 struct got_reference *
351 got_ref_dup(struct got_reference *ref)
352 {
353 	struct got_reference *ret;
354 
355 	ret = calloc(1, sizeof(*ret));
356 	if (ret == NULL)
357 		return NULL;
358 
359 	ret->flags = ref->flags;
360 	if (ref->flags & GOT_REF_IS_SYMBOLIC) {
361 		ret->ref.symref.name = strdup(ref->ref.symref.name);
362 		if (ret->ref.symref.name == NULL) {
363 			free(ret);
364 			return NULL;
365 		}
366 		ret->ref.symref.ref = strdup(ref->ref.symref.ref);
367 		if (ret->ref.symref.ref == NULL) {
368 			free(ret->ref.symref.name);
369 			free(ret);
370 			return NULL;
371 		}
372 	} else {
373 		ref->ref.ref.name = strdup(ref->ref.ref.name);
374 		if (ref->ref.ref.name == NULL) {
375 			free(ret);
376 			return NULL;
377 		}
378 		memcpy(ret->ref.ref.sha1, ref->ref.ref.sha1,
379 		    SHA1_DIGEST_LENGTH);
380 	}
381 
382 	return ret;
383 }
384 
385 static const struct got_error *
386 resolve_symbolic_ref(struct got_reference **resolved,
387     struct got_repository *repo, struct got_reference *ref)
388 {
389 	struct got_reference *nextref;
390 	const struct got_error *err;
391 
392 	err = got_ref_open(&nextref, repo, ref->ref.symref.ref);
393 	if (err)
394 		return err;
395 
396 	if (nextref->flags & GOT_REF_IS_SYMBOLIC)
397 		err = resolve_symbolic_ref(resolved, repo, nextref);
398 	else
399 		*resolved = got_ref_dup(nextref);
400 
401 	got_ref_close(nextref);
402 	return err;
403 }
404 
405 const struct got_error *
406 got_ref_resolve(struct got_object_id **id, struct got_repository *repo,
407     struct got_reference *ref)
408 {
409 	const struct got_error *err;
410 
411 	if (ref->flags & GOT_REF_IS_SYMBOLIC) {
412 		struct got_reference *resolved = NULL;
413 		err = resolve_symbolic_ref(&resolved, repo, ref);
414 		if (err == NULL)
415 			err = got_ref_resolve(id, repo, resolved);
416 		free(resolved);
417 		return err;
418 	}
419 
420 	*id = calloc(1, sizeof(**id));
421 	if (*id == NULL)
422 		return got_error_from_errno();
423 	memcpy((*id)->sha1, ref->ref.ref.sha1, SHA1_DIGEST_LENGTH);
424 	return NULL;
425 }
426 
427 char *
428 got_ref_to_str(struct got_reference *ref)
429 {
430 	char *str;
431 
432 	if (ref->flags & GOT_REF_IS_SYMBOLIC)
433 		return strdup(ref->ref.symref.ref);
434 
435 	str = malloc(SHA1_DIGEST_STRING_LENGTH);
436 	if (str == NULL)
437 		return NULL;
438 
439 	if (got_sha1_digest_to_str(ref->ref.ref.sha1, str,
440 	    SHA1_DIGEST_STRING_LENGTH) == NULL) {
441 		free(str);
442 		return NULL;
443 	}
444 
445 	return str;
446 }
447 
448 const char *
449 got_ref_get_name(struct got_reference *ref)
450 {
451 	if (ref->flags & GOT_REF_IS_SYMBOLIC)
452 		return ref->ref.symref.name;
453 
454 	return ref->ref.ref.name;
455 }
456 
457 static const struct got_error *
458 insert_ref(struct got_reflist_head *refs, struct got_reference *ref,
459     struct got_repository *repo)
460 {
461 	const struct got_error *err;
462 	struct got_object_id *id;
463 	struct got_reflist_entry *re, *prev = NULL;
464 	int cmp;
465 
466 	/*
467 	 * We must de-duplicate entries on insert because packed-refs may
468 	 * contain redundant entries. On-disk refs take precedence.
469 	 * This code assumes that on-disk revs are read before packed-refs.
470 	 * We're iterating the list anyway, so insert elements sorted by name.
471 	 */
472 	SIMPLEQ_FOREACH(re, refs, entry) {
473 		cmp = strcmp(got_ref_get_name(re->ref), got_ref_get_name(ref));
474 		if (cmp == 0) {
475 			free(ref);
476 			return NULL;
477 		} else if (cmp > 0)
478 			break;
479 		else
480 			prev = re;
481 	}
482 
483 	err = got_ref_resolve(&id, repo, ref);
484 	if (err)
485 		return err;
486 	re = malloc(sizeof(*re));
487 	if (re == NULL)
488 		return got_error_from_errno();
489 	re->ref = ref;
490 	re->id = id;
491 	if (prev)
492 		SIMPLEQ_INSERT_AFTER(refs, prev, re, entry);
493 	else
494 		SIMPLEQ_INSERT_HEAD(refs, re, entry);
495 
496 	return NULL;
497 }
498 
499 static const struct got_error *
500 gather_on_disk_refs(struct got_reflist_head *refs, const char *path_refs,
501     const char *subdir, struct got_repository *repo)
502 {
503 	const struct got_error *err = NULL;
504 	DIR *d = NULL;
505 	char *path_subdir;
506 
507 	if (asprintf(&path_subdir, "%s/%s", path_refs, subdir) == -1)
508 		return got_error_from_errno();
509 
510 	d = opendir(path_subdir);
511 	if (d == NULL)
512 		goto done;
513 
514 	while (1) {
515 		struct dirent *dent;
516 		struct got_reference *ref;
517 		char *child;
518 
519 		dent = readdir(d);
520 		if (dent == NULL)
521 			break;
522 
523 		if (strcmp(dent->d_name, ".") == 0 ||
524 		    strcmp(dent->d_name, "..") == 0)
525 			continue;
526 
527 		switch (dent->d_type) {
528 		case DT_REG:
529 			err = open_ref(&ref, path_refs, subdir, dent->d_name);
530 			if (err)
531 				goto done;
532 			if (ref) {
533 				err = insert_ref(refs, ref, repo);
534 				if (err)
535 					goto done;
536 			}
537 			break;
538 		case DT_DIR:
539 			if (asprintf(&child, "%s%s%s", subdir,
540 			    subdir[0] == '\0' ? "" : "/", dent->d_name) == -1) {
541 				err = got_error_from_errno();
542 				break;
543 			}
544 			err = gather_on_disk_refs(refs, path_refs, child, repo);
545 			free(child);
546 			break;
547 		default:
548 			break;
549 		}
550 	}
551 done:
552 	if (d)
553 		closedir(d);
554 	free(path_subdir);
555 	return err;
556 }
557 
558 const struct got_error *
559 got_ref_list(struct got_reflist_head *refs, struct got_repository *repo)
560 {
561 	const struct got_error *err;
562 	char *packed_refs_path, *path_refs = NULL;
563 	FILE *f = NULL;
564 	struct got_reference *ref;
565 
566 	/* HEAD ref should always exist. */
567 	path_refs = get_refs_dir_path(repo, GOT_REF_HEAD);
568 	if (path_refs == NULL) {
569 		err = got_error_from_errno();
570 		goto done;
571 	}
572 	err = open_ref(&ref, path_refs, "", GOT_REF_HEAD);
573 	if (err)
574 		goto done;
575 	err = insert_ref(refs, ref, repo);
576 	if (err)
577 		goto done;
578 
579 	/* Gather on-disk refs before parsing packed-refs. */
580 	free(path_refs);
581 	path_refs = get_refs_dir_path(repo, "");
582 	if (path_refs == NULL) {
583 		err = got_error_from_errno();
584 		goto done;
585 	}
586 	err = gather_on_disk_refs(refs, path_refs, "", repo);
587 	if (err)
588 		goto done;
589 
590 	/*
591 	 * The packed-refs file may contain redundant entries, in which
592 	 * case on-disk refs take precedence.
593 	 */
594 	packed_refs_path = got_repo_get_path_packed_refs(repo);
595 	if (packed_refs_path == NULL) {
596 		err = got_error_from_errno();
597 		goto done;
598 	}
599 
600 	f = fopen(packed_refs_path, "r");
601 	free(packed_refs_path);
602 	if (f) {
603 		char *line;
604 		size_t len;
605 		const char delim[3] = {'\0', '\0', '\0'};
606 		while (1) {
607 			line = fparseln(f, &len, NULL, delim, 0);
608 			if (line == NULL)
609 				break;
610 			err = parse_packed_ref_line(&ref, NULL, line);
611 			if (err)
612 				goto done;
613 			if (ref) {
614 				err = insert_ref(refs, ref, repo);
615 				if (err)
616 					goto done;
617 			}
618 		}
619 	}
620 done:
621 	free(path_refs);
622 	if (f)
623 		fclose(f);
624 	return err;
625 }