rugged 0.17.0.b6 → 0.17.0.b7

data/vendor/libgit2/src/protocol.h

@@ -14,4 +14,8 @@
 int git_protocol_store_refs(git_transport *t, int flushes);
 int git_protocol_detect_caps(git_pkt_ref *pkt, git_transport_caps *caps);
 
+#define GIT_SIDE_BAND_DATA     1
+#define GIT_SIDE_BAND_PROGRESS 2
+#define GIT_SIDE_BAND_ERROR    3
+
 #endif

data/vendor/libgit2/src/reflog.c

@@ -372,7 +372,7 @@ int git_reflog_rename(git_reference *ref, const char *new_name)
 		goto cleanup;
 
 	if (git_path_isdir(git_buf_cstr(&new_path)) && 
-		(git_futils_rmdir_r(git_buf_cstr(&new_path), GIT_DIRREMOVAL_ONLY_EMPTY_DIRS) < 0))
+		(git_futils_rmdir_r(git_buf_cstr(&new_path), NULL, GIT_DIRREMOVAL_ONLY_EMPTY_DIRS) < 0))
 		goto cleanup;
 
 	if (git_futils_mkpath2file(git_buf_cstr(&new_path), GIT_REFLOG_DIR_MODE) < 0)

data/vendor/libgit2/src/refs.c

@@ -15,6 +15,7 @@
 #include <git2/tag.h>
 #include <git2/object.h>
 #include <git2/oid.h>
+#include <git2/branch.h>
 
 GIT__USE_STRMAP;
 
