rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/netops.h

@@ -7,71 +7,95 @@
 #ifndef INCLUDE_netops_h__
 #define INCLUDE_netops_h__
 
-#include "posix.h"
 #include "common.h"
 
-#ifdef GIT_SSL
+#include "posix.h"
+#include "stream.h"
+
+#ifdef GIT_OPENSSL
 # include <openssl/ssl.h>
 #endif
 
-struct gitno_ssl {
-#ifdef GIT_SSL
-	SSL_CTX *ctx;
+typedef struct gitno_ssl {
+#ifdef GIT_OPENSSL
 	SSL *ssl;
 #else
 	size_t dummy;
 #endif
-};
-
-typedef struct gitno_ssl gitno_ssl;
+} gitno_ssl;
 
 /* Represents a socket that may or may not be using SSL */
-struct gitno_socket {
+typedef struct gitno_socket {
 	GIT_SOCKET socket;
 	gitno_ssl ssl;
-};
+} gitno_socket;
 
-typedef struct gitno_socket gitno_socket;
-
-struct gitno_buffer {
+typedef struct gitno_buffer {
 	char *data;
 	size_t len;
 	size_t offset;
-	gitno_socket *socket;
 	int (*recv)(struct gitno_buffer *buffer);
 	void *cb_data;
-};
-
-typedef struct gitno_buffer gitno_buffer;
+} gitno_buffer;
 
 /* Flags to gitno_connect */
 enum {
 	/* Attempt to create an SSL connection. */
 	GITNO_CONNECT_SSL = 1,
-
-	/* Valid only when GITNO_CONNECT_SSL is also specified.
-	 * Indicates that the server certificate should not be validated. */
-	GITNO_CONNECT_SSL_NO_CHECK_CERT = 2,
 };
 
-void gitno_buffer_setup(gitno_socket *t, gitno_buffer *buf, char *data, size_t len);
-void gitno_buffer_setup_callback(gitno_socket *t, gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data);
+/**
+ * Check if the name in a cert matches the wanted hostname
+ *
+ * Check if a pattern from a certificate matches the hostname we
+ * wanted to connect to according to RFC2818 rules (which specifies
+ * HTTP over TLS). Mainly, an asterisk matches anything, but is
+ * limited to a single url component.
+ *
+ * Note that this does not set an error message. It expects the user
+ * to provide the message for the user.
+ */
+int gitno__match_host(const char *pattern, const char *host);
+
+void gitno_buffer_setup_fromstream(git_stream *st, gitno_buffer *buf, char *data, size_t len);
+void gitno_buffer_setup_callback(gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data);
 int gitno_recv(gitno_buffer *buf);
 
 void gitno_consume(gitno_buffer *buf, const char *ptr);
 void gitno_consume_n(gitno_buffer *buf, size_t cons);
 
-int gitno_connect(gitno_socket *socket, const char *host, const char *port, int flags);
-int gitno_send(gitno_socket *socket, const char *msg, size_t len, int flags);
-int gitno_close(gitno_socket *s);
-int gitno_select_in(gitno_buffer *buf, long int sec, long int usec);
+typedef struct gitno_connection_data {
+	char *host;
+	char *port;
+	char *path;
+	char *user;
+	char *pass;
+	bool use_ssl;
+} gitno_connection_data;
+
+/*
+ * This replaces all the pointers in `data` with freshly-allocated strings,
+ * that the caller is responsible for freeing.
+ * `gitno_connection_data_free_ptrs` is good for this.
+ */
+
+int gitno_connection_data_from_url(
+		gitno_connection_data *data,
+		const char *url,
+		const char *service_suffix);
+
+/* This frees all the pointers IN the struct, but not the struct itself. */
+void gitno_connection_data_free_ptrs(gitno_connection_data *data);
 
 int gitno_extract_url_parts(
 		char **host,
 		char **port,
+		char **path,
 		char **username,
 		char **password,
 		const char *url,
 		const char *default_port);
 
