diff options
89 files changed, 2094 insertions, 1360 deletions
diff --git a/.travis.yml b/.travis.yml index caead67b1..29ef9d40d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -2,16 +2,22 @@ # see travis-ci.org for details # As CMake is not officially supported we use erlang VMs -language: erlang +language: c + +compiler: + - gcc + - clang # Settings to try env: - - CC=gcc OPTIONS="-DTHREADSAFE=ON -DCMAKE_BUILD_TYPE=Release" - - CC=clang OPTIONS="-DTHREADSAFE=ON -DCMAKE_BUILD_TYPE=Release" - - CC=gcc OPTIONS="-DBUILD_CLAR=ON -DBUILD_EXAMPLES=ON" - - CC=clang OPTIONS="-DBUILD_CLAR=ON -DBUILD_EXAMPLES=ON" - - CC=i586-mingw32msvc-gcc OPTIONS="-DBUILD_CLAR=OFF -DWIN32=ON -DMINGW=ON" - + - OPTIONS="-DTHREADSAFE=ON -DCMAKE_BUILD_TYPE=Release" + - OPTIONS="-DBUILD_CLAR=ON -DBUILD_EXAMPLES=ON" + +matrix: + include: + - compiler: i586-mingw32msvc-gcc + env: OPTIONS="-DBUILD_CLAR=OFF -DWIN32=ON -DMINGW=ON" + # Make sure CMake is installed install: - sudo apt-get install cmake valgrind @@ -35,6 +41,11 @@ branches: # Notify development list when needed notifications: + irc: + channels: + - irc.freenode.net#libgit2 + on_success: change + on_failure: always recipients: - vicent@github.com email: diff --git a/examples/network/fetch.c b/examples/network/fetch.c index d2752124d..52e0412f4 100644 --- a/examples/network/fetch.c +++ b/examples/network/fetch.c @@ -4,6 +4,7 @@ #include <stdlib.h> #include <string.h> #include <pthread.h> +#include <unistd.h> struct dl_data { git_remote *remote; @@ -39,9 +40,8 @@ exit: pthread_exit(&data->ret); } -int update_cb(const char *refname, const git_oid *a, const git_oid *b) +static int update_cb(const char *refname, const git_oid *a, const git_oid *b, void *data) { - const char *action; char a_str[GIT_OID_HEXSZ+1], b_str[GIT_OID_HEXSZ+1]; git_oid_fmt(b_str, b); @@ -65,7 +65,9 @@ int fetch(git_repository *repo, int argc, char **argv) git_indexer_stats stats; pthread_t worker; struct dl_data data; + git_remote_callbacks callbacks; + argc = argc; // Figure out whether it's a named remote or a URL printf("Fetching %s\n", argv[1]); if (git_remote_load(&remote, repo, argv[1]) < 0) { @@ -73,6 +75,11 @@ int fetch(git_repository *repo, int argc, char **argv) return -1; } + // Set up the callbacks (only update_tips for now) + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.update_tips = &update_cb; + git_remote_set_callbacks(remote, &callbacks); + // Set up the information for the background worker thread data.remote = remote; data.bytes = &bytes; @@ -89,10 +96,14 @@ int fetch(git_repository *repo, int argc, char **argv) // the download rate. do { usleep(10000); - printf("\rReceived %d/%d objects in %d bytes", stats.processed, stats.total, bytes); + printf("\rReceived %d/%d objects in %zu bytes", stats.processed, stats.total, bytes); } while (!data.finished); - printf("\rReceived %d/%d objects in %d bytes\n", stats.processed, stats.total, bytes); + if (data.ret < 0) + goto on_error; + + pthread_join(worker, NULL); + printf("\rReceived %d/%d objects in %zu bytes\n", stats.processed, stats.total, bytes); // Disconnect the underlying connection to prevent from idling. git_remote_disconnect(remote); @@ -101,7 +112,7 @@ int fetch(git_repository *repo, int argc, char **argv) // right commits. This may be needed even if there was no packfile // to download, which can happen e.g. when the branches have been // changed but all the neede objects are available locally. - if (git_remote_update_tips(remote, update_cb) < 0) + if (git_remote_update_tips(remote) < 0) return -1; git_remote_free(remote); diff --git a/examples/network/git2.c b/examples/network/git2.c index 7c02305c4..1bfb13c9e 100644 --- a/examples/network/git2.c +++ b/examples/network/git2.c @@ -1,5 +1,6 @@ #include <stdlib.h> #include <stdio.h> +#include <string.h> #include "common.h" @@ -16,7 +17,7 @@ struct { { NULL, NULL} }; -int run_command(git_cb fn, int argc, char **argv) +static int run_command(git_cb fn, int argc, char **argv) { int error; git_repository *repo; @@ -45,7 +46,7 @@ int run_command(git_cb fn, int argc, char **argv) int main(int argc, char **argv) { - int i, error; + int i; if (argc < 2) { fprintf(stderr, "usage: %s <cmd> [repo]\n", argv[0]); diff --git a/examples/network/index-pack.c b/examples/network/index-pack.c index ef5a35957..85aac4aff 100644 --- a/examples/network/index-pack.c +++ b/examples/network/index-pack.c @@ -2,13 +2,20 @@ #include <stdlib.h> #include <stdio.h> #include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> #include "common.h" // This could be run in the main loop whilst the application waits for // the indexing to finish in a worker thread -int index_cb(const git_indexer_stats *stats, void *data) +static int index_cb(const git_indexer_stats *stats, void *data) { + data = data; printf("\rProcessing %d of %d", stats->processed, stats->total); + + return 0; } int index_pack(git_repository *repo, int argc, char **argv) @@ -20,6 +27,7 @@ int index_pack(git_repository *repo, int argc, char **argv) ssize_t read_bytes; char buf[512]; + repo = repo; if (argc < 2) { fprintf(stderr, "I need a packfile\n"); return EXIT_FAILURE; @@ -43,7 +51,7 @@ int index_pack(git_repository *repo, int argc, char **argv) if ((error = git_indexer_stream_add(idx, buf, read_bytes, &stats)) < 0) goto cleanup; - printf("\rIndexing %d of %d", stats.processed, stats.total); + index_cb(&stats, NULL); } while (read_bytes > 0); if (read_bytes < 0) { @@ -65,38 +73,3 @@ int index_pack(git_repository *repo, int argc, char **argv) git_indexer_stream_free(idx); return error; } - -int index_pack_old(git_repository *repo, int argc, char **argv) -{ - git_indexer *indexer; - git_indexer_stats stats; - int error; - char hash[GIT_OID_HEXSZ + 1] = {0}; - - if (argc < 2) { - fprintf(stderr, "I need a packfile\n"); - return EXIT_FAILURE; - } - - // Create a new indexer - error = git_indexer_new(&indexer, argv[1]); - if (error < 0) - return error; - - // Index the packfile. This function can take a very long time and - // should be run in a worker thread. - error = git_indexer_run(indexer, &stats); - if (error < 0) - return error; - - // Write the information out to an index file - error = git_indexer_write(indexer); - - // Get the packfile's hash (which should become it's filename) - git_oid_fmt(hash, git_indexer_hash(indexer)); - puts(hash); - - git_indexer_free(indexer); - - return 0; -} diff --git a/examples/network/ls-remote.c b/examples/network/ls-remote.c index 39cc64725..822d6f668 100644 --- a/examples/network/ls-remote.c +++ b/examples/network/ls-remote.c @@ -7,12 +7,14 @@ static int show_ref__cb(git_remote_head *head, void *payload) { char oid[GIT_OID_HEXSZ + 1] = {0}; + + payload = payload; git_oid_fmt(oid, &head->oid); printf("%s\t%s\n", oid, head->name); return 0; } -int use_unnamed(git_repository *repo, const char *url) +static int use_unnamed(git_repository *repo, const char *url) { git_remote *remote = NULL; int error; @@ -37,7 +39,7 @@ cleanup: return error; } -int use_remote(git_repository *repo, char *name) +static int use_remote(git_repository *repo, char *name) { git_remote *remote = NULL; int error; @@ -63,8 +65,9 @@ cleanup: int ls_remote(git_repository *repo, int argc, char **argv) { - int error, i; + int error; + argc = argc; /* If there's a ':' in the name, assume it's an URL */ if (strchr(argv[1], ':') != NULL) { error = use_unnamed(repo, argv[1]); diff --git a/include/git2/attr.h b/include/git2/attr.h index 73a625a7e..d675f7555 100644 --- a/include/git2/attr.h +++ b/include/git2/attr.h @@ -30,7 +30,7 @@ GIT_BEGIN_DECL * Then for file `xyz.c` looking up attribute "foo" gives a value for * which `GIT_ATTR_TRUE(value)` is true. */ -#define GIT_ATTR_TRUE(attr) ((attr) == git_l_attr__true) +#define GIT_ATTR_TRUE(attr) (git_attr_value(attr) == GIT_ATTR_TRUE_T) /** * GIT_ATTR_FALSE checks if an attribute is set off. In core git @@ -44,7 +44,7 @@ GIT_BEGIN_DECL * Then for file `zyx.h` looking up attribute "foo" gives a value for * which `GIT_ATTR_FALSE(value)` is true. */ -#define GIT_ATTR_FALSE(attr) ((attr) == git_l_attr__false) +#define GIT_ATTR_FALSE(attr) (git_attr_value(attr) == GIT_ATTR_FALSE_T) /** * GIT_ATTR_UNSPECIFIED checks if an attribute is unspecified. This @@ -62,7 +62,7 @@ GIT_BEGIN_DECL * file `onefile.rb` or looking up "bar" on any file will all give * `GIT_ATTR_UNSPECIFIED(value)` of true. */ -#define GIT_ATTR_UNSPECIFIED(attr) (!(attr) || (attr) == git_l_attr__unset) +#define GIT_ATTR_UNSPECIFIED(attr) (git_attr_value(attr) == GIT_ATTR_UNSPECIFIED_T) /** * GIT_ATTR_HAS_VALUE checks if an attribute is set to a value (as @@ -74,13 +74,29 @@ GIT_BEGIN_DECL * Given this, looking up "eol" for `onefile.txt` will give back the * string "lf" and `GIT_ATTR_SET_TO_VALUE(attr)` will return true. */ -#define GIT_ATTR_HAS_VALUE(attr) \ - ((attr) && (attr) != git_l_attr__unset && \ - (attr) != git_l_attr__true && (attr) != git_attr__false) +#define GIT_ATTR_HAS_VALUE(attr) (git_attr_value(attr) == GIT_ATTR_VALUE_T) -GIT_EXTERN(const char *) git_l_attr__true; -GIT_EXTERN(const char *) git_l_attr__false; -GIT_EXTERN(const char *) git_l_attr__unset; +typedef enum { + GIT_ATTR_UNSPECIFIED_T = 0, + GIT_ATTR_TRUE_T, + GIT_ATTR_FALSE_T, + GIT_ATTR_VALUE_T, +} git_attr_t; + +/* + * Return the value type for a given attribute. + * + * This can be either `TRUE`, `FALSE`, `UNSPECIFIED` (if the attribute + * was not set at all), or `VALUE`, if the attribute was set to + * an actual string. + * + * If the attribute has a `VALUE` string, it can be accessed normally + * as a NULL-terminated C string. + * + * @param attr The attribute + * @return the value type for the attribute + */ +git_attr_t git_attr_value(const char *attr); /** * Check attribute flags: Reading values from index and working directory. diff --git a/include/git2/blob.h b/include/git2/blob.h index 544dc7c41..f0719f15d 100644 --- a/include/git2/blob.h +++ b/include/git2/blob.h @@ -46,7 +46,7 @@ GIT_INLINE(int) git_blob_lookup(git_blob **blob, git_repository *repo, const git * @param len the length of the short identifier * @return 0 or an error code */ -GIT_INLINE(int) git_blob_lookup_prefix(git_blob **blob, git_repository *repo, const git_oid *id, unsigned int len) +GIT_INLINE(int) git_blob_lookup_prefix(git_blob **blob, git_repository *repo, const git_oid *id, size_t len) { return git_object_lookup_prefix((git_object **)blob, repo, id, len, GIT_OBJ_BLOB); } diff --git a/include/git2/branch.h b/include/git2/branch.h index c8f2d8f5f..8bf7eb9d4 100644 --- a/include/git2/branch.h +++ b/include/git2/branch.h @@ -26,9 +26,9 @@ GIT_BEGIN_DECL * this target commit. If `force` is true and a reference * already exists with the given name, it'll be replaced. * - * @param oid_out Pointer where to store the OID of the target commit. + * The returned reference must be freed by the user. * - * @param repo Repository where to store the branch. + * @param branch_out Pointer where to store the underlying reference. * * @param branch_name Name for the branch; this name is * validated for consistency. It should also not conflict with @@ -46,7 +46,7 @@ GIT_BEGIN_DECL * pointing to the provided target commit. */ GIT_EXTERN(int) git_branch_create( - git_oid *oid_out, + git_reference **branch_out, git_repository *repo, const char *branch_name, const git_object *target, @@ -99,27 +99,62 @@ GIT_EXTERN(int) git_branch_foreach( ); /** - * Move/rename an existing branch reference. + * Move/rename an existing local branch reference. * - * @param repo Repository where lives the branch. - * - * @param old_branch_name Current name of the branch to be moved; - * this name is validated for consistency. + * @param branch Current underlying reference of the branch. * * @param new_branch_name Target name of the branch once the move * is performed; this name is validated for consistency. * * @param force Overwrite existing branch. * - * @return 0 on success, GIT_ENOTFOUND if the branch - * doesn't exist or an error code. + * @return 0 on success, or an error code. */ GIT_EXTERN(int) git_branch_move( - git_repository *repo, - const char *old_branch_name, + git_reference *branch, const char *new_branch_name, int force); +/** + * Lookup a branch by its name in a repository. + * + * The generated reference must be freed by the user. + * + * @param branch_out pointer to the looked-up branch reference + * + * @param repo the repository to look up the branch + * + * @param branch_name Name of the branch to be looked-up; + * this name is validated for consistency. + * + * @param branch_type Type of the considered branch. This should + * be valued with either GIT_BRANCH_LOCAL or GIT_BRANCH_REMOTE. + * + * @return 0 on success; GIT_ENOTFOUND when no matching branch + * exists, otherwise an error code. + */ +GIT_EXTERN(int) git_branch_lookup( + git_reference **branch_out, + git_repository *repo, + const char *branch_name, + git_branch_t branch_type); + +/** + * Return the reference supporting the remote tracking branch, + * given a local branch reference. + * + * @param tracking_out Pointer where to store the retrieved + * reference. + * + * @param branch Current underlying reference of the branch. + * + * @return 0 on success; GIT_ENOTFOUND when no remote tracking + * reference exists, otherwise an error code. + */ +GIT_EXTERN(int) git_branch_tracking( + git_reference **tracking_out, + git_reference *branch); + /** @} */ GIT_END_DECL #endif diff --git a/include/git2/commit.h b/include/git2/commit.h index e8ecc808b..a159b79e1 100644 --- a/include/git2/commit.h +++ b/include/git2/commit.h @@ -48,7 +48,7 @@ GIT_INLINE(int) git_commit_lookup(git_commit **commit, git_repository *repo, con * @param len the length of the short identifier * @return 0 or an error code */ -GIT_INLINE(int) git_commit_lookup_prefix(git_commit **commit, git_repository *repo, const git_oid *id, unsigned len) +GIT_INLINE(int) git_commit_lookup_prefix(git_commit **commit, git_repository *repo, const git_oid *id, size_t len) { return git_object_lookup_prefix((git_object **)commit, repo, id, len, GIT_OBJ_COMMIT); } diff --git a/include/git2/common.h b/include/git2/common.h index 1af045cff..0af37e81f 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -103,6 +103,29 @@ GIT_EXTERN(int) git_strarray_copy(git_strarray *tgt, const git_strarray *src); */ GIT_EXTERN(void) git_libgit2_version(int *major, int *minor, int *rev); +/** + * Combinations of these values describe the capabilities of libgit2. + */ +enum { + GIT_CAP_THREADS = ( 1 << 0 ), + GIT_CAP_HTTPS = ( 1 << 1 ) +}; + +/** + * Query compile time options for libgit2. + * + * @return A combination of GIT_CAP_* values. + * + * - GIT_CAP_THREADS + * Libgit2 was compiled with thread support. Note that thread support is still to be seen as a + * 'work in progress'. + * + * - GIT_CAP_HTTPS + * Libgit2 supports the https:// protocol. This requires the open ssl library to be + * found when compiling libgit2. + */ +GIT_EXTERN(int) git_libgit2_capabilities(void); + /** @} */ GIT_END_DECL #endif diff --git a/include/git2/index.h b/include/git2/index.h index f863a6065..0093330e2 100644 --- a/include/git2/index.h +++ b/include/git2/index.h @@ -279,7 +279,7 @@ GIT_EXTERN(int) git_index_remove(git_index *index, int position); * @param n the position of the entry * @return a pointer to the entry; NULL if out of bounds */ -GIT_EXTERN(git_index_entry *) git_index_get(git_index *index, unsigned int n); +GIT_EXTERN(git_index_entry *) git_index_get(git_index *index, size_t n); /** * Get the count of entries currently in the index @@ -319,7 +319,7 @@ GIT_EXTERN(const git_index_entry_unmerged *) git_index_get_unmerged_bypath(git_i * @param n the position of the entry * @return a pointer to the unmerged entry; NULL if out of bounds */ -GIT_EXTERN(const git_index_entry_unmerged *) git_index_get_unmerged_byindex(git_index *index, unsigned int n); +GIT_EXTERN(const git_index_entry_unmerged *) git_index_get_unmerged_byindex(git_index *index, size_t n); /** * Return the stage number from a git index entry diff --git a/include/git2/object.h b/include/git2/object.h index d9e653fd4..722434dec 100644 --- a/include/git2/object.h +++ b/include/git2/object.h @@ -75,7 +75,7 @@ GIT_EXTERN(int) git_object_lookup_prefix( git_object **object_out, git_repository *repo, const git_oid *id, - unsigned int len, + size_t len, git_otype type); /** diff --git a/include/git2/odb.h b/include/git2/odb.h index 1f25db463..1919f61a0 100644 --- a/include/git2/odb.h +++ b/include/git2/odb.h @@ -139,7 +139,7 @@ GIT_EXTERN(int) git_odb_read(git_odb_object **out, git_odb *db, const git_oid *i * GIT_ENOTFOUND if the object is not in the database. * GIT_EAMBIGUOUS if the prefix is ambiguous (several objects match the prefix) */ -GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len); +GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_id, size_t len); /** * Read the header of an object from the database, without diff --git a/include/git2/odb_backend.h b/include/git2/odb_backend.h index 3f67202d1..b812fef1e 100644 --- a/include/git2/odb_backend.h +++ b/include/git2/odb_backend.h @@ -42,7 +42,7 @@ struct git_odb_backend { void **, size_t *, git_otype *, struct git_odb_backend *, const git_oid *, - unsigned int); + size_t); int (* read_header)( size_t *, git_otype *, @@ -100,6 +100,7 @@ struct git_odb_stream { GIT_EXTERN(int) git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir); GIT_EXTERN(int) git_odb_backend_loose(git_odb_backend **backend_out, const char *objects_dir, int compression_level, int do_fsync); +GIT_EXTERN(int) git_odb_backend_one_pack(git_odb_backend **backend_out, const char *index_file); GIT_END_DECL diff --git a/include/git2/oid.h b/include/git2/oid.h index a05b40a37..887b33e50 100644 --- a/include/git2/oid.h +++ b/include/git2/oid.h @@ -136,7 +136,31 @@ GIT_EXTERN(void) git_oid_cpy(git_oid *out, const git_oid *src); * @param b second oid structure. * @return <0, 0, >0 if a < b, a == b, a > b. */ -GIT_EXTERN(int) git_oid_cmp(const git_oid *a, const git_oid *b); +GIT_INLINE(int) git_oid_cmp(const git_oid *a, const git_oid *b) +{ + const unsigned char *sha1 = a->id; + const unsigned char *sha2 = b->id; + int i; + + for (i = 0; i < GIT_OID_RAWSZ; i++, sha1++, sha2++) { + if (*sha1 != *sha2) + return *sha1 - *sha2; + } + + return 0; +} + +/** + * Compare two oid structures for equality + * + * @param a first oid structure. + * @param b second oid structure. + * @return true if equal, false otherwise + */ +GIT_INLINE(int) git_oid_equal(const git_oid *a, const git_oid *b) +{ + return !git_oid_cmp(a, b); +} /** * Compare the first 'len' hexadecimal characters (packets of 4 bits) @@ -147,7 +171,7 @@ GIT_EXTERN(int) git_oid_cmp(const git_oid *a, const git_oid *b); * @param len the number of hex chars to compare * @return 0 in case of a match */ -GIT_EXTERN(int) git_oid_ncmp(const git_oid *a, const git_oid *b, unsigned int len); +GIT_EXTERN(int) git_oid_ncmp(const git_oid *a, const git_oid *b, size_t len); /** * Check if an oid equals an hex formatted object id. diff --git a/include/git2/reflog.h b/include/git2/reflog.h index 8acba349b..447915ef8 100644 --- a/include/git2/reflog.h +++ b/include/git2/reflog.h @@ -23,6 +23,10 @@ GIT_BEGIN_DECL /** * Read the reflog for the given reference * + * If there is no reflog file for the given + * reference yet, an empty reflog object will + * be returned. + * * The reflog must be freed manually by using * git_reflog_free(). * @@ -33,22 +37,26 @@ GIT_BEGIN_DECL GIT_EXTERN(int) git_reflog_read(git_reflog **reflog, git_reference *ref); /** - * Write a new reflog for the given reference - * - * If there is no reflog file for the given - * reference yet, it will be created. + * Write an existing in-memory reflog object back to disk + * using an atomic file lock. * - * `oid_old` may be NULL in case it's a new reference. + * @param reflog an existing reflog object + * @return 0 or an error code + */ +GIT_EXTERN(int) git_reflog_write(git_reflog *reflog); + +/** + * Add a new entry to the reflog. * * `msg` is optional and can be NULL. * - * @param ref the changed reference - * @param oid_old the OID the reference was pointing to + * @param reflog an existing reflog object + * @param new_oid the OID the reference is now pointing to * @param committer the signature of the committer * @param msg the reflog message * @return 0 or an error code */ -GIT_EXTERN(int) git_reflog_write(git_reference *ref, const git_oid *oid_old, const git_signature *committer, const char *msg); +GIT_EXTERN(int) git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg); /** * Rename the reflog for the given reference @@ -84,7 +92,27 @@ GIT_EXTERN(unsigned int) git_reflog_entrycount(git_reflog *reflog); * @param idx the position to lookup * @return the entry; NULL if not found */ -GIT_EXTERN(const git_reflog_entry *) git_reflog_entry_byindex(git_reflog *reflog, unsigned int idx); +GIT_EXTERN(const git_reflog_entry *) git_reflog_entry_byindex(git_reflog *reflog, size_t idx); + +/** + * Remove an entry from the reflog by its index + * + * To ensure there's no gap in the log history, set the `rewrite_previosu_entry` to 1. + * When deleting entry `n`, member old_oid of entry `n-1` (if any) will be updated with + * the value of memeber new_oid of entry `n+1`. + * + * @param reflog a previously loaded reflog. + * + * @param idx the position of the entry to remove. + * + * @param rewrite_previous_entry 1 to rewrite the history; 0 otherwise. + * + * @return 0 on success or an error code. + */ +GIT_EXTERN(int) git_reflog_drop( + git_reflog *reflog, + unsigned int idx, + int rewrite_previous_entry); /** * Get the old oid diff --git a/include/git2/refs.h b/include/git2/refs.h index dbd9b7151..d92390061 100644 --- a/include/git2/refs.h +++ b/include/git2/refs.h @@ -364,26 +364,15 @@ GIT_EXTERN(int) git_reference_foreach_glob( */ GIT_EXTERN(int) git_reference_has_log(git_reference *ref); - /** - * Return the reference supporting the remote tracking branch, - * given a reference branch. - * - * The input reference has to be located in the `refs/heads` - * namespace. - * - * @param tracking_ref Pointer where to store the retrieved - * reference. + * Check if a reference is a local branch. * - * @param branch_ref A git local branch reference. + * @param ref A git reference * - * @return 0 on success; GIT_ENOTFOUND when no remote tracking - * reference exists, otherwise an error code. + * @return 1 when the reference lives in the refs/heads + * namespace; 0 otherwise. */ -GIT_EXTERN(int) git_reference_remote_tracking_from_branch( - git_reference **tracking_ref, - git_reference *branch_ref -); +GIT_EXTERN(int) git_reference_is_branch(git_reference *ref); /** @} */ GIT_END_DECL diff --git a/include/git2/remote.h b/include/git2/remote.h index 02b93e099..96f460e98 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -80,6 +80,36 @@ GIT_EXTERN(const char *) git_remote_name(git_remote *remote); GIT_EXTERN(const char *) git_remote_url(git_remote *remote); /** + * Get the remote's url for pushing + * + * @param remote the remote + * @return a pointer to the url or NULL if no special url for pushing is set + */ +GIT_EXTERN(const char *) git_remote_pushurl(git_remote *remote); + +/** + * Set the remote's url + * + * Existing connections will not be updated. + * + * @param remote the remote + * @param url the url to set + * @return 0 or an error value + */ +GIT_EXTERN(int) git_remote_set_url(git_remote *remote, const char* url); + +/** + * Set the remote's url for pushing + * + * Existing connections will not be updated. + * + * @param remote the remote + * @param url the url to set or NULL to clear the pushurl + * @return 0 or an error value + */ +GIT_EXTERN(int) git_remote_set_pushurl(git_remote *remote, const char* url); + +/** * Set the remote's fetch refspec * * @param remote the remote @@ -193,7 +223,7 @@ GIT_EXTERN(void) git_remote_free(git_remote *remote); * @param remote the remote to update * @param cb callback to run on each ref update. 'a' is the old value, 'b' is then new value */ -GIT_EXTERN(int) git_remote_update_tips(git_remote *remote, int (*cb)(const char *refname, const git_oid *a, const git_oid *b)); +GIT_EXTERN(int) git_remote_update_tips(git_remote *remote); /** * Return whether a string is a valid remote URL @@ -241,6 +271,39 @@ GIT_EXTERN(int) git_remote_add(git_remote **out, git_repository *repo, const cha GIT_EXTERN(void) git_remote_check_cert(git_remote *remote, int check); +/** + * Argument to the completion callback which tells it which operation + * finished. + */ +typedef enum git_remote_completion_type { + GIT_REMOTE_COMPLETION_DOWNLOAD, + GIT_REMOTE_COMPLETION_INDEXING, + GIT_REMOTE_COMPLETION_ERROR, +} git_remote_completion_type; + +/** + * The callback settings structure + * + * Set the calbacks to be called by the remote. + */ +struct git_remote_callbacks { + int (*progress)(const char *str, void *data); + int (*completion)(git_remote_completion_type type, void *data); + int (*update_tips)(const char *refname, const git_oid *a, const git_oid *b, void *data); + void *data; +}; + +/** + * Set the callbacks for a remote + * + * Note that the remote keeps its own copy of the data and you need to + * call this function again if you want to change the callbacks. + * + * @param remote the remote to configure + * @param callbacks a pointer to the user's callback settings + */ +GIT_EXTERN(void) git_remote_set_callbacks(git_remote *remote, git_remote_callbacks *callbacks); + /** @} */ GIT_END_DECL #endif diff --git a/include/git2/repository.h b/include/git2/repository.h index ff81b75ec..e727ff317 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -36,6 +36,19 @@ GIT_BEGIN_DECL GIT_EXTERN(int) git_repository_open(git_repository **repository, const char *path); /** + * Create a "fake" repository to wrap an object database + * + * Create a repository object to wrap an object database to be used + * with the API when all you have is an object database. This doesn't + * have any paths associated with it, so use with care. + * + * @param repository pointer to the repo + * @param odb the object database to wrap + * @return 0 or an error code + */ +GIT_EXTERN(int) git_repository_wrap_odb(git_repository **repository, git_odb *odb); + +/** * Look for a git repository and copy its path in the given buffer. * The lookup start from base_path and walk across parent directories * if nothing has been found. The lookup ends when the first repository @@ -302,6 +315,28 @@ GIT_EXTERN(int) git_repository_index(git_index **out, git_repository *repo); */ GIT_EXTERN(void) git_repository_set_index(git_repository *repo, git_index *index); +/** + * Retrive git's prepared message + * + * Operations such as git revert/cherry-pick/merge with the -n option + * stop just short of creating a commit with the changes and save + * their prepared message in .git/MERGE_MSG so the next git-commit + * execution can present it to the user for them to amend if they + * wish. + * + * Use this function to get the contents of this file. Don't forget to + * remove the file after you create the commit. + */ +GIT_EXTERN(int) git_repository_message(char *buffer, size_t len, git_repository *repo); + +/** + * Remove git's prepared message. + * + * Remove the message that `git_repository_message` retrieves. + */ +GIT_EXTERN(int) git_repository_message_remove(git_repository *repo); + + /** @} */ GIT_END_DECL #endif diff --git a/include/git2/tag.h b/include/git2/tag.h index b522451a1..aab4b77a8 100644 --- a/include/git2/tag.h +++ b/include/git2/tag.h @@ -46,7 +46,7 @@ GIT_INLINE(int) git_tag_lookup(git_tag **tag, git_repository *repo, const git_oi * @param len the length of the short identifier * @return 0 or an error code */ -GIT_INLINE(int) git_tag_lookup_prefix(git_tag **tag, git_repository *repo, const git_oid *id, unsigned int len) +GIT_INLINE(int) git_tag_lookup_prefix(git_tag **tag, git_repository *repo, const git_oid *id, size_t len) { return git_object_lookup_prefix((git_object **)tag, repo, id, len, (git_otype)GIT_OBJ_TAG); } diff --git a/include/git2/tree.h b/include/git2/tree.h index 5c42f3957..b91340624 100644 --- a/include/git2/tree.h +++ b/include/git2/tree.h @@ -50,7 +50,7 @@ GIT_INLINE(int) git_tree_lookup_prefix( git_tree **tree, git_repository *repo, const git_oid *id, - unsigned int len) + size_t len) { return git_object_lookup_prefix((git_object **)tree, repo, id, len, GIT_OBJ_TREE); } @@ -126,7 +126,7 @@ GIT_EXTERN(const git_tree_entry *) git_tree_entry_byname(git_tree *tree, const c * @param idx the position in the entry list * @return the tree entry; NULL if not found */ -GIT_EXTERN(const git_tree_entry *) git_tree_entry_byindex(git_tree *tree, unsigned int idx); +GIT_EXTERN(const git_tree_entry *) git_tree_entry_byindex(git_tree *tree, size_t idx); /** * Lookup a tree entry by SHA value. diff --git a/include/git2/types.h b/include/git2/types.h index 691903005..acd5a73bc 100644 --- a/include/git2/types.h +++ b/include/git2/types.h @@ -179,6 +179,7 @@ typedef struct git_refspec git_refspec; typedef struct git_remote git_remote; typedef struct git_remote_head git_remote_head; +typedef struct git_remote_callbacks git_remote_callbacks; /** @} */ GIT_END_DECL diff --git a/src/attr.c b/src/attr.c index c58a1f045..a6a87afee 100644 --- a/src/attr.c +++ b/src/attr.c @@ -5,6 +5,25 @@ GIT__USE_STRMAP; +const char *git_attr__true = "[internal]__TRUE__"; +const char *git_attr__false = "[internal]__FALSE__"; +const char *git_attr__unset = "[internal]__UNSET__"; + +git_attr_t git_attr_value(const char *attr) +{ + if (attr == NULL || attr == git_attr__unset) + return GIT_ATTR_UNSPECIFIED_T; + + if (attr == git_attr__true) + return GIT_ATTR_TRUE_T; + + if (attr == git_attr__false) + return GIT_ATTR_FALSE_T; + + return GIT_ATTR_VALUE_T; +} + + static int collect_attr_files( git_repository *repo, uint32_t flags, @@ -22,7 +41,7 @@ int git_attr_get( int error; git_attr_path path; git_vector files = GIT_VECTOR_INIT; - unsigned int i, j; + size_t i, j; git_attr_file *file; git_attr_name attr; git_attr_rule *rule; @@ -74,7 +93,7 @@ int git_attr_get_many( int error; git_attr_path path; git_vector files = GIT_VECTOR_INIT; - unsigned int i, j, k; + size_t i, j, k; git_attr_file *file; git_attr_rule *rule; attr_get_many_info *info = NULL; @@ -138,7 +157,7 @@ int git_attr_foreach( int error; git_attr_path path; git_vector files = GIT_VECTOR_INIT; - unsigned int i, j, k; + size_t i, j, k; git_attr_file *file; git_attr_rule *rule; git_attr_assignment *assign; diff --git a/src/attr_file.c b/src/attr_file.c index 837c42d8e..20b3cf631 100644 --- a/src/attr_file.c +++ b/src/attr_file.c @@ -5,10 +5,6 @@ #include "git2/tree.h" #include <ctype.h> -const char *git_l_attr__true = "[internal]__TRUE__"; -const char *git_l_attr__false = "[internal]__FALSE__"; -const char *git_l_attr__unset = "[internal]__UNSET__"; - static int sort_by_hash_and_name(const void *a_raw, const void *b_raw); static void git_attr_rule__clear(git_attr_rule *rule); @@ -183,7 +179,7 @@ int git_attr_file__lookup_one( const char *attr, const char **value) { - unsigned int i; + size_t i; git_attr_name name; git_attr_rule *rule; @@ -493,14 +489,14 @@ int git_attr_assignment__parse( } assign->name_hash = 5381; - assign->value = git_l_attr__true; + assign->value = git_attr__true; /* look for magic name prefixes */ if (*scan == '-') { - assign->value = git_l_attr__false; + assign->value = git_attr__false; scan++; } else if (*scan == '!') { - assign->value = git_l_attr__unset; /* explicit unspecified state */ + assign->value = git_attr__unset; /* explicit unspecified state */ scan++; } else if (*scan == '#') /* comment rest of line */ break; @@ -536,7 +532,7 @@ int git_attr_assignment__parse( } /* expand macros (if given a repo with a macro cache) */ - if (repo != NULL && assign->value == git_l_attr__true) { + if (repo != NULL && assign->value == git_attr__true) { git_attr_rule *macro = git_attr_cache__lookup_macro(repo, assign->name); diff --git a/src/attr_file.h b/src/attr_file.h index 7939f838a..9d6730d90 100644 --- a/src/attr_file.h +++ b/src/attr_file.h @@ -24,6 +24,10 @@ #define GIT_ATTR_FNMATCH_HASWILD (1U << 5) #define GIT_ATTR_FNMATCH_ALLOWSPACE (1U << 6) +extern const char *git_attr__true; +extern const char *git_attr__false; +extern const char *git_attr__unset; + typedef struct { char *pattern; size_t length; diff --git a/src/branch.c b/src/branch.c index 671e42051..52fed67ad 100644 --- a/src/branch.c +++ b/src/branch.c @@ -7,8 +7,11 @@ #include "common.h" #include "commit.h" -#include "branch.h" #include "tag.h" +#include "config.h" +#include "refspec.h" + +#include "git2/branch.h" static int retrieve_branch_reference( git_reference **branch_reference_out, @@ -48,8 +51,8 @@ static int create_error_invalid(const char *msg) } int git_branch_create( - git_oid *oid_out, - git_repository *repo, + git_reference **ref_out, + git_repository *repository, const char *branch_name, const git_object *target, int force) @@ -60,10 +63,8 @@ int git_branch_create( git_buf canonical_branch_name = GIT_BUF_INIT; int error = -1; - assert(repo && branch_name && target && oid_out); - - if (git_object_owner(target) != repo) - return create_error_invalid("The given target does not belong to this repository"); + assert(branch_name && target && ref_out); + assert(git_object_owner(target) == repository); target_type = git_object_type(target); @@ -90,17 +91,17 @@ int git_branch_create( if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0) goto cleanup; - if (git_reference_create_oid(&branch, repo, git_buf_cstr(&canonical_branch_name), git_object_id(commit), force) < 0) + if (git_reference_create_oid(&branch, repository, + git_buf_cstr(&canonical_branch_name), git_object_id(commit), force) < 0) goto cleanup; - git_oid_cpy(oid_out, git_reference_oid(branch)); + *ref_out = branch; error = 0; cleanup: if (target_type == GIT_OBJ_TAG) git_object_free(commit); - git_reference_free(branch); git_buf_free(&canonical_branch_name); return error; } @@ -111,6 +112,7 @@ int git_branch_delete(git_repository *repo, const char *branch_name, git_branch_ git_reference *head = NULL; int error; + assert(repo && branch_name); assert((branch_type == GIT_BRANCH_LOCAL) || (branch_type == GIT_BRANCH_REMOTE)); if ((error = retrieve_branch_reference(&branch, repo, branch_name, branch_type == GIT_BRANCH_REMOTE)) < 0) @@ -183,28 +185,110 @@ int git_branch_foreach( return git_reference_foreach(repo, GIT_REF_LISTALL, &branch_foreach_cb, (void *)&filter); } -int git_branch_move(git_repository *repo, const char *old_branch_name, const char *new_branch_name, int force) +static int not_a_local_branch(git_reference *ref) +{ + giterr_set(GITERR_INVALID, "Reference '%s' is not a local branch.", git_reference_name(ref)); + return -1; +} + +int git_branch_move( + git_reference *branch, + const char *new_branch_name, + int force) { - git_reference *reference = NULL; - git_buf old_reference_name = GIT_BUF_INIT, new_reference_name = GIT_BUF_INIT; - int error = 0; + git_buf new_reference_name = GIT_BUF_INIT; + int error; - if ((error = git_buf_joinpath(&old_reference_name, GIT_REFS_HEADS_DIR, old_branch_name)) < 0) - goto cleanup; + assert(branch && new_branch_name); - /* We need to be able to return GIT_ENOTFOUND */ - if ((error = git_reference_lookup(&reference, repo, git_buf_cstr(&old_reference_name))) < 0) - goto cleanup; + if (!git_reference_is_branch(branch)) + return not_a_local_branch(branch); if ((error = git_buf_joinpath(&new_reference_name, GIT_REFS_HEADS_DIR, new_branch_name)) < 0) goto cleanup; - error = git_reference_rename(reference, git_buf_cstr(&new_reference_name), force); + error = git_reference_rename(branch, git_buf_cstr(&new_reference_name), force); cleanup: - git_reference_free(reference); - git_buf_free(&old_reference_name); git_buf_free(&new_reference_name); return error; } + +int git_branch_lookup( + git_reference **ref_out, + git_repository *repo, + const char *branch_name, + git_branch_t branch_type) +{ + assert(ref_out && repo && branch_name); + + return retrieve_branch_reference(ref_out, repo, branch_name, branch_type == GIT_BRANCH_REMOTE); +} + +static int retrieve_tracking_configuration( + const char **out, git_reference *branch, const char *format) +{ + git_config *config; + git_buf buf = GIT_BUF_INIT; + int error; + + if (git_repository_config__weakptr(&config, git_reference_owner(branch)) < 0) + return -1; + + if (git_buf_printf(&buf, format, + git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)) < 0) + return -1; + + error = git_config_get_string(out, config, git_buf_cstr(&buf)); + git_buf_free(&buf); + return error; +} + +int git_branch_tracking( + git_reference **tracking_out, + git_reference *branch) +{ + const char *remote_name, *merge_name; + git_buf buf = GIT_BUF_INIT; + int error = -1; + git_remote *remote = NULL; + const git_refspec *refspec; + + assert(tracking_out && branch); + + if (!git_reference_is_branch(branch)) + return not_a_local_branch(branch); + + if ((error = retrieve_tracking_configuration(&remote_name, branch, "branch.%s.remote")) < 0) + goto cleanup; + + if ((error = retrieve_tracking_configuration(&merge_name, branch, "branch.%s.merge")) < 0) + goto cleanup; + + if (strcmp(".", remote_name) != 0) { + if ((error = git_remote_load(&remote, git_reference_owner(branch), remote_name)) < 0) + goto cleanup; + + refspec = git_remote_fetchspec(remote); + if (refspec == NULL) { + error = GIT_ENOTFOUND; + goto cleanup; + } + + if (git_refspec_transform_r(&buf, refspec, merge_name) < 0) + goto cleanup; + } else + if (git_buf_sets(&buf, merge_name) < 0) + goto cleanup; + + error = git_reference_lookup( + tracking_out, + git_reference_owner(branch), + git_buf_cstr(&buf)); + +cleanup: + git_remote_free(remote); + git_buf_free(&buf); + return error; +} diff --git a/src/branch.h b/src/branch.h deleted file mode 100644 index d0e5abc8b..000000000 --- a/src/branch.h +++ /dev/null @@ -1,17 +0,0 @@ -/* - * Copyright (C) 2009-2012 the libgit2 contributors - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ -#ifndef INCLUDE_branch_h__ -#define INCLUDE_branch_h__ - -#include "git2/branch.h" - -struct git_branch { - char *remote; /* TODO: Make this a git_remote */ - char *merge; -}; - -#endif diff --git a/src/commit.c b/src/commit.c index 32c47944b..b66978aff 100644 --- a/src/commit.c +++ b/src/commit.c @@ -226,7 +226,7 @@ GIT_COMMIT_GETTER(const char *, message, commit->message) GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding) GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time) GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset) -GIT_COMMIT_GETTER(unsigned int, parentcount, commit->parent_oids.length) +GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)commit->parent_oids.length) GIT_COMMIT_GETTER(const git_oid *, tree_oid, &commit->tree_oid); int git_commit_tree(git_tree **tree_out, git_commit *commit) diff --git a/src/common.h b/src/common.h index 1db308fc7..1d85428b3 100644 --- a/src/common.h +++ b/src/common.h @@ -59,4 +59,7 @@ void giterr_set_regex(const regex_t *regex, int error_code); #include "util.h" +typedef struct git_transport git_transport; +typedef struct gitno_buffer gitno_buffer; + #endif /* INCLUDE_common_h__ */ diff --git a/src/config.c b/src/config.c index 98fb3b20d..44cfe760c 100644 --- a/src/config.c +++ b/src/config.c @@ -410,7 +410,7 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex file_internal *internal; git_config_file *file; int ret = GIT_ENOTFOUND; - unsigned int i; + size_t i; assert(cfg->files.length); @@ -434,7 +434,7 @@ int git_config_set_multivar(git_config *cfg, const char *name, const char *regex file_internal *internal; git_config_file *file; int ret = GIT_ENOTFOUND; - unsigned int i; + size_t i; for (i = cfg->files.length; i > 0; --i) { internal = git_vector_get(&cfg->files, i - 1); diff --git a/src/date.c b/src/date.c index f0e637a45..965e6caab 100644 --- a/src/date.c +++ b/src/date.c @@ -121,9 +121,9 @@ static const struct { { "IDLE", +12, 0, }, /* International Date Line East */ }; -static int match_string(const char *date, const char *str) +static size_t match_string(const char *date, const char *str) { - int i = 0; + size_t i = 0; for (i = 0; *date; date++, str++, i++) { if (*date == *str) @@ -149,12 +149,12 @@ static int skip_alpha(const char *date) /* * Parse month, weekday, or timezone name */ -static int match_alpha(const char *date, struct tm *tm, int *offset) +static size_t match_alpha(const char *date, struct tm *tm, int *offset) { unsigned int i; for (i = 0; i < 12; i++) { - int match = match_string(date, month_names[i]); + size_t match = match_string(date, month_names[i]); if (match >= 3) { tm->tm_mon = i; return match; @@ -162,7 +162,7 @@ static int match_alpha(const char *date, struct tm *tm, int *offset) } for (i = 0; i < 7; i++) { - int match = match_string(date, weekday_names[i]); + size_t match = match_string(date, weekday_names[i]); if (match >= 3) { tm->tm_wday = i; return match; @@ -170,8 +170,8 @@ static int match_alpha(const char *date, struct tm *tm, int *offset) } for (i = 0; i < ARRAY_SIZE(timezone_names); i++) { - int match = match_string(date, timezone_names[i].name); - if (match >= 3 || match == (int)strlen(timezone_names[i].name)) { + size_t match = match_string(date, timezone_names[i].name); + if (match >= 3 || match == strlen(timezone_names[i].name)) { int off = timezone_names[i].offset; /* This is bogus, but we like summer */ @@ -241,7 +241,7 @@ static int is_date(int year, int month, int day, struct tm *now_tm, time_t now, return 0; } -static int match_multi_number(unsigned long num, char c, const char *date, char *end, struct tm *tm) +static size_t match_multi_number(unsigned long num, char c, const char *date, char *end, struct tm *tm) { time_t now; struct tm now_tm; @@ -319,9 +319,9 @@ static int nodate(struct tm *tm) /* * We've seen a digit. Time? Year? Date? */ -static int match_digit(const char *date, struct tm *tm, int *offset, int *tm_gmt) +static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_gmt) { - int n; + size_t n; char *end; unsigned long num; @@ -349,7 +349,7 @@ static int match_digit(const char *date, struct tm *tm, int *offset, int *tm_gmt case '/': case '-': if (isdigit(end[1])) { - int match = match_multi_number(num, *end, date, end, tm); + size_t match = match_multi_number(num, *end, date, end, tm); if (match) return match; } @@ -413,11 +413,11 @@ static int match_digit(const char *date, struct tm *tm, int *offset, int *tm_gmt return n; } -static int match_tz(const char *date, int *offp) +static size_t match_tz(const char *date, int *offp) { char *end; int hour = strtoul(date + 1, &end, 10); - int n = end - (date + 1); + size_t n = end - (date + 1); int min = 0; if (n == 4) { @@ -506,7 +506,7 @@ static int parse_date_basic(const char *date, git_time_t *timestamp, int *offset !match_object_header_date(date + 1, timestamp, offset)) return 0; /* success */ for (;;) { - int match = 0; + size_t match = 0; unsigned char c = *date; /* Stop at end of string or newline */ @@ -685,7 +685,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm ; for (i = 0; i < 12; i++) { - int match = match_string(date, month_names[i]); + size_t match = match_string(date, month_names[i]); if (match >= 3) { tm->tm_mon = i; *touched = 1; @@ -694,7 +694,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm } for (s = special; s->name; s++) { - int len = strlen(s->name); + size_t len = strlen(s->name); if (match_string(date, s->name) == len) { s->fn(tm, now, num); *touched = 1; @@ -704,7 +704,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm if (!*num) { for (i = 1; i < 11; i++) { - int len = strlen(number_name[i]); + size_t len = strlen(number_name[i]); if (match_string(date, number_name[i]) == len) { *num = i; *touched = 1; @@ -720,7 +720,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm tl = typelen; while (tl->type) { - int len = strlen(tl->type); + size_t len = strlen(tl->type); if (match_string(date, tl->type) >= len-1) { update_tm(tm, now, tl->length * *num); *num = 0; @@ -731,7 +731,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm } for (i = 0; i < 7; i++) { - int match = match_string(date, weekday_names[i]); + size_t match = match_string(date, weekday_names[i]); if (match >= 3) { int diff, n = *num -1; *num = 0; @@ -783,7 +783,7 @@ static const char *approxidate_digit(const char *date, struct tm *tm, int *num) case '/': case '-': if (isdigit(end[1])) { - int match = match_multi_number(number, *end, date, end, tm); + size_t match = match_multi_number(number, *end, date, end, tm); if (match) return date + match; } diff --git a/src/fetch.c b/src/fetch.c index 603284842..d96ac7781 100644 --- a/src/fetch.c +++ b/src/fetch.c @@ -5,7 +5,6 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "git2/remote.h" #include "git2/oid.h" #include "git2/refs.h" #include "git2/revwalk.h" @@ -18,6 +17,7 @@ #include "pack.h" #include "fetch.h" #include "netops.h" +#include "pkt.h" struct filter_payload { git_remote *remote; @@ -70,7 +70,62 @@ static int filter_wants(git_remote *remote) if (git_repository_odb__weakptr(&p.odb, remote->repo) < 0) return -1; - return remote->transport->ls(remote->transport, &filter_ref__cb, &p); + return git_remote_ls(remote, filter_ref__cb, &p); +} + +/* Wait until we get an ack from the */ +static int recv_pkt(git_pkt **out, gitno_buffer *buf) +{ + const char *ptr = buf->data, *line_end = ptr; + git_pkt *pkt; + int pkt_type, error = 0, ret; + + do { + if (buf->offset > 0) + error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->offset); + else + error = GIT_EBUFS; + + if (error == 0) + break; /* return the pkt */ + + if (error < 0 && error != GIT_EBUFS) + return -1; + + if ((ret = gitno_recv(buf)) < 0) + return -1; + } while (error); + + gitno_consume(buf, line_end); + pkt_type = pkt->type; + if (out != NULL) + *out = pkt; + else + git__free(pkt); + + return pkt_type; +} + +static int store_common(git_transport *t) +{ + git_pkt *pkt = NULL; + gitno_buffer *buf = &t->buffer; + + do { + if (recv_pkt(&pkt, buf) < 0) + return -1; + + if (pkt->type == GIT_PKT_ACK) { + if (git_vector_insert(&t->common, pkt) < 0) + return -1; + } else { + git__free(pkt); + return 0; + } + + } while (1); + + return 0; } /* @@ -81,6 +136,12 @@ static int filter_wants(git_remote *remote) int git_fetch_negotiate(git_remote *remote) { git_transport *t = remote->transport; + gitno_buffer *buf = &t->buffer; + git_buf data = GIT_BUF_INIT; + git_revwalk *walk = NULL; + int error, pkt_type; + unsigned int i; + git_oid oid; if (filter_wants(remote) < 0) { giterr_set(GITERR_NET, "Failed to filter the reference list for wants"); @@ -92,60 +153,174 @@ int git_fetch_negotiate(git_remote *remote) return 0; /* - * Now we have everything set up so we can start tell the server - * what we want and what we have. + * Now we have everything set up so we can start tell the + * server what we want and what we have. Call the function if + * the transport has its own logic. This is transitional and + * will be removed once this function can support git and http. */ - return t->negotiate_fetch(t, remote->repo, &remote->refs); + if (t->own_logic) + return t->negotiate_fetch(t, remote->repo, &remote->refs); + + /* No own logic, do our thing */ + if (git_pkt_buffer_wants(&remote->refs, &t->caps, &data) < 0) + return -1; + + if (git_fetch_setup_walk(&walk, remote->repo) < 0) + goto on_error; + /* + * We don't support any kind of ACK extensions, so the negotiation + * boils down to sending what we have and listening for an ACK + * every once in a while. + */ + i = 0; + while ((error = git_revwalk_next(&oid, walk)) == 0) { + git_pkt_buffer_have(&oid, &data); + i++; + if (i % 20 == 0) { + git_pkt_buffer_flush(&data); + if (git_buf_oom(&data)) + goto on_error; + + if (t->negotiation_step(t, data.ptr, data.size) < 0) + goto on_error; + + git_buf_clear(&data); + if (t->caps.multi_ack) { + if (store_common(t) < 0) + goto on_error; + } else { + pkt_type = recv_pkt(NULL, buf); + + if (pkt_type == GIT_PKT_ACK) { + break; + } else if (pkt_type == GIT_PKT_NAK) { + continue; + } else { + giterr_set(GITERR_NET, "Unexpected pkt type"); + goto on_error; + } + } + } + + if (t->common.length > 0) + break; + + if (i % 20 == 0 && t->rpc) { + git_pkt_ack *pkt; + unsigned int i; + + if (git_pkt_buffer_wants(&remote->refs, &t->caps, &data) < 0) + goto on_error; + + git_vector_foreach(&t->common, i, pkt) { + git_pkt_buffer_have(&pkt->oid, &data); + } + + if (git_buf_oom(&data)) + goto on_error; + } + } + + if (error < 0 && error != GIT_REVWALKOVER) + goto on_error; + + /* Tell the other end that we're done negotiating */ + if (t->rpc && t->common.length > 0) { + git_pkt_ack *pkt; + unsigned int i; + + if (git_pkt_buffer_wants(&remote->refs, &t->caps, &data) < 0) + goto on_error; + + git_vector_foreach(&t->common, i, pkt) { + git_pkt_buffer_have(&pkt->oid, &data); + } + + if (git_buf_oom(&data)) + goto on_error; + } + + git_pkt_buffer_done(&data); + if (t->negotiation_step(t, data.ptr, data.size) < 0) + goto on_error; + + git_buf_free(&data); + git_revwalk_free(walk); + + /* Now let's eat up whatever the server gives us */ + if (!t->caps.multi_ack) { + pkt_type = recv_pkt(NULL, buf); + if (pkt_type != GIT_PKT_ACK && pkt_type != GIT_PKT_NAK) { + giterr_set(GITERR_NET, "Unexpected pkt type"); + return -1; + } + } else { + git_pkt_ack *pkt; + do { + if (recv_pkt((git_pkt **)&pkt, buf) < 0) + return -1; + + if (pkt->type == GIT_PKT_NAK || + (pkt->type == GIT_PKT_ACK && pkt->status != GIT_ACK_CONTINUE)) { + git__free(pkt); + break; + } + + git__free(pkt); + } while (1); + } + + return 0; + +on_error: + git_revwalk_free(walk); + git_buf_free(&data); + return -1; } int git_fetch_download_pack(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats) { + git_transport *t = remote->transport; + if(!remote->need_pack) return 0; - return remote->transport->download_pack(remote->transport, remote->repo, bytes, stats); + if (t->own_logic) + return t->download_pack(t, remote->repo, bytes, stats); + + return git_fetch__download_pack(t, remote->repo, bytes, stats); + } /* Receiving data from a socket and storing it is pretty much the same for git and HTTP */ int git_fetch__download_pack( - const char *buffered, - size_t buffered_size, git_transport *t, git_repository *repo, git_off_t *bytes, git_indexer_stats *stats) { int recvd; - char buff[1024]; - gitno_buffer buf; git_buf path = GIT_BUF_INIT; + gitno_buffer *buf = &t->buffer; git_indexer_stream *idx = NULL; - gitno_buffer_setup(t, &buf, buff, sizeof(buff)); - - if (memcmp(buffered, "PACK", strlen("PACK"))) { - giterr_set(GITERR_NET, "The pack doesn't start with the signature"); - return -1; - } - if (git_buf_joinpath(&path, git_repository_path(repo), "objects/pack") < 0) return -1; if (git_indexer_stream_new(&idx, git_buf_cstr(&path)) < 0) goto on_error; + git_buf_free(&path); memset(stats, 0, sizeof(git_indexer_stats)); - if (git_indexer_stream_add(idx, buffered, buffered_size, stats) < 0) - goto on_error; - - *bytes = buffered_size; + *bytes = 0; do { - if (git_indexer_stream_add(idx, buf.data, buf.offset, stats) < 0) + if (git_indexer_stream_add(idx, buf->data, buf->offset, stats) < 0) goto on_error; - gitno_consume_n(&buf, buf.offset); - if ((recvd = gitno_recv(&buf)) < 0) + gitno_consume_n(buf, buf->offset); + + if ((recvd = gitno_recv(buf)) < 0) goto on_error; *bytes += recvd; diff --git a/src/fetch.h b/src/fetch.h index a7f126520..87bb43b07 100644 --- a/src/fetch.h +++ b/src/fetch.h @@ -12,8 +12,7 @@ int git_fetch_negotiate(git_remote *remote); int git_fetch_download_pack(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats); -int git_fetch__download_pack(const char *buffered, size_t buffered_size, git_transport *t, - git_repository *repo, git_off_t *bytes, git_indexer_stats *stats); +int git_fetch__download_pack(git_transport *t, git_repository *repo, git_off_t *bytes, git_indexer_stats *stats); int git_fetch_setup_walk(git_revwalk **out, git_repository *repo); #endif diff --git a/src/filebuf.c b/src/filebuf.c index 876f8e3e7..8b3ebb3e2 100644 --- a/src/filebuf.c +++ b/src/filebuf.c @@ -319,10 +319,15 @@ int git_filebuf_commit(git_filebuf *file, mode_t mode) if (verify_last_error(file) < 0) goto on_error; - p_close(file->fd); - file->fd = -1; file->fd_is_open = false; + if (p_close(file->fd) < 0) { + giterr_set(GITERR_OS, "Failed to close file at '%s'", file->path_lock); + goto on_error; + } + + file->fd = -1; + if (p_chmod(file->path_lock, mode)) { giterr_set(GITERR_OS, "Failed to set attributes for file at '%s'", file->path_lock); goto on_error; diff --git a/src/fileops.c b/src/fileops.c index 5849b79b2..e936c3e2b 100644 --- a/src/fileops.c +++ b/src/fileops.c @@ -424,6 +424,7 @@ int git_futils_find_system_file(git_buf *path, const char *filename) } if (win32_find_file(path, &root, filename) < 0) { + giterr_set(GITERR_OS, "The system file '%s' doesn't exist", filename); git_buf_clear(path); return GIT_ENOTFOUND; } @@ -438,6 +439,7 @@ int git_futils_find_system_file(git_buf *path, const char *filename) return 0; git_buf_clear(path); + giterr_set(GITERR_OS, "The system file '%s' doesn't exist", filename); return GIT_ENOTFOUND; #endif } @@ -455,6 +457,7 @@ int git_futils_find_global_file(git_buf *path, const char *filename) } if (win32_find_file(path, &root, filename) < 0) { + giterr_set(GITERR_OS, "The global file '%s' doesn't exist", filename); git_buf_clear(path); return GIT_ENOTFOUND; } @@ -473,6 +476,7 @@ int git_futils_find_global_file(git_buf *path, const char *filename) return -1; if (git_path_exists(path->ptr) == false) { + giterr_set(GITERR_OS, "The global file '%s' doesn't exist", filename); git_buf_clear(path); return GIT_ENOTFOUND; } diff --git a/src/ignore.c b/src/ignore.c index f2d08f59e..93d979f1a 100644 --- a/src/ignore.c +++ b/src/ignore.c @@ -156,7 +156,7 @@ void git_ignore__free(git_ignores *ignores) static bool ignore_lookup_in_rules( git_vector *rules, git_attr_path *path, int *ignored) { - unsigned int j; + size_t j; git_attr_fnmatch *match; git_vector_rforeach(rules, j, match) { diff --git a/src/index.c b/src/index.c index 89d479870..e021a4036 100644 --- a/src/index.c +++ b/src/index.c @@ -329,16 +329,16 @@ int git_index_write(git_index *index) unsigned int git_index_entrycount(git_index *index) { assert(index); - return index->entries.length; + return (unsigned int)index->entries.length; } unsigned int git_index_entrycount_unmerged(git_index *index) { assert(index); - return index->unmerged.length; + return (unsigned int)index->unmerged.length; } -git_index_entry *git_index_get(git_index *index, unsigned int n) +git_index_entry *git_index_get(git_index *index, size_t n) { git_vector_sort(&index->entries); return git_vector_get(&index->entries, n); @@ -584,7 +584,7 @@ const git_index_entry_unmerged *git_index_get_unmerged_bypath( } const git_index_entry_unmerged *git_index_get_unmerged_byindex( - git_index *index, unsigned int n) + git_index *index, size_t n) { assert(index); return git_vector_get(&index->unmerged, n); @@ -963,7 +963,7 @@ static int write_index(git_index *index, git_filebuf *file) header.signature = htonl(INDEX_HEADER_SIG); header.version = htonl(is_extended ? INDEX_VERSION_NUMBER_EXT : INDEX_VERSION_NUMBER); - header.entry_count = htonl(index->entries.length); + header.entry_count = htonl((uint32_t)index->entries.length); if (git_filebuf_write(file, &header, sizeof(struct index_header)) < 0) return -1; diff --git a/src/netops.c b/src/netops.c index b369e5106..49a0308bb 100644 --- a/src/netops.c +++ b/src/netops.c @@ -61,63 +61,72 @@ static int ssl_set_error(gitno_ssl *ssl, int error) } #endif -void gitno_buffer_setup(git_transport *t, gitno_buffer *buf, char *data, unsigned int len) +int gitno_recv(gitno_buffer *buf) { - memset(buf, 0x0, sizeof(gitno_buffer)); - memset(data, 0x0, len); - buf->data = data; - buf->len = len; - buf->offset = 0; - buf->fd = t->socket; -#ifdef GIT_SSL - if (t->encrypt) - buf->ssl = &t->ssl; -#endif + return buf->recv(buf); } #ifdef GIT_SSL -static int ssl_recv(gitno_ssl *ssl, void *data, size_t len) +static int gitno__recv_ssl(gitno_buffer *buf) { int ret; do { - ret = SSL_read(ssl->ssl, data, len); - } while (SSL_get_error(ssl->ssl, ret) == SSL_ERROR_WANT_READ); + ret = SSL_read(buf->ssl->ssl, buf->data + buf->offset, buf->len - buf->offset); + } while (SSL_get_error(buf->ssl->ssl, ret) == SSL_ERROR_WANT_READ); - if (ret < 0) - return ssl_set_error(ssl, ret); + if (ret < 0) { + net_set_error("Error receiving socket data"); + return -1; + } + buf->offset += ret; return ret; } #endif -int gitno_recv(gitno_buffer *buf) +int gitno__recv(gitno_buffer *buf) { int ret; -#ifdef GIT_SSL - if (buf->ssl != NULL) { - if ((ret = ssl_recv(buf->ssl, buf->data + buf->offset, buf->len - buf->offset)) < 0) - return -1; - } else { - ret = p_recv(buf->fd, buf->data + buf->offset, buf->len - buf->offset, 0); - if (ret < 0) { - net_set_error("Error receiving socket data"); - return -1; - } - } -#else ret = p_recv(buf->fd, buf->data + buf->offset, buf->len - buf->offset, 0); if (ret < 0) { net_set_error("Error receiving socket data"); return -1; } -#endif buf->offset += ret; return ret; } +void gitno_buffer_setup_callback( + git_transport *t, + gitno_buffer *buf, + char *data, + size_t len, + int (*recv)(gitno_buffer *buf), void *cb_data) +{ + memset(buf, 0x0, sizeof(gitno_buffer)); + memset(data, 0x0, len); + buf->data = data; + buf->len = len; + buf->offset = 0; + buf->fd = t->socket; + buf->recv = recv; + buf->cb_data = cb_data; +} + +void gitno_buffer_setup(git_transport *t, gitno_buffer *buf, char *data, size_t len) +{ +#ifdef GIT_SSL + if (t->use_ssl) { + gitno_buffer_setup_callback(t, buf, data, len, gitno__recv_ssl, NULL); + buf->ssl = &t->ssl; + } else +#endif + gitno_buffer_setup_callback(t, buf, data, len, gitno__recv, NULL); +} + /* Consume up to ptr and move the rest of the buffer to the beginning */ void gitno_consume(gitno_buffer *buf, const char *ptr) { @@ -147,7 +156,7 @@ int gitno_ssl_teardown(git_transport *t) int ret; #endif - if (!t->encrypt) + if (!t->use_ssl) return 0; #ifdef GIT_SSL @@ -415,7 +424,7 @@ int gitno_connect(git_transport *t, const char *host, const char *port) t->socket = s; p_freeaddrinfo(info); - if (t->encrypt && ssl_setup(t, host) < 0) + if (t->use_ssl && ssl_setup(t, host) < 0) return -1; return 0; @@ -445,7 +454,7 @@ int gitno_send(git_transport *t, const char *msg, size_t len, int flags) size_t off = 0; #ifdef GIT_SSL - if (t->encrypt) + if (t->use_ssl) return send_ssl(&t->ssl, msg, len); #endif diff --git a/src/netops.h b/src/netops.h index 4976f87f8..7c53fd0dc 100644 --- a/src/netops.h +++ b/src/netops.h @@ -8,10 +8,9 @@ #define INCLUDE_netops_h__ #include "posix.h" -#include "transport.h" #include "common.h" -typedef struct gitno_buffer { +struct gitno_buffer { char *data; size_t len; size_t offset; @@ -19,10 +18,14 @@ typedef struct gitno_buffer { #ifdef GIT_SSL struct gitno_ssl *ssl; #endif -} gitno_buffer; + int (*recv)(gitno_buffer *buffer); + void *cb_data; +}; -void gitno_buffer_setup(git_transport *t, gitno_buffer *buf, char *data, unsigned int len); +void gitno_buffer_setup(git_transport *t, gitno_buffer *buf, char *data, size_t len); +void gitno_buffer_setup_callback(git_transport *t, gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data); int gitno_recv(gitno_buffer *buf); +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); diff --git a/src/notes.c b/src/notes.c index 212413a5a..6f9e7779d 100644 --- a/src/notes.c +++ b/src/notes.c @@ -522,7 +522,8 @@ static int process_entry_path( int (*note_cb)(git_note_data *note_data, void *payload), void *payload) { - int i = 0, j = 0, error, len; + int error = -1; + size_t i = 0, j = 0, len; git_buf buf = GIT_BUF_INIT; git_note_data note_data; diff --git a/src/object.c b/src/object.c index 3ff894212..227774047 100644 --- a/src/object.c +++ b/src/object.c @@ -81,7 +81,7 @@ int git_object_lookup_prefix( git_object **object_out, git_repository *repo, const git_oid *id, - unsigned int len, + size_t len, git_otype type) { git_object *object = NULL; @@ -553,7 +553,7 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id) } int git_odb_read_prefix( - git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len) + git_odb_object **out, git_odb *db, const git_oid *short_id, size_t len) { unsigned int i; int error = GIT_ENOTFOUND; diff --git a/src/odb_loose.c b/src/odb_loose.c index ccb899e8c..41121ae10 100644 --- a/src/odb_loose.c +++ b/src/odb_loose.c @@ -42,7 +42,7 @@ typedef struct loose_backend { typedef struct { size_t dir_len; unsigned char short_oid[GIT_OID_HEXSZ]; /* hex formatted oid to match */ - unsigned int short_oid_len; + size_t short_oid_len; int found; /* number of matching * objects already found */ unsigned char res_oid[GIT_OID_HEXSZ]; /* hex formatted oid of @@ -502,7 +502,7 @@ static int locate_object_short_oid( git_oid *res_oid, loose_backend *backend, const git_oid *short_oid, - unsigned int len) + size_t len) { char *objects_dir = backend->objects_dir; size_t dir_len = strlen(objects_dir); @@ -629,7 +629,7 @@ static int loose_backend__read_prefix( git_otype *type_p, git_odb_backend *backend, const git_oid *short_oid, - unsigned int len) + size_t len) { int error = 0; diff --git a/src/odb_pack.c b/src/odb_pack.c index 176be5f01..8fc6e68e8 100644 --- a/src/odb_pack.c +++ b/src/odb_pack.c @@ -149,7 +149,7 @@ static int pack_entry_find_prefix( struct git_pack_entry *e, struct pack_backend *backend, const git_oid *short_oid, - unsigned int len); + size_t len); @@ -295,7 +295,7 @@ static int pack_entry_find_prefix( struct git_pack_entry *e, struct pack_backend *backend, const git_oid *short_oid, - unsigned int len) + size_t len) { int error; unsigned int i; @@ -384,7 +384,7 @@ static int pack_backend__read_prefix( git_otype *type_p, git_odb_backend *backend, const git_oid *short_oid, - unsigned int len) + size_t len) { int error = 0; @@ -461,6 +461,41 @@ static void pack_backend__free(git_odb_backend *_backend) git__free(backend); } +int git_odb_backend_one_pack(git_odb_backend **backend_out, const char *idx) +{ + struct pack_backend *backend = NULL; + struct git_pack_file *packfile = NULL; + + if (git_packfile_check(&packfile, idx) < 0) + return -1; + + backend = git__calloc(1, sizeof(struct pack_backend)); + GITERR_CHECK_ALLOC(backend); + + if (git_vector_init(&backend->packs, 1, NULL) < 0) + goto on_error; + + if (git_vector_insert(&backend->packs, packfile) < 0) + goto on_error; + + backend->parent.read = &pack_backend__read; + backend->parent.read_prefix = &pack_backend__read_prefix; + backend->parent.read_header = NULL; + backend->parent.exists = &pack_backend__exists; + backend->parent.foreach = &pack_backend__foreach; + backend->parent.free = &pack_backend__free; + + *backend_out = (git_odb_backend *)backend; + + return 0; + +on_error: + git_vector_free(&backend->packs); + git__free(backend); + git__free(packfile); + return -1; +} + int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir) { struct pack_backend *backend = NULL; @@ -161,12 +161,7 @@ void git_oid_cpy(git_oid *out, const git_oid *src) memcpy(out->id, src->id, sizeof(out->id)); } -int git_oid_cmp(const git_oid *a, const git_oid *b) -{ - return memcmp(a->id, b->id, sizeof(a->id)); -} - -int git_oid_ncmp(const git_oid *oid_a, const git_oid *oid_b, unsigned int len) +int git_oid_ncmp(const git_oid *oid_a, const git_oid *oid_b, size_t len) { const unsigned char *a = oid_a->id; const unsigned char *b = oid_b->id; diff --git a/src/oidmap.h b/src/oidmap.h index 5a0bab6ec..1791adb16 100644 --- a/src/oidmap.h +++ b/src/oidmap.h @@ -28,13 +28,8 @@ GIT_INLINE(khint_t) hash_git_oid(const git_oid *oid) return h; } -GIT_INLINE(int) hash_git_oid_equal(const git_oid *a, const git_oid *b) -{ - return (memcmp(a->id, b->id, sizeof(a->id)) == 0); -} - #define GIT__USE_OIDMAP \ - __KHASH_IMPL(oid, static kh_inline, const git_oid *, void *, 1, hash_git_oid, hash_git_oid_equal) + __KHASH_IMPL(oid, static kh_inline, const git_oid *, void *, 1, hash_git_oid, git_oid_equal) #define git_oidmap_alloc() kh_init(oid) #define git_oidmap_free(h) kh_destroy(oid,h), h = NULL diff --git a/src/pack.c b/src/pack.c index acdb40d35..e1fa085fd 100644 --- a/src/pack.c +++ b/src/pack.c @@ -38,7 +38,7 @@ static int pack_entry_find_offset( git_oid *found_oid, struct git_pack_file *p, const git_oid *short_oid, - unsigned int len); + size_t len); static int packfile_error(const char *message) { @@ -735,7 +735,7 @@ static int pack_entry_find_offset( git_oid *found_oid, struct git_pack_file *p, const git_oid *short_oid, - unsigned int len) + size_t len) { const uint32_t *level1_ofs = p->index_map.data; const unsigned char *index = p->index_map.data; @@ -828,7 +828,7 @@ int git_pack_entry_find( struct git_pack_entry *e, struct git_pack_file *p, const git_oid *short_oid, - unsigned int len) + size_t len) { git_off_t offset; git_oid found_oid; diff --git a/src/pack.h b/src/pack.h index 7e1f978b0..178545675 100644 --- a/src/pack.h +++ b/src/pack.h @@ -101,7 +101,7 @@ int git_pack_entry_find( struct git_pack_entry *e, struct git_pack_file *p, const git_oid *short_oid, - unsigned int len); + size_t len); int git_pack_foreach_entry( struct git_pack_file *p, int (*cb)(git_oid *oid, void *data), @@ -42,15 +42,29 @@ static int flush_pkt(git_pkt **out) /* the rest of the line will be useful for multi_ack */ static int ack_pkt(git_pkt **out, const char *line, size_t len) { - git_pkt *pkt; + git_pkt_ack *pkt; GIT_UNUSED(line); GIT_UNUSED(len); - pkt = git__malloc(sizeof(git_pkt)); + pkt = git__calloc(1, sizeof(git_pkt_ack)); GITERR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_ACK; - *out = pkt; + line += 3; + len -= 3; + + if (len >= GIT_OID_HEXSZ) { + git_oid_fromstr(&pkt->oid, line + 1); + line += GIT_OID_HEXSZ + 1; + len -= GIT_OID_HEXSZ + 1; + } + + if (len >= 7) { + if (!git__prefixcmp(line + 1, "continue")) + pkt->status = GIT_ACK_CONTINUE; + } + + *out = (git_pkt *) pkt; return 0; } @@ -283,20 +297,28 @@ int git_pkt_buffer_flush(git_buf *buf) static int buffer_want_with_caps(git_remote_head *head, git_transport_caps *caps, git_buf *buf) { - char capstr[20]; + git_buf str = GIT_BUF_INIT; char oid[GIT_OID_HEXSZ +1] = {0}; unsigned int len; if (caps->ofs_delta) - strncpy(capstr, GIT_CAP_OFS_DELTA, sizeof(capstr)); + git_buf_puts(&str, GIT_CAP_OFS_DELTA " "); + + if (caps->multi_ack) + git_buf_puts(&str, GIT_CAP_MULTI_ACK " "); + + if (git_buf_oom(&str)) + return -1; len = (unsigned int) (strlen("XXXXwant ") + GIT_OID_HEXSZ + 1 /* NUL */ + - strlen(capstr) + 1 /* LF */); + git_buf_len(&str) + 1 /* LF */); git_buf_grow(buf, git_buf_len(buf) + len); - git_oid_fmt(oid, &head->oid); - return git_buf_printf(buf, "%04xwant %s %s\n", len, oid, capstr); + git_buf_printf(buf, "%04xwant %s %s\n", len, oid, git_buf_cstr(&str)); + git_buf_free(&str); + + return git_buf_oom(buf); } /* diff --git a/src/protocol.c b/src/protocol.c index 6b3861796..20d6e230f 100644 --- a/src/protocol.c +++ b/src/protocol.c @@ -9,38 +9,36 @@ #include "pkt.h" #include "buffer.h" -int git_protocol_store_refs(git_protocol *p, const char *data, size_t len) +int git_protocol_store_refs(git_transport *t, int flushes) { - git_buf *buf = &p->buf; - git_vector *refs = p->refs; - int error; - const char *line_end, *ptr; - - if (len == 0) { /* EOF */ - if (git_buf_len(buf) != 0) { - giterr_set(GITERR_NET, "Unexpected EOF"); - return p->error = -1; - } else { - return 0; - } - } + gitno_buffer *buf = &t->buffer; + git_vector *refs = &t->refs; + int error, flush = 0, recvd; + const char *line_end; + git_pkt *pkt; - git_buf_put(buf, data, len); - ptr = buf->ptr; - while (1) { - git_pkt *pkt; + do { + if (buf->offset > 0) + error = git_pkt_parse_line(&pkt, buf->data, &line_end, buf->offset); + else + error = GIT_EBUFS; - if (git_buf_len(buf) == 0) - return 0; + if (error < 0 && error != GIT_EBUFS) + return -1; - error = git_pkt_parse_line(&pkt, ptr, &line_end, git_buf_len(buf)); - if (error == GIT_EBUFS) - return 0; /* Ask for more */ - if (error < 0) - return p->error = -1; + if (error == GIT_EBUFS) { + if ((recvd = gitno_recv(buf)) < 0) + return -1; - git_buf_consume(buf, line_end); + if (recvd == 0 && !flush) { + giterr_set(GITERR_NET, "Early EOF"); + return -1; + } + + continue; + } + gitno_consume(buf, line_end); if (pkt->type == GIT_PKT_ERR) { giterr_set(GITERR_NET, "Remote error: %s", ((git_pkt_err *)pkt)->error); git__free(pkt); @@ -48,10 +46,42 @@ int git_protocol_store_refs(git_protocol *p, const char *data, size_t len) } if (git_vector_insert(refs, pkt) < 0) - return p->error = -1; + return -1; if (pkt->type == GIT_PKT_FLUSH) - p->flush = 1; + flush++; + } while (flush < flushes); + + return flush; +} + +int git_protocol_detect_caps(git_pkt_ref *pkt, git_transport_caps *caps) +{ + const char *ptr; + + /* No refs or capabilites, odd but not a problem */ + if (pkt == NULL || pkt->capabilities == NULL) + return 0; + + ptr = pkt->capabilities; + while (ptr != NULL && *ptr != '\0') { + if (*ptr == ' ') + ptr++; + + if(!git__prefixcmp(ptr, GIT_CAP_OFS_DELTA)) { + caps->common = caps->ofs_delta = 1; + ptr += strlen(GIT_CAP_OFS_DELTA); + continue; + } + + if(!git__prefixcmp(ptr, GIT_CAP_MULTI_ACK)) { + caps->common = caps->multi_ack = 1; + ptr += strlen(GIT_CAP_MULTI_ACK); + continue; + } + + /* We don't know this capability, so skip it */ + ptr = strchr(ptr, ' '); } return 0; diff --git a/src/protocol.h b/src/protocol.h index a6c3e0735..615be8d63 100644 --- a/src/protocol.h +++ b/src/protocol.h @@ -9,15 +9,9 @@ #include "transport.h" #include "buffer.h" +#include "pkt.h" -typedef struct { - git_transport *transport; - git_vector *refs; - git_buf buf; - int error; - unsigned int flush :1; -} git_protocol; - -int git_protocol_store_refs(git_protocol *p, const char *data, size_t len); +int git_protocol_store_refs(git_transport *t, int flushes); +int git_protocol_detect_caps(git_pkt_ref *pkt, git_transport_caps *caps); #endif diff --git a/src/reflog.c b/src/reflog.c index 004ba936d..80e40b960 100644 --- a/src/reflog.c +++ b/src/reflog.c @@ -28,66 +28,68 @@ static int reflog_init(git_reflog **reflog, git_reference *ref) return -1; } + log->owner = git_reference_owner(ref); *reflog = log; return 0; } -static int reflog_write(const char *log_path, const char *oid_old, - const char *oid_new, const git_signature *committer, - const char *msg) +static int serialize_reflog_entry( + git_buf *buf, + const git_oid *oid_old, + const git_oid *oid_new, + const git_signature *committer, + const char *msg) { - int error; - git_buf log = GIT_BUF_INIT; - git_filebuf fbuf = GIT_FILEBUF_INIT; - bool trailing_newline = false; + char raw_old[GIT_OID_HEXSZ+1]; + char raw_new[GIT_OID_HEXSZ+1]; - assert(log_path && oid_old && oid_new && committer); + git_oid_tostr(raw_old, GIT_OID_HEXSZ+1, oid_old); + git_oid_tostr(raw_new, GIT_OID_HEXSZ+1, oid_new); - if (msg) { - const char *newline = strchr(msg, '\n'); - if (newline) { - if (*(newline + 1) == '\0') - trailing_newline = true; - else { - giterr_set(GITERR_INVALID, "Reflog message cannot contain newline"); - return -1; - } - } - } + git_buf_clear(buf); - git_buf_puts(&log, oid_old); - git_buf_putc(&log, ' '); + git_buf_puts(buf, raw_old); + git_buf_putc(buf, ' '); + git_buf_puts(buf, raw_new); - git_buf_puts(&log, oid_new); + git_signature__writebuf(buf, " ", committer); - git_signature__writebuf(&log, " ", committer); - git_buf_truncate(&log, log.size - 1); /* drop LF */ + /* drop trailing LF */ + git_buf_rtrim(buf); if (msg) { - git_buf_putc(&log, '\t'); - git_buf_puts(&log, msg); + git_buf_putc(buf, '\t'); + git_buf_puts(buf, msg); } - if (!trailing_newline) - git_buf_putc(&log, '\n'); + git_buf_putc(buf, '\n'); - if (git_buf_oom(&log)) { - git_buf_free(&log); - return -1; - } + return git_buf_oom(buf); +} - error = git_filebuf_open(&fbuf, log_path, GIT_FILEBUF_APPEND); - if (!error) { - if ((error = git_filebuf_write(&fbuf, log.ptr, log.size)) < 0) - git_filebuf_cleanup(&fbuf); - else - error = git_filebuf_commit(&fbuf, GIT_REFLOG_FILE_MODE); - } +static int reflog_entry_new(git_reflog_entry **entry) +{ + git_reflog_entry *e; - git_buf_free(&log); + assert(entry); - return error; + e = git__malloc(sizeof(git_reflog_entry)); + GITERR_CHECK_ALLOC(e); + + memset(e, 0, sizeof(git_reflog_entry)); + + *entry = e; + + return 0; +} + +static void reflog_entry_free(git_reflog_entry *entry) +{ + git_signature_free(entry->committer); + + git__free(entry->msg); + git__free(entry); } static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size) @@ -105,8 +107,8 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size) } while (0) while (buf_size > GIT_REFLOG_SIZE_MIN) { - entry = git__malloc(sizeof(git_reflog_entry)); - GITERR_CHECK_ALLOC(entry); + if (reflog_entry_new(&entry) < 0) + return -1; entry->committer = git__malloc(sizeof(git_signature)); GITERR_CHECK_ALLOC(entry->committer); @@ -153,10 +155,9 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size) #undef seek_forward fail: - if (entry) { - git__free(entry->committer); - git__free(entry); - } + if (entry) + reflog_entry_free(entry); + return -1; } @@ -168,10 +169,7 @@ void git_reflog_free(git_reflog *reflog) for (i=0; i < reflog->entries.length; i++) { entry = git_vector_get(&reflog->entries, i); - git_signature_free(entry->committer); - - git__free(entry->msg); - git__free(entry); + reflog_entry_free(entry); } git_vector_free(&reflog->entries); @@ -179,92 +177,163 @@ void git_reflog_free(git_reflog *reflog) git__free(reflog); } +static int retrieve_reflog_path(git_buf *path, git_reference *ref) +{ + return git_buf_join_n(path, '/', 3, + git_reference_owner(ref)->path_repository, GIT_REFLOG_DIR, ref->name); +} + +static int create_new_reflog_file(const char *filepath) +{ + int fd; + + if ((fd = p_open(filepath, + O_WRONLY | O_CREAT | O_TRUNC, + GIT_REFLOG_FILE_MODE)) < 0) + return -1; + + return p_close(fd); +} + int git_reflog_read(git_reflog **reflog, git_reference *ref) { - int error; + int error = -1; git_buf log_path = GIT_BUF_INIT; git_buf log_file = GIT_BUF_INIT; git_reflog *log = NULL; *reflog = NULL; + assert(reflog && ref); + if (reflog_init(&log, ref) < 0) return -1; - error = git_buf_join_n(&log_path, '/', 3, - ref->owner->path_repository, GIT_REFLOG_DIR, ref->name); + if (retrieve_reflog_path(&log_path, ref) < 0) + goto cleanup; + + error = git_futils_readbuffer(&log_file, git_buf_cstr(&log_path)); + if (error < 0 && error != GIT_ENOTFOUND) + goto cleanup; + + if ((error == GIT_ENOTFOUND) && + ((error = create_new_reflog_file(git_buf_cstr(&log_path))) < 0)) + goto cleanup; - if (!error) - error = git_futils_readbuffer(&log_file, log_path.ptr); + if ((error = reflog_parse(log, + git_buf_cstr(&log_file), git_buf_len(&log_file))) < 0) + goto cleanup; - if (!error) - error = reflog_parse(log, log_file.ptr, log_file.size); + *reflog = log; + goto success; - if (!error) - *reflog = log; - else - git_reflog_free(log); +cleanup: + git_reflog_free(log); +success: git_buf_free(&log_file); git_buf_free(&log_path); return error; } -int git_reflog_write(git_reference *ref, const git_oid *oid_old, - const git_signature *committer, const char *msg) +int git_reflog_write(git_reflog *reflog) { - int error; - char old[GIT_OID_HEXSZ+1]; - char new[GIT_OID_HEXSZ+1]; + int error = -1; + unsigned int i; + git_reflog_entry *entry; git_buf log_path = GIT_BUF_INIT; - git_reference *r; - const git_oid *oid; + git_buf log = GIT_BUF_INIT; + git_filebuf fbuf = GIT_FILEBUF_INIT; + + assert(reflog); - if ((error = git_reference_resolve(&r, ref)) < 0) - return error; - oid = git_reference_oid(r); - if (oid == NULL) { - giterr_set(GITERR_REFERENCE, - "Failed to write reflog. Cannot resolve reference `%s`", r->name); - git_reference_free(r); + if (git_buf_join_n(&log_path, '/', 3, + git_repository_path(reflog->owner), GIT_REFLOG_DIR, reflog->ref_name) < 0) return -1; + + if (!git_path_isfile(git_buf_cstr(&log_path))) { + giterr_set(GITERR_INVALID, + "Log file for reference '%s' doesn't exist.", reflog->ref_name); + goto cleanup; + } + + if ((error = git_filebuf_open(&fbuf, git_buf_cstr(&log_path), 0)) < 0) + goto cleanup; + + git_vector_foreach(&reflog->entries, i, entry) { + if (serialize_reflog_entry(&log, &(entry->oid_old), &(entry->oid_cur), entry->committer, entry->msg) < 0) + goto cleanup; + + if ((error = git_filebuf_write(&fbuf, log.ptr, log.size)) < 0) + goto cleanup; } + + error = git_filebuf_commit(&fbuf, GIT_REFLOG_FILE_MODE); + goto success; + +cleanup: + git_filebuf_cleanup(&fbuf); + +success: + git_buf_free(&log); + git_buf_free(&log_path); + return error; +} - git_oid_tostr(new, GIT_OID_HEXSZ+1, oid); +int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, + const git_signature *committer, const char *msg) +{ + int count; + git_reflog_entry *entry; + const char *newline; - git_reference_free(r); + assert(reflog && new_oid && committer); - error = git_buf_join_n(&log_path, '/', 3, - ref->owner->path_repository, GIT_REFLOG_DIR, ref->name); - if (error < 0) + if (reflog_entry_new(&entry) < 0) + return -1; + + if ((entry->committer = git_signature_dup(committer)) == NULL) goto cleanup; - if (git_path_exists(log_path.ptr) == false) { - error = git_futils_mkpath2file(log_path.ptr, GIT_REFLOG_DIR_MODE); - } else if (git_path_isfile(log_path.ptr) == false) { - giterr_set(GITERR_REFERENCE, - "Failed to write reflog. `%s` is directory", log_path.ptr); - error = -1; - } else if (oid_old == NULL) { - giterr_set(GITERR_REFERENCE, - "Failed to write reflog. Old OID cannot be NULL for existing reference"); - error = -1; + if (msg != NULL) { + if ((entry->msg = git__strdup(msg)) == NULL) + goto cleanup; + + newline = strchr(msg, '\n'); + + if (newline) { + if (newline[1] != '\0') { + giterr_set(GITERR_INVALID, "Reflog message cannot contain newline"); + goto cleanup; + } + + entry->msg[newline - msg] = '\0'; + } } - if (error < 0) - goto cleanup; - if (oid_old) - git_oid_tostr(old, sizeof(old), oid_old); - else - p_snprintf(old, sizeof(old), "%0*d", GIT_OID_HEXSZ, 0); + count = git_reflog_entrycount(reflog); + + if (count == 0) + git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO); + else { + const git_reflog_entry *previous; - error = reflog_write(log_path.ptr, old, new, committer, msg); + previous = git_reflog_entry_byindex(reflog, count -1); + git_oid_cpy(&entry->oid_old, &previous->oid_cur); + } + + git_oid_cpy(&entry->oid_cur, new_oid); + + if (git_vector_insert(&reflog->entries, entry) < 0) + goto cleanup; + + return 0; cleanup: - git_buf_free(&log_path); - return error; + reflog_entry_free(entry); + return -1; } int git_reflog_rename(git_reference *ref, const char *new_name) @@ -276,7 +345,7 @@ int git_reflog_rename(git_reference *ref, const char *new_name) assert(ref && new_name); - if (git_buf_joinpath(&temp_path, ref->owner->path_repository, GIT_REFLOG_DIR) < 0) + if (git_buf_joinpath(&temp_path, git_reference_owner(ref)->path_repository, GIT_REFLOG_DIR) < 0) return -1; if (git_buf_joinpath(&old_path, git_buf_cstr(&temp_path), ref->name) < 0) @@ -324,8 +393,7 @@ int git_reflog_delete(git_reference *ref) int error; git_buf path = GIT_BUF_INIT; - error = git_buf_join_n( - &path, '/', 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name); + error = retrieve_reflog_path(&path, ref); if (!error && git_path_exists(path.ptr)) error = p_unlink(path.ptr); @@ -338,10 +406,10 @@ int git_reflog_delete(git_reference *ref) unsigned int git_reflog_entrycount(git_reflog *reflog) { assert(reflog); - return reflog->entries.length; + return (unsigned int)reflog->entries.length; } -const git_reflog_entry * git_reflog_entry_byindex(git_reflog *reflog, unsigned int idx) +const git_reflog_entry * git_reflog_entry_byindex(git_reflog *reflog, size_t idx) { assert(reflog); return git_vector_get(&reflog->entries, idx); @@ -370,3 +438,52 @@ char * git_reflog_entry_msg(const git_reflog_entry *entry) assert(entry); return entry->msg; } + +int git_reflog_drop( + git_reflog *reflog, + unsigned int idx, + int rewrite_previous_entry) +{ + unsigned int entrycount; + git_reflog_entry *entry, *previous; + + assert(reflog); + + entrycount = git_reflog_entrycount(reflog); + + if (idx >= entrycount) + return GIT_ENOTFOUND; + + entry = git_vector_get(&reflog->entries, idx); + reflog_entry_free(entry); + + if (git_vector_remove(&reflog->entries, idx) < 0) + return -1; + + if (!rewrite_previous_entry) + return 0; + + /* No need to rewrite anything when removing the first entry */ + if (idx == 0) + return 0; + + /* There are no more entries in the log */ + if (entrycount == 1) + return 0; + + entry = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx - 1); + + /* If the last entry has just been removed... */ + if (idx == entrycount - 1) { + /* ...clear the oid_old member of the "new" last entry */ + if (git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO) < 0) + return -1; + + return 0; + } + + previous = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx); + git_oid_cpy(&entry->oid_old, &previous->oid_cur); + + return 0; +} diff --git a/src/reflog.h b/src/reflog.h index 33cf0776c..3bbdf6e10 100644 --- a/src/reflog.h +++ b/src/reflog.h @@ -17,6 +17,8 @@ #define GIT_REFLOG_SIZE_MIN (2*GIT_OID_HEXSZ+2+17) +#define GIT_OID_HEX_ZERO "0000000000000000000000000000000000000000" + struct git_reflog_entry { git_oid oid_old; git_oid oid_cur; @@ -28,6 +30,7 @@ struct git_reflog_entry { struct git_reflog { char *ref_name; + git_repository *owner; git_vector entries; }; diff --git a/src/refs.c b/src/refs.c index 723695cd6..0e0a491ec 100644 --- a/src/refs.c +++ b/src/refs.c @@ -11,7 +11,6 @@ #include "fileops.h" #include "pack.h" #include "reflog.h" -#include "config.h" #include <git2/tag.h> #include <git2/object.h> @@ -1824,75 +1823,9 @@ int git_reference_has_log( return result; } -//TODO: How about also taking care of local tracking branches? -//cf. http://alblue.bandlem.com/2011/07/git-tip-of-week-tracking-branches.html -int git_reference_remote_tracking_from_branch( - git_reference **tracking_ref, - git_reference *branch_ref) +int git_reference_is_branch(git_reference *ref) { - git_config *config = NULL; - const char *name, *remote, *merge; - git_buf buf = GIT_BUF_INIT; - int error = -1; - - assert(tracking_ref && branch_ref); - - name = git_reference_name(branch_ref); - - if (git__prefixcmp(name, GIT_REFS_HEADS_DIR)) { - giterr_set( - GITERR_INVALID, - "Failed to retrieve tracking reference - '%s' is not a branch.", - name); - return -1; - } - - if (git_repository_config(&config, branch_ref->owner) < 0) - return -1; - - if (git_buf_printf( - &buf, - "branch.%s.remote", - name + strlen(GIT_REFS_HEADS_DIR)) < 0) - goto cleanup; - - if ((error = git_config_get_string(&remote, config, git_buf_cstr(&buf))) < 0) - goto cleanup; - - error = -1; - - git_buf_clear(&buf); - - //TODO: Is it ok to fail when no merge target is found? - if (git_buf_printf( - &buf, - "branch.%s.merge", - name + strlen(GIT_REFS_HEADS_DIR)) < 0) - goto cleanup; - - if (git_config_get_string(&merge, config, git_buf_cstr(&buf)) < 0) - goto cleanup; - - //TODO: Should we test this? - if (git__prefixcmp(merge, GIT_REFS_HEADS_DIR)) - goto cleanup; - - git_buf_clear(&buf); - - if (git_buf_printf( - &buf, - "refs/remotes/%s/%s", - remote, - merge + strlen(GIT_REFS_HEADS_DIR)) < 0) - goto cleanup; - - error = git_reference_lookup( - tracking_ref, - branch_ref->owner, - git_buf_cstr(&buf)); + assert(ref); -cleanup: - git_config_free(config); - git_buf_free(&buf); - return error; + return git__prefixcmp(ref->name, GIT_REFS_HEADS_DIR) == 0; } diff --git a/src/remote.c b/src/remote.c index e46249e12..adbfdc437 100644 --- a/src/remote.c +++ b/src/remote.c @@ -5,7 +5,6 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "git2/remote.h" #include "git2/config.h" #include "git2/types.h" @@ -14,6 +13,7 @@ #include "remote.h" #include "fetch.h" #include "refs.h" +#include "pkt.h" #include <regex.h> @@ -131,6 +131,26 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name) GITERR_CHECK_ALLOC(remote->url); git_buf_clear(&buf); + if (git_buf_printf(&buf, "remote.%s.pushurl", name) < 0) { + error = -1; + goto cleanup; + } + + error = git_config_get_string(&val, config, git_buf_cstr(&buf)); + if (error == GIT_ENOTFOUND) + error = 0; + + if (error < 0) { + error = -1; + goto cleanup; + } + + if (val) { + remote->pushurl = git__strdup(val); + GITERR_CHECK_ALLOC(remote->pushurl); + } + + git_buf_clear(&buf); if (git_buf_printf(&buf, "remote.%s.fetch", name) < 0) { error = -1; goto cleanup; @@ -179,7 +199,7 @@ int git_remote_save(const git_remote *remote) if (git_repository_config__weakptr(&config, remote->repo) < 0) return -1; - if (git_buf_printf(&buf, "remote.%s.%s", remote->name, "url") < 0) + if (git_buf_printf(&buf, "remote.%s.url", remote->name) < 0) return -1; if (git_config_set_string(config, git_buf_cstr(&buf), remote->url) < 0) { @@ -187,6 +207,26 @@ int git_remote_save(const git_remote *remote) return -1; } + git_buf_clear(&buf); + if (git_buf_printf(&buf, "remote.%s.pushurl", remote->name) < 0) + return -1; + + if (remote->pushurl) { + if (git_config_set_string(config, git_buf_cstr(&buf), remote->pushurl) < 0) { + git_buf_free(&buf); + return -1; + } + } else { + int error = git_config_delete(config, git_buf_cstr(&buf)); + if (error == GIT_ENOTFOUND) { + error = 0; + } + if (error < 0) { + git_buf_free(&buf); + return -1; + } + } + if (remote->fetch.src != NULL && remote->fetch.dst != NULL) { git_buf_clear(&buf); git_buf_clear(&value); @@ -238,6 +278,38 @@ const char *git_remote_url(git_remote *remote) return remote->url; } +int git_remote_set_url(git_remote *remote, const char* url) +{ + assert(remote); + assert(url); + + git__free(remote->url); + remote->url = git__strdup(url); + GITERR_CHECK_ALLOC(remote->url); + + return 0; +} + +const char *git_remote_pushurl(git_remote *remote) +{ + assert(remote); + return remote->pushurl; +} + +int git_remote_set_pushurl(git_remote *remote, const char* url) +{ + assert(remote); + + git__free(remote->pushurl); + if (url) { + remote->pushurl = git__strdup(url); + GITERR_CHECK_ALLOC(remote->pushurl); + } else { + remote->pushurl = NULL; + } + return 0; +} + int git_remote_set_fetchspec(git_remote *remote, const char *spec) { git_refspec refspec; @@ -284,13 +356,33 @@ const git_refspec *git_remote_pushspec(git_remote *remote) return &remote->push; } +const char* git_remote__urlfordirection(git_remote *remote, int direction) +{ + assert(remote); + + if (direction == GIT_DIR_FETCH) { + return remote->url; + } + + if (direction == GIT_DIR_PUSH) { + return remote->pushurl ? remote->pushurl : remote->url; + } + + return NULL; +} + int git_remote_connect(git_remote *remote, int direction) { git_transport *t; + const char *url; assert(remote); - if (git_transport_new(&t, remote->url) < 0) + url = git_remote__urlfordirection(remote, direction); + if (url == NULL ) + return -1; + + if (git_transport_new(&t, url) < 0) return -1; t->check_cert = remote->check_cert; @@ -309,6 +401,10 @@ on_error: int git_remote_ls(git_remote *remote, git_headlist_cb list_cb, void *payload) { + git_vector *refs = &remote->transport->refs; + unsigned int i; + git_pkt *p = NULL; + assert(remote); if (!remote->transport || !remote->transport->connected) { @@ -316,7 +412,21 @@ int git_remote_ls(git_remote *remote, git_headlist_cb list_cb, void *payload) return -1; } - return remote->transport->ls(remote->transport, list_cb, payload); + git_vector_foreach(refs, i, p) { + git_pkt_ref *pkt = NULL; + + if (p->type != GIT_PKT_REF) + continue; + + pkt = (git_pkt_ref *)p; + + if (list_cb(&pkt->head, payload) < 0) { + giterr_set(GITERR_NET, "User callback returned error"); + return -1; + } + } + + return 0; } int git_remote_download(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats) @@ -331,7 +441,7 @@ int git_remote_download(git_remote *remote, git_off_t *bytes, git_indexer_stats return git_fetch_download_pack(remote, bytes, stats); } -int git_remote_update_tips(git_remote *remote, int (*cb)(const char *refname, const git_oid *a, const git_oid *b)) +int git_remote_update_tips(git_remote *remote) { int error = 0; unsigned int i = 0; @@ -381,8 +491,8 @@ int git_remote_update_tips(git_remote *remote, int (*cb)(const char *refname, co git_reference_free(ref); - if (cb != NULL) { - if (cb(refname.ptr, &old, &head->oid) < 0) + if (remote->callbacks.update_tips != NULL) { + if (remote->callbacks.update_tips(refname.ptr, &old, &head->oid, remote->callbacks.data) < 0) goto on_error; } } @@ -429,6 +539,7 @@ void git_remote_free(git_remote *remote) git__free(remote->push.src); git__free(remote->push.dst); git__free(remote->url); + git__free(remote->pushurl); git__free(remote->name); git__free(remote); } @@ -525,3 +636,10 @@ void git_remote_check_cert(git_remote *remote, int check) remote->check_cert = check; } + +void git_remote_set_callbacks(git_remote *remote, git_remote_callbacks *callbacks) +{ + assert(remote && callbacks); + + memcpy(&remote->callbacks, callbacks, sizeof(git_remote_callbacks)); +} diff --git a/src/remote.h b/src/remote.h index 0949ad434..67933a327 100644 --- a/src/remote.h +++ b/src/remote.h @@ -7,6 +7,8 @@ #ifndef INCLUDE_remote_h__ #define INCLUDE_remote_h__ +#include "git2/remote.h" + #include "refspec.h" #include "transport.h" #include "repository.h" @@ -14,13 +16,17 @@ struct git_remote { char *name; char *url; + char *pushurl; git_vector refs; struct git_refspec fetch; struct git_refspec push; git_transport *transport; git_repository *repo; + git_remote_callbacks callbacks; unsigned int need_pack:1, check_cert; }; +const char* git_remote__urlfordirection(struct git_remote *remote, int direction); + #endif diff --git a/src/repository.c b/src/repository.c index a2931713e..a4eb71876 100644 --- a/src/repository.c +++ b/src/repository.c @@ -388,6 +388,19 @@ int git_repository_open(git_repository **repo_out, const char *path) repo_out, path, GIT_REPOSITORY_OPEN_NO_SEARCH, NULL); } +int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb) +{ + git_repository *repo; + + repo = repository_alloc(); + GITERR_CHECK_ALLOC(repo); + + git_repository_set_odb(repo, odb); + *repo_out = repo; + + return 0; +} + int git_repository_discover( char *repository_path, size_t size, @@ -1058,3 +1071,58 @@ int git_repository_head_tree(git_tree **tree, git_repository *repo) *tree = (git_tree *)obj; return 0; } + +#define MERGE_MSG_FILE "MERGE_MSG" + +int git_repository_message(char *buffer, size_t len, git_repository *repo) +{ + git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT; + struct stat st; + ssize_t size; + int error; + + if (git_buf_joinpath(&path, repo->path_repository, MERGE_MSG_FILE) < 0) + return -1; + + error = p_stat(git_buf_cstr(&path), &st); + if (error < 0) { + if (errno == ENOENT) + error = GIT_ENOTFOUND; + + git_buf_free(&path); + return error; + } + + if (buffer == NULL) { + git_buf_free(&path); + return st.st_size; + } + + if (git_futils_readbuffer(&buf, git_buf_cstr(&path)) < 0) + goto on_error; + + memcpy(buffer, git_buf_cstr(&buf), len); + size = git_buf_len(&buf); + + git_buf_free(&path); + git_buf_free(&buf); + return size; + +on_error: + git_buf_free(&path); + return -1; +} + +int git_repository_message_remove(git_repository *repo) +{ + git_buf path = GIT_BUF_INIT; + int error; + + if (git_buf_joinpath(&path, repo->path_repository, MERGE_MSG_FILE) < 0) + return -1; + + error = p_unlink(git_buf_cstr(&path)); + git_buf_free(&path); + + return error; +} diff --git a/src/revparse.c b/src/revparse.c index b0469286b..3855c29f1 100644 --- a/src/revparse.c +++ b/src/revparse.c @@ -328,7 +328,7 @@ static int retrieve_remote_tracking_reference(git_reference **base_ref, const ch *base_ref = NULL; } - if ((error = git_reference_remote_tracking_from_branch(&tracking, ref)) < 0) + if ((error = git_branch_tracking(&tracking, ref)) < 0) goto cleanup; *base_ref = tracking; @@ -338,7 +338,7 @@ cleanup: return error; } -static int handle_at_syntax(git_object **out, git_reference **ref, const char *spec, int identifier_len, git_repository* repo, const char *curly_braces_content) +static int handle_at_syntax(git_object **out, git_reference **ref, const char *spec, size_t identifier_len, git_repository* repo, const char *curly_braces_content) { bool is_numeric; int parsed = 0, error = -1; @@ -547,7 +547,7 @@ static int handle_caret_curly_syntax(git_object **out, git_object *obj, const ch return git_object_peel(out, obj, expected_type); } -static int extract_curly_braces_content(git_buf *buf, const char *spec, int *pos) +static int extract_curly_braces_content(git_buf *buf, const char *spec, size_t *pos) { git_buf_clear(buf); @@ -572,7 +572,7 @@ static int extract_curly_braces_content(git_buf *buf, const char *spec, int *pos return 0; } -static int extract_path(git_buf *buf, const char *spec, int *pos) +static int extract_path(git_buf *buf, const char *spec, size_t *pos) { git_buf_clear(buf); @@ -588,7 +588,7 @@ static int extract_path(git_buf *buf, const char *spec, int *pos) return 0; } -static int extract_how_many(int *n, const char *spec, int *pos) +static int extract_how_many(int *n, const char *spec, size_t *pos) { const char *end_ptr; int parsed, accumulated; @@ -633,7 +633,7 @@ static int object_from_reference(git_object **object, git_reference *reference) return error; } -static int ensure_base_rev_loaded(git_object **object, git_reference **reference, const char *spec, int identifier_len, git_repository *repo, bool allow_empty_identifier) +static int ensure_base_rev_loaded(git_object **object, git_reference **reference, const char *spec, size_t identifier_len, git_repository *repo, bool allow_empty_identifier) { int error; git_buf identifier = GIT_BUF_INIT; @@ -670,7 +670,7 @@ static int ensure_base_rev_is_not_known_yet(git_object *object, const char *spec return revspec_error(spec); } -static bool any_left_hand_identifier(git_object *object, git_reference *reference, int identifier_len) +static bool any_left_hand_identifier(git_object *object, git_reference *reference, size_t identifier_len) { if (object != NULL) return true; @@ -694,7 +694,7 @@ static int ensure_left_hand_identifier_is_not_known_yet(git_object *object, git_ int git_revparse_single(git_object **out, git_repository *repo, const char *spec) { - int pos = 0, identifier_len = 0; + size_t pos = 0, identifier_len = 0; int error = -1, n; git_buf buf = GIT_BUF_INIT; diff --git a/src/status.c b/src/status.c index 618f60fd0..8e462552e 100644 --- a/src/status.c +++ b/src/status.c @@ -81,7 +81,7 @@ int git_status_foreach_ext( git_status_show_t show = opts ? opts->show : GIT_STATUS_SHOW_INDEX_AND_WORKDIR; git_diff_delta *i2h, *w2i; - unsigned int i, j, i_max, j_max; + size_t i, j, i_max, j_max; assert(show <= GIT_STATUS_SHOW_INDEX_THEN_WORKDIR); diff --git a/src/transport.h b/src/transport.h index 68b92f7a6..c4306165c 100644 --- a/src/transport.h +++ b/src/transport.h @@ -12,6 +12,7 @@ #include "vector.h" #include "posix.h" #include "common.h" +#include "netops.h" #ifdef GIT_SSL # include <openssl/ssl.h> # include <openssl/err.h> @@ -19,10 +20,12 @@ #define GIT_CAP_OFS_DELTA "ofs-delta" +#define GIT_CAP_MULTI_ACK "multi_ack" typedef struct git_transport_caps { int common:1, - ofs_delta:1; + ofs_delta:1, + multi_ack: 1; } git_transport_caps; #ifdef GIT_SSL @@ -70,19 +73,25 @@ struct git_transport { int direction : 1, /* 0 fetch, 1 push */ connected : 1, check_cert: 1, - encrypt : 1; + use_ssl : 1, + own_logic: 1, /* transitional */ + rpc: 1; /* git-speak for the HTTP transport */ #ifdef GIT_SSL struct gitno_ssl ssl; #endif + git_vector refs; + git_vector common; + gitno_buffer buffer; GIT_SOCKET socket; + git_transport_caps caps; /** * Connect and store the remote heads */ int (*connect)(struct git_transport *transport, int dir); /** - * Give a list of references, useful for ls-remote + * Send our side of a negotiation */ - int (*ls)(struct git_transport *transport, git_headlist_cb list_cb, void *opaque); + int (*negotiation_step)(struct git_transport *transport, void *data, size_t len); /** * Push the changes over */ @@ -97,10 +106,6 @@ struct git_transport { */ int (*download_pack)(struct git_transport *transport, git_repository *repo, git_off_t *bytes, git_indexer_stats *stats); /** - * Fetch the changes - */ - int (*fetch)(struct git_transport *transport); - /** * Close the connection */ int (*close)(struct git_transport *transport); @@ -124,7 +129,6 @@ int git_transport_dummy(struct git_transport **transport); */ int git_transport_valid_url(const char *url); -typedef struct git_transport git_transport; typedef int (*git_transport_cb)(git_transport **transport); #endif diff --git a/src/transports/git.c b/src/transports/git.c index 0d0ec7821..7a65718f7 100644 --- a/src/transports/git.c +++ b/src/transports/git.c @@ -24,12 +24,7 @@ typedef struct { git_transport parent; - git_protocol proto; - git_vector refs; - git_remote_head **heads; - git_transport_caps caps; char buff[1024]; - gitno_buffer buf; #ifdef GIT_WIN32 WSADATA wsd; #endif @@ -127,68 +122,6 @@ on_error: } /* - * Read from the socket and store the references in the vector - */ -static int store_refs(transport_git *t) -{ - gitno_buffer *buf = &t->buf; - int ret = 0; - - while (1) { - if ((ret = gitno_recv(buf)) < 0) - return -1; - if (ret == 0) /* Orderly shutdown, so exit */ - return 0; - - ret = git_protocol_store_refs(&t->proto, buf->data, buf->offset); - if (ret == GIT_EBUFS) { - gitno_consume_n(buf, buf->len); - continue; - } - - if (ret < 0) - return ret; - - gitno_consume_n(buf, buf->offset); - - if (t->proto.flush) { /* No more refs */ - t->proto.flush = 0; - return 0; - } - } -} - -static int detect_caps(transport_git *t) -{ - git_vector *refs = &t->refs; - git_pkt_ref *pkt; - git_transport_caps *caps = &t->caps; - const char *ptr; - - pkt = git_vector_get(refs, 0); - /* No refs or capabilites, odd but not a problem */ - if (pkt == NULL || pkt->capabilities == NULL) - return 0; - - ptr = pkt->capabilities; - while (ptr != NULL && *ptr != '\0') { - if (*ptr == ' ') - ptr++; - - if(!git__prefixcmp(ptr, GIT_CAP_OFS_DELTA)) { - caps->common = caps->ofs_delta = 1; - ptr += strlen(GIT_CAP_OFS_DELTA); - continue; - } - - /* We don't know this capability, so skip it */ - ptr = strchr(ptr, ' '); - } - - return 0; -} - -/* * Since this is a network connection, we need to parse and store the * pkt-lines at this stage and keep them there. */ @@ -202,200 +135,26 @@ static int git_connect(git_transport *transport, int direction) } t->parent.direction = direction; - if (git_vector_init(&t->refs, 16, NULL) < 0) - return -1; /* Connect and ask for the refs */ if (do_connect(t, transport->url) < 0) - goto cleanup; + return -1; - gitno_buffer_setup(transport, &t->buf, t->buff, sizeof(t->buff)); + gitno_buffer_setup(transport, &transport->buffer, t->buff, sizeof(t->buff)); t->parent.connected = 1; - if (store_refs(t) < 0) - goto cleanup; - - if (detect_caps(t) < 0) - goto cleanup; - - return 0; -cleanup: - git_vector_free(&t->refs); - return -1; -} - -static int git_ls(git_transport *transport, git_headlist_cb list_cb, void *opaque) -{ - transport_git *t = (transport_git *) transport; - git_vector *refs = &t->refs; - unsigned int i; - git_pkt *p = NULL; - - git_vector_foreach(refs, i, p) { - git_pkt_ref *pkt = NULL; - - if (p->type != GIT_PKT_REF) - continue; - - pkt = (git_pkt_ref *)p; - - if (list_cb(&pkt->head, opaque)) - return GIT_EUSER; - } - - return 0; -} - -/* Wait until we get an ack from the */ -static int recv_pkt(gitno_buffer *buf) -{ - const char *ptr = buf->data, *line_end; - git_pkt *pkt; - int pkt_type, error; - - do { - /* Wait for max. 1 second */ - if ((error = gitno_select_in(buf, 1, 0)) < 0) { - return -1; - } else if (error == 0) { - /* - * Some servers don't respond immediately, so if this - * happens, we keep sending information until it - * answers. Pretend we received a NAK to convince higher - * layers to do so. - */ - return GIT_PKT_NAK; - } - - if ((error = gitno_recv(buf)) < 0) - return -1; - - error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->offset); - if (error == GIT_EBUFS) - continue; - if (error < 0) - return -1; - } while (error); - - gitno_consume(buf, line_end); - pkt_type = pkt->type; - git__free(pkt); - - return pkt_type; -} - -static int git_negotiate_fetch(git_transport *transport, git_repository *repo, const git_vector *wants) -{ - transport_git *t = (transport_git *) transport; - git_revwalk *walk; - git_oid oid; - int error; - unsigned int i; - git_buf data = GIT_BUF_INIT; - gitno_buffer *buf = &t->buf; - - if (git_pkt_buffer_wants(wants, &t->caps, &data) < 0) + if (git_protocol_store_refs(transport, 1) < 0) return -1; - if (git_fetch_setup_walk(&walk, repo) < 0) - goto on_error; - - if (gitno_send(transport, data.ptr, data.size, 0) < 0) - goto on_error; - - git_buf_clear(&data); - /* - * We don't support any kind of ACK extensions, so the negotiation - * boils down to sending what we have and listening for an ACK - * every once in a while. - */ - i = 0; - while ((error = git_revwalk_next(&oid, walk)) == 0) { - git_pkt_buffer_have(&oid, &data); - i++; - if (i % 20 == 0) { - int pkt_type; - - git_pkt_buffer_flush(&data); - if (git_buf_oom(&data)) - goto on_error; - - if (gitno_send(transport, data.ptr, data.size, 0) < 0) - goto on_error; - - pkt_type = recv_pkt(buf); - - if (pkt_type == GIT_PKT_ACK) { - break; - } else if (pkt_type == GIT_PKT_NAK) { - continue; - } else { - giterr_set(GITERR_NET, "Unexpected pkt type"); - goto on_error; - } - - } - } - if (error < 0 && error != GIT_REVWALKOVER) - goto on_error; - - /* Tell the other end that we're done negotiating */ - git_buf_clear(&data); - git_pkt_buffer_flush(&data); - git_pkt_buffer_done(&data); - if (gitno_send(transport, data.ptr, data.size, 0) < 0) - goto on_error; + if (git_protocol_detect_caps(git_vector_get(&transport->refs, 0), &transport->caps) < 0) + return -1; - git_buf_free(&data); - git_revwalk_free(walk); return 0; - -on_error: - git_buf_free(&data); - git_revwalk_free(walk); - return -1; } -static int git_download_pack(git_transport *transport, git_repository *repo, git_off_t *bytes, git_indexer_stats *stats) +static int git_negotiation_step(struct git_transport *transport, void *data, size_t len) { - transport_git *t = (transport_git *) transport; - int error = 0, read_bytes; - gitno_buffer *buf = &t->buf; - git_pkt *pkt; - const char *line_end, *ptr; - - /* - * For now, we ignore everything and wait for the pack - */ - do { - ptr = buf->data; - /* Whilst we're searching for the pack */ - while (1) { - if (buf->offset == 0) { - break; - } - - error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->offset); - if (error == GIT_EBUFS) - break; - - if (error < 0) - return error; - - if (pkt->type == GIT_PKT_PACK) { - git__free(pkt); - return git_fetch__download_pack(buf->data, buf->offset, transport, repo, bytes, stats); - } - - /* For now we don't care about anything */ - git__free(pkt); - gitno_consume(buf, line_end); - } - - read_bytes = gitno_recv(buf); - } while (read_bytes); - - return read_bytes; + return gitno_send(transport, data, len, 0); } static int git_close(git_transport *t) @@ -406,6 +165,7 @@ static int git_close(git_transport *t) return -1; /* Can't do anything if there's an error, so don't bother checking */ gitno_send(t, buf.ptr, buf.size, 0); + git_buf_free(&buf); if (gitno_close(t->socket) < 0) { giterr_set(GITERR_NET, "Failed to close socket"); @@ -424,17 +184,22 @@ static int git_close(git_transport *t) static void git_free(git_transport *transport) { transport_git *t = (transport_git *) transport; - git_vector *refs = &t->refs; + git_vector *refs = &transport->refs; unsigned int i; for (i = 0; i < refs->length; ++i) { git_pkt *p = git_vector_get(refs, i); git_pkt_free(p); } + git_vector_free(refs); + refs = &transport->common; + for (i = 0; i < refs->length; ++i) { + git_pkt *p = git_vector_get(refs, i); + git_pkt_free(p); + } git_vector_free(refs); - git__free(t->heads); - git_buf_free(&t->proto.buf); + git__free(t->parent.url); git__free(t); } @@ -450,15 +215,16 @@ int git_transport_git(git_transport **out) GITERR_CHECK_ALLOC(t); memset(t, 0x0, sizeof(transport_git)); + if (git_vector_init(&t->parent.common, 8, NULL)) + goto on_error; + + if (git_vector_init(&t->parent.refs, 16, NULL) < 0) + goto on_error; t->parent.connect = git_connect; - t->parent.ls = git_ls; - t->parent.negotiate_fetch = git_negotiate_fetch; - t->parent.download_pack = git_download_pack; + t->parent.negotiation_step = git_negotiation_step; t->parent.close = git_close; t->parent.free = git_free; - t->proto.refs = &t->refs; - t->proto.transport = (git_transport *) t; *out = (git_transport *) t; @@ -472,4 +238,8 @@ int git_transport_git(git_transport **out) #endif return 0; + +on_error: + git__free(t); + return -1; } diff --git a/src/transports/http.c b/src/transports/http.c index 993070aac..85fec413a 100644 --- a/src/transports/http.c +++ b/src/transports/http.c @@ -29,11 +29,8 @@ enum last_cb { typedef struct { git_transport parent; - git_protocol proto; - git_vector refs; - git_vector common; + http_parser_settings settings; git_buf buf; - git_remote_head **heads; int error; int transfer_finished :1, ct_found :1, @@ -46,7 +43,7 @@ typedef struct { char *host; char *port; char *service; - git_transport_caps caps; + char buffer[4096]; #ifdef GIT_WIN32 WSADATA wsd; #endif @@ -183,17 +180,6 @@ static int on_headers_complete(http_parser *parser) return 0; } -static int on_body_store_refs(http_parser *parser, const char *str, size_t len) -{ - transport_http *t = (transport_http *) parser->data; - - if (parser->status_code == 404) { - return git_buf_put(&t->buf, str, len); - } - - return git_protocol_store_refs(&t->proto, str, len); -} - static int on_message_complete(http_parser *parser) { transport_http *t = (transport_http *) parser->data; @@ -208,51 +194,64 @@ static int on_message_complete(http_parser *parser) return 0; } -static int store_refs(transport_http *t) +static int on_body_fill_buffer(http_parser *parser, const char *str, size_t len) { - http_parser_settings settings; - char buffer[1024]; - gitno_buffer buf; - git_pkt *pkt; - int ret; + git_transport *transport = (git_transport *) parser->data; + transport_http *t = (transport_http *) parser->data; + gitno_buffer *buf = &transport->buffer; - http_parser_init(&t->parser, HTTP_RESPONSE); - t->parser.data = t; - memset(&settings, 0x0, sizeof(http_parser_settings)); - settings.on_header_field = on_header_field; - settings.on_header_value = on_header_value; - settings.on_headers_complete = on_headers_complete; - settings.on_body = on_body_store_refs; - settings.on_message_complete = on_message_complete; + if (buf->len - buf->offset < len) { + giterr_set(GITERR_NET, "Can't fit data in the buffer"); + return t->error = -1; + } - gitno_buffer_setup((git_transport *)t, &buf, buffer, sizeof(buffer)); + memcpy(buf->data + buf->offset, str, len); + buf->offset += len; - while(1) { - size_t parsed; + return 0; +} - if ((ret = gitno_recv(&buf)) < 0) - return -1; +static int http_recv_cb(gitno_buffer *buf) +{ + git_transport *transport = (git_transport *) buf->cb_data; + transport_http *t = (transport_http *) transport; + size_t old_len; + gitno_buffer inner; + char buffer[2048]; + int error; - parsed = http_parser_execute(&t->parser, &settings, buf.data, buf.offset); - /* Both should happen at the same time */ - if (parsed != buf.offset || t->error < 0) - return t->error; + if (t->transfer_finished) + return 0; - gitno_consume_n(&buf, parsed); + gitno_buffer_setup(transport, &inner, buffer, sizeof(buffer)); - if (ret == 0 || t->transfer_finished) - return 0; - } + if ((error = gitno_recv(&inner)) < 0) + return -1; - pkt = git_vector_get(&t->refs, 0); - if (pkt == NULL || pkt->type != GIT_PKT_COMMENT) { - giterr_set(GITERR_NET, "Invalid HTTP response"); - return t->error = -1; - } else { - git_vector_remove(&t->refs, 0); - } + old_len = buf->offset; + http_parser_execute(&t->parser, &t->settings, inner.data, inner.offset); + if (t->error < 0) + return t->error; - return 0; + return buf->offset - old_len; +} + +/* Set up the gitno_buffer so calling gitno_recv() grabs data from the HTTP response */ +static void setup_gitno_buffer(git_transport *transport) +{ + transport_http *t = (transport_http *) transport; + + http_parser_init(&t->parser, HTTP_RESPONSE); + t->parser.data = t; + t->transfer_finished = 0; + memset(&t->settings, 0x0, sizeof(http_parser_settings)); + t->settings.on_header_field = on_header_field; + t->settings.on_header_value = on_header_value; + t->settings.on_headers_complete = on_headers_complete; + t->settings.on_body = on_body_fill_buffer; + t->settings.on_message_complete = on_message_complete; + + gitno_buffer_setup_callback(transport, &transport->buffer, t->buffer, sizeof(t->buffer), http_recv_cb, t); } static int http_connect(git_transport *transport, int direction) @@ -263,6 +262,7 @@ static int http_connect(git_transport *transport, int direction) const char *service = "upload-pack"; const char *url = t->parent.url, *prefix_http = "http://", *prefix_https = "https://"; const char *default_port; + git_pkt *pkt; if (direction == GIT_DIR_PUSH) { giterr_set(GITERR_NET, "Pushing over HTTP is not implemented"); @@ -270,8 +270,6 @@ static int http_connect(git_transport *transport, int direction) } t->parent.direction = direction; - if (git_vector_init(&t->refs, 16, NULL) < 0) - return -1; if (!git__prefixcmp(url, prefix_http)) { url = t->parent.url + strlen(prefix_http); @@ -304,305 +302,61 @@ static int http_connect(git_transport *transport, int direction) if (gitno_send(transport, request.ptr, request.size, 0) < 0) goto cleanup; - ret = store_refs(t); - -cleanup: - git_buf_free(&request); - git_buf_clear(&t->buf); - - return ret; -} - -static int http_ls(git_transport *transport, git_headlist_cb list_cb, void *opaque) -{ - transport_http *t = (transport_http *) transport; - git_vector *refs = &t->refs; - unsigned int i; - git_pkt_ref *p; - - git_vector_foreach(refs, i, p) { - if (p->type != GIT_PKT_REF) - continue; - - if (list_cb(&p->head, opaque)) - return GIT_EUSER; - } - - return 0; -} - -static int on_body_parse_response(http_parser *parser, const char *str, size_t len) -{ - transport_http *t = (transport_http *) parser->data; - git_buf *buf = &t->buf; - git_vector *common = &t->common; - int error; - const char *line_end, *ptr; - - if (len == 0) { /* EOF */ - if (git_buf_len(buf) != 0) { - giterr_set(GITERR_NET, "Unexpected EOF"); - return t->error = -1; - } else { - return 0; - } - } - - git_buf_put(buf, str, len); - ptr = buf->ptr; - while (1) { - git_pkt *pkt; - - if (git_buf_len(buf) == 0) - return 0; - - error = git_pkt_parse_line(&pkt, ptr, &line_end, git_buf_len(buf)); - if (error == GIT_EBUFS) { - return 0; /* Ask for more */ - } - if (error < 0) - return t->error = -1; - - git_buf_consume(buf, line_end); - - if (pkt->type == GIT_PKT_PACK) { - git__free(pkt); - t->pack_ready = 1; - return 0; - } - - if (pkt->type == GIT_PKT_NAK) { - git__free(pkt); - return 0; - } - - if (pkt->type != GIT_PKT_ACK) { - git__free(pkt); - continue; - } - - if (git_vector_insert(common, pkt) < 0) - return -1; - } - - return error; - -} - -static int parse_response(transport_http *t) -{ - int ret = 0; - http_parser_settings settings; - char buffer[1024]; - gitno_buffer buf; - - http_parser_init(&t->parser, HTTP_RESPONSE); - t->parser.data = t; - t->transfer_finished = 0; - memset(&settings, 0x0, sizeof(http_parser_settings)); - settings.on_header_field = on_header_field; - settings.on_header_value = on_header_value; - settings.on_headers_complete = on_headers_complete; - settings.on_body = on_body_parse_response; - settings.on_message_complete = on_message_complete; - - gitno_buffer_setup((git_transport *)t, &buf, buffer, sizeof(buffer)); - - while(1) { - size_t parsed; - - if ((ret = gitno_recv(&buf)) < 0) - return -1; - - parsed = http_parser_execute(&t->parser, &settings, buf.data, buf.offset); - /* Both should happen at the same time */ - if (parsed != buf.offset || t->error < 0) - return t->error; - - gitno_consume_n(&buf, parsed); + setup_gitno_buffer(transport); + if ((ret = git_protocol_store_refs(transport, 2)) < 0) + goto cleanup; - if (ret == 0 || t->transfer_finished || t->pack_ready) { - return 0; - } + pkt = git_vector_get(&transport->refs, 0); + if (pkt == NULL || pkt->type != GIT_PKT_COMMENT) { + giterr_set(GITERR_NET, "Invalid HTTP response"); + return t->error = -1; + } else { + /* Remove the comment and flush pkts */ + git_vector_remove(&transport->refs, 0); + git__free(pkt); + pkt = git_vector_get(&transport->refs, 0); + git_vector_remove(&transport->refs, 0); + git__free(pkt); } - return ret; -} - -static int http_negotiate_fetch(git_transport *transport, git_repository *repo, const git_vector *wants) -{ - transport_http *t = (transport_http *) transport; - int ret; - unsigned int i; - char buff[128]; - gitno_buffer buf; - git_revwalk *walk = NULL; - git_oid oid; - git_pkt_ack *pkt; - git_vector *common = &t->common; - git_buf request = GIT_BUF_INIT, data = GIT_BUF_INIT; - - gitno_buffer_setup(transport, &buf, buff, sizeof(buff)); - - if (git_vector_init(common, 16, NULL) < 0) - return -1; - - if (git_fetch_setup_walk(&walk, repo) < 0) - return -1; - - do { - if ((ret = do_connect(t, t->host, t->port)) < 0) - goto cleanup; - - if ((ret = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0) - goto cleanup; - - /* We need to send these on each connection */ - git_vector_foreach (common, i, pkt) { - if ((ret = git_pkt_buffer_have(&pkt->oid, &data)) < 0) - goto cleanup; - } - - i = 0; - while ((i < 20) && ((ret = git_revwalk_next(&oid, walk)) == 0)) { - if ((ret = git_pkt_buffer_have(&oid, &data)) < 0) - goto cleanup; - - i++; - } - - git_pkt_buffer_done(&data); - - if ((ret = gen_request(&request, t->path, t->host, "POST", "upload-pack", data.size, 0)) < 0) - goto cleanup; - - if ((ret = gitno_send(transport, request.ptr, request.size, 0)) < 0) - goto cleanup; - - if ((ret = gitno_send(transport, data.ptr, data.size, 0)) < 0) - goto cleanup; - - git_buf_clear(&request); - git_buf_clear(&data); - - if (ret < 0 || i >= 256) - break; - - if ((ret = parse_response(t)) < 0) - goto cleanup; - - if (t->pack_ready) { - ret = 0; - goto cleanup; - } - - } while(1); + if (git_protocol_detect_caps(git_vector_get(&transport->refs, 0), &transport->caps) < 0) + return t->error = -1; cleanup: git_buf_free(&request); - git_buf_free(&data); - git_revwalk_free(walk); - return ret; -} - -typedef struct { - git_indexer_stream *idx; - git_indexer_stats *stats; - transport_http *transport; -} download_pack_cbdata; - -static int on_message_complete_download_pack(http_parser *parser) -{ - download_pack_cbdata *data = (download_pack_cbdata *) parser->data; - - data->transport->transfer_finished = 1; - - return 0; -} -static int on_body_download_pack(http_parser *parser, const char *str, size_t len) -{ - download_pack_cbdata *data = (download_pack_cbdata *) parser->data; - transport_http *t = data->transport; - git_indexer_stream *idx = data->idx; - git_indexer_stats *stats = data->stats; + git_buf_clear(&t->buf); - return t->error = git_indexer_stream_add(idx, str, len, stats); + return ret; } -/* - * As the server is probably using Transfer-Encoding: chunked, we have - * to use the HTTP parser to download the pack instead of giving it to - * the simple downloader. Furthermore, we're using keep-alive - * connections, so the simple downloader would just hang. - */ -static int http_download_pack(git_transport *transport, git_repository *repo, git_off_t *bytes, git_indexer_stats *stats) +static int http_negotiation_step(struct git_transport *transport, void *data, size_t len) { transport_http *t = (transport_http *) transport; - git_buf *oldbuf = &t->buf; - int recvd; - http_parser_settings settings; - char buffer[1024]; - gitno_buffer buf; - git_buf path = GIT_BUF_INIT; - git_indexer_stream *idx = NULL; - download_pack_cbdata data; - - gitno_buffer_setup(transport, &buf, buffer, sizeof(buffer)); - - if (memcmp(oldbuf->ptr, "PACK", strlen("PACK"))) { - giterr_set(GITERR_NET, "The pack doesn't start with a pack signature"); - return -1; - } - - if (git_buf_joinpath(&path, git_repository_path(repo), "objects/pack") < 0) - return -1; + git_buf request = GIT_BUF_INIT; + int ret; - if (git_indexer_stream_new(&idx, git_buf_cstr(&path)) < 0) + /* First, send the data as a HTTP POST request */ + if ((ret = do_connect(t, t->host, t->port)) < 0) return -1; - /* - * This is part of the previous response, so we don't want to - * re-init the parser, just set these two callbacks. - */ - memset(stats, 0, sizeof(git_indexer_stats)); - data.stats = stats; - data.idx = idx; - data.transport = t; - t->parser.data = &data; - t->transfer_finished = 0; - memset(&settings, 0x0, sizeof(settings)); - settings.on_message_complete = on_message_complete_download_pack; - settings.on_body = on_body_download_pack; - *bytes = git_buf_len(oldbuf); - - if (git_indexer_stream_add(idx, git_buf_cstr(oldbuf), git_buf_len(oldbuf), stats) < 0) + if ((ret = gen_request(&request, t->path, t->host, "POST", "upload-pack", len, 0)) < 0) goto on_error; - gitno_buffer_setup(transport, &buf, buffer, sizeof(buffer)); - - do { - size_t parsed; - - if ((recvd = gitno_recv(&buf)) < 0) - goto on_error; + if ((ret = gitno_send(transport, request.ptr, request.size, 0)) < 0) + goto on_error; - parsed = http_parser_execute(&t->parser, &settings, buf.data, buf.offset); - if (parsed != buf.offset || t->error < 0) - goto on_error; + if ((ret = gitno_send(transport, data, len, 0)) < 0) + goto on_error; - *bytes += recvd; - gitno_consume_n(&buf, parsed); - } while (recvd > 0 && !t->transfer_finished); + git_buf_free(&request); - if (git_indexer_stream_finalize(idx, stats) < 0) - goto on_error; + /* Then we need to set up the buffer to grab data from the HTTP response */ + setup_gitno_buffer(transport); - git_indexer_stream_free(idx); return 0; on_error: - git_indexer_stream_free(idx); - git_buf_free(&path); + git_buf_free(&request); return -1; } @@ -625,8 +379,8 @@ static int http_close(git_transport *transport) static void http_free(git_transport *transport) { transport_http *t = (transport_http *) transport; - git_vector *refs = &t->refs; - git_vector *common = &t->common; + git_vector *refs = &transport->refs; + git_vector *common = &transport->common; unsigned int i; git_pkt *p; @@ -647,8 +401,6 @@ static void http_free(git_transport *transport) } git_vector_free(common); git_buf_free(&t->buf); - git_buf_free(&t->proto.buf); - git__free(t->heads); git__free(t->content_type); git__free(t->host); git__free(t->port); @@ -667,13 +419,15 @@ int git_transport_http(git_transport **out) memset(t, 0x0, sizeof(transport_http)); t->parent.connect = http_connect; - t->parent.ls = http_ls; - t->parent.negotiate_fetch = http_negotiate_fetch; - t->parent.download_pack = http_download_pack; + t->parent.negotiation_step = http_negotiation_step; t->parent.close = http_close; t->parent.free = http_free; - t->proto.refs = &t->refs; - t->proto.transport = (git_transport *) t; + t->parent.rpc = 1; + + if (git_vector_init(&t->parent.refs, 16, NULL) < 0) { + git__free(t); + return -1; + } #ifdef GIT_WIN32 /* on win32, the WSA context needs to be initialized @@ -696,7 +450,7 @@ int git_transport_https(git_transport **out) if (git_transport_http((git_transport **)&t) < 0) return -1; - t->parent.encrypt = 1; + t->parent.use_ssl = 1; t->parent.check_cert = 1; *out = (git_transport *) t; diff --git a/src/transports/local.c b/src/transports/local.c index ccbfb0492..561c84fa0 100644 --- a/src/transports/local.c +++ b/src/transports/local.c @@ -15,11 +15,11 @@ #include "posix.h" #include "path.h" #include "buffer.h" +#include "pkt.h" typedef struct { git_transport parent; git_repository *repo; - git_vector refs; } transport_local; static int add_ref(transport_local *t, const char *name) @@ -27,19 +27,32 @@ static int add_ref(transport_local *t, const char *name) const char peeled[] = "^{}"; git_remote_head *head; git_object *obj = NULL, *target = NULL; + git_transport *transport = (git_transport *) t; git_buf buf = GIT_BUF_INIT; + git_pkt_ref *pkt; head = git__malloc(sizeof(git_remote_head)); GITERR_CHECK_ALLOC(head); + pkt = git__malloc(sizeof(git_pkt_ref)); + GITERR_CHECK_ALLOC(pkt); head->name = git__strdup(name); GITERR_CHECK_ALLOC(head->name); - if (git_reference_name_to_oid(&head->oid, t->repo, name) < 0 || - git_vector_insert(&t->refs, head) < 0) - { - git__free(head->name); + if (git_reference_name_to_oid(&head->oid, t->repo, name) < 0) { git__free(head); + git__free(pkt->head.name); + git__free(pkt); + } + + pkt->type = GIT_PKT_REF; + memcpy(&pkt->head, head, sizeof(git_remote_head)); + git__free(head); + + if (git_vector_insert(&transport->refs, pkt) < 0) + { + git__free(pkt->head.name); + git__free(pkt); return -1; } @@ -47,7 +60,7 @@ static int add_ref(transport_local *t, const char *name) if (git__prefixcmp(name, GIT_REFS_TAGS_DIR)) return 0; - if (git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY) < 0) + if (git_object_lookup(&obj, t->repo, &pkt->head.oid, GIT_OBJ_ANY) < 0) return -1; head = NULL; @@ -66,14 +79,20 @@ static int add_ref(transport_local *t, const char *name) head->name = git_buf_detach(&buf); + pkt = git__malloc(sizeof(git_pkt_ref)); + GITERR_CHECK_ALLOC(pkt); + pkt->type = GIT_PKT_REF; + if (git_tag_peel(&target, (git_tag *) obj) < 0) goto on_error; git_oid_cpy(&head->oid, git_object_id(target)); git_object_free(obj); git_object_free(target); + memcpy(&pkt->head, head, sizeof(git_remote_head)); + git__free(head); - if (git_vector_insert(&t->refs, head) < 0) + if (git_vector_insert(&transport->refs, pkt) < 0) return -1; return 0; @@ -88,11 +107,12 @@ static int store_refs(transport_local *t) { unsigned int i; git_strarray ref_names = {0}; + git_transport *transport = (git_transport *) t; assert(t); if (git_reference_list(&ref_names, t->repo, GIT_REF_LISTALL) < 0 || - git_vector_init(&t->refs, (unsigned int)ref_names.count, NULL) < 0) + git_vector_init(&transport->refs, (unsigned int)ref_names.count, NULL) < 0) goto on_error; /* Sort the references first */ @@ -111,28 +131,11 @@ static int store_refs(transport_local *t) return 0; on_error: - git_vector_free(&t->refs); + git_vector_free(&transport->refs); git_strarray_free(&ref_names); return -1; } -static int local_ls(git_transport *transport, git_headlist_cb list_cb, void *payload) -{ - transport_local *t = (transport_local *) transport; - git_vector *refs = &t->refs; - unsigned int i; - git_remote_head *h; - - assert(transport && transport->connected); - - git_vector_foreach(refs, i, h) { - if (list_cb(h, payload)) - return GIT_EUSER; - } - - return 0; -} - /* * Try to open the url as a git directory. The direction doesn't * matter in this case because we're calulating the heads ourselves. @@ -201,14 +204,14 @@ static void local_free(git_transport *transport) { unsigned int i; transport_local *t = (transport_local *) transport; - git_vector *vec = &t->refs; - git_remote_head *h; + git_vector *vec = &transport->refs; + git_pkt_ref *pkt; assert(transport); - git_vector_foreach (vec, i, h) { - git__free(h->name); - git__free(h); + git_vector_foreach (vec, i, pkt) { + git__free(pkt->head.name); + git__free(pkt); } git_vector_free(vec); @@ -229,8 +232,8 @@ int git_transport_local(git_transport **out) memset(t, 0x0, sizeof(transport_local)); + t->parent.own_logic = 1; t->parent.connect = local_connect; - t->parent.ls = local_ls; t->parent.negotiate_fetch = local_negotiate_fetch; t->parent.close = local_close; t->parent.free = local_free; diff --git a/src/tree.c b/src/tree.c index 2e6153ba0..e5858b50e 100644 --- a/src/tree.c +++ b/src/tree.c @@ -234,7 +234,7 @@ const git_tree_entry *git_tree_entry_byname(git_tree *tree, const char *filename return entry_fromname(tree, filename, strlen(filename)); } -const git_tree_entry *git_tree_entry_byindex(git_tree *tree, unsigned int idx) +const git_tree_entry *git_tree_entry_byindex(git_tree *tree, size_t idx) { assert(tree); return git_vector_get(&tree->entries, idx); @@ -285,7 +285,7 @@ int git_tree__prefix_position(git_tree *tree, const char *path) unsigned int git_tree_entrycount(git_tree *tree) { assert(tree); - return tree->entries.length; + return (unsigned int)tree->entries.length; } static int tree_error(const char *str) @@ -516,7 +516,7 @@ static void sort_entries(git_treebuilder *bld) int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source) { git_treebuilder *bld; - unsigned int i, source_entries = DEFAULT_TREE_SIZE; + size_t i, source_entries = DEFAULT_TREE_SIZE; assert(builder_p); diff --git a/src/util.c b/src/util.c index 90bb3d02a..51bf843de 100644 --- a/src/util.c +++ b/src/util.c @@ -22,6 +22,18 @@ void git_libgit2_version(int *major, int *minor, int *rev) *rev = LIBGIT2_VER_REVISION; } +int git_libgit2_capabilities() +{ + return 0 +#ifdef GIT_THREADS + | GIT_CAP_THREADS +#endif +#ifdef GIT_SSL + | GIT_CAP_HTTPS +#endif + ; +} + void git_strarray_free(git_strarray *array) { size_t i; diff --git a/src/vector.c b/src/vector.c index 6f9aacccf..0308ce26e 100644 --- a/src/vector.c +++ b/src/vector.c @@ -35,7 +35,7 @@ void git_vector_free(git_vector *v) v->_alloc_size = 0; } -int git_vector_init(git_vector *v, unsigned int initial_size, git_vector_cmp cmp) +int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp) { assert(v); diff --git a/src/vector.h b/src/vector.h index 9139db345..f75e634ba 100644 --- a/src/vector.h +++ b/src/vector.h @@ -12,16 +12,16 @@ typedef int (*git_vector_cmp)(const void *, const void *); typedef struct git_vector { - unsigned int _alloc_size; + size_t _alloc_size; git_vector_cmp _cmp; void **contents; - unsigned int length; + size_t length; int sorted; } git_vector; #define GIT_VECTOR_INIT {0} -int git_vector_init(git_vector *v, unsigned int initial_size, git_vector_cmp cmp); +int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp); void git_vector_free(git_vector *v); void git_vector_clear(git_vector *v); void git_vector_swap(git_vector *a, git_vector *b); @@ -45,12 +45,12 @@ GIT_INLINE(int) git_vector_bsearch2( return git_vector_bsearch3(NULL, v, cmp, key); } -GIT_INLINE(void *) git_vector_get(git_vector *v, unsigned int position) +GIT_INLINE(void *) git_vector_get(git_vector *v, size_t position) { return (position < v->length) ? v->contents[position] : NULL; } -GIT_INLINE(const void *) git_vector_get_const(const git_vector *v, unsigned int position) +GIT_INLINE(const void *) git_vector_get_const(const git_vector *v, size_t position) { return (position < v->length) ? v->contents[position] : NULL; } diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c index 4e0150fb5..e1471cab4 100644 --- a/src/win32/posix_w32.c +++ b/src/win32/posix_w32.c @@ -60,6 +60,7 @@ GIT_INLINE(time_t) filetime_to_time_t(const FILETIME *ft) static int do_lstat(const char *file_name, struct stat *buf) { WIN32_FILE_ATTRIBUTE_DATA fdata; + DWORD last_error; wchar_t* fbuf = gitwin_to_utf16(file_name); if (!fbuf) return -1; @@ -93,6 +94,12 @@ static int do_lstat(const char *file_name, struct stat *buf) return 0; } + last_error = GetLastError(); + if (last_error == ERROR_FILE_NOT_FOUND) + errno = ENOENT; + else if (last_error == ERROR_PATH_NOT_FOUND) + errno = ENOTDIR; + git__free(fbuf); return -1; } diff --git a/tests-clar/diff/diff_helpers.c b/tests-clar/diff/diff_helpers.c index 1d9f6121c..18daa080b 100644 --- a/tests-clar/diff/diff_helpers.c +++ b/tests-clar/diff/diff_helpers.c @@ -5,7 +5,7 @@ git_tree *resolve_commit_oid_to_tree( git_repository *repo, const char *partial_oid) { - unsigned int len = (unsigned int)strlen(partial_oid); + size_t len = strlen(partial_oid); git_oid oid; git_object *obj = NULL; git_tree *tree = NULL; diff --git a/tests-clar/network/remotelocal.c b/tests-clar/network/remotelocal.c index 5e20b4240..16e3fe2dd 100644 --- a/tests-clar/network/remotelocal.c +++ b/tests-clar/network/remotelocal.c @@ -107,7 +107,7 @@ void test_network_remotelocal__retrieve_advertised_references(void) cl_git_pass(git_remote_ls(remote, &count_ref__cb, &how_many_refs)); - cl_assert_equal_i(how_many_refs, 22); + cl_assert_equal_i(how_many_refs, 23); } void test_network_remotelocal__retrieve_advertised_references_from_spaced_repository(void) @@ -121,7 +121,7 @@ void test_network_remotelocal__retrieve_advertised_references_from_spaced_reposi cl_git_pass(git_remote_ls(remote, &count_ref__cb, &how_many_refs)); - cl_assert_equal_i(how_many_refs, 22); + cl_assert_equal_i(how_many_refs, 23); git_remote_free(remote); /* Disconnect from the "spaced repo" before the cleanup */ remote = NULL; diff --git a/tests-clar/network/remotes.c b/tests-clar/network/remotes.c index eb7947dfb..f1d6f47c6 100644 --- a/tests-clar/network/remotes.c +++ b/tests-clar/network/remotes.c @@ -2,6 +2,7 @@ #include "buffer.h" #include "refspec.h" #include "transport.h" +#include "remote.h" static git_remote *_remote; static git_repository *_repo; @@ -27,8 +28,37 @@ void test_network_remotes__cleanup(void) void test_network_remotes__parsing(void) { + git_remote *_remote2 = NULL; + cl_assert_equal_s(git_remote_name(_remote), "test"); cl_assert_equal_s(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); + cl_assert(git_remote_pushurl(_remote) == NULL); + + cl_assert_equal_s(git_remote__urlfordirection(_remote, GIT_DIR_FETCH), + "git://github.com/libgit2/libgit2"); + cl_assert_equal_s(git_remote__urlfordirection(_remote, GIT_DIR_PUSH), + "git://github.com/libgit2/libgit2"); + + cl_git_pass(git_remote_load(&_remote2, _repo, "test_with_pushurl")); + cl_assert_equal_s(git_remote_name(_remote2), "test_with_pushurl"); + cl_assert_equal_s(git_remote_url(_remote2), "git://github.com/libgit2/fetchlibgit2"); + cl_assert_equal_s(git_remote_pushurl(_remote2), "git://github.com/libgit2/pushlibgit2"); + + cl_assert_equal_s(git_remote__urlfordirection(_remote2, GIT_DIR_FETCH), + "git://github.com/libgit2/fetchlibgit2"); + cl_assert_equal_s(git_remote__urlfordirection(_remote2, GIT_DIR_PUSH), + "git://github.com/libgit2/pushlibgit2"); + + git_remote_free(_remote2); +} + +void test_network_remotes__pushurl(void) +{ + cl_git_pass(git_remote_set_pushurl(_remote, "git://github.com/libgit2/notlibgit2")); + cl_assert_equal_s(git_remote_pushurl(_remote), "git://github.com/libgit2/notlibgit2"); + + cl_git_pass(git_remote_set_pushurl(_remote, NULL)); + cl_assert(git_remote_pushurl(_remote) == NULL); } void test_network_remotes__parsing_ssh_remote(void) @@ -81,6 +111,7 @@ void test_network_remotes__save(void) cl_git_pass(git_remote_new(&_remote, _repo, "upstream", "git://github.com/libgit2/libgit2", NULL)); cl_git_pass(git_remote_set_fetchspec(_remote, "refs/heads/*:refs/remotes/upstream/*")); cl_git_pass(git_remote_set_pushspec(_remote, "refs/heads/*:refs/heads/*")); + cl_git_pass(git_remote_set_pushurl(_remote, "git://github.com/libgit2/libgit2_push")); cl_git_pass(git_remote_save(_remote)); git_remote_free(_remote); _remote = NULL; @@ -98,6 +129,18 @@ void test_network_remotes__save(void) cl_assert(_refspec != NULL); cl_assert_equal_s(git_refspec_src(_refspec), "refs/heads/*"); cl_assert_equal_s(git_refspec_dst(_refspec), "refs/heads/*"); + + cl_assert_equal_s(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); + cl_assert_equal_s(git_remote_pushurl(_remote), "git://github.com/libgit2/libgit2_push"); + + /* remove the pushurl again and see if we can save that too */ + cl_git_pass(git_remote_set_pushurl(_remote, NULL)); + cl_git_pass(git_remote_save(_remote)); + git_remote_free(_remote); + _remote = NULL; + + cl_git_pass(git_remote_load(&_remote, _repo, "upstream")); + cl_assert(git_remote_pushurl(_remote) == NULL); } void test_network_remotes__fnmatch(void) @@ -143,13 +186,13 @@ void test_network_remotes__list(void) git_config *cfg; cl_git_pass(git_remote_list(&list, _repo)); - cl_assert(list.count == 1); + cl_assert(list.count == 2); git_strarray_free(&list); cl_git_pass(git_repository_config(&cfg, _repo)); cl_git_pass(git_config_set_string(cfg, "remote.specless.url", "http://example.com")); cl_git_pass(git_remote_list(&list, _repo)); - cl_assert(list.count == 2); + cl_assert(list.count == 3); git_strarray_free(&list); git_config_free(cfg); @@ -180,4 +223,5 @@ void test_network_remotes__add(void) cl_assert(!strcmp(git_refspec_src(_refspec), "refs/heads/*")); cl_assert(git_refspec_force(_refspec) == 1); cl_assert(!strcmp(git_refspec_dst(_refspec), "refs/remotes/addtest/*")); + cl_assert_equal_s(git_remote_url(_remote), "http://github.com/libgit2/libgit2"); } diff --git a/tests-clar/object/blob/fromchunks.c b/tests-clar/object/blob/fromchunks.c index 228e969b6..dc57d4fbe 100644 --- a/tests-clar/object/blob/fromchunks.c +++ b/tests-clar/object/blob/fromchunks.c @@ -30,7 +30,7 @@ static int text_chunked_source_cb(char *content, size_t max_length, void *payloa return 0; strcpy(content, textual_content); - return strlen(textual_content); + return (int)strlen(textual_content); } void test_object_blob_fromchunks__can_create_a_blob_from_a_in_memory_chunk_provider(void) diff --git a/tests-clar/odb/foreach.c b/tests-clar/odb/foreach.c index e025fa210..802935a5c 100644 --- a/tests-clar/odb/foreach.c +++ b/tests-clar/odb/foreach.c @@ -7,12 +7,6 @@ static git_odb *_odb; static git_repository *_repo; static int nobj; -void test_odb_foreach__initialize(void) -{ - cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git"))); - git_repository_odb(&_odb, _repo); -} - void test_odb_foreach__cleanup(void) { git_odb_free(_odb); @@ -29,11 +23,37 @@ static int foreach_cb(git_oid *oid, void *data) return 0; } +/* + * $ git --git-dir tests-clar/resources/testrepo.git count-objects --verbose + * count: 43 + * size: 3 + * in-pack: 1640 + * packs: 3 + * size-pack: 425 + * prune-packable: 0 + * garbage: 0 + */ void test_odb_foreach__foreach(void) { + cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git"))); + git_repository_odb(&_odb, _repo); + + cl_git_pass(git_odb_foreach(_odb, foreach_cb, NULL)); + cl_assert_equal_i(43 + 1640, nobj); /* count + in-pack */ +} + +void test_odb_foreach__one_pack(void) +{ + git_odb_backend *backend = NULL; + + cl_git_pass(git_odb_new(&_odb)); + cl_git_pass(git_odb_backend_one_pack(&backend, cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); + cl_git_pass(git_odb_add_backend(_odb, backend, 1)); + _repo = NULL; + nobj = 0; cl_git_pass(git_odb_foreach(_odb, foreach_cb, NULL)); - cl_assert(nobj == 1683); + cl_assert(nobj == 1628); } static int foreach_stop_cb(git_oid *oid, void *data) diff --git a/tests-clar/odb/pack_data_one.h b/tests-clar/odb/pack_data_one.h new file mode 100644 index 000000000..13570ba78 --- /dev/null +++ b/tests-clar/odb/pack_data_one.h @@ -0,0 +1,19 @@ +/* Just a few to make sure it's working, the rest is tested already */ +static const char *packed_objects_one[] = { + "9fcf811e00fa469688943a9152c16d4ee90fb9a9", + "a93f42a5b5e9de40fa645a9ff1e276a021c9542b", + "12bf5f3e3470d90db177ccf1b5e8126409377fc6", + "ed1ea164cdbe3c4b200fb4fa19861ea90eaee222", + "dfae6ed8f6dd8acc3b40a31811ea316239223559", + "aefe66d192771201e369fde830530f4475beec30", + "775e4b4c1296e9e3104f2a36ca9cf9356a130959", + "412ec4e4a6a7419bc1be00561fe474e54cb499fe", + "236e7579fed7763be77209efb8708960982f3cb3", + "09fe9364461cf60dd1c46b0e9545b1e47bb1a297", + "d76d8a6390d1cf32138d98a91b1eb7e0275a12f5", + "d0fdf2dcff2f548952eec536ccc6d266550041bc", + "a20d733a9fa79fa5b4cbb9639864f93325ec27a6", + "785d3fe8e7db5ade2c2242fecd46c32a7f4dc59f", + "4d8d0fd9cb6045075385701c3f933ec13345e9c4", + "0cfd861bd547b6520d1fc2e190e8359e0a9c9b90" +}; diff --git a/tests-clar/odb/packed_one.c b/tests-clar/odb/packed_one.c new file mode 100644 index 000000000..a064829dd --- /dev/null +++ b/tests-clar/odb/packed_one.c @@ -0,0 +1,58 @@ +#include "clar_libgit2.h" +#include "odb.h" +#include "pack_data_one.h" +#include "pack.h" + +static git_odb *_odb; + +void test_odb_packed_one__initialize(void) +{ + git_odb_backend *backend = NULL; + + cl_git_pass(git_odb_new(&_odb)); + cl_git_pass(git_odb_backend_one_pack(&backend, cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); + cl_git_pass(git_odb_add_backend(_odb, backend, 1)); +} + +void test_odb_packed_one__cleanup(void) +{ + git_odb_free(_odb); +} + +void test_odb_packed_one__mass_read(void) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_one); ++i) { + git_oid id; + git_odb_object *obj; + + cl_git_pass(git_oid_fromstr(&id, packed_objects_one[i])); + cl_assert(git_odb_exists(_odb, &id) == 1); + cl_git_pass(git_odb_read(&obj, _odb, &id)); + + git_odb_object_free(obj); + } +} + +void test_odb_packed_one__read_header_0(void) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_one); ++i) { + git_oid id; + git_odb_object *obj; + size_t len; + git_otype type; + + cl_git_pass(git_oid_fromstr(&id, packed_objects_one[i])); + + cl_git_pass(git_odb_read(&obj, _odb, &id)); + cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); + + cl_assert(obj->raw.len == len); + cl_assert(obj->raw.type == type); + + git_odb_object_free(obj); + } +} diff --git a/tests-clar/refs/branches/create.c b/tests-clar/refs/branches/create.c index ad7e1fd2c..fe72d4708 100644 --- a/tests-clar/refs/branches/create.c +++ b/tests-clar/refs/branches/create.c @@ -1,19 +1,22 @@ #include "clar_libgit2.h" #include "refs.h" -#include "branch.h" static git_repository *repo; -static git_oid branch_target_oid; static git_object *target; +static git_reference *branch; void test_refs_branches_create__initialize(void) { cl_fixture_sandbox("testrepo.git"); cl_git_pass(git_repository_open(&repo, "testrepo.git")); + + branch = NULL; } void test_refs_branches_create__cleanup(void) { + git_reference_free(branch); + git_object_free(target); git_repository_free(repo); @@ -39,54 +42,24 @@ void test_refs_branches_create__can_create_a_local_branch(void) { retrieve_known_commit(&target, repo); - cl_git_pass(git_branch_create(&branch_target_oid, repo, NEW_BRANCH_NAME, target, 0)); - cl_git_pass(git_oid_cmp(&branch_target_oid, git_object_id(target))); -} - -void test_refs_branches_create__creating_a_local_branch_triggers_the_creation_of_a_new_direct_reference(void) -{ - git_reference *branch; - - retrieve_known_commit(&target, repo); - - cl_git_fail(git_reference_lookup(&branch, repo, GIT_REFS_HEADS_DIR NEW_BRANCH_NAME)); - - cl_git_pass(git_branch_create(&branch_target_oid, repo, NEW_BRANCH_NAME, target, 0)); - - cl_git_pass(git_reference_lookup(&branch, repo, GIT_REFS_HEADS_DIR NEW_BRANCH_NAME)); - cl_assert(git_reference_type(branch) == GIT_REF_OID); - - git_reference_free(branch); + cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0)); + cl_git_pass(git_oid_cmp(git_reference_oid(branch), git_object_id(target))); } void test_refs_branches_create__can_not_create_a_branch_if_its_name_collide_with_an_existing_one(void) { retrieve_known_commit(&target, repo); - cl_git_fail(git_branch_create(&branch_target_oid, repo, "br2", target, 0)); + cl_git_fail(git_branch_create(&branch, repo, "br2", target, 0)); } void test_refs_branches_create__can_force_create_over_an_existing_branch(void) { retrieve_known_commit(&target, repo); - cl_git_pass(git_branch_create(&branch_target_oid, repo, "br2", target, 1)); - cl_git_pass(git_oid_cmp(&branch_target_oid, git_object_id(target))); -} - -void test_refs_branches_create__can_not_create_a_branch_pointing_at_an_object_unknown_from_the_repository(void) -{ - git_repository *repo2; - - /* Open another instance of the same repository */ - cl_git_pass(git_repository_open(&repo2, cl_fixture("testrepo.git"))); - - /* Retrieve a commit object from this different repository */ - retrieve_known_commit(&target, repo2); - - cl_git_fail(git_branch_create(&branch_target_oid, repo, NEW_BRANCH_NAME, target, 0)); - - git_repository_free(repo2); + cl_git_pass(git_branch_create(&branch, repo, "br2", target, 1)); + cl_git_pass(git_oid_cmp(git_reference_oid(branch), git_object_id(target))); + cl_assert_equal_s("refs/heads/br2", git_reference_name(branch)); } void test_refs_branches_create__creating_a_branch_targeting_a_tag_dereferences_it_to_its_commit(void) @@ -94,8 +67,8 @@ void test_refs_branches_create__creating_a_branch_targeting_a_tag_dereferences_i /* b25fa35 is a tag, pointing to another tag which points to a commit */ retrieve_target_from_oid(&target, repo, "b25fa35b38051e4ae45d4222e795f9df2e43f1d1"); - cl_git_pass(git_branch_create(&branch_target_oid, repo, NEW_BRANCH_NAME, target, 0)); - cl_git_pass(git_oid_streq(&branch_target_oid, "e90810b8df3e80c413d903f631643c716887138d")); + cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0)); + cl_git_pass(git_oid_streq(git_reference_oid(branch), "e90810b8df3e80c413d903f631643c716887138d")); } void test_refs_branches_create__can_not_create_a_branch_pointing_to_a_non_commit_object(void) @@ -103,11 +76,11 @@ void test_refs_branches_create__can_not_create_a_branch_pointing_to_a_non_commit /* 53fc32d is the tree of commit e90810b */ retrieve_target_from_oid(&target, repo, "53fc32d17276939fc79ed05badaef2db09990016"); - cl_git_fail(git_branch_create(&branch_target_oid, repo, NEW_BRANCH_NAME, target, 0)); + cl_git_fail(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0)); git_object_free(target); /* 521d87c is an annotated tag pointing to a blob */ retrieve_target_from_oid(&target, repo, "521d87c1ec3aef9824daf6d96cc0ae3710766d91"); - cl_git_fail(git_branch_create(&branch_target_oid, repo, NEW_BRANCH_NAME, target, 0)); + cl_git_fail(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0)); } diff --git a/tests-clar/refs/branches/delete.c b/tests-clar/refs/branches/delete.c index 03d3c56d7..699655f27 100644 --- a/tests-clar/refs/branches/delete.c +++ b/tests-clar/refs/branches/delete.c @@ -1,6 +1,5 @@ #include "clar_libgit2.h" #include "refs.h" -#include "branch.h" static git_repository *repo; static git_reference *fake_remote; diff --git a/tests-clar/refs/branches/foreach.c b/tests-clar/refs/branches/foreach.c index 8b39b7dc8..79c7e59e4 100644 --- a/tests-clar/refs/branches/foreach.c +++ b/tests-clar/refs/branches/foreach.c @@ -1,6 +1,5 @@ #include "clar_libgit2.h" #include "refs.h" -#include "branch.h" static git_repository *repo; static git_reference *fake_remote; @@ -48,7 +47,7 @@ static void assert_retrieval(unsigned int flags, unsigned int expected_count) void test_refs_branches_foreach__retrieve_all_branches(void) { - assert_retrieval(GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE, 10); + assert_retrieval(GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE, 11); } void test_refs_branches_foreach__retrieve_remote_branches(void) @@ -58,7 +57,7 @@ void test_refs_branches_foreach__retrieve_remote_branches(void) void test_refs_branches_foreach__retrieve_local_branches(void) { - assert_retrieval(GIT_BRANCH_LOCAL, 8); + assert_retrieval(GIT_BRANCH_LOCAL, 9); } struct expectations { diff --git a/tests-clar/refs/branches/lookup.c b/tests-clar/refs/branches/lookup.c new file mode 100644 index 000000000..2aabf9889 --- /dev/null +++ b/tests-clar/refs/branches/lookup.c @@ -0,0 +1,35 @@ +#include "clar_libgit2.h" +#include "refs.h" + +static git_repository *repo; +static git_reference *branch; + +void test_refs_branches_lookup__initialize(void) +{ + cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); + + branch = NULL; +} + +void test_refs_branches_lookup__cleanup(void) +{ + git_reference_free(branch); + + git_repository_free(repo); +} + +void test_refs_branches_lookup__can_retrieve_a_local_branch(void) +{ + cl_git_pass(git_branch_lookup(&branch, repo, "br2", GIT_BRANCH_LOCAL)); +} + +void test_refs_branches_lookup__can_retrieve_a_remote_tracking_branch(void) +{ + cl_git_pass(git_branch_lookup(&branch, repo, "test/master", GIT_BRANCH_REMOTE)); +} + +void test_refs_branches_lookup__trying_to_retrieve_an_unknown_branch_returns_ENOTFOUND(void) +{ + cl_assert_equal_i(GIT_ENOTFOUND, git_branch_lookup(&branch, repo, "where/are/you", GIT_BRANCH_LOCAL)); + cl_assert_equal_i(GIT_ENOTFOUND, git_branch_lookup(&branch, repo, "over/here", GIT_BRANCH_REMOTE)); +} diff --git a/tests-clar/refs/branches/move.c b/tests-clar/refs/branches/move.c index 242e5cd01..6750473e1 100644 --- a/tests-clar/refs/branches/move.c +++ b/tests-clar/refs/branches/move.c @@ -1,72 +1,64 @@ #include "clar_libgit2.h" -#include "branch.h" +#include "refs.h" static git_repository *repo; +static git_reference *ref; void test_refs_branches_move__initialize(void) { - cl_fixture_sandbox("testrepo.git"); - cl_git_pass(git_repository_open(&repo, "testrepo.git")); + repo = cl_git_sandbox_init("testrepo.git"); + + cl_git_pass(git_reference_lookup(&ref, repo, "refs/heads/br2")); } void test_refs_branches_move__cleanup(void) { - git_repository_free(repo); - - cl_fixture_cleanup("testrepo.git"); + git_reference_free(ref); + cl_git_sandbox_cleanup(); } #define NEW_BRANCH_NAME "new-branch-on-the-block" void test_refs_branches_move__can_move_a_local_branch(void) { - cl_git_pass(git_branch_move(repo, "br2", NEW_BRANCH_NAME, 0)); + cl_git_pass(git_branch_move(ref, NEW_BRANCH_NAME, 0)); + cl_assert_equal_s(GIT_REFS_HEADS_DIR NEW_BRANCH_NAME, git_reference_name(ref)); } void test_refs_branches_move__can_move_a_local_branch_to_a_different_namespace(void) { /* Downward */ - cl_git_pass(git_branch_move(repo, "br2", "somewhere/" NEW_BRANCH_NAME, 0)); + cl_git_pass(git_branch_move(ref, "somewhere/" NEW_BRANCH_NAME, 0)); /* Upward */ - cl_git_pass(git_branch_move(repo, "somewhere/" NEW_BRANCH_NAME, "br2", 0)); + cl_git_pass(git_branch_move(ref, "br2", 0)); } void test_refs_branches_move__can_move_a_local_branch_to_a_partially_colliding_namespace(void) { /* Downward */ - cl_git_pass(git_branch_move(repo, "br2", "br2/" NEW_BRANCH_NAME, 0)); + cl_git_pass(git_branch_move(ref, "br2/" NEW_BRANCH_NAME, 0)); /* Upward */ - cl_git_pass(git_branch_move(repo, "br2/" NEW_BRANCH_NAME, "br2", 0)); + cl_git_pass(git_branch_move(ref, "br2", 0)); } void test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_collide_with_an_existing_one(void) { - cl_git_fail(git_branch_move(repo, "br2", "master", 0)); + cl_git_fail(git_branch_move(ref, "master", 0)); } -void test_refs_branches_move__can_not_move_a_non_existing_branch(void) +void test_refs_branches_move__can_not_move_a_non_branch(void) { - cl_git_fail(git_branch_move(repo, "i-am-no-branch", NEW_BRANCH_NAME, 0)); -} + git_reference *tag; -void test_refs_branches_move__can_force_move_over_an_existing_branch(void) -{ - cl_git_pass(git_branch_move(repo, "br2", "master", 1)); -} + cl_git_pass(git_reference_lookup(&tag, repo, "refs/tags/e90810b")); + cl_git_fail(git_branch_move(tag, NEW_BRANCH_NAME, 0)); -void test_refs_branches_move__can_not_move_a_branch_through_its_canonical_name(void) -{ - cl_git_fail(git_branch_move(repo, "refs/heads/br2", NEW_BRANCH_NAME, 1)); + git_reference_free(tag); } -void test_refs_branches_move__moving_a_non_exisiting_branch_returns_ENOTFOUND(void) +void test_refs_branches_move__can_force_move_over_an_existing_branch(void) { - int error; - - error = git_branch_move(repo, "where/am/I", NEW_BRANCH_NAME, 0); - cl_git_fail(error); - - cl_assert_equal_i(GIT_ENOTFOUND, error); + cl_git_pass(git_branch_move(ref, "master", 1)); } diff --git a/tests-clar/refs/branches/tracking.c b/tests-clar/refs/branches/tracking.c new file mode 100644 index 000000000..8f7019437 --- /dev/null +++ b/tests-clar/refs/branches/tracking.c @@ -0,0 +1,69 @@ +#include "clar_libgit2.h" +#include "refs.h" + +static git_repository *repo; +static git_reference *branch; + +void test_refs_branches_tracking__initialize(void) +{ + cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); + + branch = NULL; +} + +void test_refs_branches_tracking__cleanup(void) +{ + git_reference_free(branch); + + git_repository_free(repo); +} + +void test_refs_branches_tracking__can_retrieve_the_remote_tracking_reference_of_a_local_branch(void) +{ + git_reference *branch, *tracking; + + cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master")); + + cl_git_pass(git_branch_tracking(&tracking, branch)); + + cl_assert_equal_s("refs/remotes/test/master", git_reference_name(tracking)); + + git_reference_free(branch); + git_reference_free(tracking); +} + +void test_refs_branches_tracking__can_retrieve_the_local_tracking_reference_of_a_local_branch(void) +{ + git_reference *branch, *tracking; + + cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/track-local")); + + cl_git_pass(git_branch_tracking(&tracking, branch)); + + cl_assert_equal_s("refs/heads/master", git_reference_name(tracking)); + + git_reference_free(branch); + git_reference_free(tracking); +} + +void test_refs_branches_tracking__cannot_retrieve_a_remote_tracking_reference_from_a_non_branch(void) +{ + git_reference *branch, *tracking; + + cl_git_pass(git_reference_lookup(&branch, repo, "refs/tags/e90810b")); + + cl_git_fail(git_branch_tracking(&tracking, branch)); + + git_reference_free(branch); +} + +void test_refs_branches_tracking__trying_to_retrieve_a_remote_tracking_reference_from_a_plain_local_branch_returns_GIT_ENOTFOUND(void) +{ + git_reference *branch, *tracking; + + cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/subtrees")); + + cl_assert_equal_i(GIT_ENOTFOUND, git_branch_tracking(&tracking, branch)); + + git_reference_free(branch); +} diff --git a/tests-clar/refs/foreachglob.c b/tests-clar/refs/foreachglob.c index 7d514d461..66827e525 100644 --- a/tests-clar/refs/foreachglob.c +++ b/tests-clar/refs/foreachglob.c @@ -46,7 +46,7 @@ static void assert_retrieval(const char *glob, unsigned int flags, int expected_ void test_refs_foreachglob__retrieve_all_refs(void) { /* 7 heads (including one packed head) + 1 note + 2 remotes + 6 tags */ - assert_retrieval("*", GIT_REF_LISTALL, 17); + assert_retrieval("*", GIT_REF_LISTALL, 18); } void test_refs_foreachglob__retrieve_remote_branches(void) @@ -56,7 +56,7 @@ void test_refs_foreachglob__retrieve_remote_branches(void) void test_refs_foreachglob__retrieve_local_branches(void) { - assert_retrieval("refs/heads/*", GIT_REF_LISTALL, 8); + assert_retrieval("refs/heads/*", GIT_REF_LISTALL, 9); } void test_refs_foreachglob__retrieve_partially_named_references(void) diff --git a/tests-clar/refs/read.c b/tests-clar/refs/read.c index ce4eefeba..1948e0a56 100644 --- a/tests-clar/refs/read.c +++ b/tests-clar/refs/read.c @@ -202,3 +202,19 @@ void test_refs_read__unfound_return_ENOTFOUND(void) cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&reference, g_repo, "refs/tags/test/master")); cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&reference, g_repo, "refs/tags/test/farther/master")); } + +static void assert_is_branch(const char *name, bool expected_branchness) +{ + git_reference *reference; + cl_git_pass(git_reference_lookup(&reference, g_repo, name)); + cl_assert_equal_i(expected_branchness, git_reference_is_branch(reference)); + git_reference_free(reference); +} + +void test_refs_read__can_determine_if_a_reference_is_a_local_branch(void) +{ + assert_is_branch("refs/heads/master", true); + assert_is_branch("refs/heads/packed", true); + assert_is_branch("refs/remotes/test/master", false); + assert_is_branch("refs/tags/e90810b", false); +} diff --git a/tests-clar/refs/reflog/drop.c b/tests-clar/refs/reflog/drop.c new file mode 100644 index 000000000..86781c041 --- /dev/null +++ b/tests-clar/refs/reflog/drop.c @@ -0,0 +1,130 @@ +#include "clar_libgit2.h" + +#include "reflog.h" + +static git_repository *g_repo; +static git_reflog *g_reflog; +static unsigned int entrycount; + +void test_refs_reflog_drop__initialize(void) +{ + git_reference *ref; + + g_repo = cl_git_sandbox_init("testrepo.git"); + cl_git_pass(git_reference_lookup(&ref, g_repo, "HEAD")); + + git_reflog_read(&g_reflog, ref); + entrycount = git_reflog_entrycount(g_reflog); + + git_reference_free(ref); +} + +void test_refs_reflog_drop__cleanup(void) +{ + git_reflog_free(g_reflog); + + cl_git_sandbox_cleanup(); +} + +void test_refs_reflog_drop__dropping_a_non_exisiting_entry_from_the_log_returns_ENOTFOUND(void) +{ + cl_assert_equal_i(GIT_ENOTFOUND, git_reflog_drop(g_reflog, entrycount, 0)); + + cl_assert_equal_i(entrycount, git_reflog_entrycount(g_reflog)); +} + +void test_refs_reflog_drop__can_drop_an_entry(void) +{ + cl_assert(entrycount > 4); + + cl_git_pass(git_reflog_drop(g_reflog, 2, 0)); + cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog)); +} + +void test_refs_reflog_drop__can_drop_an_entry_and_rewrite_the_log_history(void) +{ + const git_reflog_entry *before_previous, *before_next; + const git_reflog_entry *after_next; + git_oid before_next_old_oid; + + cl_assert(entrycount > 4); + + before_previous = git_reflog_entry_byindex(g_reflog, 3); + before_next = git_reflog_entry_byindex(g_reflog, 1); + git_oid_cpy(&before_next_old_oid, &before_next->oid_old); + + cl_git_pass(git_reflog_drop(g_reflog, 2, 1)); + cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog)); + + after_next = git_reflog_entry_byindex(g_reflog, 1); + + cl_assert_equal_i(0, git_oid_cmp(&before_next->oid_cur, &after_next->oid_cur)); + cl_assert(git_oid_cmp(&before_next_old_oid, &after_next->oid_old) != 0); + cl_assert_equal_i(0, git_oid_cmp(&before_previous->oid_cur, &after_next->oid_old)); +} + +void test_refs_reflog_drop__can_drop_the_first_entry(void) +{ + cl_assert(entrycount > 2); + + cl_git_pass(git_reflog_drop(g_reflog, 0, 0)); + cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog)); +} + +void test_refs_reflog_drop__can_drop_the_last_entry(void) +{ + const git_reflog_entry *entry; + + cl_assert(entrycount > 2); + + cl_git_pass(git_reflog_drop(g_reflog, entrycount - 1, 0)); + cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog)); + + entry = git_reflog_entry_byindex(g_reflog, entrycount - 2); + cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) != 0); +} + +void test_refs_reflog_drop__can_drop_the_last_entry_and_rewrite_the_log_history(void) +{ + const git_reflog_entry *entry; + + cl_assert(entrycount > 2); + + cl_git_pass(git_reflog_drop(g_reflog, entrycount - 1, 1)); + cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog)); + + entry = git_reflog_entry_byindex(g_reflog, entrycount - 2); + cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) == 0); +} + +void test_refs_reflog_drop__can_drop_all_the_entries(void) +{ + cl_assert(--entrycount > 0); + + do { + cl_git_pass(git_reflog_drop(g_reflog, --entrycount, 1)); + } while (entrycount > 0); + + cl_git_pass(git_reflog_drop(g_reflog, 0, 1)); + + cl_assert_equal_i(0, git_reflog_entrycount(g_reflog)); +} + +void test_refs_reflog_drop__can_persist_deletion_on_disk(void) +{ + git_reference *ref; + + cl_assert(entrycount > 2); + + cl_git_pass(git_reference_lookup(&ref, g_repo, g_reflog->ref_name)); + cl_git_pass(git_reflog_drop(g_reflog, entrycount - 1, 1)); + cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog)); + cl_git_pass(git_reflog_write(g_reflog)); + + git_reflog_free(g_reflog); + + git_reflog_read(&g_reflog, ref); + git_reference_free(ref); + + cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog)); +} diff --git a/tests-clar/refs/reflog.c b/tests-clar/refs/reflog/reflog.c index 05f3786bb..20f08f523 100644 --- a/tests-clar/refs/reflog.c +++ b/tests-clar/refs/reflog/reflog.c @@ -7,7 +7,7 @@ static const char *new_ref = "refs/heads/test-reflog"; static const char *current_master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"; -static const char *commit_msg = "commit: bla bla"; +#define commit_msg "commit: bla bla" static git_repository *g_repo; @@ -24,66 +24,60 @@ static void assert_signature(git_signature *expected, git_signature *actual) // Fixture setup and teardown -void test_refs_reflog__initialize(void) +void test_refs_reflog_reflog__initialize(void) { g_repo = cl_git_sandbox_init("testrepo.git"); } -void test_refs_reflog__cleanup(void) +void test_refs_reflog_reflog__cleanup(void) { cl_git_sandbox_cleanup(); } - - -void test_refs_reflog__write_then_read(void) +void test_refs_reflog_reflog__append_then_read(void) { // write a reflog for a given reference and ensure it can be read back - git_repository *repo2; + git_repository *repo2; git_reference *ref, *lookedup_ref; git_oid oid; git_signature *committer; git_reflog *reflog; - git_reflog_entry *entry; - char oid_str[GIT_OID_HEXSZ+1]; + const git_reflog_entry *entry; /* Create a new branch pointing at the HEAD */ git_oid_fromstr(&oid, current_master_tip); cl_git_pass(git_reference_create_oid(&ref, g_repo, new_ref, &oid, 0)); - git_reference_free(ref); - cl_git_pass(git_reference_lookup(&ref, g_repo, new_ref)); cl_git_pass(git_signature_now(&committer, "foo", "foo@bar")); - cl_git_pass(git_reflog_write(ref, NULL, committer, NULL)); - cl_git_fail(git_reflog_write(ref, NULL, committer, "no ancestor NULL for an existing reflog")); - cl_git_fail(git_reflog_write(ref, NULL, committer, "no\nnewline")); - cl_git_pass(git_reflog_write(ref, &oid, committer, commit_msg)); + cl_git_pass(git_reflog_read(&reflog, ref)); + + cl_git_fail(git_reflog_append(reflog, &oid, committer, "no inner\nnewline")); + cl_git_pass(git_reflog_append(reflog, &oid, committer, NULL)); + cl_git_pass(git_reflog_append(reflog, &oid, committer, commit_msg "\n")); + cl_git_pass(git_reflog_write(reflog)); + git_reflog_free(reflog); /* Reopen a new instance of the repository */ cl_git_pass(git_repository_open(&repo2, "testrepo.git")); - /* Lookup the preivously created branch */ + /* Lookup the previously created branch */ cl_git_pass(git_reference_lookup(&lookedup_ref, repo2, new_ref)); /* Read and parse the reflog for this branch */ cl_git_pass(git_reflog_read(&reflog, lookedup_ref)); - cl_assert(reflog->entries.length == 2); + cl_assert_equal_i(2, git_reflog_entrycount(reflog)); - entry = (git_reflog_entry *)git_vector_get(&reflog->entries, 0); + entry = git_reflog_entry_byindex(reflog, 0); assert_signature(committer, entry->committer); - git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_old); - cl_assert_equal_s("0000000000000000000000000000000000000000", oid_str); - git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_cur); - cl_assert_equal_s(current_master_tip, oid_str); + cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) == 0); + cl_assert(git_oid_cmp(&oid, &entry->oid_cur) == 0); cl_assert(entry->msg == NULL); - entry = (git_reflog_entry *)git_vector_get(&reflog->entries, 1); + entry = git_reflog_entry_byindex(reflog, 1); assert_signature(committer, entry->committer); - git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_old); - cl_assert_equal_s(current_master_tip, oid_str); - git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_cur); - cl_assert_equal_s(current_master_tip, oid_str); + cl_assert(git_oid_cmp(&oid, &entry->oid_old) == 0); + cl_assert(git_oid_cmp(&oid, &entry->oid_cur) == 0); cl_assert_equal_s(commit_msg, entry->msg); git_signature_free(committer); @@ -94,35 +88,7 @@ void test_refs_reflog__write_then_read(void) git_reference_free(lookedup_ref); } -void test_refs_reflog__dont_write_bad(void) -{ - // avoid writing an obviously wrong reflog - git_reference *ref; - git_oid oid; - git_signature *committer; - - /* Create a new branch pointing at the HEAD */ - git_oid_fromstr(&oid, current_master_tip); - cl_git_pass(git_reference_create_oid(&ref, g_repo, new_ref, &oid, 0)); - git_reference_free(ref); - cl_git_pass(git_reference_lookup(&ref, g_repo, new_ref)); - - cl_git_pass(git_signature_now(&committer, "foo", "foo@bar")); - - /* Write the reflog for the new branch */ - cl_git_pass(git_reflog_write(ref, NULL, committer, NULL)); - - /* Try to update the reflog with wrong information: - * It's no new reference, so the ancestor OID cannot - * be NULL. */ - cl_git_fail(git_reflog_write(ref, NULL, committer, NULL)); - - git_signature_free(committer); - - git_reference_free(ref); -} - -void test_refs_reflog__renaming_the_reference_moves_the_reflog(void) +void test_refs_reflog_reflog__renaming_the_reference_moves_the_reflog(void) { git_reference *master; git_buf master_log_path = GIT_BUF_INIT, moved_log_path = GIT_BUF_INIT; @@ -145,6 +111,7 @@ void test_refs_reflog__renaming_the_reference_moves_the_reflog(void) git_buf_free(&moved_log_path); git_buf_free(&master_log_path); } + static void assert_has_reflog(bool expected_result, const char *name) { git_reference *ref; @@ -156,9 +123,50 @@ static void assert_has_reflog(bool expected_result, const char *name) git_reference_free(ref); } -void test_refs_reflog__reference_has_reflog(void) +void test_refs_reflog_reflog__reference_has_reflog(void) { assert_has_reflog(true, "HEAD"); assert_has_reflog(true, "refs/heads/master"); assert_has_reflog(false, "refs/heads/subtrees"); } + +void test_refs_reflog_reflog__reading_the_reflog_from_a_reference_with_no_log_returns_an_empty_one(void) +{ + git_reference *subtrees; + git_reflog *reflog; + git_buf subtrees_log_path = GIT_BUF_INIT; + + cl_git_pass(git_reference_lookup(&subtrees, g_repo, "refs/heads/subtrees")); + + git_buf_join_n(&subtrees_log_path, '/', 3, git_repository_path(g_repo), GIT_REFLOG_DIR, git_reference_name(subtrees)); + cl_assert_equal_i(false, git_path_isfile(git_buf_cstr(&subtrees_log_path))); + + cl_git_pass(git_reflog_read(&reflog, subtrees)); + + cl_assert_equal_i(0, git_reflog_entrycount(reflog)); + + git_reflog_free(reflog); + git_reference_free(subtrees); + git_buf_free(&subtrees_log_path); +} + +void test_refs_reflog_reflog__cannot_write_a_moved_reflog(void) +{ + git_reference *master; + git_buf master_log_path = GIT_BUF_INIT, moved_log_path = GIT_BUF_INIT; + git_reflog *reflog; + + cl_git_pass(git_reference_lookup(&master, g_repo, "refs/heads/master")); + cl_git_pass(git_reflog_read(&reflog, master)); + + cl_git_pass(git_reflog_write(reflog)); + + cl_git_pass(git_reference_rename(master, "refs/moved", 0)); + + cl_git_fail(git_reflog_write(reflog)); + + git_reflog_free(reflog); + git_reference_free(master); + git_buf_free(&moved_log_path); + git_buf_free(&master_log_path); +} diff --git a/tests-clar/refs/remotetracking.c b/tests-clar/refs/remotetracking.c deleted file mode 100644 index c4ec588ee..000000000 --- a/tests-clar/refs/remotetracking.c +++ /dev/null @@ -1,49 +0,0 @@ -#include "clar_libgit2.h" - -static git_repository *g_repo; - -void test_refs_remotetracking__initialize(void) -{ - cl_git_pass(git_repository_open(&g_repo, cl_fixture("testrepo.git"))); -} - -void test_refs_remotetracking__cleanup(void) -{ - git_repository_free(g_repo); -} - -void test_refs_remotetracking__unfound_returns_GIT_ENOTFOUND(void) -{ - git_reference *branch, *tracking; - - cl_git_pass(git_reference_lookup(&branch, g_repo, "refs/heads/subtrees")); - - cl_assert_equal_i(GIT_ENOTFOUND, git_reference_remote_tracking_from_branch(&tracking, branch)); - - git_reference_free(branch); -} - -void test_refs_remotetracking__retrieving_from_a_non_head_fails(void) -{ - git_reference *branch, *tracking; - - cl_git_pass(git_reference_lookup(&branch, g_repo, "refs/tags/e90810b")); - - cl_git_fail(git_reference_remote_tracking_from_branch(&tracking, branch)); - - git_reference_free(branch); -} - -void test_refs_remotetracking__can_retrieve_a_remote_tracking_branch_reference(void) -{ - git_reference *branch, *tracking; - - cl_git_pass(git_reference_lookup(&branch, g_repo, "refs/heads/master")); - - cl_git_pass(git_reference_remote_tracking_from_branch(&tracking, branch)); - - cl_assert_equal_s("refs/remotes/test/master", git_reference_name(tracking)); - - git_reference_free(branch); - git_reference_free(tracking); -} diff --git a/tests-clar/repo/message.c b/tests-clar/repo/message.c new file mode 100644 index 000000000..4a6f13b9d --- /dev/null +++ b/tests-clar/repo/message.c @@ -0,0 +1,47 @@ +#include "clar_libgit2.h" +#include "buffer.h" +#include "refs.h" +#include "posix.h" + +static git_repository *_repo; +static git_buf _path; +static char *_actual; + +void test_repo_message__initialize(void) +{ + _repo = cl_git_sandbox_init("testrepo.git"); +} + +void test_repo_message__cleanup(void) +{ + cl_git_sandbox_cleanup(); + git_buf_free(&_path); + git__free(_actual); + _actual = NULL; +} + +void test_repo_message__none(void) +{ + cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(NULL, 0, _repo)); +} + +void test_repo_message__message(void) +{ + const char expected[] = "Test\n\nThis is a test of the emergency broadcast system\n"; + ssize_t len; + + cl_git_pass(git_buf_joinpath(&_path, git_repository_path(_repo), "MERGE_MSG")); + cl_git_mkfile(git_buf_cstr(&_path), expected); + + len = git_repository_message(NULL, 0, _repo); + cl_assert(len > 0); + _actual = git__malloc(len + 1); + cl_assert(_actual != NULL); + + cl_assert(git_repository_message(_actual, len, _repo) > 0); + _actual[len] = '\0'; + cl_assert_equal_s(expected, _actual); + + cl_git_pass(p_unlink(git_buf_cstr(&_path))); + cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(NULL, 0, _repo)); +} diff --git a/tests-clar/resources/testrepo.git/config b/tests-clar/resources/testrepo.git/config index b4fdac6c2..04ab38776 100644 --- a/tests-clar/resources/testrepo.git/config +++ b/tests-clar/resources/testrepo.git/config @@ -7,6 +7,14 @@ url = git://github.com/libgit2/libgit2 fetch = +refs/heads/*:refs/remotes/test/* +[remote "test_with_pushurl"] + url = git://github.com/libgit2/fetchlibgit2 + pushurl = git://github.com/libgit2/pushlibgit2 + fetch = +refs/heads/*:refs/remotes/test_with_pushurl/* + [branch "master"] remote = test merge = refs/heads/master +[branch "track-local"] + remote = . + merge = refs/heads/master diff --git a/tests-clar/resources/testrepo.git/refs/heads/track-local b/tests-clar/resources/testrepo.git/refs/heads/track-local new file mode 100644 index 000000000..f37febb2c --- /dev/null +++ b/tests-clar/resources/testrepo.git/refs/heads/track-local @@ -0,0 +1 @@ +9fd738e8f7967c078dceed8190330fc8648ee56a |