@@ -68,11 +69,6 @@ static int reference_path_available(git_repository *repo,
 static int reference_delete(git_reference *ref);
 static int reference_lookup(git_reference *ref);
 
-/* name normalization */
-static int normalize_name(char *buffer_out, size_t out_size,
-	const char *name, int is_oid_ref);
-
-
 void git_reference_free(git_reference *reference)
 {
 	if (reference == NULL)
@@ -159,11 +155,26 @@ static int loose_parse_symbolic(git_reference *ref, git_buf *file_content)
 
 static int loose_parse_oid(git_oid *oid, git_buf *file_content)
 {
-	/* File format: 40 chars (OID) */
-	if (git_buf_len(file_content) == GIT_OID_HEXSZ &&
-		git_oid_fromstr(oid, git_buf_cstr(file_content)) == 0)
+	size_t len;
+	const char *str;
+
+	len = git_buf_len(file_content);
+	if (len < GIT_OID_HEXSZ)
+		goto corrupted;
+
+	/* str is guranteed to be zero-terminated */
+	str = git_buf_cstr(file_content);
+
+	/* If the file is longer than 40 chars, the 41st must be a space */
+	if (git_oid_fromstr(oid, git_buf_cstr(file_content)) < 0)
+		goto corrupted;
+
+	/* If the file is longer than 40 chars, the 41st must be a space */
+	str += GIT_OID_HEXSZ;
+	if (*str == '\0' || git__isspace(*str))
 		return 0;
 
+corrupted:
 	giterr_set(GITERR_REFERENCE, "Corrupted loose reference file");
 	return -1;
 }
@@ -200,8 +211,6 @@ static int loose_lookup(git_reference *ref)
 	if (!updated)
 		return 0;
 
-	git_buf_rtrim(&ref_file);
-
 	if (ref->flags & GIT_REF_SYMBOLIC) {
 		git__free(ref->target.symbolic);
 		ref->target.symbolic = NULL;
@@ -211,6 +220,7 @@ static int loose_lookup(git_reference *ref)
 
 	if (git__prefixcmp((const char *)(ref_file.ptr), GIT_SYMREF) == 0) {
 		ref->flags |= GIT_REF_SYMBOLIC;
+		git_buf_rtrim(&ref_file);
 		result = loose_parse_symbolic(ref, &ref_file);
 	} else {
 		ref->flags |= GIT_REF_OID;
@@ -266,14 +276,15 @@ static int loose_write(git_reference *ref)
 	if (git_buf_joinpath(&ref_path, ref->owner->path_repository, ref->name) < 0)
 		return -1;
 
-	/* Remove a possibly existing empty directory hierarchy 
+	/* Remove a possibly existing empty directory hierarchy
 	 * which name would collide with the reference name
 	 */
-	if (git_path_isdir(git_buf_cstr(&ref_path)) && 
-		(git_futils_rmdir_r(git_buf_cstr(&ref_path), GIT_DIRREMOVAL_ONLY_EMPTY_DIRS) < 0)) {
-			git_buf_free(&ref_path);
-			return -1;
-		}
+	if (git_path_isdir(git_buf_cstr(&ref_path)) &&
+		git_futils_rmdir_r(git_buf_cstr(&ref_path), NULL,
+			GIT_DIRREMOVAL_ONLY_EMPTY_DIRS) < 0) {
+		git_buf_free(&ref_path);
+		return -1;
+	}
 
 	if (git_filebuf_open(&file, ref_path.ptr, GIT_FILEBUF_FORCE) < 0) {
 		git_buf_free(&ref_path);
@@ -499,6 +510,10 @@ static int _dirent_loose_listall(void *_data, git_buf *full_path)
 			return 0; /* we are filtering out this reference */
 	}
 
+	/* Locked references aren't returned */
+	if (!git__suffixcmp(file_path, GIT_FILELOCK_EXTENSION))
+		return 0;
+
 	if (data->callback(file_path, data->callback_payload))
 		data->callback_error = GIT_EUSER;
 
@@ -1099,9 +1114,12 @@ int git_reference_lookup_resolved(
 	scan->name = git__calloc(GIT_REFNAME_MAX + 1, sizeof(char));
 	GITERR_CHECK_ALLOC(scan->name);
 
-	if ((result = normalize_name(scan->name, GIT_REFNAME_MAX, name, 0)) < 0) {
-		git_reference_free(scan);
-		return result;
+	if ((result = git_reference__normalize_name_lax(
+		scan->name,
+		GIT_REFNAME_MAX,
+		name)) < 0) {
+			git_reference_free(scan);
+			return result;
 	}
 
 	scan->target.symbolic = git__strdup(scan->name);
@@ -1197,12 +1215,16 @@ int git_reference_create_symbolic(
 {
 	char normalized[GIT_REFNAME_MAX];
 	git_reference *ref = NULL;
+	int error;
 
-	if (normalize_name(normalized, sizeof(normalized), name, 0) < 0)
-		return -1;
+	if (git_reference__normalize_name_lax(
+		normalized,
+		sizeof(normalized),
+		name) < 0)
+			return -1;
 
-	if (reference_can_write(repo, normalized, NULL, force) < 0)
-		return -1;
+	if ((error = reference_can_write(repo, normalized, NULL, force)) < 0)
+		return error;
 
 	if (reference_alloc(&ref, repo, normalized) < 0)
 		return -1;
@@ -1231,14 +1253,18 @@ int git_reference_create_oid(
 	const git_oid *id,
 	int force)
 {
+	int error;
 	git_reference *ref = NULL;
 	char normalized[GIT_REFNAME_MAX];
 
-	if (normalize_name(normalized, sizeof(normalized), name, 1) < 0)
-		return -1;
+	if (git_reference__normalize_name_lax(
+		normalized,
+		sizeof(normalized),
+		name) < 0)
+			return -1;
 
-	if (reference_can_write(repo, normalized, NULL, force) < 0)
-		return -1;
+	if ((error = reference_can_write(repo, normalized, NULL, force)) < 0)
+		return error;
 
 	if (reference_alloc(&ref, repo, name) < 0)
 		return -1;
@@ -1314,8 +1340,11 @@ int git_reference_set_target(git_reference *ref, const char *target)
 		return -1;
 	}
 
-	if (normalize_name(normalized, sizeof(normalized), target, 0))
-		return -1;
+	if (git_reference__normalize_name_lax(
+		normalized,
+		sizeof(normalized),
+		target))
+			return -1;
 
 	git__free(ref->target.symbolic);
 	ref->target.symbolic = git__strdup(normalized);
@@ -1327,24 +1356,36 @@ int git_reference_set_target(git_reference *ref, const char *target)
 int git_reference_rename(git_reference *ref, const char *new_name, int force)
 {
 	int result;
+	unsigned int normalization_flags;
 	git_buf aux_path = GIT_BUF_INIT;
 	char normalized[GIT_REFNAME_MAX];
+	bool should_head_be_updated = false;
 
-	const char *head_target = NULL;
-	git_reference *head = NULL;
+	normalization_flags = ref->flags & GIT_REF_SYMBOLIC ?
+		GIT_REF_FORMAT_ALLOW_ONELEVEL
+		: GIT_REF_FORMAT_NORMAL;
 
-	if (normalize_name(normalized, sizeof(normalized),
-		new_name, ref->flags & GIT_REF_OID) < 0)
-		return -1;
+	if (git_reference_normalize_name(
+		normalized,
+		sizeof(normalized),
+		new_name,
+		normalization_flags) < 0)
+			return -1;
 
-	if (reference_can_write(ref->owner, normalized, ref->name, force) < 0)
-		return -1;
+	if ((result = reference_can_write(ref->owner, normalized, ref->name, force)) < 0)
+		return result;
 
 	/* Initialize path now so we won't get an allocation failure once
 	 * we actually start removing things. */
 	if (git_buf_joinpath(&aux_path, ref->owner->path_repository, new_name) < 0)
 		return -1;
 
+	/*
+	 * Check if we have to update HEAD.
+	 */
+	if ((should_head_be_updated = git_branch_is_head(ref)) < 0)
+		goto cleanup;
+
 	/*
 	 * Now delete the old ref and remove an possibly existing directory
 	 * named `new_name`. Note that using the internal `reference_delete`
@@ -1369,25 +1410,13 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force)
 		goto rollback;
 
 	/*
-	 * Check if we have to update HEAD.
+	 * Update HEAD it was poiting to the reference being renamed.
 	 */
-	if (git_reference_lookup(&head, ref->owner, GIT_HEAD_FILE) < 0) {
-		giterr_set(GITERR_REFERENCE,
-			"Failed to update HEAD after renaming reference");
-		goto cleanup;
-	}
-
-	head_target = git_reference_target(head);
-
-	if (head_target && !strcmp(head_target, ref->name)) {
-		git_reference_free(head);
-		head = NULL;
-
-		if (git_reference_create_symbolic(&head, ref->owner, "HEAD", new_name, 1) < 0) {
+	if (should_head_be_updated && 
+		git_repository_set_head(ref->owner, new_name) < 0) {
 			giterr_set(GITERR_REFERENCE,
 				"Failed to update HEAD after renaming reference");
 			goto cleanup;
-		}
 	}
 
 	/*
@@ -1405,12 +1434,10 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force)
 	/* The reference is no longer packed */
 	ref->flags &= ~GIT_REF_PACKED;
 
-	git_reference_free(head);
 	git_buf_free(&aux_path);
 	return 0;
 
 cleanup:
-	git_reference_free(head);
 	git_buf_free(&aux_path);
 	return -1;
 
@@ -1565,112 +1592,185 @@ static int is_valid_ref_char(char ch)
 	}
 }
 
-static int normalize_name(
-	char *buffer_out,
-	size_t out_size,
-	const char *name,
-	int is_oid_ref)
+static int ensure_segment_validity(const char *name)
 {
-	const char *name_end, *buffer_out_start;
-	const char *current;
-	int contains_a_slash = 0;
+	const char *current = name;
+	char prev = '\0';
 
-	assert(name && buffer_out);
+	if (*current == '.')
+		return -1; /* Refname starts with "." */
 
-	buffer_out_start = buffer_out;
-	current = name;
-	name_end = name + strlen(name);
+	for (current = name; ; current++) {
+		if (*current == '\0' || *current == '/')
+			break;
 
-	/* Terminating null byte */
-	out_size--;
+		if (!is_valid_ref_char(*current))
+			return -1; /* Illegal character in refname */
 
-	/* A refname can not be empty */
-	if (name_end == name)
-		goto invalid_name;
+		if (prev == '.' && *current == '.')
+			return -1; /* Refname contains ".." */
 
-	/* A refname can not end with a dot or a slash */
-	if (*(name_end - 1) == '.' || *(name_end - 1) == '/')
-		goto invalid_name;
+		if (prev == '@' && *current == '{')
+			return -1; /* Refname contains "@{" */
 
-	while (current < name_end && out_size) {
-		if (!is_valid_ref_char(*current))
-			goto invalid_name;
+		prev = *current;
+	}
+
+	return (int)(current - name);
+}
 
-		if (buffer_out > buffer_out_start) {
-			char prev = *(buffer_out - 1);
+static bool is_all_caps_and_underscore(const char *name, size_t len)
+{
+	size_t i;
+	char c;
 
-			/* A refname can not start with a dot nor contain a double dot */
-			if (*current == '.' && ((prev == '.') || (prev == '/')))
-				goto invalid_name;
+	assert(name && len > 0);
 
-			/* '@{' is forbidden within a refname */
-			if (*current == '{' && prev == '@')
-				goto invalid_name;
+	for (i = 0; i < len; i++)
+	{
+		c = name[i];
+		if ((c < 'A' || c > 'Z') && c != '_')
+			return false;
+	}
 
-			/* Prevent multiple slashes from being added to the output */
-			if (*current == '/' && prev == '/') {
-				current++;
-				continue;
+	if (*name == '_' || name[len - 1] == '_')
+		return false;
+
+	return true;
+}
+
+int git_reference__normalize_name(
+	git_buf *buf,
+	const char *name,
+	unsigned int flags)
+{
+	// Inspired from https://github.com/git/git/blob/f06d47e7e0d9db709ee204ed13a8a7486149f494/refs.c#L36-100
+
+	char *current;
+	int segment_len, segments_count = 0, error = -1;
+	unsigned int process_flags;
+	bool normalize = (buf != NULL);
+	assert(name);
+
+	process_flags = flags;
+	current = (char *)name;
+
+	if (normalize)
+		git_buf_clear(buf);
+
+	while (true) {
+		segment_len = ensure_segment_validity(current);
+		if (segment_len < 0) {
+			if ((process_flags & GIT_REF_FORMAT_REFSPEC_PATTERN) &&
+					current[0] == '*' &&
+					(current[1] == '\0' || current[1] == '/')) {
+				/* Accept one wildcard as a full refname component. */
+				process_flags &= ~GIT_REF_FORMAT_REFSPEC_PATTERN;
+				segment_len = 1;
+			} else
+				goto cleanup;
+		}
+
+		if (segment_len > 0) {
+			if (normalize) {
+				size_t cur_len = git_buf_len(buf);
+
+				git_buf_joinpath(buf, git_buf_cstr(buf), current);
+				git_buf_truncate(buf,
+					cur_len + segment_len + (segments_count ? 1 : 0));
+
+				if (git_buf_oom(buf))
+					goto cleanup;
 			}
+
+			segments_count++;
 		}
 
-		if (*current == '/')
-			contains_a_slash = 1;
+		if (current[segment_len] == '\0')
+			break;
 
-		*buffer_out++ = *current++;
-		out_size--;
+		current += segment_len + 1;
 	}
 
-	if (!out_size)
-		goto invalid_name;
+	/* A refname can not be empty */
+	if (segment_len == 0 && segments_count == 0)
+		goto cleanup;
 
-	/* Object id refname have to contain at least one slash, except
-	 * for HEAD in a detached state or MERGE_HEAD if we're in the
-	 * middle of a merge */
-	if (is_oid_ref &&
-		!contains_a_slash &&
-		strcmp(name, GIT_HEAD_FILE) != 0 &&
-		strcmp(name, GIT_MERGE_HEAD_FILE) != 0 &&
-		strcmp(name, GIT_FETCH_HEAD_FILE) != 0)
-		goto invalid_name;
+	/* A refname can not end with "." */
+	if (current[segment_len - 1] == '.')
+		goto cleanup;
+
+	/* A refname can not end with "/" */
+	if (current[segment_len - 1] == '/')
+		goto cleanup;
 
 	/* A refname can not end with ".lock" */
 	if (!git__suffixcmp(name, GIT_FILELOCK_EXTENSION))
-		goto invalid_name;
+		goto cleanup;
 
-	*buffer_out = '\0';
+	if ((segments_count == 1 ) && !(flags & GIT_REF_FORMAT_ALLOW_ONELEVEL))
+		goto cleanup;
 
-	/*
-	 * For object id references, name has to start with refs/. Again,
-	 * we need to allow HEAD to be in a detached state.
-	 */
-	if (is_oid_ref && !(git__prefixcmp(buffer_out_start, GIT_REFS_DIR) ||
-		strcmp(buffer_out_start, GIT_HEAD_FILE)))
-		goto invalid_name;
+	if ((segments_count == 1 ) &&
+		!(is_all_caps_and_underscore(name, (size_t)segment_len) ||
+			((flags & GIT_REF_FORMAT_REFSPEC_PATTERN) && !strcmp("*", name))))
+			goto cleanup;
 
-	return 0;
+	if ((segments_count > 1)
+		&& (is_all_caps_and_underscore(name, strchr(name, '/') - name)))
+			goto cleanup;
 
-invalid_name:
-	giterr_set(GITERR_REFERENCE, "The given reference name is not valid");
-	return -1;
+	error = 0;
+
+cleanup:
+	if (error)
+		giterr_set(
+			GITERR_REFERENCE,
+			"The given reference name '%s' is not valid", name);
+
+	return error;
 }
 
-int git_reference__normalize_name(
+int git_reference_normalize_name(
 	char *buffer_out,
-	size_t out_size,
-	const char *name)
+	size_t buffer_size,
+	const char *name,
+	unsigned int flags)
 {
-	return normalize_name(buffer_out, out_size, name, 0);
+	git_buf buf = GIT_BUF_INIT;
+	int error;
+
+	if ((error = git_reference__normalize_name(&buf, name, flags)) < 0)
+		goto cleanup;
+
+	if (git_buf_len(&buf) > buffer_size - 1) {
+		giterr_set(
+		GITERR_REFERENCE,
+		"The provided buffer is too short to hold the normalization of '%s'", name);
+		error = GIT_EBUFS;
+		goto cleanup;
+	}
+
+	git_buf_copy_cstr(buffer_out, buffer_size, &buf);
+
+	error = 0;
+
+cleanup:
+	git_buf_free(&buf);
+	return error;
 }
 
-int git_reference__normalize_name_oid(
+int git_reference__normalize_name_lax(
 	char *buffer_out,
 	size_t out_size,
 	const char *name)
 {
-	return normalize_name(buffer_out, out_size, name, 1);
+	return git_reference_normalize_name(
+		buffer_out,
+		out_size,
+		name,
+		GIT_REF_FORMAT_ALLOW_ONELEVEL);
 }
-
 #define GIT_REF_TYPEMASK (GIT_REF_OID | GIT_REF_SYMBOLIC)
 
 int git_reference_cmp(git_reference *ref1, git_reference *ref2)
@@ -1804,6 +1904,74 @@ int git_reference_has_log(
 int git_reference_is_branch(git_reference *ref)
 {
 	assert(ref);
-
 	return git__prefixcmp(ref->name, GIT_REFS_HEADS_DIR) == 0;
 }
+
+int git_reference_is_remote(git_reference *ref)
+{
+	assert(ref);
+	return git__prefixcmp(ref->name, GIT_REFS_REMOTES_DIR) == 0;
+}
+
+static int peel_error(int error, git_reference *ref, const char* msg)
+{
+	giterr_set(
+		GITERR_INVALID,
+		"The reference '%s' cannot be peeled - %s", git_reference_name(ref), msg);
+	return error;
+}
+
+static int reference_target(git_object **object, git_reference *ref)
+{
+	const git_oid *oid;
+
+	oid = git_reference_oid(ref);
+
+	return git_object_lookup(object, git_reference_owner(ref), oid, GIT_OBJ_ANY);
+}
+
+int git_reference_peel(
+		git_object **peeled,
+		git_reference *ref,
+		git_otype target_type)
+{
+	git_reference *resolved = NULL;
+	git_object *target = NULL;
+	int error;
+
+	assert(ref);
+
+	if ((error = git_reference_resolve(&resolved, ref)) < 0)
+		return peel_error(error, ref, "Cannot resolve reference");
+
+	if ((error = reference_target(&target, resolved)) < 0) {
+		peel_error(error, ref, "Cannot retrieve reference target");
+		goto cleanup;
+	}
+	
+	if (target_type == GIT_OBJ_ANY && git_object_type(target) != GIT_OBJ_TAG)
+		error = git_object__dup(peeled, target);
+	else 
+		error = git_object_peel(peeled, target, target_type);
+
+cleanup:
+	git_object_free(target);
+	git_reference_free(resolved);
+	return error;
+}
+
+int git_reference__is_valid_name(
+	const char *refname,
+	unsigned int flags)
+{
+	giterr_clear();
+	return git_reference__normalize_name(NULL, refname, flags) == 0;
+}
+
+int git_reference_is_valid_name(
+	const char *refname)
+{
+	return git_reference__is_valid_name(
+		refname,
+		GIT_REF_FORMAT_ALLOW_ONELEVEL);
+}