op public repos

Blame

Date:: Sun Oct 23 00:37:19 2022 UTC
Message:: introduce gotd(8), a Git repository server reachable via ssh(1) This is an initial barebones implementation which provides the absolute minimum of functionality required to serve got(1) and git(1) clients. Basic fetch/send functionality has been tested and seems to work here, but this server is not yet expected to be stable. More testing is welcome. See the man pages for setup instructions. The current design uses one reader and one writer process per repository, which will have to be extended to N readers and N writers in the future. At startup, each process will chroot(2) into its assigned repository. This works because gotd(8) can only be started as root, and will then fork+exec, chroot, and privdrop. At present the parent process runs with the following pledge(2) promises: "stdio rpath wpath cpath proc getpw sendfd recvfd fattr flock unix unveil" The parent is the only process able to modify the repository in a way that becomes visible to Git clients. The parent uses unveil(2) to restrict its view of the filesystem to /tmp and the repositories listed in the configuration file gotd.conf(5). Per-repository chroot(2) processes use "stdio rpath sendfd recvfd". The writer defers to the parent for modifying references in the repository to point at newly uploaded commits. The reader is fine without such help, because Git repositories can be read without having to create any lock-files. gotd(8) requires a dedicated user ID, which should own repositories on the filesystem, and a separate secondary group, which should not have filesystem-level repository access, and must be allowed access to the gotd(8) socket. To obtain Git repository access, users must be members of this secondary group, and must have their login shell set to gotsh(1). gotsh(1) connects to the gotd(8) socket and speaks Git-protocol towards the client on the other end of the SSH connection. gotsh(1) is not an interactive command shell. At present, authenticated clients are granted read/write access to all repositories and all references (except for the "refs/got/" and the "refs/remotes/" namespaces, which are already being protected from modification). While complicated access control mechanism are not a design goal, making it possible to safely offer anonymous Git repository access over ssh(1) is on the road map.
Actions:: History | Blob | Raw File
   1 5261c201 2018-04-01 stsp /*
   2 5d56da81 2019-01-13 stsp  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
   3 5261c201 2018-04-01 stsp  *
   4 5261c201 2018-04-01 stsp  * Permission to use, copy, modify, and distribute this software for any
   5 5261c201 2018-04-01 stsp  * purpose with or without fee is hereby granted, provided that the above
   6 5261c201 2018-04-01 stsp  * copyright notice and this permission notice appear in all copies.
   7 5261c201 2018-04-01 stsp  *
   8 5261c201 2018-04-01 stsp  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9 5261c201 2018-04-01 stsp  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10 5261c201 2018-04-01 stsp  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11 5261c201 2018-04-01 stsp  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12 5261c201 2018-04-01 stsp  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13 5261c201 2018-04-01 stsp  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14 5261c201 2018-04-01 stsp  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15 5261c201 2018-04-01 stsp  */
  16 5261c201 2018-04-01 stsp 
  17 5261c201 2018-04-01 stsp #include <sys/types.h>
  18 5261c201 2018-04-01 stsp #include <sys/queue.h>
  19 9e672c74 2019-03-11 stsp #include <sys/stat.h>
  20 5261c201 2018-04-01 stsp 
  21 0fd469ce 2019-03-11 stsp #include <errno.h>
  22 a04f49d2 2019-02-04 stsp #include <dirent.h>
  23 56e0773d 2019-11-28 stsp #include <limits.h>
  24 5261c201 2018-04-01 stsp #include <sha1.h>
  25 5261c201 2018-04-01 stsp #include <stdio.h>
  26 5261c201 2018-04-01 stsp #include <stdlib.h>
  27 5261c201 2018-04-01 stsp #include <string.h>
  28 81a12da5 2020-09-09 naddy #include <unistd.h>
  29 5261c201 2018-04-01 stsp #include <util.h>
  30 5261c201 2018-04-01 stsp #include <zlib.h>
  31 788c352e 2018-06-16 stsp #include <time.h>
  32 0cd1c46a 2019-03-11 stsp #include <libgen.h>
  33 5261c201 2018-04-01 stsp 
  34 5261c201 2018-04-01 stsp #include "got_error.h"
  35 5261c201 2018-04-01 stsp #include "got_object.h"
  36 5261c201 2018-04-01 stsp #include "got_repository.h"
  37 5261c201 2018-04-01 stsp #include "got_reference.h"
  38 9e672c74 2019-03-11 stsp #include "got_opentemp.h"
  39 324d37e7 2019-05-11 stsp #include "got_path.h"
  40 5261c201 2018-04-01 stsp 
  41 5261c201 2018-04-01 stsp #include "got_lib_sha1.h"
  42 5261c201 2018-04-01 stsp #include "got_lib_delta.h"
  43 63581804 2018-07-09 stsp #include "got_lib_inflate.h"
  44 5261c201 2018-04-01 stsp #include "got_lib_object.h"
  45 7b5b670e 2020-12-25 stsp #include "got_lib_object_idset.h"
  46 f77a24b0 2019-03-11 stsp #include "got_lib_lockfile.h"
  47 5261c201 2018-04-01 stsp 
  48 fb79db15 2019-02-01 stsp #ifndef nitems
  49 fb79db15 2019-02-01 stsp #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
  50 fb79db15 2019-02-01 stsp #endif
  51 fb79db15 2019-02-01 stsp 
  52 d1f2edc9 2018-06-13 stsp #define GOT_REF_HEADS	"heads"
  53 d1f2edc9 2018-06-13 stsp #define GOT_REF_TAGS	"tags"
  54 d1f2edc9 2018-06-13 stsp #define GOT_REF_REMOTES	"remotes"
  55 d1f2edc9 2018-06-13 stsp 
  56 598a8b91 2019-03-15 stsp /*
  57 598a8b91 2019-03-15 stsp  * We do not resolve tags yet, and don't yet care about sorting refs either,
  58 598a8b91 2019-03-15 stsp  * so packed-refs files we write contain a minimal header which disables all
  59 598a8b91 2019-03-15 stsp  * packed-refs "traits" supported by Git.
  60 598a8b91 2019-03-15 stsp  */
  61 598a8b91 2019-03-15 stsp #define GOT_PACKED_REFS_HEADER	"# pack-refs with:"
  62 598a8b91 2019-03-15 stsp 
  63 5261c201 2018-04-01 stsp /* A symbolic reference. */
  64 5261c201 2018-04-01 stsp struct got_symref {
  65 5261c201 2018-04-01 stsp 	char *name;
  66 5261c201 2018-04-01 stsp 	char *ref;
  67 5261c201 2018-04-01 stsp };
  68 29e86f7a 2019-08-12 stsp 
  69 29e86f7a 2019-08-12 stsp #define GOT_REF_RECURSE_MAX	20
  70 5261c201 2018-04-01 stsp 
  71 5261c201 2018-04-01 stsp /* A non-symbolic reference (there is no better designation). */
  72 5261c201 2018-04-01 stsp struct got_ref {
  73 5261c201 2018-04-01 stsp 	char *name;
  74 5261c201 2018-04-01 stsp 	u_int8_t sha1[SHA1_DIGEST_LENGTH];
  75 5261c201 2018-04-01 stsp };
  76 5261c201 2018-04-01 stsp 
  77 5261c201 2018-04-01 stsp /* A reference which points to an arbitrary object. */
  78 5261c201 2018-04-01 stsp struct got_reference {
  79 5261c201 2018-04-01 stsp 	unsigned int flags;
  80 5261c201 2018-04-01 stsp #define GOT_REF_IS_SYMBOLIC	0x01
  81 f9267c9a 2019-03-15 stsp #define GOT_REF_IS_PACKED	0x02
  82 5261c201 2018-04-01 stsp 
  83 5261c201 2018-04-01 stsp 	union {
  84 5261c201 2018-04-01 stsp 		struct got_ref ref;
  85 5261c201 2018-04-01 stsp 		struct got_symref symref;
  86 5261c201 2018-04-01 stsp 	} ref;
  87 2f17228e 2019-05-12 stsp 
  88 2f17228e 2019-05-12 stsp 	struct got_lockfile *lf;
  89 3f338f0a 2021-07-27 stsp 	time_t mtime;
  90 2c9e323b 2021-10-10 stsp 
  91 2c9e323b 2021-10-10 stsp 	/* Cached timestamp for got_ref_cmp_by_commit_timestamp_descending() */
  92 2c9e323b 2021-10-10 stsp 	time_t committer_time;
  93 5261c201 2018-04-01 stsp };
  94 5261c201 2018-04-01 stsp 
  95 5261c201 2018-04-01 stsp static const struct got_error *
  96 f9267c9a 2019-03-15 stsp alloc_ref(struct got_reference **ref, const char *name,
  97 3f338f0a 2021-07-27 stsp     struct got_object_id *id, int flags, time_t mtime)
  98 5261c201 2018-04-01 stsp {
  99 f9267c9a 2019-03-15 stsp 	const struct got_error *err = NULL;
 100 5261c201 2018-04-01 stsp 
 101 f9267c9a 2019-03-15 stsp 	*ref = calloc(1, sizeof(**ref));
 102 f9267c9a 2019-03-15 stsp 	if (*ref == NULL)
 103 638f9024 2019-05-13 stsp 		return got_error_from_errno("calloc");
 104 f9267c9a 2019-03-15 stsp 
 105 80d5fc1f 2019-03-15 stsp 	memcpy((*ref)->ref.ref.sha1, id->sha1, sizeof((*ref)->ref.ref.sha1));
 106 c980e470 2019-03-15 stsp 	(*ref)->flags = flags;
 107 f9267c9a 2019-03-15 stsp 	(*ref)->ref.ref.name = strdup(name);
 108 3f338f0a 2021-07-27 stsp 	(*ref)->mtime = mtime;
 109 f9267c9a 2019-03-15 stsp 	if ((*ref)->ref.ref.name == NULL) {
 110 638f9024 2019-05-13 stsp 		err = got_error_from_errno("strdup");
 111 c980e470 2019-03-15 stsp 		got_ref_close(*ref);
 112 f9267c9a 2019-03-15 stsp 		*ref = NULL;
 113 5261c201 2018-04-01 stsp 	}
 114 f9267c9a 2019-03-15 stsp 	return err;
 115 f9267c9a 2019-03-15 stsp }
 116 5261c201 2018-04-01 stsp 
 117 f9267c9a 2019-03-15 stsp static const struct got_error *
 118 f9267c9a 2019-03-15 stsp alloc_symref(struct got_reference **ref, const char *name,
 119 f9267c9a 2019-03-15 stsp     const char *target_ref, int flags)
 120 f9267c9a 2019-03-15 stsp {
 121 f9267c9a 2019-03-15 stsp 	const struct got_error *err = NULL;
 122 f9267c9a 2019-03-15 stsp 
 123 5261c201 2018-04-01 stsp 	*ref = calloc(1, sizeof(**ref));
 124 5261c201 2018-04-01 stsp 	if (*ref == NULL)
 125 638f9024 2019-05-13 stsp 		return got_error_from_errno("calloc");
 126 f9267c9a 2019-03-15 stsp 
 127 f9267c9a 2019-03-15 stsp 	(*ref)->flags = GOT_REF_IS_SYMBOLIC | flags;
 128 f9267c9a 2019-03-15 stsp 	(*ref)->ref.symref.name = strdup(name);
 129 f9267c9a 2019-03-15 stsp 	if ((*ref)->ref.symref.name == NULL) {
 130 638f9024 2019-05-13 stsp 		err = got_error_from_errno("strdup");
 131 f9267c9a 2019-03-15 stsp 		got_ref_close(*ref);
 132 f9267c9a 2019-03-15 stsp 		*ref = NULL;
 133 cdb8f1fa 2019-08-28 hiltjo 		return err;
 134 f9267c9a 2019-03-15 stsp 	}
 135 f9267c9a 2019-03-15 stsp 	(*ref)->ref.symref.ref = strdup(target_ref);
 136 f9267c9a 2019-03-15 stsp 	if ((*ref)->ref.symref.ref == NULL) {
 137 638f9024 2019-05-13 stsp 		err = got_error_from_errno("strdup");
 138 f9267c9a 2019-03-15 stsp 		got_ref_close(*ref);
 139 f9267c9a 2019-03-15 stsp 		*ref = NULL;
 140 f9267c9a 2019-03-15 stsp 	}
 141 f9267c9a 2019-03-15 stsp 	return err;
 142 5261c201 2018-04-01 stsp }
 143 5261c201 2018-04-01 stsp 
 144 5261c201 2018-04-01 stsp static const struct got_error *
 145 f9267c9a 2019-03-15 stsp parse_symref(struct got_reference **ref, const char *name, const char *line)
 146 f9267c9a 2019-03-15 stsp {
 147 f9267c9a 2019-03-15 stsp 	if (line[0] == '\0')
 148 f9267c9a 2019-03-15 stsp 		return got_error(GOT_ERR_BAD_REF_DATA);
 149 f9267c9a 2019-03-15 stsp 
 150 f9267c9a 2019-03-15 stsp 	return alloc_symref(ref, name, line, 0);
 151 f9267c9a 2019-03-15 stsp }
 152 f9267c9a 2019-03-15 stsp 
 153 f9267c9a 2019-03-15 stsp static const struct got_error *
 154 3f338f0a 2021-07-27 stsp parse_ref_line(struct got_reference **ref, const char *name, const char *line,
 155 3f338f0a 2021-07-27 stsp     time_t mtime)
 156 5261c201 2018-04-01 stsp {
 157 5892cdd6 2019-03-10 stsp 	struct got_object_id id;
 158 5261c201 2018-04-01 stsp 
 159 5261c201 2018-04-01 stsp 	if (strncmp(line, "ref: ", 5) == 0) {
 160 5261c201 2018-04-01 stsp 		line += 5;
 161 5261c201 2018-04-01 stsp 		return parse_symref(ref, name, line);
 162 5261c201 2018-04-01 stsp 	}
 163 5261c201 2018-04-01 stsp 
 164 5892cdd6 2019-03-10 stsp 	if (!got_parse_sha1_digest(id.sha1, line))
 165 30c0868d 2019-02-03 stsp 		return got_error(GOT_ERR_BAD_REF_DATA);
 166 5261c201 2018-04-01 stsp 
 167 3f338f0a 2021-07-27 stsp 	return alloc_ref(ref, name, &id, 0, mtime);
 168 5261c201 2018-04-01 stsp }
 169 5261c201 2018-04-01 stsp 
 170 5261c201 2018-04-01 stsp static const struct got_error *
 171 5261c201 2018-04-01 stsp parse_ref_file(struct got_reference **ref, const char *name,
 172 b2070a3f 2020-03-22 stsp     const char *absname, const char *abspath, int lock)
 173 5261c201 2018-04-01 stsp {
 174 5261c201 2018-04-01 stsp 	const struct got_error *err = NULL;
 175 c0a1c016 2019-03-15 stsp 	FILE *f;
 176 c30018ad 2019-10-21 stsp 	char *line = NULL;
 177 c30018ad 2019-10-21 stsp 	size_t linesize = 0;
 178 c30018ad 2019-10-21 stsp 	ssize_t linelen;
 179 2f17228e 2019-05-12 stsp 	struct got_lockfile *lf = NULL;
 180 3f338f0a 2021-07-27 stsp 	struct stat sb;
 181 5261c201 2018-04-01 stsp 
 182 2f17228e 2019-05-12 stsp 	if (lock) {
 183 5345b4c7 2021-07-06 stsp 		err = got_lockfile_lock(&lf, abspath, -1);
 184 9f142382 2020-03-21 stsp 		if (err) {
 185 9f142382 2020-03-21 stsp 			if (err->code == GOT_ERR_ERRNO && errno == ENOENT)
 186 b2070a3f 2020-03-22 stsp 				err = got_error_not_ref(name);
 187 9f142382 2020-03-21 stsp 			return err;
 188 9f142382 2020-03-21 stsp 		}
 189 2f17228e 2019-05-12 stsp 	}
 190 2f17228e 2019-05-12 stsp 
 191 00fe21f2 2021-12-31 stsp 	f = fopen(abspath, "rbe");
 192 f5c58ad1 2019-05-12 stsp 	if (f == NULL) {
 193 b2070a3f 2020-03-22 stsp 		if (errno != ENOTDIR && errno != ENOENT)
 194 b2070a3f 2020-03-22 stsp 			err = got_error_from_errno2("fopen", abspath);
 195 b2070a3f 2020-03-22 stsp 		else
 196 b2070a3f 2020-03-22 stsp 			err = got_error_not_ref(name);
 197 f5c58ad1 2019-05-12 stsp 		if (lock)
 198 5345b4c7 2021-07-06 stsp 			got_lockfile_unlock(lf, -1);
 199 b2070a3f 2020-03-22 stsp 		return err;
 200 f5c58ad1 2019-05-12 stsp 	}
 201 3f338f0a 2021-07-27 stsp 	if (fstat(fileno(f), &sb) == -1) {
 202 3f338f0a 2021-07-27 stsp 		err = got_error_from_errno2("fstat", abspath);
 203 3f338f0a 2021-07-27 stsp 		goto done;
 204 3f338f0a 2021-07-27 stsp 	}
 205 5261c201 2018-04-01 stsp 
 206 c30018ad 2019-10-21 stsp 	linelen = getline(&line, &linesize, f);
 207 c30018ad 2019-10-21 stsp 	if (linelen == -1) {
 208 c30018ad 2019-10-21 stsp 		if (feof(f))
 209 c30018ad 2019-10-21 stsp 			err = NULL; /* ignore empty files (could be locks) */
 210 b2070a3f 2020-03-22 stsp 		else {
 211 b2070a3f 2020-03-22 stsp 			if (errno == EISDIR)
 212 b2070a3f 2020-03-22 stsp 				err = got_error(GOT_ERR_NOT_REF);
 213 b2070a3f 2020-03-22 stsp 			else if (ferror(f))
 214 b2070a3f 2020-03-22 stsp 				err = got_ferror(f, GOT_ERR_IO);
 215 b2070a3f 2020-03-22 stsp 			else
 216 b2070a3f 2020-03-22 stsp 				err = got_error_from_errno2("getline", abspath);
 217 b2070a3f 2020-03-22 stsp 		}
 218 f5c58ad1 2019-05-12 stsp 		if (lock)
 219 5345b4c7 2021-07-06 stsp 			got_lockfile_unlock(lf, -1);
 220 5261c201 2018-04-01 stsp 		goto done;
 221 5261c201 2018-04-01 stsp 	}
 222 c30018ad 2019-10-21 stsp 	while (linelen > 0 && line[linelen - 1] == '\n') {
 223 c30018ad 2019-10-21 stsp 		line[linelen - 1] = '\0';
 224 c30018ad 2019-10-21 stsp 		linelen--;
 225 c30018ad 2019-10-21 stsp 	}
 226 5261c201 2018-04-01 stsp 
 227 3f338f0a 2021-07-27 stsp 	err = parse_ref_line(ref, absname, line, sb.st_mtime);
 228 f5c58ad1 2019-05-12 stsp 	if (lock) {
 229 f5c58ad1 2019-05-12 stsp 		if (err)
 230 5345b4c7 2021-07-06 stsp 			got_lockfile_unlock(lf, -1);
 231 f5c58ad1 2019-05-12 stsp 		else {
 232 f5c58ad1 2019-05-12 stsp 			if (*ref)
 233 f5c58ad1 2019-05-12 stsp 				(*ref)->lf = lf;
 234 f5c58ad1 2019-05-12 stsp 			else
 235 5345b4c7 2021-07-06 stsp 				got_lockfile_unlock(lf, -1);
 236 f5c58ad1 2019-05-12 stsp 		}
 237 f5c58ad1 2019-05-12 stsp 	}
 238 5261c201 2018-04-01 stsp done:
 239 5261c201 2018-04-01 stsp 	free(line);
 240 56b63ca4 2021-01-22 stsp 	if (fclose(f) == EOF && err == NULL) {
 241 638f9024 2019-05-13 stsp 		err = got_error_from_errno("fclose");
 242 2f17228e 2019-05-12 stsp 		if (*ref) {
 243 f5c58ad1 2019-05-12 stsp 			if (lock)
 244 f5c58ad1 2019-05-12 stsp 				got_ref_unlock(*ref);
 245 2f17228e 2019-05-12 stsp 			got_ref_close(*ref);
 246 2f17228e 2019-05-12 stsp 			*ref = NULL;
 247 2f17228e 2019-05-12 stsp 		}
 248 2f17228e 2019-05-12 stsp 	}
 249 5261c201 2018-04-01 stsp 	return err;
 250 5261c201 2018-04-01 stsp }
 251 5261c201 2018-04-01 stsp 
 252 c5f754cc 2019-02-01 stsp static int
 253 c5f754cc 2019-02-01 stsp is_well_known_ref(const char *refname)
 254 5261c201 2018-04-01 stsp {
 255 c5f754cc 2019-02-01 stsp 	return (strcmp(refname, GOT_REF_HEAD) == 0 ||
 256 5261c201 2018-04-01 stsp 	    strcmp(refname, GOT_REF_ORIG_HEAD) == 0 ||
 257 5261c201 2018-04-01 stsp 	    strcmp(refname, GOT_REF_MERGE_HEAD) == 0 ||
 258 c5f754cc 2019-02-01 stsp 	    strcmp(refname, GOT_REF_FETCH_HEAD) == 0);
 259 c5f754cc 2019-02-01 stsp }
 260 c5f754cc 2019-02-01 stsp 
 261 c5f754cc 2019-02-01 stsp static char *
 262 c5f754cc 2019-02-01 stsp get_refs_dir_path(struct got_repository *repo, const char *refname)
 263 c5f754cc 2019-02-01 stsp {
 264 c5f754cc 2019-02-01 stsp 	if (is_well_known_ref(refname) || strncmp(refname, "refs/", 5) == 0)
 265 6e9da951 2019-01-06 stsp 		return strdup(got_repo_get_path_git_dir(repo));
 266 5261c201 2018-04-01 stsp 
 267 5261c201 2018-04-01 stsp 	return got_repo_get_path_refs(repo);
 268 5892cdd6 2019-03-10 stsp }
 269 5892cdd6 2019-03-10 stsp 
 270 5892cdd6 2019-03-10 stsp const struct got_error *
 271 5892cdd6 2019-03-10 stsp got_ref_alloc(struct got_reference **ref, const char *name,
 272 5892cdd6 2019-03-10 stsp     struct got_object_id *id)
 273 5892cdd6 2019-03-10 stsp {
 274 63e5aa5c 2021-08-23 stsp 	if (!got_ref_name_is_valid(name))
 275 24b5452a 2019-10-09 stsp 		return got_error_path(name, GOT_ERR_BAD_REF_NAME);
 276 f77a24b0 2019-03-11 stsp 
 277 3f338f0a 2021-07-27 stsp 	return alloc_ref(ref, name, id, 0, 0);
 278 aaf88317 2019-07-10 stsp }
 279 aaf88317 2019-07-10 stsp 
 280 aaf88317 2019-07-10 stsp const struct got_error *
 281 aaf88317 2019-07-10 stsp got_ref_alloc_symref(struct got_reference **ref, const char *name,
 282 aaf88317 2019-07-10 stsp 	struct got_reference *target_ref)
 283 aaf88317 2019-07-10 stsp {
 284 63e5aa5c 2021-08-23 stsp 	if (!got_ref_name_is_valid(name))
 285 24b5452a 2019-10-09 stsp 		return got_error_path(name, GOT_ERR_BAD_REF_NAME);
 286 aaf88317 2019-07-10 stsp 
 287 aaf88317 2019-07-10 stsp 	return alloc_symref(ref, name, got_ref_get_name(target_ref), 0);
 288 5261c201 2018-04-01 stsp }
 289 5261c201 2018-04-01 stsp 
 290 d1f2edc9 2018-06-13 stsp static const struct got_error *
 291 fb79db15 2019-02-01 stsp parse_packed_ref_line(struct got_reference **ref, const char *abs_refname,
 292 3f338f0a 2021-07-27 stsp     const char *line, time_t mtime)
 293 fb79db15 2019-02-01 stsp {
 294 5892cdd6 2019-03-10 stsp 	struct got_object_id id;
 295 5892cdd6 2019-03-10 stsp 	const char *name;
 296 fb79db15 2019-02-01 stsp 
 297 fb79db15 2019-02-01 stsp 	*ref = NULL;
 298 fb79db15 2019-02-01 stsp 
 299 532920c8 2019-02-01 stsp 	if (line[0] == '#' || line[0] == '^')
 300 fb79db15 2019-02-01 stsp 		return NULL;
 301 fb79db15 2019-02-01 stsp 
 302 5892cdd6 2019-03-10 stsp 	if (!got_parse_sha1_digest(id.sha1, line))
 303 30c0868d 2019-02-03 stsp 		return got_error(GOT_ERR_BAD_REF_DATA);
 304 fb79db15 2019-02-01 stsp 
 305 199a4027 2019-02-02 stsp 	if (abs_refname) {
 306 199a4027 2019-02-02 stsp 		if (strcmp(line + SHA1_DIGEST_STRING_LENGTH, abs_refname) != 0)
 307 199a4027 2019-02-02 stsp 			return NULL;
 308 5892cdd6 2019-03-10 stsp 		name = abs_refname;
 309 5892cdd6 2019-03-10 stsp 	} else
 310 5892cdd6 2019-03-10 stsp 		name = line + SHA1_DIGEST_STRING_LENGTH;
 311 fb79db15 2019-02-01 stsp 
 312 3f338f0a 2021-07-27 stsp 	return alloc_ref(ref, name, &id, GOT_REF_IS_PACKED, mtime);
 313 fb79db15 2019-02-01 stsp }
 314 fb79db15 2019-02-01 stsp 
 315 fb79db15 2019-02-01 stsp static const struct got_error *
 316 0dec1cc0 2019-02-01 stsp open_packed_ref(struct got_reference **ref, FILE *f, const char **subdirs,
 317 3f338f0a 2021-07-27 stsp     int nsubdirs, const char *refname, time_t mtime)
 318 fb79db15 2019-02-01 stsp {
 319 fb79db15 2019-02-01 stsp 	const struct got_error *err = NULL;
 320 fb79db15 2019-02-01 stsp 	char *abs_refname;
 321 9bdd68dd 2020-01-02 naddy 	char *line = NULL;
 322 9bdd68dd 2020-01-02 naddy 	size_t linesize = 0;
 323 9bdd68dd 2020-01-02 naddy 	ssize_t linelen;
 324 0dec1cc0 2019-02-01 stsp 	int i, ref_is_absolute = (strncmp(refname, "refs/", 5) == 0);
 325 fb79db15 2019-02-01 stsp 
 326 1e37702e 2019-02-04 stsp 	*ref = NULL;
 327 1e37702e 2019-02-04 stsp 
 328 0dec1cc0 2019-02-01 stsp 	if (ref_is_absolute)
 329 0dec1cc0 2019-02-01 stsp 		abs_refname = (char *)refname;
 330 fb79db15 2019-02-01 stsp 	do {
 331 9bdd68dd 2020-01-02 naddy 		linelen = getline(&line, &linesize, f);
 332 9bdd68dd 2020-01-02 naddy 		if (linelen == -1) {
 333 7ab0422a 2019-03-15 stsp 			if (feof(f))
 334 7ab0422a 2019-03-15 stsp 				break;
 335 7ab0422a 2019-03-15 stsp 			err = got_ferror(f, GOT_ERR_BAD_REF_DATA);
 336 fb79db15 2019-02-01 stsp 			break;
 337 7ab0422a 2019-03-15 stsp 		}
 338 9bdd68dd 2020-01-02 naddy 		if (linelen > 0 && line[linelen - 1] == '\n')
 339 9bdd68dd 2020-01-02 naddy 			line[linelen - 1] = '\0';
 340 0dec1cc0 2019-02-01 stsp 		for (i = 0; i < nsubdirs; i++) {
 341 0dec1cc0 2019-02-01 stsp 			if (!ref_is_absolute &&
 342 0dec1cc0 2019-02-01 stsp 			    asprintf(&abs_refname, "refs/%s/%s", subdirs[i],
 343 0dec1cc0 2019-02-01 stsp 			    refname) == -1)
 344 638f9024 2019-05-13 stsp 				return got_error_from_errno("asprintf");
 345 3f338f0a 2021-07-27 stsp 			err = parse_packed_ref_line(ref, abs_refname, line,
 346 3f338f0a 2021-07-27 stsp 			    mtime);
 347 0dec1cc0 2019-02-01 stsp 			if (!ref_is_absolute)
 348 0dec1cc0 2019-02-01 stsp 				free(abs_refname);
 349 532920c8 2019-02-01 stsp 			if (err || *ref != NULL)
 350 0dec1cc0 2019-02-01 stsp 				break;
 351 0dec1cc0 2019-02-01 stsp 		}
 352 fb79db15 2019-02-01 stsp 		if (err)
 353 fb79db15 2019-02-01 stsp 			break;
 354 fb79db15 2019-02-01 stsp 	} while (*ref == NULL);
 355 9bdd68dd 2020-01-02 naddy 	free(line);
 356 fb79db15 2019-02-01 stsp 
 357 fb79db15 2019-02-01 stsp 	return err;
 358 fb79db15 2019-02-01 stsp }
 359 fb79db15 2019-02-01 stsp 
 360 fb79db15 2019-02-01 stsp static const struct got_error *
 361 d1f2edc9 2018-06-13 stsp open_ref(struct got_reference **ref, const char *path_refs, const char *subdir,
 362 2f17228e 2019-05-12 stsp     const char *name, int lock)
 363 d1f2edc9 2018-06-13 stsp {
 364 d1f2edc9 2018-06-13 stsp 	const struct got_error *err = NULL;
 365 a04f49d2 2019-02-04 stsp 	char *path = NULL;
 366 a04f49d2 2019-02-04 stsp 	char *absname = NULL;
 367 a04f49d2 2019-02-04 stsp 	int ref_is_absolute = (strncmp(name, "refs/", 5) == 0);
 368 75236079 2020-03-25 stsp 	int ref_is_well_known = (subdir[0] == '\0' && is_well_known_ref(name));
 369 d1f2edc9 2018-06-13 stsp 
 370 1e37702e 2019-02-04 stsp 	*ref = NULL;
 371 1e37702e 2019-02-04 stsp 
 372 63e5aa5c 2021-08-23 stsp 	if (!got_ref_name_is_valid(name))
 373 57c18198 2021-05-24 stsp 		return got_error_path(name, GOT_ERR_BAD_REF_NAME);
 374 57c18198 2021-05-24 stsp 
 375 a04f49d2 2019-02-04 stsp 	if (ref_is_absolute || ref_is_well_known) {
 376 a04f49d2 2019-02-04 stsp 		if (asprintf(&path, "%s/%s", path_refs, name) == -1)
 377 638f9024 2019-05-13 stsp 			return got_error_from_errno("asprintf");
 378 a04f49d2 2019-02-04 stsp 		absname = (char *)name;
 379 a04f49d2 2019-02-04 stsp 	} else {
 380 58908ed0 2019-03-11 stsp 		if (asprintf(&path, "%s/%s%s%s", path_refs, subdir,
 381 58908ed0 2019-03-11 stsp 		    subdir[0] ? "/" : "", name) == -1)
 382 638f9024 2019-05-13 stsp 			return got_error_from_errno("asprintf");
 383 d1f2edc9 2018-06-13 stsp 
 384 58908ed0 2019-03-11 stsp 		if (asprintf(&absname, "refs/%s%s%s",
 385 58908ed0 2019-03-11 stsp 		    subdir, subdir[0] ? "/" : "", name) == -1) {
 386 638f9024 2019-05-13 stsp 			err = got_error_from_errno("asprintf");
 387 a04f49d2 2019-02-04 stsp 			goto done;
 388 a04f49d2 2019-02-04 stsp 		}
 389 a04f49d2 2019-02-04 stsp 	}
 390 a04f49d2 2019-02-04 stsp 
 391 b2070a3f 2020-03-22 stsp 	err = parse_ref_file(ref, name, absname, path, lock);
 392 d1f2edc9 2018-06-13 stsp done:
 393 a04f49d2 2019-02-04 stsp 	if (!ref_is_absolute && !ref_is_well_known)
 394 a04f49d2 2019-02-04 stsp 		free(absname);
 395 a04f49d2 2019-02-04 stsp 	free(path);
 396 d1f2edc9 2018-06-13 stsp 	return err;
 397 d1f2edc9 2018-06-13 stsp }
 398 d1f2edc9 2018-06-13 stsp 
 399 5261c201 2018-04-01 stsp const struct got_error *
 400 5261c201 2018-04-01 stsp got_ref_open(struct got_reference **ref, struct got_repository *repo,
 401 abc59930 2021-09-05 naddy     const char *refname, int lock)
 402 5261c201 2018-04-01 stsp {
 403 5261c201 2018-04-01 stsp 	const struct got_error *err = NULL;
 404 c3821bef 2022-07-21 florian 	char *packed_refs_path = NULL, *path_refs = NULL;
 405 fb79db15 2019-02-01 stsp 	const char *subdirs[] = {
 406 fb79db15 2019-02-01 stsp 	    GOT_REF_HEADS, GOT_REF_TAGS, GOT_REF_REMOTES
 407 fb79db15 2019-02-01 stsp 	};
 408 16aeacf7 2020-11-26 stsp 	size_t i;
 409 16aeacf7 2020-11-26 stsp 	int well_known = is_well_known_ref(refname);
 410 a875589a 2019-05-12 stsp 	struct got_lockfile *lf = NULL;
 411 1e37702e 2019-02-04 stsp 
 412 1e37702e 2019-02-04 stsp 	*ref = NULL;
 413 e135804e 2019-02-10 stsp 
 414 e135804e 2019-02-10 stsp 	path_refs = get_refs_dir_path(repo, refname);
 415 e135804e 2019-02-10 stsp 	if (path_refs == NULL) {
 416 638f9024 2019-05-13 stsp 		err = got_error_from_errno2("get_refs_dir_path", refname);
 417 e135804e 2019-02-10 stsp 		goto done;
 418 e135804e 2019-02-10 stsp 	}
 419 5261c201 2018-04-01 stsp 
 420 0885ce8f 2019-05-12 stsp 	if (well_known) {
 421 0885ce8f 2019-05-12 stsp 		err = open_ref(ref, path_refs, "", refname, lock);
 422 0885ce8f 2019-05-12 stsp 	} else {
 423 c5f754cc 2019-02-01 stsp 		FILE *f;
 424 c5f754cc 2019-02-01 stsp 
 425 e135804e 2019-02-10 stsp 		/* Search on-disk refs before packed refs! */
 426 e135804e 2019-02-10 stsp 		for (i = 0; i < nitems(subdirs); i++) {
 427 2f17228e 2019-05-12 stsp 			err = open_ref(ref, path_refs, subdirs[i], refname,
 428 2f17228e 2019-05-12 stsp 			    lock);
 429 b2070a3f 2020-03-22 stsp 			if ((err && err->code != GOT_ERR_NOT_REF) || *ref)
 430 e135804e 2019-02-10 stsp 				goto done;
 431 e135804e 2019-02-10 stsp 		}
 432 e135804e 2019-02-10 stsp 
 433 c5f754cc 2019-02-01 stsp 		packed_refs_path = got_repo_get_path_packed_refs(repo);
 434 e135804e 2019-02-10 stsp 		if (packed_refs_path == NULL) {
 435 638f9024 2019-05-13 stsp 			err = got_error_from_errno(
 436 230a42bd 2019-05-11 jcs 			    "got_repo_get_path_packed_refs");
 437 e135804e 2019-02-10 stsp 			goto done;
 438 e135804e 2019-02-10 stsp 		}
 439 c5f754cc 2019-02-01 stsp 
 440 2f17228e 2019-05-12 stsp 		if (lock) {
 441 5345b4c7 2021-07-06 stsp 			err = got_lockfile_lock(&lf, packed_refs_path, -1);
 442 2f17228e 2019-05-12 stsp 			if (err)
 443 2f17228e 2019-05-12 stsp 				goto done;
 444 2f17228e 2019-05-12 stsp 		}
 445 00fe21f2 2021-12-31 stsp 		f = fopen(packed_refs_path, "rbe");
 446 c5f754cc 2019-02-01 stsp 		if (f != NULL) {
 447 3f338f0a 2021-07-27 stsp 			struct stat sb;
 448 3f338f0a 2021-07-27 stsp 			if (fstat(fileno(f), &sb) == -1) {
 449 3f338f0a 2021-07-27 stsp 				err = got_error_from_errno2("fstat",
 450 3f338f0a 2021-07-27 stsp 				    packed_refs_path);
 451 3f338f0a 2021-07-27 stsp 				goto done;
 452 3f338f0a 2021-07-27 stsp 			}
 453 0dec1cc0 2019-02-01 stsp 			err = open_packed_ref(ref, f, subdirs, nitems(subdirs),
 454 3f338f0a 2021-07-27 stsp 			    refname, sb.st_mtime);
 455 a875589a 2019-05-12 stsp 			if (!err) {
 456 56b63ca4 2021-01-22 stsp 				if (fclose(f) == EOF) {
 457 638f9024 2019-05-13 stsp 					err = got_error_from_errno("fclose");
 458 a875589a 2019-05-12 stsp 					got_ref_close(*ref);
 459 a875589a 2019-05-12 stsp 					*ref = NULL;
 460 6e472abb 2019-05-13 stsp 				} else if (*ref)
 461 a875589a 2019-05-12 stsp 					(*ref)->lf = lf;
 462 a875589a 2019-05-12 stsp 			}
 463 fb79db15 2019-02-01 stsp 		}
 464 fb79db15 2019-02-01 stsp 	}
 465 e135804e 2019-02-10 stsp done:
 466 5b575c25 2019-05-12 stsp 	if (!err && *ref == NULL)
 467 1e37702e 2019-02-04 stsp 		err = got_error_not_ref(refname);
 468 a875589a 2019-05-12 stsp 	if (err && lf)
 469 5345b4c7 2021-07-06 stsp 		got_lockfile_unlock(lf, -1);
 470 c3821bef 2022-07-21 florian 	free(packed_refs_path);
 471 5261c201 2018-04-01 stsp 	free(path_refs);
 472 5261c201 2018-04-01 stsp 	return err;
 473 5261c201 2018-04-01 stsp }
 474 5261c201 2018-04-01 stsp 
 475 5261c201 2018-04-01 stsp void
 476 5261c201 2018-04-01 stsp got_ref_close(struct got_reference *ref)
 477 5261c201 2018-04-01 stsp {
 478 e09d28b1 2019-03-15 stsp 	if (ref->flags & GOT_REF_IS_SYMBOLIC) {
 479 5261c201 2018-04-01 stsp 		free(ref->ref.symref.name);
 480 e09d28b1 2019-03-15 stsp 		free(ref->ref.symref.ref);
 481 e09d28b1 2019-03-15 stsp 	} else
 482 5261c201 2018-04-01 stsp 		free(ref->ref.ref.name);
 483 5261c201 2018-04-01 stsp 	free(ref);
 484 5261c201 2018-04-01 stsp }
 485 5261c201 2018-04-01 stsp 
 486 5261c201 2018-04-01 stsp struct got_reference *
 487 5261c201 2018-04-01 stsp got_ref_dup(struct got_reference *ref)
 488 5261c201 2018-04-01 stsp {
 489 5261c201 2018-04-01 stsp 	struct got_reference *ret;
 490 5261c201 2018-04-01 stsp 
 491 5261c201 2018-04-01 stsp 	ret = calloc(1, sizeof(*ret));
 492 5261c201 2018-04-01 stsp 	if (ret == NULL)
 493 5261c201 2018-04-01 stsp 		return NULL;
 494 5261c201 2018-04-01 stsp 
 495 5261c201 2018-04-01 stsp 	ret->flags = ref->flags;
 496 5261c201 2018-04-01 stsp 	if (ref->flags & GOT_REF_IS_SYMBOLIC) {
 497 5261c201 2018-04-01 stsp 		ret->ref.symref.name = strdup(ref->ref.symref.name);
 498 5261c201 2018-04-01 stsp 		if (ret->ref.symref.name == NULL) {
 499 5261c201 2018-04-01 stsp 			free(ret);
 500 5261c201 2018-04-01 stsp 			return NULL;
 501 5261c201 2018-04-01 stsp 		}
 502 5261c201 2018-04-01 stsp 		ret->ref.symref.ref = strdup(ref->ref.symref.ref);
 503 5261c201 2018-04-01 stsp 		if (ret->ref.symref.ref == NULL) {
 504 5261c201 2018-04-01 stsp 			free(ret->ref.symref.name);
 505 5261c201 2018-04-01 stsp 			free(ret);
 506 5261c201 2018-04-01 stsp 			return NULL;
 507 5261c201 2018-04-01 stsp 		}
 508 5261c201 2018-04-01 stsp 	} else {
 509 4c4ce67b 2020-12-25 stsp 		ret->ref.ref.name = strdup(ref->ref.ref.name);
 510 4c4ce67b 2020-12-25 stsp 		if (ret->ref.ref.name == NULL) {
 511 5261c201 2018-04-01 stsp 			free(ret);
 512 5261c201 2018-04-01 stsp 			return NULL;
 513 5261c201 2018-04-01 stsp 		}
 514 5261c201 2018-04-01 stsp 		memcpy(ret->ref.ref.sha1, ref->ref.ref.sha1,
 515 80d5fc1f 2019-03-15 stsp 		    sizeof(ret->ref.ref.sha1));
 516 5261c201 2018-04-01 stsp 	}
 517 5261c201 2018-04-01 stsp 
 518 5261c201 2018-04-01 stsp 	return ret;
 519 5261c201 2018-04-01 stsp }
 520 b8bad2ba 2019-08-23 stsp 
 521 b8bad2ba 2019-08-23 stsp const struct got_error *
 522 b8bad2ba 2019-08-23 stsp got_reflist_entry_dup(struct got_reflist_entry **newp,
 523 b8bad2ba 2019-08-23 stsp     struct got_reflist_entry *re)
 524 b8bad2ba 2019-08-23 stsp {
 525 b8bad2ba 2019-08-23 stsp 	const struct got_error *err = NULL;
 526 b8bad2ba 2019-08-23 stsp 	struct got_reflist_entry *new;
 527 b8bad2ba 2019-08-23 stsp 
 528 b8bad2ba 2019-08-23 stsp 	*newp = NULL;
 529 b8bad2ba 2019-08-23 stsp 
 530 b8bad2ba 2019-08-23 stsp 	new = malloc(sizeof(*new));
 531 b8bad2ba 2019-08-23 stsp 	if (new == NULL)
 532 b8bad2ba 2019-08-23 stsp 		return got_error_from_errno("malloc");
 533 5261c201 2018-04-01 stsp 
 534 b8bad2ba 2019-08-23 stsp 	new->ref = got_ref_dup(re->ref);
 535 b8bad2ba 2019-08-23 stsp 	if (new->ref == NULL) {
 536 b8bad2ba 2019-08-23 stsp 		err = got_error_from_errno("got_ref_dup");
 537 b8bad2ba 2019-08-23 stsp 		free(new);
 538 b8bad2ba 2019-08-23 stsp 		return err;
 539 b8bad2ba 2019-08-23 stsp 	}
 540 b8bad2ba 2019-08-23 stsp 
 541 b8bad2ba 2019-08-23 stsp 	*newp = new;
 542 b8bad2ba 2019-08-23 stsp 	return NULL;
 543 b8bad2ba 2019-08-23 stsp }
 544 b8bad2ba 2019-08-23 stsp 
 545 cce2f485 2021-08-22 stsp const struct got_error *
 546 cce2f485 2021-08-22 stsp got_ref_resolve_symbolic(struct got_reference **resolved,
 547 5261c201 2018-04-01 stsp     struct got_repository *repo, struct got_reference *ref)
 548 5261c201 2018-04-01 stsp {
 549 5261c201 2018-04-01 stsp 	struct got_reference *nextref;
 550 5261c201 2018-04-01 stsp 	const struct got_error *err;
 551 5261c201 2018-04-01 stsp 
 552 2f17228e 2019-05-12 stsp 	err = got_ref_open(&nextref, repo, ref->ref.symref.ref, 0);
 553 5261c201 2018-04-01 stsp 	if (err)
 554 5261c201 2018-04-01 stsp 		return err;
 555 5261c201 2018-04-01 stsp 
 556 5261c201 2018-04-01 stsp 	if (nextref->flags & GOT_REF_IS_SYMBOLIC)
 557 cce2f485 2021-08-22 stsp 		err = got_ref_resolve_symbolic(resolved, repo, nextref);
 558 5261c201 2018-04-01 stsp 	else
 559 5261c201 2018-04-01 stsp 		*resolved = got_ref_dup(nextref);
 560 5261c201 2018-04-01 stsp 
 561 5261c201 2018-04-01 stsp 	got_ref_close(nextref);
 562 5261c201 2018-04-01 stsp 	return err;
 563 5261c201 2018-04-01 stsp }
 564 5261c201 2018-04-01 stsp 
 565 29e86f7a 2019-08-12 stsp static const struct got_error *
 566 29e86f7a 2019-08-12 stsp ref_resolve(struct got_object_id **id, struct got_repository *repo,
 567 29e86f7a 2019-08-12 stsp     struct got_reference *ref, int recursion)
 568 5261c201 2018-04-01 stsp {
 569 5261c201 2018-04-01 stsp 	const struct got_error *err;
 570 5261c201 2018-04-01 stsp 
 571 29e86f7a 2019-08-12 stsp 	if (recursion <= 0)
 572 29e86f7a 2019-08-12 stsp 		return got_error_msg(GOT_ERR_RECURSION,
 573 29e86f7a 2019-08-12 stsp 		    "reference recursion limit reached");
 574 29e86f7a 2019-08-12 stsp 
 575 5261c201 2018-04-01 stsp 	if (ref->flags & GOT_REF_IS_SYMBOLIC) {
 576 5261c201 2018-04-01 stsp 		struct got_reference *resolved = NULL;
 577 cce2f485 2021-08-22 stsp 		err = got_ref_resolve_symbolic(&resolved, repo, ref);
 578 5261c201 2018-04-01 stsp 		if (err == NULL)
 579 29e86f7a 2019-08-12 stsp 			err = ref_resolve(id, repo, resolved, --recursion);
 580 57b6f99a 2019-04-13 stsp 		if (resolved)
 581 57b6f99a 2019-04-13 stsp 			got_ref_close(resolved);
 582 5261c201 2018-04-01 stsp 		return err;
 583 5261c201 2018-04-01 stsp 	}
 584 5261c201 2018-04-01 stsp 
 585 5261c201 2018-04-01 stsp 	*id = calloc(1, sizeof(**id));
 586 5261c201 2018-04-01 stsp 	if (*id == NULL)
 587 638f9024 2019-05-13 stsp 		return got_error_from_errno("calloc");
 588 80d5fc1f 2019-03-15 stsp 	memcpy((*id)->sha1, ref->ref.ref.sha1, sizeof((*id)->sha1));
 589 5261c201 2018-04-01 stsp 	return NULL;
 590 29e86f7a 2019-08-12 stsp }
 591 29e86f7a 2019-08-12 stsp 
 592 29e86f7a 2019-08-12 stsp const struct got_error *
 593 29e86f7a 2019-08-12 stsp got_ref_resolve(struct got_object_id **id, struct got_repository *repo,
 594 29e86f7a 2019-08-12 stsp     struct got_reference *ref)
 595 29e86f7a 2019-08-12 stsp {
 596 29e86f7a 2019-08-12 stsp 	return ref_resolve(id, repo, ref, GOT_REF_RECURSE_MAX);
 597 5261c201 2018-04-01 stsp }
 598 5261c201 2018-04-01 stsp 
 599 5261c201 2018-04-01 stsp char *
 600 5261c201 2018-04-01 stsp got_ref_to_str(struct got_reference *ref)
 601 5261c201 2018-04-01 stsp {
 602 5261c201 2018-04-01 stsp 	char *str;
 603 271d2a38 2018-12-25 stsp 
 604 271d2a38 2018-12-25 stsp 	if (ref->flags & GOT_REF_IS_SYMBOLIC)
 605 271d2a38 2018-12-25 stsp 		return strdup(ref->ref.symref.ref);
 606 271d2a38 2018-12-25 stsp 
 607 271d2a38 2018-12-25 stsp 	str = malloc(SHA1_DIGEST_STRING_LENGTH);
 608 271d2a38 2018-12-25 stsp 	if (str == NULL)
 609 271d2a38 2018-12-25 stsp 		return NULL;
 610 271d2a38 2018-12-25 stsp 
 611 271d2a38 2018-12-25 stsp 	if (got_sha1_digest_to_str(ref->ref.ref.sha1, str,
 612 271d2a38 2018-12-25 stsp 	    SHA1_DIGEST_STRING_LENGTH) == NULL) {
 613 271d2a38 2018-12-25 stsp 		free(str);
 614 271d2a38 2018-12-25 stsp 		return NULL;
 615 5261c201 2018-04-01 stsp 	}
 616 5261c201 2018-04-01 stsp 
 617 5261c201 2018-04-01 stsp 	return str;
 618 5261c201 2018-04-01 stsp }
 619 0bd18d37 2019-02-01 stsp 
 620 0bd18d37 2019-02-01 stsp const char *
 621 0bd18d37 2019-02-01 stsp got_ref_get_name(struct got_reference *ref)
 622 0bd18d37 2019-02-01 stsp {
 623 0bd18d37 2019-02-01 stsp 	if (ref->flags & GOT_REF_IS_SYMBOLIC)
 624 0bd18d37 2019-02-01 stsp 		return ref->ref.symref.name;
 625 0bd18d37 2019-02-01 stsp 
 626 0bd18d37 2019-02-01 stsp 	return ref->ref.ref.name;
 627 199a4027 2019-02-02 stsp }
 628 199a4027 2019-02-02 stsp 
 629 aaf88317 2019-07-10 stsp const char *
 630 aaf88317 2019-07-10 stsp got_ref_get_symref_target(struct got_reference *ref)
 631 aaf88317 2019-07-10 stsp {
 632 aaf88317 2019-07-10 stsp 	if (ref->flags & GOT_REF_IS_SYMBOLIC)
 633 aaf88317 2019-07-10 stsp 		return ref->ref.symref.ref;
 634 b8bad2ba 2019-08-23 stsp 
 635 b8bad2ba 2019-08-23 stsp 	return NULL;
 636 3f338f0a 2021-07-27 stsp }
 637 3f338f0a 2021-07-27 stsp 
 638 3f338f0a 2021-07-27 stsp time_t
 639 3f338f0a 2021-07-27 stsp got_ref_get_mtime(struct got_reference *ref)
 640 3f338f0a 2021-07-27 stsp {
 641 3f338f0a 2021-07-27 stsp 	return ref->mtime;
 642 b8bad2ba 2019-08-23 stsp }
 643 b8bad2ba 2019-08-23 stsp 
 644 b8bad2ba 2019-08-23 stsp const struct got_error *
 645 b8bad2ba 2019-08-23 stsp got_ref_cmp_by_name(void *arg, int *cmp, struct got_reference *re1,
 646 b8bad2ba 2019-08-23 stsp     struct got_reference* re2)
 647 b8bad2ba 2019-08-23 stsp {
 648 b8bad2ba 2019-08-23 stsp 	const char *name1 = got_ref_get_name(re1);
 649 b8bad2ba 2019-08-23 stsp 	const char *name2 = got_ref_get_name(re2);
 650 aaf88317 2019-07-10 stsp 
 651 b8bad2ba 2019-08-23 stsp 	*cmp = got_path_cmp(name1, name2, strlen(name1), strlen(name2));
 652 aaf88317 2019-07-10 stsp 	return NULL;
 653 d1f16636 2020-01-15 stsp }
 654 d1f16636 2020-01-15 stsp 
 655 d1f16636 2020-01-15 stsp const struct got_error *
 656 d1f16636 2020-01-15 stsp got_ref_cmp_tags(void *arg, int *cmp, struct got_reference *ref1,
 657 d1f16636 2020-01-15 stsp     struct got_reference *ref2)
 658 d1f16636 2020-01-15 stsp {
 659 d1f16636 2020-01-15 stsp 	const struct got_error *err = NULL;
 660 d1f16636 2020-01-15 stsp 	struct got_repository *repo = arg;
 661 d1f16636 2020-01-15 stsp 	struct got_object_id *id1, *id2 = NULL;
 662 d1f16636 2020-01-15 stsp 	struct got_tag_object *tag1 = NULL, *tag2 = NULL;
 663 d1f16636 2020-01-15 stsp 	struct got_commit_object *commit1 = NULL, *commit2 = NULL;
 664 d1f16636 2020-01-15 stsp 	time_t time1, time2;
 665 d1f16636 2020-01-15 stsp 
 666 d1f16636 2020-01-15 stsp 	*cmp = 0;
 667 d1f16636 2020-01-15 stsp 
 668 d1f16636 2020-01-15 stsp 	err = got_ref_resolve(&id1, repo, ref1);
 669 d1f16636 2020-01-15 stsp 	if (err)
 670 d1f16636 2020-01-15 stsp 		return err;
 671 d1f16636 2020-01-15 stsp 	err = got_object_open_as_tag(&tag1, repo, id1);
 672 d1f16636 2020-01-15 stsp 	if (err) {
 673 d1f16636 2020-01-15 stsp 		if (err->code != GOT_ERR_OBJ_TYPE)
 674 d1f16636 2020-01-15 stsp 			goto done;
 675 d1f16636 2020-01-15 stsp 		/* "lightweight" tag */
 676 d1f16636 2020-01-15 stsp 		err = got_object_open_as_commit(&commit1, repo, id1);
 677 d1f16636 2020-01-15 stsp 		if (err)
 678 d1f16636 2020-01-15 stsp 			goto done;
 679 d1f16636 2020-01-15 stsp 		time1 = got_object_commit_get_committer_time(commit1);
 680 d1f16636 2020-01-15 stsp 	} else
 681 d1f16636 2020-01-15 stsp 		time1 = got_object_tag_get_tagger_time(tag1);
 682 d1f16636 2020-01-15 stsp 
 683 d1f16636 2020-01-15 stsp 	err = got_ref_resolve(&id2, repo, ref2);
 684 d1f16636 2020-01-15 stsp 	if (err)
 685 d1f16636 2020-01-15 stsp 		goto done;
 686 d1f16636 2020-01-15 stsp 	err = got_object_open_as_tag(&tag2, repo, id2);
 687 d1f16636 2020-01-15 stsp 	if (err) {
 688 d1f16636 2020-01-15 stsp 		if (err->code != GOT_ERR_OBJ_TYPE)
 689 d1f16636 2020-01-15 stsp 			goto done;
 690 d1f16636 2020-01-15 stsp 		/* "lightweight" tag */
 691 d1f16636 2020-01-15 stsp 		err = got_object_open_as_commit(&commit2, repo, id2);
 692 d1f16636 2020-01-15 stsp 		if (err)
 693 d1f16636 2020-01-15 stsp 			goto done;
 694 d1f16636 2020-01-15 stsp 		time2 = got_object_commit_get_committer_time(commit2);
 695 d1f16636 2020-01-15 stsp 	} else
 696 d1f16636 2020-01-15 stsp 		time2 = got_object_tag_get_tagger_time(tag2);
 697 d1f16636 2020-01-15 stsp 
 698 d1f16636 2020-01-15 stsp 	/* Put latest tags first. */
 699 d1f16636 2020-01-15 stsp 	if (time1 < time2)
 700 d1f16636 2020-01-15 stsp 		*cmp = 1;
 701 d1f16636 2020-01-15 stsp 	else if (time1 > time2)
 702 d1f16636 2020-01-15 stsp 		*cmp = -1;
 703 d1f16636 2020-01-15 stsp 	else
 704 d1f16636 2020-01-15 stsp 		err = got_ref_cmp_by_name(NULL, cmp, ref2, ref1);
 705 d1f16636 2020-01-15 stsp done:
 706 d1f16636 2020-01-15 stsp 	free(id1);
 707 d1f16636 2020-01-15 stsp 	free(id2);
 708 d1f16636 2020-01-15 stsp 	if (tag1)
 709 d1f16636 2020-01-15 stsp 		got_object_tag_close(tag1);
 710 d1f16636 2020-01-15 stsp 	if (tag2)
 711 d1f16636 2020-01-15 stsp 		got_object_tag_close(tag2);
 712 e600f124 2021-03-21 stsp 	if (commit1)
 713 e600f124 2021-03-21 stsp 		got_object_commit_close(commit1);
 714 e600f124 2021-03-21 stsp 	if (commit2)
 715 e600f124 2021-03-21 stsp 		got_object_commit_close(commit2);
 716 7f66531d 2021-11-16 stsp 	return err;
 717 7f66531d 2021-11-16 stsp }
 718 7f66531d 2021-11-16 stsp 
 719 7f66531d 2021-11-16 stsp static const struct got_error *
 720 7f66531d 2021-11-16 stsp get_committer_time(struct got_reference *ref, struct got_repository *repo)
 721 7f66531d 2021-11-16 stsp {
 722 7f66531d 2021-11-16 stsp 	const struct got_error *err = NULL;
 723 7f66531d 2021-11-16 stsp 	int obj_type;
 724 7f66531d 2021-11-16 stsp 	struct got_commit_object *commit = NULL;
 725 7f66531d 2021-11-16 stsp 	struct got_tag_object *tag = NULL;
 726 7f66531d 2021-11-16 stsp 	struct got_object_id *id = NULL;
 727 7f66531d 2021-11-16 stsp 
 728 7f66531d 2021-11-16 stsp 	err = got_ref_resolve(&id, repo, ref);
 729 7f66531d 2021-11-16 stsp 	if (err)
 730 7f66531d 2021-11-16 stsp 		return err;
 731 7f66531d 2021-11-16 stsp 
 732 7f66531d 2021-11-16 stsp 	err = got_object_get_type(&obj_type, repo, id);
 733 7f66531d 2021-11-16 stsp 	if (err)
 734 7f66531d 2021-11-16 stsp 		goto done;
 735 7f66531d 2021-11-16 stsp 
 736 7f66531d 2021-11-16 stsp 	switch (obj_type) {
 737 7f66531d 2021-11-16 stsp 	case GOT_OBJ_TYPE_COMMIT:
 738 7f66531d 2021-11-16 stsp 		err = got_object_open_as_commit(&commit, repo, id);
 739 7f66531d 2021-11-16 stsp 		if (err)
 740 7f66531d 2021-11-16 stsp 			goto done;
 741 7f66531d 2021-11-16 stsp 		ref->committer_time =
 742 7f66531d 2021-11-16 stsp 		    got_object_commit_get_committer_time(commit);
 743 7f66531d 2021-11-16 stsp 		break;
 744 7f66531d 2021-11-16 stsp 	case GOT_OBJ_TYPE_TAG:
 745 7f66531d 2021-11-16 stsp 		err = got_object_open_as_tag(&tag, repo, id);
 746 7f66531d 2021-11-16 stsp 		if (err)
 747 7f66531d 2021-11-16 stsp 			goto done;
 748 7f66531d 2021-11-16 stsp 		ref->committer_time = got_object_tag_get_tagger_time(tag);
 749 7f66531d 2021-11-16 stsp 		break;
 750 7f66531d 2021-11-16 stsp 	default:
 751 7f66531d 2021-11-16 stsp 		/* best effort for other object types */
 752 7f66531d 2021-11-16 stsp 		ref->committer_time = got_ref_get_mtime(ref);
 753 7f66531d 2021-11-16 stsp 		break;
 754 7f66531d 2021-11-16 stsp 	}
 755 7f66531d 2021-11-16 stsp done:
 756 7f66531d 2021-11-16 stsp 	free(id);
 757 7f66531d 2021-11-16 stsp 	if (commit)
 758 7f66531d 2021-11-16 stsp 		got_object_commit_close(commit);
 759 7f66531d 2021-11-16 stsp 	if (tag)
 760 7f66531d 2021-11-16 stsp 		got_object_tag_close(tag);
 761 e600f124 2021-03-21 stsp 	return err;
 762 e600f124 2021-03-21 stsp }
 763 e600f124 2021-03-21 stsp 
 764 e600f124 2021-03-21 stsp const struct got_error *
 765 e600f124 2021-03-21 stsp got_ref_cmp_by_commit_timestamp_descending(void *arg, int *cmp,
 766 e600f124 2021-03-21 stsp     struct got_reference *ref1, struct got_reference *ref2)
 767 e600f124 2021-03-21 stsp {
 768 0309152a 2021-11-20 stsp 	const struct got_error *err = NULL;
 769 e600f124 2021-03-21 stsp 	struct got_repository *repo = arg;
 770 e600f124 2021-03-21 stsp 
 771 e600f124 2021-03-21 stsp 	*cmp = 0;
 772 e600f124 2021-03-21 stsp 
 773 2c9e323b 2021-10-10 stsp 	if (ref1->committer_time == 0) {
 774 7f66531d 2021-11-16 stsp 		err = get_committer_time(ref1, repo);
 775 2c9e323b 2021-10-10 stsp 		if (err)
 776 2c9e323b 2021-10-10 stsp 			return err;
 777 2c9e323b 2021-10-10 stsp 	}
 778 7f66531d 2021-11-16 stsp 	if (ref2->committer_time == 0) {
 779 7f66531d 2021-11-16 stsp 		err = get_committer_time(ref2, repo);
 780 2c9e323b 2021-10-10 stsp 		if (err)
 781 2c9e323b 2021-10-10 stsp 			return err;
 782 2c9e323b 2021-10-10 stsp 	}
 783 2c9e323b 2021-10-10 stsp 
 784 2c9e323b 2021-10-10 stsp 	if (ref1->committer_time < ref2->committer_time)
 785 e600f124 2021-03-21 stsp 		*cmp = 1;
 786 2c9e323b 2021-10-10 stsp 	else if (ref2->committer_time < ref1->committer_time)
 787 e600f124 2021-03-21 stsp 		*cmp = -1;
 788 42864987 2021-11-20 stsp 	else
 789 42864987 2021-11-20 stsp 		return got_ref_cmp_by_name(arg, cmp, ref1, ref2);
 790 7f66531d 2021-11-16 stsp 
 791 d1f16636 2020-01-15 stsp 	return err;
 792 aaf88317 2019-07-10 stsp }
 793 aaf88317 2019-07-10 stsp 
 794 779e1159 2021-06-18 stsp const struct got_error *
 795 c0df5966 2021-12-31 stsp got_reflist_insert(struct got_reflist_entry **newp,
 796 c0df5966 2021-12-31 stsp     struct got_reflist_head *refs, struct got_reference *ref,
 797 c0df5966 2021-12-31 stsp     got_ref_cmp_cb cmp_cb, void *cmp_arg)
 798 199a4027 2019-02-02 stsp {
 799 199a4027 2019-02-02 stsp 	const struct got_error *err;
 800 d9dff0e5 2020-12-26 stsp 	struct got_reflist_entry *new, *re;
 801 e397b6db 2019-02-04 stsp 	int cmp;
 802 7a3c76f5 2019-02-05 stsp 
 803 505287be 2019-03-15 stsp 	*newp = NULL;
 804 7a3c76f5 2019-02-05 stsp 
 805 3d8e0c5e 2022-09-05 stsp 	if (cmp_cb != got_ref_cmp_by_name && (ref->flags & GOT_REF_IS_PACKED)) {
 806 7db2b0dd 2022-09-05 stsp 		/*
 807 7db2b0dd 2022-09-05 stsp 		 * If we are not sorting elements by name then we must still
 808 7db2b0dd 2022-09-05 stsp 		 * detect collisions between a packed ref and an on-disk ref
 809 7db2b0dd 2022-09-05 stsp 		 * using the same name. On-disk refs take precedence and are
 810 7db2b0dd 2022-09-05 stsp 		 * already present on the list before packed refs get added.
 811 7db2b0dd 2022-09-05 stsp 		 */
 812 7db2b0dd 2022-09-05 stsp 		TAILQ_FOREACH(re, refs, entry) {
 813 3d8e0c5e 2022-09-05 stsp 			err = got_ref_cmp_by_name(NULL, &cmp, re->ref, ref);
 814 7db2b0dd 2022-09-05 stsp 			if (err)
 815 7db2b0dd 2022-09-05 stsp 				return err;
 816 3d8e0c5e 2022-09-05 stsp 			if (cmp == 0)
 817 7db2b0dd 2022-09-05 stsp 				return NULL;
 818 7db2b0dd 2022-09-05 stsp 		}
 819 7db2b0dd 2022-09-05 stsp 	}
 820 7db2b0dd 2022-09-05 stsp 
 821 3d8e0c5e 2022-09-05 stsp 	new = malloc(sizeof(*new));
 822 3d8e0c5e 2022-09-05 stsp 	if (new == NULL)
 823 3d8e0c5e 2022-09-05 stsp 		return got_error_from_errno("malloc");
 824 3d8e0c5e 2022-09-05 stsp 	new->ref = ref;
 825 3d8e0c5e 2022-09-05 stsp 	*newp = new;
 826 3d8e0c5e 2022-09-05 stsp 
 827 29b5c214 2019-02-04 stsp 	/*
 828 29b5c214 2019-02-04 stsp 	 * We must de-duplicate entries on insert because packed-refs may
 829 29b5c214 2019-02-04 stsp 	 * contain redundant entries. On-disk refs take precedence.
 830 29b5c214 2019-02-04 stsp 	 * This code assumes that on-disk revs are read before packed-refs.
 831 e397b6db 2019-02-04 stsp 	 * We're iterating the list anyway, so insert elements sorted by name.
 832 d9dff0e5 2020-12-26 stsp 	 *
 833 d9dff0e5 2020-12-26 stsp 	 * Many callers will provide paths in a somewhat sorted order.
 834 d9dff0e5 2020-12-26 stsp 	 * Iterating backwards from the tail of the list should be more
 835 d9dff0e5 2020-12-26 stsp 	 * efficient than traversing through the entire list each time
 836 d9dff0e5 2020-12-26 stsp 	 * an element is inserted.
 837 29b5c214 2019-02-04 stsp 	 */
 838 d9dff0e5 2020-12-26 stsp 	re = TAILQ_LAST(refs, got_reflist_head);
 839 7a3c76f5 2019-02-05 stsp 	while (re) {
 840 b8bad2ba 2019-08-23 stsp 		err = (*cmp_cb)(cmp_arg, &cmp, re->ref, new->ref);
 841 b8bad2ba 2019-08-23 stsp 		if (err)
 842 b8bad2ba 2019-08-23 stsp 			return err;
 843 e397b6db 2019-02-04 stsp 		if (cmp == 0) {
 844 27a1ed03 2019-03-15 stsp 			/* duplicate */
 845 27a1ed03 2019-03-15 stsp 			free(new);
 846 505287be 2019-03-15 stsp 			*newp = NULL;
 847 7a3c76f5 2019-02-05 stsp 			return NULL;
 848 d9dff0e5 2020-12-26 stsp 		} else if (cmp < 0) {
 849 d9dff0e5 2020-12-26 stsp 			TAILQ_INSERT_AFTER(refs, re, new, entry);
 850 7a3c76f5 2019-02-05 stsp 			return NULL;
 851 7a3c76f5 2019-02-05 stsp 		}
 852 d9dff0e5 2020-12-26 stsp 		re = TAILQ_PREV(re, got_reflist_head, entry);
 853 29b5c214 2019-02-04 stsp 	}
 854 199a4027 2019-02-02 stsp 
 855 d9dff0e5 2020-12-26 stsp 	TAILQ_INSERT_HEAD(refs, new, entry);
 856 199a4027 2019-02-02 stsp 	return NULL;
 857 0bd18d37 2019-02-01 stsp }
 858 2d497592 2021-11-20 stsp 
 859 2d497592 2021-11-20 stsp const struct got_error *
 860 2d497592 2021-11-20 stsp got_reflist_sort(struct got_reflist_head *refs,
 861 2d497592 2021-11-20 stsp     got_ref_cmp_cb cmp_cb, void *cmp_arg)
 862 2d497592 2021-11-20 stsp {
 863 2d497592 2021-11-20 stsp 	const struct got_error *err = NULL;
 864 2d497592 2021-11-20 stsp 	struct got_reflist_entry *re, *tmp, *new;
 865 2d497592 2021-11-20 stsp 	struct got_reflist_head sorted;
 866 199a4027 2019-02-02 stsp 
 867 2d497592 2021-11-20 stsp 	TAILQ_INIT(&sorted);
 868 2d497592 2021-11-20 stsp 
 869 2d497592 2021-11-20 stsp 	TAILQ_FOREACH_SAFE(re, refs, entry, tmp) {
 870 2d497592 2021-11-20 stsp 		struct got_reference *ref = re->ref;
 871 2d497592 2021-11-20 stsp 		TAILQ_REMOVE(refs, re, entry);
 872 2d497592 2021-11-20 stsp 		free(re);
 873 2d497592 2021-11-20 stsp 		err = got_reflist_insert(&new, &sorted, ref, cmp_cb, cmp_arg);
 874 2d497592 2021-11-20 stsp 		if (err || new == NULL /* duplicate */)
 875 2d497592 2021-11-20 stsp 			got_ref_close(ref);
 876 2d497592 2021-11-20 stsp 		if (err)
 877 2d497592 2021-11-20 stsp 			return err;
 878 2d497592 2021-11-20 stsp 	}
 879 2d497592 2021-11-20 stsp 
 880 2d497592 2021-11-20 stsp 	TAILQ_CONCAT(refs, &sorted, entry);
 881 2d497592 2021-11-20 stsp 	return NULL;
 882 2d497592 2021-11-20 stsp }
 883 2d497592 2021-11-20 stsp 
 884 a04f49d2 2019-02-04 stsp static const struct got_error *
 885 29b5c214 2019-02-04 stsp gather_on_disk_refs(struct got_reflist_head *refs, const char *path_refs,
 886 b8bad2ba 2019-08-23 stsp     const char *subdir, struct got_repository *repo,
 887 b8bad2ba 2019-08-23 stsp     got_ref_cmp_cb cmp_cb, void *cmp_arg)
 888 a04f49d2 2019-02-04 stsp {
 889 a04f49d2 2019-02-04 stsp 	const struct got_error *err = NULL;
 890 a04f49d2 2019-02-04 stsp 	DIR *d = NULL;
 891 a04f49d2 2019-02-04 stsp 	char *path_subdir;
 892 b2070a3f 2020-03-22 stsp 
 893 b2070a3f 2020-03-22 stsp 	while (subdir[0] == '/')
 894 b2070a3f 2020-03-22 stsp 		subdir++;
 895 a04f49d2 2019-02-04 stsp 
 896 a04f49d2 2019-02-04 stsp 	if (asprintf(&path_subdir, "%s/%s", path_refs, subdir) == -1)
 897 638f9024 2019-05-13 stsp 		return got_error_from_errno("asprintf");
 898 a04f49d2 2019-02-04 stsp 
 899 a04f49d2 2019-02-04 stsp 	d = opendir(path_subdir);
 900 a04f49d2 2019-02-04 stsp 	if (d == NULL)
 901 a04f49d2 2019-02-04 stsp 		goto done;
 902 a04f49d2 2019-02-04 stsp 
 903 656b1f76 2019-05-11 jcs 	for (;;) {
 904 a04f49d2 2019-02-04 stsp 		struct dirent *dent;
 905 a04f49d2 2019-02-04 stsp 		struct got_reference *ref;
 906 a04f49d2 2019-02-04 stsp 		char *child;
 907 20ccae39 2020-07-21 stsp 		int type;
 908 a04f49d2 2019-02-04 stsp 
 909 a04f49d2 2019-02-04 stsp 		dent = readdir(d);
 910 a04f49d2 2019-02-04 stsp 		if (dent == NULL)
 911 a04f49d2 2019-02-04 stsp 			break;
 912 a04f49d2 2019-02-04 stsp 
 913 a04f49d2 2019-02-04 stsp 		if (strcmp(dent->d_name, ".") == 0 ||
 914 a04f49d2 2019-02-04 stsp 		    strcmp(dent->d_name, "..") == 0)
 915 a04f49d2 2019-02-04 stsp 			continue;
 916 a04f49d2 2019-02-04 stsp 
 917 20ccae39 2020-07-21 stsp 		err = got_path_dirent_type(&type, path_subdir, dent);
 918 20ccae39 2020-07-21 stsp 		if (err)
 919 20ccae39 2020-07-21 stsp 			break;
 920 20ccae39 2020-07-21 stsp 
 921 20ccae39 2020-07-21 stsp 		switch (type) {
 922 a04f49d2 2019-02-04 stsp 		case DT_REG:
 923 2f17228e 2019-05-12 stsp 			err = open_ref(&ref, path_refs, subdir, dent->d_name,
 924 2f17228e 2019-05-12 stsp 			    0);
 925 1e37702e 2019-02-04 stsp 			if (err)
 926 a04f49d2 2019-02-04 stsp 				goto done;
 927 a04f49d2 2019-02-04 stsp 			if (ref) {
 928 505287be 2019-03-15 stsp 				struct got_reflist_entry *new;
 929 72acb3d8 2021-08-06 stsp 				err = got_reflist_insert(&new, refs, ref,
 930 b8bad2ba 2019-08-23 stsp 				    cmp_cb, cmp_arg);
 931 505287be 2019-03-15 stsp 				if (err || new == NULL /* duplicate */)
 932 505287be 2019-03-15 stsp 					got_ref_close(ref);
 933 a04f49d2 2019-02-04 stsp 				if (err)
 934 a04f49d2 2019-02-04 stsp 					goto done;
 935 a04f49d2 2019-02-04 stsp 			}
 936 a04f49d2 2019-02-04 stsp 			break;
 937 a04f49d2 2019-02-04 stsp 		case DT_DIR:
 938 a04f49d2 2019-02-04 stsp 			if (asprintf(&child, "%s%s%s", subdir,
 939 a04f49d2 2019-02-04 stsp 			    subdir[0] == '\0' ? "" : "/", dent->d_name) == -1) {
 940 638f9024 2019-05-13 stsp 				err = got_error_from_errno("asprintf");
 941 a04f49d2 2019-02-04 stsp 				break;
 942 a04f49d2 2019-02-04 stsp 			}
 943 b8bad2ba 2019-08-23 stsp 			err = gather_on_disk_refs(refs, path_refs, child, repo,
 944 b8bad2ba 2019-08-23 stsp 			    cmp_cb, cmp_arg);
 945 a04f49d2 2019-02-04 stsp 			free(child);
 946 a04f49d2 2019-02-04 stsp 			break;
 947 a04f49d2 2019-02-04 stsp 		default:
 948 a04f49d2 2019-02-04 stsp 			break;
 949 a04f49d2 2019-02-04 stsp 		}
 950 a04f49d2 2019-02-04 stsp 	}
 951 a04f49d2 2019-02-04 stsp done:
 952 a04f49d2 2019-02-04 stsp 	if (d)
 953 a04f49d2 2019-02-04 stsp 		closedir(d);
 954 a04f49d2 2019-02-04 stsp 	free(path_subdir);
 955 a04f49d2 2019-02-04 stsp 	return err;
 956 a04f49d2 2019-02-04 stsp }
 957 a04f49d2 2019-02-04 stsp 
 958 199a4027 2019-02-02 stsp const struct got_error *
 959 29606af7 2019-08-23 stsp got_ref_list(struct got_reflist_head *refs, struct got_repository *repo,
 960 b8bad2ba 2019-08-23 stsp     const char *ref_namespace, got_ref_cmp_cb cmp_cb, void *cmp_arg)
 961 199a4027 2019-02-02 stsp {
 962 199a4027 2019-02-02 stsp 	const struct got_error *err;
 963 c3821bef 2022-07-21 florian 	char *packed_refs_path = NULL, *path_refs = NULL;
 964 58e31a80 2022-06-27 op 	char *abs_namespace = NULL, *buf = NULL;
 965 58e31a80 2022-06-27 op 	const char *ondisk_ref_namespace = NULL;
 966 9bdd68dd 2020-01-02 naddy 	char *line = NULL;
 967 29b5c214 2019-02-04 stsp 	FILE *f = NULL;
 968 199a4027 2019-02-02 stsp 	struct got_reference *ref;
 969 505287be 2019-03-15 stsp 	struct got_reflist_entry *new;
 970 199a4027 2019-02-02 stsp 
 971 29606af7 2019-08-23 stsp 	if (ref_namespace == NULL || ref_namespace[0] == '\0') {
 972 29606af7 2019-08-23 stsp 		path_refs = get_refs_dir_path(repo, GOT_REF_HEAD);
 973 29606af7 2019-08-23 stsp 		if (path_refs == NULL) {
 974 29606af7 2019-08-23 stsp 			err = got_error_from_errno("get_refs_dir_path");
 975 29606af7 2019-08-23 stsp 			goto done;
 976 29606af7 2019-08-23 stsp 		}
 977 29606af7 2019-08-23 stsp 		err = open_ref(&ref, path_refs, "", GOT_REF_HEAD, 0);
 978 29606af7 2019-08-23 stsp 		if (err)
 979 29606af7 2019-08-23 stsp 			goto done;
 980 72acb3d8 2021-08-06 stsp 		err = got_reflist_insert(&new, refs, ref, cmp_cb, cmp_arg);
 981 29606af7 2019-08-23 stsp 		if (err || new == NULL /* duplicate */)
 982 29606af7 2019-08-23 stsp 			got_ref_close(ref);
 983 f68a7890 2020-03-19 stsp 		if (err && err->code != GOT_ERR_NOT_REF)
 984 29606af7 2019-08-23 stsp 			goto done;
 985 b2070a3f 2020-03-22 stsp 	} else {
 986 b2070a3f 2020-03-22 stsp 		/* Try listing a single reference. */
 987 b2070a3f 2020-03-22 stsp 		const char *refname = ref_namespace;
 988 b2070a3f 2020-03-22 stsp 		path_refs = get_refs_dir_path(repo, refname);
 989 b2070a3f 2020-03-22 stsp 		if (path_refs == NULL) {
 990 b2070a3f 2020-03-22 stsp 			err = got_error_from_errno("get_refs_dir_path");
 991 b2070a3f 2020-03-22 stsp 			goto done;
 992 b2070a3f 2020-03-22 stsp 		}
 993 b2070a3f 2020-03-22 stsp 		err = open_ref(&ref, path_refs, "", refname, 0);
 994 b2070a3f 2020-03-22 stsp 		if (err) {
 995 b2070a3f 2020-03-22 stsp 			if (err->code != GOT_ERR_NOT_REF)
 996 b2070a3f 2020-03-22 stsp 				goto done;
 997 b2070a3f 2020-03-22 stsp 			/* Try to look up references in a given namespace. */
 998 b2070a3f 2020-03-22 stsp 		} else {
 999 72acb3d8 2021-08-06 stsp 			err = got_reflist_insert(&new, refs, ref,
1000 b2070a3f 2020-03-22 stsp 			    cmp_cb, cmp_arg);
1001 b2070a3f 2020-03-22 stsp 			if (err || new == NULL /* duplicate */)
1002 b2070a3f 2020-03-22 stsp 				got_ref_close(ref);
1003 b2070a3f 2020-03-22 stsp 			return err;
1004 b2070a3f 2020-03-22 stsp 		}
1005 29b5c214 2019-02-04 stsp 	}
1006 29b5c214 2019-02-04 stsp 
1007 b2070a3f 2020-03-22 stsp 	if (ref_namespace) {
1008 b2070a3f 2020-03-22 stsp 		size_t len;
1009 b2070a3f 2020-03-22 stsp 		/* Canonicalize the path to eliminate double-slashes if any. */
1010 b2070a3f 2020-03-22 stsp 		if (asprintf(&abs_namespace, "/%s", ref_namespace) == -1) {
1011 b2070a3f 2020-03-22 stsp 			err = got_error_from_errno("asprintf");
1012 b2070a3f 2020-03-22 stsp 			goto done;
1013 b2070a3f 2020-03-22 stsp 		}
1014 b2070a3f 2020-03-22 stsp 		len = strlen(abs_namespace) + 1;
1015 b2070a3f 2020-03-22 stsp 		buf = malloc(len);
1016 b2070a3f 2020-03-22 stsp 		if (buf == NULL) {
1017 b2070a3f 2020-03-22 stsp 			err = got_error_from_errno("malloc");
1018 b2070a3f 2020-03-22 stsp 			goto done;
1019 b2070a3f 2020-03-22 stsp 		}
1020 b2070a3f 2020-03-22 stsp 		err = got_canonpath(abs_namespace, buf, len);
1021 b2070a3f 2020-03-22 stsp 		if (err)
1022 b2070a3f 2020-03-22 stsp 			goto done;
1023 b2070a3f 2020-03-22 stsp 		ondisk_ref_namespace = buf;
1024 b2070a3f 2020-03-22 stsp 		while (ondisk_ref_namespace[0] == '/')
1025 b2070a3f 2020-03-22 stsp 			ondisk_ref_namespace++;
1026 b2070a3f 2020-03-22 stsp 		if (strncmp(ondisk_ref_namespace, "refs/", 5) == 0)
1027 b2070a3f 2020-03-22 stsp 			ondisk_ref_namespace += 5;
1028 b2070a3f 2020-03-22 stsp 		else if (strcmp(ondisk_ref_namespace, "refs") == 0)
1029 b2070a3f 2020-03-22 stsp 			ondisk_ref_namespace = "";
1030 b2070a3f 2020-03-22 stsp 	}
1031 29606af7 2019-08-23 stsp 
1032 29b5c214 2019-02-04 stsp 	/* Gather on-disk refs before parsing packed-refs. */
1033 29b5c214 2019-02-04 stsp 	free(path_refs);
1034 29b5c214 2019-02-04 stsp 	path_refs = get_refs_dir_path(repo, "");
1035 29b5c214 2019-02-04 stsp 	if (path_refs == NULL) {
1036 638f9024 2019-05-13 stsp 		err = got_error_from_errno("get_refs_dir_path");
1037 29b5c214 2019-02-04 stsp 		goto done;
1038 29b5c214 2019-02-04 stsp 	}
1039 29606af7 2019-08-23 stsp 	err = gather_on_disk_refs(refs, path_refs,
1040 6aeab596 2019-08-28 stsp 	    ondisk_ref_namespace ? ondisk_ref_namespace : "", repo,
1041 6aeab596 2019-08-28 stsp 	    cmp_cb, cmp_arg);
1042 29b5c214 2019-02-04 stsp 	if (err)
1043 29b5c214 2019-02-04 stsp 		goto done;
1044 29b5c214 2019-02-04 stsp 
1045 29b5c214 2019-02-04 stsp 	/*
1046 29b5c214 2019-02-04 stsp 	 * The packed-refs file may contain redundant entries, in which
1047 29b5c214 2019-02-04 stsp 	 * case on-disk refs take precedence.
1048 29b5c214 2019-02-04 stsp 	 */
1049 199a4027 2019-02-02 stsp 	packed_refs_path = got_repo_get_path_packed_refs(repo);
1050 29b5c214 2019-02-04 stsp 	if (packed_refs_path == NULL) {
1051 638f9024 2019-05-13 stsp 		err = got_error_from_errno("got_repo_get_path_packed_refs");
1052 29b5c214 2019-02-04 stsp 		goto done;
1053 29b5c214 2019-02-04 stsp 	}
1054 199a4027 2019-02-02 stsp 
1055 00fe21f2 2021-12-31 stsp 	f = fopen(packed_refs_path, "re");
1056 199a4027 2019-02-02 stsp 	if (f) {
1057 7a90b680 2020-01-02 naddy 		size_t linesize = 0;
1058 9bdd68dd 2020-01-02 naddy 		ssize_t linelen;
1059 3f338f0a 2021-07-27 stsp 		struct stat sb;
1060 3f338f0a 2021-07-27 stsp 
1061 3f338f0a 2021-07-27 stsp 		if (fstat(fileno(f), &sb) == -1) {
1062 3f338f0a 2021-07-27 stsp 			err = got_error_from_errno2("fstat", packed_refs_path);
1063 3f338f0a 2021-07-27 stsp 			goto done;
1064 3f338f0a 2021-07-27 stsp 		}
1065 656b1f76 2019-05-11 jcs 		for (;;) {
1066 9bdd68dd 2020-01-02 naddy 			linelen = getline(&line, &linesize, f);
1067 9bdd68dd 2020-01-02 naddy 			if (linelen == -1) {
1068 0bb4abae 2019-03-15 stsp 				if (feof(f))
1069 0bb4abae 2019-03-15 stsp 					break;
1070 0bb4abae 2019-03-15 stsp 				err = got_ferror(f, GOT_ERR_BAD_REF_DATA);
1071 0bb4abae 2019-03-15 stsp 				goto done;
1072 0bb4abae 2019-03-15 stsp 			}
1073 9bdd68dd 2020-01-02 naddy 			if (linelen > 0 && line[linelen - 1] == '\n')
1074 9bdd68dd 2020-01-02 naddy 				line[linelen - 1] = '\0';
1075 3f338f0a 2021-07-27 stsp 			err = parse_packed_ref_line(&ref, NULL, line,
1076 3f338f0a 2021-07-27 stsp 			    sb.st_mtime);
1077 199a4027 2019-02-02 stsp 			if (err)
1078 199a4027 2019-02-02 stsp 				goto done;
1079 76b4ead2 2019-02-03 stsp 			if (ref) {
1080 29606af7 2019-08-23 stsp 				if (ref_namespace) {
1081 29606af7 2019-08-23 stsp 					const char *name;
1082 29606af7 2019-08-23 stsp 					name = got_ref_get_name(ref);
1083 b2070a3f 2020-03-22 stsp 					if (!got_path_is_child(name,
1084 b2070a3f 2020-03-22 stsp 					    ref_namespace,
1085 b2070a3f 2020-03-22 stsp 					    strlen(ref_namespace))) {
1086 29606af7 2019-08-23 stsp 						got_ref_close(ref);
1087 29606af7 2019-08-23 stsp 						continue;
1088 29606af7 2019-08-23 stsp 					}
1089 29606af7 2019-08-23 stsp 				}
1090 72acb3d8 2021-08-06 stsp 				err = got_reflist_insert(&new, refs, ref,
1091 b8bad2ba 2019-08-23 stsp 				    cmp_cb, cmp_arg);
1092 505287be 2019-03-15 stsp 				if (err || new == NULL /* duplicate */)
1093 505287be 2019-03-15 stsp 					got_ref_close(ref);
1094 76b4ead2 2019-02-03 stsp 				if (err)
1095 76b4ead2 2019-02-03 stsp 					goto done;
1096 76b4ead2 2019-02-03 stsp 			}
1097 199a4027 2019-02-02 stsp 		}
1098 199a4027 2019-02-02 stsp 	}
1099 199a4027 2019-02-02 stsp done:
1100 c3821bef 2022-07-21 florian 	free(packed_refs_path);
1101 b2070a3f 2020-03-22 stsp 	free(abs_namespace);
1102 b2070a3f 2020-03-22 stsp 	free(buf);
1103 9bdd68dd 2020-01-02 naddy 	free(line);
1104 a04f49d2 2019-02-04 stsp 	free(path_refs);
1105 56b63ca4 2021-01-22 stsp 	if (f && fclose(f) == EOF && err == NULL)
1106 638f9024 2019-05-13 stsp 		err = got_error_from_errno("fclose");
1107 199a4027 2019-02-02 stsp 	return err;
1108 199a4027 2019-02-02 stsp }
1109 9e672c74 2019-03-11 stsp 
1110 e2e879a0 2019-03-11 stsp void
1111 e2e879a0 2019-03-11 stsp got_ref_list_free(struct got_reflist_head *refs)
1112 e2e879a0 2019-03-11 stsp {
1113 e2e879a0 2019-03-11 stsp 	struct got_reflist_entry *re;
1114 e2e879a0 2019-03-11 stsp 
1115 d9dff0e5 2020-12-26 stsp 	while ((re = TAILQ_FIRST(refs))) {
1116 d9dff0e5 2020-12-26 stsp 		TAILQ_REMOVE(refs, re, entry);
1117 af8a5c4a 2021-05-21 stsp 		got_ref_close(re->ref);
1118 e2e879a0 2019-03-11 stsp 		free(re);
1119 e2e879a0 2019-03-11 stsp 	}
1120 b249b824 2019-05-09 stsp 
1121 b249b824 2019-05-09 stsp }
1122 b249b824 2019-05-09 stsp 
1123 b249b824 2019-05-09 stsp int
1124 b249b824 2019-05-09 stsp got_ref_is_symbolic(struct got_reference *ref)
1125 b249b824 2019-05-09 stsp {
1126 b249b824 2019-05-09 stsp 	return (ref->flags & GOT_REF_IS_SYMBOLIC);
1127 b249b824 2019-05-09 stsp }
1128 b249b824 2019-05-09 stsp 
1129 b249b824 2019-05-09 stsp const struct got_error *
1130 b249b824 2019-05-09 stsp got_ref_change_ref(struct got_reference *ref, struct got_object_id *id)
1131 b249b824 2019-05-09 stsp {
1132 b249b824 2019-05-09 stsp 	if (ref->flags & GOT_REF_IS_SYMBOLIC)
1133 b249b824 2019-05-09 stsp 		return got_error(GOT_ERR_BAD_REF_TYPE);
1134 e2e879a0 2019-03-11 stsp 
1135 b249b824 2019-05-09 stsp 	memcpy(ref->ref.ref.sha1, id->sha1, sizeof(ref->ref.ref.sha1));
1136 b249b824 2019-05-09 stsp 	return NULL;
1137 e2e879a0 2019-03-11 stsp }
1138 e2e879a0 2019-03-11 stsp 
1139 9e672c74 2019-03-11 stsp const struct got_error *
1140 d7b899ab 2020-03-25 stsp got_ref_change_symref(struct got_reference *ref, const char *refname)
1141 b249b824 2019-05-09 stsp {
1142 b249b824 2019-05-09 stsp 	char *new_name;
1143 b249b824 2019-05-09 stsp 
1144 b249b824 2019-05-09 stsp 	if ((ref->flags & GOT_REF_IS_SYMBOLIC) == 0)
1145 b249b824 2019-05-09 stsp 		return got_error(GOT_ERR_BAD_REF_TYPE);
1146 b249b824 2019-05-09 stsp 
1147 b249b824 2019-05-09 stsp 	new_name = strdup(refname);
1148 b249b824 2019-05-09 stsp 	if (new_name == NULL)
1149 638f9024 2019-05-13 stsp 		return got_error_from_errno("strdup");
1150 b249b824 2019-05-09 stsp 
1151 d7b899ab 2020-03-25 stsp 	free(ref->ref.symref.ref);
1152 d7b899ab 2020-03-25 stsp 	ref->ref.symref.ref = new_name;
1153 b249b824 2019-05-09 stsp 	return NULL;
1154 b249b824 2019-05-09 stsp }
1155 b249b824 2019-05-09 stsp 
1156 b249b824 2019-05-09 stsp const struct got_error *
1157 e8a967e0 2020-03-21 stsp got_ref_change_symref_to_ref(struct got_reference *symref,
1158 e8a967e0 2020-03-21 stsp     struct got_object_id *id)
1159 e8a967e0 2020-03-21 stsp {
1160 e8a967e0 2020-03-21 stsp 	if ((symref->flags & GOT_REF_IS_SYMBOLIC) == 0)
1161 e8a967e0 2020-03-21 stsp 		return got_error(GOT_ERR_BAD_REF_TYPE);
1162 e8a967e0 2020-03-21 stsp 
1163 e8a967e0 2020-03-21 stsp 	symref->ref.ref.name = symref->ref.symref.name;
1164 e8a967e0 2020-03-21 stsp 	memcpy(symref->ref.ref.sha1, id->sha1, SHA1_DIGEST_LENGTH);
1165 e8a967e0 2020-03-21 stsp 	symref->flags &= ~GOT_REF_IS_SYMBOLIC;
1166 e8a967e0 2020-03-21 stsp 	return NULL;
1167 e8a967e0 2020-03-21 stsp }
1168 e8a967e0 2020-03-21 stsp 
1169 e8a967e0 2020-03-21 stsp const struct got_error *
1170 9e672c74 2019-03-11 stsp got_ref_write(struct got_reference *ref, struct got_repository *repo)
1171 9e672c74 2019-03-11 stsp {
1172 9e672c74 2019-03-11 stsp 	const struct got_error *err = NULL, *unlock_err = NULL;
1173 9e672c74 2019-03-11 stsp 	const char *name = got_ref_get_name(ref);
1174 9e672c74 2019-03-11 stsp 	char *path_refs = NULL, *path = NULL, *tmppath = NULL;
1175 9e672c74 2019-03-11 stsp 	struct got_lockfile *lf = NULL;
1176 9e672c74 2019-03-11 stsp 	FILE *f = NULL;
1177 9e672c74 2019-03-11 stsp 	size_t n;
1178 9e672c74 2019-03-11 stsp 	struct stat sb;
1179 9e672c74 2019-03-11 stsp 
1180 9e672c74 2019-03-11 stsp 	path_refs = get_refs_dir_path(repo, name);
1181 9e672c74 2019-03-11 stsp 	if (path_refs == NULL) {
1182 638f9024 2019-05-13 stsp 		err = got_error_from_errno2("get_refs_dir_path", name);
1183 9e672c74 2019-03-11 stsp 		goto done;
1184 9e672c74 2019-03-11 stsp 	}
1185 9e672c74 2019-03-11 stsp 
1186 9e672c74 2019-03-11 stsp 	if (asprintf(&path, "%s/%s", path_refs, name) == -1) {
1187 638f9024 2019-05-13 stsp 		err = got_error_from_errno("asprintf");
1188 9e672c74 2019-03-11 stsp 		goto done;
1189 9e672c74 2019-03-11 stsp 	}
1190 9e672c74 2019-03-11 stsp 
1191 9e672c74 2019-03-11 stsp 	err = got_opentemp_named(&tmppath, &f, path);
1192 49c7094f 2019-03-11 stsp 	if (err) {
1193 d1667f0d 2019-03-11 stsp 		char *parent;
1194 49c7094f 2019-03-11 stsp 		if (!(err->code == GOT_ERR_ERRNO && errno == ENOENT))
1195 5e1c9f23 2019-03-11 stsp 			goto done;
1196 d1667f0d 2019-03-11 stsp 		err = got_path_dirname(&parent, path);
1197 d1667f0d 2019-03-11 stsp 		if (err)
1198 0cd1c46a 2019-03-11 stsp 			goto done;
1199 0cd1c46a 2019-03-11 stsp 		err = got_path_mkdir(parent);
1200 5e1c9f23 2019-03-11 stsp 		free(parent);
1201 0cd1c46a 2019-03-11 stsp 		if (err)
1202 0cd1c46a 2019-03-11 stsp 			goto done;
1203 0cd1c46a 2019-03-11 stsp 		err = got_opentemp_named(&tmppath, &f, path);
1204 49c7094f 2019-03-11 stsp 		if (err)
1205 0cd1c46a 2019-03-11 stsp 			goto done;
1206 9e672c74 2019-03-11 stsp 	}
1207 9e672c74 2019-03-11 stsp 
1208 9e672c74 2019-03-11 stsp 	if (ref->flags & GOT_REF_IS_SYMBOLIC) {
1209 9e672c74 2019-03-11 stsp 		n = fprintf(f, "ref: %s\n", ref->ref.symref.ref);
1210 9e672c74 2019-03-11 stsp 		if (n != strlen(ref->ref.symref.ref) + 6) {
1211 9e672c74 2019-03-11 stsp 			err = got_ferror(f, GOT_ERR_IO);
1212 9e672c74 2019-03-11 stsp 			goto done;
1213 9e672c74 2019-03-11 stsp 		}
1214 9e672c74 2019-03-11 stsp 	} else {
1215 9e672c74 2019-03-11 stsp 		char hex[SHA1_DIGEST_STRING_LENGTH];
1216 9e672c74 2019-03-11 stsp 		if (got_sha1_digest_to_str(ref->ref.ref.sha1, hex,
1217 9e672c74 2019-03-11 stsp 		    sizeof(hex)) == NULL) {
1218 9e672c74 2019-03-11 stsp 			err = got_error(GOT_ERR_BAD_REF_DATA);
1219 9e672c74 2019-03-11 stsp 			goto done;
1220 9e672c74 2019-03-11 stsp 		}
1221 9e672c74 2019-03-11 stsp 		n = fprintf(f, "%s\n", hex);
1222 8fa2f096 2019-03-11 stsp 		if (n != sizeof(hex)) {
1223 9e672c74 2019-03-11 stsp 			err = got_ferror(f, GOT_ERR_IO);
1224 9e672c74 2019-03-11 stsp 			goto done;
1225 9e672c74 2019-03-11 stsp 		}
1226 9e672c74 2019-03-11 stsp 	}
1227 9e672c74 2019-03-11 stsp 
1228 2f17228e 2019-05-12 stsp 	if (ref->lf == NULL) {
1229 5345b4c7 2021-07-06 stsp 		err = got_lockfile_lock(&lf, path, -1);
1230 2f17228e 2019-05-12 stsp 		if (err)
1231 2f17228e 2019-05-12 stsp 			goto done;
1232 2f17228e 2019-05-12 stsp 	}
1233 9e672c74 2019-03-11 stsp 
1234 9e672c74 2019-03-11 stsp 	/* XXX: check if old content matches our expectations? */
1235 9e672c74 2019-03-11 stsp 
1236 0cd1c46a 2019-03-11 stsp 	if (stat(path, &sb) != 0) {
1237 0cd1c46a 2019-03-11 stsp 		if (errno != ENOENT) {
1238 638f9024 2019-05-13 stsp 			err = got_error_from_errno2("stat", path);
1239 0cd1c46a 2019-03-11 stsp 			goto done;
1240 0cd1c46a 2019-03-11 stsp 		}
1241 0cd1c46a 2019-03-11 stsp 		sb.st_mode = GOT_DEFAULT_FILE_MODE;
1242 3818e3c4 2020-11-01 naddy 	}
1243 3818e3c4 2020-11-01 naddy 
1244 3818e3c4 2020-11-01 naddy 	if (fchmod(fileno(f), sb.st_mode) != 0) {
1245 3818e3c4 2020-11-01 naddy 		err = got_error_from_errno2("fchmod", tmppath);
1246 3818e3c4 2020-11-01 naddy 		goto done;
1247 9e672c74 2019-03-11 stsp 	}
1248 9e672c74 2019-03-11 stsp 
1249 9e672c74 2019-03-11 stsp 	if (rename(tmppath, path) != 0) {
1250 638f9024 2019-05-13 stsp 		err = got_error_from_errno3("rename", tmppath, path);
1251 9e672c74 2019-03-11 stsp 		goto done;
1252 9e672c74 2019-03-11 stsp 	}
1253 9e672c74 2019-03-11 stsp 	free(tmppath);
1254 9e672c74 2019-03-11 stsp 	tmppath = NULL;
1255 3f338f0a 2021-07-27 stsp 
1256 3f338f0a 2021-07-27 stsp 	if (stat(path, &sb) == -1) {
1257 3f338f0a 2021-07-27 stsp 		err = got_error_from_errno2("stat", path);
1258 3f338f0a 2021-07-27 stsp 		goto done;
1259 3f338f0a 2021-07-27 stsp 	}
1260 3f338f0a 2021-07-27 stsp 	ref->mtime = sb.st_mtime;
1261 9e672c74 2019-03-11 stsp done:
1262 2f17228e 2019-05-12 stsp 	if (ref->lf == NULL && lf)
1263 5345b4c7 2021-07-06 stsp 		unlock_err = got_lockfile_unlock(lf, -1);
1264 9e672c74 2019-03-11 stsp 	if (f) {
1265 56b63ca4 2021-01-22 stsp 		if (fclose(f) == EOF && err == NULL)
1266 638f9024 2019-05-13 stsp 			err = got_error_from_errno("fclose");
1267 9e672c74 2019-03-11 stsp 	}
1268 9e672c74 2019-03-11 stsp 	free(path_refs);
1269 9e672c74 2019-03-11 stsp 	free(path);
1270 9e672c74 2019-03-11 stsp 	if (tmppath) {
1271 a06ca3f7 2022-10-15 stsp 		if (unlink(tmppath) == -1 && err == NULL)
1272 638f9024 2019-05-13 stsp 			err = got_error_from_errno2("unlink", tmppath);
1273 9e672c74 2019-03-11 stsp 		free(tmppath);
1274 2d2e1378 2019-03-11 stsp 	}
1275 2d2e1378 2019-03-11 stsp 	return err ? err : unlock_err;
1276 2d2e1378 2019-03-11 stsp }
1277 598a8b91 2019-03-15 stsp 
1278 598a8b91 2019-03-15 stsp static const struct got_error *
1279 598a8b91 2019-03-15 stsp delete_packed_ref(struct got_reference *delref, struct got_repository *repo)
1280 598a8b91 2019-03-15 stsp {
1281 598a8b91 2019-03-15 stsp 	const struct got_error *err = NULL, *unlock_err = NULL;
1282 598a8b91 2019-03-15 stsp 	struct got_lockfile *lf = NULL;
1283 598a8b91 2019-03-15 stsp 	FILE *f = NULL, *tmpf = NULL;
1284 9bdd68dd 2020-01-02 naddy 	char *line = NULL, *packed_refs_path, *tmppath = NULL;
1285 7a90b680 2020-01-02 naddy 	size_t linesize = 0;
1286 598a8b91 2019-03-15 stsp 	struct got_reflist_head refs;
1287 598a8b91 2019-03-15 stsp 	int found_delref = 0;
1288 2d2e1378 2019-03-11 stsp 
1289 598a8b91 2019-03-15 stsp 	/* The packed-refs file does not cotain symbolic references. */
1290 598a8b91 2019-03-15 stsp 	if (delref->flags & GOT_REF_IS_SYMBOLIC)
1291 598a8b91 2019-03-15 stsp 		return got_error(GOT_ERR_BAD_REF_DATA);
1292 598a8b91 2019-03-15 stsp 
1293 d9dff0e5 2020-12-26 stsp 	TAILQ_INIT(&refs);
1294 598a8b91 2019-03-15 stsp 
1295 598a8b91 2019-03-15 stsp 	packed_refs_path = got_repo_get_path_packed_refs(repo);
1296 598a8b91 2019-03-15 stsp 	if (packed_refs_path == NULL)
1297 638f9024 2019-05-13 stsp 		return got_error_from_errno("got_repo_get_path_packed_refs");
1298 598a8b91 2019-03-15 stsp 
1299 598a8b91 2019-03-15 stsp 	err = got_opentemp_named(&tmppath, &tmpf, packed_refs_path);
1300 598a8b91 2019-03-15 stsp 	if (err)
1301 598a8b91 2019-03-15 stsp 		goto done;
1302 598a8b91 2019-03-15 stsp 
1303 2f17228e 2019-05-12 stsp 	if (delref->lf == NULL) {
1304 5345b4c7 2021-07-06 stsp 		err = got_lockfile_lock(&lf, packed_refs_path, -1);
1305 2f17228e 2019-05-12 stsp 		if (err)
1306 2f17228e 2019-05-12 stsp 			goto done;
1307 2f17228e 2019-05-12 stsp 	}
1308 598a8b91 2019-03-15 stsp 
1309 00fe21f2 2021-12-31 stsp 	f = fopen(packed_refs_path, "re");
1310 598a8b91 2019-03-15 stsp 	if (f == NULL) {
1311 638f9024 2019-05-13 stsp 		err = got_error_from_errno2("fopen", packed_refs_path);
1312 598a8b91 2019-03-15 stsp 		goto done;
1313 598a8b91 2019-03-15 stsp 	}
1314 656b1f76 2019-05-11 jcs 	for (;;) {
1315 9bdd68dd 2020-01-02 naddy 		ssize_t linelen;
1316 598a8b91 2019-03-15 stsp 		struct got_reference *ref;
1317 598a8b91 2019-03-15 stsp 		struct got_reflist_entry *new;
1318 598a8b91 2019-03-15 stsp 
1319 9bdd68dd 2020-01-02 naddy 		linelen = getline(&line, &linesize, f);
1320 9bdd68dd 2020-01-02 naddy 		if (linelen == -1) {
1321 598a8b91 2019-03-15 stsp 			if (feof(f))
1322 598a8b91 2019-03-15 stsp 				break;
1323 598a8b91 2019-03-15 stsp 			err = got_ferror(f, GOT_ERR_BAD_REF_DATA);
1324 598a8b91 2019-03-15 stsp 			goto done;
1325 598a8b91 2019-03-15 stsp 		}
1326 9bdd68dd 2020-01-02 naddy 		if (linelen > 0 && line[linelen - 1] == '\n')
1327 9bdd68dd 2020-01-02 naddy 			line[linelen - 1] = '\0';
1328 3f338f0a 2021-07-27 stsp 		err = parse_packed_ref_line(&ref, NULL, line, 0);
1329 598a8b91 2019-03-15 stsp 		if (err)
1330 598a8b91 2019-03-15 stsp 			goto done;
1331 598a8b91 2019-03-15 stsp 		if (ref == NULL)
1332 598a8b91 2019-03-15 stsp 			continue;
1333 598a8b91 2019-03-15 stsp 
1334 598a8b91 2019-03-15 stsp 		if (strcmp(ref->ref.ref.name, delref->ref.ref.name) == 0 &&
1335 598a8b91 2019-03-15 stsp 		    memcmp(ref->ref.ref.sha1, delref->ref.ref.sha1,
1336 598a8b91 2019-03-15 stsp 		    sizeof(delref->ref.ref.sha1)) == 0) {
1337 598a8b91 2019-03-15 stsp 			found_delref = 1;
1338 598a8b91 2019-03-15 stsp 			got_ref_close(ref);
1339 598a8b91 2019-03-15 stsp 			continue;
1340 598a8b91 2019-03-15 stsp 		}
1341 598a8b91 2019-03-15 stsp 
1342 72acb3d8 2021-08-06 stsp 		err = got_reflist_insert(&new, &refs, ref,
1343 b8bad2ba 2019-08-23 stsp 		    got_ref_cmp_by_name, NULL);
1344 598a8b91 2019-03-15 stsp 		if (err || new == NULL /* duplicate */)
1345 598a8b91 2019-03-15 stsp 			got_ref_close(ref);
1346 598a8b91 2019-03-15 stsp 		if (err)
1347 598a8b91 2019-03-15 stsp 			goto done;
1348 598a8b91 2019-03-15 stsp 	}
1349 598a8b91 2019-03-15 stsp 
1350 598a8b91 2019-03-15 stsp 	if (found_delref) {
1351 598a8b91 2019-03-15 stsp 		struct got_reflist_entry *re;
1352 598a8b91 2019-03-15 stsp 		size_t n;
1353 598a8b91 2019-03-15 stsp 		struct stat sb;
1354 598a8b91 2019-03-15 stsp 
1355 598a8b91 2019-03-15 stsp 		n = fprintf(tmpf, "%s\n", GOT_PACKED_REFS_HEADER);
1356 598a8b91 2019-03-15 stsp 		if (n != sizeof(GOT_PACKED_REFS_HEADER)) {
1357 598a8b91 2019-03-15 stsp 			err = got_ferror(f, GOT_ERR_IO);
1358 598a8b91 2019-03-15 stsp 			goto done;
1359 598a8b91 2019-03-15 stsp 		}
1360 598a8b91 2019-03-15 stsp 
1361 d9dff0e5 2020-12-26 stsp 		TAILQ_FOREACH(re, &refs, entry) {
1362 9dd14b99 2021-09-28 naddy 			char hex[SHA1_DIGEST_STRING_LENGTH];
1363 598a8b91 2019-03-15 stsp 
1364 598a8b91 2019-03-15 stsp 			if (got_sha1_digest_to_str(re->ref->ref.ref.sha1, hex,
1365 598a8b91 2019-03-15 stsp 			    sizeof(hex)) == NULL) {
1366 598a8b91 2019-03-15 stsp 				err = got_error(GOT_ERR_BAD_REF_DATA);
1367 598a8b91 2019-03-15 stsp 				goto done;
1368 598a8b91 2019-03-15 stsp 			}
1369 598a8b91 2019-03-15 stsp 			n = fprintf(tmpf, "%s ", hex);
1370 598a8b91 2019-03-15 stsp 			if (n != sizeof(hex)) {
1371 598a8b91 2019-03-15 stsp 				err = got_ferror(f, GOT_ERR_IO);
1372 598a8b91 2019-03-15 stsp 				goto done;
1373 598a8b91 2019-03-15 stsp 			}
1374 598a8b91 2019-03-15 stsp 			n = fprintf(tmpf, "%s\n", re->ref->ref.ref.name);
1375 598a8b91 2019-03-15 stsp 			if (n != strlen(re->ref->ref.ref.name) + 1) {
1376 598a8b91 2019-03-15 stsp 				err = got_ferror(f, GOT_ERR_IO);
1377 598a8b91 2019-03-15 stsp 				goto done;
1378 598a8b91 2019-03-15 stsp 			}
1379 598a8b91 2019-03-15 stsp 		}
1380 598a8b91 2019-03-15 stsp 
1381 598a8b91 2019-03-15 stsp 		if (fflush(tmpf) != 0) {
1382 638f9024 2019-05-13 stsp 			err = got_error_from_errno("fflush");
1383 598a8b91 2019-03-15 stsp 			goto done;
1384 598a8b91 2019-03-15 stsp 		}
1385 598a8b91 2019-03-15 stsp 
1386 3818e3c4 2020-11-01 naddy 		if (fstat(fileno(f), &sb) != 0) {
1387 598a8b91 2019-03-15 stsp 			if (errno != ENOENT) {
1388 3818e3c4 2020-11-01 naddy 				err = got_error_from_errno2("fstat",
1389 230a42bd 2019-05-11 jcs 				    packed_refs_path);
1390 598a8b91 2019-03-15 stsp 				goto done;
1391 598a8b91 2019-03-15 stsp 			}
1392 598a8b91 2019-03-15 stsp 			sb.st_mode = GOT_DEFAULT_FILE_MODE;
1393 598a8b91 2019-03-15 stsp 		}
1394 598a8b91 2019-03-15 stsp 
1395 3818e3c4 2020-11-01 naddy 		if (fchmod(fileno(tmpf), sb.st_mode) != 0) {
1396 3818e3c4 2020-11-01 naddy 			err = got_error_from_errno2("fchmod", tmppath);
1397 598a8b91 2019-03-15 stsp 			goto done;
1398 598a8b91 2019-03-15 stsp 		}
1399 598a8b91 2019-03-15 stsp 
1400 3818e3c4 2020-11-01 naddy 		if (rename(tmppath, packed_refs_path) != 0) {
1401 3818e3c4 2020-11-01 naddy 			err = got_error_from_errno3("rename", tmppath,
1402 230a42bd 2019-05-11 jcs 			    packed_refs_path);
1403 598a8b91 2019-03-15 stsp 			goto done;
1404 598a8b91 2019-03-15 stsp 		}
1405 15c388a9 2022-10-15 stsp 		free(tmppath);
1406 15c388a9 2022-10-15 stsp 		tmppath = NULL;
1407 598a8b91 2019-03-15 stsp 	}
1408 598a8b91 2019-03-15 stsp done:
1409 2f17228e 2019-05-12 stsp 	if (delref->lf == NULL && lf)
1410 5345b4c7 2021-07-06 stsp 		unlock_err = got_lockfile_unlock(lf, -1);
1411 598a8b91 2019-03-15 stsp 	if (f) {
1412 56b63ca4 2021-01-22 stsp 		if (fclose(f) == EOF && err == NULL)
1413 638f9024 2019-05-13 stsp 			err = got_error_from_errno("fclose");
1414 598a8b91 2019-03-15 stsp 	}
1415 15c388a9 2022-10-15 stsp 	if (tmppath && unlink(tmppath) == -1 && err == NULL)
1416 15c388a9 2022-10-15 stsp 		err = got_error_from_errno2("unlink", tmppath);
1417 15c388a9 2022-10-15 stsp 	if (tmpf && fclose(tmpf) == EOF && err == NULL)
1418 15c388a9 2022-10-15 stsp 		err = got_error_from_errno("fclose");
1419 598a8b91 2019-03-15 stsp 	free(tmppath);
1420 598a8b91 2019-03-15 stsp 	free(packed_refs_path);
1421 9bdd68dd 2020-01-02 naddy 	free(line);
1422 598a8b91 2019-03-15 stsp 	got_ref_list_free(&refs);
1423 598a8b91 2019-03-15 stsp 	return err ? err : unlock_err;
1424 598a8b91 2019-03-15 stsp }
1425 598a8b91 2019-03-15 stsp 
1426 2a104ff6 2020-09-21 stsp static const struct got_error *
1427 2a104ff6 2020-09-21 stsp delete_loose_ref(struct got_reference *ref, struct got_repository *repo)
1428 2d2e1378 2019-03-11 stsp {
1429 2d2e1378 2019-03-11 stsp 	const struct got_error *err = NULL, *unlock_err = NULL;
1430 2d2e1378 2019-03-11 stsp 	const char *name = got_ref_get_name(ref);
1431 2d2e1378 2019-03-11 stsp 	char *path_refs = NULL, *path = NULL;
1432 2d2e1378 2019-03-11 stsp 	struct got_lockfile *lf = NULL;
1433 2d2e1378 2019-03-11 stsp 
1434 2d2e1378 2019-03-11 stsp 	path_refs = get_refs_dir_path(repo, name);
1435 2d2e1378 2019-03-11 stsp 	if (path_refs == NULL) {
1436 638f9024 2019-05-13 stsp 		err = got_error_from_errno2("get_refs_dir_path", name);
1437 2d2e1378 2019-03-11 stsp 		goto done;
1438 2d2e1378 2019-03-11 stsp 	}
1439 2d2e1378 2019-03-11 stsp 
1440 2d2e1378 2019-03-11 stsp 	if (asprintf(&path, "%s/%s", path_refs, name) == -1) {
1441 638f9024 2019-05-13 stsp 		err = got_error_from_errno("asprintf");
1442 2d2e1378 2019-03-11 stsp 		goto done;
1443 9e672c74 2019-03-11 stsp 	}
1444 2d2e1378 2019-03-11 stsp 
1445 2f17228e 2019-05-12 stsp 	if (ref->lf == NULL) {
1446 5345b4c7 2021-07-06 stsp 		err = got_lockfile_lock(&lf, path, -1);
1447 2f17228e 2019-05-12 stsp 		if (err)
1448 2f17228e 2019-05-12 stsp 			goto done;
1449 2f17228e 2019-05-12 stsp 	}
1450 2d2e1378 2019-03-11 stsp 
1451 2d2e1378 2019-03-11 stsp 	/* XXX: check if old content matches our expectations? */
1452 2d2e1378 2019-03-11 stsp 
1453 a06ca3f7 2022-10-15 stsp 	if (unlink(path) == -1)
1454 638f9024 2019-05-13 stsp 		err = got_error_from_errno2("unlink", path);
1455 2d2e1378 2019-03-11 stsp done:
1456 2f17228e 2019-05-12 stsp 	if (ref->lf == NULL && lf)
1457 5345b4c7 2021-07-06 stsp 		unlock_err = got_lockfile_unlock(lf, -1);
1458 2d2e1378 2019-03-11 stsp 
1459 2d2e1378 2019-03-11 stsp 	free(path_refs);
1460 2d2e1378 2019-03-11 stsp 	free(path);
1461 9e672c74 2019-03-11 stsp 	return err ? err : unlock_err;
1462 2a104ff6 2020-09-21 stsp }
1463 2a104ff6 2020-09-21 stsp 
1464 2a104ff6 2020-09-21 stsp const struct got_error *
1465 2a104ff6 2020-09-21 stsp got_ref_delete(struct got_reference *ref, struct got_repository *repo)
1466 2a104ff6 2020-09-21 stsp {
1467 2a104ff6 2020-09-21 stsp 	const struct got_error *err = NULL;
1468 2a104ff6 2020-09-21 stsp 	struct got_reference *ref2;
1469 2a104ff6 2020-09-21 stsp 
1470 2a104ff6 2020-09-21 stsp 	if (ref->flags & GOT_REF_IS_PACKED) {
1471 2a104ff6 2020-09-21 stsp 		err = delete_packed_ref(ref, repo);
1472 2a104ff6 2020-09-21 stsp 		if (err)
1473 2a104ff6 2020-09-21 stsp 			return err;
1474 2a104ff6 2020-09-21 stsp 
1475 a1c4175c 2020-09-22 stsp 		err = got_ref_open(&ref2, repo, got_ref_get_name(ref), 0);
1476 2a104ff6 2020-09-21 stsp 		if (err) {
1477 2a104ff6 2020-09-21 stsp 			if (err->code == GOT_ERR_NOT_REF)
1478 2a104ff6 2020-09-21 stsp 				return NULL;
1479 2a104ff6 2020-09-21 stsp 			return err;
1480 2a104ff6 2020-09-21 stsp 		}
1481 2a104ff6 2020-09-21 stsp 
1482 2a104ff6 2020-09-21 stsp 		err = delete_loose_ref(ref2, repo);
1483 2a104ff6 2020-09-21 stsp 		got_ref_close(ref2);
1484 2a104ff6 2020-09-21 stsp 		return err;
1485 2a104ff6 2020-09-21 stsp 	} else {
1486 2a104ff6 2020-09-21 stsp 		err = delete_loose_ref(ref, repo);
1487 2a104ff6 2020-09-21 stsp 		if (err)
1488 2a104ff6 2020-09-21 stsp 			return err;
1489 2a104ff6 2020-09-21 stsp 
1490 a1c4175c 2020-09-22 stsp 		err = got_ref_open(&ref2, repo, got_ref_get_name(ref), 0);
1491 2a104ff6 2020-09-21 stsp 		if (err) {
1492 2a104ff6 2020-09-21 stsp 			if (err->code == GOT_ERR_NOT_REF)
1493 2a104ff6 2020-09-21 stsp 				return NULL;
1494 2a104ff6 2020-09-21 stsp 			return err;
1495 2a104ff6 2020-09-21 stsp 		}
1496 2a104ff6 2020-09-21 stsp 
1497 2a104ff6 2020-09-21 stsp 		err = delete_packed_ref(ref2, repo);
1498 2a104ff6 2020-09-21 stsp 		got_ref_close(ref2);
1499 2a104ff6 2020-09-21 stsp 		return err;
1500 2a104ff6 2020-09-21 stsp 	}
1501 9e672c74 2019-03-11 stsp }
1502 2f17228e 2019-05-12 stsp 
1503 2f17228e 2019-05-12 stsp const struct got_error *
1504 2f17228e 2019-05-12 stsp got_ref_unlock(struct got_reference *ref)
1505 2f17228e 2019-05-12 stsp {
1506 2f17228e 2019-05-12 stsp 	const struct got_error *err;
1507 5345b4c7 2021-07-06 stsp 	err = got_lockfile_unlock(ref->lf, -1);
1508 2f17228e 2019-05-12 stsp 	ref->lf = NULL;
1509 2f17228e 2019-05-12 stsp 	return err;
1510 2f17228e 2019-05-12 stsp }
1511 7b5b670e 2020-12-25 stsp 
1512 7b5b670e 2020-12-25 stsp struct got_reflist_object_id_map {
1513 7b5b670e 2020-12-25 stsp 	struct got_object_idset *idset;
1514 7b5b670e 2020-12-25 stsp };
1515 7b5b670e 2020-12-25 stsp 
1516 7b5b670e 2020-12-25 stsp struct got_reflist_object_id_map_entry {
1517 7b5b670e 2020-12-25 stsp 	struct got_reflist_head refs;
1518 7b5b670e 2020-12-25 stsp };
1519 24202e46 2020-12-26 stsp 
1520 24202e46 2020-12-26 stsp static const struct got_error *
1521 24202e46 2020-12-26 stsp add_object_id_map_entry(struct got_object_idset *idset,
1522 24202e46 2020-12-26 stsp     struct got_object_id *id, struct got_reflist_entry *re)
1523 24202e46 2020-12-26 stsp {
1524 24202e46 2020-12-26 stsp 	const struct got_error *err = NULL;
1525 24202e46 2020-12-26 stsp 	struct got_reflist_object_id_map_entry *ent;
1526 24202e46 2020-12-26 stsp 	struct got_reflist_entry *new;
1527 24202e46 2020-12-26 stsp 
1528 24202e46 2020-12-26 stsp 	ent = got_object_idset_get(idset, id);
1529 24202e46 2020-12-26 stsp 	if (ent == NULL) {
1530 24202e46 2020-12-26 stsp 		ent = malloc(sizeof(*ent));
1531 24202e46 2020-12-26 stsp 		if (ent == NULL)
1532 24202e46 2020-12-26 stsp 			return got_error_from_errno("malloc");
1533 7b5b670e 2020-12-25 stsp 
1534 24202e46 2020-12-26 stsp 		TAILQ_INIT(&ent->refs);
1535 24202e46 2020-12-26 stsp 		err = got_object_idset_add(idset, id, ent);
1536 bb6672b6 2022-04-14 tb 		if (err) {
1537 bb6672b6 2022-04-14 tb 			free(ent);
1538 24202e46 2020-12-26 stsp 			return err;
1539 bb6672b6 2022-04-14 tb 		}
1540 24202e46 2020-12-26 stsp 	}
1541 24202e46 2020-12-26 stsp 
1542 24202e46 2020-12-26 stsp 	err = got_reflist_entry_dup(&new, re);
1543 24202e46 2020-12-26 stsp 	if (err)
1544 24202e46 2020-12-26 stsp 		return err;
1545 24202e46 2020-12-26 stsp 
1546 24202e46 2020-12-26 stsp 	TAILQ_INSERT_TAIL(&ent->refs, new, entry);
1547 24202e46 2020-12-26 stsp 	return NULL;
1548 24202e46 2020-12-26 stsp }
1549 24202e46 2020-12-26 stsp 
1550 7b5b670e 2020-12-25 stsp const struct got_error *
1551 7b5b670e 2020-12-25 stsp got_reflist_object_id_map_create(struct got_reflist_object_id_map **map,
1552 7b5b670e 2020-12-25 stsp     struct got_reflist_head *refs, struct got_repository *repo)
1553 7b5b670e 2020-12-25 stsp {
1554 7b5b670e 2020-12-25 stsp 	const struct got_error *err = NULL;
1555 7b5b670e 2020-12-25 stsp 	struct got_object_idset *idset;
1556 7b5b670e 2020-12-25 stsp 	struct got_object_id *id = NULL;
1557 7b5b670e 2020-12-25 stsp 	struct got_reflist_entry *re;
1558 7b5b670e 2020-12-25 stsp 
1559 7b5b670e 2020-12-25 stsp 	idset = got_object_idset_alloc();
1560 7b5b670e 2020-12-25 stsp 	if (idset == NULL)
1561 7b5b670e 2020-12-25 stsp 		return got_error_from_errno("got_object_idset_alloc");
1562 7b5b670e 2020-12-25 stsp 
1563 7b5b670e 2020-12-25 stsp 	*map = malloc(sizeof(**map));
1564 7b5b670e 2020-12-25 stsp 	if (*map == NULL) {
1565 7b5b670e 2020-12-25 stsp 		got_object_idset_free(idset);
1566 7b5b670e 2020-12-25 stsp 		return got_error_from_errno("malloc");
1567 7b5b670e 2020-12-25 stsp 	}
1568 7b5b670e 2020-12-25 stsp 	(*map)->idset = idset;
1569 7b5b670e 2020-12-25 stsp 
1570 d9dff0e5 2020-12-26 stsp 	TAILQ_FOREACH(re, refs, entry) {
1571 24202e46 2020-12-26 stsp 		struct got_tag_object *tag = NULL;
1572 7b5b670e 2020-12-25 stsp 
1573 7b5b670e 2020-12-25 stsp 		err = got_ref_resolve(&id, repo, re->ref);
1574 7b5b670e 2020-12-25 stsp 		if (err)
1575 7b5b670e 2020-12-25 stsp 			goto done;
1576 7b5b670e 2020-12-25 stsp 
1577 24202e46 2020-12-26 stsp 		err = add_object_id_map_entry(idset, id, re);
1578 24202e46 2020-12-26 stsp 		if (err)
1579 24202e46 2020-12-26 stsp 			goto done;
1580 24202e46 2020-12-26 stsp 
1581 24202e46 2020-12-26 stsp 		if (strstr(got_ref_get_name(re->ref), "/tags/") == NULL) {
1582 24202e46 2020-12-26 stsp 			free(id);
1583 24202e46 2020-12-26 stsp 			id = NULL;
1584 24202e46 2020-12-26 stsp 			continue;
1585 24202e46 2020-12-26 stsp 		}
1586 24202e46 2020-12-26 stsp 
1587 24202e46 2020-12-26 stsp 		err = got_object_open_as_tag(&tag, repo, id);
1588 24202e46 2020-12-26 stsp 		if (err) {
1589 24202e46 2020-12-26 stsp 			if (err->code != GOT_ERR_OBJ_TYPE)
1590 7b5b670e 2020-12-25 stsp 				goto done;
1591 24202e46 2020-12-26 stsp 			/* Ref points at something other than a tag. */
1592 24202e46 2020-12-26 stsp 			err = NULL;
1593 24202e46 2020-12-26 stsp 			tag = NULL;
1594 24202e46 2020-12-26 stsp 			free(id);
1595 24202e46 2020-12-26 stsp 			id = NULL;
1596 24202e46 2020-12-26 stsp 			continue;
1597 7b5b670e 2020-12-25 stsp 		}
1598 7b5b670e 2020-12-25 stsp 
1599 24202e46 2020-12-26 stsp 		err = add_object_id_map_entry(idset,
1600 24202e46 2020-12-26 stsp 		    got_object_tag_get_object_id(tag), re);
1601 f0ff8d4c 2020-12-26 stsp 		got_object_tag_close(tag);
1602 7b5b670e 2020-12-25 stsp 		if (err)
1603 7b5b670e 2020-12-25 stsp 			goto done;
1604 24202e46 2020-12-26 stsp 
1605 7b5b670e 2020-12-25 stsp 		free(id);
1606 7b5b670e 2020-12-25 stsp 		id = NULL;
1607 7b5b670e 2020-12-25 stsp 	}
1608 7b5b670e 2020-12-25 stsp done:
1609 7b5b670e 2020-12-25 stsp 	free(id);
1610 7b5b670e 2020-12-25 stsp 	if (err) {
1611 f193b038 2020-12-26 stsp 		got_reflist_object_id_map_free(*map);
1612 7b5b670e 2020-12-25 stsp 		*map = NULL;
1613 7b5b670e 2020-12-25 stsp 	}
1614 a53af95f 2020-12-26 stsp 	return err;
1615 7b5b670e 2020-12-25 stsp }
1616 7b5b670e 2020-12-25 stsp 
1617 7b5b670e 2020-12-25 stsp struct got_reflist_head *
1618 7b5b670e 2020-12-25 stsp got_reflist_object_id_map_lookup(struct got_reflist_object_id_map *map,
1619 7b5b670e 2020-12-25 stsp     struct got_object_id *id)
1620 7b5b670e 2020-12-25 stsp {
1621 7b5b670e 2020-12-25 stsp 	struct got_reflist_object_id_map_entry *ent;
1622 7b5b670e 2020-12-25 stsp 	ent = got_object_idset_get(map->idset, id);
1623 7b5b670e 2020-12-25 stsp 	if (ent)
1624 7b5b670e 2020-12-25 stsp 		return &ent->refs;
1625 7b5b670e 2020-12-25 stsp 	return NULL;
1626 7b5b670e 2020-12-25 stsp }
1627 7b5b670e 2020-12-25 stsp 
1628 7b5b670e 2020-12-25 stsp static const struct got_error *
1629 7b5b670e 2020-12-25 stsp free_id_map_entry(struct got_object_id *id, void *data, void *arg)
1630 7b5b670e 2020-12-25 stsp {
1631 7b5b670e 2020-12-25 stsp 	struct got_reflist_object_id_map_entry *ent = data;
1632 7b5b670e 2020-12-25 stsp 
1633 7b5b670e 2020-12-25 stsp 	got_ref_list_free(&ent->refs);
1634 7b5b670e 2020-12-25 stsp 	free(ent);
1635 7b5b670e 2020-12-25 stsp 	return NULL;
1636 7b5b670e 2020-12-25 stsp }
1637 7b5b670e 2020-12-25 stsp 
1638 7b5b670e 2020-12-25 stsp void
1639 f193b038 2020-12-26 stsp got_reflist_object_id_map_free(struct got_reflist_object_id_map *map)
1640 7b5b670e 2020-12-25 stsp {
1641 7b5b670e 2020-12-25 stsp 	got_object_idset_for_each(map->idset, free_id_map_entry, NULL);
1642 7b5b670e 2020-12-25 stsp 	got_object_idset_free(map->idset);
1643 7b5b670e 2020-12-25 stsp 	free(map);
1644 7b5b670e 2020-12-25 stsp }