rugged 1.7.2 → 1.9.6

data/vendor/libgit2/src/libgit2/submodule.c

@@ -77,6 +77,7 @@ static void submodule_get_index_status(unsigned int *, git_submodule *);
 static void submodule_get_wd_status(unsigned int *, git_submodule *, git_repository *, git_submodule_ignore_t);
 static void submodule_update_from_index_entry(git_submodule *sm, const git_index_entry *ie);
 static void submodule_update_from_head_data(git_submodule *sm, mode_t mode, const git_oid *id);
+static int path_is_valid(git_repository *repo, const char *path);
 
 static int submodule_cmp(const void *a, const void *b)
 {
@@ -169,22 +170,27 @@ out:
 	return error;
 }
 
+GIT_HASHMAP_STR_SETUP(git_submodule_namemap, char *);
+
 /**
  * Release the name map returned by 'load_submodule_names'.
  */
-static void free_submodule_names(git_strmap *names)
+static void free_submodule_names(git_submodule_namemap *names)
 {
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 	const char *key;
 	char *value;
 
 	if (names == NULL)
 		return;
 
-	git_strmap_foreach(names, key, value, {
-		git__free((char *) key);
+	while (git_submodule_namemap_iterate(&iter, &key, &value, names) == 0) {
+		git__free((char *)key);
 		git__free(value);
-	});
-	git_strmap_free(names);
+	}
+
+	git_submodule_namemap_dispose(names);
+	git__free(names);
 
 	return;
 }
@@ -194,29 +200,33 @@ static void free_submodule_names(git_strmap *names)
  * TODO: for some use-cases, this might need case-folding on a
  * case-insensitive filesystem
  */