+const char *gitno__default_port(gitno_connection_data *data);
+
 #endif

data/vendor/libgit2/src/notes.c

@@ -12,10 +12,11 @@
 #include "config.h"
 #include "iterator.h"
 #include "signature.h"
+#include "blob.h"
 
 static int note_error_notfound(void)
 {
-	giterr_set(GITERR_INVALID, "Note could not be found");
+	git_error_set(GIT_ERROR_INVALID, "note could not be found");
 	return GIT_ENOTFOUND;
 }
 
@@ -107,7 +108,7 @@ static int tree_write(
 	const git_tree_entry *entry;
 	git_oid tree_oid;
 
-	if ((error = git_treebuilder_create(&tb, source_tree)) < 0)
+	if ((error = git_treebuilder_new(&tb, repo, source_tree)) < 0)
 		goto cleanup;
 
 	if (object_oid) {
@@ -119,7 +120,7 @@ static int tree_write(
 			goto cleanup;
 	}
 
-	if ((error = git_treebuilder_write(&tree_oid, repo, tb)) < 0)
+	if ((error = git_treebuilder_write(&tree_oid, tb)) < 0)
 		goto cleanup;
 
 	error = git_tree_lookup(out, repo, &tree_oid);
@@ -226,7 +227,7 @@ static int remove_note_in_tree_enotfound_cb(
 	GIT_UNUSED(note_oid);
 	GIT_UNUSED(fanout);
 
-	giterr_set(GITERR_REPOSITORY, "Object '%s' has no note", annotated_object_sha);
+	git_error_set(GIT_ERROR_REPOSITORY, "object '%s' has no note", annotated_object_sha);
 	return current_error;
 }
 
@@ -244,7 +245,7 @@ static int insert_note_in_tree_eexists_cb(git_tree **out,
 	GIT_UNUSED(note_oid);
 	GIT_UNUSED(fanout);
 
-	giterr_set(GITERR_REPOSITORY, "Note for '%s' exists already", annotated_object_sha);
+	git_error_set(GIT_ERROR_REPOSITORY, "note for '%s' exists already", annotated_object_sha);
 	return current_error;
 }
 
@@ -268,7 +269,9 @@ static int insert_note_in_tree_enotfound_cb(git_tree **out,
 		GIT_FILEMODE_BLOB);
 }
 
-static int note_write(git_oid *out,
+static int note_write(
+	git_oid *notes_commit_out,
+	git_oid *notes_blob_out,
 	git_repository *repo,
 	const git_signature *author,
 	const git_signature *committer,
@@ -283,7 +286,7 @@ static int note_write(git_oid *out,
 	git_oid oid;
 	git_tree *tree = NULL;
 
-	// TODO: should we apply filters?
+	/* TODO: should we apply filters? */
 	/* create note object */
 	if ((error = git_blob_create_frombuffer(&oid, repo, note, strlen(note))) < 0)
 		goto cleanup;
@@ -294,36 +297,56 @@ static int note_write(git_oid *out,
 		insert_note_in_tree_enotfound_cb)) < 0)
 		goto cleanup;
 
-	if (out)
-		git_oid_cpy(out, &oid);
+	if (notes_blob_out)
+		git_oid_cpy(notes_blob_out, &oid);
+
 
 	error = git_commit_create(&oid, repo, notes_ref, author, committer,
 				  NULL, GIT_NOTES_DEFAULT_MSG_ADD,
 				  tree, *parents == NULL ? 0 : 1, (const git_commit **) parents);
 
+	if (notes_commit_out)
+		git_oid_cpy(notes_commit_out, &oid);
+
 cleanup:
 	git_tree_free(tree);
 	return error;
 }
 
-static int note_new(git_note **out, git_oid *note_oid, git_blob *blob)
+static int note_new(
+	git_note **out,
+	git_oid *note_oid,
+	git_commit *commit,
+	git_blob *blob)
 {
 	git_note *note = NULL;
+	git_off_t blobsize;
 
-	note = (git_note *)git__malloc(sizeof(git_note));
-	GITERR_CHECK_ALLOC(note);
+	note = git__malloc(sizeof(git_note));
+	GIT_ERROR_CHECK_ALLOC(note);
 
-	git_oid_cpy(&note->oid, note_oid);
-	note->message = git__strdup((char *)git_blob_rawcontent(blob));
-	GITERR_CHECK_ALLOC(note->message);
+	git_oid_cpy(&note->id, note_oid);
 
-	*out = note;
+	if (git_signature_dup(&note->author, git_commit_author(commit)) < 0 ||
+		git_signature_dup(&note->committer, git_commit_committer(commit)) < 0)
+		return -1;
 
+	blobsize = git_blob_rawsize(blob);
+	GIT_ERROR_CHECK_BLOBSIZE(blobsize);
+
+	note->message = git__strndup(git_blob_rawcontent(blob), (size_t)blobsize);
+	GIT_ERROR_CHECK_ALLOC(note->message);
+
+	*out = note;
 	return 0;
 }
 
 static int note_lookup(
-	git_note **out, git_repository *repo, git_tree *tree, const char *target)
+	git_note **out,
+	git_repository *repo,
+	git_commit *commit,
+	git_tree *tree,
+	const char *target)
 {
 	int error, fanout = 0;
 	git_oid oid;
@@ -340,7 +363,7 @@ static int note_lookup(
 	if ((error = git_blob_lookup(&blob, repo, &oid)) < 0)
 		goto cleanup;
 
-	if ((error = note_new(&note, &oid, blob)) < 0)
+	if ((error = note_new(&note, &oid, commit, blob)) < 0)
 		goto cleanup;
 
 	*out = note;
@@ -351,7 +374,9 @@ cleanup:
 	return error;
 }
 
-static int note_remove(git_repository *repo,
+static int note_remove(
+		git_oid *notes_commit_out,
+		git_repository *repo,
 		const git_signature *author, const git_signature *committer,
 		const char *notes_ref, git_tree *tree,
 		const char *target, git_commit **parents)
@@ -371,144 +396,258 @@ static int note_remove(git_repository *repo,
 	  *parents == NULL ? 0 : 1,
 	  (const git_commit **) parents);
 
+	if (error < 0)
+		goto cleanup;
+
+	if (notes_commit_out)
+		git_oid_cpy(notes_commit_out, &oid);
+
 cleanup:
 	git_tree_free(tree_after_removal);
 	return error;
 }
 
-static int note_get_default_ref(const char **out, git_repository *repo)
+static int note_get_default_ref(char **out, git_repository *repo)
 {
-	int ret;
 	git_config *cfg;
+	int ret = git_repository_config__weakptr(&cfg, repo);
 
-	*out = NULL;
-
-	if (git_repository_config__weakptr(&cfg, repo) < 0)
-		return -1;
-
-	ret = git_config_get_string(out, cfg, "core.notesRef");
-	if (ret == GIT_ENOTFOUND) {
-		giterr_clear();
-		*out = GIT_NOTES_DEFAULT_REF;
-		return 0;
-	}
+	*out = (ret != 0) ? NULL : git_config__get_string_force(
+		cfg, "core.notesref", GIT_NOTES_DEFAULT_REF);
 
 	return ret;
 }
 
-static int normalize_namespace(const char **notes_ref, git_repository *repo)
+static int normalize_namespace(char **out, git_repository *repo, const char *notes_ref)
 {
-	if (*notes_ref)
+	if (notes_ref) {
+		*out = git__strdup(notes_ref);
+		GIT_ERROR_CHECK_ALLOC(*out);
 		return 0;
+	}
 
-	return note_get_default_ref(notes_ref, repo);
+	return note_get_default_ref(out, repo);
 }
 
-static int retrieve_note_tree_and_commit(
-	git_tree **tree_out,
+static int retrieve_note_commit(
 	git_commit **commit_out,
+	char **notes_ref_out,
 	git_repository *repo,
-	const char **notes_ref)
+	const char *notes_ref)
 {
 	int error;
 	git_oid oid;
 
-	if ((error = normalize_namespace(notes_ref, repo)) < 0)
+	if ((error = normalize_namespace(notes_ref_out, repo, notes_ref)) < 0)
 		return error;
 
-	if ((error = git_reference_name_to_id(&oid, repo, *notes_ref)) < 0)
+	if ((error = git_reference_name_to_id(&oid, repo, *notes_ref_out)) < 0)
 		return error;
 
 	if (git_commit_lookup(commit_out, repo, &oid) < 0)
 		return error;
 
-	if ((error = git_commit_tree(tree_out, *commit_out)) < 0)
-		return error;
-
 	return 0;
 }
 
-int git_note_read(git_note **out, git_repository *repo,
-		  const char *notes_ref, const git_oid *oid)
+int git_note_commit_read(
+	git_note **out,
+	git_repository *repo,
+	git_commit *notes_commit,
+	const git_oid *oid)
 {
 	int error;
-	char *target = NULL;
 	git_tree *tree = NULL;
-	git_commit *commit = NULL;
+	char target[GIT_OID_HEXSZ + 1];
 
-	target = git_oid_allocfmt(oid);
-	GITERR_CHECK_ALLOC(target);
+	git_oid_tostr(target, sizeof(target), oid);
+
+	if ((error = git_commit_tree(&tree, notes_commit)) < 0)
+		goto cleanup;
 
-	if (!(error = retrieve_note_tree_and_commit(
-			&tree, &commit, repo, &notes_ref)))
-		error = note_lookup(out, repo, tree, target);
+	error = note_lookup(out, repo, notes_commit, tree, target);
 
-	git__free(target);
+cleanup:
 	git_tree_free(tree);
+	return error;
+}
+
+int git_note_read(git_note **out, git_repository *repo,
+		  const char *notes_ref_in, const git_oid *oid)
+{
+	int error;
+	char *notes_ref = NULL;
+	git_commit *commit = NULL;
+
+	error = retrieve_note_commit(&commit, &notes_ref, repo, notes_ref_in);
+
+	if (error < 0)
+		goto cleanup;
+
+	error = git_note_commit_read(out, repo, commit, oid);
+
+cleanup:
+	git__free(notes_ref);
 	git_commit_free(commit);
 	return error;
 }
 
-int git_note_create(
-	git_oid *out,
+int git_note_commit_create(
+	git_oid *notes_commit_out,
+	git_oid *notes_blob_out,
 	git_repository *repo,
+	git_commit *parent,
 	const git_signature *author,
 	const git_signature *committer,
-	const char *notes_ref,
 	const git_oid *oid,
 	const char *note,
 	int allow_note_overwrite)
 {
 	int error;
-	char *target = NULL;
-	git_commit *commit = NULL;
 	git_tree *tree = NULL;
+	char target[GIT_OID_HEXSZ + 1];
+
+	git_oid_tostr(target, sizeof(target), oid);
+
+	if (parent != NULL && (error = git_commit_tree(&tree, parent)) < 0)
+		goto cleanup;
 
-	target = git_oid_allocfmt(oid);
-	GITERR_CHECK_ALLOC(target);
+	error = note_write(notes_commit_out, notes_blob_out, repo, author,
+			committer, NULL, note, tree, target, &parent, allow_note_overwrite);
 
-	error = retrieve_note_tree_and_commit(&tree, &commit, repo, &notes_ref);
+	if (error < 0)
+		goto cleanup;
+
+cleanup:
+	git_tree_free(tree);
+	return error;
+}
+
+int git_note_create(
+	git_oid *out,
+	git_repository *repo,
+	const char *notes_ref_in,
+	const git_signature *author,
+	const git_signature *committer,
+	const git_oid *oid,
+	const char *note,
+	int allow_note_overwrite)
+{
+	int error;
+	char *notes_ref = NULL;
+	git_commit *existing_notes_commit = NULL;
+	git_reference *ref = NULL;
+	git_oid notes_blob_oid, notes_commit_oid;
+
+	error = retrieve_note_commit(&existing_notes_commit, &notes_ref,
+			repo, notes_ref_in);
 
 	if (error < 0 && error != GIT_ENOTFOUND)
 		goto cleanup;
 
-	error = note_write(out, repo, author, committer, notes_ref,
-			note, tree, target, &commit, allow_note_overwrite);
+	error = git_note_commit_create(&notes_commit_oid,
+			&notes_blob_oid,
+			repo, existing_notes_commit, author,
+			committer, oid, note,
+			allow_note_overwrite);
+	if (error < 0)
+		goto cleanup;
+
+	error = git_reference_create(&ref, repo, notes_ref,
+				&notes_commit_oid, 1, NULL);
+
+	if (out != NULL)
+		git_oid_cpy(out, &notes_blob_oid);
 
 cleanup:
-	git__free(target);
-	git_commit_free(commit);
-	git_tree_free(tree);
+	git__free(notes_ref);
+	git_commit_free(existing_notes_commit);
+	git_reference_free(ref);
 	return error;
 }
 
-int git_note_remove(git_repository *repo, const char *notes_ref,
-		const git_signature *author, const git_signature *committer,
+int git_note_commit_remove(
+		git_oid *notes_commit_out,
+		git_repository *repo,
+		git_commit *notes_commit,
+		const git_signature *author,
+		const git_signature *committer,
 		const git_oid *oid)
 {
 	int error;
-	char *target = NULL;
-	git_commit *commit = NULL;
 	git_tree *tree = NULL;
+	char target[GIT_OID_HEXSZ + 1];
+
+	git_oid_tostr(target, sizeof(target), oid);
 
-	target = git_oid_allocfmt(oid);
-	GITERR_CHECK_ALLOC(target);
+	if ((error = git_commit_tree(&tree, notes_commit)) < 0)
+		goto cleanup;
 
-	if (!(error = retrieve_note_tree_and_commit(
-			&tree, &commit, repo, &notes_ref)))
-		error = note_remove(
-			repo, author, committer, notes_ref, tree, target, &commit);
+	error = note_remove(notes_commit_out,
+		repo, author, committer, NULL, tree, target, &notes_commit);
 
-	git__free(target);
-	git_commit_free(commit);
+cleanup:
 	git_tree_free(tree);
 	return error;
 }
 
-int git_note_default_ref(const char **out, git_repository *repo)
+int git_note_remove(git_repository *repo, const char *notes_ref_in,
+		const git_signature *author, const git_signature *committer,
+		const git_oid *oid)
 {
-	assert(repo);
-	return note_get_default_ref(out, repo);
+	int error;
+	char *notes_ref_target = NULL;
+	git_commit *existing_notes_commit = NULL;
+	git_oid new_notes_commit;
+	git_reference *notes_ref = NULL;
+
+	error = retrieve_note_commit(&existing_notes_commit, &notes_ref_target,
+			repo, notes_ref_in);
+
+	if (error < 0)
+		goto cleanup;
+
+	error = git_note_commit_remove(&new_notes_commit, repo,
+			existing_notes_commit, author, committer, oid);
+	if (error < 0)
+		goto cleanup;
+
+	error = git_reference_create(&notes_ref, repo, notes_ref_target,
+			&new_notes_commit, 1, NULL);
+
+cleanup:
+	git__free(notes_ref_target);
+	git_reference_free(notes_ref);
+	git_commit_free(existing_notes_commit);
+	return error;
+}
+
+int git_note_default_ref(git_buf *out, git_repository *repo)
+{
+	char *default_ref;
+	int error;
+
+	assert(out && repo);
+
+	git_buf_sanitize(out);
+
+	if ((error = note_get_default_ref(&default_ref, repo)) < 0)
+		return error;
+
+	git_buf_attach(out, default_ref, strlen(default_ref));
+	return 0;
+}
+
+const git_signature *git_note_committer(const git_note *note)
+{
+	assert(note);
+	return note->committer;
+}
+
+const git_signature *git_note_author(const git_note *note)
+{
+	assert(note);
+	return note->author;
 }
 
 const char * git_note_message(const git_note *note)
@@ -517,10 +656,10 @@ const char * git_note_message(const git_note *note)
 	return note->message;
 }
 
-const git_oid * git_note_oid(const git_note *note)
+const git_oid * git_note_id(const git_note *note)
 {
 	assert(note);
-	return &note->oid;
+	return &note->id;
 }
 
 void git_note_free(git_note *note)
@@ -528,6 +667,8 @@ void git_note_free(git_note *note)
 	if (note == NULL)
 		return;
 
+	git_signature_free(note->committer);
+	git_signature_free(note->author);
 	git__free(note->message);
 	git__free(note);
 }
@@ -574,7 +715,7 @@ static int process_entry_path(
 	error = git_oid_fromstr(annotated_object_id, buf.ptr);
 
 cleanup:
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 	return error;
 }
 
@@ -592,8 +733,8 @@ int git_note_foreach(
 		return error;
 
 	while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
-		if (note_cb(&note_id, &annotated_id, payload)) {
-			error = GIT_EUSER;
+		if ((error = note_cb(&note_id, &annotated_id, payload)) != 0) {
+			git_error_set_after_callback(error);
 			break;
 		}
 	}
@@ -605,7 +746,6 @@ int git_note_foreach(
 	return error;
 }
 
-
 void git_note_iterator_free(git_note_iterator *it)
 {
 	if (it == NULL)
@@ -614,25 +754,42 @@ void git_note_iterator_free(git_note_iterator *it)
 	git_iterator_free(it);
 }
 
+int git_note_commit_iterator_new(
+	git_note_iterator **it,
+	git_commit *notes_commit)
+{
+	int error;
+	git_tree *tree;
+
+	if ((error = git_commit_tree(&tree, notes_commit)) < 0)
+		goto cleanup;
+
+	if ((error = git_iterator_for_tree(it, tree, NULL)) < 0)
+		git_iterator_free(*it);
+
+cleanup:
+	git_tree_free(tree);
+
+	return error;
+}
 
 int git_note_iterator_new(
 	git_note_iterator **it,
 	git_repository *repo,
-	const char *notes_ref)
+	const char *notes_ref_in)
 {
 	int error;
 	git_commit *commit = NULL;
-	git_tree *tree = NULL;
+	char *notes_ref;
 
-	error = retrieve_note_tree_and_commit(&tree, &commit, repo, &notes_ref);
+	error = retrieve_note_commit(&commit, &notes_ref, repo, notes_ref_in);
 	if (error < 0)
 		goto cleanup;
 
-	if ((error = git_iterator_for_tree(it, tree, 0, NULL, NULL)) < 0)
-		git_iterator_free(*it);
+	error = git_note_commit_iterator_new(it, commit);
 
 cleanup:
-	git_tree_free(tree);
+	git__free(notes_ref);
 	git_commit_free(commit);
 
 	return error;
@@ -649,7 +806,7 @@ int git_note_next(
 	if ((error = git_iterator_current(&item, it)) < 0)
 		return error;
 
-	git_oid_cpy(note_id, &item->oid);
+	git_oid_cpy(note_id, &item->id);
 
 	if (!(error = process_entry_path(item->path, annotated_id)))
 		git_iterator_advance(NULL, it);