-static int load_submodule_names(git_strmap **out, git_repository *repo, git_config *cfg)
+static int load_submodule_names(git_submodule_namemap **out, git_repository *repo, git_config *cfg)
 {
-	const char *key = "submodule\\..*\\.path";
+	const char *key = "^submodule\\..*\\.path$";
+	char *value;
 	git_config_iterator *iter = NULL;
 	git_config_entry *entry;
 	git_str buf = GIT_STR_INIT;
-	git_strmap *names;
+	git_submodule_namemap *names;
 	int isvalid, error;
 
 	*out = NULL;
 
-	if ((error = git_strmap_new(&names)) < 0)
+	if ((names = git__calloc(1, sizeof(git_submodule_namemap))) == NULL) {
+		error = -1;
 		goto out;
+	}
 
 	if ((error = git_config_iterator_glob_new(&iter, cfg, key)) < 0)
 		goto out;
 
 	while ((error = git_config_next(&entry, iter)) == 0) {
 		const char *fdot, *ldot;
+
 		fdot = strchr(entry->name, '.');
 		ldot = strrchr(entry->name, '.');
 
-		if (git_strmap_exists(names, entry->value)) {
+		if (git_submodule_namemap_contains(names, entry->value)) {
 			git_error_set(GIT_ERROR_SUBMODULE,
 				   "duplicated submodule path '%s'", entry->value);
 			error = -1;
@@ -225,6 +235,7 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
 
 		git_str_clear(&buf);
 		git_str_put(&buf, fdot + 1, ldot - fdot - 1);
+
 		isvalid = git_submodule_name_is_valid(repo, buf.ptr, 0);
 		if (isvalid < 0) {
 			error = isvalid;
@@ -233,7 +244,20 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
 		if (!isvalid)
 			continue;
 
-		if ((error = git_strmap_set(names, git__strdup(entry->value), git_str_detach(&buf))) < 0) {
+		isvalid = path_is_valid(repo, entry->value);
+		if (isvalid < 0) {
+			error = isvalid;
+			goto out;
+		}
+		if (!isvalid)
+			continue;
+
+		if ((value = git__strdup(entry->value)) == NULL) {
+			error = -1;
+			goto out;
+		}
+
+		if ((error = git_submodule_namemap_put(names, value, git_str_detach(&buf))) < 0) {
 			git_error_set(GIT_ERROR_NOMEMORY, "error inserting submodule into hash table");
 			error = -1;
 			goto out;
@@ -252,31 +276,43 @@ out:
 	return error;
 }
 
-int git_submodule_cache_init(git_strmap **out, git_repository *repo)
+GIT_HASHMAP_STR_FUNCTIONS(git_submodule_cache, GIT_HASHMAP_INLINE, git_submodule *);
+
+int git_submodule__map(git_submodule_cache *cache, git_repository *repo);
+
+int git_submodule_cache_init(git_submodule_cache **out, git_repository *repo)
 {
+	git_submodule_cache *cache = NULL;
 	int error = 0;
-	git_strmap *cache = NULL;
+
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(repo);
-	if ((error = git_strmap_new(&cache)) < 0)
-		return error;
-	if ((error = git_submodule__map(repo, cache)) < 0) {
+
+	if ((cache = git__calloc(1, sizeof(git_submodule_cache))) == NULL)
+		return -1;
+
+	if ((error = git_submodule__map(cache, repo)) < 0) {
 		git_submodule_cache_free(cache);
 		return error;
 	}
+
 	*out = cache;
 	return error;
 }
 
-int git_submodule_cache_free(git_strmap *cache)
+int git_submodule_cache_free(git_submodule_cache *cache)
 {
 	git_submodule *sm = NULL;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
 	if (cache == NULL)
 		return 0;
-	git_strmap_foreach_value(cache, sm, {
+
+	while (git_submodule_cache_iterate(&iter, NULL, &sm, cache) == 0)
 		git_submodule_free(sm);
-	});
-	git_strmap_free(cache);
+
+	git_submodule_cache_dispose(cache);
+	git__free(cache);
 	return 0;
 }
 
@@ -292,11 +328,11 @@ int git_submodule__lookup_with_cache(
 	git_submodule **out, /* NULL if user only wants to test existence */
 	git_repository *repo,
 	const char *name,    /* trailing slash is allowed */
-	git_strmap *cache)
+	git_submodule_cache *cache)
 {
-	int error;
-	unsigned int location;
 	git_submodule *sm;
+	unsigned int location;
+	int error;
 
 	GIT_ASSERT_ARG(repo);
 	GIT_ASSERT_ARG(name);
@@ -307,7 +343,7 @@ int git_submodule__lookup_with_cache(
 	}
 
 	if (cache != NULL) {
-		if ((sm = git_strmap_get(cache, name)) != NULL) {
+		if (git_submodule_cache_get(&sm, cache, name) == 0) {
 			if (out) {
 				*out = sm;
 				GIT_REFCOUNT_INC(*out);
@@ -319,7 +355,17 @@ int git_submodule__lookup_with_cache(
 	if ((error = submodule_alloc(&sm, repo, name)) < 0)
 		return error;
 
-	if ((error = git_submodule_reload(sm, false)) < 0) {
+	/*
+	 * Only try to reload if they gave us a valid _name_; if this is a
+	 * path, we'll do some lookups then try to reload to populate.
+	 */
+	if (git_submodule_name_is_valid(sm->repo, name, 0) <= 0) {
+		error = GIT_ENOTFOUND;
+	} else {
+		error = git_submodule_reload(sm, false);
+	}
+
+	if (error < 0 && error != GIT_ENOTFOUND) {
 		git_submodule_free(sm);
 		return error;
 	}
@@ -332,7 +378,7 @@ int git_submodule__lookup_with_cache(
 	/* If it's not configured or we're looking by path  */
 	if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) {
 		git_config_backend *mods;
-		const char *pattern = "submodule\\..*\\.path";
+		const char *pattern = "^submodule\\..*\\.path$";
 		git_str path = GIT_STR_INIT;
 		fbp_data data = { NULL, NULL };
 
@@ -378,6 +424,7 @@ int git_submodule__lookup_with_cache(
 	/* If we still haven't found it, do the WD check */
 	if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) {
 		git_submodule_free(sm);
+		git_error_set(GIT_ERROR_SUBMODULE, "invalid submodule name: '%s'", name);
 		error = GIT_ENOTFOUND;
 
 		/* If it's not configured, we still check if there's a repo at the path */
@@ -429,24 +476,49 @@ int git_submodule_name_is_valid(git_repository *repo, const char *name, int flag
 	return isvalid;
 }
 
+static int path_is_valid(git_repository *repo, const char *path)
+{
+	git_str buf = GIT_STR_INIT;
+	int flags = GIT_FS_PATH_REJECT_FILESYSTEM_DEFAULTS &
+	            ~GIT_FS_PATH_REJECT_EMPTY_COMPONENT;
+	int error, isvalid;
+
+	/* Avoid allocating a new string if we can avoid it */
+	if (strchr(path, '\\') != NULL) {
+		if ((error = git_fs_path_normalize_slashes(&buf, path)) < 0)
+			return error;
+	} else {
+		git_str_attach_notowned(&buf, path, strlen(path));
+	}
+
+	isvalid = git_path_is_valid(repo, buf.ptr, 0, flags);
+	git_str_dispose(&buf);
+
+	return isvalid;
+}
+
 static void submodule_free_dup(void *sm)
 {
 	git_submodule_free(sm);
 }
 
-static int submodule_get_or_create(git_submodule **out, git_repository *repo, git_strmap *map, const char *name)
+static int submodule_get_or_create(
+	git_submodule **out,
+	git_repository *repo,
+	git_submodule_cache *cache,
+	const char *name)
 {
 	git_submodule *sm = NULL;
 	int error;
 
-	if ((sm = git_strmap_get(map, name)) != NULL)
+	if (git_submodule_cache_get(&sm, cache, name) == 0)
 		goto done;
 
 	/* if the submodule doesn't exist yet in the map, create it */
 	if ((error = submodule_alloc(&sm, repo, name)) < 0)
 		return error;
 
-	if ((error = git_strmap_set(map, sm->name, sm)) < 0) {
+	if ((error = git_submodule_cache_put(cache, sm->name, sm)) < 0) {
 		git_submodule_free(sm);
 		return error;
 	}
@@ -457,12 +529,15 @@ done:
 	return 0;
 }
 
-static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cfg)
+static int submodules_from_index(
+	git_submodule_cache *cache,
+	git_index *idx,
+	git_config *cfg)
 {
 	int error;
 	git_iterator *i = NULL;
 	const git_index_entry *entry;
-	git_strmap *names;
+	git_submodule_namemap *names;
 
 	if ((error = load_submodule_names(&names, git_index_owner(idx), cfg)))
 		goto done;
@@ -473,7 +548,7 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
 	while (!(error = git_iterator_advance(&entry, i))) {
 		git_submodule *sm;
 
-		if ((sm = git_strmap_get(map, entry->path)) != NULL) {
+		if (git_submodule_cache_get(&sm, cache, entry->path) == 0) {
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_index_entry(sm, entry);
 			else
@@ -481,10 +556,10 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
 		} else if (S_ISGITLINK(entry->mode)) {
 			const char *name;
 
-			if ((name = git_strmap_get(names, entry->path)) == NULL)
+			if (git_submodule_namemap_get((char **)&name, names, entry->path) != 0)
 				name = entry->path;
 
-			if (!submodule_get_or_create(&sm, git_index_owner(idx), map, name)) {
+			if (!submodule_get_or_create(&sm, git_index_owner(idx), cache, name)) {
 				submodule_update_from_index_entry(sm, entry);
 				git_submodule_free(sm);
 			}
@@ -501,12 +576,15 @@ done:
 	return error;
 }
 
-static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg)
+static int submodules_from_head(
+	git_submodule_cache *cache,
+	git_tree *head,
+	git_config *cfg)
 {
 	int error;
 	git_iterator *i = NULL;
 	const git_index_entry *entry;
-	git_strmap *names;
+	git_submodule_namemap *names;
 
 	if ((error = load_submodule_names(&names, git_tree_owner(head), cfg)))
 		goto done;
@@ -517,7 +595,7 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
 	while (!(error = git_iterator_advance(&entry, i))) {
 		git_submodule *sm;
 
-		if ((sm = git_strmap_get(map, entry->path)) != NULL) {
+		if (git_submodule_cache_get(&sm, cache, entry->path) == 0) {
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_head_data(sm, entry->mode, &entry->id);
 			else
@@ -525,10 +603,10 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
 		} else if (S_ISGITLINK(entry->mode)) {
 			const char *name;
 
-			if ((name = git_strmap_get(names, entry->path)) == NULL)
+			if (git_submodule_namemap_get((char **)&name, names, entry->path) != 0)
 				name = entry->path;
 
-			if (!submodule_get_or_create(&sm, git_tree_owner(head), map, name)) {
+			if (!submodule_get_or_create(&sm, git_tree_owner(head), cache, name)) {
 				submodule_update_from_head_data(
 					sm, entry->mode, &entry->id);
 				git_submodule_free(sm);
@@ -549,11 +627,11 @@ done:
 /* If have_sm is true, sm is populated, otherwise map an repo are. */
 typedef struct {
 	git_config *mods;
-	git_strmap *map;
+	git_submodule_cache *cache;
 	git_repository *repo;
 } lfc_data;
 
-int git_submodule__map(git_repository *repo, git_strmap *map)
+int git_submodule__map(git_submodule_cache *cache, git_repository *repo)
 {
 	int error = 0;
 	git_index *idx = NULL;
@@ -563,8 +641,8 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
 	git_config *mods = NULL;
 	bool has_workdir;
 
+	GIT_ASSERT_ARG(cache);
 	GIT_ASSERT_ARG(repo);
-	GIT_ASSERT_ARG(map);
 
 	/* get sources that we will need to check */
 	if (git_repository_index(&idx, repo) < 0)
@@ -581,7 +659,7 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
 	/* add submodule information from .gitmodules */
 	if (has_workdir) {
 		lfc_data data = { 0 };
-		data.map = map;
+		data.cache = cache;
 		data.repo = repo;
 
 		if ((error = gitmodules_snapshot(&mods, repo)) < 0) {
@@ -597,19 +675,22 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
 	}
 	/* add back submodule information from index */
 	if (mods && idx) {
-		if ((error = submodules_from_index(map, idx, mods)) < 0)
+		if ((error = submodules_from_index(cache, idx, mods)) < 0)
 			goto cleanup;
 	}
 	/* add submodule information from HEAD */
 	if (mods && head) {
-		if ((error = submodules_from_head(map, head, mods)) < 0)
+		if ((error = submodules_from_head(cache, head, mods)) < 0)
 			goto cleanup;
 	}
 	/* shallow scan submodules in work tree as needed */
 	if (has_workdir) {
-		git_strmap_foreach_value(map, sm, {
-				submodule_load_from_wd_lite(sm);
-			});
+		git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
+		while (git_submodule_cache_iterate(&iter, NULL, &sm, cache) == 0) {
+			if ((error = submodule_load_from_wd_lite(sm)) < 0)
+				goto cleanup;
+		}
 	}
 
 cleanup:
@@ -627,8 +708,9 @@ int git_submodule_foreach(
 	void *payload)
 {
 	git_vector snapshot = GIT_VECTOR_INIT;
-	git_strmap *submodules;
+	git_submodule_cache *submodules;
 	git_submodule *sm;
+	git_hashmap_iter_t iter;
 	int error;
 	size_t i;
 
@@ -637,20 +719,22 @@ int git_submodule_foreach(
 		return -1;
 	}
 
-	if ((error = git_strmap_new(&submodules)) < 0)
-		return error;
+	if ((submodules = git__calloc(1, sizeof(git_submodule_cache))) == NULL)
+		return -1;
 
-	if ((error = git_submodule__map(repo, submodules)) < 0)
+	if ((error = git_submodule__map(submodules, repo)) < 0)
 		goto done;
 
-	if (!(error = git_vector_init(
-			&snapshot, git_strmap_size(submodules), submodule_cmp))) {
-
-		git_strmap_foreach_value(submodules, sm, {
+	if (!(error = git_vector_init(&snapshot,
+			git_submodule_cache_size(submodules),
+			submodule_cmp))) {
+		for (iter = GIT_HASHMAP_ITER_INIT;
+		     git_submodule_cache_iterate(&iter, NULL, &sm, submodules) == 0; ) {
 			if ((error = git_vector_insert(&snapshot, sm)) < 0)
 				break;
+
 			GIT_REFCOUNT_INC(sm);
-		});
+		}
 	}
 
 	if (error < 0)
@@ -668,12 +752,14 @@ int git_submodule_foreach(
 done:
 	git_vector_foreach(&snapshot, i, sm)
 		git_submodule_free(sm);
-	git_vector_free(&snapshot);
+	git_vector_dispose(&snapshot);
 
-	git_strmap_foreach_value(submodules, sm, {
+	for (iter = GIT_HASHMAP_ITER_INIT;
+	     git_submodule_cache_iterate(&iter, NULL, &sm, submodules) == 0; )
 		git_submodule_free(sm);
-	});
-	git_strmap_free(submodules);
+
+	git_submodule_cache_dispose(submodules);
+	git__free(submodules);
 
 	return error;
 }
@@ -1032,16 +1118,23 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index)
 	git_commit_free(head);
 
 	/* add it */
-	error = git_index_add(index, &entry);
+	if ((error = git_index_add(index, &entry)) < 0)
+		goto cleanup;
+
+	/* Adding implies conflict was resolved, move conflict entries to REUC */
+	if ((error = git_index__conflict_to_reuc(index, entry.path)) < 0 && error != GIT_ENOTFOUND)
+		goto cleanup;
 
 	/* write it, if requested */
-	if (!error && write_index) {
-		error = git_index_write(index);
+	if (write_index) {
+		if ((error = git_index_write(index)) < 0)
+			goto cleanup;
 
-		if (!error)
-			git_oid_cpy(&sm->index_oid, &sm->wd_oid);
+		git_oid_cpy(&sm->index_oid, &sm->wd_oid);
 	}
 
+	error = 0;
+
 cleanup:
 	git_repository_free(sm_repo);
 	git_str_dispose(&path);
@@ -1338,11 +1431,11 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 	/* Get the status of the submodule to determine if it is already initialized  */
 	if ((error = git_submodule_status(&submodule_status, sm->repo, sm->name, GIT_SUBMODULE_IGNORE_UNSPECIFIED)) < 0)
 		goto done;
-	
+
 	/* If the submodule is configured but hasn't been added, skip it */
 	if (submodule_status == GIT_SUBMODULE_STATUS_IN_CONFIG)
 	        goto done;
-	
+
 	/*
 	 * If submodule work dir is not already initialized, check to see
 	 * what we need to do (initialize, clone, return error...)
@@ -1671,18 +1764,34 @@ static int submodule_update_head(git_submodule *submodule)
 	return 0;
 }
 
+static int submodule_name_error(const char *name)
+{
+	git_error_set(GIT_ERROR_SUBMODULE,
+		"invalid value for submodule name: '%s'", name);
+	return GIT_EINVALID;
+}
+
+static int submodule_config_error(const char *property, const char *value)
+{
+	git_error_set(GIT_ERROR_SUBMODULE,
+		"invalid value for submodule '%s' property: '%s'", property, value);
+	return GIT_EINVALID;
+}
+
 int git_submodule_reload(git_submodule *sm, int force)
 {
 	git_config *mods = NULL;
-	int error;
+	int valid, error = 0;
 
 	GIT_UNUSED(force);
 
 	GIT_ASSERT_ARG(sm);
 
-	if ((error = git_submodule_name_is_valid(sm->repo, sm->name, 0)) <= 0)
+	if ((valid = git_submodule_name_is_valid(sm->repo, sm->name, 0)) <= 0) {
 		/* This should come with a warning, but we've no API for that */
+		error = valid ? valid : submodule_name_error(sm->name);
 		goto out;
+	}
 
 	if (git_repository_is_bare(sm->repo))
 		goto out;
@@ -1705,6 +1814,12 @@ int git_submodule_reload(git_submodule *sm, int force)
 	    (error = submodule_update_head(sm)) < 0)
 		goto out;
 
+	if ((valid = path_is_valid(sm->repo, sm->path)) <= 0) {
+		/* This should come with a warning, but we've no API for that */
+		error = valid ? valid : submodule_config_error("path", sm->path);
+		goto out;
+	}
+
 out:
 	git_config_free(mods);
 	return error;
@@ -1888,13 +2003,6 @@ void git_submodule_free(git_submodule *sm)
 	GIT_REFCOUNT_DEC(sm, submodule_release);
 }
 
-static int submodule_config_error(const char *property, const char *value)
-{
-	git_error_set(GIT_ERROR_INVALID,
-		"invalid value for submodule '%s' property: '%s'", property, value);
-	return -1;
-}
-
 int git_submodule_parse_ignore(git_submodule_ignore_t *out, const char *value)
 {
 	int val;
@@ -2049,7 +2157,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 {
 	lfc_data *data = payload;
 	const char *namestart, *property;
-	git_strmap *map = data->map;
+	git_submodule_cache *cache = data->cache;
 	git_str name = GIT_STR_INIT;
 	git_submodule *sm;
 	int error, isvalid;
@@ -2080,7 +2188,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 	 * a new submodule, load the config and insert it. If it's
 	 * already inserted, we've already loaded it, so we skip.
 	 */
-	if (git_strmap_exists(map, name.ptr)) {
+	if (git_submodule_cache_contains(cache, name.ptr)) {
 		error = 0;
 		goto done;
 	}
@@ -2093,7 +2201,14 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 		goto done;
 	}
 
-	if ((error = git_strmap_set(map, sm->name, sm)) < 0)
+	isvalid = path_is_valid(data->repo, sm->path);
+	if (isvalid <= 0) {
+		git_submodule_free(sm);
+		error = isvalid;
+		goto done;
+	}
+
+	if ((error = git_submodule_cache_put(cache, sm->name, sm)) < 0)
 		goto done;
 
 	error = 0;

data/vendor/libgit2/src/libgit2/submodule.h

@@ -12,6 +12,7 @@
 #include "git2/submodule.h"
 #include "git2/repository.h"
 #include "futils.h"
+#include "hashmap.h"
 
 /* Notes:
  *
@@ -116,15 +117,17 @@ enum {
 #define GIT_SUBMODULE_STATUS__CLEAR_INTERNAL(S) \
 	((S) & ~(0xFFFFFFFFu << 20))
 
+GIT_HASHMAP_STR_STRUCT(git_submodule_cache, git_submodule *);
+
 /* Initialize an external submodule cache for the provided repo. */
-extern int git_submodule_cache_init(git_strmap **out, git_repository *repo);
+extern int git_submodule_cache_init(git_submodule_cache **out, git_repository *repo);
 
 /* Release the resources of the submodule cache. */
-extern int git_submodule_cache_free(git_strmap *cache);
+extern int git_submodule_cache_free(git_submodule_cache *cache);
 
 /* Submodule lookup with an explicit cache */
 extern int git_submodule__lookup_with_cache(
-	git_submodule **out, git_repository *repo, const char *path, git_strmap *cache);
+	git_submodule **out, git_repository *repo, const char *path, git_submodule_cache *cache);
 
 /* Internal status fn returns status and optionally the various OIDs */
 extern int git_submodule__status(
@@ -145,10 +148,6 @@ extern int git_submodule_parse_ignore(
 extern int git_submodule_parse_update(
 	git_submodule_update_t *out, const char *value);
 
-extern int git_submodule__map(
-	git_repository *repo,
-	git_strmap *map);
-
 /**
  * Check whether a submodule's name is valid.
  *

data/vendor/libgit2/src/libgit2/tag.c

@@ -263,8 +263,10 @@ static bool tag_name_is_valid(const char *tag_name)
 	/*
 	 * Discourage tag name starting with dash,
 	 * https://github.com/git/git/commit/4f0accd638b8d2
+	 * and refuse to use HEAD as a tagname,
+	 * https://github.com/git/git/commit/bbd445d5efd415
 	 */
-	return tag_name[0] != '-';
+	return tag_name[0] != '-' && git__strcmp(tag_name, "HEAD");
 }
 
 static int git_tag_create__internal(
@@ -548,7 +550,7 @@ int git_tag_list_match(git_strarray *tag_names, const char *pattern, git_reposit
 	error = git_tag_foreach(repo, &tag_list_cb, (void *)&filter);
 
 	if (error < 0)
-		git_vector_free(&taglist);
+		git_vector_dispose(&taglist);
 
 	tag_names->strings =
 		(char **)git_vector_detach(&tag_names->count, NULL, &taglist);