diff --git a/AUTHORS b/AUTHORS index 954f25964..03904ff55 100644 --- a/AUTHORS +++ b/AUTHORS @@ -43,6 +43,7 @@ Ramsay Jones Robert G. Jakabosky Romain Geissler Romain Muller +Russell Belfer Sakari Jokinen Sam Sarath Lakshman diff --git a/docs/error-handling.md b/docs/error-handling.md new file mode 100644 index 000000000..04c855fbc --- /dev/null +++ b/docs/error-handling.md @@ -0,0 +1,111 @@ +Error reporting in libgit2 +========================== + +Error reporting is performed on an explicit `git_error **` argument, which appears at the end of all API calls that can return an error. Yes, this does clutter the API. + +When a function fails, an error is set on the error variable **and** returns one of the generic error codes. + +~~~c +int git_repository_open(git_repository **repository, const char *path, git_error **error) +{ + // perform some opening + if (p_exists(path) < 0) { + giterr_set(error, GITERR_REPOSITORY, "The path '%s' doesn't exist", path); + return GIT_ENOTFOUND; + } + + ... + + if (try_to_parse(path, error) < 0) + return GIT_ERROR; + + ... +} +~~~ + +The simple error API +-------------------- + +- `void giterr_set(git_error **, int, const char *, ...)`: the main function used to set an error. It allocates a new error object and stores it in the passed error pointer. It has no return value. The arguments for `giterr_set` are as follows: + + - `git_error **error_ptr`: the pointer where the error will be created. + - `int error_class`: the class for the error. This is **not** an error code: this is an speficic enum that specifies the error family. The point is to map these families 1-1 with Exception types on higher level languages (e.g. GitRepositoryException) + - `const char *error_str, ...`: the error string, with optional formatting arguments + +- `void giterr_free(git_error *)`: takes an error and frees it. This function is available in the external API. + +- `void giterr_clear(git_error **)`: clears an error previously set in an error pointer, setting it to NULL and calling `giterr_free` on it. + +- `void giterr_propagate(git_error **, git_error *)`: moves an error to a given error pointer, handling the case when the error pointer is NULL (in that case the error gets freed, because it cannot be propagated). + +The new error code return values +-------------------------------- + +We are doing this the POSIX way: one error code for each "expected failure", and a generic error code for all the critical failures. + +For instance: A reference lookup can have an expected failure (which is when the reference cannot be found), and a critical failure (which could be any of a long list of things that could go wrong, such as the refs packfile being corrupted, a loose ref being written with the wrong permissions, etc). We cannot have distinct error codes for every single error in the library, hence `git_reference_lookup` would return GIT_SUCCESS if the operation was successful, GIT_ENOTFOUND when the reference doesn't exist, and GIT_ERROR when an error happens -- **the error is then detailed in the `git_error` parameter**. + +Please be smart when returning error codes. Functions have max two "expected errors", and in most cases only one. + +Writing error messages +---------------------- + +Here are some guidelines when writing error messages: + +- Use proper English, and an impersonal or past tenses: *The given path does not exist*, *Failed to lookup object in ODB* + +- Use short, direct and objective messages. **One line, max**. libgit2 is a low level library: think that all the messages reported will be thrown as Ruby or Python exceptions. Think how long are common exception messages in those languages. + +- **Do not add redundant information to the error message**, specially information that can be infered from the context. + + E.g. in `git_repository_open`, do not report a message like "Failed to open repository: path not found". Somebody is + calling that function. If it fails, he already knows that the repository failed to open! + +General guidelines for error reporting +-------------------------------------- + +- We never handle programming errors with these functions. Programming errors are `assert`ed, and when their source is internal, fixed as soon as possible. This is C, people. + + Example of programming errors that would **not** be handled: passing NULL to a function that expects a valid pointer; passing a `git_tree` to a function that expects a `git_commit`. All these cases need to be identified with `assert` and fixed asap. + + Example of a runtime error: failing to parse a `git_tree` because it contains invalid data. Failing to open a file because it doesn't exist on disk. These errors would be handled, and a `git_error` would be set. + +- The `git_error **` argument is always the last in the signature of all API calls. No exceptions. + +- When the programmer (or us, internally) doesn't need error handling, he can pass `NULL` to the `git_error **` param. This means that the errors won't be *reported*, but obviously they still will be handled (i.e. the failing function will interrupt and return cleanly). This is transparently handled by `giterr_set` + +- `git_error *` **must be initialized to `NULL` before passing its value to a function!!** + + ~~~c + git_error *err; + git_error *good_error = NULL; + + git_foo_func(arg1, arg2, &error); // invalid: `error` is not initialized + git_foo_func2(arg1, arg2, &good_error); // OK! + git_foo_func3(arg1, arg2, NULL); // OK! But no error reporting! + ~~~ + +- Piling up errors is an error! Don't do this! Errors must always be free'd when a function returns. + + ~~~c + git_error *error = NULL; + + git_foo_func1(arg1, &error); + git_foo_func2(arg2, &error); // WRONG! What if func1 failed? `error` would leak! + ~~~ + +- Likewise: do not rethrow errors internally! + + ~~~c + int git_commit_create(..., git_error **error) + { + if (git_reference_exists("HEAD", error) < 0) { + /* HEAD does not exist; create it so we can commit... */ + if (git_reference_create("HEAD", error) < 0) { + /* error could be rethrown */ + } + } + +- Remember that errors are now allocated, and hence they need to be free'd after they've been used. Failure to do so internally (e.g. in the already seen examples of error piling) will be reported by Valgrind, so we can easily find where are we rethrowing errors. + +- Remember that any function that fails **will set an error object**, and that object will be freed. diff --git a/examples/network/Makefile b/examples/network/Makefile index ed0c2099f..c21869ac9 100644 --- a/examples/network/Makefile +++ b/examples/network/Makefile @@ -2,7 +2,7 @@ default: all CC = gcc CFLAGS += -g -CFLAGS += -I../../include -L../../ -lgit2 +CFLAGS += -I../../include -L../../ -lgit2 -lpthread OBJECTS = \ git2.o \ diff --git a/examples/network/fetch.c b/examples/network/fetch.c index cdd4a4662..23046bd09 100644 --- a/examples/network/fetch.c +++ b/examples/network/fetch.c @@ -3,95 +3,111 @@ #include #include #include +#include -static int rename_packfile(char *packname, git_indexer *idx) +struct dl_data { + git_remote *remote; + git_off_t *bytes; + git_indexer_stats *stats; + int ret; + int finished; +}; + +static void *download(void *ptr) { - char path[GIT_PATH_MAX], oid[GIT_OID_HEXSZ + 1], *slash; - int ret; + struct dl_data *data = (struct dl_data *)ptr; - strcpy(path, packname); - slash = strrchr(path, '/'); + // Connect to the remote end specifying that we want to fetch + // information from it. + if (git_remote_connect(data->remote, GIT_DIR_FETCH) < 0) { + data->ret = -1; + goto exit; + } - if (!slash) - return GIT_EINVALIDARGS; + // Download the packfile and index it. This function updates the + // amount of received data and the indexer stats which lets you + // inform the user about progress. + if (git_remote_download(data->remote, data->bytes, data->stats) < 0) { + data->ret = -1; + goto exit; + } - memset(oid, 0x0, sizeof(oid)); - // The name of the packfile is given by it's hash which you can get - // with git_indexer_hash after the index has been written out to - // disk. Rename the packfile to its "real" name in the same - // directory as it was originally (libgit2 stores it in the folder - // where the packs go, so a rename in place is the right thing to do here - git_oid_fmt(oid, git_indexer_hash(idx)); - ret = sprintf(slash + 1, "pack-%s.pack", oid); - if(ret < 0) - return GIT_EOSERR; + data->ret = 0; - printf("Renaming pack to %s\n", path); - return rename(packname, path); +exit: + data->finished = 1; + pthread_exit(&data->ret); +} + +int update_cb(const char *refname, const git_oid *a, const git_oid *b) +{ + const char *action; + char a_str[GIT_OID_HEXSZ+1], b_str[GIT_OID_HEXSZ+1]; + + git_oid_fmt(b_str, b); + b_str[GIT_OID_HEXSZ] = '\0'; + + if (git_oid_iszero(a)) { + printf("[new] %.20s %s\n", b_str, refname); + } else { + git_oid_fmt(a_str, a); + a_str[GIT_OID_HEXSZ] = '\0'; + printf("[updated] %.10s..%.10s %s\n", a_str, b_str, refname); + } + + return 0; } int fetch(git_repository *repo, int argc, char **argv) { git_remote *remote = NULL; - git_indexer *idx = NULL; + git_off_t bytes = 0; git_indexer_stats stats; - int error; - char *packname = NULL; + pthread_t worker; + struct dl_data data; - // Get the remote and connect to it + // Figure out whether it's a named remote or a URL printf("Fetching %s\n", argv[1]); - error = git_remote_new(&remote, repo, argv[1], NULL); - if (error < GIT_SUCCESS) - return error; - - error = git_remote_connect(remote, GIT_DIR_FETCH); - if (error < GIT_SUCCESS) - return error; - - // Download the packfile from the server. As we don't know its hash - // yet, it will get a temporary filename - error = git_remote_download(&packname, remote); - if (error < GIT_SUCCESS) - return error; - - // No error and a NULL packname means no packfile was needed - if (packname != NULL) { - printf("The packname is %s\n", packname); - - // Create a new instance indexer - error = git_indexer_new(&idx, packname); - if (error < GIT_SUCCESS) - return error; - - // This should be run in paralel, but it'd be too complicated for the example - error = git_indexer_run(idx, &stats); - if (error < GIT_SUCCESS) - return error; - - printf("Received %d objects\n", stats.total); - - // Write the index file. The index will be stored with the - // correct filename - error = git_indexer_write(idx); - if (error < GIT_SUCCESS) - return error; - - error = rename_packfile(packname, idx); - if (error < GIT_SUCCESS) - return error; + if (git_remote_load(&remote, repo, argv[1]) < 0) { + if (git_remote_new(&remote, repo, argv[1], NULL) < 0) + return -1; } + // Set up the information for the background worker thread + data.remote = remote; + data.bytes = &bytes; + data.stats = &stats; + data.ret = 0; + data.finished = 0; + memset(&stats, 0, sizeof(stats)); + + pthread_create(&worker, NULL, download, &data); + + // Loop while the worker thread is still running. Here we show processed + // and total objects in the pack and the amount of received + // data. Most frontends will probably want to show a percentage and + // the download rate. + do { + usleep(10000); + printf("\rReceived %d/%d objects in %d bytes", stats.processed, stats.total, bytes); + } while (!data.finished); + printf("\rReceived %d/%d objects in %d bytes\n", stats.processed, stats.total, bytes); + + // Disconnect the underlying connection to prevent from idling. + git_remote_disconnect(remote); + // Update the references in the remote's namespace to point to the // 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. - error = git_remote_update_tips(remote); - if (error < GIT_SUCCESS) - return error; + if (git_remote_update_tips(remote, update_cb) < 0) + return -1; - free(packname); - git_indexer_free(idx); git_remote_free(remote); - return GIT_SUCCESS; + return 0; + +on_error: + git_remote_free(remote); + return -1; } diff --git a/examples/network/git2.c b/examples/network/git2.c index def56e83b..aeb0e8f4c 100644 --- a/examples/network/git2.c +++ b/examples/network/git2.c @@ -31,7 +31,7 @@ int run_command(git_cb fn, int argc, char **argv) // Run the command. If something goes wrong, print the error message to stderr error = fn(repo, argc, argv); if (error < GIT_SUCCESS) - fprintf(stderr, "Bad news:\n %s\n", git_lasterror()); + fprintf(stderr, "Bad news:\n %s\n", git_error_last()->message); if(repo) git_repository_free(repo); diff --git a/examples/network/index-pack.c b/examples/network/index-pack.c index 671035fb7..881c1493f 100644 --- a/examples/network/index-pack.c +++ b/examples/network/index-pack.c @@ -12,6 +12,61 @@ int index_cb(const git_indexer_stats *stats, void *data) } int index_pack(git_repository *repo, int argc, char **argv) +{ + git_indexer_stream *idx; + git_indexer_stats stats = {0, 0}; + int error, fd; + char hash[GIT_OID_HEXSZ + 1] = {0}; + ssize_t read_bytes; + char buf[512]; + + if (argc < 2) { + fprintf(stderr, "I need a packfile\n"); + return EXIT_FAILURE; + } + + if (git_indexer_stream_new(&idx, ".git") < 0) { + puts("bad idx"); + return -1; + } + + if ((fd = open(argv[1], 0)) < 0) { + perror("open"); + return -1; + } + + do { + read_bytes = read(fd, buf, sizeof(buf)); + if (read_bytes < 0) + break; + + if ((error = git_indexer_stream_add(idx, buf, read_bytes, &stats)) < 0) + goto cleanup; + + printf("\rIndexing %d of %d", stats.processed, stats.total); + } while (read_bytes > 0); + + if (read_bytes < 0) { + error = -1; + perror("failed reading"); + goto cleanup; + } + + if ((error = git_indexer_stream_finalize(idx, &stats)) < 0) + goto cleanup; + + printf("\rIndexing %d of %d\n", stats.processed, stats.total); + + git_oid_fmt(hash, git_indexer_stream_hash(idx)); + puts(hash); + +cleanup: + close(fd); + 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; diff --git a/include/git2.h b/include/git2.h index 1711ff8be..d75387318 100644 --- a/include/git2.h +++ b/include/git2.h @@ -22,6 +22,7 @@ #include "git2/repository.h" #include "git2/revwalk.h" +#include "git2/merge.h" #include "git2/refs.h" #include "git2/reflog.h" @@ -40,7 +41,7 @@ #include "git2/net.h" #include "git2/status.h" #include "git2/indexer.h" - +#include "git2/submodule.h" #include "git2/notes.h" #endif diff --git a/include/git2/attr.h b/include/git2/attr.h index 81d1e517b..6a05496dc 100644 --- a/include/git2/attr.h +++ b/include/git2/attr.h @@ -19,42 +19,186 @@ */ GIT_BEGIN_DECL +/** + * GIT_ATTR_TRUE checks if an attribute is set on. In core git + * parlance, this the value for "Set" attributes. + * + * For example, if the attribute file contains: + * + * *.c foo + * + * 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_attr__true) + +/** + * GIT_ATTR_FALSE checks if an attribute is set off. In core git + * parlance, this is the value for attributes that are "Unset" (not to + * be confused with values that a "Unspecified"). + * + * For example, if the attribute file contains: + * + * *.h -foo + * + * 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_attr__false) -#define GIT_ATTR_UNSPECIFIED(attr) ((attr) == NULL) + +/** + * GIT_ATTR_UNSPECIFIED checks if an attribute is unspecified. This + * may be due to the attribute not being mentioned at all or because + * the attribute was explicitly set unspecified via the `!` operator. + * + * For example, if the attribute file contains: + * + * *.c foo + * *.h -foo + * onefile.c !foo + * + * Then for `onefile.c` looking up attribute "foo" yields a value with + * `GIT_ATTR_UNSPECIFIED(value)` of true. Also, looking up "foo" on + * 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_attr__unset) + +/** + * GIT_ATTR_SET_TO_VALUE checks if an attribute is set to a value (as + * opposied to TRUE, FALSE or UNSPECIFIED). This would be the case if + * for a file with something like: + * + * *.txt eol=lf + * + * 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_SET_TO_VALUE(attr) \ + ((attr) && (attr) != git_attr__unset && \ + (attr) != git_attr__true && (attr) != git_attr__false) GIT_EXTERN(const char *) git_attr__true; GIT_EXTERN(const char *) git_attr__false; - +GIT_EXTERN(const char *) git_attr__unset; /** - * Lookup attribute for path returning string caller must free + * Check attribute flags: Reading values from index and working directory. + * + * When checking attributes, it is possible to check attribute files + * in both the working directory (if there is one) and the index (if + * there is one). You can explicitly choose where to check and in + * which order using the following flags. + * + * Core git usually checks the working directory then the index, + * except during a checkout when it checks the index first. It will + * use index only for creating archives or for a bare repo (if an + * index has been specified for the bare repo). + */ +#define GIT_ATTR_CHECK_FILE_THEN_INDEX 0 +#define GIT_ATTR_CHECK_INDEX_THEN_FILE 1 +#define GIT_ATTR_CHECK_INDEX_ONLY 2 + +/** + * Check attribute flags: Using the system attributes file. + * + * Normally, attribute checks include looking in the /etc (or system + * equivalent) directory for a `gitattributes` file. Passing this + * flag will cause attribute checks to ignore that file. + */ +#define GIT_ATTR_CHECK_NO_SYSTEM (1 << 2) + +/** + * Look up the value of one git attribute for path. + * + * @param repo The repository containing the path. + * @param flags A combination of GIT_ATTR_CHECK... flags. + * @param path The path to check for attributes. Relative paths are + * interpreted relative to the repo root. The file does + * not have to exist, but if it does not, then it will be + * treated as a plain file (not a directory). + * @param name The name of the attribute to look up. + * @param value Output of the value of the attribute. Use the GIT_ATTR_... + * macros to test for TRUE, FALSE, UNSPECIFIED, etc. or just + * use the string value for attributes set to a value. You + * should NOT modify or free this value. */ GIT_EXTERN(int) git_attr_get( - git_repository *repo, const char *path, const char *name, + git_repository *repo, + uint32_t flags, + const char *path, + const char *name, const char **value); /** - * Lookup list of attributes for path, populating array of strings + * Look up a list of git attributes for path. + * + * Use this if you have a known list of attributes that you want to + * look up in a single call. This is somewhat more efficient than + * calling `git_attr_get()` multiple times. + * + * For example, you might write: + * + * const char *attrs[] = { "crlf", "diff", "foo" }; + * const char **values[3]; + * git_attr_get_many(repo, 0, "my/fun/file.c", 3, attrs, values); + * + * Then you could loop through the 3 values to get the settings for + * the three attributes you asked about. + * + * @param repo The repository containing the path. + * @param flags A combination of GIT_ATTR_CHECK... flags. + * @param path The path inside the repo to check attributes. This + * does not have to exist, but if it does not, then + * it will be treated as a plain file (i.e. not a directory). + * @param num_attr The number of attributes being looked up + * @param names An array of num_attr strings containing attribute names. + * @param values An array of num_attr entries that will have string + * pointers written into it for the values of the attributes. + * You should not modify or free the values that are written + * into this array (although of course, you should free the + * array itself if you allocated it). */ GIT_EXTERN(int) git_attr_get_many( - git_repository *repo, const char *path, - size_t num_attr, const char **names, + git_repository *repo, + uint32_t flags, + const char *path, + size_t num_attr, + const char **names, const char **values); /** - * Perform an operation on each attribute of a path. + * Loop over all the git attributes for a path. + * + * @param repo The repository containing the path. + * @param flags A combination of GIT_ATTR_CHECK... flags. + * @param path The path inside the repo to check attributes. This + * does not have to exist, but if it does not, then + * it will be treated as a plain file (i.e. not a directory). + * @param callback The function that will be invoked on each attribute + * and attribute value. The name parameter will be the name + * of the attribute and the value will be the value it is + * set to, including possibly NULL if the attribute is + * explicitly set to UNSPECIFIED using the ! sign. This + * will be invoked only once per attribute name, even if + * there are multiple rules for a given file. The highest + * priority rule will be used. + * @param payload Passed on as extra parameter to callback function. */ GIT_EXTERN(int) git_attr_foreach( - git_repository *repo, const char *path, + git_repository *repo, + uint32_t flags, + const char *path, int (*callback)(const char *name, const char *value, void *payload), void *payload); /** * Flush the gitattributes cache. * - * Call this if you have reason to believe that the attributes files - * on disk no longer match the cached contents of memory. + * Call this if you have reason to believe that the attributes files on + * disk no longer match the cached contents of memory. This will cause + * the attributes files to be reloaded the next time that an attribute + * access function is called. */ GIT_EXTERN(void) git_attr_cache_flush( git_repository *repo); @@ -62,7 +206,7 @@ GIT_EXTERN(void) git_attr_cache_flush( /** * Add a macro definition. * - * Macros will automatically be loaded from the top level .gitattributes + * Macros will automatically be loaded from the top level `.gitattributes` * file of the repository (plus the build-in "binary" macro). This * function allows you to add others. For example, to add the default * macro, you would call: diff --git a/include/git2/branch.h b/include/git2/branch.h index 75927e99a..f4681dc09 100644 --- a/include/git2/branch.h +++ b/include/git2/branch.h @@ -4,12 +4,119 @@ * 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__ +#ifndef INCLUDE_git_branch_h__ +#define INCLUDE_git_branch_h__ -struct git_branch { - char *remote; /* TODO: Make this a git_remote */ - char *merge; -}; +#include "common.h" +#include "types.h" +/** + * @file git2/branch.h + * @brief Git branch parsing routines + * @defgroup git_branch Git branch management + * @ingroup Git + * @{ + */ +GIT_BEGIN_DECL + +/** + * Create a new branch pointing at a target commit + * + * A new direct reference will be created pointing to + * 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. + * + * @param repo Repository where to store the branch. + * + * @param branch_name Name for the branch; this name is + * validated for consistency. It should also not conflict with + * an already existing branch name. + * + * @param target Object to which this branch should point. This object + * must belong to the given `repo` and can either be a git_commit or a + * git_tag. When a git_tag is being passed, it should be dereferencable + * to a git_commit which oid will be used as the target of the branch. + * + * @param force Overwrite existing branch. + * + * @return GIT_SUCCESS or an error code. + * A proper reference is written in the refs/heads namespace + * pointing to the provided target commit. + */ +GIT_EXTERN(int) git_branch_create( + git_oid *oid_out, + git_repository *repo, + const char *branch_name, + const git_object *target, + int force); + +/** + * Delete an existing branch reference. + * + * @param repo Repository where lives the branch. + * + * @param branch_name Name of the branch to be deleted; + * 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 GIT_SUCCESS on success, GIT_ENOTFOUND if the branch + * doesn't exist or an error code. + */ +GIT_EXTERN(int) git_branch_delete( + git_repository *repo, + const char *branch_name, + git_branch_type branch_type); + +/** + * Fill a list with all the branches in the Repository + * + * The string array will be filled with the names of the + * matching branches; these values are owned by the user and + * should be free'd manually when no longer needed, using + * `git_strarray_free`. + * + * @param branch_names Pointer to a git_strarray structure + * where the branch names will be stored. + * + * @param repo Repository where to find the branches. + * + * @param list_flags Filtering flags for the branch + * listing. Valid values are GIT_BRANCH_LOCAL, GIT_BRANCH_REMOTE + * or a combination of the two. + * + * @return GIT_SUCCESS or an error code. + */ +GIT_EXTERN(int) git_branch_list( + git_strarray *branch_names, + git_repository *repo, + unsigned int list_flags); + +/** + * Move/rename an existing 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 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 GIT_SUCCESS on success, GIT_ENOTFOUND if the branch + * doesn't exist or an error code. + */ +GIT_EXTERN(int) git_branch_move( + git_repository *repo, + const char *old_branch_name, + const char *new_branch_name, + int force); + +/** @} */ +GIT_END_DECL #endif diff --git a/include/git2/common.h b/include/git2/common.h index a66f9c380..a8f8d8e1e 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -87,6 +87,7 @@ typedef struct { } git_strarray; GIT_EXTERN(void) git_strarray_free(git_strarray *array); +GIT_EXTERN(int) git_strarray_copy(git_strarray *tgt, const git_strarray *src); /** * Return the version of the libgit2 library diff --git a/include/git2/diff.h b/include/git2/diff.h index 0176d1c2f..6afa608bb 100644 --- a/include/git2/diff.h +++ b/include/git2/diff.h @@ -39,7 +39,9 @@ enum { GIT_DIFF_IGNORE_SUBMODULES = (1 << 5), GIT_DIFF_PATIENCE = (1 << 6), GIT_DIFF_INCLUDE_IGNORED = (1 << 7), - GIT_DIFF_INCLUDE_UNTRACKED = (1 << 8) + GIT_DIFF_INCLUDE_UNTRACKED = (1 << 8), + GIT_DIFF_INCLUDE_UNMODIFIED = (1 << 9), + GIT_DIFF_RECURSE_UNTRACKED_DIRS = (1 << 10), }; /** @@ -152,19 +154,22 @@ typedef int (*git_diff_hunk_fn)( * Line origin constants. * * These values describe where a line came from and will be passed to - * the git_diff_line_fn when iterating over a diff. There are some + * the git_diff_data_fn when iterating over a diff. There are some * special origin contants at the end that are used for the text * output callbacks to demarcate lines that are actually part of * the file or hunk headers. */ enum { - /* these values will be sent to `git_diff_line_fn` along with the line */ + /* these values will be sent to `git_diff_data_fn` along with the line */ GIT_DIFF_LINE_CONTEXT = ' ', GIT_DIFF_LINE_ADDITION = '+', GIT_DIFF_LINE_DELETION = '-', GIT_DIFF_LINE_ADD_EOFNL = '\n', /**< LF was added at end of file */ GIT_DIFF_LINE_DEL_EOFNL = '\0', /**< LF was removed at end of file */ - /* these values will only be sent to a `git_diff_output_fn` */ + /* these values will only be sent to a `git_diff_data_fn` when the content + * of a diff is being formatted (eg. through git_diff_print_patch() or + * git_diff_print_compact(), for instance). + */ GIT_DIFF_LINE_FILE_HDR = 'F', GIT_DIFF_LINE_HUNK_HDR = 'H', GIT_DIFF_LINE_BINARY = 'B' @@ -172,25 +177,19 @@ enum { /** * When iterating over a diff, callback that will be made per text diff - * line. - */ -typedef int (*git_diff_line_fn)( - void *cb_data, - git_diff_delta *delta, - char line_origin, /**< GIT_DIFF_LINE_... value from above */ - const char *content, - size_t content_len); - -/** + * line. In this context, the provided range will be NULL. + * * When printing a diff, callback that will be made to output each line * of text. This uses some extra GIT_DIFF_LINE_... constants for output * of lines of file and hunk headers. */ -typedef int (*git_diff_output_fn)( +typedef int (*git_diff_data_fn)( void *cb_data, + git_diff_delta *delta, + git_diff_range *range, char line_origin, /**< GIT_DIFF_LINE_... value from above */ - const char *formatted_output); - + const char *content, + size_t content_len); /** @name Diff List Generator Functions * @@ -309,7 +308,7 @@ GIT_EXTERN(int) git_diff_foreach( void *cb_data, git_diff_file_fn file_cb, git_diff_hunk_fn hunk_cb, - git_diff_line_fn line_cb); + git_diff_data_fn line_cb); /** * Iterate over a diff generating text output like "git diff --name-status". @@ -317,7 +316,7 @@ GIT_EXTERN(int) git_diff_foreach( GIT_EXTERN(int) git_diff_print_compact( git_diff_list *diff, void *cb_data, - git_diff_output_fn print_cb); + git_diff_data_fn print_cb); /** * Iterate over a diff generating text output like "git diff". @@ -327,7 +326,7 @@ GIT_EXTERN(int) git_diff_print_compact( GIT_EXTERN(int) git_diff_print_patch( git_diff_list *diff, void *cb_data, - git_diff_output_fn print_cb); + git_diff_data_fn print_cb); /**@}*/ @@ -345,7 +344,7 @@ GIT_EXTERN(int) git_diff_blobs( git_diff_options *options, void *cb_data, git_diff_hunk_fn hunk_cb, - git_diff_line_fn line_cb); + git_diff_data_fn line_cb); GIT_END_DECL diff --git a/include/git2/errors.h b/include/git2/errors.h index f617986e1..0406c165a 100644 --- a/include/git2/errors.h +++ b/include/git2/errors.h @@ -21,123 +21,61 @@ typedef enum { GIT_SUCCESS = 0, GIT_ERROR = -1, - /** Input was not a properly formatted Git object id. */ - GIT_ENOTOID = -2, - /** Input does not exist in the scope searched. */ GIT_ENOTFOUND = -3, - /** Not enough space available. */ - GIT_ENOMEM = -4, - - /** Consult the OS error information. */ - GIT_EOSERR = -5, - - /** The specified object is of invalid type */ - GIT_EOBJTYPE = -6, - - /** The specified repository is invalid */ - GIT_ENOTAREPO = -7, - - /** The object type is invalid or doesn't match */ - GIT_EINVALIDTYPE = -8, - - /** The object cannot be written because it's missing internal data */ - GIT_EMISSINGOBJDATA = -9, - - /** The packfile for the ODB is corrupted */ - GIT_EPACKCORRUPTED = -10, - - /** Failed to acquire or release a file lock */ - GIT_EFLOCKFAIL = -11, - - /** The Z library failed to inflate/deflate an object's data */ - GIT_EZLIB = -12, - - /** The queried object is currently busy */ - GIT_EBUSY = -13, - - /** The index file is not backed up by an existing repository */ - GIT_EBAREINDEX = -14, - - /** The name of the reference is not valid */ - GIT_EINVALIDREFNAME = -15, - - /** The specified reference has its data corrupted */ - GIT_EREFCORRUPTED = -16, - - /** The specified symbolic reference is too deeply nested */ - GIT_ETOONESTEDSYMREF = -17, - - /** The pack-refs file is either corrupted or its format is not currently supported */ - GIT_EPACKEDREFSCORRUPTED = -18, - - /** The path is invalid */ - GIT_EINVALIDPATH = -19, - - /** The revision walker is empty; there are no more commits left to iterate */ - GIT_EREVWALKOVER = -20, - - /** The state of the reference is not valid */ - GIT_EINVALIDREFSTATE = -21, - - /** This feature has not been implemented yet */ - GIT_ENOTIMPLEMENTED = -22, - /** A reference with this name already exists */ GIT_EEXISTS = -23, /** The given integer literal is too large to be parsed */ GIT_EOVERFLOW = -24, - /** The given literal is not a valid number */ - GIT_ENOTNUM = -25, - - /** Streaming error */ - GIT_ESTREAM = -26, - - /** invalid arguments to function */ - GIT_EINVALIDARGS = -27, - - /** The specified object has its data corrupted */ - GIT_EOBJCORRUPTED = -28, - /** The given short oid is ambiguous */ - GIT_EAMBIGUOUSOIDPREFIX = -29, + GIT_EAMBIGUOUS = -29, /** Skip and passthrough the given ODB backend */ GIT_EPASSTHROUGH = -30, - /** The path pattern and string did not match */ - GIT_ENOMATCH = -31, - /** The buffer is too short to satisfy the request */ GIT_ESHORTBUFFER = -32, + + GIT_EREVWALKOVER = -33, +} git_error_t; + +typedef struct { + char *message; + int klass; } git_error; -/** - * Return a detailed error string with the latest error - * that occurred in the library. - * @return a string explaining the error - */ -GIT_EXTERN(const char *) git_lasterror(void); +typedef enum { + GITERR_NOMEMORY, + GITERR_OS, + GITERR_INVALID, + GITERR_REFERENCE, + GITERR_ZLIB, + GITERR_REPOSITORY, + GITERR_CONFIG, + GITERR_REGEX, + GITERR_ODB, + GITERR_INDEX, + GITERR_OBJECT, + GITERR_NET, + GITERR_TAG, + GITERR_TREE, +} git_error_class; /** - * strerror() for the Git library + * Return the last `git_error` object that was generated for the + * current thread or NULL if no error has occurred. * - * Get a string description for a given error code. - * NOTE: This method will be eventually deprecated in favor - * of the new `git_lasterror`. - * - * @param num The error code to explain - * @return a string explaining the error code + * @return A git_error object. */ -GIT_EXTERN(const char *) git_strerror(int num); +GIT_EXTERN(const git_error *) giterr_last(void); /** - * Clear the latest library error + * Clear the last library error that occurred for this thread. */ -GIT_EXTERN(void) git_clearerror(void); +GIT_EXTERN(void) giterr_clear(void); /** @} */ GIT_END_DECL diff --git a/include/git2/indexer.h b/include/git2/indexer.h index 7f336f8e6..14bd0e402 100644 --- a/include/git2/indexer.h +++ b/include/git2/indexer.h @@ -23,6 +23,51 @@ typedef struct git_indexer_stats { typedef struct git_indexer git_indexer; +typedef struct git_indexer_stream git_indexer_stream; + +/** + * Create a new streaming indexer instance + * + * @param out where to store the inexer instance + * @param path to the gitdir (metadata directory) + */ +GIT_EXTERN(int) git_indexer_stream_new(git_indexer_stream **out, const char *gitdir); + +/** + * Add data to the indexer + * + * @param idx the indexer + * @param data the data to add + * @param size the size of the data + * @param stats stat storage + */ +GIT_EXTERN(int) git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t size, git_indexer_stats *stats); + +/** + * Finalize the pack and index + * + * Resolve any pending deltas and write out the index file + * + * @param idx the indexer + */ +GIT_EXTERN(int) git_indexer_stream_finalize(git_indexer_stream *idx, git_indexer_stats *stats); + +/** + * Get the packfile's hash + * + * A packfile's name is derived from the sorted hashing of all object + * names. This is only correct after the index has been finalized. + * + * @param idx the indexer instance + */ +GIT_EXTERN(const git_oid *) git_indexer_stream_hash(git_indexer_stream *idx); + +/** + * Free the indexer and its resources + * + * @param idx the indexer to free + */ +GIT_EXTERN(void) git_indexer_stream_free(git_indexer_stream *idx); /** * Create a new indexer instance diff --git a/include/git2/merge.h b/include/git2/merge.h new file mode 100644 index 000000000..5a0b2e7f2 --- /dev/null +++ b/include/git2/merge.h @@ -0,0 +1,35 @@ +/* + * 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_git_merge_h__ +#define INCLUDE_git_merge_h__ + +#include "common.h" +#include "types.h" +#include "oid.h" + +/** + * @file git2/merge.h + * @brief Git merge-base routines + * @defgroup git_revwalk Git merge-base routines + * @ingroup Git + * @{ + */ +GIT_BEGIN_DECL + +/** + * Find a merge base between two commits + * + * @param out the OID of a merge base between 'one' and 'two' + * @param repo the repository where the commits exist + * @param one one of the commits + * @param two the other commit + */ +GIT_EXTERN(int) git_merge_base(git_oid *out, git_repository *repo, git_oid *one, git_oid *two); + +/** @} */ +GIT_END_DECL +#endif diff --git a/include/git2/notes.h b/include/git2/notes.h index 1b5944f9d..ecb37f3ab 100644 --- a/include/git2/notes.h +++ b/include/git2/notes.h @@ -92,6 +92,16 @@ GIT_EXTERN(int) git_note_remove(git_repository *repo, const char *notes_ref, */ GIT_EXTERN(void) git_note_free(git_note *note); +/** + * Get the default notes reference for a repository + * + * @param out Pointer to the default notes reference + * @param repo The Git repository + * + * @return GIT_SUCCESS or an error code + */ +GIT_EXTERN(int) git_note_default_ref(const char **out, git_repository *repo); + /** @} */ GIT_END_DECL #endif diff --git a/include/git2/refs.h b/include/git2/refs.h index 5395ded4b..2073aabc5 100644 --- a/include/git2/refs.h +++ b/include/git2/refs.h @@ -32,6 +32,17 @@ GIT_BEGIN_DECL */ GIT_EXTERN(int) git_reference_lookup(git_reference **reference_out, git_repository *repo, const char *name); +/** + * Lookup a reference by name and resolve immediately to OID. + * + * @param oid Pointer to oid to be filled in + * @param repo The repository in which to look up the reference + * @param name The long name for the reference + * @return 0 on success, -1 if name could not be resolved + */ +GIT_EXTERN(int) git_reference_name_to_oid( + git_oid *out, git_repository *repo, const char *name); + /** * Create a new symbolic reference. * @@ -304,6 +315,15 @@ GIT_EXTERN(int) git_reference_reload(git_reference *ref); */ GIT_EXTERN(void) git_reference_free(git_reference *ref); +/** + * Compare two references. + * + * @param ref1 The first git_reference + * @param ref2 The second git_reference + * @return GIT_SUCCESS if the same, else a stable but meaningless ordering. + */ +GIT_EXTERN(int) git_reference_cmp(git_reference *ref1, git_reference *ref2); + /** @} */ GIT_END_DECL #endif diff --git a/include/git2/refspec.h b/include/git2/refspec.h index 3acf1143d..28afe652d 100644 --- a/include/git2/refspec.h +++ b/include/git2/refspec.h @@ -7,6 +7,7 @@ #ifndef INCLUDE_git_refspec_h__ #define INCLUDE_git_refspec_h__ +#include "common.h" #include "types.h" /** @@ -35,14 +36,13 @@ const char *git_refspec_src(const git_refspec *refspec); const char *git_refspec_dst(const git_refspec *refspec); /** - * Match a refspec's source descriptor with a reference name + * Check if a refspec's source descriptor matches a reference * * @param refspec the refspec * @param refname the name of the reference to check - * @return GIT_SUCCESS on successful match; GIT_ENOMACH on match - * failure or an error code on other failure + * @return 1 if the refspec matches, 0 otherwise */ -int git_refspec_src_match(const git_refspec *refspec, const char *refname); +int git_refspec_src_matches(const git_refspec *refspec, const char *refname); /** * Transform a reference to its target following the refspec's rules diff --git a/include/git2/remote.h b/include/git2/remote.h index 1830c7218..e81e25f98 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -11,6 +11,7 @@ #include "repository.h" #include "refspec.h" #include "net.h" +#include "indexer.h" /** * @file git2/remote.h @@ -150,7 +151,7 @@ GIT_EXTERN(int) git_remote_ls(git_remote *remote, git_headlist_cb list_cb, void * @param filename where to store the temproray filename * @return GIT_SUCCESS or an error code */ -GIT_EXTERN(int) git_remote_download(char **filename, git_remote *remote); +GIT_EXTERN(int) git_remote_download(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats); /** * Check whether the remote is connected @@ -175,6 +176,9 @@ GIT_EXTERN(void) git_remote_disconnect(git_remote *remote); /** * Free the memory associated with a remote * + * This also disconnects from the remote, if the connection + * has not been closed yet (using git_remote_disconnect). + * * @param remote the remote to free */ GIT_EXTERN(void) git_remote_free(git_remote *remote); @@ -182,12 +186,10 @@ GIT_EXTERN(void) git_remote_free(git_remote *remote); /** * Update the tips to the new state * - * Make sure that you only call this once you've successfully indexed - * or expanded the packfile. - * * @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); +GIT_EXTERN(int) git_remote_update_tips(git_remote *remote, int (*cb)(const char *refname, const git_oid *a, const git_oid *b)); /** * Return whether a string is a valid remote URL diff --git a/include/git2/repository.h b/include/git2/repository.h index 34dd90444..d760c23b7 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -70,6 +70,20 @@ GIT_EXTERN(int) git_repository_discover( int across_fs, const char *ceiling_dirs); +enum { + GIT_REPOSITORY_OPEN_NO_SEARCH = (1 << 0), + GIT_REPOSITORY_OPEN_CROSS_FS = (1 << 1), +}; + +/** + * Find and open a repository with extended controls. + */ +GIT_EXTERN(int) git_repository_open_ext( + git_repository **repo, + const char *start_path, + uint32_t flags, + const char *ceiling_dirs); + /** * Free a previously allocated repository * diff --git a/include/git2/revwalk.h b/include/git2/revwalk.h index e7ec2abf3..632c67588 100644 --- a/include/git2/revwalk.h +++ b/include/git2/revwalk.h @@ -163,6 +163,28 @@ GIT_EXTERN(int) git_revwalk_hide_glob(git_revwalk *walk, const char *glob); */ GIT_EXTERN(int) git_revwalk_hide_head(git_revwalk *walk); +/** + * Push the OID pointed to by a reference + * + * The reference must point to a commit. + * + * @param walk the walker being used for the traversal + * @param refname the referece to push + * @return GIT_SUCCESS or an error code + */ +GIT_EXTERN(int) git_revwalk_push_ref(git_revwalk *walk, const char *refname); + +/** + * Hide the OID pointed to by a reference + * + * The reference must point to a commit. + * + * @param walk the walker being used for the traversal + * @param refname the referece to hide + * @return GIT_SUCCESS or an error code + */ +GIT_EXTERN(int) git_revwalk_hide_ref(git_revwalk *walk, const char *refname); + /** * Get the next commit from the revision walk. * diff --git a/include/git2/status.h b/include/git2/status.h index 5c45dae1e..f5fc95f0a 100644 --- a/include/git2/status.h +++ b/include/git2/status.h @@ -46,6 +46,79 @@ GIT_BEGIN_DECL */ GIT_EXTERN(int) git_status_foreach(git_repository *repo, int (*callback)(const char *, unsigned int, void *), void *payload); +/** + * Select the files on which to report status. + * + * - GIT_STATUS_SHOW_INDEX_AND_WORKDIR is the default. This is the + * rough equivalent of `git status --porcelain` where each file + * will receive a callback indicating its status in the index and + * in the workdir. + * - GIT_STATUS_SHOW_INDEX_ONLY will only make callbacks for index + * side of status. The status of the index contents relative to + * the HEAD will be given. + * - GIT_STATUS_SHOW_WORKDIR_ONLY will only make callbacks for the + * workdir side of status, reporting the status of workdir content + * relative to the index. + * - GIT_STATUS_SHOW_INDEX_THEN_WORKDIR behaves like index-only + * followed by workdir-only, causing two callbacks to be issued + * per file (first index then workdir). This is slightly more + * efficient than making separate calls. This makes it easier to + * emulate the output of a plain `git status`. + */ +typedef enum { + GIT_STATUS_SHOW_INDEX_AND_WORKDIR = 0, + GIT_STATUS_SHOW_INDEX_ONLY = 1, + GIT_STATUS_SHOW_WORKDIR_ONLY = 2, + GIT_STATUS_SHOW_INDEX_THEN_WORKDIR = 3, +} git_status_show_t; + +/** + * Flags to control status callbacks + * + * - GIT_STATUS_OPT_INCLUDE_UNTRACKED says that callbacks should + * be made on untracked files. These will only be made if the + * workdir files are included in the status "show" option. + * - GIT_STATUS_OPT_INCLUDE_IGNORED says that ignored files should + * get callbacks. Again, these callbacks will only be made if + * the workdir files are included in the status "show" option. + * Right now, there is no option to include all files in + * directories that are ignored completely. + * - GIT_STATUS_OPT_INCLUDE_UNMODIFIED indicates that callback + * should be made even on unmodified files. + * - GIT_STATUS_OPT_EXCLUDE_SUBMODULES indicates that directories + * which appear to be submodules should just be skipped over. + * - GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS indicates that the + * contents of untracked directories should be included in the + * status. Normally if an entire directory is new, then just + * the top-level directory will be included (with a trailing + * slash on the entry name). Given this flag, the directory + * itself will not be included, but all the files in it will. + */ +#define GIT_STATUS_OPT_INCLUDE_UNTRACKED (1 << 0) +#define GIT_STATUS_OPT_INCLUDE_IGNORED (1 << 1) +#define GIT_STATUS_OPT_INCLUDE_UNMODIFIED (1 << 2) +#define GIT_STATUS_OPT_EXCLUDE_SUBMODULES (1 << 3) +#define GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS (1 << 4) + +/** + * Options to control how callbacks will be made by + * `git_status_foreach_ext()`. + */ +typedef struct { + git_status_show_t show; + unsigned int flags; + git_strarray pathspec; +} git_status_options; + +/** + * Gather file status information and run callbacks as requested. + */ +GIT_EXTERN(int) git_status_foreach_ext( + git_repository *repo, + git_status_options *opts, + int (*callback)(const char *, unsigned int, void *), + void *payload); + /** * Get file status for a single file * diff --git a/include/git2/submodule.h b/include/git2/submodule.h new file mode 100644 index 000000000..930168275 --- /dev/null +++ b/include/git2/submodule.h @@ -0,0 +1,103 @@ +/* + * Copyright (C) 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_git_submodule_h__ +#define INCLUDE_git_submodule_h__ + +#include "common.h" +#include "types.h" +#include "oid.h" + +/** + * @file git2/submodule.h + * @brief Git submodule management utilities + * @defgroup git_submodule Git submodule management routines + * @ingroup Git + * @{ + */ +GIT_BEGIN_DECL + +typedef enum { + GIT_SUBMODULE_UPDATE_CHECKOUT = 0, + GIT_SUBMODULE_UPDATE_REBASE = 1, + GIT_SUBMODULE_UPDATE_MERGE = 2 +} git_submodule_update_t; + +typedef enum { + GIT_SUBMODULE_IGNORE_ALL = 0, /* never dirty */ + GIT_SUBMODULE_IGNORE_DIRTY = 1, /* only dirty if HEAD moved */ + GIT_SUBMODULE_IGNORE_UNTRACKED = 2, /* dirty if tracked files change */ + GIT_SUBMODULE_IGNORE_NONE = 3 /* any change or untracked == dirty */ +} git_submodule_ignore_t; + +/** + * Description of submodule + * + * This record describes a submodule found in a repository. There + * should be an entry for every submodule found in the HEAD and for + * every submodule described in .gitmodules. The fields are as follows: + * + * - `name` is the name of the submodule from .gitmodules. + * - `path` is the path to the submodule from the repo working directory. + * It is almost always the same as `name`. + * - `url` is the url for the submodule. + * - `oid` is the HEAD SHA1 for the submodule. + * - `update` is a value from above - see gitmodules(5) update. + * - `ignore` is a value from above - see gitmodules(5) ignore. + * - `fetch_recurse` is 0 or 1 - see gitmodules(5) fetchRecurseSubmodules. + * - `refcount` is for internal use. + * + * If the submodule has been added to .gitmodules but not yet git added, + * then the `oid` will be zero. If the submodule has been deleted, but + * the delete has not been committed yet, then the `oid` will be set, but + * the `url` will be NULL. + */ +typedef struct { + char *name; + char *path; + char *url; + git_oid oid; /* sha1 of submodule HEAD ref or zero if not committed */ + git_submodule_update_t update; + git_submodule_ignore_t ignore; + int fetch_recurse; + int refcount; +} git_submodule; + +/** + * Iterate over all submodules of a repository. + * + * @param repo The repository + * @param callback Function to be called with the name of each submodule. + * Return a non-zero value to terminate the iteration. + * @param payload Extra data to pass to callback + * @return 0 on success, -1 on error, or non-zero return value of callback + */ +GIT_EXTERN(int) git_submodule_foreach( + git_repository *repo, + int (*callback)(const char *name, void *payload), + void *payload); + +/** + * Lookup submodule information by name or path. + * + * Given either the submodule name or path (they are ususally the same), + * this returns a structure describing the submodule. If the submodule + * does not exist, this will return GIT_ENOTFOUND and set the submodule + * pointer to NULL. + * + * @param submodule Pointer to submodule description object pointer.. + * @param repo The repository. + * @param name The name of the submodule. Trailing slashes will be ignored. + * @return 0 on success, GIT_ENOTFOUND if submodule does not exist, -1 on error + */ +GIT_EXTERN(int) git_submodule_lookup( + git_submodule **submodule, + git_repository *repo, + const char *name); + +/** @} */ +GIT_END_DECL +#endif diff --git a/include/git2/tag.h b/include/git2/tag.h index f7fce3a70..9ab4b7b9e 100644 --- a/include/git2/tag.h +++ b/include/git2/tag.h @@ -274,6 +274,21 @@ GIT_EXTERN(int) git_tag_list_match( const char *pattern, git_repository *repo); +/** + * Recursively peel a tag until a non tag git_object + * is met + * + * The retrieved `tag_target` object is owned by the repository + * and should be closed with the `git_object_free` method. + * + * @param tag_target Pointer to the peeled git_object + * @param tag The tag to be processed + * @return GIT_SUCCESS or an error code + */ +GIT_EXTERN(int) git_tag_peel( + git_object **tag_target, + git_tag *tag); + /** @} */ GIT_END_DECL #endif diff --git a/include/git2/types.h b/include/git2/types.h index ffada630a..98eea5374 100644 --- a/include/git2/types.h +++ b/include/git2/types.h @@ -160,6 +160,11 @@ typedef enum { GIT_REF_LISTALL = GIT_REF_OID|GIT_REF_SYMBOLIC|GIT_REF_PACKED, } git_rtype; +/** Basic type of any Git branch. */ +typedef enum { + GIT_BRANCH_LOCAL = 1, + GIT_BRANCH_REMOTE = 2, +} git_branch_type; typedef struct git_refspec git_refspec; typedef struct git_remote git_remote; diff --git a/src/attr.c b/src/attr.c index 603498df2..b7ac6355d 100644 --- a/src/attr.c +++ b/src/attr.c @@ -3,13 +3,21 @@ #include "config.h" #include +GIT__USE_STRMAP; + static int collect_attr_files( - git_repository *repo, const char *path, git_vector *files); + git_repository *repo, + uint32_t flags, + const char *path, + git_vector *files); int git_attr_get( - git_repository *repo, const char *pathname, - const char *name, const char **value) + git_repository *repo, + uint32_t flags, + const char *pathname, + const char *name, + const char **value) { int error; git_attr_path path; @@ -21,10 +29,11 @@ int git_attr_get( *value = NULL; - if ((error = git_attr_path__init( - &path, pathname, git_repository_workdir(repo))) < GIT_SUCCESS || - (error = collect_attr_files(repo, pathname, &files)) < GIT_SUCCESS) - return git__rethrow(error, "Could not get attribute for %s", pathname); + if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0) + return -1; + + if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0) + goto cleanup; attr.name = name; attr.name_hash = git_attr_file__name_hash(name); @@ -33,18 +42,17 @@ int git_attr_get( git_attr_file__foreach_matching_rule(file, &path, j, rule) { int pos = git_vector_bsearch(&rule->assigns, &attr); - git_clearerror(); /* okay if search failed */ - if (pos >= 0) { *value = ((git_attr_assignment *)git_vector_get( &rule->assigns, pos))->value; - goto found; + goto cleanup; } } } -found: +cleanup: git_vector_free(&files); + git_attr_path__free(&path); return error; } @@ -56,8 +64,12 @@ typedef struct { } attr_get_many_info; int git_attr_get_many( - git_repository *repo, const char *pathname, - size_t num_attr, const char **names, const char **values) + git_repository *repo, + uint32_t flags, + const char *pathname, + size_t num_attr, + const char **names, + const char **values) { int error; git_attr_path path; @@ -70,15 +82,14 @@ int git_attr_get_many( memset((void *)values, 0, sizeof(const char *) * num_attr); - if ((error = git_attr_path__init( - &path, pathname, git_repository_workdir(repo))) < GIT_SUCCESS || - (error = collect_attr_files(repo, pathname, &files)) < GIT_SUCCESS) - return git__rethrow(error, "Could not get attributes for %s", pathname); + if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0) + return -1; - if ((info = git__calloc(num_attr, sizeof(attr_get_many_info))) == NULL) { - git__rethrow(GIT_ENOMEM, "Could not get attributes for %s", pathname); + if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0) goto cleanup; - } + + info = git__calloc(num_attr, sizeof(attr_get_many_info)); + GITERR_CHECK_ALLOC(info); git_vector_foreach(&files, i, file) { @@ -96,8 +107,6 @@ int git_attr_get_many( } pos = git_vector_bsearch(&rule->assigns, &info[k].name); - git_clearerror(); /* okay if search failed */ - if (pos >= 0) { info[k].found = (git_attr_assignment *) git_vector_get(&rule->assigns, pos); @@ -112,6 +121,7 @@ int git_attr_get_many( cleanup: git_vector_free(&files); + git_attr_path__free(&path); git__free(info); return error; @@ -119,7 +129,9 @@ cleanup: int git_attr_foreach( - git_repository *repo, const char *pathname, + git_repository *repo, + uint32_t flags, + const char *pathname, int (*callback)(const char *name, const char *value, void *payload), void *payload) { @@ -130,18 +142,16 @@ int git_attr_foreach( git_attr_file *file; git_attr_rule *rule; git_attr_assignment *assign; - git_hashtable *seen = NULL; + git_strmap *seen = NULL; - if ((error = git_attr_path__init( - &path, pathname, git_repository_workdir(repo))) < GIT_SUCCESS || - (error = collect_attr_files(repo, pathname, &files)) < GIT_SUCCESS) - return git__rethrow(error, "Could not get attributes for %s", pathname); + if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0) + return -1; - seen = git_hashtable_alloc(8, git_hash__strhash_cb, git_hash__strcmp_cb); - if (!seen) { - error = GIT_ENOMEM; + if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0) goto cleanup; - } + + seen = git_strmap_alloc(); + GITERR_CHECK_ALLOC(seen); git_vector_foreach(&files, i, file) { @@ -149,27 +159,23 @@ int git_attr_foreach( git_vector_foreach(&rule->assigns, k, assign) { /* skip if higher priority assignment was already seen */ - if (git_hashtable_lookup(seen, assign->name)) + if (git_strmap_exists(seen, assign->name)) continue; - error = git_hashtable_insert(seen, assign->name, assign); - if (error != GIT_SUCCESS) - goto cleanup; + git_strmap_insert(seen, assign->name, assign, error); + if (error >= 0) + error = callback(assign->name, assign->value, payload); - error = callback(assign->name, assign->value, payload); - if (error != GIT_SUCCESS) + if (error != 0) goto cleanup; } } } cleanup: - if (seen) - git_hashtable_free(seen); + git_strmap_free(seen); git_vector_free(&files); - - if (error != GIT_SUCCESS) - (void)git__rethrow(error, "Could not get attributes for %s", pathname); + git_attr_path__free(&path); return error; } @@ -182,148 +188,274 @@ int git_attr_add_macro( { int error; git_attr_rule *macro = NULL; + git_pool *pool; - if ((error = git_attr_cache__init(repo)) < GIT_SUCCESS) - return error; + if (git_attr_cache__init(repo) < 0) + return -1; macro = git__calloc(1, sizeof(git_attr_rule)); - if (!macro) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(macro); - macro->match.pattern = git__strdup(name); - if (!macro->match.pattern) { - git__free(macro); - return GIT_ENOMEM; - } + pool = &git_repository_attr_cache(repo)->pool; + + macro->match.pattern = git_pool_strdup(pool, name); + GITERR_CHECK_ALLOC(macro->match.pattern); macro->match.length = strlen(macro->match.pattern); macro->match.flags = GIT_ATTR_FNMATCH_MACRO; - error = git_attr_assignment__parse(repo, ¯o->assigns, &values); + error = git_attr_assignment__parse(repo, pool, ¯o->assigns, &values); - if (error == GIT_SUCCESS) + if (!error) error = git_attr_cache__insert_macro(repo, macro); - if (error < GIT_SUCCESS) + if (error < 0) git_attr_rule__free(macro); return error; } -int git_attr_cache__is_cached(git_repository *repo, const char *path) +bool git_attr_cache__is_cached( + git_repository *repo, git_attr_file_source source, const char *path) { - const char *cache_key = path; - if (repo && git__prefixcmp(cache_key, git_repository_workdir(repo)) == 0) - cache_key += strlen(git_repository_workdir(repo)); - return (git_hashtable_lookup(repo->attrcache.files, cache_key) == NULL); + git_buf cache_key = GIT_BUF_INIT; + git_strmap *files = git_repository_attr_cache(repo)->files; + const char *workdir = git_repository_workdir(repo); + bool rval; + + if (workdir && git__prefixcmp(path, workdir) == 0) + path += strlen(workdir); + if (git_buf_printf(&cache_key, "%d#%s", (int)source, path) < 0) + return false; + + rval = git_strmap_exists(files, git_buf_cstr(&cache_key)); + + git_buf_free(&cache_key); + + return rval; } -int git_attr_cache__lookup_or_create_file( - git_repository *repo, - const char *key, - const char *filename, - int (*loader)(git_repository *, const char *, git_attr_file *), - git_attr_file **file_ptr) +static int load_attr_file(const char *filename, const char **data) { int error; - git_attr_cache *cache = &repo->attrcache; - git_attr_file *file = NULL; + git_buf content = GIT_BUF_INIT; - file = git_hashtable_lookup(cache->files, key); - if (file) { - *file_ptr = file; - return GIT_SUCCESS; - } + error = git_futils_readbuffer(&content, filename); + *data = error ? NULL : git_buf_detach(&content); - if (loader && git_path_exists(filename) != GIT_SUCCESS) { - *file_ptr = NULL; - return GIT_SUCCESS; - } - - if ((error = git_attr_file__new(&file)) < GIT_SUCCESS) - return error; - - if (loader) - error = loader(repo, filename, file); - else - error = git_attr_file__set_path(repo, key, file); - - if (error == GIT_SUCCESS) - error = git_hashtable_insert(cache->files, file->path, file); - - if (error < GIT_SUCCESS) { - git_attr_file__free(file); - file = NULL; - } - - *file_ptr = file; return error; } -/* add git_attr_file to vector of files, loading if needed */ -int git_attr_cache__push_file( - git_repository *repo, - git_vector *stack, - const char *base, - const char *filename, - int (*loader)(git_repository *, const char *, git_attr_file *)) +static int load_attr_blob_from_index( + git_repository *repo, const char *filename, git_blob **blob) { int error; - git_buf path = GIT_BUF_INIT; - git_attr_file *file = NULL; - const char *cache_key; + git_index *index; + git_index_entry *entry; - if (base != NULL) { - if ((error = git_buf_joinpath(&path, base, filename)) < GIT_SUCCESS) - return error; + if ((error = git_repository_index__weakptr(&index, repo)) < 0 || + (error = git_index_find(index, filename)) < 0) + return error; + + entry = git_index_get(index, error); + + return git_blob_lookup(blob, repo, &entry->oid); +} + +int git_attr_cache__internal_file( + git_repository *repo, + const char *filename, + git_attr_file **file) +{ + int error = 0; + git_attr_cache *cache = git_repository_attr_cache(repo); + khiter_t cache_pos = git_strmap_lookup_index(cache->files, filename); + + if (git_strmap_valid_index(cache->files, cache_pos)) { + *file = git_strmap_value_at(cache->files, cache_pos); + return 0; + } + + if (git_attr_file__new(file, 0, filename, &cache->pool) < 0) + return -1; + + git_strmap_insert(cache->files, (*file)->key + 2, *file, error); + if (error > 0) + error = 0; + + return error; +} + +int git_attr_cache__push_file( + git_repository *repo, + const char *base, + const char *filename, + git_attr_file_source source, + git_attr_file_parser parse, + git_vector *stack) +{ + int error = 0; + git_buf path = GIT_BUF_INIT; + const char *workdir = git_repository_workdir(repo); + const char *relfile, *content = NULL; + git_attr_cache *cache = git_repository_attr_cache(repo); + git_attr_file *file = NULL; + git_blob *blob = NULL; + + assert(filename && stack); + + /* join base and path as needed */ + if (base != NULL && git_path_root(filename) < 0) { + if (git_buf_joinpath(&path, base, filename) < 0) + return -1; filename = path.ptr; } - /* either get attr_file from cache or read from disk */ - cache_key = filename; - if (repo && git__prefixcmp(cache_key, git_repository_workdir(repo)) == 0) - cache_key += strlen(git_repository_workdir(repo)); + relfile = filename; + if (workdir && git__prefixcmp(relfile, workdir) == 0) + relfile += strlen(workdir); - error = git_attr_cache__lookup_or_create_file( - repo, cache_key, filename, loader, &file); + /* check cache */ + if (cache && cache->files) { + git_buf cache_key = GIT_BUF_INIT; + khiter_t cache_pos; - if (error == GIT_SUCCESS && file != NULL) + if (git_buf_printf(&cache_key, "%d#%s", (int)source, relfile) < 0) + return -1; + + cache_pos = git_strmap_lookup_index(cache->files, cache_key.ptr); + + git_buf_free(&cache_key); + + if (git_strmap_valid_index(cache->files, cache_pos)) { + file = git_strmap_value_at(cache->files, cache_pos); + goto finish; + } + } + + /* if not in cache, load data, parse, and cache */ + + if (source == GIT_ATTR_FILE_FROM_FILE) + error = load_attr_file(filename, &content); + else + error = load_attr_blob_from_index(repo, relfile, &blob); + + if (error) { + /* not finding a file is not an error for this function */ + if (error == GIT_ENOTFOUND) { + giterr_clear(); + error = 0; + } + goto finish; + } + + if (blob) + content = git_blob_rawcontent(blob); + + if ((error = git_attr_file__new(&file, source, relfile, &cache->pool)) < 0) + goto finish; + + if (parse && (error = parse(repo, content, file)) < 0) + goto finish; + + git_strmap_insert(cache->files, file->key, file, error); + if (error > 0) + error = 0; + +finish: + /* push file onto vector if we found one*/ + if (!error && file != NULL) error = git_vector_insert(stack, file); + if (error != 0) + git_attr_file__free(file); + + if (blob) + git_blob_free(blob); + else + git__free((void *)content); + git_buf_free(&path); + return error; } -#define push_attrs(R,S,B,F) \ - git_attr_cache__push_file((R),(S),(B),(F),git_attr_file__from_file) +#define push_attr_file(R,S,B,F) \ + git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,git_attr_file__parse_buffer,(S)) typedef struct { git_repository *repo; + uint32_t flags; + const char *workdir; + git_index *index; git_vector *files; } attr_walk_up_info; +int git_attr_cache__decide_sources( + uint32_t flags, bool has_wd, bool has_index, git_attr_file_source *srcs) +{ + int count = 0; + + switch (flags & 0x03) { + case GIT_ATTR_CHECK_FILE_THEN_INDEX: + if (has_wd) + srcs[count++] = GIT_ATTR_FILE_FROM_FILE; + if (has_index) + srcs[count++] = GIT_ATTR_FILE_FROM_INDEX; + break; + case GIT_ATTR_CHECK_INDEX_THEN_FILE: + if (has_index) + srcs[count++] = GIT_ATTR_FILE_FROM_INDEX; + if (has_wd) + srcs[count++] = GIT_ATTR_FILE_FROM_FILE; + break; + case GIT_ATTR_CHECK_INDEX_ONLY: + if (has_index) + srcs[count++] = GIT_ATTR_FILE_FROM_INDEX; + break; + } + + return count; +} + static int push_one_attr(void *ref, git_buf *path) { + int error = 0, n_src, i; attr_walk_up_info *info = (attr_walk_up_info *)ref; - return push_attrs(info->repo, info->files, path->ptr, GIT_ATTR_FILE); + git_attr_file_source src[2]; + + n_src = git_attr_cache__decide_sources( + info->flags, info->workdir != NULL, info->index != NULL, src); + + for (i = 0; !error && i < n_src; ++i) + error = git_attr_cache__push_file( + info->repo, path->ptr, GIT_ATTR_FILE, src[i], + git_attr_file__parse_buffer, info->files); + + return error; } static int collect_attr_files( - git_repository *repo, const char *path, git_vector *files) + git_repository *repo, + uint32_t flags, + const char *path, + git_vector *files) { - int error = GIT_SUCCESS; + int error; git_buf dir = GIT_BUF_INIT; - git_config *cfg; const char *workdir = git_repository_workdir(repo); attr_walk_up_info info; - if ((error = git_attr_cache__init(repo)) < GIT_SUCCESS) - goto cleanup; + if (git_attr_cache__init(repo) < 0 || + git_vector_init(files, 4, NULL) < 0) + return -1; - if ((error = git_vector_init(files, 4, NULL)) < GIT_SUCCESS) - goto cleanup; - - if ((error = git_path_find_dir(&dir, path, workdir)) < GIT_SUCCESS) + /* given a unrooted path in a non-bare repo, resolve it */ + if (workdir && git_path_root(path) < 0) + error = git_path_find_dir(&dir, path, workdir); + else + error = git_buf_sets(&dir, path); + if (error < 0) goto cleanup; /* in precendence order highest to lowest: @@ -333,38 +465,40 @@ static int collect_attr_files( * - $GIT_PREFIX/etc/gitattributes */ - error = push_attrs(repo, files, repo->path_repository, GIT_ATTR_FILE_INREPO); - if (error < GIT_SUCCESS) + error = push_attr_file( + repo, files, git_repository_path(repo), GIT_ATTR_FILE_INREPO); + if (error < 0) goto cleanup; - info.repo = repo; + info.repo = repo; + info.flags = flags; + info.workdir = workdir; + if (git_repository_index__weakptr(&info.index, repo) < 0) + giterr_clear(); /* no error even if there is no index */ info.files = files; + error = git_path_walk_up(&dir, workdir, push_one_attr, &info); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; - if ((error = git_repository_config(&cfg, repo)) == GIT_SUCCESS) { - const char *core_attribs = NULL; - git_config_get_string(cfg, GIT_ATTR_CONFIG, &core_attribs); - git_clearerror(); /* don't care if attributesfile is not set */ - if (core_attribs) - error = push_attrs(repo, files, NULL, core_attribs); - git_config_free(cfg); + if (git_repository_attr_cache(repo)->cfg_attr_file != NULL) { + error = push_attr_file( + repo, files, NULL, git_repository_attr_cache(repo)->cfg_attr_file); + if (error < 0) + goto cleanup; } - if (error == GIT_SUCCESS) { + if ((flags & GIT_ATTR_CHECK_NO_SYSTEM) == 0) { error = git_futils_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM); - if (error == GIT_SUCCESS) - error = push_attrs(repo, files, NULL, dir.ptr); + if (!error) + error = push_attr_file(repo, files, NULL, dir.ptr); else if (error == GIT_ENOTFOUND) - error = GIT_SUCCESS; + error = 0; } cleanup: - if (error < GIT_SUCCESS) { - git__rethrow(error, "Could not get attributes for '%s'", path); + if (error < 0) git_vector_free(files); - } git_buf_free(&dir); return error; @@ -373,68 +507,108 @@ static int collect_attr_files( int git_attr_cache__init(git_repository *repo) { - int error = GIT_SUCCESS; - git_attr_cache *cache = &repo->attrcache; + int ret; + git_attr_cache *cache = git_repository_attr_cache(repo); + git_config *cfg; if (cache->initialized) - return GIT_SUCCESS; + return 0; + /* cache config settings for attributes and ignores */ + if (git_repository_config__weakptr(&cfg, repo) < 0) + return -1; + + ret = git_config_get_string(cfg, GIT_ATTR_CONFIG, &cache->cfg_attr_file); + if (ret < 0 && ret != GIT_ENOTFOUND) + return ret; + + ret = git_config_get_string(cfg, GIT_IGNORE_CONFIG, &cache->cfg_excl_file); + if (ret < 0 && ret != GIT_ENOTFOUND) + return ret; + + giterr_clear(); + + /* allocate hashtable for attribute and ignore file contents */ if (cache->files == NULL) { - cache->files = git_hashtable_alloc( - 8, git_hash__strhash_cb, git_hash__strcmp_cb); - if (!cache->files) - return git__throw(GIT_ENOMEM, "Could not initialize attribute cache"); + cache->files = git_strmap_alloc(); + GITERR_CHECK_ALLOC(cache->files); } + /* allocate hashtable for attribute macros */ if (cache->macros == NULL) { - cache->macros = git_hashtable_alloc( - 8, git_hash__strhash_cb, git_hash__strcmp_cb); - if (!cache->macros) - return git__throw(GIT_ENOMEM, "Could not initialize attribute cache"); + cache->macros = git_strmap_alloc(); + GITERR_CHECK_ALLOC(cache->macros); } + /* allocate string pool */ + if (git_pool_init(&cache->pool, 1, 0) < 0) + return -1; + cache->initialized = 1; /* insert default macros */ - error = git_attr_add_macro(repo, "binary", "-diff -crlf"); - - return error; + return git_attr_add_macro(repo, "binary", "-diff -crlf -text"); } void git_attr_cache_flush( git_repository *repo) { + git_attr_cache *cache; + if (!repo) return; - if (repo->attrcache.files) { + cache = git_repository_attr_cache(repo); + + if (cache->files != NULL) { git_attr_file *file; - GIT_HASHTABLE_FOREACH_VALUE(repo->attrcache.files, file, - git_attr_file__free(file)); + git_strmap_foreach_value(cache->files, file, { + git_attr_file__free(file); + }); - git_hashtable_free(repo->attrcache.files); - repo->attrcache.files = NULL; + git_strmap_free(cache->files); } - if (repo->attrcache.macros) { + if (cache->macros != NULL) { git_attr_rule *rule; - GIT_HASHTABLE_FOREACH_VALUE(repo->attrcache.macros, rule, - git_attr_rule__free(rule)); + git_strmap_foreach_value(cache->macros, rule, { + git_attr_rule__free(rule); + }); - git_hashtable_free(repo->attrcache.macros); - repo->attrcache.macros = NULL; + git_strmap_free(cache->macros); } - repo->attrcache.initialized = 0; + git_pool_clear(&cache->pool); + + cache->initialized = 0; } int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro) { - if (macro->assigns.length == 0) - return git__throw(GIT_EMISSINGOBJDATA, "git attribute macro with no values"); + git_strmap *macros = git_repository_attr_cache(repo)->macros; + int error; - return git_hashtable_insert( - repo->attrcache.macros, macro->match.pattern, macro); + /* TODO: generate warning log if (macro->assigns.length == 0) */ + if (macro->assigns.length == 0) + return 0; + + git_strmap_insert(macros, macro->match.pattern, macro, error); + return (error < 0) ? -1 : 0; } + +git_attr_rule *git_attr_cache__lookup_macro( + git_repository *repo, const char *name) +{ + git_strmap *macros = git_repository_attr_cache(repo)->macros; + khiter_t pos; + + pos = git_strmap_lookup_index(macros, name); + + if (!git_strmap_valid_index(macros, pos)) + return NULL; + + return (git_attr_rule *)git_strmap_value_at(macros, pos); +} + diff --git a/src/attr.h b/src/attr.h index 5dbbb2366..a35b1160f 100644 --- a/src/attr.h +++ b/src/attr.h @@ -8,33 +8,49 @@ #define INCLUDE_attr_h__ #include "attr_file.h" +#include "strmap.h" + +#define GIT_ATTR_CONFIG "core.attributesfile" +#define GIT_IGNORE_CONFIG "core.excludesfile" typedef struct { int initialized; - git_hashtable *files; /* hash path to git_attr_file of rules */ - git_hashtable *macros; /* hash name to vector */ + git_pool pool; + git_strmap *files; /* hash path to git_attr_file of rules */ + git_strmap *macros; /* hash name to vector */ + const char *cfg_attr_file; /* cached value of core.attributesfile */ + const char *cfg_excl_file; /* cached value of core.excludesfile */ } git_attr_cache; +typedef int (*git_attr_file_parser)( + git_repository *, const char *, git_attr_file *); + extern int git_attr_cache__init(git_repository *repo); extern int git_attr_cache__insert_macro( git_repository *repo, git_attr_rule *macro); -extern int git_attr_cache__lookup_or_create_file( - git_repository *repo, - const char *key, - const char *filename, - int (*loader)(git_repository *, const char *, git_attr_file *), - git_attr_file **file_ptr); +extern git_attr_rule *git_attr_cache__lookup_macro( + git_repository *repo, const char *name); extern int git_attr_cache__push_file( git_repository *repo, - git_vector *stack, - const char *base, - const char *filename, - int (*loader)(git_repository *, const char *, git_attr_file *)); + const char *base, + const char *filename, + git_attr_file_source source, + git_attr_file_parser parse, + git_vector *stack); -/* returns GIT_SUCCESS if path is in cache */ -extern int git_attr_cache__is_cached(git_repository *repo, const char *path); +extern int git_attr_cache__internal_file( + git_repository *repo, + const char *key, + git_attr_file **file_ptr); + +/* returns true if path is in cache */ +extern bool git_attr_cache__is_cached( + git_repository *repo, git_attr_file_source source, const char *path); + +extern int git_attr_cache__decide_sources( + uint32_t flags, bool has_wd, bool has_index, git_attr_file_source *srcs); #endif diff --git a/src/attr_file.c b/src/attr_file.c index 3783b5ef3..ab320a6c4 100644 --- a/src/attr_file.c +++ b/src/attr_file.c @@ -1,62 +1,65 @@ #include "common.h" #include "repository.h" #include "filebuf.h" +#include "git2/blob.h" +#include "git2/tree.h" #include const char *git_attr__true = "[internal]__TRUE__"; const char *git_attr__false = "[internal]__FALSE__"; +const char *git_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); -int git_attr_file__new(git_attr_file **attrs_ptr) +int git_attr_file__new( + git_attr_file **attrs_ptr, + git_attr_file_source from, + const char *path, + git_pool *pool) { - int error; git_attr_file *attrs = NULL; attrs = git__calloc(1, sizeof(git_attr_file)); - if (attrs == NULL) - error = GIT_ENOMEM; - else - error = git_vector_init(&attrs->rules, 4, NULL); + GITERR_CHECK_ALLOC(attrs); - if (error != GIT_SUCCESS) { - git__rethrow(error, "Could not allocate attribute storage"); - git__free(attrs); - attrs = NULL; + if (pool) + attrs->pool = pool; + else { + attrs->pool = git__calloc(1, sizeof(git_pool)); + if (!attrs->pool || git_pool_init(attrs->pool, 1, 0) < 0) + goto fail; + attrs->pool_is_allocated = true; } + if (path) { + size_t len = strlen(path); + + attrs->key = git_pool_malloc(attrs->pool, len + 3); + GITERR_CHECK_ALLOC(attrs->key); + + attrs->key[0] = '0' + from; + attrs->key[1] = '#'; + memcpy(&attrs->key[2], path, len); + attrs->key[len + 2] = '\0'; + } + + if (git_vector_init(&attrs->rules, 4, NULL) < 0) + goto fail; + *attrs_ptr = attrs; + return 0; - return error; +fail: + git_attr_file__free(attrs); + attrs_ptr = NULL; + return -1; } -int git_attr_file__set_path( - git_repository *repo, const char *path, git_attr_file *file) -{ - if (file->path != NULL) { - git__free(file->path); - file->path = NULL; - } - - if (repo == NULL) - file->path = git__strdup(path); - else { - const char *workdir = git_repository_workdir(repo); - - if (workdir && git__prefixcmp(path, workdir) == 0) - file->path = git__strdup(path + strlen(workdir)); - else - file->path = git__strdup(path); - } - - return (file->path == NULL) ? GIT_ENOMEM : GIT_SUCCESS; -} - -int git_attr_file__from_buffer( +int git_attr_file__parse_buffer( git_repository *repo, const char *buffer, git_attr_file *attrs) { - int error = GIT_SUCCESS; + int error = 0; const char *scan = NULL; char *context = NULL; git_attr_rule *rule = NULL; @@ -65,22 +68,24 @@ int git_attr_file__from_buffer( scan = buffer; - if (attrs->path && git__suffixcmp(attrs->path, GIT_ATTR_FILE) == 0) { - context = git__strndup(attrs->path, - strlen(attrs->path) - strlen(GIT_ATTR_FILE)); - if (!context) error = GIT_ENOMEM; + /* if subdir file path, convert context for file paths */ + if (attrs->key && git__suffixcmp(attrs->key, "/" GIT_ATTR_FILE) == 0) { + context = attrs->key + 2; + context[strlen(context) - strlen(GIT_ATTR_FILE)] = '\0'; } - while (error == GIT_SUCCESS && *scan) { + while (!error && *scan) { /* allocate rule if needed */ if (!rule && !(rule = git__calloc(1, sizeof(git_attr_rule)))) { - error = GIT_ENOMEM; + error = -1; break; } /* parse the next "pattern attr attr attr" line */ - if (!(error = git_attr_fnmatch__parse(&rule->match, context, &scan)) && - !(error = git_attr_assignment__parse(repo, &rule->assigns, &scan))) + if (!(error = git_attr_fnmatch__parse( + &rule->match, attrs->pool, context, &scan)) && + !(error = git_attr_assignment__parse( + repo, attrs->pool, &rule->assigns, &scan))) { if (rule->match.flags & GIT_ATTR_FNMATCH_MACRO) /* should generate error/warning if this is coming from any @@ -92,39 +97,44 @@ int git_attr_file__from_buffer( } /* if the rule wasn't a pattern, on to the next */ - if (error != GIT_SUCCESS) { + if (error < 0) { git_attr_rule__clear(rule); /* reset rule contents */ if (error == GIT_ENOTFOUND) - error = GIT_SUCCESS; + error = 0; } else { rule = NULL; /* vector now "owns" the rule */ } } git_attr_rule__free(rule); - git__free(context); + + /* restore file path used for context */ + if (context) + context[strlen(context)] = '.'; /* first char of GIT_ATTR_FILE */ return error; } -int git_attr_file__from_file( - git_repository *repo, const char *path, git_attr_file *file) +int git_attr_file__new_and_load( + git_attr_file **attrs_ptr, + const char *path) { - int error = GIT_SUCCESS; - git_buf fbuf = GIT_BUF_INIT; + int error; + git_buf content = GIT_BUF_INIT; - assert(path && file); + if ((error = git_attr_file__new(attrs_ptr, 0, path, NULL)) < 0) + return error; - if (file->path == NULL) - error = git_attr_file__set_path(repo, path, file); + if (!(error = git_futils_readbuffer(&content, path))) + error = git_attr_file__parse_buffer( + NULL, git_buf_cstr(&content), *attrs_ptr); - if (error == GIT_SUCCESS && - (error = git_futils_readbuffer(&fbuf, path)) == GIT_SUCCESS) - error = git_attr_file__from_buffer(repo, fbuf.ptr, file); + git_buf_free(&content); - git_buf_free(&fbuf); - if (error != GIT_SUCCESS) - git__rethrow(error, "Could not open attribute file '%s'", path); + if (error) { + git_attr_file__free(*attrs_ptr); + *attrs_ptr = NULL; + } return error; } @@ -142,15 +152,18 @@ void git_attr_file__free(git_attr_file *file) git_vector_free(&file->rules); - git__free(file->path); - file->path = NULL; + if (file->pool_is_allocated) { + git_pool_clear(file->pool); + git__free(file->pool); + } + file->pool = NULL; git__free(file); } -unsigned long git_attr_file__name_hash(const char *name) +uint32_t git_attr_file__name_hash(const char *name) { - unsigned long h = 5381; + uint32_t h = 5381; int c; assert(name); while ((c = (int)*name++) != 0) @@ -176,7 +189,6 @@ int git_attr_file__lookup_one( git_attr_file__foreach_matching_rule(file, path, i, rule) { int pos = git_vector_bsearch(&rule->assigns, &name); - git_clearerror(); /* okay if search failed */ if (pos >= 0) { *value = ((git_attr_assignment *) @@ -185,37 +197,37 @@ int git_attr_file__lookup_one( } } - return GIT_SUCCESS; + return 0; } -int git_attr_fnmatch__match( +bool git_attr_fnmatch__match( git_attr_fnmatch *match, const git_attr_path *path) { - int matched = FNM_NOMATCH; + int fnm; if (match->flags & GIT_ATTR_FNMATCH_DIRECTORY && !path->is_dir) - return matched; + return false; if (match->flags & GIT_ATTR_FNMATCH_FULLPATH) - matched = p_fnmatch(match->pattern, path->path, FNM_PATHNAME); + fnm = p_fnmatch(match->pattern, path->path, FNM_PATHNAME); else if (path->is_dir) - matched = p_fnmatch(match->pattern, path->basename, FNM_LEADING_DIR); + fnm = p_fnmatch(match->pattern, path->basename, FNM_LEADING_DIR); else - matched = p_fnmatch(match->pattern, path->basename, 0); + fnm = p_fnmatch(match->pattern, path->basename, 0); - return matched; + return (fnm == FNM_NOMATCH) ? false : true; } -int git_attr_rule__match( +bool git_attr_rule__match( git_attr_rule *rule, const git_attr_path *path) { - int matched = git_attr_fnmatch__match(&rule->match, path); + bool matched = git_attr_fnmatch__match(&rule->match, path); if (rule->match.flags & GIT_ATTR_FNMATCH_NEGATIVE) - matched = (matched == GIT_SUCCESS) ? FNM_NOMATCH : GIT_SUCCESS; + matched = !matched; return matched; } @@ -230,7 +242,6 @@ git_attr_assignment *git_attr_rule__lookup_assignment( key.name_hash = git_attr_file__name_hash(name); pos = git_vector_bsearch(&rule->assigns, &key); - git_clearerror(); /* okay if search failed */ return (pos >= 0) ? git_vector_get(&rule->assigns, pos) : NULL; } @@ -238,25 +249,48 @@ git_attr_assignment *git_attr_rule__lookup_assignment( int git_attr_path__init( git_attr_path *info, const char *path, const char *base) { - assert(info && path); - info->path = path; - info->basename = strrchr(path, '/'); + /* build full path as best we can */ + git_buf_init(&info->full, 0); + + if (base != NULL && git_path_root(path) < 0) { + if (git_buf_joinpath(&info->full, base, path) < 0) + return -1; + info->path = info->full.ptr + strlen(base); + } else { + if (git_buf_sets(&info->full, path) < 0) + return -1; + info->path = info->full.ptr; + } + + /* remove trailing slashes */ + while (info->full.size > 0) { + if (info->full.ptr[info->full.size - 1] != '/') + break; + info->full.size--; + } + info->full.ptr[info->full.size] = '\0'; + + /* skip leading slashes in path */ + while (*info->path == '/') + info->path++; + + /* find trailing basename component */ + info->basename = strrchr(info->path, '/'); if (info->basename) info->basename++; if (!info->basename || !*info->basename) - info->basename = path; + info->basename = info->path; - if (base != NULL && git_path_root(path) < 0) { - git_buf full_path = GIT_BUF_INIT; - int error = git_buf_joinpath(&full_path, base, path); - if (error == GIT_SUCCESS) - info->is_dir = (git_path_isdir(full_path.ptr) == GIT_SUCCESS); - git_buf_free(&full_path); - return error; - } - info->is_dir = (git_path_isdir(path) == GIT_SUCCESS); + info->is_dir = (int)git_path_isdir(info->full.ptr); - return GIT_SUCCESS; + return 0; +} + +void git_attr_path__free(git_attr_path *info) +{ + git_buf_free(&info->full); + info->path = NULL; + info->basename = NULL; } @@ -293,12 +327,13 @@ int git_attr_path__init( */ /* - * This will return GIT_SUCCESS if the spec was filled out, + * This will return 0 if the spec was filled out, * GIT_ENOTFOUND if the fnmatch does not require matching, or * another error code there was an actual problem. */ int git_attr_fnmatch__parse( git_attr_fnmatch *spec, + git_pool *pool, const char *source, const char **base) { @@ -339,7 +374,13 @@ int git_attr_fnmatch__parse( if (*scan == '/') { spec->flags = spec->flags | GIT_ATTR_FNMATCH_FULLPATH; slash_count++; + if (pattern == scan) + pattern++; } + /* remember if we see an unescaped wildcard in pattern */ + else if ((*scan == '*' || *scan == '.' || *scan == '[') && + (scan == pattern || (*(scan - 1) != '\\'))) + spec->flags = spec->flags | GIT_ATTR_FNMATCH_HASWILD; } *base = scan; @@ -360,7 +401,8 @@ int git_attr_fnmatch__parse( /* given an unrooted fullpath match from a file inside a repo, * prefix the pattern with the relative directory of the source file */ - spec->pattern = git__malloc(sourcelen + spec->length + 1); + spec->pattern = git_pool_malloc( + pool, (uint32_t)(sourcelen + spec->length + 1)); if (spec->pattern) { memcpy(spec->pattern, source, sourcelen); memcpy(spec->pattern + sourcelen, pattern, spec->length); @@ -368,12 +410,12 @@ int git_attr_fnmatch__parse( spec->pattern[spec->length] = '\0'; } } else { - spec->pattern = git__strndup(pattern, spec->length); + spec->pattern = git_pool_strndup(pool, pattern, spec->length); } if (!spec->pattern) { *base = git__next_line(pattern); - return GIT_ENOMEM; + return -1; } else { /* strip '\' that might have be used for internal whitespace */ char *to = spec->pattern; @@ -389,7 +431,7 @@ int git_attr_fnmatch__parse( } } - return GIT_SUCCESS; + return 0; } static int sort_by_hash_and_name(const void *a_raw, const void *b_raw) @@ -407,14 +449,11 @@ static int sort_by_hash_and_name(const void *a_raw, const void *b_raw) static void git_attr_assignment__free(git_attr_assignment *assign) { - git__free(assign->name); + /* name and value are stored in a git_pool associated with the + * git_attr_file, so they do not need to be freed here + */ assign->name = NULL; - - if (assign->is_allocated) { - git__free((void *)assign->value); - assign->value = NULL; - } - + assign->value = NULL; git__free(assign); } @@ -430,10 +469,11 @@ static int merge_assignments(void **old_raw, void *new_raw) int git_attr_assignment__parse( git_repository *repo, + git_pool *pool, git_vector *assigns, const char **base) { - int error = GIT_SUCCESS; + int error; const char *scan = *base; git_attr_assignment *assign = NULL; @@ -441,7 +481,7 @@ int git_attr_assignment__parse( assigns->_cmp = sort_by_hash_and_name; - while (*scan && *scan != '\n' && error == GIT_SUCCESS) { + while (*scan && *scan != '\n') { const char *name_start, *value_start; /* skip leading blanks */ @@ -450,23 +490,19 @@ int git_attr_assignment__parse( /* allocate assign if needed */ if (!assign) { assign = git__calloc(1, sizeof(git_attr_assignment)); - if (!assign) { - error = GIT_ENOMEM; - break; - } + GITERR_CHECK_ALLOC(assign); GIT_REFCOUNT_INC(assign); } assign->name_hash = 5381; assign->value = git_attr__true; - assign->is_allocated = 0; /* look for magic name prefixes */ if (*scan == '-') { assign->value = git_attr__false; scan++; } else if (*scan == '!') { - assign->value = NULL; /* explicit unspecified state */ + assign->value = git_attr__unset; /* explicit unspecified state */ scan++; } else if (*scan == '#') /* comment rest of line */ break; @@ -487,11 +523,8 @@ int git_attr_assignment__parse( } /* allocate permanent storage for name */ - assign->name = git__strndup(name_start, scan - name_start); - if (!assign->name) { - error = GIT_ENOMEM; - break; - } + assign->name = git_pool_strndup(pool, name_start, scan - name_start); + GITERR_CHECK_ALLOC(assign->name); /* if there is an equals sign, find the value */ if (*scan == '=') { @@ -499,20 +532,15 @@ int git_attr_assignment__parse( /* if we found a value, allocate permanent storage for it */ if (scan > value_start) { - assign->value = git__strndup(value_start, scan - value_start); - if (!assign->value) { - error = GIT_ENOMEM; - break; - } else { - assign->is_allocated = 1; - } + assign->value = git_pool_strndup(pool, value_start, scan - value_start); + GITERR_CHECK_ALLOC(assign->value); } } /* expand macros (if given a repo with a macro cache) */ if (repo != NULL && assign->value == git_attr__true) { git_attr_rule *macro = - git_hashtable_lookup(repo->attrcache.macros, assign->name); + git_attr_cache__lookup_macro(repo, assign->name); if (macro != NULL) { unsigned int i; @@ -523,35 +551,27 @@ int git_attr_assignment__parse( error = git_vector_insert_sorted( assigns, massign, &merge_assignments); - - if (error == GIT_EEXISTS) - error = GIT_SUCCESS; - else if (error != GIT_SUCCESS) - break; + if (error < 0 && error != GIT_EEXISTS) + return error; } } } /* insert allocated assign into vector */ error = git_vector_insert_sorted(assigns, assign, &merge_assignments); - if (error == GIT_EEXISTS) - error = GIT_SUCCESS; - else if (error < GIT_SUCCESS) - break; + if (error < 0 && error != GIT_EEXISTS) + return error; /* clear assign since it is now "owned" by the vector */ assign = NULL; } - if (!assigns->length) - error = git__throw(GIT_ENOTFOUND, "No attribute assignments found for rule"); - if (assign != NULL) git_attr_assignment__free(assign); *base = git__next_line(scan); - return error; + return (assigns->length == 0) ? GIT_ENOTFOUND : 0; } static void git_attr_rule__clear(git_attr_rule *rule) @@ -568,7 +588,7 @@ static void git_attr_rule__clear(git_attr_rule *rule) git_vector_free(&rule->assigns); } - git__free(rule->match.pattern); + /* match.pattern is stored in a git_pool, so no need to free */ rule->match.pattern = NULL; rule->match.length = 0; } diff --git a/src/attr_file.h b/src/attr_file.h index 1ba18f9e4..ec488c4dc 100644 --- a/src/attr_file.h +++ b/src/attr_file.h @@ -9,18 +9,19 @@ #include "git2/attr.h" #include "vector.h" -#include "hashtable.h" +#include "pool.h" +#include "buffer.h" #define GIT_ATTR_FILE ".gitattributes" #define GIT_ATTR_FILE_INREPO "info/attributes" #define GIT_ATTR_FILE_SYSTEM "gitattributes" -#define GIT_ATTR_CONFIG "core.attributesfile" #define GIT_ATTR_FNMATCH_NEGATIVE (1U << 0) #define GIT_ATTR_FNMATCH_DIRECTORY (1U << 1) #define GIT_ATTR_FNMATCH_FULLPATH (1U << 2) #define GIT_ATTR_FNMATCH_MACRO (1U << 3) #define GIT_ATTR_FNMATCH_IGNORE (1U << 4) +#define GIT_ATTR_FNMATCH_HASWILD (1U << 5) typedef struct { char *pattern; @@ -36,42 +37,49 @@ typedef struct { typedef struct { git_refcount unused; const char *name; - unsigned long name_hash; + uint32_t name_hash; } git_attr_name; typedef struct { git_refcount rc; /* for macros */ char *name; - unsigned long name_hash; + uint32_t name_hash; const char *value; - int is_allocated; } git_attr_assignment; typedef struct { - char *path; /* cache the path this was loaded from */ + char *key; /* cache "source#path" this was loaded from */ git_vector rules; /* vector of or */ + git_pool *pool; + bool pool_is_allocated; } git_attr_file; typedef struct { + git_buf full; const char *path; const char *basename; - int is_dir; + int is_dir; } git_attr_path; +typedef enum { + GIT_ATTR_FILE_FROM_FILE = 0, + GIT_ATTR_FILE_FROM_INDEX = 1 +} git_attr_file_source; + /* * git_attr_file API */ -extern int git_attr_file__new(git_attr_file **attrs_ptr); +extern int git_attr_file__new( + git_attr_file **attrs_ptr, git_attr_file_source src, const char *path, git_pool *pool); + +extern int git_attr_file__new_and_load( + git_attr_file **attrs_ptr, const char *path); + extern void git_attr_file__free(git_attr_file *file); -extern int git_attr_file__from_buffer( +extern int git_attr_file__parse_buffer( git_repository *repo, const char *buf, git_attr_file *file); -extern int git_attr_file__from_file( - git_repository *repo, const char *path, git_attr_file *file); - -extern int git_attr_file__set_path( - git_repository *repo, const char *path, git_attr_file *file); extern int git_attr_file__lookup_one( git_attr_file *file, @@ -82,9 +90,9 @@ extern int git_attr_file__lookup_one( /* loop over rules in file from bottom to top */ #define git_attr_file__foreach_matching_rule(file, path, iter, rule) \ git_vector_rforeach(&(file)->rules, (iter), (rule)) \ - if (git_attr_rule__match((rule), (path)) == GIT_SUCCESS) + if (git_attr_rule__match((rule), (path))) -extern unsigned long git_attr_file__name_hash(const char *name); +extern uint32_t git_attr_file__name_hash(const char *name); /* @@ -93,16 +101,17 @@ extern unsigned long git_attr_file__name_hash(const char *name); extern int git_attr_fnmatch__parse( git_attr_fnmatch *spec, + git_pool *pool, const char *source, const char **base); -extern int git_attr_fnmatch__match( +extern bool git_attr_fnmatch__match( git_attr_fnmatch *rule, const git_attr_path *path); extern void git_attr_rule__free(git_attr_rule *rule); -extern int git_attr_rule__match( +extern bool git_attr_rule__match( git_attr_rule *rule, const git_attr_path *path); @@ -112,8 +121,11 @@ extern git_attr_assignment *git_attr_rule__lookup_assignment( extern int git_attr_path__init( git_attr_path *info, const char *path, const char *base); +extern void git_attr_path__free(git_attr_path *info); + extern int git_attr_assignment__parse( git_repository *repo, /* needed to expand macros */ + git_pool *pool, git_vector *assigns, const char **scan); diff --git a/src/blob.c b/src/blob.c index b67f8afa5..36571c70a 100644 --- a/src/blob.c +++ b/src/blob.c @@ -42,7 +42,7 @@ int git_blob__parse(git_blob *blob, git_odb_object *odb_obj) assert(blob); git_cached_obj_incref((git_cached_obj *)odb_obj); blob->odb_object = odb_obj; - return GIT_SUCCESS; + return 0; } int git_blob_create_frombuffer(git_oid *oid, git_repository *repo, const void *buffer, size_t len) @@ -51,58 +51,50 @@ int git_blob_create_frombuffer(git_oid *oid, git_repository *repo, const void *b git_odb *odb; git_odb_stream *stream; - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) + if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 || + (error = git_odb_open_wstream(&stream, odb, len, GIT_OBJ_BLOB)) < 0) return error; - if ((error = git_odb_open_wstream(&stream, odb, len, GIT_OBJ_BLOB)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to create blob"); + if ((error = stream->write(stream, buffer, len)) == 0) + error = stream->finalize_write(oid, stream); - if ((error = stream->write(stream, buffer, len)) < GIT_SUCCESS) { - stream->free(stream); - return error; - } - - error = stream->finalize_write(oid, stream); stream->free(stream); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create blob"); - - return GIT_SUCCESS; + return error; } -static int write_file_stream(git_oid *oid, git_odb *odb, const char *path, git_off_t file_size) +static int write_file_stream( + git_oid *oid, git_odb *odb, const char *path, git_off_t file_size) { int fd, error; char buffer[4096]; git_odb_stream *stream = NULL; - if ((error = git_odb_open_wstream(&stream, odb, file_size, GIT_OBJ_BLOB)) < GIT_SUCCESS) + if ((error = git_odb_open_wstream( + &stream, odb, (size_t)file_size, GIT_OBJ_BLOB)) < 0) return error; - if ((fd = p_open(path, O_RDONLY)) < 0) { - error = git__throw(GIT_ENOTFOUND, "Failed to create blob. Could not open '%s'", path); - goto cleanup; + if ((fd = git_futils_open_ro(path)) < 0) { + stream->free(stream); + return -1; } - while (file_size > 0) { + while (!error && file_size > 0) { ssize_t read_len = p_read(fd, buffer, sizeof(buffer)); if (read_len < 0) { - error = git__throw(GIT_EOSERR, "Failed to create blob. Can't read full file"); - p_close(fd); - goto cleanup; + giterr_set( + GITERR_OS, "Failed to create blob. Can't read whole file"); + error = -1; } - - stream->write(stream, buffer, read_len); - file_size -= read_len; + else if (!(error = stream->write(stream, buffer, read_len))) + file_size -= read_len; } p_close(fd); - error = stream->finalize_write(oid, stream); -cleanup: + if (!error) + error = stream->finalize_write(oid, stream); + stream->free(stream); return error; } @@ -117,8 +109,7 @@ static int write_file_filtered( git_buf source = GIT_BUF_INIT; git_buf dest = GIT_BUF_INIT; - error = git_futils_readbuffer(&source, full_path); - if (error < GIT_SUCCESS) + if ((error = git_futils_readbuffer(&source, full_path)) < 0) return error; error = git_filters_apply(&dest, &source, filters); @@ -127,40 +118,39 @@ static int write_file_filtered( * and we don't want to ODB write to choke */ git_buf_free(&source); - if (error == GIT_SUCCESS) { - /* Write the file to disk if it was properly filtered */ + /* Write the file to disk if it was properly filtered */ + if (!error) error = git_odb_write(oid, odb, dest.ptr, dest.size, GIT_OBJ_BLOB); - } git_buf_free(&dest); - return GIT_SUCCESS; + return error; } -static int write_symlink(git_oid *oid, git_odb *odb, const char *path, size_t link_size) +static int write_symlink( + git_oid *oid, git_odb *odb, const char *path, size_t link_size) { char *link_data; ssize_t read_len; int error; link_data = git__malloc(link_size); - if (!link_data) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(link_data); read_len = p_readlink(path, link_data, link_size); - if (read_len != (ssize_t)link_size) { - free(link_data); - return git__throw(GIT_EOSERR, "Failed to create blob. Can't read symlink"); + giterr_set(GITERR_OS, "Failed to create blob. Can't read symlink '%s'", path); + git__free(link_data); + return -1; } error = git_odb_write(oid, odb, (void *)link_data, link_size, GIT_OBJ_BLOB); - free(link_data); + git__free(link_data); return error; } int git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *path) { - int error = GIT_SUCCESS; + int error; git_buf full_path = GIT_BUF_INIT; git_off_t size; struct stat st; @@ -168,25 +158,18 @@ int git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *pat git_odb *odb = NULL; workdir = git_repository_workdir(repo); - if (workdir == NULL) - return git__throw(GIT_ENOTFOUND, "Failed to create blob. (No working directory found)"); + assert(workdir); /* error to call this on bare repo */ - error = git_buf_joinpath(&full_path, workdir, path); - if (error < GIT_SUCCESS) + if ((error = git_buf_joinpath(&full_path, workdir, path)) < 0 || + (error = git_path_lstat(full_path.ptr, &st)) < 0 || + (error = git_repository_odb__weakptr(&odb, repo)) < 0) + { + git_buf_free(&full_path); return error; - - error = p_lstat(full_path.ptr, &st); - if (error < 0) { - error = git__throw(GIT_EOSERR, "Failed to stat blob. %s", strerror(errno)); - goto cleanup; } size = st.st_size; - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) - goto cleanup; - if (S_ISLNK(st.st_mode)) { error = write_symlink(oid, odb, full_path.ptr, (size_t)size); } else { @@ -194,12 +177,12 @@ int git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *pat int filter_count; /* Load the filters for writing this file to the ODB */ - filter_count = git_filters_load(&write_filters, repo, path, GIT_FILTER_TO_ODB); + filter_count = git_filters_load( + &write_filters, repo, path, GIT_FILTER_TO_ODB); if (filter_count < 0) { /* Negative value means there was a critical error */ error = filter_count; - goto cleanup; } else if (filter_count == 0) { /* No filters need to be applied to the document: we can stream * directly from disk */ @@ -212,19 +195,20 @@ int git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *pat git_filters_free(&write_filters); /* - * TODO: eventually support streaming filtered files, for files which are bigger - * than a given threshold. This is not a priority because applying a filter in - * streaming mode changes the final size of the blob, and without knowing its - * final size, the blob cannot be written in stream mode to the ODB. + * TODO: eventually support streaming filtered files, for files + * which are bigger than a given threshold. This is not a priority + * because applying a filter in streaming mode changes the final + * size of the blob, and without knowing its final size, the blob + * cannot be written in stream mode to the ODB. * - * The plan is to do streaming writes to a tempfile on disk and then opening - * streaming that file to the ODB, using `write_file_stream`. + * The plan is to do streaming writes to a tempfile on disk and then + * opening streaming that file to the ODB, using + * `write_file_stream`. * * CAREFULLY DESIGNED APIS YO */ } -cleanup: git_buf_free(&full_path); return error; } diff --git a/src/branch.c b/src/branch.c new file mode 100644 index 000000000..c980cf08c --- /dev/null +++ b/src/branch.c @@ -0,0 +1,208 @@ +/* + * 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. + */ + +#include "common.h" +#include "commit.h" +#include "branch.h" +#include "tag.h" + +static int retrieve_branch_reference( + git_reference **branch_reference_out, + git_repository *repo, + const char *branch_name, + int is_remote) +{ + git_reference *branch; + int error = -1; + char *prefix; + git_buf ref_name = GIT_BUF_INIT; + + *branch_reference_out = NULL; + + prefix = is_remote ? GIT_REFS_REMOTES_DIR : GIT_REFS_HEADS_DIR; + + if (git_buf_joinpath(&ref_name, prefix, branch_name) < 0) + goto cleanup; + + if ((error = git_reference_lookup(&branch, repo, ref_name.ptr)) < 0) { + giterr_set(GITERR_REFERENCE, + "Cannot locate %s branch '%s'.", is_remote ? "remote-tracking" : "local", branch_name); + goto cleanup; + } + + *branch_reference_out = branch; + +cleanup: + git_buf_free(&ref_name); + return error; +} + +static int create_error_invalid(const char *msg) +{ + giterr_set(GITERR_INVALID, "Cannot create branch - %s", msg); + return -1; +} + +int git_branch_create( + git_oid *oid_out, + git_repository *repo, + const char *branch_name, + const git_object *target, + int force) +{ + git_otype target_type = GIT_OBJ_BAD; + git_object *commit = NULL; + git_reference *branch = NULL; + 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"); + + target_type = git_object_type(target); + + switch (target_type) + { + case GIT_OBJ_TAG: + if (git_tag_peel(&commit, (git_tag *)target) < 0) + goto cleanup; + + if (git_object_type(commit) != GIT_OBJ_COMMIT) { + create_error_invalid("The given target does not resolve to a commit"); + goto cleanup; + } + break; + + case GIT_OBJ_COMMIT: + commit = (git_object *)target; + break; + + default: + return create_error_invalid("Only git_tag and git_commit objects are valid targets."); + } + + 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) + goto cleanup; + + git_oid_cpy(oid_out, git_reference_oid(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; +} + +int git_branch_delete(git_repository *repo, const char *branch_name, git_branch_type branch_type) +{ + git_reference *branch = NULL; + git_reference *head = NULL; + int error; + + 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) + goto on_error; + + if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0) { + giterr_set(GITERR_REFERENCE, "Cannot locate HEAD."); + goto on_error; + } + + if ((git_reference_type(head) == GIT_REF_SYMBOLIC) + && (strcmp(git_reference_target(head), git_reference_name(branch)) == 0)) { + giterr_set(GITERR_REFERENCE, + "Cannot delete branch '%s' as it is the current HEAD of the repository.", branch_name); + goto on_error; + } + + if (git_reference_delete(branch) < 0) + goto on_error; + + git_reference_free(head); + return 0; + +on_error: + git_reference_free(head); + git_reference_free(branch); + return -1; +} + +typedef struct { + git_vector *branchlist; + unsigned int branch_type; +} branch_filter_data; + +static int branch_list_cb(const char *branch_name, void *payload) +{ + branch_filter_data *filter = (branch_filter_data *)payload; + + if ((filter->branch_type & GIT_BRANCH_LOCAL && git__prefixcmp(branch_name, GIT_REFS_HEADS_DIR) == 0) + || (filter->branch_type & GIT_BRANCH_REMOTE && git__prefixcmp(branch_name, GIT_REFS_REMOTES_DIR) == 0)) + return git_vector_insert(filter->branchlist, git__strdup(branch_name)); + + return 0; +} + +int git_branch_list(git_strarray *branch_names, git_repository *repo, unsigned int list_flags) +{ + int error; + branch_filter_data filter; + git_vector branchlist; + + assert(branch_names && repo); + + if (git_vector_init(&branchlist, 8, NULL) < 0) + return -1; + + filter.branchlist = &branchlist; + filter.branch_type = list_flags; + + error = git_reference_foreach(repo, GIT_REF_OID|GIT_REF_PACKED, &branch_list_cb, (void *)&filter); + if (error < 0) { + git_vector_free(&branchlist); + return -1; + } + + branch_names->strings = (char **)branchlist.contents; + branch_names->count = branchlist.length; + return 0; +} + +int git_branch_move(git_repository *repo, const char *old_branch_name, 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; + + if ((error = git_buf_joinpath(&old_reference_name, GIT_REFS_HEADS_DIR, old_branch_name)) < 0) + goto cleanup; + + /* 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 ((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); + +cleanup: + git_reference_free(reference); + git_buf_free(&old_reference_name); + git_buf_free(&new_reference_name); + + return error; +} diff --git a/src/branch.h b/src/branch.h new file mode 100644 index 000000000..d0e5abc8b --- /dev/null +++ b/src/branch.h @@ -0,0 +1,17 @@ +/* + * 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/buffer.c b/src/buffer.c index 3098f6d68..0785b5399 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -17,8 +17,8 @@ char git_buf_initbuf[1]; static char git_buf__oom; #define ENSURE_SIZE(b, d) \ - if ((d) > buf->asize && git_buf_grow(b, (d)) < GIT_SUCCESS)\ - return GIT_ENOMEM; + if ((d) > buf->asize && git_buf_grow(b, (d)) < 0)\ + return -1; void git_buf_init(git_buf *buf, size_t initial_size) @@ -34,10 +34,8 @@ void git_buf_init(git_buf *buf, size_t initial_size) int git_buf_grow(git_buf *buf, size_t target_size) { int error = git_buf_try_grow(buf, target_size); - if (error != GIT_SUCCESS) { + if (error != 0) buf->ptr = &git_buf__oom; - } - return error; } @@ -47,10 +45,10 @@ int git_buf_try_grow(git_buf *buf, size_t target_size) size_t new_size; if (buf->ptr == &git_buf__oom) - return GIT_ENOMEM; + return -1; if (target_size <= buf->asize) - return GIT_SUCCESS; + return 0; if (buf->asize == 0) { new_size = target_size; @@ -70,7 +68,7 @@ int git_buf_try_grow(git_buf *buf, size_t target_size) new_ptr = git__realloc(new_ptr, new_size); if (!new_ptr) - return GIT_ENOMEM; + return -1; buf->asize = new_size; buf->ptr = new_ptr; @@ -80,7 +78,7 @@ int git_buf_try_grow(git_buf *buf, size_t target_size) buf->size = buf->asize - 1; buf->ptr[buf->size] = '\0'; - return GIT_SUCCESS; + return 0; } void git_buf_free(git_buf *buf) @@ -100,16 +98,11 @@ void git_buf_clear(git_buf *buf) buf->ptr[0] = '\0'; } -int git_buf_oom(const git_buf *buf) +bool git_buf_oom(const git_buf *buf) { return (buf->ptr == &git_buf__oom); } -int git_buf_lasterror(const git_buf *buf) -{ - return (buf->ptr == &git_buf__oom) ? GIT_ENOMEM : GIT_SUCCESS; -} - int git_buf_set(git_buf *buf, const char *data, size_t len) { if (len == 0 || data == NULL) { @@ -122,7 +115,7 @@ int git_buf_set(git_buf *buf, const char *data, size_t len) buf->size = len; buf->ptr[buf->size] = '\0'; } - return GIT_SUCCESS; + return 0; } int git_buf_sets(git_buf *buf, const char *string) @@ -135,7 +128,7 @@ int git_buf_putc(git_buf *buf, char c) ENSURE_SIZE(buf, buf->size + 2); buf->ptr[buf->size++] = c; buf->ptr[buf->size] = '\0'; - return GIT_SUCCESS; + return 0; } int git_buf_put(git_buf *buf, const char *data, size_t len) @@ -144,7 +137,7 @@ int git_buf_put(git_buf *buf, const char *data, size_t len) memmove(buf->ptr + buf->size, data, len); buf->size += len; buf->ptr[buf->size] = '\0'; - return GIT_SUCCESS; + return 0; } int git_buf_puts(git_buf *buf, const char *string) @@ -153,22 +146,26 @@ int git_buf_puts(git_buf *buf, const char *string) return git_buf_put(buf, string, strlen(string)); } -int git_buf_printf(git_buf *buf, const char *format, ...) +int git_buf_vprintf(git_buf *buf, const char *format, va_list ap) { int len; - va_list arglist; - ENSURE_SIZE(buf, buf->size + 1); + ENSURE_SIZE(buf, buf->size + (strlen(format) * 2)); while (1) { - va_start(arglist, format); - len = p_vsnprintf(buf->ptr + buf->size, buf->asize - buf->size, format, arglist); - va_end(arglist); + va_list args; + va_copy(args, ap); + + len = p_vsnprintf( + buf->ptr + buf->size, + buf->asize - buf->size, + format, args + ); if (len < 0) { - free(buf->ptr); + git__free(buf->ptr); buf->ptr = &git_buf__oom; - return GIT_ENOMEM; + return -1; } if ((size_t)len + 1 <= buf->asize - buf->size) { @@ -179,7 +176,19 @@ int git_buf_printf(git_buf *buf, const char *format, ...) ENSURE_SIZE(buf, buf->size + len + 1); } - return GIT_SUCCESS; + return 0; +} + +int git_buf_printf(git_buf *buf, const char *format, ...) +{ + int r; + va_list ap; + + va_start(ap, format); + r = git_buf_vprintf(buf, format, ap); + va_end(ap); + + return r; } void git_buf_copy_cstr(char *data, size_t datasize, const git_buf *buf) @@ -220,8 +229,8 @@ void git_buf_truncate(git_buf *buf, size_t len) void git_buf_rtruncate_at_char(git_buf *buf, char separator) { - int idx = git_buf_rfind_next(buf, separator); - git_buf_truncate(buf, idx < 0 ? 0 : idx); + ssize_t idx = git_buf_rfind_next(buf, separator); + git_buf_truncate(buf, idx < 0 ? 0 : (size_t)idx); } void git_buf_swap(git_buf *buf_a, git_buf *buf_b) @@ -262,9 +271,9 @@ void git_buf_attach(git_buf *buf, char *ptr, size_t asize) int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...) { va_list ap; - int i, error = GIT_SUCCESS; - size_t total_size = 0; - char *out; + int i; + size_t total_size = 0, original_size = buf->size; + char *out, *original = buf->ptr; if (buf->size > 0 && buf->ptr[buf->size - 1] != separator) ++total_size; /* space for initial separator */ @@ -288,9 +297,10 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...) va_end(ap); /* expand buffer if needed */ - if (total_size > 0 && - (error = git_buf_grow(buf, buf->size + total_size + 1)) < GIT_SUCCESS) - return error; + if (total_size == 0) + return 0; + if (git_buf_grow(buf, buf->size + total_size + 1) < 0) + return -1; out = buf->ptr + buf->size; @@ -307,12 +317,23 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...) if (!segment) continue; + /* deal with join that references buffer's original content */ + if (segment >= original && segment < original + original_size) { + size_t offset = (segment - original); + segment = buf->ptr + offset; + segment_len = original_size - offset; + } else { + segment_len = strlen(segment); + } + /* skip leading separators */ if (out > buf->ptr && out[-1] == separator) - while (*segment == separator) segment++; + while (segment_len > 0 && *segment == separator) { + segment++; + segment_len--; + } /* copy over next buffer */ - segment_len = strlen(segment); if (segment_len > 0) { memmove(out, segment, segment_len); out += segment_len; @@ -328,7 +349,7 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...) buf->size = out - buf->ptr; buf->ptr[buf->size] = '\0'; - return error; + return 0; } int git_buf_join( @@ -337,7 +358,6 @@ int git_buf_join( const char *str_a, const char *str_b) { - int error = GIT_SUCCESS; size_t strlen_a = str_a ? strlen(str_a) : 0; size_t strlen_b = strlen(str_b); int need_sep = 0; @@ -357,9 +377,8 @@ int git_buf_join( if (str_a >= buf->ptr && str_a < buf->ptr + buf->size) offset_a = str_a - buf->ptr; - error = git_buf_grow(buf, strlen_a + strlen_b + need_sep + 1); - if (error < GIT_SUCCESS) - return error; + if (git_buf_grow(buf, strlen_a + strlen_b + need_sep + 1) < 0) + return -1; /* fix up internal pointers */ if (offset_a >= 0) @@ -375,7 +394,7 @@ int git_buf_join( buf->size = strlen_a + strlen_b + need_sep; buf->ptr[buf->size] = '\0'; - return error; + return 0; } void git_buf_rtrim(git_buf *buf) diff --git a/src/buffer.h b/src/buffer.h index 3cdd794af..f15fdaa5d 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -32,7 +32,7 @@ void git_buf_init(git_buf *buf, size_t initial_size); * If the allocation fails, this will return an error and the buffer * will be marked as invalid for future operations. The existing * contents of the buffer will be preserved however. - * @return GIT_SUCCESS or GIT_ENOMEM on failure + * @return 0 on success or -1 on failure */ int git_buf_grow(git_buf *buf, size_t target_size); @@ -57,23 +57,18 @@ void git_buf_attach(git_buf *buf, char *ptr, size_t asize); * further calls to modify the buffer will fail. Check git_buf_oom() at the * end of your sequence and it will be true if you ran out of memory at any * point with that buffer. - * @return 0 if no error, 1 if allocation error. + * + * @return false if no error, true if allocation error */ -int git_buf_oom(const git_buf *buf); - -/** - * Just like git_buf_oom, except returns appropriate error code. - * @return GIT_ENOMEM if allocation error, GIT_SUCCESS if not. - */ -int git_buf_lasterror(const git_buf *buf); +bool git_buf_oom(const git_buf *buf); /* - * The functions below that return int values, will return GIT_ENOMEM - * if they fail to expand the git_buf when they are called, otherwise - * GIT_SUCCESS. Passing a git_buf that has failed an allocation will - * automatically return GIT_ENOMEM for all further calls. As a result, - * you can ignore the return code of these functions and call them in a - * series then just call git_buf_lasterror at the end. + * Functions below that return int value error codes will return 0 on + * success or -1 on failure (which generally means an allocation failed). + * Using a git_buf where the allocation has failed with result in -1 from + * all further calls using that buffer. As a result, you can ignore the + * return code of these functions and call them in a series then just call + * git_buf_oom at the end. */ int git_buf_set(git_buf *buf, const char *data, size_t len); int git_buf_sets(git_buf *buf, const char *string); @@ -81,6 +76,7 @@ int git_buf_putc(git_buf *buf, char c); int git_buf_put(git_buf *buf, const char *data, size_t len); int git_buf_puts(git_buf *buf, const char *string); int git_buf_printf(git_buf *buf, const char *format, ...) GIT_FORMAT_PRINTF(2, 3); +int git_buf_vprintf(git_buf *buf, const char *format, va_list ap); void git_buf_clear(git_buf *buf); void git_buf_consume(git_buf *buf, const char *end); void git_buf_truncate(git_buf *buf, size_t len); @@ -91,25 +87,30 @@ int git_buf_join(git_buf *buf, char separator, const char *str_a, const char *st /** * Join two strings as paths, inserting a slash between as needed. - * @return error code or GIT_SUCCESS + * @return 0 on success, -1 on failure */ GIT_INLINE(int) git_buf_joinpath(git_buf *buf, const char *a, const char *b) { return git_buf_join(buf, '/', a, b); } -GIT_INLINE(const char *) git_buf_cstr(git_buf *buf) +GIT_INLINE(const char *) git_buf_cstr(const git_buf *buf) { return buf->ptr; } +GIT_INLINE(size_t) git_buf_len(const git_buf *buf) +{ + return buf->size; +} + void git_buf_copy_cstr(char *data, size_t datasize, const git_buf *buf); #define git_buf_PUTS(buf, str) git_buf_put(buf, str, sizeof(str) - 1) -GIT_INLINE(int) git_buf_rfind_next(git_buf *buf, char ch) +GIT_INLINE(ssize_t) git_buf_rfind_next(git_buf *buf, char ch) { - int idx = buf->size - 1; + ssize_t idx = (ssize_t)buf->size - 1; while (idx >= 0 && buf->ptr[idx] == ch) idx--; while (idx >= 0 && buf->ptr[idx] != ch) idx--; return idx; diff --git a/src/cache.c b/src/cache.c index 9e566792a..31da3c36e 100644 --- a/src/cache.c +++ b/src/cache.c @@ -9,21 +9,14 @@ #include "repository.h" #include "commit.h" #include "thread-utils.h" +#include "util.h" #include "cache.h" int git_cache_init(git_cache *cache, size_t size, git_cached_obj_freeptr free_ptr) { if (size < 8) size = 8; - - /* round up size to closest power of 2 */ - size--; - size |= size >> 1; - size |= size >> 2; - size |= size >> 4; - size |= size >> 8; - size |= size >> 16; - size++; + size = git__size_t_powerof2(size); cache->size_mask = size - 1; cache->lru_count = 0; @@ -32,11 +25,10 @@ int git_cache_init(git_cache *cache, size_t size, git_cached_obj_freeptr free_pt git_mutex_init(&cache->lock); cache->nodes = git__malloc(size * sizeof(git_cached_obj *)); - if (cache->nodes == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(cache->nodes); memset(cache->nodes, 0x0, size * sizeof(git_cached_obj *)); - return GIT_SUCCESS; + return 0; } void git_cache_free(git_cache *cache) diff --git a/src/cc-compat.h b/src/cc-compat.h index 3df36b61f..9f23dcae2 100644 --- a/src/cc-compat.h +++ b/src/cc-compat.h @@ -50,4 +50,20 @@ # pragma warning ( disable : 4127 ) #endif +#if defined (_MSC_VER) + typedef unsigned char bool; +# define true 1 +# define false 0 +#else +# include +#endif + +#ifndef va_copy +# ifdef __va_copy +# define va_copy(dst, src) __va_copy(dst, src) +# else +# define va_copy(dst, src) ((dst) = (src)) +# endif +#endif + #endif /* INCLUDE_compat_h__ */ diff --git a/src/commit.c b/src/commit.c index 189d8fe9e..04f37fe16 100644 --- a/src/commit.c +++ b/src/commit.c @@ -69,24 +69,84 @@ int git_commit_create_v( ...) { va_list ap; - int i, error; + int i, res; const git_commit **parents; parents = git__malloc(parent_count * sizeof(git_commit *)); + GITERR_CHECK_ALLOC(parents); va_start(ap, parent_count); for (i = 0; i < parent_count; ++i) parents[i] = va_arg(ap, const git_commit *); va_end(ap); - error = git_commit_create( + res = git_commit_create( oid, repo, update_ref, author, committer, message_encoding, message, tree, parent_count, parents); git__free((void *)parents); + return res; +} - return error; +/* Update the reference named `ref_name` so it points to `oid` */ +static int update_reference(git_repository *repo, git_oid *oid, const char *ref_name) +{ + git_reference *ref; + int res; + + res = git_reference_lookup(&ref, repo, ref_name); + + /* If we haven't found the reference at all, we assume we need to create + * a new reference and that's it */ + if (res == GIT_ENOTFOUND) { + giterr_clear(); + return git_reference_create_oid(NULL, repo, ref_name, oid, 1); + } + + if (res < 0) + return -1; + + /* If we have found a reference, but it's symbolic, we need to update + * the direct reference it points to */ + if (git_reference_type(ref) == GIT_REF_SYMBOLIC) { + git_reference *aux; + const char *sym_target; + + /* The target pointed at by this reference */ + sym_target = git_reference_target(ref); + + /* resolve the reference to the target it points to */ + res = git_reference_resolve(&aux, ref); + + /* + * if the symbolic reference pointed to an inexisting ref, + * this is means we're creating a new branch, for example. + * We need to create a new direct reference with that name + */ + if (res == GIT_ENOTFOUND) { + giterr_clear(); + res = git_reference_create_oid(NULL, repo, sym_target, oid, 1); + git_reference_free(ref); + return res; + } + + /* free the original symbolic reference now; not before because + * we're using the `sym_target` pointer */ + git_reference_free(ref); + + if (res < 0) + return -1; + + /* store the newly found direct reference in its place */ + ref = aux; + } + + /* ref is made to point to `oid`: ref is either the original reference, + * or the target of the symbolic reference we've looked up */ + res = git_reference_set_oid(ref, oid); + git_reference_free(ref); + return res; } int git_commit_create( @@ -102,20 +162,15 @@ int git_commit_create( const git_commit *parents[]) { git_buf commit = GIT_BUF_INIT; - int error, i; + int i; git_odb *odb; - if (git_object_owner((const git_object *)tree) != repo) - return git__throw(GIT_EINVALIDARGS, "The given tree does not belong to this repository"); + assert(git_object_owner((const git_object *)tree) == repo); git_oid__writebuf(&commit, "tree ", git_object_id((const git_object *)tree)); for (i = 0; i < parent_count; ++i) { - if (git_object_owner((const git_object *)parents[i]) != repo) { - error = git__throw(GIT_EINVALIDARGS, "The given parent does not belong to this repository"); - goto cleanup; - } - + assert(git_object_owner((const git_object *)parents[i]) == repo); git_oid__writebuf(&commit, "parent ", git_object_id((const git_object *)parents[i])); } @@ -128,67 +183,25 @@ int git_commit_create( git_buf_putc(&commit, '\n'); git_buf_puts(&commit, message); - if (git_buf_oom(&commit)) { - error = git__throw(git_buf_lasterror(&commit), - "Not enough memory to build the commit data"); - goto cleanup; - } + if (git_buf_oom(&commit)) + goto on_error; - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_repository_odb__weakptr(&odb, repo) < 0) + goto on_error; + + if (git_odb_write(oid, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT) < 0) + goto on_error; - error = git_odb_write(oid, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT); git_buf_free(&commit); - if (error == GIT_SUCCESS && update_ref != NULL) { - git_reference *head; - git_reference *target; + if (update_ref != NULL) + return update_reference(repo, oid, update_ref); - error = git_reference_lookup(&head, repo, update_ref); - if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) - return git__rethrow(error, "Failed to create commit"); + return 0; - if (error != GIT_ENOTFOUND) { - update_ref = git_reference_target(head); - error = git_reference_resolve(&target, head); - } - - if (error < GIT_SUCCESS) { - if (error != GIT_ENOTFOUND) { - git_reference_free(head); - return git__rethrow(error, "Failed to create commit"); - } - /* - * The target of the reference was not found. This can happen - * just after a repository has been initialized (the master - * branch doesn't exist yet, as it doesn't have anything to - * point to) or after an orphan checkout, so if the target - * branch doesn't exist yet, create it and return. - */ - error = git_reference_create_oid(&target, repo, update_ref, oid, 1); - - git_reference_free(head); - if (error == GIT_SUCCESS) - git_reference_free(target); - - return error; - } - - error = git_reference_set_oid(target, oid); - - git_reference_free(head); - git_reference_free(target); - } - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create commit"); - - return GIT_SUCCESS; - -cleanup: +on_error: git_buf_free(&commit); - return error; + return -1; } int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len) @@ -197,35 +210,40 @@ int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len) const char *buffer_end = (const char *)data + len; git_oid parent_oid; - int error; git_vector_init(&commit->parent_oids, 4, NULL); - if ((error = git_oid__parse(&commit->tree_oid, &buffer, buffer_end, "tree ")) < GIT_SUCCESS) - return git__rethrow(error, "Failed to parse buffer"); + if (git_oid__parse(&commit->tree_oid, &buffer, buffer_end, "tree ") < 0) + goto bad_buffer; /* * TODO: commit grafts! */ - while (git_oid__parse(&parent_oid, &buffer, buffer_end, "parent ") == GIT_SUCCESS) { + while (git_oid__parse(&parent_oid, &buffer, buffer_end, "parent ") == 0) { git_oid *new_oid; new_oid = git__malloc(sizeof(git_oid)); + GITERR_CHECK_ALLOC(new_oid); + git_oid_cpy(new_oid, &parent_oid); - if (git_vector_insert(&commit->parent_oids, new_oid) < GIT_SUCCESS) - return GIT_ENOMEM; + if (git_vector_insert(&commit->parent_oids, new_oid) < 0) + return -1; } commit->author = git__malloc(sizeof(git_signature)); - if ((error = git_signature__parse(commit->author, &buffer, buffer_end, "author ", '\n')) < GIT_SUCCESS) - return git__rethrow(error, "Failed to parse commit"); + GITERR_CHECK_ALLOC(commit->author); + + if (git_signature__parse(commit->author, &buffer, buffer_end, "author ", '\n') < 0) + return -1; /* Always parse the committer; we need the commit time */ commit->committer = git__malloc(sizeof(git_signature)); - if ((error = git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n')) < GIT_SUCCESS) - return git__rethrow(error, "Failed to parse commit"); + GITERR_CHECK_ALLOC(commit->committer); + + if (git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n') < 0) + return -1; if (git__prefixcmp(buffer, "encoding ") == 0) { const char *encoding_end; @@ -236,8 +254,7 @@ int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len) encoding_end++; commit->message_encoding = git__strndup(buffer, encoding_end - buffer); - if (!commit->message_encoding) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(commit->message_encoding); buffer = encoding_end; } @@ -248,11 +265,14 @@ int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len) if (buffer <= buffer_end) { commit->message = git__strndup(buffer, buffer_end - buffer); - if (!commit->message) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(commit->message); } - return GIT_SUCCESS; + return 0; + +bad_buffer: + giterr_set(GITERR_OBJECT, "Failed to parse bad commit object"); + return -1; } int git_commit__parse(git_commit *commit, git_odb_object *obj) @@ -290,8 +310,10 @@ int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n) assert(commit); parent_oid = git_vector_get(&commit->parent_oids, n); - if (parent_oid == NULL) - return git__throw(GIT_ENOTFOUND, "Parent %u does not exist", n); + if (parent_oid == NULL) { + giterr_set(GITERR_INVALID, "Parent %u does not exist", n); + return GIT_ENOTFOUND; + } return git_commit_lookup(parent, commit->object.repo, parent_oid); } diff --git a/src/common.h b/src/common.h index 0b4dc2e49..30757de70 100644 --- a/src/common.h +++ b/src/common.h @@ -46,6 +46,8 @@ #include "thread-utils.h" #include "bswap.h" +#include + extern void git___throw(const char *, ...) GIT_FORMAT_PRINTF(1, 2); #define git__throw(error, ...) \ (git___throw(__VA_ARGS__), error) @@ -54,6 +56,16 @@ extern void git___rethrow(const char *, ...) GIT_FORMAT_PRINTF(1, 2); #define git__rethrow(error, ...) \ (git___rethrow(__VA_ARGS__), error) + +#define GITERR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; } + +void giterr_set_oom(void); +void giterr_set(int error_class, const char *string, ...); +void giterr_clear(void); +void giterr_set_str(int error_class, const char *string); +void giterr_set_regex(const regex_t *regex, int error_code); + + #include "util.h" diff --git a/src/config.c b/src/config.c index 912224158..0ab0cd424 100644 --- a/src/config.c +++ b/src/config.c @@ -7,7 +7,6 @@ #include "common.h" #include "fileops.h" -#include "hashtable.h" #include "config.h" #include "git2/config.h" #include "vector.h" @@ -60,84 +59,77 @@ int git_config_new(git_config **out) git_config *cfg; cfg = git__malloc(sizeof(git_config)); - if (cfg == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(cfg); memset(cfg, 0x0, sizeof(git_config)); if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) { git__free(cfg); - return GIT_ENOMEM; + return -1; } *out = cfg; GIT_REFCOUNT_INC(cfg); - return GIT_SUCCESS; + return 0; } int git_config_add_file_ondisk(git_config *cfg, const char *path, int priority) { git_config_file *file = NULL; - int error; - error = git_config_file__ondisk(&file, path); - if (error < GIT_SUCCESS) - return error; + if (git_config_file__ondisk(&file, path) < 0) + return -1; - error = git_config_add_file(cfg, file, priority); - if (error < GIT_SUCCESS) { + if (git_config_add_file(cfg, file, priority) < 0) { /* * free manually; the file is not owned by the config * instance yet and will not be freed on cleanup */ file->free(file); - return error; + return -1; } - return GIT_SUCCESS; + return 0; } int git_config_open_ondisk(git_config **cfg, const char *path) { - int error; + if (git_config_new(cfg) < 0) + return -1; - error = git_config_new(cfg); - if (error < GIT_SUCCESS) - return error; - - error = git_config_add_file_ondisk(*cfg, path, 1); - if (error < GIT_SUCCESS) + if (git_config_add_file_ondisk(*cfg, path, 1) < 0) { git_config_free(*cfg); + return -1; + } - return error; + return 0; } int git_config_add_file(git_config *cfg, git_config_file *file, int priority) { file_internal *internal; - int error; + int result; assert(cfg && file); - if ((error = file->open(file)) < GIT_SUCCESS) - return git__throw(error, "Failed to open config file"); + if ((result = file->open(file)) < 0) + return result; internal = git__malloc(sizeof(file_internal)); - if (internal == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(internal); internal->file = file; internal->priority = priority; if (git_vector_insert(&cfg->files, internal) < 0) { git__free(internal); - return GIT_ENOMEM; + return -1; } git_vector_sort(&cfg->files); internal->file->cfg = cfg; - return GIT_SUCCESS; + return 0; } /* @@ -146,7 +138,7 @@ int git_config_add_file(git_config *cfg, git_config_file *file, int priority) int git_config_foreach(git_config *cfg, int (*fn)(const char *, const char *, void *), void *data) { - int ret = GIT_SUCCESS; + int ret = 0; unsigned int i; file_internal *internal; git_config_file *file; @@ -165,8 +157,7 @@ int git_config_delete(git_config *cfg, const char *name) file_internal *internal; git_config_file *file; - if (cfg->files.length == 0) - return git__throw(GIT_EINVALIDARGS, "Cannot delete variable; no files open in the `git_config` instance"); + assert(cfg->files.length); internal = git_vector_get(&cfg->files, 0); file = internal->file; @@ -200,8 +191,7 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value) file_internal *internal; git_config_file *file; - if (cfg->files.length == 0) - return git__throw(GIT_EINVALIDARGS, "Cannot set variable value; no files open in the `git_config` instance"); + assert(cfg->files.length); internal = git_vector_get(&cfg->files, 0); file = internal->file; @@ -209,28 +199,28 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value) return file->set(file, name, value); } -static int parse_bool(int *out, const char *value) +int git_config_parse_bool(int *out, const char *value) { /* A missing value means true */ if (value == NULL) { *out = 1; - return GIT_SUCCESS; + return 0; } if (!strcasecmp(value, "true") || !strcasecmp(value, "yes") || !strcasecmp(value, "on")) { *out = 1; - return GIT_SUCCESS; + return 0; } if (!strcasecmp(value, "false") || !strcasecmp(value, "no") || !strcasecmp(value, "off")) { *out = 0; - return GIT_SUCCESS; + return 0; } - return GIT_EINVALIDTYPE; + return -1; } static int parse_int64(int64_t *out, const char *value) @@ -239,7 +229,7 @@ static int parse_int64(int64_t *out, const char *value) int64_t num; if (git__strtol64(&num, value, &num_end, 0) < 0) - return GIT_EINVALIDTYPE; + return -1; switch (*num_end) { case 'g': @@ -259,7 +249,7 @@ static int parse_int64(int64_t *out, const char *value) /* check that that there are no more characters after the * given modifier suffix */ if (num_end[1] != '\0') - return GIT_EINVALIDTYPE; + return -1; /* fallthrough */ @@ -268,7 +258,7 @@ static int parse_int64(int64_t *out, const char *value) return 0; default: - return GIT_EINVALIDTYPE; + return -1; } } @@ -278,11 +268,11 @@ static int parse_int32(int32_t *out, const char *value) int32_t truncate; if (parse_int64(&tmp, value) < 0) - return GIT_EINVALIDTYPE; + return -1; truncate = tmp & 0xFFFFFFFF; if (truncate != tmp) - return GIT_EOVERFLOW; + return -1; *out = truncate; return 0; @@ -291,49 +281,62 @@ static int parse_int32(int32_t *out, const char *value) /*********** * Getters ***********/ -int git_config_get_mapped(git_config *cfg, const char *name, git_cvar_map *maps, size_t map_n, int *out) +int git_config_lookup_map_value( + git_cvar_map *maps, size_t map_n, const char *value, int *out) { size_t i; - const char *value; - int error; - error = git_config_get_string(cfg, name, &value); - if (error < GIT_SUCCESS) - return error; + if (!value) + return GIT_ENOTFOUND; for (i = 0; i < map_n; ++i) { git_cvar_map *m = maps + i; switch (m->cvar_type) { - case GIT_CVAR_FALSE: - case GIT_CVAR_TRUE: { - int bool_val; + case GIT_CVAR_FALSE: + case GIT_CVAR_TRUE: { + int bool_val; - if (parse_bool(&bool_val, value) == 0 && - bool_val == (int)m->cvar_type) { - *out = m->map_value; - return 0; - } - - break; + if (git_config_parse_bool(&bool_val, value) == 0 && + bool_val == (int)m->cvar_type) { + *out = m->map_value; + return 0; } + break; + } - case GIT_CVAR_INT32: - if (parse_int32(out, value) == 0) - return 0; + case GIT_CVAR_INT32: + if (parse_int32(out, value) == 0) + return 0; + break; - break; - - case GIT_CVAR_STRING: - if (strcasecmp(value, m->str_match) == 0) { - *out = m->map_value; - return 0; - } + case GIT_CVAR_STRING: + if (strcasecmp(value, m->str_match) == 0) { + *out = m->map_value; + return 0; + } + break; } } - return git__throw(GIT_ENOTFOUND, + return GIT_ENOTFOUND; +} + +int git_config_get_mapped(git_config *cfg, const char *name, git_cvar_map *maps, size_t map_n, int *out) +{ + const char *value; + int ret; + + ret = git_config_get_string(cfg, name, &value); + if (ret < 0) + return ret; + + if (!git_config_lookup_map_value(maps, map_n, value, out)) + return 0; + + giterr_set(GITERR_CONFIG, "Failed to map the '%s' config variable with a valid value", name); + return -1; } int git_config_get_int64(git_config *cfg, const char *name, int64_t *out) @@ -342,69 +345,73 @@ int git_config_get_int64(git_config *cfg, const char *name, int64_t *out) int ret; ret = git_config_get_string(cfg, name, &value); - if (ret < GIT_SUCCESS) - return git__rethrow(ret, "Failed to retrieve value for '%s'", name); + if (ret < 0) + return ret; - if (parse_int64(out, value) < 0) - return git__throw(GIT_EINVALIDTYPE, "Failed to parse '%s' as an integer", value); + if (parse_int64(out, value) < 0) { + giterr_set(GITERR_CONFIG, "Failed to parse '%s' as an integer", value); + return -1; + } - return GIT_SUCCESS; + return 0; } int git_config_get_int32(git_config *cfg, const char *name, int32_t *out) { const char *value; - int error; + int ret; - error = git_config_get_string(cfg, name, &value); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to get value for %s", name); + ret = git_config_get_string(cfg, name, &value); + if (ret < 0) + return ret; - error = parse_int32(out, value); - if (error < GIT_SUCCESS) - return git__throw(GIT_EINVALIDTYPE, "Failed to parse '%s' as a 32-bit integer", value); - - return GIT_SUCCESS; + if (parse_int32(out, value) < 0) { + giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a 32-bit integer", value); + return -1; + } + + return 0; } int git_config_get_bool(git_config *cfg, const char *name, int *out) { const char *value; - int error = GIT_SUCCESS; + int ret; - error = git_config_get_string(cfg, name, &value); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to get value for %s", name); + ret = git_config_get_string(cfg, name, &value); + if (ret < 0) + return ret; - if (parse_bool(out, value) == 0) - return GIT_SUCCESS; + if (git_config_parse_bool(out, value) == 0) + return 0; if (parse_int32(out, value) == 0) { *out = !!(*out); - return GIT_SUCCESS; + return 0; } - return git__throw(GIT_EINVALIDTYPE, "Failed to parse '%s' as a boolean value", value); + giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a boolean value", value); + return -1; } int git_config_get_string(git_config *cfg, const char *name, const char **out) { file_internal *internal; - git_config_file *file; - int error = GIT_ENOTFOUND; unsigned int i; - if (cfg->files.length == 0) - return git__throw(GIT_EINVALIDARGS, "Cannot get variable value; no files open in the `git_config` instance"); + assert(cfg->files.length); - for (i = 0; i < cfg->files.length; ++i) { - internal = git_vector_get(&cfg->files, i); - file = internal->file; - if ((error = file->get(file, name, out)) == GIT_SUCCESS) - return GIT_SUCCESS; + *out = NULL; + + git_vector_foreach(&cfg->files, i, internal) { + git_config_file *file = internal->file; + int ret = file->get(file, name, out); + if (ret != GIT_ENOTFOUND) + return ret; } - return git__throw(error, "Config value '%s' not found", name); + giterr_set(GITERR_CONFIG, "Config variable '%s' not found", name); + return GIT_ENOTFOUND; } int git_config_get_multivar(git_config *cfg, const char *name, const char *regexp, @@ -412,12 +419,10 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex { file_internal *internal; git_config_file *file; - int error = GIT_ENOTFOUND; + int ret = GIT_ENOTFOUND; unsigned int i; - - if (cfg->files.length == 0) - return git__throw(GIT_EINVALIDARGS, "Cannot get variable value; no files open in the `git_config` instance"); + assert(cfg->files.length); /* * This loop runs the "wrong" way 'round because we need to @@ -426,30 +431,30 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex for (i = cfg->files.length; i > 0; --i) { internal = git_vector_get(&cfg->files, i - 1); file = internal->file; - error = file->get_multivar(file, name, regexp, fn, data); - if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) - git__rethrow(error, "Failed to get multivar"); + ret = file->get_multivar(file, name, regexp, fn, data); + if (ret < 0 && ret != GIT_ENOTFOUND) + return ret; } - return GIT_SUCCESS; + return 0; } int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value) { file_internal *internal; git_config_file *file; - int error = GIT_ENOTFOUND; + int ret = GIT_ENOTFOUND; unsigned int i; for (i = cfg->files.length; i > 0; --i) { internal = git_vector_get(&cfg->files, i - 1); file = internal->file; - error = file->set_multivar(file, name, regexp, value); - if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) - git__rethrow(error, "Failed to replace multivar"); + ret = file->set_multivar(file, name, regexp, value); + if (ret < 0 && ret != GIT_ENOTFOUND) + return ret; } - return GIT_SUCCESS; + return 0; } int git_config_find_global_r(git_buf *path) @@ -460,18 +465,23 @@ int git_config_find_global_r(git_buf *path) int git_config_find_global(char *global_config_path) { git_buf path = GIT_BUF_INIT; - int error = git_config_find_global_r(&path); + int ret = git_config_find_global_r(&path); - if (error == GIT_SUCCESS) { - if (path.size > GIT_PATH_MAX) - error = git__throw(GIT_ESHORTBUFFER, "Path is too long"); - else - git_buf_copy_cstr(global_config_path, GIT_PATH_MAX, &path); + if (ret < 0) { + git_buf_free(&path); + return ret; } - git_buf_free(&path); + if (path.size > GIT_PATH_MAX) { + git_buf_free(&path); + giterr_set(GITERR_NOMEMORY, + "Path is to long to fit on the given buffer"); + return -1; + } - return error; + git_buf_copy_cstr(global_config_path, GIT_PATH_MAX, &path); + git_buf_free(&path); + return 0; } int git_config_find_system_r(git_buf *path) @@ -482,18 +492,23 @@ int git_config_find_system_r(git_buf *path) int git_config_find_system(char *system_config_path) { git_buf path = GIT_BUF_INIT; - int error = git_config_find_system_r(&path); + int ret = git_config_find_system_r(&path); - if (error == GIT_SUCCESS) { - if (path.size > GIT_PATH_MAX) - error = git__throw(GIT_ESHORTBUFFER, "Path is too long"); - else - git_buf_copy_cstr(system_config_path, GIT_PATH_MAX, &path); + if (ret < 0) { + git_buf_free(&path); + return ret; } - git_buf_free(&path); + if (path.size > GIT_PATH_MAX) { + git_buf_free(&path); + giterr_set(GITERR_NOMEMORY, + "Path is to long to fit on the given buffer"); + return -1; + } - return error; + git_buf_copy_cstr(system_config_path, GIT_PATH_MAX, &path); + git_buf_free(&path); + return 0; } int git_config_open_global(git_config **out) @@ -501,7 +516,7 @@ int git_config_open_global(git_config **out) int error; char global_path[GIT_PATH_MAX]; - if ((error = git_config_find_global(global_path)) < GIT_SUCCESS) + if ((error = git_config_find_global(global_path)) < 0) return error; return git_config_open_ondisk(out, global_path); diff --git a/src/config.h b/src/config.h index 59d1d9a26..82e98ce51 100644 --- a/src/config.h +++ b/src/config.h @@ -25,4 +25,9 @@ struct git_config { extern int git_config_find_global_r(git_buf *global_config_path); extern int git_config_find_system_r(git_buf *system_config_path); +extern int git_config_parse_bool(int *out, const char *bool_string); + +extern int git_config_lookup_map_value( + git_cvar_map *maps, size_t map_n, const char *value, int *out); + #endif diff --git a/src/config_cache.c b/src/config_cache.c index 5e20847f5..3679a9646 100644 --- a/src/config_cache.c +++ b/src/config_cache.c @@ -7,7 +7,6 @@ #include "common.h" #include "fileops.h" -#include "hashtable.h" #include "config.h" #include "git2/config.h" #include "vector.h" diff --git a/src/config_file.c b/src/config_file.c index e1f4ef932..746d9655c 100644 --- a/src/config_file.c +++ b/src/config_file.c @@ -12,12 +12,14 @@ #include "buffer.h" #include "git2/config.h" #include "git2/types.h" - +#include "strmap.h" #include #include #include +GIT__USE_STRMAP; + typedef struct cvar_t { struct cvar_t *next; char *key; /* TODO: we might be able to get rid of this */ @@ -70,7 +72,7 @@ typedef struct { typedef struct { git_config_file parent; - git_hashtable *values; + git_strmap *values; struct { git_buf buffer; @@ -86,6 +88,12 @@ static int config_parse(diskfile_backend *cfg_file); static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_value); static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char *value); +static void set_parse_error(diskfile_backend *backend, int col, const char *error_str) +{ + giterr_set(GITERR_CONFIG, "Failed to parse config file: %s (in %s:%d, column %d)", + error_str, backend->file_path, backend->reader.line_number, col); +} + static void cvar_free(cvar_t *var) { if (var == NULL) @@ -104,15 +112,16 @@ static int normalize_name(const char *in, char **out) assert(in && out); name = git__strdup(in); - if (name == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(name); fdot = strchr(name, '.'); ldot = strrchr(name, '.'); if (fdot == NULL || ldot == NULL) { git__free(name); - return git__throw(GIT_EINVALIDARGS, "Bad format. No dot in '%s'", in); + giterr_set(GITERR_CONFIG, + "Invalid variable name: '%s'", in); + return -1; } /* Downcase up to the first dot and after the last one */ @@ -120,60 +129,50 @@ static int normalize_name(const char *in, char **out) git__strtolower(ldot); *out = name; - return GIT_SUCCESS; + return 0; } -static void free_vars(git_hashtable *values) +static void free_vars(git_strmap *values) { cvar_t *var = NULL; if (values == NULL) return; - GIT_HASHTABLE_FOREACH_VALUE(values, var, - do { - cvar_t *next = CVAR_LIST_NEXT(var); - cvar_free(var); - var = next; - } while (var != NULL); - ) + git_strmap_foreach_value(values, var, + while (var != NULL) { + cvar_t *next = CVAR_LIST_NEXT(var); + cvar_free(var); + var = next; + }); - git_hashtable_free(values); + git_strmap_free(values); } static int config_open(git_config_file *cfg) { - int error; + int res; diskfile_backend *b = (diskfile_backend *)cfg; - b->values = git_hashtable_alloc (20, git_hash__strhash_cb, git_hash__strcmp_cb); - if (b->values == NULL) - return GIT_ENOMEM; + b->values = git_strmap_alloc(); + GITERR_CHECK_ALLOC(b->values); git_buf_init(&b->reader.buffer, 0); - error = git_futils_readbuffer(&b->reader.buffer, b->file_path); + res = git_futils_readbuffer(&b->reader.buffer, b->file_path); /* It's fine if the file doesn't exist */ - if (error == GIT_ENOTFOUND) - return GIT_SUCCESS; + if (res == GIT_ENOTFOUND) + return 0; - if (error < GIT_SUCCESS) - goto cleanup; - - error = config_parse(b); - if (error < GIT_SUCCESS) - goto cleanup; + if (res < 0 || config_parse(b) < 0) { + free_vars(b->values); + b->values = NULL; + git_buf_free(&b->reader.buffer); + return -1; + } git_buf_free(&b->reader.buffer); - - return GIT_SUCCESS; - - cleanup: - free_vars(b->values); - b->values = NULL; - git_buf_free(&b->reader.buffer); - - return git__rethrow(error, "Failed to open config"); + return 0; } static void backend_free(git_config_file *_backend) @@ -184,58 +183,61 @@ static void backend_free(git_config_file *_backend) return; git__free(backend->file_path); - free_vars(backend->values); - git__free(backend); } static int file_foreach(git_config_file *backend, int (*fn)(const char *, const char *, void *), void *data) { - int ret = GIT_SUCCESS; - cvar_t *var; diskfile_backend *b = (diskfile_backend *)backend; + cvar_t *var; const char *key; - GIT_HASHTABLE_FOREACH(b->values, key, var, - do { - ret = fn(key, var->value, data); - if (ret) - break; - var = CVAR_LIST_NEXT(var); - } while (var != NULL); - ) + if (!b->values) + return 0; + git_strmap_foreach(b->values, key, var, + do { + if (fn(key, var->value, data) < 0) + break; - return ret; + var = CVAR_LIST_NEXT(var); + } while (var != NULL); + ); + + return 0; } static int config_set(git_config_file *cfg, const char *name, const char *value) { - cvar_t *var = NULL; - cvar_t *existing = NULL, *old_value = NULL; - int error = GIT_SUCCESS; + cvar_t *var = NULL, *old_var; diskfile_backend *b = (diskfile_backend *)cfg; char *key; + khiter_t pos; + int rval; - if ((error = normalize_name(name, &key)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to normalize variable name '%s'", name); + if (normalize_name(name, &key) < 0) + return -1; /* * Try to find it in the existing values and update it if it * only has one value. */ - existing = git_hashtable_lookup(b->values, key); - if (existing != NULL) { - char *tmp; + pos = git_strmap_lookup_index(b->values, key); + if (git_strmap_valid_index(b->values, pos)) { + cvar_t *existing = git_strmap_value_at(b->values, pos); + char *tmp = NULL; git__free(key); - if (existing->next != NULL) - return git__throw(GIT_EINVALIDARGS, "Multivar incompatible with simple set"); + if (existing->next != NULL) { + giterr_set(GITERR_CONFIG, "Multivar incompatible with simple set"); + return -1; + } - tmp = value ? git__strdup(value) : NULL; - if (tmp == NULL && value != NULL) - return GIT_ENOMEM; + if (value) { + tmp = git__strdup(value); + GITERR_CHECK_ALLOC(tmp); + } git__free(existing->value); existing->value = tmp; @@ -244,32 +246,31 @@ static int config_set(git_config_file *cfg, const char *name, const char *value) } var = git__malloc(sizeof(cvar_t)); - if (var == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(var); memset(var, 0x0, sizeof(cvar_t)); var->key = key; + var->value = NULL; - var->value = value ? git__strdup(value) : NULL; - if (var->value == NULL && value != NULL) { - error = GIT_ENOMEM; - goto out; + if (value) { + var->value = git__strdup(value); + GITERR_CHECK_ALLOC(var->value); } - error = git_hashtable_insert2(b->values, key, var, (void **)&old_value); - if (error < GIT_SUCCESS) - goto out; + git_strmap_insert2(b->values, key, var, old_var, rval); + if (rval < 0) + return -1; + if (old_var != NULL) + cvar_free(old_var); - cvar_free(old_value); - - error = config_write(b, key, NULL, value); - - out: - if (error < GIT_SUCCESS) + if (config_write(b, key, NULL, value) < 0) { + git_strmap_delete(b->values, var->key); cvar_free(var); + return -1; + } - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to set config value"); + return 0; } /* @@ -277,172 +278,188 @@ static int config_set(git_config_file *cfg, const char *name, const char *value) */ static int config_get(git_config_file *cfg, const char *name, const char **out) { - cvar_t *var; - int error = GIT_SUCCESS; diskfile_backend *b = (diskfile_backend *)cfg; char *key; + khiter_t pos; - if ((error = normalize_name(name, &key)) < GIT_SUCCESS) - return error; + if (normalize_name(name, &key) < 0) + return -1; - var = git_hashtable_lookup(b->values, key); + pos = git_strmap_lookup_index(b->values, key); git__free(key); - if (var == NULL) - return git__throw(GIT_ENOTFOUND, "Variable '%s' not found", name); + /* no error message; the config system will write one */ + if (!git_strmap_valid_index(b->values, pos)) + return GIT_ENOTFOUND; - *out = var->value; + *out = ((cvar_t *)git_strmap_value_at(b->values, pos))->value; - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to get config value for %s", name); + return 0; } -static int config_get_multivar(git_config_file *cfg, const char *name, const char *regexp, int (*fn)(const char *, void *), void *data) +static int config_get_multivar( + git_config_file *cfg, + const char *name, + const char *regex_str, + int (*fn)(const char *, void *), + void *data) { cvar_t *var; - int error = GIT_SUCCESS; diskfile_backend *b = (diskfile_backend *)cfg; char *key; - regex_t preg; + khiter_t pos; - if ((error = normalize_name(name, &key)) < GIT_SUCCESS) - return error; + if (normalize_name(name, &key) < 0) + return -1; - var = git_hashtable_lookup(b->values, key); + pos = git_strmap_lookup_index(b->values, key); git__free(key); - if (var == NULL) - return git__throw(GIT_ENOTFOUND, "Variable '%s' not found", name); + if (!git_strmap_valid_index(b->values, pos)) + return GIT_ENOTFOUND; - if (regexp != NULL) { - error = regcomp(&preg, regexp, REG_EXTENDED); - if (error < 0) - return git__throw(GIT_EINVALIDARGS, "Failed to compile regex"); - } + var = git_strmap_value_at(b->values, pos); - do { - if (regexp == NULL || !regexec(&preg, var->value, 0, NULL, 0)) { - error = fn(var->value, data); - if (error < GIT_SUCCESS) - goto exit; + if (regex_str != NULL) { + regex_t regex; + int result; + + /* regex matching; build the regex */ + result = regcomp(®ex, regex_str, REG_EXTENDED); + if (result < 0) { + giterr_set_regex(®ex, result); + return -1; } - var = var->next; - } while (var != NULL); + /* and throw the callback only on the variables that + * match the regex */ + do { + if (regexec(®ex, var->value, 0, NULL, 0) == 0) { + /* early termination by the user is not an error; + * just break and return successfully */ + if (fn(var->value, data) < 0) + break; + } - exit: - if (regexp != NULL) - regfree(&preg); - return error; + var = var->next; + } while (var != NULL); + regfree(®ex); + } else { + /* no regex; go through all the variables */ + do { + /* early termination by the user is not an error; + * just break and return successfully */ + if (fn(var->value, data) < 0) + break; + + var = var->next; + } while (var != NULL); + } + + return 0; } -static int config_set_multivar(git_config_file *cfg, const char *name, const char *regexp, const char *value) +static int config_set_multivar( + git_config_file *cfg, const char *name, const char *regexp, const char *value) { - int error, replaced = 0; + int replaced = 0; cvar_t *var, *newvar; diskfile_backend *b = (diskfile_backend *)cfg; char *key; regex_t preg; + int result; + khiter_t pos; - if (regexp == NULL) - return git__throw(GIT_EINVALIDARGS, "No regex supplied"); + assert(regexp); - if ((error = normalize_name(name, &key)) < GIT_SUCCESS) - return error; + if (normalize_name(name, &key) < 0) + return -1; - var = git_hashtable_lookup(b->values, key); - if (var == NULL) { - free(key); - return git__throw(GIT_ENOTFOUND, "Variable '%s' not found", name); + pos = git_strmap_lookup_index(b->values, key); + if (!git_strmap_valid_index(b->values, pos)) { + git__free(key); + return GIT_ENOTFOUND; } - error = regcomp(&preg, regexp, REG_EXTENDED); - if (error < 0) { - free(key); - return git__throw(GIT_EINVALIDARGS, "Failed to compile regex"); + var = git_strmap_value_at(b->values, pos); + + result = regcomp(&preg, regexp, REG_EXTENDED); + if (result < 0) { + git__free(key); + giterr_set_regex(&preg, result); + return -1; } - do { - if (!regexec(&preg, var->value, 0, NULL, 0)) { + for (;;) { + if (regexec(&preg, var->value, 0, NULL, 0) == 0) { char *tmp = git__strdup(value); - if (tmp == NULL) { - error = GIT_ENOMEM; - goto exit; - } + GITERR_CHECK_ALLOC(tmp); - free(var->value); + git__free(var->value); var->value = tmp; replaced = 1; } - if (var->next != NULL) - var = var->next; - else + if (var->next == NULL) break; - } while (var != NULL); + + var = var->next; + } /* If we've reached the end of the variables and we haven't found it yet, we need to append it */ if (!replaced) { newvar = git__malloc(sizeof(cvar_t)); - if (newvar == NULL) { - error = GIT_ENOMEM; - goto exit; - } + GITERR_CHECK_ALLOC(newvar); memset(newvar, 0x0, sizeof(cvar_t)); + newvar->key = git__strdup(var->key); - if (newvar->key == NULL) { - error = GIT_ENOMEM; - goto exit; - } + GITERR_CHECK_ALLOC(newvar->key); + newvar->value = git__strdup(value); - if (newvar->value == NULL) { - error = GIT_ENOMEM; - goto exit; - } + GITERR_CHECK_ALLOC(newvar->value); var->next = newvar; } - error = config_write(b, key, &preg, value); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to update value in file"); - goto exit; - } + result = config_write(b, key, &preg, value); - exit: - free(key); + git__free(key); regfree(&preg); - return error; + + return result; } static int config_delete(git_config_file *cfg, const char *name) { - int error; - const cvar_t *var; - cvar_t *old_value; + cvar_t *var; diskfile_backend *b = (diskfile_backend *)cfg; char *key; + int result; + khiter_t pos; - if ((error = normalize_name(name, &key)) < GIT_SUCCESS) - return error; + if (normalize_name(name, &key) < 0) + return -1; - var = git_hashtable_lookup(b->values, key); - free(key); + pos = git_strmap_lookup_index(b->values, key); + git__free(key); - if (var == NULL) - return git__throw(GIT_ENOTFOUND, "Variable '%s' not found", name); + if (!git_strmap_valid_index(b->values, pos)) + return GIT_ENOTFOUND; - if (var->next != NULL) - return git__throw(GIT_EINVALIDARGS, "Multivar incompatible with simple delete"); + var = git_strmap_value_at(b->values, pos); + if (var->next != NULL) { + giterr_set(GITERR_CONFIG, "Cannot delete multivar with a single delete"); + return -1; + } - if ((error = git_hashtable_remove2(b->values, var->key, (void **)&old_value)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to remove %s from hashtable", key); + git_strmap_delete_at(b->values, pos); - error = config_write(b, var->key, NULL, NULL); - cvar_free(old_value); + result = config_write(b, var->key, NULL, NULL); - return error; + cvar_free(var); + return result; } int git_config_file__ondisk(git_config_file **out, const char *path) @@ -450,16 +467,12 @@ int git_config_file__ondisk(git_config_file **out, const char *path) diskfile_backend *backend; backend = git__malloc(sizeof(diskfile_backend)); - if (backend == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(backend); memset(backend, 0x0, sizeof(diskfile_backend)); backend->file_path = git__strdup(path); - if (backend->file_path == NULL) { - git__free(backend); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(backend->file_path); backend->parent.open = config_open; backend->parent.get = config_get; @@ -472,7 +485,7 @@ int git_config_file__ondisk(git_config_file **out, const char *path) *out = (git_config_file *)backend; - return GIT_SUCCESS; + return 0; } static int cfg_getchar_raw(diskfile_backend *cfg) @@ -551,7 +564,7 @@ static int cfg_peek(diskfile_backend *cfg, int flags) /* * Read and consume a line, returning it in newly-allocated memory. */ -static char *cfg_readline(diskfile_backend *cfg) +static char *cfg_readline(diskfile_backend *cfg, bool skip_whitespace) { char *line = NULL; char *line_src, *line_end; @@ -559,9 +572,11 @@ static char *cfg_readline(diskfile_backend *cfg) line_src = cfg->reader.read_ptr; - /* Skip empty empty lines */ - while (isspace(*line_src)) - ++line_src; + if (skip_whitespace) { + /* Skip empty empty lines */ + while (isspace(*line_src)) + ++line_src; + } line_end = strchr(line_src, '\n'); @@ -621,12 +636,11 @@ GIT_INLINE(int) config_keychar(int c) return isalnum(c) || c == '-'; } -static int parse_section_header_ext(const char *line, const char *base_name, char **section_name) +static int parse_section_header_ext(diskfile_backend *cfg, const char *line, const char *base_name, char **section_name) { int c, rpos; char *first_quote, *last_quote; git_buf buf = GIT_BUF_INIT; - int error = GIT_SUCCESS; int quote_marks; /* * base_name is what came before the space. We should be at the @@ -637,8 +651,10 @@ static int parse_section_header_ext(const char *line, const char *base_name, cha first_quote = strchr(line, '"'); last_quote = strrchr(line, '"'); - if (last_quote - first_quote == 0) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse ext header. There is no final quotation mark"); + if (last_quote - first_quote == 0) { + set_parse_error(cfg, 0, "Missing closing quotation mark in section header"); + return -1; + } git_buf_grow(&buf, strlen(base_name) + last_quote - first_quote + 2); git_buf_printf(&buf, "%s.", base_name); @@ -655,27 +671,30 @@ static int parse_section_header_ext(const char *line, const char *base_name, cha */ do { if (quote_marks == 2) { - puts("too many marks"); - error = git__throw(GIT_EOBJCORRUPTED, "Falied to parse ext header. Text after closing quote"); - goto out; - + set_parse_error(cfg, rpos, "Unexpected text after closing quotes"); + git_buf_free(&buf); + return -1; } switch (c) { case '"': ++quote_marks; continue; + case '\\': c = line[rpos++]; + switch (c) { case '"': case '\\': break; + default: - error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse ext header. Unsupported escape char \\%c", c); - goto out; + set_parse_error(cfg, rpos, "Unsupported escape sequence"); + git_buf_free(&buf); + return -1; } - break; + default: break; } @@ -683,61 +702,53 @@ static int parse_section_header_ext(const char *line, const char *base_name, cha git_buf_putc(&buf, c); } while ((c = line[rpos++]) != ']'); - *section_name = git__strdup(git_buf_cstr(&buf)); - out: - git_buf_free(&buf); - - return error; + *section_name = git_buf_detach(&buf); + return 0; } static int parse_section_header(diskfile_backend *cfg, char **section_out) { char *name, *name_end; int name_length, c, pos; - int error = GIT_SUCCESS; + int result; char *line; - line = cfg_readline(cfg); + line = cfg_readline(cfg, true); if (line == NULL) - return GIT_ENOMEM; + return -1; /* find the end of the variable's name */ name_end = strchr(line, ']'); if (name_end == NULL) { git__free(line); - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse header. Can't find header name end"); + set_parse_error(cfg, 0, "Missing ']' in section header"); + return -1; } name = (char *)git__malloc((size_t)(name_end - line) + 1); - if (name == NULL) { - git__free(line); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(name); name_length = 0; pos = 0; /* Make sure we were given a section header */ c = line[pos++]; - if (c != '[') { - error = git__throw(GIT_ERROR, "Failed to parse header. Didn't get section header. This is a bug"); - goto error; - } + assert(c == '['); c = line[pos++]; do { if (isspace(c)){ name[name_length] = '\0'; - error = parse_section_header_ext(line, name, section_out); + result = parse_section_header_ext(cfg, line, name, section_out); git__free(line); git__free(name); - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse header"); + return result; } if (!config_keychar(c) && c != '.') { - error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse header. Wrong format on header"); - goto error; + set_parse_error(cfg, pos, "Unexpected character in header"); + goto fail_parse; } name[name_length++] = (char) tolower(c); @@ -745,20 +756,21 @@ static int parse_section_header(diskfile_backend *cfg, char **section_out) } while ((c = line[pos++]) != ']'); if (line[pos - 1] != ']') { - error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse header. Config file ended unexpectedly"); - goto error; + set_parse_error(cfg, pos, "Unexpected end of file"); + goto fail_parse; } - name[name_length] = 0; git__free(line); - git__strtolower(name); - *section_out = name; - return GIT_SUCCESS; -error: + name[name_length] = 0; + *section_out = name; + + return 0; + +fail_parse: git__free(line); git__free(name); - return error; + return -1; } static int skip_bom(diskfile_backend *cfg) @@ -766,7 +778,7 @@ static int skip_bom(diskfile_backend *cfg) static const char utf8_bom[] = "\xef\xbb\xbf"; if (cfg->reader.buffer.size < sizeof(utf8_bom)) - return GIT_SUCCESS; + return 0; if (memcmp(cfg->reader.read_ptr, utf8_bom, sizeof(utf8_bom)) == 0) cfg->reader.read_ptr += sizeof(utf8_bom); @@ -775,7 +787,7 @@ static int skip_bom(diskfile_backend *cfg) shit with the BoM */ - return GIT_SUCCESS; + return 0; } /* @@ -817,9 +829,9 @@ static int skip_bom(diskfile_backend *cfg) boolean_false = "no" | "0" | "false" | "off" */ -static void strip_comments(char *line) +static int strip_comments(char *line, int in_quotes) { - int quote_count = 0; + int quote_count = in_quotes; char *ptr; for (ptr = line; *ptr; ++ptr) { @@ -832,19 +844,25 @@ static void strip_comments(char *line) } } + /* skip any space at the end */ if (isspace(ptr[-1])) { - /* TODO skip whitespace */ + ptr--; } + ptr[0] = '\0'; + + return quote_count; } static int config_parse(diskfile_backend *cfg_file) { - int error = GIT_SUCCESS, c; + int c; char *current_section = NULL; char *var_name; char *var_value; cvar_t *var, *existing; git_buf buf = GIT_BUF_INIT; + int result = 0; + khiter_t pos; /* Initialize the reading position */ cfg_file->reader.read_ptr = cfg_file->reader.buffer.ptr; @@ -852,11 +870,11 @@ static int config_parse(diskfile_backend *cfg_file) /* If the file is empty, there's nothing for us to do */ if (*cfg_file->reader.read_ptr == '\0') - return GIT_SUCCESS; + return 0; skip_bom(cfg_file); - while (error == GIT_SUCCESS && !cfg_file->reader.eof) { + while (result == 0 && !cfg_file->reader.eof) { c = cfg_peek(cfg_file, SKIP_WHITESPACE); @@ -868,7 +886,7 @@ static int config_parse(diskfile_backend *cfg_file) case '[': /* section header, new section begins */ git__free(current_section); current_section = NULL; - error = parse_section_header(cfg_file, ¤t_section); + result = parse_section_header(cfg_file, ¤t_section); break; case ';': @@ -877,16 +895,12 @@ static int config_parse(diskfile_backend *cfg_file) break; default: /* assume variable declaration */ - error = parse_variable(cfg_file, &var_name, &var_value); - - if (error < GIT_SUCCESS) + result = parse_variable(cfg_file, &var_name, &var_value); + if (result < 0) break; var = git__malloc(sizeof(cvar_t)); - if (var == NULL) { - error = GIT_ENOMEM; - break; - } + GITERR_CHECK_ALLOC(var); memset(var, 0x0, sizeof(cvar_t)); @@ -894,19 +908,21 @@ static int config_parse(diskfile_backend *cfg_file) git_buf_printf(&buf, "%s.%s", current_section, var_name); git__free(var_name); - if (git_buf_oom(&buf)) { - error = GIT_ENOMEM; - break; - } + if (git_buf_oom(&buf)) + return -1; var->key = git_buf_detach(&buf); var->value = var_value; /* Add or append the new config option */ - existing = git_hashtable_lookup(cfg_file->values, var->key); - if (existing == NULL) { - error = git_hashtable_insert(cfg_file->values, var->key, var); + pos = git_strmap_lookup_index(cfg_file->values, var->key); + if (!git_strmap_valid_index(cfg_file->values, pos)) { + git_strmap_insert(cfg_file->values, var->key, var, result); + if (result < 0) + break; + result = 0; } else { + existing = git_strmap_value_at(cfg_file->values, pos); while (existing->next != NULL) { existing = existing->next; } @@ -918,13 +934,12 @@ static int config_parse(diskfile_backend *cfg_file) } git__free(current_section); - - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse config"); + return result; } static int write_section(git_filebuf *file, const char *key) { - int error; + int result; const char *dot; git_buf buf = GIT_BUF_INIT; @@ -939,13 +954,14 @@ static int write_section(git_filebuf *file, const char *key) git_buf_printf(&buf, " \"%s\"", dot + 1); } git_buf_puts(&buf, "]\n"); - if (git_buf_oom(&buf)) - return GIT_ENOMEM; - error = git_filebuf_write(file, git_buf_cstr(&buf), buf.size); + if (git_buf_oom(&buf)) + return -1; + + result = git_filebuf_write(file, git_buf_cstr(&buf), buf.size); git_buf_free(&buf); - return error; + return result; } /* @@ -953,50 +969,45 @@ static int write_section(git_filebuf *file, const char *key) */ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char* value) { - int error = GIT_SUCCESS, c; - int section_matches = 0, last_section_matched = 0, preg_replaced = 0; - char *current_section = NULL, *section, *name, *ldot; - char *var_name, *var_value; - git_filebuf file = GIT_FILEBUF_INIT; + int result, c; + int section_matches = 0, last_section_matched = 0, preg_replaced = 0, write_trailer = 0; const char *pre_end = NULL, *post_start = NULL, *data_start; + char *current_section = NULL, *section, *name, *ldot; + git_filebuf file = GIT_FILEBUF_INIT; /* We need to read in our own config file */ - error = git_futils_readbuffer(&cfg->reader.buffer, cfg->file_path); - if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) { - return git__rethrow(error, "Failed to read existing config file %s", cfg->file_path); - } + result = git_futils_readbuffer(&cfg->reader.buffer, cfg->file_path); /* Initialise the reading position */ - if (error == GIT_ENOTFOUND) { - error = GIT_SUCCESS; + if (result == GIT_ENOTFOUND) { cfg->reader.read_ptr = NULL; cfg->reader.eof = 1; data_start = NULL; git_buf_clear(&cfg->reader.buffer); - } else { + } else if (result == 0) { cfg->reader.read_ptr = cfg->reader.buffer.ptr; cfg->reader.eof = 0; data_start = cfg->reader.read_ptr; + } else { + return -1; /* OS error when reading the file */ } /* Lock the file */ - error = git_filebuf_open(&file, cfg->file_path, 0); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lock config file"); + if (git_filebuf_open(&file, cfg->file_path, 0) < 0) + return -1; skip_bom(cfg); ldot = strrchr(key, '.'); name = ldot + 1; section = git__strndup(key, ldot - key); - while (error == GIT_SUCCESS && !cfg->reader.eof) { + while (!cfg->reader.eof) { c = cfg_peek(cfg, SKIP_WHITESPACE); - switch (c) { - case '\0': /* We've arrived at the end of the file */ + if (c == '\0') { /* We've arrived at the end of the file */ break; - case '[': /* section header, new section begins */ + } else if (c == '[') { /* section header, new section begins */ /* * We set both positions to the current one in case we * need to add a variable to the end of a section. In that @@ -1005,23 +1016,21 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p * default case will take care of updating them. */ pre_end = post_start = cfg->reader.read_ptr; - if (current_section) - git__free(current_section); - error = parse_section_header(cfg, ¤t_section); - if (error < GIT_SUCCESS) - break; + + git__free(current_section); + if (parse_section_header(cfg, ¤t_section) < 0) + goto rewrite_fail; /* Keep track of when it stops matching */ last_section_matched = section_matches; section_matches = !strcmp(current_section, section); - break; + } - case ';': - case '#': + else if (c == ';' || c == '#') { cfg_consume_line(cfg); - break; + } - default: + else { /* * If the section doesn't match, but the last section did, * it means we need to add a variable (so skip the line @@ -1035,67 +1044,54 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p if (!section_matches) { if (!last_section_matched) { cfg_consume_line(cfg); - break; + continue; } } else { - int cmp = -1; + int has_matched = 0; + char *var_name, *var_value; pre_end = cfg->reader.read_ptr; - if ((error = parse_variable(cfg, &var_name, &var_value)) == GIT_SUCCESS) - cmp = strcasecmp(name, var_name); + if (parse_variable(cfg, &var_name, &var_value) < 0) + goto rewrite_fail; - if (cmp == 0 && preg != NULL) - cmp = regexec(preg, var_value, 0, NULL, 0); + /* First try to match the name of the variable */ + if (strcasecmp(name, var_name) == 0) + has_matched = 1; + + /* If the name matches, and we have a regex to match the + * value, try to match it */ + if (has_matched && preg != NULL) + has_matched = (regexec(preg, var_value, 0, NULL, 0) == 0); git__free(var_name); git__free(var_value); - if (cmp != 0) - break; + /* if there is no match, keep going */ + if (!has_matched) + continue; post_start = cfg->reader.read_ptr; } - /* - * We've found the variable we wanted to change, so - * write anything up to it - */ + /* We've found the variable we wanted to change, so + * write anything up to it */ + git_filebuf_write(&file, data_start, pre_end - data_start); preg_replaced = 1; - error = git_filebuf_write(&file, data_start, pre_end - data_start); - if (error < GIT_SUCCESS) { - git__rethrow(error, "Failed to write the first part of the file"); - break; - } - - /* - * Then replace the variable. If the value is NULL, it - * means we want to delete it, so pretend everything went - * fine - */ - if (value == NULL) - error = GIT_SUCCESS; - else - error = git_filebuf_printf(&file, "\t%s = %s\n", name, value); - if (error < GIT_SUCCESS) { - git__rethrow(error, "Failed to overwrite the variable"); - break; + + /* Then replace the variable. If the value is NULL, it + * means we want to delete it, so don't write anything. */ + if (value != NULL) { + git_filebuf_printf(&file, "\t%s = %s\n", name, value); } + /* multiline variable? we need to keep reading lines to match */ if (preg != NULL) { data_start = post_start; continue; } - /* And then the write out rest of the file */ - error = git_filebuf_write(&file, post_start, - cfg->reader.buffer.size - (post_start - data_start)); - - if (error < GIT_SUCCESS) { - git__rethrow(error, "Failed to write the rest of the file"); - break; - } - - goto cleanup; + write_trailer = 1; + break; /* break from the loop */ } } @@ -1115,134 +1111,159 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p * want to write the rest of the file. Otherwise we need to write * out the whole file and then the new variable. */ - if (preg_replaced) { - error = git_filebuf_printf(&file, "\n%s", data_start); - if (error < GIT_SUCCESS) - error = git__rethrow(error, "Failed to write the rest of the file"); + if (write_trailer) { + /* Write out rest of the file */ + git_filebuf_write(&file, post_start, cfg->reader.buffer.size - (post_start - data_start)); + } else { + if (preg_replaced) { + git_filebuf_printf(&file, "\n%s", data_start); + } else { + git_filebuf_write(&file, cfg->reader.buffer.ptr, cfg->reader.buffer.size); - goto cleanup; + /* And now if we just need to add a variable */ + if (!section_matches && write_section(&file, section) < 0) + goto rewrite_fail; + + /* Sanity check: if we are here, and value is NULL, that means that somebody + * touched the config file after our intial read. We should probably assert() + * this, but instead we'll handle it gracefully with an error. */ + if (value == NULL) { + giterr_set(GITERR_CONFIG, + "Race condition when writing a config file (a cvar has been removed)"); + goto rewrite_fail; + } + + git_filebuf_printf(&file, "\t%s = %s\n", name, value); + } } - error = git_filebuf_write(&file, cfg->reader.buffer.ptr, cfg->reader.buffer.size); - if (error < GIT_SUCCESS) { - git__rethrow(error, "Failed to write original config content"); - goto cleanup; - } - - /* And now if we just need to add a variable */ - if (section_matches) { - error = git_filebuf_printf(&file, "\t%s = %s\n", name, value); - goto cleanup; - } - - /* Or maybe we need to write out a whole section */ - error = write_section(&file, section); - if (error < GIT_SUCCESS) - git__rethrow(error, "Failed to write new section"); - - error = git_filebuf_printf(&file, "\t%s = %s\n", name, value); - cleanup: git__free(section); git__free(current_section); - if (error < GIT_SUCCESS) - git_filebuf_cleanup(&file); - else - error = git_filebuf_commit(&file, GIT_CONFIG_FILE_MODE); - + result = git_filebuf_commit(&file, GIT_CONFIG_FILE_MODE); git_buf_free(&cfg->reader.buffer); - return error; + return result; + +rewrite_fail: + git__free(section); + git__free(current_section); + + git_filebuf_cleanup(&file); + git_buf_free(&cfg->reader.buffer); + return -1; +} + +/* '\"' -> '"' etc */ +static char *fixup_line(const char *ptr, int quote_count) +{ + char *str = git__malloc(strlen(ptr) + 1); + char *out = str, *esc; + const char *escapes = "ntb\"\\"; + const char *escaped = "\n\t\b\"\\"; + + if (str == NULL) + return NULL; + + while (*ptr != '\0') { + if (*ptr == '"') { + quote_count++; + } else if (*ptr != '\\') { + *out++ = *ptr; + } else { + /* backslash, check the next char */ + ptr++; + /* if we're at the end, it's a multiline, so keep the backslash */ + if (*ptr == '\0') { + *out++ = '\\'; + goto out; + } + if ((esc = strchr(escapes, *ptr)) != NULL) { + *out++ = escaped[esc - escapes]; + } else { + git__free(str); + giterr_set(GITERR_CONFIG, "Invalid escape at %s", ptr); + return NULL; + } + } + ptr++; + } + +out: + *out = '\0'; + + return str; } static int is_multiline_var(const char *str) { - char *end = strrchr(str, '\0') - 1; - - while (isspace(*end)) - --end; - - return *end == '\\'; + const char *end = str + strlen(str); + return (end > str) && (end[-1] == '\\'); } -static int parse_multiline_variable(diskfile_backend *cfg, const char *first, char **out) +static int parse_multiline_variable(diskfile_backend *cfg, git_buf *value, int in_quotes) { - char *line = NULL, *end; - int error = GIT_SUCCESS, ret; - size_t len; - char *buf; + char *line = NULL, *proc_line = NULL; + int quote_count; /* Check that the next line exists */ - line = cfg_readline(cfg); + line = cfg_readline(cfg, false); if (line == NULL) - return GIT_ENOMEM; + return -1; /* We've reached the end of the file, there is input missing */ if (line[0] == '\0') { - error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse multiline var. File ended unexpectedly"); - goto out; + set_parse_error(cfg, 0, "Unexpected end of file while parsing multine var"); + git__free(line); + return -1; } - strip_comments(line); + quote_count = strip_comments(line, !!in_quotes); /* If it was just a comment, pretend it didn't exist */ if (line[0] == '\0') { - error = parse_multiline_variable(cfg, first, out); - goto out; + git__free(line); + return parse_multiline_variable(cfg, value, quote_count); + /* TODO: unbounded recursion. This **could** be exploitable */ } - /* Find the continuation character '\' and strip the whitespace */ - end = strrchr(first, '\\'); - while (isspace(end[-1])) - --end; + /* Drop the continuation character '\': to closely follow the UNIX + * standard, this character **has** to be last one in the buf, with + * no whitespace after it */ + assert(is_multiline_var(value->ptr)); + git_buf_truncate(value, git_buf_len(value) - 1); - *end = '\0'; /* Terminate the string here */ - - len = strlen(first) + strlen(line) + 2; - buf = git__malloc(len); - if (buf == NULL) { - error = GIT_ENOMEM; - goto out; - } - - ret = p_snprintf(buf, len, "%s %s", first, line); - if (ret < 0) { - error = git__throw(GIT_EOSERR, "Failed to parse multiline var. Failed to put together two lines. OS err: %s", strerror(errno)); - git__free(buf); - goto out; + proc_line = fixup_line(line, in_quotes); + if (proc_line == NULL) { + git__free(line); + return -1; } + /* add this line to the multiline var */ + git_buf_puts(value, proc_line); + git__free(line); + git__free(proc_line); /* - * If we need to continue reading the next line, pretend - * everything we've read up to now was in one line and call - * ourselves. + * If we need to continue reading the next line, let's just + * keep putting stuff in the buffer */ - if (is_multiline_var(buf)) { - char *final_val; - error = parse_multiline_variable(cfg, buf, &final_val); - git__free(buf); - buf = final_val; - } + if (is_multiline_var(value->ptr)) + return parse_multiline_variable(cfg, value, quote_count); - *out = buf; - - out: - git__free(line); - return error; + return 0; } static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_value) { - char *tmp; - int error = GIT_SUCCESS; const char *var_end = NULL; const char *value_start = NULL; char *line; + int quote_count; - line = cfg_readline(cfg); + line = cfg_readline(cfg, true); if (line == NULL) - return GIT_ENOMEM; + return -1; - strip_comments(line); + quote_count = strip_comments(line, 0); var_end = strchr(line, '='); @@ -1256,52 +1277,42 @@ static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_val while (isspace(var_end[0])); } - tmp = git__strndup(line, var_end - line + 1); - if (tmp == NULL) { - error = GIT_ENOMEM; - goto out; - } + *var_name = git__strndup(line, var_end - line + 1); + GITERR_CHECK_ALLOC(*var_name); - *var_name = tmp; + /* If there is no value, boolean true is assumed */ + *var_value = NULL; /* * Now, let's try to parse the value */ if (value_start != NULL) { - while (isspace(value_start[0])) value_start++; - if (value_start[0] == '\0') { - *var_value = NULL; - goto out; - } - if (is_multiline_var(value_start)) { - error = parse_multiline_variable(cfg, value_start, var_value); - if (error != GIT_SUCCESS) - { - *var_value = NULL; + git_buf multi_value = GIT_BUF_INIT; + char *proc_line = fixup_line(value_start, 0); + GITERR_CHECK_ALLOC(proc_line); + git_buf_puts(&multi_value, proc_line); + git__free(proc_line); + if (parse_multiline_variable(cfg, &multi_value, quote_count) < 0 || git_buf_oom(&multi_value)) { git__free(*var_name); + git__free(line); + git_buf_free(&multi_value); + return -1; } - goto out; + + *var_value = git_buf_detach(&multi_value); + + } + else if (value_start[0] != '\0') { + *var_value = fixup_line(value_start, 0); + GITERR_CHECK_ALLOC(*var_value); } - tmp = git__strdup(value_start); - if (tmp == NULL) { - git__free(*var_name); - *var_value = NULL; - error = GIT_ENOMEM; - goto out; - } - - *var_value = tmp; - } else { - /* If there is no value, boolean true is assumed */ - *var_value = NULL; } - out: git__free(line); - return error; + return 0; } diff --git a/src/config_file.h b/src/config_file.h new file mode 100644 index 000000000..0080b5713 --- /dev/null +++ b/src/config_file.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 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_config_file_h__ +#define INCLUDE_config_file_h__ + +#include "git2/config.h" + +GIT_INLINE(int) git_config_file_open(git_config_file *cfg) +{ + return cfg->open(cfg); +} + +GIT_INLINE(void) git_config_file_free(git_config_file *cfg) +{ + cfg->free(cfg); +} + +GIT_INLINE(int) git_config_file_foreach( + git_config_file *cfg, + int (*fn)(const char *key, const char *value, void *data), + void *data) +{ + return cfg->foreach(cfg, fn, data); +} + +#endif + diff --git a/src/crlf.c b/src/crlf.c index f0ec7b736..5d09a1f40 100644 --- a/src/crlf.c +++ b/src/crlf.c @@ -82,7 +82,8 @@ static int crlf_load_attributes(struct crlf_attrs *ca, git_repository *repo, con const char *attr_vals[NUM_CONV_ATTRS]; int error; - error = git_attr_get_many(repo, path, NUM_CONV_ATTRS, attr_names, attr_vals); + error = git_attr_get_many( + repo, 0, path, NUM_CONV_ATTRS, attr_names, attr_vals); if (error == GIT_ENOTFOUND) { ca->crlf_action = GIT_CRLF_GUESS; @@ -105,7 +106,7 @@ static int crlf_load_attributes(struct crlf_attrs *ca, git_repository *repo, con static int drop_crlf(git_buf *dest, const git_buf *source) { const char *scan = source->ptr, *next; - const char *scan_end = source->ptr + source->size; + const char *scan_end = git_buf_cstr(source) + git_buf_len(source); /* Main scan loop. Find the next carriage return and copy the * whole chunk up to that point to the destination buffer. @@ -128,8 +129,7 @@ static int drop_crlf(git_buf *dest, const git_buf *source) /* Copy remaining input into dest */ git_buf_put(dest, scan, scan_end - scan); - - return git_buf_lasterror(dest); + return 0; } static int crlf_apply_to_odb(git_filter *self, git_buf *dest, const git_buf *source) @@ -139,7 +139,7 @@ static int crlf_apply_to_odb(git_filter *self, git_buf *dest, const git_buf *sou assert(self && dest && source); /* Empty file? Nothing to do */ - if (source->size == 0) + if (git_buf_len(source) == 0) return 0; /* Heuristics to see if we can skip the conversion. @@ -217,8 +217,7 @@ int git_filter_add__crlf_to_odb(git_vector *filters, git_repository *repo, const /* If we're good, we create a new filter object and push it * into the filters array */ filter = git__malloc(sizeof(struct crlf_filter)); - if (filter == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(filter); filter->f.apply = &crlf_apply_to_odb; filter->f.do_free = NULL; diff --git a/src/delta-apply.c b/src/delta-apply.c index 24eba2bda..d3be084e0 100644 --- a/src/delta-apply.c +++ b/src/delta-apply.c @@ -51,14 +51,19 @@ int git__delta_apply( * if not we would underflow while accessing data from the * base object, resulting in data corruption or segfault. */ - if ((hdr_sz(&base_sz, &delta, delta_end) < 0) || (base_sz != base_len)) - return git__throw(GIT_ERROR, "Failed to apply delta. Base size does not match given data"); + if ((hdr_sz(&base_sz, &delta, delta_end) < 0) || (base_sz != base_len)) { + giterr_set(GITERR_INVALID, "Failed to apply delta. Base size does not match given data"); + return -1; + } - if (hdr_sz(&res_sz, &delta, delta_end) < 0) - return git__throw(GIT_ERROR, "Failed to apply delta. Base size does not match given data"); + if (hdr_sz(&res_sz, &delta, delta_end) < 0) { + giterr_set(GITERR_INVALID, "Failed to apply delta. Base size does not match given data"); + return -1; + } + + res_dp = git__malloc(res_sz + 1); + GITERR_CHECK_ALLOC(res_dp); - if ((res_dp = git__malloc(res_sz + 1)) == NULL) - return GIT_ENOMEM; res_dp[res_sz] = '\0'; out->data = res_dp; out->len = res_sz; @@ -111,5 +116,6 @@ int git__delta_apply( fail: git__free(out->data); out->data = NULL; - return git__throw(GIT_ERROR, "Failed to apply delta"); + giterr_set(GITERR_INVALID, "Failed to apply delta"); + return -1; } diff --git a/src/diff.c b/src/diff.c index db339d74e..524cc9f59 100644 --- a/src/diff.c +++ b/src/diff.c @@ -8,23 +8,47 @@ #include "git2/diff.h" #include "diff.h" #include "fileops.h" +#include "config.h" +#include "attr_file.h" -static void diff_delta__free(git_diff_delta *delta) +static bool diff_pathspec_is_interesting(const git_strarray *pathspec) { - if (!delta) - return; + const char *str; - if (delta->new_file.flags & GIT_DIFF_FILE_FREE_PATH) { - git__free((char *)delta->new_file.path); - delta->new_file.path = NULL; + if (pathspec == NULL || pathspec->count == 0) + return false; + if (pathspec->count > 1) + return true; + + str = pathspec->strings[0]; + if (!str || !str[0] || (!str[1] && (str[0] == '*' || str[0] == '.'))) + return false; + return true; +} + +static bool diff_path_matches_pathspec(git_diff_list *diff, const char *path) +{ + unsigned int i; + git_attr_fnmatch *match; + + if (!diff->pathspec.length) + return true; + + git_vector_foreach(&diff->pathspec, i, match) { + int result = p_fnmatch(match->pattern, path, 0); + + /* if we didn't match, look for exact dirname prefix match */ + if (result == FNM_NOMATCH && + (match->flags & GIT_ATTR_FNMATCH_HASWILD) == 0 && + strncmp(path, match->pattern, match->length) == 0 && + path[match->length] == '/') + result = 0; + + if (result == 0) + return (match->flags & GIT_ATTR_FNMATCH_NEGATIVE) ? false : true; } - if (delta->old_file.flags & GIT_DIFF_FILE_FREE_PATH) { - git__free((char *)delta->old_file.path); - delta->old_file.path = NULL; - } - - git__free(delta); + return false; } static git_diff_delta *diff_delta__alloc( @@ -36,12 +60,12 @@ static git_diff_delta *diff_delta__alloc( if (!delta) return NULL; - delta->old_file.path = git__strdup(path); + delta->old_file.path = git_pool_strdup(&diff->pool, path); if (delta->old_file.path == NULL) { git__free(delta); return NULL; } - delta->old_file.flags |= GIT_DIFF_FILE_FREE_PATH; + delta->new_file.path = delta->old_file.path; if (diff->opts.flags & GIT_DIFF_REVERSE) { @@ -56,7 +80,8 @@ static git_diff_delta *diff_delta__alloc( return delta; } -static git_diff_delta *diff_delta__dup(const git_diff_delta *d) +static git_diff_delta *diff_delta__dup( + const git_diff_delta *d, git_pool *pool) { git_diff_delta *delta = git__malloc(sizeof(git_diff_delta)); if (!delta) @@ -64,33 +89,29 @@ static git_diff_delta *diff_delta__dup(const git_diff_delta *d) memcpy(delta, d, sizeof(git_diff_delta)); - delta->old_file.path = git__strdup(d->old_file.path); - if (delta->old_file.path == NULL) { - git__free(delta); - return NULL; - } - delta->old_file.flags |= GIT_DIFF_FILE_FREE_PATH; + delta->old_file.path = git_pool_strdup(pool, d->old_file.path); + if (delta->old_file.path == NULL) + goto fail; if (d->new_file.path != d->old_file.path) { - delta->new_file.path = git__strdup(d->new_file.path); - if (delta->new_file.path == NULL) { - git__free(delta->old_file.path); - git__free(delta); - return NULL; - } - delta->new_file.flags |= GIT_DIFF_FILE_FREE_PATH; + delta->new_file.path = git_pool_strdup(pool, d->new_file.path); + if (delta->new_file.path == NULL) + goto fail; } else { delta->new_file.path = delta->old_file.path; - delta->new_file.flags &= ~GIT_DIFF_FILE_FREE_PATH; } return delta; + +fail: + git__free(delta); + return NULL; } static git_diff_delta *diff_delta__merge_like_cgit( - const git_diff_delta *a, const git_diff_delta *b) + const git_diff_delta *a, const git_diff_delta *b, git_pool *pool) { - git_diff_delta *dup = diff_delta__dup(a); + git_diff_delta *dup = diff_delta__dup(a, pool); if (!dup) return NULL; @@ -101,9 +122,7 @@ static git_diff_delta *diff_delta__merge_like_cgit( dup->new_file.mode = b->new_file.mode; dup->new_file.size = b->new_file.size; - dup->new_file.flags = - (dup->new_file.flags & GIT_DIFF_FILE_FREE_PATH) | - (b->new_file.flags & ~GIT_DIFF_FILE_FREE_PATH); + dup->new_file.flags = b->new_file.flags; /* Emulate C git for merging two diffs (a la 'git diff '). * @@ -132,10 +151,21 @@ static int diff_delta__from_one( git_delta_t status, const git_index_entry *entry) { - int error; - git_diff_delta *delta = diff_delta__alloc(diff, status, entry->path); - if (!delta) - return git__rethrow(GIT_ENOMEM, "Could not allocate diff record"); + git_diff_delta *delta; + + if (status == GIT_DELTA_IGNORED && + (diff->opts.flags & GIT_DIFF_INCLUDE_IGNORED) == 0) + return 0; + + if (status == GIT_DELTA_UNTRACKED && + (diff->opts.flags & GIT_DIFF_INCLUDE_UNTRACKED) == 0) + return 0; + + if (!diff_path_matches_pathspec(diff, entry->path)) + return 0; + + delta = diff_delta__alloc(diff, status, entry->path); + GITERR_CHECK_ALLOC(delta); /* This fn is just for single-sided diffs */ assert(status != GIT_DELTA_MODIFIED); @@ -153,10 +183,12 @@ static int diff_delta__from_one( delta->old_file.flags |= GIT_DIFF_FILE_VALID_OID; delta->new_file.flags |= GIT_DIFF_FILE_VALID_OID; - if ((error = git_vector_insert(&diff->deltas, delta)) < GIT_SUCCESS) - diff_delta__free(delta); + if (git_vector_insert(&diff->deltas, delta) < 0) { + git__free(delta); + return -1; + } - return error; + return 0; } static int diff_delta__from_two( @@ -166,9 +198,12 @@ static int diff_delta__from_two( const git_index_entry *new_entry, git_oid *new_oid) { - int error; git_diff_delta *delta; + if (status == GIT_DELTA_UNMODIFIED && + (diff->opts.flags & GIT_DIFF_INCLUDE_UNMODIFIED) == 0) + return 0; + if ((diff->opts.flags & GIT_DIFF_REVERSE) != 0) { const git_index_entry *temp = old_entry; old_entry = new_entry; @@ -176,8 +211,7 @@ static int diff_delta__from_two( } delta = diff_delta__alloc(diff, status, old_entry->path); - if (!delta) - return git__rethrow(GIT_ENOMEM, "Could not allocate diff record"); + GITERR_CHECK_ALLOC(delta); delta->old_file.mode = old_entry->mode; git_oid_cpy(&delta->old_file.oid, &old_entry->oid); @@ -188,28 +222,23 @@ static int diff_delta__from_two( if (new_oid || !git_oid_iszero(&new_entry->oid)) delta->new_file.flags |= GIT_DIFF_FILE_VALID_OID; - if ((error = git_vector_insert(&diff->deltas, delta)) < GIT_SUCCESS) - diff_delta__free(delta); + if (git_vector_insert(&diff->deltas, delta) < 0) { + git__free(delta); + return -1; + } - return error; + return 0; } -#define DIFF_OLD_PREFIX_DEFAULT "a/" -#define DIFF_NEW_PREFIX_DEFAULT "b/" - -static char *diff_strdup_prefix(const char *prefix) +static char *diff_strdup_prefix(git_pool *pool, const char *prefix) { size_t len = strlen(prefix); - char *str = git__malloc(len + 2); - if (str != NULL) { - memcpy(str, prefix, len + 1); - /* append '/' at end if needed */ - if (len > 0 && str[len - 1] != '/') { - str[len] = '/'; - str[len + 1] = '\0'; - } - } - return str; + + /* append '/' at end if needed */ + if (len > 0 && prefix[len - 1] != '/') + return git_pool_strcat(pool, prefix, "/"); + else + return git_pool_strndup(pool, prefix, len + 1); } static int diff_delta__cmp(const void *a, const void *b) @@ -219,29 +248,55 @@ static int diff_delta__cmp(const void *a, const void *b) return val ? val : ((int)da->status - (int)db->status); } +static int config_bool(git_config *cfg, const char *name, int defvalue) +{ + int val = defvalue; + if (git_config_get_bool(cfg, name, &val) < 0) + giterr_clear(); + return val; +} + static git_diff_list *git_diff_list_alloc( git_repository *repo, const git_diff_options *opts) { + git_config *cfg; + size_t i; git_diff_list *diff = git__calloc(1, sizeof(git_diff_list)); if (diff == NULL) return NULL; diff->repo = repo; + if (git_vector_init(&diff->deltas, 0, diff_delta__cmp) < 0 || + git_pool_init(&diff->pool, 1, 0) < 0) + goto fail; + + /* load config values that affect diff behavior */ + if (git_repository_config__weakptr(&cfg, repo) < 0) + goto fail; + if (config_bool(cfg, "core.symlinks", 1)) + diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_HAS_SYMLINKS; + if (config_bool(cfg, "core.ignorestat", 0)) + diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_ASSUME_UNCHANGED; + if (config_bool(cfg, "core.filemode", 1)) + diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_EXEC_BIT; + if (config_bool(cfg, "core.trustctime", 1)) + diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_CTIME; + /* Don't set GIT_DIFFCAPS_USE_DEV - compile time option in core git */ + if (opts == NULL) return diff; memcpy(&diff->opts, opts, sizeof(git_diff_options)); + memset(&diff->opts.pathspec, 0, sizeof(diff->opts.pathspec)); - diff->opts.old_prefix = diff_strdup_prefix( + diff->opts.old_prefix = diff_strdup_prefix(&diff->pool, opts->old_prefix ? opts->old_prefix : DIFF_OLD_PREFIX_DEFAULT); - diff->opts.new_prefix = diff_strdup_prefix( + diff->opts.new_prefix = diff_strdup_prefix(&diff->pool, opts->new_prefix ? opts->new_prefix : DIFF_NEW_PREFIX_DEFAULT); - if (!diff->opts.old_prefix || !diff->opts.new_prefix) { - git__free(diff); - return NULL; - } + if (!diff->opts.old_prefix || !diff->opts.new_prefix) + goto fail; if (diff->opts.flags & GIT_DIFF_REVERSE) { char *swap = diff->opts.old_prefix; @@ -249,33 +304,63 @@ static git_diff_list *git_diff_list_alloc( diff->opts.new_prefix = swap; } - if (git_vector_init(&diff->deltas, 0, diff_delta__cmp) < GIT_SUCCESS) { - git__free(diff->opts.old_prefix); - git__free(diff->opts.new_prefix); - git__free(diff); - return NULL; + /* only copy pathspec if it is "interesting" so we can test + * diff->pathspec.length > 0 to know if it is worth calling + * fnmatch as we iterate. + */ + if (!diff_pathspec_is_interesting(&opts->pathspec)) + return diff; + + if (git_vector_init( + &diff->pathspec, (unsigned int)opts->pathspec.count, NULL) < 0) + goto fail; + + for (i = 0; i < opts->pathspec.count; ++i) { + int ret; + const char *pattern = opts->pathspec.strings[i]; + git_attr_fnmatch *match = git__calloc(1, sizeof(git_attr_fnmatch)); + if (!match) + goto fail; + ret = git_attr_fnmatch__parse(match, &diff->pool, NULL, &pattern); + if (ret == GIT_ENOTFOUND) { + git__free(match); + continue; + } else if (ret < 0) + goto fail; + + if (git_vector_insert(&diff->pathspec, match) < 0) + goto fail; } - /* do something safe with the pathspec strarray */ - return diff; + +fail: + git_diff_list_free(diff); + return NULL; } void git_diff_list_free(git_diff_list *diff) { git_diff_delta *delta; + git_attr_fnmatch *match; unsigned int i; if (!diff) return; git_vector_foreach(&diff->deltas, i, delta) { - diff_delta__free(delta); + git__free(delta); diff->deltas.contents[i] = NULL; } git_vector_free(&diff->deltas); - git__free(diff->opts.old_prefix); - git__free(diff->opts.new_prefix); + + git_vector_foreach(&diff->pathspec, i, match) { + git__free(match); + diff->pathspec.contents[i] = NULL; + } + git_vector_free(&diff->pathspec); + + git_pool_clear(&diff->pool); git__free(diff); } @@ -284,27 +369,24 @@ static int oid_for_workdir_item( const git_index_entry *item, git_oid *oid) { - int error = GIT_SUCCESS; + int result; git_buf full_path = GIT_BUF_INIT; - error = git_buf_joinpath( - &full_path, git_repository_workdir(repo), item->path); - if (error != GIT_SUCCESS) - return error; + if (git_buf_joinpath(&full_path, git_repository_workdir(repo), item->path) < 0) + return -1; - /* otherwise calculate OID for file */ + /* calculate OID for file if possible*/ if (S_ISLNK(item->mode)) - error = git_odb__hashlink(oid, full_path.ptr); - else if (!git__is_sizet(item->file_size)) - error = git__throw(GIT_ERROR, "File size overflow for 32-bit systems"); - else { - int fd; - - if ((fd = p_open(full_path.ptr, O_RDONLY)) < 0) - error = git__throw( - GIT_EOSERR, "Could not open '%s'", item->path); + result = git_odb__hashlink(oid, full_path.ptr); + else if (!git__is_sizet(item->file_size)) { + giterr_set(GITERR_OS, "File size overflow for 32-bit systems"); + result = -1; + } else { + int fd = git_futils_open_ro(full_path.ptr); + if (fd < 0) + result = fd; else { - error = git_odb__hashfd( + result = git_odb__hashfd( oid, fd, (size_t)item->file_size, GIT_OBJ_BLOB); p_close(fd); } @@ -312,9 +394,11 @@ static int oid_for_workdir_item( git_buf_free(&full_path); - return error; + return result; } +#define EXEC_BIT_MASK 0000111 + static int maybe_modified( git_iterator *old_iter, const git_index_entry *oitem, @@ -322,55 +406,96 @@ static int maybe_modified( const git_index_entry *nitem, git_diff_list *diff) { - int error = GIT_SUCCESS; git_oid noid, *use_noid = NULL; + git_delta_t status = GIT_DELTA_MODIFIED; + unsigned int omode = oitem->mode; + unsigned int nmode = nitem->mode; GIT_UNUSED(old_iter); - /* support "assume unchanged" & "skip worktree" bits */ - if ((oitem->flags_extended & GIT_IDXENTRY_INTENT_TO_ADD) != 0 || - (oitem->flags_extended & GIT_IDXENTRY_SKIP_WORKTREE) != 0) - return GIT_SUCCESS; + if (!diff_path_matches_pathspec(diff, oitem->path)) + return 0; - if (GIT_MODE_TYPE(oitem->mode) != GIT_MODE_TYPE(nitem->mode)) { - error = diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem); - if (error == GIT_SUCCESS) - error = diff_delta__from_one(diff, GIT_DELTA_ADDED, nitem); - return error; + /* on platforms with no symlinks, promote plain files to symlinks */ + if (S_ISLNK(omode) && S_ISREG(nmode) && + !(diff->diffcaps & GIT_DIFFCAPS_HAS_SYMLINKS)) + nmode = GIT_MODE_TYPE(omode) | (nmode & GIT_MODE_PERMS_MASK); + + /* on platforms with no execmode, clear exec bit from comparisons */ + if (!(diff->diffcaps & GIT_DIFFCAPS_TRUST_EXEC_BIT)) { + omode = omode & ~EXEC_BIT_MASK; + nmode = nmode & ~EXEC_BIT_MASK; } - if (git_oid_cmp(&oitem->oid, &nitem->oid) == 0 && - oitem->mode == nitem->mode) - return GIT_SUCCESS; + /* support "assume unchanged" (badly, b/c we still stat everything) */ + if ((diff->diffcaps & GIT_DIFFCAPS_ASSUME_UNCHANGED) != 0) + status = (oitem->flags_extended & GIT_IDXENTRY_INTENT_TO_ADD) ? + GIT_DELTA_MODIFIED : GIT_DELTA_UNMODIFIED; + + /* support "skip worktree" index bit */ + else if ((oitem->flags_extended & GIT_IDXENTRY_SKIP_WORKTREE) != 0) + status = GIT_DELTA_UNMODIFIED; + + /* if basic type of file changed, then split into delete and add */ + else if (GIT_MODE_TYPE(omode) != GIT_MODE_TYPE(nmode)) { + if (diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem) < 0 || + diff_delta__from_one(diff, GIT_DELTA_ADDED, nitem) < 0) + return -1; + return 0; + } + + /* if oids and modes match, then file is unmodified */ + else if (git_oid_cmp(&oitem->oid, &nitem->oid) == 0 && + omode == nmode) + status = GIT_DELTA_UNMODIFIED; + + /* if we have a workdir item with an unknown oid, check deeper */ + else if (git_oid_iszero(&nitem->oid) && new_iter->type == GIT_ITERATOR_WORKDIR) { + /* TODO: add check against index file st_mtime to avoid racy-git */ - if (git_oid_iszero(&nitem->oid) && new_iter->type == GIT_ITERATOR_WORKDIR) { /* if they files look exactly alike, then we'll assume the same */ if (oitem->file_size == nitem->file_size && - oitem->ctime.seconds == nitem->ctime.seconds && + (!(diff->diffcaps & GIT_DIFFCAPS_TRUST_CTIME) || + (oitem->ctime.seconds == nitem->ctime.seconds)) && oitem->mtime.seconds == nitem->mtime.seconds && - oitem->dev == nitem->dev && + (!(diff->diffcaps & GIT_DIFFCAPS_USE_DEV) || + (oitem->dev == nitem->dev)) && oitem->ino == nitem->ino && oitem->uid == nitem->uid && oitem->gid == nitem->gid) - return GIT_SUCCESS; + status = GIT_DELTA_UNMODIFIED; + + else if (S_ISGITLINK(nmode)) { + git_submodule *sub; + + if ((diff->opts.flags & GIT_DIFF_IGNORE_SUBMODULES) != 0) + status = GIT_DELTA_UNMODIFIED; + else if (git_submodule_lookup(&sub, diff->repo, nitem->path) < 0) + return -1; + else if (sub->ignore == GIT_SUBMODULE_IGNORE_ALL) + status = GIT_DELTA_UNMODIFIED; + else { + /* TODO: support other GIT_SUBMODULE_IGNORE values */ + status = GIT_DELTA_UNMODIFIED; + } + } /* TODO: check git attributes so we will not have to read the file * in if it is marked binary. */ - error = oid_for_workdir_item(diff->repo, nitem, &noid); - if (error != GIT_SUCCESS) - return error; - if (git_oid_cmp(&oitem->oid, &noid) == 0 && - oitem->mode == nitem->mode) - return GIT_SUCCESS; + else if (oid_for_workdir_item(diff->repo, nitem, &noid) < 0) + return -1; + + else if (git_oid_cmp(&oitem->oid, &noid) == 0 && + omode == nmode) + status = GIT_DELTA_UNMODIFIED; /* store calculated oid so we don't have to recalc later */ use_noid = &noid; } - return diff_delta__from_two( - diff, GIT_DELTA_MODIFIED, oitem, nitem, use_noid); + return diff_delta__from_two(diff, status, oitem, nitem, use_noid); } static int diff_from_iterators( @@ -380,55 +505,61 @@ static int diff_from_iterators( git_iterator *new_iter, git_diff_list **diff_ptr) { - int error; const git_index_entry *oitem, *nitem; - char *ignore_prefix = NULL; + git_buf ignore_prefix = GIT_BUF_INIT; git_diff_list *diff = git_diff_list_alloc(repo, opts); - if (!diff) { - error = GIT_ENOMEM; - goto cleanup; - } + if (!diff) + goto fail; diff->old_src = old_iter->type; diff->new_src = new_iter->type; - if ((error = git_iterator_current(old_iter, &oitem)) < GIT_SUCCESS || - (error = git_iterator_current(new_iter, &nitem)) < GIT_SUCCESS) - goto cleanup; + if (git_iterator_current(old_iter, &oitem) < 0 || + git_iterator_current(new_iter, &nitem) < 0) + goto fail; /* run iterators building diffs */ - while (!error && (oitem || nitem)) { + while (oitem || nitem) { /* create DELETED records for old items not matched in new */ if (oitem && (!nitem || strcmp(oitem->path, nitem->path) < 0)) { - error = diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem); - if (error == GIT_SUCCESS) - error = git_iterator_advance(old_iter, &oitem); - continue; + if (diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem) < 0 || + git_iterator_advance(old_iter, &oitem) < 0) + goto fail; } /* create ADDED, TRACKED, or IGNORED records for new items not * matched in old (and/or descend into directories as needed) */ - if (nitem && (!oitem || strcmp(oitem->path, nitem->path) > 0)) { + else if (nitem && (!oitem || strcmp(oitem->path, nitem->path) > 0)) { int is_ignored; git_delta_t delta_type = GIT_DELTA_ADDED; /* contained in ignored parent directory, so this can be skipped. */ - if (ignore_prefix != NULL && - git__prefixcmp(nitem->path, ignore_prefix) == 0) + if (git_buf_len(&ignore_prefix) && + git__prefixcmp(nitem->path, git_buf_cstr(&ignore_prefix)) == 0) { - error = git_iterator_advance(new_iter, &nitem); + if (git_iterator_advance(new_iter, &nitem) < 0) + goto fail; + continue; } is_ignored = git_iterator_current_is_ignored(new_iter); if (S_ISDIR(nitem->mode)) { - if (git__prefixcmp(oitem->path, nitem->path) == 0) { + /* recurse into directory if explicitly requested or + * if there are tracked items inside the directory + */ + if ((diff->opts.flags & GIT_DIFF_RECURSE_UNTRACKED_DIRS) || + (oitem && git__prefixcmp(oitem->path, nitem->path) == 0)) + { if (is_ignored) - ignore_prefix = nitem->path; - error = git_iterator_advance_into_directory(new_iter, &nitem); + git_buf_sets(&ignore_prefix, nitem->path); + + if (git_iterator_advance_into_directory(new_iter, &nitem) < 0) + goto fail; + continue; } delta_type = GIT_DELTA_UNTRACKED; @@ -438,36 +569,39 @@ static int diff_from_iterators( else if (new_iter->type == GIT_ITERATOR_WORKDIR) delta_type = GIT_DELTA_UNTRACKED; - error = diff_delta__from_one(diff, delta_type, nitem); - if (error == GIT_SUCCESS) - error = git_iterator_advance(new_iter, &nitem); - continue; + if (diff_delta__from_one(diff, delta_type, nitem) < 0 || + git_iterator_advance(new_iter, &nitem) < 0) + goto fail; } /* otherwise item paths match, so create MODIFIED record * (or ADDED and DELETED pair if type changed) */ - assert(oitem && nitem && strcmp(oitem->path, nitem->path) == 0); + else { + assert(oitem && nitem && strcmp(oitem->path, nitem->path) == 0); - error = maybe_modified(old_iter, oitem, new_iter, nitem, diff); - if (error == GIT_SUCCESS) - error = git_iterator_advance(old_iter, &oitem); - if (error == GIT_SUCCESS) - error = git_iterator_advance(new_iter, &nitem); + if (maybe_modified(old_iter, oitem, new_iter, nitem, diff) < 0 || + git_iterator_advance(old_iter, &oitem) < 0 || + git_iterator_advance(new_iter, &nitem) < 0) + goto fail; + } } -cleanup: git_iterator_free(old_iter); git_iterator_free(new_iter); - - if (error != GIT_SUCCESS) { - git_diff_list_free(diff); - diff = NULL; - } + git_buf_free(&ignore_prefix); *diff_ptr = diff; + return 0; - return error; +fail: + git_iterator_free(old_iter); + git_iterator_free(new_iter); + git_buf_free(&ignore_prefix); + + git_diff_list_free(diff); + *diff_ptr = NULL; + return -1; } @@ -478,14 +612,13 @@ int git_diff_tree_to_tree( git_tree *new_tree, git_diff_list **diff) { - int error; git_iterator *a = NULL, *b = NULL; assert(repo && old_tree && new_tree && diff); - if ((error = git_iterator_for_tree(repo, old_tree, &a)) < GIT_SUCCESS || - (error = git_iterator_for_tree(repo, new_tree, &b)) < GIT_SUCCESS) - return error; + if (git_iterator_for_tree(repo, old_tree, &a) < 0 || + git_iterator_for_tree(repo, new_tree, &b) < 0) + return -1; return diff_from_iterators(repo, opts, a, b, diff); } @@ -496,14 +629,13 @@ int git_diff_index_to_tree( git_tree *old_tree, git_diff_list **diff) { - int error; git_iterator *a = NULL, *b = NULL; assert(repo && old_tree && diff); - if ((error = git_iterator_for_tree(repo, old_tree, &a)) < GIT_SUCCESS || - (error = git_iterator_for_index(repo, &b)) < GIT_SUCCESS) - return error; + if (git_iterator_for_tree(repo, old_tree, &a) < 0 || + git_iterator_for_index(repo, &b) < 0) + return -1; return diff_from_iterators(repo, opts, a, b, diff); } @@ -513,14 +645,13 @@ int git_diff_workdir_to_index( const git_diff_options *opts, git_diff_list **diff) { - int error; git_iterator *a = NULL, *b = NULL; assert(repo && diff); - if ((error = git_iterator_for_index(repo, &a)) < GIT_SUCCESS || - (error = git_iterator_for_workdir(repo, &b)) < GIT_SUCCESS) - return error; + if (git_iterator_for_index(repo, &a) < 0 || + git_iterator_for_workdir(repo, &b) < 0) + return -1; return diff_from_iterators(repo, opts, a, b, diff); } @@ -532,14 +663,13 @@ int git_diff_workdir_to_tree( git_tree *old_tree, git_diff_list **diff) { - int error; git_iterator *a = NULL, *b = NULL; assert(repo && old_tree && diff); - if ((error = git_iterator_for_tree(repo, old_tree, &a)) < GIT_SUCCESS || - (error = git_iterator_for_workdir(repo, &b)) < GIT_SUCCESS) - return error; + if (git_iterator_for_tree(repo, old_tree, &a) < 0 || + git_iterator_for_workdir(repo, &b) < 0) + return -1; return diff_from_iterators(repo, opts, a, b, diff); } @@ -548,52 +678,53 @@ int git_diff_merge( git_diff_list *onto, const git_diff_list *from) { - int error; - unsigned int i = 0, j = 0; + int error = 0; + git_pool onto_pool; git_vector onto_new; git_diff_delta *delta; + unsigned int i, j; - error = git_vector_init(&onto_new, onto->deltas.length, diff_delta__cmp); - if (error < GIT_SUCCESS) - return error; + assert(onto && from); - while (i < onto->deltas.length || j < from->deltas.length) { - git_diff_delta *o = git_vector_get(&onto->deltas, i); - const git_diff_delta *f = git_vector_get_const(&from->deltas, j); - const char *opath = - !o ? NULL : o->old_file.path ? o->old_file.path : o->new_file.path; - const char *fpath = - !f ? NULL : f->old_file.path ? f->old_file.path : f->new_file.path; + if (!from->deltas.length) + return 0; - if (opath && (!fpath || strcmp(opath, fpath) < 0)) { - delta = diff_delta__dup(o); + if (git_vector_init(&onto_new, onto->deltas.length, diff_delta__cmp) < 0 || + git_pool_init(&onto_pool, 1, 0) < 0) + return -1; + + for (i = 0, j = 0; i < onto->deltas.length || j < from->deltas.length; ) { + git_diff_delta *o = GIT_VECTOR_GET(&onto->deltas, i); + const git_diff_delta *f = GIT_VECTOR_GET(&from->deltas, j); + int cmp = !f ? -1 : !o ? 1 : strcmp(o->old_file.path, f->old_file.path); + + if (cmp < 0) { + delta = diff_delta__dup(o, &onto_pool); i++; - } else if (fpath && (!opath || strcmp(opath, fpath) > 0)) { - delta = diff_delta__dup(f); + } else if (cmp > 0) { + delta = diff_delta__dup(f, &onto_pool); j++; } else { - delta = diff_delta__merge_like_cgit(o, f); + delta = diff_delta__merge_like_cgit(o, f, &onto_pool); i++; j++; } - if (!delta) - error = GIT_ENOMEM; - else - error = git_vector_insert(&onto_new, delta); - - if (error != GIT_SUCCESS) + if ((error = !delta ? -1 : git_vector_insert(&onto_new, delta)) < 0) break; } - if (error == GIT_SUCCESS) { + if (!error) { git_vector_swap(&onto->deltas, &onto_new); + git_pool_swap(&onto->pool, &onto_pool); onto->new_src = from->new_src; } git_vector_foreach(&onto_new, i, delta) - diff_delta__free(delta); + git__free(delta); git_vector_free(&onto_new); + git_pool_clear(&onto_pool); return error; } + diff --git a/src/diff.h b/src/diff.h index 7d69199ea..ac2457956 100644 --- a/src/diff.h +++ b/src/diff.h @@ -12,13 +12,28 @@ #include "buffer.h" #include "iterator.h" #include "repository.h" +#include "pool.h" + +#define DIFF_OLD_PREFIX_DEFAULT "a/" +#define DIFF_NEW_PREFIX_DEFAULT "b/" + +enum { + GIT_DIFFCAPS_HAS_SYMLINKS = (1 << 0), /* symlinks on platform? */ + GIT_DIFFCAPS_ASSUME_UNCHANGED = (1 << 1), /* use stat? */ + GIT_DIFFCAPS_TRUST_EXEC_BIT = (1 << 2), /* use st_mode exec bit? */ + GIT_DIFFCAPS_TRUST_CTIME = (1 << 3), /* use st_ctime? */ + GIT_DIFFCAPS_USE_DEV = (1 << 4), /* use st_dev? */ +}; struct git_diff_list { git_repository *repo; git_diff_options opts; + git_vector pathspec; git_vector deltas; /* vector of git_diff_file_delta */ + git_pool pool; git_iterator_type_t old_src; git_iterator_type_t new_src; + uint32_t diffcaps; }; #endif diff --git a/src/diff_output.c b/src/diff_output.c index 23f74d216..c380db996 100644 --- a/src/diff_output.c +++ b/src/diff_output.c @@ -19,9 +19,10 @@ typedef struct { git_diff_list *diff; void *cb_data; git_diff_hunk_fn hunk_cb; - git_diff_line_fn line_cb; + git_diff_data_fn line_cb; unsigned int index; git_diff_delta *delta; + git_diff_range range; } diff_output_info; static int read_next_int(const char **str, int *value) @@ -35,31 +36,41 @@ static int read_next_int(const char **str, int *value) v = (v * 10) + (*scan - '0'); *str = scan; *value = v; - return (digits > 0) ? GIT_SUCCESS : GIT_ENOTFOUND; + return (digits > 0) ? 0 : -1; } static int diff_output_cb(void *priv, mmbuffer_t *bufs, int len) { - int err = GIT_SUCCESS; diff_output_info *info = priv; if (len == 1 && info->hunk_cb) { git_diff_range range = { -1, 0, -1, 0 }; + const char *scan = bufs[0].ptr; /* expect something of the form "@@ -%d[,%d] +%d[,%d] @@" */ - if (bufs[0].ptr[0] == '@') { - const char *scan = bufs[0].ptr; - if (!(err = read_next_int(&scan, &range.old_start)) && *scan == ',') - err = read_next_int(&scan, &range.old_lines); - if (!err && - !(err = read_next_int(&scan, &range.new_start)) && *scan == ',') - err = read_next_int(&scan, &range.new_lines); - if (!err && range.old_start >= 0 && range.new_start >= 0) - err = info->hunk_cb( - info->cb_data, info->delta, &range, bufs[0].ptr, bufs[0].size); - } + if (*scan != '@') + return -1; + + if (read_next_int(&scan, &range.old_start) < 0) + return -1; + if (*scan == ',' && read_next_int(&scan, &range.old_lines) < 0) + return -1; + + if (read_next_int(&scan, &range.new_start) < 0) + return -1; + if (*scan == ',' && read_next_int(&scan, &range.new_lines) < 0) + return -1; + + if (range.old_start < 0 || range.new_start < 0) + return -1; + + memcpy(&info->range, &range, sizeof(git_diff_range)); + + return info->hunk_cb( + info->cb_data, info->delta, &range, bufs[0].ptr, bufs[0].size); } - else if ((len == 2 || len == 3) && info->line_cb) { + + if ((len == 2 || len == 3) && info->line_cb) { int origin; /* expect " "/"-"/"+", then data, then maybe newline */ @@ -68,41 +79,43 @@ static int diff_output_cb(void *priv, mmbuffer_t *bufs, int len) (*bufs[0].ptr == '-') ? GIT_DIFF_LINE_DELETION : GIT_DIFF_LINE_CONTEXT; - err = info->line_cb( - info->cb_data, info->delta, origin, bufs[1].ptr, bufs[1].size); + if (info->line_cb( + info->cb_data, info->delta, &info->range, origin, bufs[1].ptr, bufs[1].size) < 0) + return -1; /* deal with adding and removing newline at EOF */ - if (err == GIT_SUCCESS && len == 3) { + if (len == 3) { if (origin == GIT_DIFF_LINE_ADDITION) origin = GIT_DIFF_LINE_ADD_EOFNL; else origin = GIT_DIFF_LINE_DEL_EOFNL; - err = info->line_cb( - info->cb_data, info->delta, origin, bufs[2].ptr, bufs[2].size); + return info->line_cb( + info->cb_data, info->delta, &info->range, origin, bufs[2].ptr, bufs[2].size); } } - return err; + return 0; } #define BINARY_DIFF_FLAGS (GIT_DIFF_FILE_BINARY|GIT_DIFF_FILE_NOT_BINARY) -static int set_file_is_binary_by_attr(git_repository *repo, git_diff_file *file) +static int update_file_is_binary_by_attr(git_repository *repo, git_diff_file *file) { const char *value; - int error = git_attr_get(repo, file->path, "diff", &value); - if (error != GIT_SUCCESS) - return error; + if (git_attr_get(repo, 0, file->path, "diff", &value) < 0) + return -1; + if (GIT_ATTR_FALSE(value)) file->flags |= GIT_DIFF_FILE_BINARY; else if (GIT_ATTR_TRUE(value)) file->flags |= GIT_DIFF_FILE_NOT_BINARY; /* otherwise leave file->flags alone */ - return error; + + return 0; } -static void set_delta_is_binary(git_diff_delta *delta) +static void update_delta_is_binary(git_diff_delta *delta) { if ((delta->old_file.flags & GIT_DIFF_FILE_BINARY) != 0 || (delta->new_file.flags & GIT_DIFF_FILE_BINARY) != 0) @@ -117,7 +130,7 @@ static int file_is_binary_by_attr( git_diff_list *diff, git_diff_delta *delta) { - int error, mirror_new; + int error = 0, mirror_new; delta->binary = -1; @@ -128,7 +141,7 @@ static int file_is_binary_by_attr( delta->old_file.flags |= GIT_DIFF_FILE_BINARY; delta->new_file.flags |= GIT_DIFF_FILE_BINARY; delta->binary = 1; - return GIT_SUCCESS; + return 0; } /* check if user is forcing us to text diff these files */ @@ -136,22 +149,21 @@ static int file_is_binary_by_attr( delta->old_file.flags |= GIT_DIFF_FILE_NOT_BINARY; delta->new_file.flags |= GIT_DIFF_FILE_NOT_BINARY; delta->binary = 0; - return GIT_SUCCESS; + return 0; } /* check diff attribute +, -, or 0 */ - error = set_file_is_binary_by_attr(diff->repo, &delta->old_file); - if (error != GIT_SUCCESS) - return error; + if (update_file_is_binary_by_attr(diff->repo, &delta->old_file) < 0) + return -1; mirror_new = (delta->new_file.path == delta->old_file.path || strcmp(delta->new_file.path, delta->old_file.path) == 0); if (mirror_new) delta->new_file.flags &= (delta->old_file.flags & BINARY_DIFF_FLAGS); else - error = set_file_is_binary_by_attr(diff->repo, &delta->new_file); + error = update_file_is_binary_by_attr(diff->repo, &delta->new_file); - set_delta_is_binary(delta); + update_delta_is_binary(delta); return error; } @@ -191,11 +203,11 @@ static int file_is_binary_by_content( delta->new_file.flags |= GIT_DIFF_FILE_NOT_BINARY; } - set_delta_is_binary(delta); + update_delta_is_binary(delta); /* TODO: if value != NULL, implement diff drivers */ - return GIT_SUCCESS; + return 0; } static void setup_xdiff_options( @@ -226,17 +238,15 @@ static int get_blob_content( git_map *map, git_blob **blob) { - int error; - if (git_oid_iszero(oid)) - return GIT_SUCCESS; + return 0; - if ((error = git_blob_lookup(blob, repo, oid)) == GIT_SUCCESS) { - map->data = (void *)git_blob_rawcontent(*blob); - map->len = git_blob_rawsize(*blob); - } + if (git_blob_lookup(blob, repo, oid) < 0) + return -1; - return error; + map->data = (void *)git_blob_rawcontent(*blob); + map->len = git_blob_rawsize(*blob); + return 0; } static int get_workdir_content( @@ -244,35 +254,33 @@ static int get_workdir_content( git_diff_file *file, git_map *map) { - git_buf full_path = GIT_BUF_INIT; - int error = git_buf_joinpath( - &full_path, git_repository_workdir(repo), file->path); - if (error != GIT_SUCCESS) - return error; + int error = 0; + git_buf path = GIT_BUF_INIT; + + if (git_buf_joinpath(&path, git_repository_workdir(repo), file->path) < 0) + return -1; if (S_ISLNK(file->mode)) { + ssize_t read_len; + file->flags |= GIT_DIFF_FILE_FREE_DATA; file->flags |= GIT_DIFF_FILE_BINARY; map->data = git__malloc((size_t)file->size + 1); - if (map->data == NULL) - error = GIT_ENOMEM; - else { - ssize_t read_len = - p_readlink(full_path.ptr, map->data, (size_t)file->size + 1); - if (read_len != (ssize_t)file->size) - error = git__throw( - GIT_EOSERR, "Failed to read symlink %s", file->path); - else - map->len = read_len; + GITERR_CHECK_ALLOC(map->data); - } + read_len = p_readlink(path.ptr, map->data, (size_t)file->size + 1); + if (read_len != (ssize_t)file->size) { + giterr_set(GITERR_OS, "Failed to read symlink '%s'", file->path); + error = -1; + } else + map->len = read_len; } else { - error = git_futils_mmap_ro_file(map, full_path.ptr); + error = git_futils_mmap_ro_file(map, path.ptr); file->flags |= GIT_DIFF_FILE_UNMAP_DATA; } - git_buf_free(&full_path); + git_buf_free(&path); return error; } @@ -298,9 +306,9 @@ int git_diff_foreach( void *data, git_diff_file_fn file_cb, git_diff_hunk_fn hunk_cb, - git_diff_line_fn line_cb) + git_diff_data_fn line_cb) { - int error = GIT_SUCCESS; + int error = 0; diff_output_info info; git_diff_delta *delta; xpparam_t xdiff_params; @@ -322,7 +330,8 @@ int git_diff_foreach( git_map old_data, new_data; mmfile_t old_xdiff_data, new_xdiff_data; - if (delta->status == GIT_DELTA_UNMODIFIED) + if (delta->status == GIT_DELTA_UNMODIFIED && + (diff->opts.flags & GIT_DIFF_INCLUDE_UNMODIFIED) == 0) continue; if (delta->status == GIT_DELTA_IGNORED && @@ -333,8 +342,7 @@ int git_diff_foreach( (diff->opts.flags & GIT_DIFF_INCLUDE_UNTRACKED) == 0) continue; - error = file_is_binary_by_attr(diff, delta); - if (error < GIT_SUCCESS) + if ((error = file_is_binary_by_attr(diff, delta)) < 0) goto cleanup; old_data.data = ""; @@ -358,7 +366,8 @@ int git_diff_foreach( else error = get_blob_content( diff->repo, &delta->old_file.oid, &old_data, &old_blob); - if (error != GIT_SUCCESS) + + if (error < 0) goto cleanup; } @@ -372,13 +381,15 @@ int git_diff_foreach( else error = get_blob_content( diff->repo, &delta->new_file.oid, &new_data, &new_blob); - if (error != GIT_SUCCESS) + + if (error < 0) goto cleanup; if ((delta->new_file.flags | GIT_DIFF_FILE_VALID_OID) == 0) { error = git_odb_hash( &delta->new_file.oid, new_data.data, new_data.len, GIT_OBJ_BLOB); - if (error != GIT_SUCCESS) + + if (error < 0) goto cleanup; /* since we did not have the definitive oid, we may have @@ -386,7 +397,8 @@ int git_diff_foreach( */ if (git_oid_cmp(&delta->old_file.oid, &delta->new_file.oid) == 0) { delta->status = GIT_DELTA_UNMODIFIED; - goto cleanup; + if ((diff->opts.flags & GIT_DIFF_INCLUDE_UNMODIFIED) == 0) + goto cleanup; } } } @@ -397,7 +409,7 @@ int git_diff_foreach( if (delta->binary == -1) { error = file_is_binary_by_content( diff, delta, &old_data, &new_data); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; } @@ -407,7 +419,7 @@ int git_diff_foreach( if (file_cb != NULL) { error = file_cb(data, delta, (float)info.index / diff->deltas.length); - if (error != GIT_SUCCESS) + if (error < 0) goto cleanup; } @@ -434,7 +446,7 @@ cleanup: release_content(&delta->old_file, &old_data, old_blob); release_content(&delta->new_file, &new_data, new_blob); - if (error != GIT_SUCCESS) + if (error < 0) break; } @@ -444,7 +456,7 @@ cleanup: typedef struct { git_diff_list *diff; - git_diff_output_fn print_cb; + git_diff_data_fn print_cb; void *cb_data; git_buf *buf; } diff_print_info; @@ -479,7 +491,7 @@ static int print_compact(void *data, git_diff_delta *delta, float progress) } if (!code) - return GIT_SUCCESS; + return 0; old_suffix = pick_suffix(delta->old_file.mode); new_suffix = pick_suffix(delta->new_file.mode); @@ -499,16 +511,16 @@ static int print_compact(void *data, git_diff_delta *delta, float progress) else git_buf_printf(pi->buf, "%c\t%s\n", code, delta->old_file.path); - if (git_buf_lasterror(pi->buf) != GIT_SUCCESS) - return git_buf_lasterror(pi->buf); + if (git_buf_oom(pi->buf)) + return -1; - return pi->print_cb(pi->cb_data, GIT_DIFF_LINE_FILE_HDR, pi->buf->ptr); + return pi->print_cb(pi->cb_data, delta, NULL, GIT_DIFF_LINE_FILE_HDR, git_buf_cstr(pi->buf), git_buf_len(pi->buf)); } int git_diff_print_compact( git_diff_list *diff, void *cb_data, - git_diff_output_fn print_cb) + git_diff_data_fn print_cb) { int error; git_buf buf = GIT_BUF_INIT; @@ -551,32 +563,42 @@ static int print_oid_range(diff_print_info *pi, git_diff_delta *delta) git_buf_printf(pi->buf, "index %s..%s\n", start_oid, end_oid); } - return git_buf_lasterror(pi->buf); + if (git_buf_oom(pi->buf)) + return -1; + + return 0; } static int print_patch_file(void *data, git_diff_delta *delta, float progress) { - int error; diff_print_info *pi = data; const char *oldpfx = pi->diff->opts.old_prefix; const char *oldpath = delta->old_file.path; const char *newpfx = pi->diff->opts.new_prefix; const char *newpath = delta->new_file.path; + int result; GIT_UNUSED(progress); + if (!oldpfx) + oldpfx = DIFF_OLD_PREFIX_DEFAULT; + + if (!newpfx) + newpfx = DIFF_NEW_PREFIX_DEFAULT; + git_buf_clear(pi->buf); git_buf_printf(pi->buf, "diff --git %s%s %s%s\n", oldpfx, delta->old_file.path, newpfx, delta->new_file.path); - if ((error = print_oid_range(pi, delta)) < GIT_SUCCESS) - return error; + + if (print_oid_range(pi, delta) < 0) + return -1; if (git_oid_iszero(&delta->old_file.oid)) { oldpfx = ""; oldpath = "/dev/null"; } if (git_oid_iszero(&delta->new_file.oid)) { - oldpfx = ""; - oldpath = "/dev/null"; + newpfx = ""; + newpath = "/dev/null"; } if (delta->binary != 1) { @@ -584,21 +606,24 @@ static int print_patch_file(void *data, git_diff_delta *delta, float progress) git_buf_printf(pi->buf, "+++ %s%s\n", newpfx, newpath); } - if (git_buf_lasterror(pi->buf) != GIT_SUCCESS) - return git_buf_lasterror(pi->buf); + if (git_buf_oom(pi->buf)) + return -1; - error = pi->print_cb(pi->cb_data, GIT_DIFF_LINE_FILE_HDR, pi->buf->ptr); - if (error != GIT_SUCCESS || delta->binary != 1) - return error; + result = pi->print_cb(pi->cb_data, delta, NULL, GIT_DIFF_LINE_FILE_HDR, git_buf_cstr(pi->buf), git_buf_len(pi->buf)); + if (result < 0) + return result; + + if (delta->binary != 1) + return 0; git_buf_clear(pi->buf); git_buf_printf( pi->buf, "Binary files %s%s and %s%s differ\n", oldpfx, oldpath, newpfx, newpath); - if (git_buf_lasterror(pi->buf) != GIT_SUCCESS) - return git_buf_lasterror(pi->buf); + if (git_buf_oom(pi->buf)) + return -1; - return pi->print_cb(pi->cb_data, GIT_DIFF_LINE_BINARY, pi->buf->ptr); + return pi->print_cb(pi->cb_data, delta, NULL, GIT_DIFF_LINE_BINARY, git_buf_cstr(pi->buf), git_buf_len(pi->buf)); } static int print_patch_hunk( @@ -610,28 +635,23 @@ static int print_patch_hunk( { diff_print_info *pi = data; - GIT_UNUSED(d); - GIT_UNUSED(r); - git_buf_clear(pi->buf); + if (git_buf_printf(pi->buf, "%.*s", (int)header_len, header) < 0) + return -1; - if (git_buf_printf(pi->buf, "%.*s", (int)header_len, header) == GIT_SUCCESS) - return pi->print_cb(pi->cb_data, GIT_DIFF_LINE_HUNK_HDR, pi->buf->ptr); - else - return git_buf_lasterror(pi->buf); + return pi->print_cb(pi->cb_data, d, r, GIT_DIFF_LINE_HUNK_HDR, git_buf_cstr(pi->buf), git_buf_len(pi->buf)); } static int print_patch_line( void *data, git_diff_delta *delta, + git_diff_range *range, char line_origin, /* GIT_DIFF_LINE value from above */ const char *content, size_t content_len) { diff_print_info *pi = data; - GIT_UNUSED(delta); - git_buf_clear(pi->buf); if (line_origin == GIT_DIFF_LINE_ADDITION || @@ -641,16 +661,16 @@ static int print_patch_line( else if (content_len > 0) git_buf_printf(pi->buf, "%.*s", (int)content_len, content); - if (git_buf_lasterror(pi->buf) != GIT_SUCCESS) - return git_buf_lasterror(pi->buf); + if (git_buf_oom(pi->buf)) + return -1; - return pi->print_cb(pi->cb_data, line_origin, pi->buf->ptr); + return pi->print_cb(pi->cb_data, delta, range, line_origin, git_buf_cstr(pi->buf), git_buf_len(pi->buf)); } int git_diff_print_patch( git_diff_list *diff, void *cb_data, - git_diff_output_fn print_cb) + git_diff_data_fn print_cb) { int error; git_buf buf = GIT_BUF_INIT; @@ -676,7 +696,7 @@ int git_diff_blobs( git_diff_options *options, void *cb_data, git_diff_hunk_fn hunk_cb, - git_diff_line_fn line_cb) + git_diff_data_fn line_cb) { diff_output_info info; git_diff_delta delta; @@ -732,5 +752,5 @@ int git_diff_blobs( xdl_diff(&old_data, &new_data, &xdiff_params, &xdiff_config, &xdiff_callback); - return GIT_SUCCESS; + return 0; } diff --git a/src/errors.c b/src/errors.c index 58e0976f2..d43d7d9b5 100644 --- a/src/errors.c +++ b/src/errors.c @@ -6,99 +6,114 @@ */ #include "common.h" #include "global.h" +#include "posix.h" +#include "buffer.h" #include -static struct { - int num; - const char *str; -} error_codes[] = { - {GIT_ERROR, "Unspecified error"}, - {GIT_ENOTOID, "Input was not a properly formatted Git object id."}, - {GIT_ENOTFOUND, "Object does not exist in the scope searched."}, - {GIT_ENOMEM, "Not enough space available."}, - {GIT_EOSERR, "Consult the OS error information."}, - {GIT_EOBJTYPE, "The specified object is of invalid type"}, - {GIT_EOBJCORRUPTED, "The specified object has its data corrupted"}, - {GIT_ENOTAREPO, "The specified repository is invalid"}, - {GIT_EINVALIDTYPE, "The object or config variable type is invalid or doesn't match"}, - {GIT_EMISSINGOBJDATA, "The object cannot be written that because it's missing internal data"}, - {GIT_EPACKCORRUPTED, "The packfile for the ODB is corrupted"}, - {GIT_EFLOCKFAIL, "Failed to adquire or release a file lock"}, - {GIT_EZLIB, "The Z library failed to inflate/deflate an object's data"}, - {GIT_EBUSY, "The queried object is currently busy"}, - {GIT_EINVALIDPATH, "The path is invalid"}, - {GIT_EBAREINDEX, "The index file is not backed up by an existing repository"}, - {GIT_EINVALIDREFNAME, "The name of the reference is not valid"}, - {GIT_EREFCORRUPTED, "The specified reference has its data corrupted"}, - {GIT_ETOONESTEDSYMREF, "The specified symbolic reference is too deeply nested"}, - {GIT_EPACKEDREFSCORRUPTED, "The pack-refs file is either corrupted of its format is not currently supported"}, - {GIT_EINVALIDPATH, "The path is invalid" }, - {GIT_EREVWALKOVER, "The revision walker is empty; there are no more commits left to iterate"}, - {GIT_EINVALIDREFSTATE, "The state of the reference is not valid"}, - {GIT_ENOTIMPLEMENTED, "This feature has not been implemented yet"}, - {GIT_EEXISTS, "A reference with this name already exists"}, - {GIT_EOVERFLOW, "The given integer literal is too large to be parsed"}, - {GIT_ENOTNUM, "The given literal is not a valid number"}, - {GIT_EAMBIGUOUSOIDPREFIX, "The given oid prefix is ambiguous"}, +/******************************************** + * New error handling + ********************************************/ + +static git_error g_git_oom_error = { + "Out of memory", + GITERR_NOMEMORY }; -const char *git_strerror(int num) +static void set_error(int error_class, char *string) { - size_t i; + git_error *error = &GIT_GLOBAL->error_t; - if (num == GIT_EOSERR) - return strerror(errno); - for (i = 0; i < ARRAY_SIZE(error_codes); i++) - if (num == error_codes[i].num) - return error_codes[i].str; + git__free(error->message); - return "Unknown error"; + error->message = string; + error->klass = error_class; + + GIT_GLOBAL->last_error = error; } -#define ERROR_MAX_LEN 1024 - -void git___rethrow(const char *msg, ...) +void giterr_set_oom(void) { - char new_error[ERROR_MAX_LEN]; - char *last_error; - char *old_error = NULL; - - va_list va; - - last_error = GIT_GLOBAL->error.last; - - va_start(va, msg); - vsnprintf(new_error, ERROR_MAX_LEN, msg, va); - va_end(va); - - old_error = git__strdup(last_error); - - snprintf(last_error, ERROR_MAX_LEN, "%s \n - %s", new_error, old_error); - - git__free(old_error); + GIT_GLOBAL->last_error = &g_git_oom_error; } -void git___throw(const char *msg, ...) +void giterr_set(int error_class, const char *string, ...) { - va_list va; + git_buf buf = GIT_BUF_INIT; + va_list arglist; - va_start(va, msg); - vsnprintf(GIT_GLOBAL->error.last, ERROR_MAX_LEN, msg, va); - va_end(va); + int unix_error_code = 0; + +#ifdef GIT_WIN32 + DWORD win32_error_code = 0; +#endif + + if (error_class == GITERR_OS) { + unix_error_code = errno; + errno = 0; + +#ifdef GIT_WIN32 + win32_error_code = GetLastError(); + SetLastError(0); +#endif + } + + va_start(arglist, string); + git_buf_vprintf(&buf, string, arglist); + va_end(arglist); + + /* automatically suffix strerror(errno) for GITERR_OS errors */ + if (error_class == GITERR_OS) { + + if (unix_error_code != 0) { + git_buf_PUTS(&buf, ": "); + git_buf_puts(&buf, strerror(unix_error_code)); + } + +#ifdef GIT_WIN32 + else if (win32_error_code != 0) { + LPVOID lpMsgBuf = NULL; + + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, win32_error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL); + + if (lpMsgBuf) { + git_buf_PUTS(&buf, ": "); + git_buf_puts(&buf, lpMsgBuf); + LocalFree(lpMsgBuf); + } + } +#endif + } + + if (!git_buf_oom(&buf)) + set_error(error_class, git_buf_detach(&buf)); } -const char *git_lasterror(void) +void giterr_set_str(int error_class, const char *string) { - char *last_error = GIT_GLOBAL->error.last; + char *message = git__strdup(string); - if (!last_error[0]) - return NULL; - - return last_error; + if (message) + set_error(error_class, message); } -void git_clearerror(void) +void giterr_set_regex(const regex_t *regex, int error_code) { - char *last_error = GIT_GLOBAL->error.last; - last_error[0] = '\0'; + char error_buf[1024]; + regerror(error_code, regex, error_buf, sizeof(error_buf)); + giterr_set_str(GITERR_REGEX, error_buf); } + +void giterr_clear(void) +{ + GIT_GLOBAL->last_error = NULL; +} + +const git_error *giterr_last(void) +{ + return GIT_GLOBAL->last_error; +} + diff --git a/src/fetch.c b/src/fetch.c index 23208f17e..1944bd005 100644 --- a/src/fetch.c +++ b/src/fetch.c @@ -9,6 +9,7 @@ #include "git2/oid.h" #include "git2/refs.h" #include "git2/revwalk.h" +#include "git2/indexer.h" #include "common.h" #include "transport.h" @@ -28,19 +29,13 @@ struct filter_payload { static int filter_ref__cb(git_remote_head *head, void *payload) { struct filter_payload *p = payload; - int error; if (!p->found_head && strcmp(head->name, GIT_HEAD_FILE) == 0) { p->found_head = 1; } else { /* If it doesn't match the refpec, we don't want it */ - error = git_refspec_src_match(p->spec, head->name); - - if (error == GIT_ENOMATCH) - return GIT_SUCCESS; - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Error matching remote ref name"); + if (!git_refspec_src_matches(p->spec, head->name)) + return 0; } /* If we have the object, mark it so we don't ask for it */ @@ -54,7 +49,6 @@ static int filter_ref__cb(git_remote_head *head, void *payload) static int filter_wants(git_remote *remote) { - int error; struct filter_payload p; git_vector_clear(&remote->refs); @@ -69,9 +63,8 @@ static int filter_wants(git_remote *remote) p.found_head = 0; p.remote = remote; - error = git_repository_odb__weakptr(&p.odb, remote->repo); - if (error < GIT_SUCCESS) - return error; + if (git_repository_odb__weakptr(&p.odb, remote->repo) < 0) + return -1; return remote->transport->ls(remote->transport, &filter_ref__cb, &p); } @@ -83,19 +76,16 @@ static int filter_wants(git_remote *remote) */ int git_fetch_negotiate(git_remote *remote) { - int error; git_transport *t = remote->transport; - error = filter_wants(remote); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to filter the reference list for wants"); + if (filter_wants(remote) < 0) { + giterr_set(GITERR_NET, "Failed to filter the reference list for wants"); + return -1; + } /* Don't try to negotiate when we don't want anything */ - if (remote->refs.length == 0) - return GIT_SUCCESS; - - if (!remote->need_pack) - return GIT_SUCCESS; + if (remote->refs.length == 0 || !remote->need_pack) + return 0; /* * Now we have everything set up so we can start tell the server @@ -104,75 +94,103 @@ int git_fetch_negotiate(git_remote *remote) return t->negotiate_fetch(t, remote->repo, &remote->refs); } -int git_fetch_download_pack(char **out, git_remote *remote) +int git_fetch_download_pack(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats) { - if(!remote->need_pack) { - *out = NULL; - return GIT_SUCCESS; - } + if(!remote->need_pack) + return 0; - return remote->transport->download_pack(out, remote->transport, remote->repo); + return remote->transport->download_pack(remote->transport, 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( - char **out, const char *buffered, size_t buffered_size, GIT_SOCKET fd, - git_repository *repo) + git_repository *repo, + git_off_t *bytes, + git_indexer_stats *stats) { - git_filebuf file = GIT_FILEBUF_INIT; - int error; + int recvd; char buff[1024]; - git_buf path = GIT_BUF_INIT; - static const char suff[] = "/objects/pack/pack-received"; gitno_buffer buf; + git_indexer_stream *idx; gitno_buffer_setup(&buf, buff, sizeof(buff), fd); if (memcmp(buffered, "PACK", strlen("PACK"))) { - return git__throw(GIT_ERROR, "The pack doesn't start with the signature"); + giterr_set(GITERR_NET, "The pack doesn't start with the signature"); + return -1; } - error = git_buf_joinpath(&path, repo->path_repository, suff); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_indexer_stream_new(&idx, git_repository_path(repo)) < 0) + return -1; - error = git_filebuf_open(&file, path.ptr, GIT_FILEBUF_TEMPORARY); - if (error < GIT_SUCCESS) - goto cleanup; + memset(stats, 0, sizeof(git_indexer_stats)); + if (git_indexer_stream_add(idx, buffered, buffered_size, stats) < 0) + goto on_error; - /* Part of the packfile has been received, don't loose it */ - error = git_filebuf_write(&file, buffered, buffered_size); - if (error < GIT_SUCCESS) - goto cleanup; + *bytes = buffered_size; - while (1) { - error = git_filebuf_write(&file, buf.data, buf.offset); - if (error < GIT_SUCCESS) - goto cleanup; + do { + if (git_indexer_stream_add(idx, buf.data, buf.offset, stats) < 0) + goto on_error; gitno_consume_n(&buf, buf.offset); - error = gitno_recv(&buf); - if (error < GIT_SUCCESS) - goto cleanup; - if (error == 0) /* Orderly shutdown */ - break; - } + if ((recvd = gitno_recv(&buf)) < 0) + goto on_error; - *out = git__strdup(file.path_lock); - if (*out == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + *bytes += recvd; + } while(recvd > 0); - /* A bit dodgy, but we need to keep the pack at the temporary path */ - error = git_filebuf_commit_at(&file, file.path_lock, GIT_PACK_FILE_MODE); -cleanup: - if (error < GIT_SUCCESS) - git_filebuf_cleanup(&file); - git_buf_free(&path); + if (git_indexer_stream_finalize(idx, stats)) + goto on_error; - return error; + git_indexer_stream_free(idx); + return 0; + +on_error: + git_indexer_stream_free(idx); + return -1; +} + +int git_fetch_setup_walk(git_revwalk **out, git_repository *repo) +{ + git_revwalk *walk; + git_strarray refs; + unsigned int i; + git_reference *ref; + + if (git_reference_listall(&refs, repo, GIT_REF_LISTALL) < 0) + return -1; + + if (git_revwalk_new(&walk, repo) < 0) + return -1; + + git_revwalk_sorting(walk, GIT_SORT_TIME); + + for (i = 0; i < refs.count; ++i) { + /* No tags */ + if (!git__prefixcmp(refs.strings[i], GIT_REFS_TAGS_DIR)) + continue; + + if (git_reference_lookup(&ref, repo, refs.strings[i]) < 0) + goto on_error; + + if (git_reference_type(ref) == GIT_REF_SYMBOLIC) + continue; + if (git_revwalk_push(walk, git_reference_oid(ref)) < 0) + goto on_error; + + git_reference_free(ref); + } + + git_strarray_free(&refs); + *out = walk; + return 0; + +on_error: + git_reference_free(ref); + git_strarray_free(&refs); + return -1; } diff --git a/src/fetch.h b/src/fetch.h index c1ab84034..b3192a563 100644 --- a/src/fetch.h +++ b/src/fetch.h @@ -10,9 +10,10 @@ #include "netops.h" int git_fetch_negotiate(git_remote *remote); -int git_fetch_download_pack(char **out, git_remote *remote); +int git_fetch_download_pack(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats); -int git_fetch__download_pack(char **out, const char *buffered, size_t buffered_size, - GIT_SOCKET fd, git_repository *repo); +int git_fetch__download_pack(const char *buffered, size_t buffered_size, GIT_SOCKET fd, + 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 01df8e2d0..6538aea66 100644 --- a/src/filebuf.c +++ b/src/filebuf.c @@ -14,13 +14,46 @@ static const size_t WRITE_BUFFER_SIZE = (4096 * 2); +enum buferr_t { + BUFERR_OK = 0, + BUFERR_WRITE, + BUFERR_ZLIB, + BUFERR_MEM +}; + +#define ENSURE_BUF_OK(buf) if ((buf)->last_error != BUFERR_OK) { return -1; } + +static int verify_last_error(git_filebuf *file) +{ + switch (file->last_error) { + case BUFERR_WRITE: + giterr_set(GITERR_OS, "Failed to write out file"); + return -1; + + case BUFERR_MEM: + giterr_set_oom(); + return -1; + + case BUFERR_ZLIB: + giterr_set(GITERR_ZLIB, + "Buffer error when writing out ZLib data"); + return -1; + + default: + return 0; + } +} + static int lock_file(git_filebuf *file, int flags) { - if (git_path_exists(file->path_lock) == 0) { + if (git_path_exists(file->path_lock) == true) { if (flags & GIT_FILEBUF_FORCE) p_unlink(file->path_lock); - else - return git__throw(GIT_EOSERR, "Failed to lock file"); + else { + giterr_set(GITERR_OS, + "Failed to lock file '%s' for writing", file->path_lock); + return -1; + } } /* create path to the file buffer is required */ @@ -32,16 +65,22 @@ static int lock_file(git_filebuf *file, int flags) } if (file->fd < 0) - return git__throw(GIT_EOSERR, "Failed to create lock"); + return -1; - if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == 0) { + file->fd_is_open = true; + + if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == true) { git_file source; char buffer[2048]; size_t read_bytes; source = p_open(file->path_original, O_RDONLY); - if (source < 0) - return git__throw(GIT_EOSERR, "Failed to lock file. Could not open %s", file->path_original); + if (source < 0) { + giterr_set(GITERR_OS, + "Failed to open file '%s' for reading", + file->path_original); + return -1; + } while ((read_bytes = p_read(source, buffer, 2048)) > 0) { p_write(file->fd, buffer, read_bytes); @@ -52,15 +91,15 @@ static int lock_file(git_filebuf *file, int flags) p_close(source); } - return GIT_SUCCESS; + return 0; } void git_filebuf_cleanup(git_filebuf *file) { - if (file->fd >= 0) + if (file->fd_is_open && file->fd >= 0) p_close(file->fd); - if (file->fd >= 0 && file->path_lock && git_path_exists(file->path_lock) == GIT_SUCCESS) + if (file->fd_is_open && file->path_lock && git_path_exists(file->path_lock)) p_unlink(file->path_lock); if (file->digest) @@ -93,20 +132,21 @@ GIT_INLINE(int) flush_buffer(git_filebuf *file) static int write_normal(git_filebuf *file, void *source, size_t len) { - int result = 0; - if (len > 0) { - result = p_write(file->fd, (void *)source, len); + if (p_write(file->fd, (void *)source, len) < 0) { + file->last_error = BUFERR_WRITE; + return -1; + } + if (file->digest) git_hash_update(file->digest, source, len); } - return result; + return 0; } static int write_deflate(git_filebuf *file, void *source, size_t len) { - int result = Z_OK; z_stream *zs = &file->zs; if (len > 0 || file->flush_mode == Z_FINISH) { @@ -119,14 +159,17 @@ static int write_deflate(git_filebuf *file, void *source, size_t len) zs->next_out = file->z_buf; zs->avail_out = (uInt)file->buf_size; - result = deflate(zs, file->flush_mode); - if (result == Z_STREAM_ERROR) - return git__throw(GIT_ERROR, "Failed to deflate input"); + if (deflate(zs, file->flush_mode) == Z_STREAM_ERROR) { + file->last_error = BUFERR_ZLIB; + return -1; + } have = file->buf_size - (size_t)zs->avail_out; - if (p_write(file->fd, file->z_buf, have) < GIT_SUCCESS) - return git__throw(GIT_EOSERR, "Failed to write to file"); + if (p_write(file->fd, file->z_buf, have) < 0) { + file->last_error = BUFERR_WRITE; + return -1; + } } while (zs->avail_out == 0); @@ -136,38 +179,39 @@ static int write_deflate(git_filebuf *file, void *source, size_t len) git_hash_update(file->digest, source, len); } - return GIT_SUCCESS; + return 0; } int git_filebuf_open(git_filebuf *file, const char *path, int flags) { - int error, compression; + int compression; size_t path_len; - assert(file && path); - - if (file->buffer) - return git__throw(GIT_EINVALIDARGS, "Tried to reopen an open filebuf"); + /* opening an already open buffer is a programming error; + * assert that this never happens instead of returning + * an error code */ + assert(file && path && file->buffer == NULL); memset(file, 0x0, sizeof(git_filebuf)); + if (flags & GIT_FILEBUF_DO_NOT_BUFFER) + file->do_not_buffer = true; + file->buf_size = WRITE_BUFFER_SIZE; file->buf_pos = 0; file->fd = -1; + file->last_error = BUFERR_OK; /* Allocate the main cache buffer */ - file->buffer = git__malloc(file->buf_size); - if (file->buffer == NULL){ - error = GIT_ENOMEM; - goto cleanup; + if (!file->do_not_buffer) { + file->buffer = git__malloc(file->buf_size); + GITERR_CHECK_ALLOC(file->buffer); } /* If we are hashing on-write, allocate a new hash context */ if (flags & GIT_FILEBUF_HASH_CONTENTS) { - if ((file->digest = git_hash_new_ctx()) == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + file->digest = git_hash_new_ctx(); + GITERR_CHECK_ALLOC(file->digest); } compression = flags >> GIT_FILEBUF_DEFLATE_SHIFT; @@ -176,16 +220,13 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags) if (compression != 0) { /* Initialize the ZLib stream */ if (deflateInit(&file->zs, compression) != Z_OK) { - error = git__throw(GIT_EZLIB, "Failed to initialize zlib"); + giterr_set(GITERR_ZLIB, "Failed to initialize zlib"); goto cleanup; } /* Allocate the Zlib cache buffer */ file->z_buf = git__malloc(file->buf_size); - if (file->z_buf == NULL){ - error = GIT_ENOMEM; - goto cleanup; - } + GITERR_CHECK_ALLOC(file->z_buf); /* Never flush */ file->flush_mode = Z_NO_FLUSH; @@ -200,106 +241,101 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags) /* Open the file as temporary for locking */ file->fd = git_futils_mktmp(&tmp_path, path); + if (file->fd < 0) { git_buf_free(&tmp_path); - error = GIT_EOSERR; goto cleanup; } + file->fd_is_open = true; /* No original path */ file->path_original = NULL; file->path_lock = git_buf_detach(&tmp_path); - - if (file->path_lock == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + GITERR_CHECK_ALLOC(file->path_lock); } else { path_len = strlen(path); /* Save the original path of the file */ file->path_original = git__strdup(path); - if (file->path_original == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + GITERR_CHECK_ALLOC(file->path_original); /* create the locking path by appending ".lock" to the original */ file->path_lock = git__malloc(path_len + GIT_FILELOCK_EXTLENGTH); - if (file->path_lock == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + GITERR_CHECK_ALLOC(file->path_lock); memcpy(file->path_lock, file->path_original, path_len); memcpy(file->path_lock + path_len, GIT_FILELOCK_EXTENSION, GIT_FILELOCK_EXTLENGTH); /* open the file for locking */ - if ((error = lock_file(file, flags)) < GIT_SUCCESS) + if (lock_file(file, flags) < 0) goto cleanup; } - return GIT_SUCCESS; + return 0; cleanup: git_filebuf_cleanup(file); - return git__rethrow(error, "Failed to open file buffer for '%s'", path); + return -1; } int git_filebuf_hash(git_oid *oid, git_filebuf *file) { - int error; - assert(oid && file && file->digest); - if ((error = flush_buffer(file)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to get hash for file"); + flush_buffer(file); + + if (verify_last_error(file) < 0) + return -1; git_hash_final(oid, file->digest); git_hash_free_ctx(file->digest); file->digest = NULL; - return GIT_SUCCESS; + return 0; } int git_filebuf_commit_at(git_filebuf *file, const char *path, mode_t mode) { git__free(file->path_original); file->path_original = git__strdup(path); - if (file->path_original == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(file->path_original); return git_filebuf_commit(file, mode); } int git_filebuf_commit(git_filebuf *file, mode_t mode) { - int error; - /* temporary files cannot be committed */ assert(file && file->path_original); file->flush_mode = Z_FINISH; - if ((error = flush_buffer(file)) < GIT_SUCCESS) - goto cleanup; + flush_buffer(file); + + if (verify_last_error(file) < 0) + goto on_error; p_close(file->fd); file->fd = -1; + file->fd_is_open = false; if (p_chmod(file->path_lock, mode)) { - error = git__throw(GIT_EOSERR, "Failed to chmod locked file before committing"); - goto cleanup; + giterr_set(GITERR_OS, "Failed to set attributes for file at '%s'", file->path_lock); + goto on_error; } p_unlink(file->path_original); - error = p_rename(file->path_lock, file->path_original); + if (p_rename(file->path_lock, file->path_original) < 0) { + giterr_set(GITERR_OS, "Failed to rename lockfile to '%s'", file->path_original); + goto on_error; + } -cleanup: git_filebuf_cleanup(file); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to commit locked file from buffer"); - return GIT_SUCCESS; + return 0; + +on_error: + git_filebuf_cleanup(file); + return -1; } GIT_INLINE(void) add_to_cache(git_filebuf *file, const void *buf, size_t len) @@ -310,22 +346,25 @@ GIT_INLINE(void) add_to_cache(git_filebuf *file, const void *buf, size_t len) int git_filebuf_write(git_filebuf *file, const void *buff, size_t len) { - int error; const unsigned char *buf = buff; + ENSURE_BUF_OK(file); + + if (file->do_not_buffer) + return file->write(file, (void *)buff, len); + for (;;) { size_t space_left = file->buf_size - file->buf_pos; /* cache if it's small */ if (space_left > len) { add_to_cache(file, buf, len); - return GIT_SUCCESS; + return 0; } add_to_cache(file, buf, space_left); - - if ((error = flush_buffer(file)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to write to buffer"); + if (flush_buffer(file) < 0) + return -1; len -= space_left; buf += space_left; @@ -334,32 +373,37 @@ int git_filebuf_write(git_filebuf *file, const void *buff, size_t len) int git_filebuf_reserve(git_filebuf *file, void **buffer, size_t len) { - int error; size_t space_left = file->buf_size - file->buf_pos; *buffer = NULL; - if (len > file->buf_size) - return GIT_ENOMEM; + ENSURE_BUF_OK(file); + + if (len > file->buf_size) { + file->last_error = BUFERR_MEM; + return -1; + } if (space_left <= len) { - if ((error = flush_buffer(file)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to reserve buffer"); + if (flush_buffer(file) < 0) + return -1; } *buffer = (file->buffer + file->buf_pos); file->buf_pos += len; - return GIT_SUCCESS; + return 0; } int git_filebuf_printf(git_filebuf *file, const char *format, ...) { va_list arglist; size_t space_left; - int len, error; + int len, res; char *tmp_buffer; + ENSURE_BUF_OK(file); + space_left = file->buf_size - file->buf_pos; do { @@ -367,24 +411,28 @@ int git_filebuf_printf(git_filebuf *file, const char *format, ...) len = p_vsnprintf((char *)file->buffer + file->buf_pos, space_left, format, arglist); va_end(arglist); - if (len < 0) - return git__throw(GIT_EOSERR, "Failed to format string"); + if (len < 0) { + file->last_error = BUFERR_MEM; + return -1; + } if ((size_t)len + 1 <= space_left) { file->buf_pos += len; - return GIT_SUCCESS; + return 0; } - if ((error = flush_buffer(file)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to output to buffer"); + if (flush_buffer(file) < 0) + return -1; space_left = file->buf_size - file->buf_pos; } while ((size_t)len + 1 <= space_left); tmp_buffer = git__malloc(len + 1); - if (!tmp_buffer) - return GIT_ENOMEM; + if (!tmp_buffer) { + file->last_error = BUFERR_MEM; + return -1; + } va_start(arglist, format); len = p_vsnprintf(tmp_buffer, len + 1, format, arglist); @@ -392,12 +440,13 @@ int git_filebuf_printf(git_filebuf *file, const char *format, ...) if (len < 0) { git__free(tmp_buffer); - return git__throw(GIT_EOSERR, "Failed to format string"); + file->last_error = BUFERR_MEM; + return -1; } - error = git_filebuf_write(file, tmp_buffer, len); + res = git_filebuf_write(file, tmp_buffer, len); git__free(tmp_buffer); - return error; + return res; } diff --git a/src/filebuf.h b/src/filebuf.h index 371215391..72563b57a 100644 --- a/src/filebuf.h +++ b/src/filebuf.h @@ -19,7 +19,8 @@ #define GIT_FILEBUF_APPEND (1 << 2) #define GIT_FILEBUF_FORCE (1 << 3) #define GIT_FILEBUF_TEMPORARY (1 << 4) -#define GIT_FILEBUF_DEFLATE_SHIFT (5) +#define GIT_FILEBUF_DO_NOT_BUFFER (1 << 5) +#define GIT_FILEBUF_DEFLATE_SHIFT (6) #define GIT_FILELOCK_EXTENSION ".lock\0" #define GIT_FILELOCK_EXTLENGTH 6 @@ -40,25 +41,37 @@ struct git_filebuf { size_t buf_size, buf_pos; git_file fd; + bool fd_is_open; + bool do_not_buffer; + int last_error; }; typedef struct git_filebuf git_filebuf; #define GIT_FILEBUF_INIT {0} -/* The git_filebuf object lifecycle is: +/* + * The git_filebuf object lifecycle is: * - Allocate git_filebuf, preferably using GIT_FILEBUF_INIT. + * * - Call git_filebuf_open() to initialize the filebuf for use. + * * - Make as many calls to git_filebuf_write(), git_filebuf_printf(), - * git_filebuf_reserve() as you like. + * git_filebuf_reserve() as you like. The error codes for these + * functions don't need to be checked. They are stored internally + * by the file buffer. + * * - While you are writing, you may call git_filebuf_hash() to get - * the hash of all you have written so far. + * the hash of all you have written so far. This function will + * fail if any of the previous writes to the buffer failed. + * * - To close the git_filebuf, you may call git_filebuf_commit() or * git_filebuf_commit_at() to save the file, or * git_filebuf_cleanup() to abandon the file. All of these will - * clear the git_filebuf object. + * free the git_filebuf object. Likewise, all of these will fail + * if any of the previous writes to the buffer failed, and set + * an error code accordingly. */ - int git_filebuf_write(git_filebuf *lock, const void *buff, size_t len); int git_filebuf_reserve(git_filebuf *file, void **buff, size_t len); int git_filebuf_printf(git_filebuf *file, const char *format, ...) GIT_FORMAT_PRINTF(2, 3); diff --git a/src/fileops.c b/src/fileops.c index 856823afb..bf95f769c 100644 --- a/src/fileops.c +++ b/src/fileops.c @@ -10,25 +10,19 @@ int git_futils_mkpath2file(const char *file_path, const mode_t mode) { - int error; + int result = 0; git_buf target_folder = GIT_BUF_INIT; - error = git_path_dirname_r(&target_folder, file_path); - if (error < GIT_SUCCESS) { - git_buf_free(&target_folder); - return git__throw(GIT_EINVALIDPATH, "Failed to recursively build `%s` tree structure. Unable to parse parent folder name", file_path); - } else { - /* reset error */ - error = GIT_SUCCESS; - } + if (git_path_dirname_r(&target_folder, file_path) < 0) + return -1; /* Does the containing folder exist? */ - if (git_path_isdir(target_folder.ptr) != GIT_SUCCESS) + if (git_path_isdir(target_folder.ptr) == false) /* Let's create the tree structure */ - error = git_futils_mkdir_r(target_folder.ptr, NULL, mode); + result = git_futils_mkdir_r(target_folder.ptr, NULL, mode); git_buf_free(&target_folder); - return error; + return result; } int git_futils_mktmp(git_buf *path_out, const char *filename) @@ -39,42 +33,82 @@ int git_futils_mktmp(git_buf *path_out, const char *filename) git_buf_puts(path_out, "_git2_XXXXXX"); if (git_buf_oom(path_out)) - return git__rethrow(git_buf_lasterror(path_out), - "Failed to create temporary file for %s", filename); + return -1; - if ((fd = p_mkstemp(path_out->ptr)) < 0) - return git__throw(GIT_EOSERR, "Failed to create temporary file %s", path_out->ptr); + if ((fd = p_mkstemp(path_out->ptr)) < 0) { + giterr_set(GITERR_OS, + "Failed to create temporary file '%s'", path_out->ptr); + return -1; + } return fd; } int git_futils_creat_withpath(const char *path, const mode_t dirmode, const mode_t mode) { - if (git_futils_mkpath2file(path, dirmode) < GIT_SUCCESS) - return git__throw(GIT_EOSERR, "Failed to create file %s", path); + int fd; - return p_creat(path, mode); + if (git_futils_mkpath2file(path, dirmode) < 0) + return -1; + + fd = p_creat(path, mode); + if (fd < 0) { + giterr_set(GITERR_OS, "Failed to create file '%s'", path); + return -1; + } + + return fd; } int git_futils_creat_locked(const char *path, const mode_t mode) { - int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode); - return fd >= 0 ? fd : git__throw(GIT_EOSERR, "Failed to create locked file. Could not open %s", path); + int fd; + +#ifdef GIT_WIN32 + wchar_t* buf; + + buf = gitwin_to_utf16(path); + fd = _wopen(buf, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode); + git__free(buf); +#else + fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode); +#endif + + if (fd < 0) { + giterr_set(GITERR_OS, "Failed to create locked file '%s'", path); + return -1; + } + + return fd; } int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode) { - if (git_futils_mkpath2file(path, dirmode) < GIT_SUCCESS) - return git__throw(GIT_EOSERR, "Failed to create locked file %s", path); + if (git_futils_mkpath2file(path, dirmode) < 0) + return -1; return git_futils_creat_locked(path, mode); } +int git_futils_open_ro(const char *path) +{ + int fd = p_open(path, O_RDONLY); + if (fd < 0) { + if (errno == ENOENT) + fd = GIT_ENOTFOUND; + giterr_set(GITERR_OS, "Failed to open '%s'", path); + } + return fd; +} + git_off_t git_futils_filesize(git_file fd) { struct stat sb; - if (p_fstat(fd, &sb)) - return GIT_ERROR; + + if (p_fstat(fd, &sb)) { + giterr_set(GITERR_OS, "Failed to stat file descriptor"); + return -1; + } return sb.st_size; } @@ -85,10 +119,10 @@ mode_t git_futils_canonical_mode(mode_t raw_mode) return S_IFREG | GIT_CANONICAL_PERMS(raw_mode); else if (S_ISLNK(raw_mode)) return S_IFLNK; - else if (S_ISDIR(raw_mode)) - return S_IFDIR; else if (S_ISGITLINK(raw_mode)) return S_IFGITLINK; + else if (S_ISDIR(raw_mode)) + return S_IFDIR; else return 0; } @@ -104,13 +138,13 @@ int git_futils_readbuffer_updated(git_buf *buf, const char *path, time_t *mtime, if (updated != NULL) *updated = 0; - if ((fd = p_open(path, O_RDONLY)) < 0) { - return git__throw(GIT_ENOTFOUND, "Failed to read file '%s': %s", path, strerror(errno)); - } + if ((fd = git_futils_open_ro(path)) < 0) + return fd; if (p_fstat(fd, &st) < 0 || S_ISDIR(st.st_mode) || !git__is_sizet(st.st_size+1)) { - close(fd); - return git__throw(GIT_EOSERR, "Failed to stat file '%s'", path); + p_close(fd); + giterr_set(GITERR_OS, "Invalid regular file stat for '%s'", path); + return -1; } /* @@ -118,7 +152,7 @@ int git_futils_readbuffer_updated(git_buf *buf, const char *path, time_t *mtime, * has been modified. */ if (mtime != NULL && *mtime >= st.st_mtime) { - close(fd); + p_close(fd); return 0; } @@ -130,8 +164,8 @@ int git_futils_readbuffer_updated(git_buf *buf, const char *path, time_t *mtime, git_buf_clear(buf); if (git_buf_grow(buf, len + 1) < 0) { - close(fd); - return GIT_ENOMEM; + p_close(fd); + return -1; } buf->ptr[len] = '\0'; @@ -140,8 +174,9 @@ int git_futils_readbuffer_updated(git_buf *buf, const char *path, time_t *mtime, ssize_t read_size = p_read(fd, buf->ptr, len); if (read_size < 0) { - close(fd); - return git__throw(GIT_EOSERR, "Failed to read from FD"); + p_close(fd); + giterr_set(GITERR_OS, "Failed to read descriptor for '%s'", path); + return -1; } len -= read_size; @@ -166,10 +201,15 @@ int git_futils_readbuffer(git_buf *buf, const char *path) int git_futils_mv_withpath(const char *from, const char *to, const mode_t dirmode) { - if (git_futils_mkpath2file(to, dirmode) < GIT_SUCCESS) - return GIT_EOSERR; /* The callee already takes care of setting the correct error message. */ + if (git_futils_mkpath2file(to, dirmode) < 0) + return -1; - return p_rename(from, to); /* The callee already takes care of setting the correct error message. */ + if (p_rename(from, to) < 0) { + giterr_set(GITERR_OS, "Failed to rename '%s' to '%s'", from, to); + return -1; + } + + return 0; } int git_futils_mmap_ro(git_map *out, git_file fd, git_off_t begin, size_t len) @@ -179,11 +219,19 @@ int git_futils_mmap_ro(git_map *out, git_file fd, git_off_t begin, size_t len) int git_futils_mmap_ro_file(git_map *out, const char *path) { - git_file fd = p_open(path, O_RDONLY /* | O_NOATIME */); - git_off_t len = git_futils_filesize(fd); + git_file fd = git_futils_open_ro(path); + git_off_t len; int result; - if (!git__is_sizet(len)) - return git__throw(GIT_ERROR, "File `%s` too large to mmap", path); + + if (fd < 0) + return fd; + + len = git_futils_filesize(fd); + if (!git__is_sizet(len)) { + giterr_set(GITERR_OS, "File `%s` too large to mmap", path); + return -1; + } + result = git_futils_mmap_ro(out, fd, 0, (size_t)len); p_close(fd); return result; @@ -196,20 +244,21 @@ void git_futils_mmap_free(git_map *out) int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode) { - int error, root_path_offset; + int root_path_offset; git_buf make_path = GIT_BUF_INIT; size_t start; char *pp, *sp; + bool failed = false; if (base != NULL) { start = strlen(base); - error = git_buf_joinpath(&make_path, base, path); + if (git_buf_joinpath(&make_path, base, path) < 0) + return -1; } else { start = 0; - error = git_buf_puts(&make_path, path); + if (git_buf_puts(&make_path, path) < 0) + return -1; } - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create `%s` tree structure", path); pp = make_path.ptr + start; @@ -217,14 +266,13 @@ int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode) if (root_path_offset > 0) pp += root_path_offset; /* On Windows, will skip the drive name (eg. C: or D:) */ - while (error == GIT_SUCCESS && (sp = strchr(pp, '/')) != NULL) { - if (sp != pp && git_path_isdir(make_path.ptr) < GIT_SUCCESS) { + while (!failed && (sp = strchr(pp, '/')) != NULL) { + if (sp != pp && git_path_isdir(make_path.ptr) == false) { *sp = 0; - error = p_mkdir(make_path.ptr, mode); /* Do not choke while trying to recreate an existing directory */ - if (errno == EEXIST) - error = GIT_SUCCESS; + if (p_mkdir(make_path.ptr, mode) < 0 && errno != EEXIST) + failed = true; *sp = '/'; } @@ -232,53 +280,76 @@ int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode) pp = sp + 1; } - if (*pp != '\0' && error == GIT_SUCCESS) { - error = p_mkdir(make_path.ptr, mode); - if (errno == EEXIST) - error = GIT_SUCCESS; + if (*pp != '\0' && !failed) { + if (p_mkdir(make_path.ptr, mode) < 0 && errno != EEXIST) + failed = true; } git_buf_free(&make_path); - if (error < GIT_SUCCESS) - return git__throw(error, "Failed to recursively create `%s` tree structure", path); + if (failed) { + giterr_set(GITERR_OS, + "Failed to create directory structure at '%s'", path); + return -1; + } - return GIT_SUCCESS; + return 0; } static int _rmdir_recurs_foreach(void *opaque, git_buf *path) { - int error = GIT_SUCCESS; - int force = *(int *)opaque; + git_directory_removal_type removal_type = *(git_directory_removal_type *)opaque; - if (git_path_isdir(path->ptr) == GIT_SUCCESS) { - error = git_path_direach(path, _rmdir_recurs_foreach, opaque); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to remove directory `%s`", path->ptr); - return p_rmdir(path->ptr); + assert(removal_type == GIT_DIRREMOVAL_EMPTY_HIERARCHY + || removal_type == GIT_DIRREMOVAL_FILES_AND_DIRS + || removal_type == GIT_DIRREMOVAL_ONLY_EMPTY_DIRS); - } else if (force) { - return p_unlink(path->ptr); + if (git_path_isdir(path->ptr) == true) { + if (git_path_direach(path, _rmdir_recurs_foreach, opaque) < 0) + return -1; + + if (p_rmdir(path->ptr) < 0) { + if (removal_type == GIT_DIRREMOVAL_ONLY_EMPTY_DIRS && errno == ENOTEMPTY) + return 0; + + giterr_set(GITERR_OS, "Could not remove directory '%s'", path->ptr); + return -1; + } + + return 0; } - return git__rethrow(error, "Failed to remove directory. `%s` is not empty", path->ptr); + if (removal_type == GIT_DIRREMOVAL_FILES_AND_DIRS) { + if (p_unlink(path->ptr) < 0) { + giterr_set(GITERR_OS, "Could not remove directory. File '%s' cannot be removed", path->ptr); + return -1; + } + + return 0; + } + + if (removal_type == GIT_DIRREMOVAL_EMPTY_HIERARCHY) { + giterr_set(GITERR_OS, "Could not remove directory. File '%s' still present", path->ptr); + return -1; + } + + return 0; } -int git_futils_rmdir_r(const char *path, int force) +int git_futils_rmdir_r(const char *path, git_directory_removal_type removal_type) { int error; git_buf p = GIT_BUF_INIT; error = git_buf_sets(&p, path); - if (error == GIT_SUCCESS) - error = _rmdir_recurs_foreach(&force, &p); + if (!error) + error = _rmdir_recurs_foreach(&removal_type, &p); git_buf_free(&p); return error; } int git_futils_find_global_file(git_buf *path, const char *filename) { - int error; const char *home = getenv("HOME"); #ifdef GIT_WIN32 @@ -286,19 +357,21 @@ int git_futils_find_global_file(git_buf *path, const char *filename) home = getenv("USERPROFILE"); #endif - if (home == NULL) - return git__throw(GIT_EOSERR, "Failed to open global %s file. " - "Cannot locate the user's home directory.", filename); + if (home == NULL) { + giterr_set(GITERR_OS, "Global file lookup failed. " + "Cannot locate the user's home directory"); + return -1; + } - if ((error = git_buf_joinpath(path, home, filename)) < GIT_SUCCESS) - return error; + if (git_buf_joinpath(path, home, filename) < 0) + return -1; - if (git_path_exists(path->ptr) < GIT_SUCCESS) { + if (git_path_exists(path->ptr) == false) { git_buf_clear(path); return GIT_ENOTFOUND; } - return GIT_SUCCESS; + return 0; } #ifdef GIT_WIN32 @@ -315,9 +388,8 @@ static const win32_path *win32_system_root(void) const wchar_t *root_tmpl = L"%PROGRAMFILES%\\Git\\etc\\"; s_root.len = ExpandEnvironmentStringsW(root_tmpl, NULL, 0); - if (s_root.len <= 0) { - git__throw(GIT_EOSERR, "Failed to expand environment strings"); + giterr_set(GITERR_OS, "Failed to expand environment strings"); return NULL; } @@ -326,7 +398,7 @@ static const win32_path *win32_system_root(void) return NULL; if (ExpandEnvironmentStringsW(root_tmpl, s_root.path, s_root.len) != s_root.len) { - git__throw(GIT_EOSERR, "Failed to expand environment strings"); + giterr_set(GITERR_OS, "Failed to expand environment strings"); git__free(s_root.path); s_root.path = NULL; return NULL; @@ -338,7 +410,7 @@ static const win32_path *win32_system_root(void) static int win32_find_system_file(git_buf *path, const char *filename) { - int error = GIT_SUCCESS; + int error = 0; const win32_path *root = win32_system_root(); size_t len; wchar_t *file_utf16 = NULL, *scan; @@ -349,8 +421,7 @@ static int win32_find_system_file(git_buf *path, const char *filename) /* allocate space for wchar_t path to file */ file_utf16 = git__calloc(root->len + len + 2, sizeof(wchar_t)); - if (!file_utf16) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(file_utf16); /* append root + '\\' + filename as wchar_t */ memcpy(file_utf16, root->path, root->len * sizeof(wchar_t)); @@ -360,7 +431,7 @@ static int win32_find_system_file(git_buf *path, const char *filename) if (gitwin_append_utf16(file_utf16 + root->len - 1, filename, len + 1) != (int)len + 1) { - error = git__throw(GIT_EOSERR, "Failed to build file path"); + error = -1; goto cleanup; } @@ -376,9 +447,8 @@ static int win32_find_system_file(git_buf *path, const char *filename) /* convert to utf8 */ if ((file_utf8 = gitwin_from_utf16(file_utf16)) == NULL) - error = GIT_ENOMEM; - - if (file_utf8) { + error = -1; + else { git_path_mkposix(file_utf8); git_buf_attach(path, file_utf8, 0); } @@ -392,11 +462,11 @@ cleanup: int git_futils_find_system_file(git_buf *path, const char *filename) { - if (git_buf_joinpath(path, "/etc", filename) < GIT_SUCCESS) - return git_buf_lasterror(path); + if (git_buf_joinpath(path, "/etc", filename) < 0) + return -1; - if (git_path_exists(path->ptr) == GIT_SUCCESS) - return GIT_SUCCESS; + if (git_path_exists(path->ptr) == true) + return 0; git_buf_clear(path); diff --git a/src/fileops.h b/src/fileops.h index ab57b6f38..be619d620 100644 --- a/src/fileops.h +++ b/src/fileops.h @@ -26,7 +26,7 @@ extern int git_futils_readbuffer_updated(git_buf *obj, const char *path, time_t * These are custom filesystem-related helper methods. They are * rather high level, and wrap the underlying POSIX methods * - * All these methods return GIT_SUCCESS on success, + * All these methods return 0 on success, * or an error code on failure and an error message is set. */ @@ -58,10 +58,25 @@ extern int git_futils_mkdir_r(const char *path, const char *base, const mode_t m */ extern int git_futils_mkpath2file(const char *path, const mode_t mode); +typedef enum { + GIT_DIRREMOVAL_EMPTY_HIERARCHY = 0, + GIT_DIRREMOVAL_FILES_AND_DIRS = 1, + GIT_DIRREMOVAL_ONLY_EMPTY_DIRS = 2, +} git_directory_removal_type; + /** * Remove path and any files and directories beneath it. + * + * @param path Path to to top level directory to process. + * + * @param removal_type GIT_DIRREMOVAL_EMPTY_HIERARCHY to remove a hierarchy + * of empty directories (will fail if any file is found), GIT_DIRREMOVAL_FILES_AND_DIRS + * to remove a hierarchy of files and folders, GIT_DIRREMOVAL_ONLY_EMPTY_DIRS to only remove + * empty directories (no failure on file encounter). + * + * @return 0 on success; -1 on error. */ -extern int git_futils_rmdir_r(const char *path, int force); +extern int git_futils_rmdir_r(const char *path, git_directory_removal_type removal_type); /** * Create and open a temporary file with a `_git2_` suffix. @@ -76,6 +91,11 @@ extern int git_futils_mktmp(git_buf *path_out, const char *filename); */ extern int git_futils_mv_withpath(const char *from, const char *to, const mode_t dirmode); +/** + * Open a file readonly and set error if needed. + */ +extern int git_futils_open_ro(const char *path); + /** * Get the filesize in bytes of a file */ @@ -103,8 +123,8 @@ extern mode_t git_futils_canonical_mode(mode_t raw_mode); * @param begin first byte to map, this should be page aligned. * @param end number of bytes to map. * @return - * - GIT_SUCCESS on success; - * - GIT_EOSERR on an unspecified OS related error. + * - 0 on success; + * - -1 on error. */ extern int git_futils_mmap_ro( git_map *out, @@ -118,8 +138,9 @@ extern int git_futils_mmap_ro( * @param out buffer to populate with the mapping information. * @param path path to file to be opened. * @return - * - GIT_SUCCESS on success; - * - GIT_EOSERR on an unspecified OS related error. + * - 0 on success; + * - GIT_ENOTFOUND if not found; + * - -1 on an unspecified OS related error. */ extern int git_futils_mmap_ro_file( git_map *out, @@ -137,9 +158,9 @@ extern void git_futils_mmap_free(git_map *map); * @param pathbuf buffer to write the full path into * @param filename name of file to find in the home directory * @return - * - GIT_SUCCESS if found; + * - 0 if found; * - GIT_ENOTFOUND if not found; - * - GIT_EOSERR on an unspecified OS related error. + * - -1 on an unspecified OS related error. */ extern int git_futils_find_global_file(git_buf *path, const char *filename); @@ -149,9 +170,9 @@ extern int git_futils_find_global_file(git_buf *path, const char *filename); * @param pathbuf buffer to write the full path into * @param filename name of file to find in the home directory * @return - * - GIT_SUCCESS if found; + * - 0 if found; * - GIT_ENOTFOUND if not found; - * - GIT_EOSERR on an unspecified OS related error. + * - -1 on an unspecified OS related error. */ extern int git_futils_find_system_file(git_buf *path, const char *filename); diff --git a/src/filter.c b/src/filter.c index f0ee1ad39..73fe83e61 100644 --- a/src/filter.c +++ b/src/filter.c @@ -19,13 +19,13 @@ void git_text_gather_stats(git_text_stats *stats, const git_buf *text) memset(stats, 0, sizeof(*stats)); - for (i = 0; i < text->size; i++) { + for (i = 0; i < git_buf_len(text); i++) { unsigned char c = text->ptr[i]; if (c == '\r') { stats->cr++; - if (i + 1 < text->size && text->ptr[i + 1] == '\n') + if (i + 1 < git_buf_len(text) && text->ptr[i + 1] == '\n') stats->crlf++; } @@ -59,7 +59,7 @@ void git_text_gather_stats(git_text_stats *stats, const git_buf *text) } /* If file ends with EOF then don't count this EOF as non-printable. */ - if (text->size >= 1 && text->ptr[text->size - 1] == '\032') + if (git_buf_len(text) >= 1 && text->ptr[text->size - 1] == '\032') stats->nonprintable--; } @@ -92,11 +92,11 @@ int git_filters_load(git_vector *filters, git_repository *repo, const char *path if (mode == GIT_FILTER_TO_ODB) { /* Load the CRLF cleanup filter when writing to the ODB */ error = git_filter_add__crlf_to_odb(filters, repo, path); - if (error < GIT_SUCCESS) + if (error < 0) return error; } else { - return git__throw(GIT_ENOTIMPLEMENTED, - "Worktree filters are not implemented yet"); + giterr_set(GITERR_INVALID, "Worktree filters are not implemented yet"); + return -1; } return (int)filters->length; @@ -111,7 +111,7 @@ void git_filters_free(git_vector *filters) if (filter->do_free != NULL) filter->do_free(filter); else - free(filter); + git__free(filter); } git_vector_free(filters); @@ -127,15 +127,15 @@ int git_filters_apply(git_buf *dest, git_buf *source, git_vector *filters) src = 0; - if (source->size == 0) { + if (git_buf_len(source) == 0) { git_buf_clear(dest); return GIT_SUCCESS; } /* Pre-grow the destination buffer to more or less the size * we expect it to have */ - if (git_buf_grow(dest, source->size) < 0) - return GIT_ENOMEM; + if (git_buf_grow(dest, git_buf_len(source)) < 0) + return -1; for (i = 0; i < filters->length; ++i) { git_filter *filter = git_vector_get(filters, i); @@ -153,7 +153,7 @@ int git_filters_apply(git_buf *dest, git_buf *source, git_vector *filters) src = dst; if (git_buf_oom(dbuffer[dst])) - return GIT_ENOMEM; + return -1; } /* Ensure that the output ends up in dbuffer[1] (i.e. the dest) */ diff --git a/src/global.c b/src/global.c index b10fabc61..368c6c664 100644 --- a/src/global.c +++ b/src/global.c @@ -62,7 +62,7 @@ git_global_st *git__global_state(void) if ((ptr = TlsGetValue(_tls_index)) != NULL) return ptr; - ptr = malloc(sizeof(git_global_st)); + ptr = git__malloc(sizeof(git_global_st)); if (!ptr) return NULL; @@ -78,7 +78,7 @@ static int _tls_init = 0; static void cb__free_status(void *st) { - free(st); + git__free(st); } void git_threads_init(void) @@ -103,7 +103,7 @@ git_global_st *git__global_state(void) if ((ptr = pthread_getspecific(_tls_key)) != NULL) return ptr; - ptr = malloc(sizeof(git_global_st)); + ptr = git__malloc(sizeof(git_global_st)); if (!ptr) return NULL; diff --git a/src/global.h b/src/global.h index 0c1e3289c..2b525ce07 100644 --- a/src/global.h +++ b/src/global.h @@ -14,6 +14,9 @@ typedef struct { char last[1024]; } error; + git_error *last_error; + git_error error_t; + git_mwindow_ctl mem_ctl; } git_global_st; diff --git a/src/hashtable.c b/src/hashtable.c deleted file mode 100644 index 73a6336c4..000000000 --- a/src/hashtable.c +++ /dev/null @@ -1,258 +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. - */ - -#include "common.h" -#include "repository.h" -#include "commit.h" - -#define MAX_LOOPS 5 -static const double max_load_factor = 0.65; - -static int resize_to(git_hashtable *self, size_t new_size); -static int set_size(git_hashtable *self, size_t new_size); -static git_hashtable_node *node_with_hash(git_hashtable *self, const void *key, int hash_id); -static void node_swap_with(git_hashtable_node *self, git_hashtable_node *other); -static int node_insert(git_hashtable *self, git_hashtable_node *new_node); -static int insert_nodes(git_hashtable *self, git_hashtable_node *old_nodes, size_t old_size); - -static int resize_to(git_hashtable *self, size_t new_size) -{ - git_hashtable_node *old_nodes = self->nodes; - size_t old_size = self->size; - - self->is_resizing = 1; - - do { - self->size = new_size; - self->size_mask = new_size - 1; - self->key_count = 0; - self->nodes = git__calloc(1, sizeof(git_hashtable_node) * self->size); - - if (self->nodes == NULL) - return GIT_ENOMEM; - - if (insert_nodes(self, old_nodes, old_size) == 0) - self->is_resizing = 0; - else { - new_size *= 2; - git__free(self->nodes); - } - } while(self->is_resizing); - - git__free(old_nodes); - return GIT_SUCCESS; -} - -static int set_size(git_hashtable *self, size_t new_size) -{ - self->nodes = git__realloc(self->nodes, new_size * sizeof(git_hashtable_node)); - if (self->nodes == NULL) - return GIT_ENOMEM; - - if (new_size > self->size) { - memset(&self->nodes[self->size], 0x0, (new_size - self->size) * sizeof(git_hashtable_node)); - } - - self->size = new_size; - self->size_mask = new_size - 1; - return GIT_SUCCESS; -} - -static git_hashtable_node *node_with_hash(git_hashtable *self, const void *key, int hash_id) -{ - size_t pos = self->hash(key, hash_id) & self->size_mask; - return git_hashtable_node_at(self->nodes, pos); -} - -static void node_swap_with(git_hashtable_node *self, git_hashtable_node *other) -{ - git_hashtable_node tmp = *self; - *self = *other; - *other = tmp; -} - -static int node_insert(git_hashtable *self, git_hashtable_node *new_node) -{ - int iteration, hash_id; - - for (iteration = 0; iteration < MAX_LOOPS; iteration++) { - for (hash_id = 0; hash_id < GIT_HASHTABLE_HASHES; ++hash_id) { - git_hashtable_node *node; - node = node_with_hash(self, new_node->key, hash_id); - node_swap_with(new_node, node); - if(new_node->key == 0x0){ - self->key_count++; - return GIT_SUCCESS; - } - } - } - - if (self->is_resizing) - return git__throw(GIT_EBUSY, "Failed to insert node. Hashtable is currently resizing"); - - resize_to(self, self->size * 2); - git_hashtable_insert(self, new_node->key, new_node->value); - return GIT_SUCCESS; -} - -static int insert_nodes(git_hashtable *self, git_hashtable_node *old_nodes, size_t old_size) -{ - size_t i; - - for (i = 0; i < old_size; ++i) { - git_hashtable_node *node = git_hashtable_node_at(old_nodes, i); - if (node->key && git_hashtable_insert(self, node->key, node->value) < GIT_SUCCESS) - return GIT_ENOMEM; - } - - return GIT_SUCCESS; -} - -git_hashtable *git_hashtable_alloc(size_t min_size, - git_hash_ptr hash, - git_hash_keyeq_ptr key_eq) -{ - git_hashtable *table; - - assert(hash && key_eq); - - if ((table = git__malloc(sizeof(git_hashtable))) == NULL) - return NULL; - - memset(table, 0x0, sizeof(git_hashtable)); - - if (min_size < 8) - min_size = 8; - - /* round up size to closest power of 2 */ - min_size--; - min_size |= min_size >> 1; - min_size |= min_size >> 2; - min_size |= min_size >> 4; - min_size |= min_size >> 8; - min_size |= min_size >> 16; - - table->hash = hash; - table->key_equal = key_eq; - - set_size(table, min_size + 1); - - return table; -} - -void git_hashtable_clear(git_hashtable *self) -{ - assert(self); - - memset(self->nodes, 0x0, sizeof(git_hashtable_node) * self->size); - self->key_count = 0; -} - -void git_hashtable_free(git_hashtable *self) -{ - assert(self); - - git__free(self->nodes); - git__free(self); -} - - -int git_hashtable_insert2(git_hashtable *self, const void *key, void *value, void **old_value) -{ - int hash_id; - git_hashtable_node *node; - - assert(self && self->nodes); - - *old_value = NULL; - - for (hash_id = 0; hash_id < GIT_HASHTABLE_HASHES; ++hash_id) { - node = node_with_hash(self, key, hash_id); - - if (!node->key) { - node->key = key; - node->value = value; - self->key_count++; - return GIT_SUCCESS; - } - - if (key == node->key || self->key_equal(key, node->key) == 0) { - *old_value = node->value; - node->key = key; - node->value = value; - return GIT_SUCCESS; - } - } - - /* no space in table; must do cuckoo dance */ - { - git_hashtable_node x; - x.key = key; - x.value = value; - return node_insert(self, &x); - } -} - -void *git_hashtable_lookup(git_hashtable *self, const void *key) -{ - int hash_id; - git_hashtable_node *node; - - assert(self && self->nodes); - - for (hash_id = 0; hash_id < GIT_HASHTABLE_HASHES; ++hash_id) { - node = node_with_hash(self, key, hash_id); - if (node->key && self->key_equal(key, node->key) == 0) - return node->value; - } - - return NULL; -} - -int git_hashtable_remove2(git_hashtable *self, const void *key, void **old_value) -{ - int hash_id; - git_hashtable_node *node; - - assert(self && self->nodes); - - for (hash_id = 0; hash_id < GIT_HASHTABLE_HASHES; ++hash_id) { - node = node_with_hash(self, key, hash_id); - if (node->key && self->key_equal(key, node->key) == 0) { - *old_value = node->value; - node->key = NULL; - node->value = NULL; - self->key_count--; - return GIT_SUCCESS; - } - } - - return git__throw(GIT_ENOTFOUND, "Entry not found in hash table"); -} - -int git_hashtable_merge(git_hashtable *self, git_hashtable *other) -{ - if (resize_to(self, (self->size + other->size) * 2) < GIT_SUCCESS) - return GIT_ENOMEM; - - return insert_nodes(self, other->nodes, other->key_count); -} - - -/** - * Standard string - */ -uint32_t git_hash__strhash_cb(const void *key, int hash_id) -{ - static uint32_t hash_seeds[GIT_HASHTABLE_HASHES] = { - 2147483647, - 0x5d20bb23, - 0x7daaab3c - }; - - return git__hash(key, strlen((const char *)key), hash_seeds[hash_id]); -} diff --git a/src/hashtable.h b/src/hashtable.h deleted file mode 100644 index e09965965..000000000 --- a/src/hashtable.h +++ /dev/null @@ -1,95 +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_hashtable_h__ -#define INCLUDE_hashtable_h__ - -#include "git2/common.h" -#include "git2/oid.h" -#include "git2/odb.h" -#include "common.h" - -#define GIT_HASHTABLE_HASHES 3 - -typedef uint32_t (*git_hash_ptr)(const void *, int hash_id); -typedef int (*git_hash_keyeq_ptr)(const void *key_a, const void *key_b); - -struct git_hashtable_node { - const void *key; - void *value; -}; - -struct git_hashtable { - struct git_hashtable_node *nodes; - - size_t size_mask; - size_t size; - size_t key_count; - - int is_resizing; - - git_hash_ptr hash; - git_hash_keyeq_ptr key_equal; -}; - -typedef struct git_hashtable_node git_hashtable_node; -typedef struct git_hashtable git_hashtable; - -git_hashtable *git_hashtable_alloc(size_t min_size, - git_hash_ptr hash, - git_hash_keyeq_ptr key_eq); -void *git_hashtable_lookup(git_hashtable *h, const void *key); -int git_hashtable_remove2(git_hashtable *table, const void *key, void **old_value); - -GIT_INLINE(int) git_hashtable_remove(git_hashtable *table, const void *key) -{ - void *_unused; - return git_hashtable_remove2(table, key, &_unused); -} - - -void git_hashtable_free(git_hashtable *h); -void git_hashtable_clear(git_hashtable *h); -int git_hashtable_merge(git_hashtable *self, git_hashtable *other); - -int git_hashtable_insert2(git_hashtable *h, const void *key, void *value, void **old_value); - -GIT_INLINE(int) git_hashtable_insert(git_hashtable *h, const void *key, void *value) -{ - void *_unused; - return git_hashtable_insert2(h, key, value, &_unused); -} - -#define git_hashtable_node_at(nodes, pos) ((git_hashtable_node *)(&nodes[pos])) - -#define GIT_HASHTABLE__FOREACH(self,block) { \ - unsigned int _c; \ - git_hashtable_node *_n = (self)->nodes; \ - for (_c = (self)->size; _c > 0; _c--, _n++) { \ - if (!_n->key) continue; block } } - -#define GIT_HASHTABLE_FOREACH(self, pkey, pvalue, code)\ - GIT_HASHTABLE__FOREACH(self,{(pkey)=_n->key;(pvalue)=_n->value;code;}) - -#define GIT_HASHTABLE_FOREACH_KEY(self, pkey, code)\ - GIT_HASHTABLE__FOREACH(self,{(pkey)=_n->key;code;}) - -#define GIT_HASHTABLE_FOREACH_VALUE(self, pvalue, code)\ - GIT_HASHTABLE__FOREACH(self,{(pvalue)=_n->value;code;}) - -#define GIT_HASHTABLE_FOREACH_DELETE() {\ - _node->key = NULL; _node->value = NULL; _self->key_count--;\ -} - -/* - * If you want a hashtable with standard string keys, you can - * just pass git_hash__strcmp_cb and git_hash__strhash_cb to - * git_hashtable_alloc. - */ -#define git_hash__strcmp_cb git__strcmp_cb -extern uint32_t git_hash__strhash_cb(const void *key, int hash_id); - -#endif diff --git a/src/ignore.c b/src/ignore.c index a3bf0a282..fc6194bb5 100644 --- a/src/ignore.c +++ b/src/ignore.c @@ -1,81 +1,75 @@ #include "ignore.h" #include "path.h" -#include "git2/config.h" #define GIT_IGNORE_INTERNAL "[internal]exclude" #define GIT_IGNORE_FILE_INREPO "info/exclude" #define GIT_IGNORE_FILE ".gitignore" -#define GIT_IGNORE_CONFIG "core.excludesfile" -static int load_ignore_file( - git_repository *repo, const char *path, git_attr_file *ignores) +static int parse_ignore_file( + git_repository *repo, const char *buffer, git_attr_file *ignores) { - int error = GIT_SUCCESS; - git_buf fbuf = GIT_BUF_INIT; + int error = 0; git_attr_fnmatch *match = NULL; const char *scan = NULL; char *context = NULL; - if (ignores->path == NULL) - error = git_attr_file__set_path(repo, path, ignores); + GIT_UNUSED(repo); - if (git__suffixcmp(ignores->path, GIT_IGNORE_FILE) == 0) { - context = git__strndup(ignores->path, - strlen(ignores->path) - strlen(GIT_IGNORE_FILE)); - if (!context) error = GIT_ENOMEM; + if (ignores->key && git__suffixcmp(ignores->key, "/" GIT_IGNORE_FILE) == 0) { + context = ignores->key + 2; + context[strlen(context) - strlen(GIT_IGNORE_FILE)] = '\0'; } - if (error == GIT_SUCCESS) - error = git_futils_readbuffer(&fbuf, path); + scan = buffer; - scan = fbuf.ptr; - - while (error == GIT_SUCCESS && *scan) { - if (!match && !(match = git__calloc(1, sizeof(git_attr_fnmatch)))) { - error = GIT_ENOMEM; - break; + while (!error && *scan) { + if (!match) { + match = git__calloc(1, sizeof(*match)); + GITERR_CHECK_ALLOC(match); } - if (!(error = git_attr_fnmatch__parse(match, context, &scan))) { + if (!(error = git_attr_fnmatch__parse( + match, ignores->pool, context, &scan))) + { match->flags = match->flags | GIT_ATTR_FNMATCH_IGNORE; scan = git__next_line(scan); error = git_vector_insert(&ignores->rules, match); } - if (error != GIT_SUCCESS) { + if (error != 0) { git__free(match->pattern); match->pattern = NULL; if (error == GIT_ENOTFOUND) - error = GIT_SUCCESS; + error = 0; } else { match = NULL; /* vector now "owns" the match */ } } - git_buf_free(&fbuf); git__free(match); - git__free(context); - - if (error != GIT_SUCCESS) - git__rethrow(error, "Could not open ignore file '%s'", path); + /* restore file path used for context */ + if (context) + context[strlen(context)] = '.'; /* first char of GIT_IGNORE_FILE */ return error; } -#define push_ignore(R,S,B,F) \ - git_attr_cache__push_file((R),(S),(B),(F),load_ignore_file) +#define push_ignore_file(R,S,B,F) \ + git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,parse_ignore_file,(S)) static int push_one_ignore(void *ref, git_buf *path) { git_ignores *ign = (git_ignores *)ref; - return push_ignore(ign->repo, &ign->ign_path, path->ptr, GIT_IGNORE_FILE); + return push_ignore_file(ign->repo, &ign->ign_path, path->ptr, GIT_IGNORE_FILE); } -int git_ignore__for_path(git_repository *repo, const char *path, git_ignores *ignores) +int git_ignore__for_path( + git_repository *repo, + const char *path, + git_ignores *ignores) { - int error = GIT_SUCCESS; - git_config *cfg; + int error = 0; const char *workdir = git_repository_workdir(repo); assert(ignores); @@ -83,74 +77,70 @@ int git_ignore__for_path(git_repository *repo, const char *path, git_ignores *ig ignores->repo = repo; git_buf_init(&ignores->dir, 0); ignores->ign_internal = NULL; - git_vector_init(&ignores->ign_path, 8, NULL); - git_vector_init(&ignores->ign_global, 2, NULL); - if ((error = git_attr_cache__init(repo)) < GIT_SUCCESS) + if ((error = git_vector_init(&ignores->ign_path, 8, NULL)) < 0 || + (error = git_vector_init(&ignores->ign_global, 2, NULL)) < 0 || + (error = git_attr_cache__init(repo)) < 0) goto cleanup; - if ((error = git_path_find_dir(&ignores->dir, path, workdir)) < GIT_SUCCESS) + /* given a unrooted path in a non-bare repo, resolve it */ + if (workdir && git_path_root(path) < 0) + error = git_path_find_dir(&ignores->dir, path, workdir); + else + error = git_buf_sets(&ignores->dir, path); + if (error < 0) goto cleanup; /* set up internals */ - error = git_attr_cache__lookup_or_create_file( - repo, GIT_IGNORE_INTERNAL, NULL, NULL, &ignores->ign_internal); - if (error < GIT_SUCCESS) + error = git_attr_cache__internal_file( + repo, GIT_IGNORE_INTERNAL, &ignores->ign_internal); + if (error < 0) goto cleanup; /* load .gitignore up the path */ - error = git_path_walk_up(&ignores->dir, workdir, push_one_ignore, ignores); - if (error < GIT_SUCCESS) - goto cleanup; + if (workdir != NULL) { + error = git_path_walk_up( + &ignores->dir, workdir, push_one_ignore, ignores); + if (error < 0) + goto cleanup; + } /* load .git/info/exclude */ - error = push_ignore(repo, &ignores->ign_global, - repo->path_repository, GIT_IGNORE_FILE_INREPO); - if (error < GIT_SUCCESS) + error = push_ignore_file(repo, &ignores->ign_global, + git_repository_path(repo), GIT_IGNORE_FILE_INREPO); + if (error < 0) goto cleanup; /* load core.excludesfile */ - if ((error = git_repository_config(&cfg, repo)) == GIT_SUCCESS) { - const char *core_ignore; - error = git_config_get_string(cfg, GIT_IGNORE_CONFIG, &core_ignore); - if (error == GIT_SUCCESS && core_ignore != NULL) - error = push_ignore(repo, &ignores->ign_global, NULL, core_ignore); - else { - error = GIT_SUCCESS; - git_clearerror(); /* don't care if attributesfile is not set */ - } - git_config_free(cfg); - } + if (git_repository_attr_cache(repo)->cfg_excl_file != NULL) + error = push_ignore_file(repo, &ignores->ign_global, NULL, + git_repository_attr_cache(repo)->cfg_excl_file); cleanup: - if (error < GIT_SUCCESS) { + if (error < 0) git_ignore__free(ignores); - git__rethrow(error, "Could not get ignore files for '%s'", path); - } return error; } int git_ignore__push_dir(git_ignores *ign, const char *dir) { - int error = git_buf_joinpath(&ign->dir, ign->dir.ptr, dir); - - if (error == GIT_SUCCESS) - error = push_ignore( + if (git_buf_joinpath(&ign->dir, ign->dir.ptr, dir) < 0) + return -1; + else + return push_ignore_file( ign->repo, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE); - - return error; } int git_ignore__pop_dir(git_ignores *ign) { if (ign->ign_path.length > 0) { git_attr_file *file = git_vector_last(&ign->ign_path); - if (git__suffixcmp(ign->dir.ptr, file->path) == 0) + if (git__suffixcmp(ign->dir.ptr, file->key + 2) == 0) git_vector_pop(&ign->ign_path); git_buf_rtruncate_at_char(&ign->dir, '/'); } - return GIT_SUCCESS; + return 0; } void git_ignore__free(git_ignores *ignores) @@ -161,54 +151,53 @@ void git_ignore__free(git_ignores *ignores) git_buf_free(&ignores->dir); } -static int ignore_lookup_in_rules( +static bool ignore_lookup_in_rules( git_vector *rules, git_attr_path *path, int *ignored) { unsigned int j; git_attr_fnmatch *match; git_vector_rforeach(rules, j, match) { - if (git_attr_fnmatch__match(match, path) == GIT_SUCCESS) { + if (git_attr_fnmatch__match(match, path)) { *ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0); - return GIT_SUCCESS; + return true; } } - return GIT_ENOTFOUND; + return false; } -int git_ignore__lookup(git_ignores *ignores, const char *pathname, int *ignored) +int git_ignore__lookup( + git_ignores *ignores, const char *pathname, int *ignored) { - int error; unsigned int i; git_attr_file *file; git_attr_path path; - if ((error = git_attr_path__init( - &path, pathname, git_repository_workdir(ignores->repo))) < GIT_SUCCESS) - return git__rethrow(error, "Could not get attribute for '%s'", pathname); + if (git_attr_path__init( + &path, pathname, git_repository_workdir(ignores->repo)) < 0) + return -1; - /* first process builtins */ - error = ignore_lookup_in_rules( - &ignores->ign_internal->rules, &path, ignored); - if (error == GIT_SUCCESS) - return error; + /* first process builtins - success means path was found */ + if (ignore_lookup_in_rules( + &ignores->ign_internal->rules, &path, ignored)) + goto cleanup; /* next process files in the path */ git_vector_foreach(&ignores->ign_path, i, file) { - error = ignore_lookup_in_rules(&file->rules, &path, ignored); - if (error == GIT_SUCCESS) - return error; + if (ignore_lookup_in_rules(&file->rules, &path, ignored)) + goto cleanup; } /* last process global ignores */ git_vector_foreach(&ignores->ign_global, i, file) { - error = ignore_lookup_in_rules(&file->rules, &path, ignored); - if (error == GIT_SUCCESS) - return error; + if (ignore_lookup_in_rules(&file->rules, &path, ignored)) + goto cleanup; } *ignored = 0; - return GIT_SUCCESS; +cleanup: + git_attr_path__free(&path); + return 0; } diff --git a/src/ignore.h b/src/ignore.h index 49f72bf25..809d2edbd 100644 --- a/src/ignore.h +++ b/src/ignore.h @@ -25,13 +25,14 @@ typedef struct { git_vector ign_global; } git_ignores; -extern int git_ignore__for_path( - git_repository *repo, const char *path, git_ignores *ign); +extern int git_ignore__for_path(git_repository *repo, const char *path, git_ignores *ign); extern int git_ignore__push_dir(git_ignores *ign, const char *dir); + extern int git_ignore__pop_dir(git_ignores *ign); extern void git_ignore__free(git_ignores *ign); + extern int git_ignore__lookup(git_ignores *ign, const char *path, int *ignored); #endif diff --git a/src/index.c b/src/index.c index 5ac99de3e..216ede777 100644 --- a/src/index.c +++ b/src/index.c @@ -135,22 +135,17 @@ int git_index_open(git_index **index_out, const char *index_path) assert(index_out && index_path); - index = git__malloc(sizeof(git_index)); - if (index == NULL) - return GIT_ENOMEM; - - memset(index, 0x0, sizeof(git_index)); + index = git__calloc(1, sizeof(git_index)); + GITERR_CHECK_ALLOC(index); index->index_file_path = git__strdup(index_path); - if (index->index_file_path == NULL) { - git__free(index); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(index->index_file_path); - git_vector_init(&index->entries, 32, index_cmp); + if (git_vector_init(&index->entries, 32, index_cmp) < 0) + return -1; /* Check if index file is stored on disk already */ - if (git_path_exists(index->index_file_path) == 0) + if (git_path_exists(index->index_file_path) == true) index->on_disk = 1; *index_out = index; @@ -215,36 +210,35 @@ void git_index_clear(git_index *index) int git_index_read(git_index *index) { - int error = GIT_SUCCESS, updated; + int error, updated; git_buf buffer = GIT_BUF_INIT; time_t mtime; assert(index->index_file_path); - if (!index->on_disk || git_path_exists(index->index_file_path) < 0) { + if (!index->on_disk || git_path_exists(index->index_file_path) == false) { git_index_clear(index); index->on_disk = 0; - return GIT_SUCCESS; + return 0; } /* We don't want to update the mtime if we fail to parse the index */ mtime = index->last_modified; - error = git_futils_readbuffer_updated(&buffer, index->index_file_path, &mtime, &updated); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to read index"); + error = git_futils_readbuffer_updated( + &buffer, index->index_file_path, &mtime, &updated); + if (error < 0) + return error; if (updated) { git_index_clear(index); error = parse_index(index, buffer.ptr, buffer.size); - if (error == GIT_SUCCESS) + if (!error) index->last_modified = mtime; git_buf_free(&buffer); } - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to parse index"); return error; } @@ -256,23 +250,24 @@ int git_index_write(git_index *index) git_vector_sort(&index->entries); - if ((error = git_filebuf_open(&file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to write index"); + if ((error = git_filebuf_open( + &file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS)) < 0) + return error; - if ((error = write_index(index, &file)) < GIT_SUCCESS) { + if ((error = write_index(index, &file)) < 0) { git_filebuf_cleanup(&file); - return git__rethrow(error, "Failed to write index"); + return error; } - if ((error = git_filebuf_commit(&file, GIT_INDEX_FILE_MODE)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to write index"); + if ((error = git_filebuf_commit(&file, GIT_INDEX_FILE_MODE)) < 0) + return error; if (p_stat(index->index_file_path, &indexst) == 0) { index->last_modified = indexst.st_mtime; index->on_disk = 1; } - return GIT_SUCCESS; + return 0; } unsigned int git_index_entrycount(git_index *index) @@ -293,6 +288,20 @@ git_index_entry *git_index_get(git_index *index, unsigned int n) return git_vector_get(&index->entries, n); } +void git_index__init_entry_from_stat(struct stat *st, git_index_entry *entry) +{ + entry->ctime.seconds = (git_time_t)st->st_ctime; + entry->mtime.seconds = (git_time_t)st->st_mtime; + /* entry->mtime.nanoseconds = st->st_mtimensec; */ + /* entry->ctime.nanoseconds = st->st_ctimensec; */ + entry->dev = st->st_rdev; + entry->ino = st->st_ino; + entry->mode = index_create_mode(st->st_mode); + entry->uid = st->st_uid; + entry->gid = st->st_gid; + entry->file_size = st->st_size; +} + static int index_entry_init(git_index_entry **entry_out, git_index *index, const char *rel_path, int stage) { git_index_entry *entry = NULL; @@ -302,25 +311,20 @@ static int index_entry_init(git_index_entry **entry_out, git_index *index, const git_buf full_path = GIT_BUF_INIT; int error; - if (INDEX_OWNER(index) == NULL) - return git__throw(GIT_EBAREINDEX, - "Failed to initialize entry. Repository is bare"); + assert(stage >= 0 && stage <= 3); - if (stage < 0 || stage > 3) - return git__throw(GIT_ERROR, - "Failed to initialize entry. Invalid stage %i", stage); + if (INDEX_OWNER(index) == NULL || + (workdir = git_repository_workdir(INDEX_OWNER(index))) == NULL) + { + giterr_set(GITERR_INDEX, + "Could not initialize index entry. Repository is bare"); + return -1; + } - workdir = git_repository_workdir(INDEX_OWNER(index)); - if (workdir == NULL) - return git__throw(GIT_EBAREINDEX, - "Failed to initialize entry. Cannot resolved workdir"); - - error = git_buf_joinpath(&full_path, workdir, rel_path); - if (error < GIT_SUCCESS) + if ((error = git_buf_joinpath(&full_path, workdir, rel_path)) < 0) return error; - if (p_lstat(full_path.ptr, &st) < 0) { - error = git__throw(GIT_ENOTFOUND, "Failed to initialize entry. '%s' cannot be opened. %s", full_path.ptr, strerror(errno)); + if ((error = git_path_lstat(full_path.ptr, &st)) < 0) { git_buf_free(&full_path); return error; } @@ -332,34 +336,21 @@ static int index_entry_init(git_index_entry **entry_out, git_index *index, const */ /* write the blob to disk and get the oid */ - if ((error = git_blob_create_fromfile(&oid, INDEX_OWNER(index), rel_path)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to initialize index entry"); + if ((error = git_blob_create_fromfile(&oid, INDEX_OWNER(index), rel_path)) < 0) + return error; entry = git__calloc(1, sizeof(git_index_entry)); - if (!entry) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(entry); + + git_index__init_entry_from_stat(&st, entry); - entry->ctime.seconds = (git_time_t)st.st_ctime; - entry->mtime.seconds = (git_time_t)st.st_mtime; - /* entry.mtime.nanoseconds = st.st_mtimensec; */ - /* entry.ctime.nanoseconds = st.st_ctimensec; */ - entry->dev= st.st_rdev; - entry->ino = st.st_ino; - entry->mode = index_create_mode(st.st_mode); - entry->uid = st.st_uid; - entry->gid = st.st_gid; - entry->file_size = st.st_size; entry->oid = oid; - entry->flags |= (stage << GIT_IDXENTRY_STAGESHIFT); entry->path = git__strdup(rel_path); - if (entry->path == NULL) { - git__free(entry); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(entry->path); *entry_out = entry; - return GIT_SUCCESS; + return 0; } static git_index_entry *index_entry_dup(const git_index_entry *source_entry) @@ -394,10 +385,7 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace) int position; git_index_entry **entry_array; - assert(index && entry); - - if (entry->path == NULL) - return git__throw(GIT_EMISSINGOBJDATA, "Failed to insert into index. Entry has no path"); + assert(index && entry && entry->path != NULL); /* make sure that the path length flag is correct */ path_length = strlen(entry->path); @@ -413,12 +401,8 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace) * replacing is not requested: just insert entry at the end; * the index is no longer sorted */ - if (!replace) { - if (git_vector_insert(&index->entries, entry) < GIT_SUCCESS) - return GIT_ENOMEM; - - return GIT_SUCCESS; - } + if (!replace) + return git_vector_insert(&index->entries, entry); /* look if an entry with this path already exists */ position = git_index_find(index, entry->path); @@ -427,12 +411,8 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace) * if no entry exists add the entry at the end; * the index is no longer sorted */ - if (position == GIT_ENOTFOUND) { - if (git_vector_insert(&index->entries, entry) < GIT_SUCCESS) - return GIT_ENOMEM; - - return GIT_SUCCESS; - } + if (position == GIT_ENOTFOUND) + return git_vector_insert(&index->entries, entry); /* exists, replace it */ entry_array = (git_index_entry **) index->entries.contents; @@ -440,7 +420,7 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace) git__free(entry_array[position]); entry_array[position] = entry; - return GIT_SUCCESS; + return 0; } static int index_add(git_index *index, const char *path, int stage, int replace) @@ -448,20 +428,15 @@ static int index_add(git_index *index, const char *path, int stage, int replace) git_index_entry *entry = NULL; int ret; - ret = index_entry_init(&entry, index, path, stage); - if (ret) - goto err; - - ret = index_insert(index, entry, replace); - if (ret) - goto err; + if ((ret = index_entry_init(&entry, index, path, stage)) < 0 || + (ret = index_insert(index, entry, replace)) < 0) + { + index_entry_free(entry); + return ret; + } git_tree_cache_invalidate_path(index->tree, entry->path); - - return ret; -err: - index_entry_free(entry); - return git__rethrow(ret, "Failed to append to index"); + return 0; } int git_index_add(git_index *index, const char *path, int stage) @@ -474,28 +449,23 @@ int git_index_append(git_index *index, const char *path, int stage) return index_add(index, path, stage, 0); } -static int index_add2(git_index *index, const git_index_entry *source_entry, - int replace) +static int index_add2( + git_index *index, const git_index_entry *source_entry, int replace) { git_index_entry *entry = NULL; int ret; entry = index_entry_dup(source_entry); - if (entry == NULL) { - ret = GIT_ENOMEM; - goto err; + if (entry == NULL) + return -1; + + if ((ret = index_insert(index, entry, replace)) < 0) { + index_entry_free(entry); + return ret; } - ret = index_insert(index, entry, replace); - if (ret) - goto err; - git_tree_cache_invalidate_path(index->tree, entry->path); - - return ret; -err: - index_entry_free(entry); - return git__rethrow(ret, "Failed to append to index"); + return 0; } int git_index_add2(git_index *index, const git_index_entry *source_entry) @@ -514,13 +484,14 @@ int git_index_remove(git_index *index, int position) git_index_entry *entry; git_vector_sort(&index->entries); + entry = git_vector_get(&index->entries, position); if (entry != NULL) git_tree_cache_invalidate_path(index->tree, entry->path); error = git_vector_remove(&index->entries, (unsigned int)position); - if (error == GIT_SUCCESS) + if (!error) index_entry_free(entry); return error; @@ -536,7 +507,8 @@ void git_index_uniq(git_index *index) git_vector_uniq(&index->entries); } -const git_index_entry_unmerged *git_index_get_unmerged_bypath(git_index *index, const char *path) +const git_index_entry_unmerged *git_index_get_unmerged_bypath( + git_index *index, const char *path) { int pos; assert(index && path); @@ -544,75 +516,87 @@ const git_index_entry_unmerged *git_index_get_unmerged_bypath(git_index *index, if (!index->unmerged.length) return NULL; - if ((pos = git_vector_bsearch2(&index->unmerged, unmerged_srch, path)) < GIT_SUCCESS) + if ((pos = git_vector_bsearch2(&index->unmerged, unmerged_srch, path)) < 0) return NULL; return git_vector_get(&index->unmerged, pos); } -const git_index_entry_unmerged *git_index_get_unmerged_byindex(git_index *index, unsigned int n) +const git_index_entry_unmerged *git_index_get_unmerged_byindex( + git_index *index, unsigned int n) { assert(index); return git_vector_get(&index->unmerged, n); } +static int index_error_invalid(const char *message) +{ + giterr_set(GITERR_INDEX, "Invalid data in index - %s", message); + return -1; +} + static int read_unmerged(git_index *index, const char *buffer, size_t size) { const char *endptr; size_t len; int i; - git_vector_init(&index->unmerged, 16, unmerged_cmp); + if (git_vector_init(&index->unmerged, 16, unmerged_cmp) < 0) + return -1; while (size) { git_index_entry_unmerged *lost; len = strlen(buffer) + 1; if (size <= len) - return git__throw(GIT_ERROR, "Failed to read unmerged entries"); + return index_error_invalid("reading unmerged entries"); - if ((lost = git__malloc(sizeof(git_index_entry_unmerged))) == NULL) - return GIT_ENOMEM; + lost = git__malloc(sizeof(git_index_entry_unmerged)); + GITERR_CHECK_ALLOC(lost); - if (git_vector_insert(&index->unmerged, lost) < GIT_SUCCESS) - return git__throw(GIT_ERROR, "Failed to read unmerged entries"); + if (git_vector_insert(&index->unmerged, lost) < 0) + return -1; + /* read NUL-terminated pathname for entry */ lost->path = git__strdup(buffer); - if (!lost->path) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(lost->path); size -= len; buffer += len; + /* read 3 ASCII octal numbers for stage entries */ for (i = 0; i < 3; i++) { int tmp; - if (git__strtol32(&tmp, buffer, &endptr, 8) < GIT_SUCCESS || - !endptr || endptr == buffer || *endptr || (unsigned)tmp > UINT_MAX) - return GIT_ERROR; + if (git__strtol32(&tmp, buffer, &endptr, 8) < 0 || + !endptr || endptr == buffer || *endptr || + (unsigned)tmp > UINT_MAX) + return index_error_invalid("reading unmerged entry stage"); lost->mode[i] = tmp; len = (endptr + 1) - buffer; if (size <= len) - return git__throw(GIT_ERROR, "Failed to read unmerged entries"); + return index_error_invalid("reading unmerged entry stage"); size -= len; buffer += len; } + /* read up to 3 OIDs for stage entries */ for (i = 0; i < 3; i++) { if (!lost->mode[i]) continue; if (size < 20) - return git__throw(GIT_ERROR, "Failed to read unmerged entries"); + return index_error_invalid("reading unmerged entry oid"); + git_oid_fromraw(&lost->oid[i], (const unsigned char *) buffer); size -= 20; buffer += 20; } } - return GIT_SUCCESS; + return 0; } static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffer_size) @@ -658,7 +642,7 @@ static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffe path_end = memchr(path_ptr, '\0', buffer_size); if (path_end == NULL) - return 0; + return 0; path_length = path_end - path_ptr; } @@ -683,15 +667,15 @@ static int read_header(struct index_header *dest, const void *buffer) dest->signature = ntohl(source->signature); if (dest->signature != INDEX_HEADER_SIG) - return GIT_EOBJCORRUPTED; + return index_error_invalid("incorrect header signature"); dest->version = ntohl(source->version); if (dest->version != INDEX_VERSION_NUMBER_EXT && dest->version != INDEX_VERSION_NUMBER) - return GIT_EOBJCORRUPTED; + return index_error_invalid("incorrect header version"); dest->entry_count = ntohl(source->entry_count); - return GIT_SUCCESS; + return 0; } static size_t read_extension(git_index *index, const char *buffer, size_t buffer_size) @@ -714,10 +698,10 @@ static size_t read_extension(git_index *index, const char *buffer, size_t buffer if (dest.signature[0] >= 'A' && dest.signature[0] <= 'Z') { /* tree cache */ if (memcmp(dest.signature, INDEX_EXT_TREECACHE_SIG, 4) == 0) { - if (git_tree_cache_read(&index->tree, buffer + 8, dest.extension_size) < GIT_SUCCESS) + if (git_tree_cache_read(&index->tree, buffer + 8, dest.extension_size) < 0) return 0; } else if (memcmp(dest.signature, INDEX_EXT_UNMERGED_SIG, 4) == 0) { - if (read_unmerged(index, buffer + 8, dest.extension_size) < GIT_SUCCESS) + if (read_unmerged(index, buffer + 8, dest.extension_size) < 0) return 0; } /* else, unsupported extension. We cannot parse this, but we can skip @@ -739,21 +723,21 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) #define seek_forward(_increase) { \ if (_increase >= buffer_size) \ - return git__throw(GIT_EOBJCORRUPTED, "Failed to seek forward. Buffer size exceeded"); \ + return index_error_invalid("ran out of data while parsing"); \ buffer += _increase; \ buffer_size -= _increase;\ } if (buffer_size < INDEX_HEADER_SIZE + INDEX_FOOTER_SIZE) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Buffer too small"); + return index_error_invalid("insufficient buffer space"); /* Precalculate the SHA1 of the files's contents -- we'll match it to * the provided SHA1 in the footer */ git_hash_buf(&checksum_calculated, buffer, buffer_size - INDEX_FOOTER_SIZE); /* Parse header */ - if (read_header(&header, buffer) < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Header is corrupted"); + if (read_header(&header, buffer) < 0) + return -1; seek_forward(INDEX_HEADER_SIZE); @@ -765,23 +749,22 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) git_index_entry *entry; entry = git__malloc(sizeof(git_index_entry)); - if (entry == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(entry); entry_size = read_entry(entry, buffer, buffer_size); /* 0 bytes read means an object corruption */ if (entry_size == 0) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Entry size is zero"); + return index_error_invalid("invalid entry"); - if (git_vector_insert(&index->entries, entry) < GIT_SUCCESS) - return GIT_ENOMEM; + if (git_vector_insert(&index->entries, entry) < 0) + return -1; seek_forward(entry_size); } if (i != header.entry_count) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Header entries changed while parsing"); + return index_error_invalid("header entries changed while parsing"); /* There's still space for some extensions! */ while (buffer_size > INDEX_FOOTER_SIZE) { @@ -791,43 +774,43 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) /* see if we have read any bytes from the extension */ if (extension_size == 0) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Extension size is zero"); + return index_error_invalid("extension size is zero"); seek_forward(extension_size); } if (buffer_size != INDEX_FOOTER_SIZE) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Buffer size does not match index footer size"); + return index_error_invalid("buffer size does not match index footer size"); /* 160-bit SHA-1 over the content of the index file before this checksum. */ git_oid_fromraw(&checksum_expected, (const unsigned char *)buffer); if (git_oid_cmp(&checksum_calculated, &checksum_expected) != 0) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Calculated checksum does not match expected checksum"); + return index_error_invalid("calculated checksum does not match expected"); #undef seek_forward /* force sorting in the vector: the entries are * assured to be sorted on the index */ index->entries.sorted = 1; - return GIT_SUCCESS; + return 0; } static int is_index_extended(git_index *index) { unsigned int i, extended; + git_index_entry *entry; extended = 0; - for (i = 0; i < index->entries.length; ++i) { - git_index_entry *entry; - entry = git_vector_get(&index->entries, i); + git_vector_foreach(&index->entries, i, entry) { entry->flags &= ~GIT_IDXENTRY_EXTENDED; if (entry->flags_extended & GIT_IDXENTRY_EXTENDED_FLAGS) { extended++; entry->flags |= GIT_IDXENTRY_EXTENDED; } } + return extended; } @@ -845,8 +828,8 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry) else disk_size = short_entry_size(path_len); - if (git_filebuf_reserve(file, &mem, disk_size) < GIT_SUCCESS) - return GIT_ENOMEM; + if (git_filebuf_reserve(file, &mem, disk_size) < 0) + return -1; ondisk = (struct entry_short *)mem; @@ -888,7 +871,7 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry) memcpy(path, entry->path, path_len); - return GIT_SUCCESS; + return 0; } static int write_entries(git_index *index, git_filebuf *file) @@ -898,16 +881,15 @@ static int write_entries(git_index *index, git_filebuf *file) for (i = 0; i < index->entries.length; ++i) { git_index_entry *entry; entry = git_vector_get(&index->entries, i); - if (write_disk_entry(file, entry) < GIT_SUCCESS) - return GIT_ENOMEM; + if (write_disk_entry(file, entry) < 0) + return -1; } - return GIT_SUCCESS; + return 0; } static int write_index(git_index *index, git_filebuf *file) { - int error = GIT_SUCCESS; git_oid hash_final; struct index_header header; @@ -922,11 +904,11 @@ static int write_index(git_index *index, git_filebuf *file) header.version = htonl(is_extended ? INDEX_VERSION_NUMBER_EXT : INDEX_VERSION_NUMBER); header.entry_count = htonl(index->entries.length); - git_filebuf_write(file, &header, sizeof(struct index_header)); + if (git_filebuf_write(file, &header, sizeof(struct index_header)) < 0) + return -1; - error = write_entries(index, file); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to write index"); + if (write_entries(index, file) < 0) + return -1; /* TODO: write extensions (tree cache) */ @@ -934,9 +916,7 @@ static int write_index(git_index *index, git_filebuf *file) git_filebuf_hash(&hash_final, file); /* write it at the end of the file */ - git_filebuf_write(file, hash_final.id, GIT_OID_RAWSZ); - - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write index"); + return git_filebuf_write(file, hash_final.id, GIT_OID_RAWSZ); } int git_index_entry_stage(const git_index_entry *entry) @@ -946,36 +926,30 @@ int git_index_entry_stage(const git_index_entry *entry) static int read_tree_cb(const char *root, git_tree_entry *tentry, void *data) { - int ret = GIT_SUCCESS; git_index *index = data; git_index_entry *entry = NULL; git_buf path = GIT_BUF_INIT; if (entry_is_tree(tentry)) - goto exit; + return 0; - ret = git_buf_joinpath(&path, root, tentry->filename); - if (ret < GIT_SUCCESS) - goto exit; + if (git_buf_joinpath(&path, root, tentry->filename) < 0) + return -1; entry = git__calloc(1, sizeof(git_index_entry)); - if (!entry) { - ret = GIT_ENOMEM; - goto exit; - } + GITERR_CHECK_ALLOC(entry); entry->mode = tentry->attr; entry->oid = tentry->oid; entry->path = git_buf_detach(&path); - - ret = index_insert(index, entry, 0); - -exit: git_buf_free(&path); - if (ret < GIT_SUCCESS) + if (index_insert(index, entry, 0) < 0) { index_entry_free(entry); - return ret; + return -1; + } + + return 0; } int git_index_read_tree(git_index *index, git_tree *tree) diff --git a/src/index.h b/src/index.h index 4f036526f..e745c8f69 100644 --- a/src/index.h +++ b/src/index.h @@ -31,4 +31,6 @@ struct git_index { git_vector unmerged; }; +extern void git_index__init_entry_from_stat(struct stat *st, git_index_entry *entry); + #endif diff --git a/src/indexer.c b/src/indexer.c index de1e5dc52..d2e492c39 100644 --- a/src/indexer.c +++ b/src/indexer.c @@ -30,8 +30,6 @@ struct entry { struct git_indexer { struct git_pack_file *pack; - struct stat st; - struct git_pack_header hdr; size_t nr_objects; git_vector objects; git_filebuf file; @@ -39,27 +37,89 @@ struct git_indexer { git_oid hash; }; +struct git_indexer_stream { + unsigned int parsed_header :1, + opened_pack; + struct git_pack_file *pack; + git_filebuf pack_file; + git_filebuf index_file; + git_off_t off; + size_t nr_objects; + git_vector objects; + git_vector deltas; + unsigned int fanout[256]; + git_oid hash; +}; + +struct delta_info { + git_off_t delta_off; +}; + const git_oid *git_indexer_hash(git_indexer *idx) { return &idx->hash; } -static int parse_header(git_indexer *idx) +const git_oid *git_indexer_stream_hash(git_indexer_stream *idx) +{ + return &idx->hash; +} + +static int open_pack(struct git_pack_file **out, const char *filename) +{ + size_t namelen; + struct git_pack_file *pack; + struct stat st; + int fd; + + namelen = strlen(filename); + pack = git__calloc(1, sizeof(struct git_pack_file) + namelen + 1); + GITERR_CHECK_ALLOC(pack); + + memcpy(pack->pack_name, filename, namelen + 1); + + if (p_stat(filename, &st) < 0) { + giterr_set(GITERR_OS, "Failed to stat packfile."); + goto cleanup; + } + + if ((fd = p_open(pack->pack_name, O_RDONLY)) < 0) { + giterr_set(GITERR_OS, "Failed to open packfile."); + goto cleanup; + } + + pack->mwf.fd = fd; + pack->mwf.size = (git_off_t)st.st_size; + + *out = pack; + return 0; + +cleanup: + git__free(pack); + return -1; +} + +static int parse_header(struct git_pack_header *hdr, struct git_pack_file *pack) { int error; /* Verify we recognize this pack file format. */ - if ((error = p_read(idx->pack->mwf.fd, &idx->hdr, sizeof(idx->hdr))) < GIT_SUCCESS) - return git__rethrow(error, "Failed to read in pack header"); + if ((error = p_read(pack->mwf.fd, hdr, sizeof(*hdr))) < 0) { + giterr_set(GITERR_OS, "Failed to read in pack header"); + return error; + } - if (idx->hdr.hdr_signature != ntohl(PACK_SIGNATURE)) - return git__throw(GIT_EOBJCORRUPTED, "Wrong pack signature"); + if (hdr->hdr_signature != ntohl(PACK_SIGNATURE)) { + giterr_set(GITERR_INVALID, "Wrong pack signature"); + return -1; + } - if (!pack_version_ok(idx->hdr.hdr_version)) - return git__throw(GIT_EOBJCORRUPTED, "Wrong pack version"); + if (!pack_version_ok(hdr->hdr_version)) { + giterr_set(GITERR_INVALID, "Wrong pack version"); + return -1; + } - - return GIT_SUCCESS; + return 0; } static int objects_cmp(const void *a, const void *b) @@ -78,78 +138,484 @@ static int cache_cmp(const void *a, const void *b) return git_oid_cmp(&ea->sha1, &eb->sha1); } +int git_indexer_stream_new(git_indexer_stream **out, const char *prefix) +{ + git_indexer_stream *idx; + git_buf path = GIT_BUF_INIT; + static const char suff[] = "/objects/pack/pack-received"; + int error; + + idx = git__calloc(1, sizeof(git_indexer_stream)); + GITERR_CHECK_ALLOC(idx); + + error = git_buf_joinpath(&path, prefix, suff); + if (error < 0) + goto cleanup; + + error = git_filebuf_open(&idx->pack_file, path.ptr, + GIT_FILEBUF_TEMPORARY | GIT_FILEBUF_DO_NOT_BUFFER); + git_buf_free(&path); + if (error < 0) + goto cleanup; + + *out = idx; + return 0; + +cleanup: + git_buf_free(&path); + git_filebuf_cleanup(&idx->pack_file); + git__free(idx); + return -1; +} + +/* Try to store the delta so we can try to resolve it later */ +static int store_delta(git_indexer_stream *idx) +{ + git_otype type; + git_mwindow *w = NULL; + git_mwindow_file *mwf = &idx->pack->mwf; + git_off_t entry_start = idx->off; + struct delta_info *delta; + size_t entry_size; + git_rawobj obj; + int error; + + /* + * ref-delta objects can refer to object that we haven't + * found yet, so give it another opportunity + */ + if (git_packfile_unpack_header(&entry_size, &type, mwf, &w, &idx->off) < 0) + return -1; + + git_mwindow_close(&w); + + /* If it's not a delta, mark it as failure, we can't do anything with it */ + if (type != GIT_OBJ_REF_DELTA && type != GIT_OBJ_OFS_DELTA) + return -1; + + if (type == GIT_OBJ_REF_DELTA) { + idx->off += GIT_OID_RAWSZ; + } else { + git_off_t base_off; + + base_off = get_delta_base(idx->pack, &w, &idx->off, type, entry_start); + git_mwindow_close(&w); + if (base_off < 0) + return (int)base_off; + } + + error = packfile_unpack_compressed(&obj, idx->pack, &w, &idx->off, entry_size, type); + if (error == GIT_ESHORTBUFFER) { + idx->off = entry_start; + return GIT_ESHORTBUFFER; + } else if (error < 0){ + return -1; + } + + delta = git__calloc(1, sizeof(struct delta_info)); + GITERR_CHECK_ALLOC(delta); + delta->delta_off = entry_start; + + git__free(obj.data); + + if (git_vector_insert(&idx->deltas, delta) < 0) + return -1; + + return 0; +} + +static int hash_and_save(git_indexer_stream *idx, git_rawobj *obj, git_off_t entry_start) +{ + int i; + git_oid oid; + void *packed; + size_t entry_size; + unsigned int left; + struct entry *entry; + git_mwindow *w = NULL; + git_mwindow_file *mwf = &idx->pack->mwf; + struct git_pack_entry *pentry; + + entry = git__calloc(1, sizeof(*entry)); + GITERR_CHECK_ALLOC(entry); + + if (entry_start > UINT31_MAX) { + entry->offset = UINT32_MAX; + entry->offset_long = entry_start; + } else { + entry->offset = (uint32_t)entry_start; + } + + /* FIXME: Parse the object instead of hashing it */ + if (git_odb__hashobj(&oid, obj) < 0) { + giterr_set(GITERR_INVALID, "Failed to hash object"); + return -1; + } + + pentry = git__malloc(sizeof(struct git_pack_entry)); + GITERR_CHECK_ALLOC(pentry); + + git_oid_cpy(&pentry->sha1, &oid); + pentry->offset = entry_start; + if (git_vector_insert(&idx->pack->cache, pentry) < 0) + goto on_error; + + git_oid_cpy(&entry->oid, &oid); + entry->crc = crc32(0L, Z_NULL, 0); + + entry_size = (size_t)(idx->off - entry_start); + packed = git_mwindow_open(mwf, &w, entry_start, entry_size, &left); + if (packed == NULL) + goto on_error; + + entry->crc = htonl(crc32(entry->crc, packed, (uInt)entry_size)); + git_mwindow_close(&w); + + /* Add the object to the list */ + if (git_vector_insert(&idx->objects, entry) < 0) + goto on_error; + + for (i = oid.id[0]; i < 256; ++i) { + idx->fanout[i]++; + } + + return 0; + +on_error: + git__free(entry); + git__free(pentry); + git__free(obj->data); + return -1; +} + +int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t size, git_indexer_stats *stats) +{ + int error; + struct git_pack_header hdr; + size_t processed = stats->processed; + git_mwindow_file *mwf = &idx->pack->mwf; + + assert(idx && data && stats); + + if (git_filebuf_write(&idx->pack_file, data, size) < 0) + return -1; + + /* Make sure we set the new size of the pack */ + if (idx->opened_pack) { + idx->pack->mwf.size += size; + //printf("\nadding %zu for %zu\n", size, idx->pack->mwf.size); + } else { + if (open_pack(&idx->pack, idx->pack_file.path_lock) < 0) + return -1; + idx->opened_pack = 1; + mwf = &idx->pack->mwf; + if (git_mwindow_file_register(&idx->pack->mwf) < 0) + return -1; + + return 0; + } + + if (!idx->parsed_header) { + if ((unsigned)idx->pack->mwf.size < sizeof(hdr)) + return 0; + + if (parse_header(&hdr, idx->pack) < 0) + return -1; + + idx->parsed_header = 1; + idx->nr_objects = ntohl(hdr.hdr_entries); + idx->off = sizeof(struct git_pack_header); + + /* for now, limit to 2^32 objects */ + assert(idx->nr_objects == (size_t)((unsigned int)idx->nr_objects)); + + if (git_vector_init(&idx->pack->cache, (unsigned int)idx->nr_objects, cache_cmp) < 0) + return -1; + + idx->pack->has_cache = 1; + if (git_vector_init(&idx->objects, (unsigned int)idx->nr_objects, objects_cmp) < 0) + return -1; + + if (git_vector_init(&idx->deltas, (unsigned int)(idx->nr_objects / 2), NULL) < 0) + return -1; + + stats->total = (unsigned int)idx->nr_objects; + stats->processed = 0; + } + + /* Now that we have data in the pack, let's try to parse it */ + + /* As the file grows any windows we try to use will be out of date */ + git_mwindow_free_all(mwf); + while (processed < idx->nr_objects) { + git_rawobj obj; + git_off_t entry_start = idx->off; + + if (idx->pack->mwf.size <= idx->off + 20) + return 0; + + error = git_packfile_unpack(&obj, idx->pack, &idx->off); + if (error == GIT_ESHORTBUFFER) { + idx->off = entry_start; + return 0; + } + + if (error < 0) { + idx->off = entry_start; + error = store_delta(idx); + if (error == GIT_ESHORTBUFFER) + return 0; + if (error < 0) + return error; + + continue; + } + + if (hash_and_save(idx, &obj, entry_start) < 0) + goto on_error; + + git__free(obj.data); + + stats->processed = (unsigned int)++processed; + } + + return 0; + +on_error: + git_mwindow_free_all(mwf); + return -1; +} + +static int index_path_stream(git_buf *path, git_indexer_stream *idx, const char *suffix) +{ + const char prefix[] = "pack-"; + size_t slash = (size_t)path->size; + + /* search backwards for '/' */ + while (slash > 0 && path->ptr[slash - 1] != '/') + slash--; + + if (git_buf_grow(path, slash + 1 + strlen(prefix) + + GIT_OID_HEXSZ + strlen(suffix) + 1) < 0) + return -1; + + git_buf_truncate(path, slash); + git_buf_puts(path, prefix); + git_oid_fmt(path->ptr + git_buf_len(path), &idx->hash); + path->size += GIT_OID_HEXSZ; + git_buf_puts(path, suffix); + + return git_buf_oom(path) ? -1 : 0; +} + +static int resolve_deltas(git_indexer_stream *idx, git_indexer_stats *stats) +{ + unsigned int i; + struct delta_info *delta; + + git_vector_foreach(&idx->deltas, i, delta) { + git_rawobj obj; + + idx->off = delta->delta_off; + if (git_packfile_unpack(&obj, idx->pack, &idx->off) < 0) + return -1; + + if (hash_and_save(idx, &obj, delta->delta_off) < 0) + return -1; + + git__free(obj.data); + stats->processed++; + } + + return 0; +} + +int git_indexer_stream_finalize(git_indexer_stream *idx, git_indexer_stats *stats) +{ + git_mwindow *w = NULL; + unsigned int i, long_offsets = 0, left; + struct git_pack_idx_header hdr; + git_buf filename = GIT_BUF_INIT; + struct entry *entry; + void *packfile_hash; + git_oid file_hash; + SHA_CTX ctx; + + if (idx->deltas.length > 0) + if (resolve_deltas(idx, stats) < 0) + return -1; + + git_vector_sort(&idx->objects); + + git_buf_sets(&filename, idx->pack->pack_name); + git_buf_truncate(&filename, filename.size - strlen("pack")); + git_buf_puts(&filename, "idx"); + if (git_buf_oom(&filename)) + return -1; + + if (git_filebuf_open(&idx->index_file, filename.ptr, GIT_FILEBUF_HASH_CONTENTS) < 0) + goto on_error; + + /* Write out the header */ + hdr.idx_signature = htonl(PACK_IDX_SIGNATURE); + hdr.idx_version = htonl(2); + git_filebuf_write(&idx->index_file, &hdr, sizeof(hdr)); + + /* Write out the fanout table */ + for (i = 0; i < 256; ++i) { + uint32_t n = htonl(idx->fanout[i]); + git_filebuf_write(&idx->index_file, &n, sizeof(n)); + } + + /* Write out the object names (SHA-1 hashes) */ + SHA1_Init(&ctx); + git_vector_foreach(&idx->objects, i, entry) { + git_filebuf_write(&idx->index_file, &entry->oid, sizeof(git_oid)); + SHA1_Update(&ctx, &entry->oid, GIT_OID_RAWSZ); + } + SHA1_Final(idx->hash.id, &ctx); + + /* Write out the CRC32 values */ + git_vector_foreach(&idx->objects, i, entry) { + git_filebuf_write(&idx->index_file, &entry->crc, sizeof(uint32_t)); + } + + /* Write out the offsets */ + git_vector_foreach(&idx->objects, i, entry) { + uint32_t n; + + if (entry->offset == UINT32_MAX) + n = htonl(0x80000000 | long_offsets++); + else + n = htonl(entry->offset); + + git_filebuf_write(&idx->index_file, &n, sizeof(uint32_t)); + } + + /* Write out the long offsets */ + git_vector_foreach(&idx->objects, i, entry) { + uint32_t split[2]; + + if (entry->offset != UINT32_MAX) + continue; + + split[0] = htonl(entry->offset_long >> 32); + split[1] = htonl(entry->offset_long & 0xffffffff); + + git_filebuf_write(&idx->index_file, &split, sizeof(uint32_t) * 2); + } + + /* Write out the packfile trailer */ + packfile_hash = git_mwindow_open(&idx->pack->mwf, &w, idx->pack->mwf.size - GIT_OID_RAWSZ, GIT_OID_RAWSZ, &left); + if (packfile_hash == NULL) { + git_mwindow_close(&w); + goto on_error; + } + + memcpy(&file_hash, packfile_hash, GIT_OID_RAWSZ); + git_mwindow_close(&w); + + git_filebuf_write(&idx->index_file, &file_hash, sizeof(git_oid)); + + /* Write out the packfile trailer to the idx file as well */ + if (git_filebuf_hash(&file_hash, &idx->index_file) < 0) + goto on_error; + + git_filebuf_write(&idx->index_file, &file_hash, sizeof(git_oid)); + + /* Figure out what the final name should be */ + if (index_path_stream(&filename, idx, ".idx") < 0) + goto on_error; + + /* Commit file */ + if (git_filebuf_commit_at(&idx->index_file, filename.ptr, GIT_PACK_FILE_MODE) < 0) + goto on_error; + + git_mwindow_free_all(&idx->pack->mwf); + + if (index_path_stream(&filename, idx, ".pack") < 0) + goto on_error; + /* And don't forget to rename the packfile to its new place. */ + if (git_filebuf_commit_at(&idx->pack_file, filename.ptr, GIT_PACK_FILE_MODE) < 0) + return -1; + + git_buf_free(&filename); + return 0; + +on_error: + git_mwindow_free_all(&idx->pack->mwf); + git_filebuf_cleanup(&idx->index_file); + git_buf_free(&filename); + return -1; +} + +void git_indexer_stream_free(git_indexer_stream *idx) +{ + unsigned int i; + struct entry *e; + struct git_pack_entry *pe; + struct delta_info *delta; + + if (idx == NULL) + return; + + p_close(idx->pack->mwf.fd); + git_vector_foreach(&idx->objects, i, e) + git__free(e); + git_vector_free(&idx->objects); + git_vector_foreach(&idx->pack->cache, i, pe) + git__free(pe); + git_vector_free(&idx->pack->cache); + git_vector_foreach(&idx->deltas, i, delta) + git__free(delta); + git_vector_free(&idx->deltas); + git__free(idx->pack); + git__free(idx); +} int git_indexer_new(git_indexer **out, const char *packname) { git_indexer *idx; - size_t namelen; - int ret, error; + struct git_pack_header hdr; + int error; assert(out && packname); - if (git_path_root(packname) < 0) - return git__throw(GIT_EINVALIDPATH, "Path is not absolute"); - - idx = git__malloc(sizeof(git_indexer)); - if (idx == NULL) - return GIT_ENOMEM; - - memset(idx, 0x0, sizeof(*idx)); - - namelen = strlen(packname); - idx->pack = git__malloc(sizeof(struct git_pack_file) + namelen + 1); - if (idx->pack == NULL) { - error = GIT_ENOMEM; - goto cleanup; + if (git_path_root(packname) < 0) { + giterr_set(GITERR_INVALID, "Path is not absolute"); + return -1; } - memset(idx->pack, 0x0, sizeof(struct git_pack_file)); - memcpy(idx->pack->pack_name, packname, namelen + 1); + idx = git__calloc(1, sizeof(git_indexer)); + GITERR_CHECK_ALLOC(idx); - ret = p_stat(packname, &idx->st); - if (ret < 0) { - if (errno == ENOENT) - error = git__throw(GIT_ENOTFOUND, "Failed to stat packfile. File not found"); - else - error = git__throw(GIT_EOSERR, "Failed to stat packfile."); + open_pack(&idx->pack, packname); + if ((error = parse_header(&hdr, idx->pack)) < 0) goto cleanup; - } - ret = p_open(idx->pack->pack_name, O_RDONLY); - if (ret < 0) { - error = git__throw(GIT_EOSERR, "Failed to open packfile"); - goto cleanup; - } + idx->nr_objects = ntohl(hdr.hdr_entries); - idx->pack->mwf.fd = ret; - idx->pack->mwf.size = (git_off_t)idx->st.st_size; + /* for now, limit to 2^32 objects */ + assert(idx->nr_objects == (size_t)((unsigned int)idx->nr_objects)); - error = parse_header(idx); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to parse packfile header"); - goto cleanup; - } - - idx->nr_objects = ntohl(idx->hdr.hdr_entries); - - error = git_vector_init(&idx->pack->cache, idx->nr_objects, cache_cmp); - if (error < GIT_SUCCESS) + error = git_vector_init(&idx->pack->cache, (unsigned int)idx->nr_objects, cache_cmp); + if (error < 0) goto cleanup; idx->pack->has_cache = 1; - error = git_vector_init(&idx->objects, idx->nr_objects, objects_cmp); - if (error < GIT_SUCCESS) + error = git_vector_init(&idx->objects, (unsigned int)idx->nr_objects, objects_cmp); + if (error < 0) goto cleanup; *out = idx; - return GIT_SUCCESS; + return 0; cleanup: git_indexer_free(idx); - return error; + return -1; } static int index_path(git_buf *path, git_indexer *idx) @@ -162,16 +628,16 @@ static int index_path(git_buf *path, git_indexer *idx) slash--; if (git_buf_grow(path, slash + 1 + strlen(prefix) + - GIT_OID_HEXSZ + strlen(suffix) + 1) < GIT_SUCCESS) - return GIT_ENOMEM; + GIT_OID_HEXSZ + strlen(suffix) + 1) < 0) + return -1; git_buf_truncate(path, slash); git_buf_puts(path, prefix); - git_oid_fmt(path->ptr + path->size, &idx->hash); + git_oid_fmt(path->ptr + git_buf_len(path), &idx->hash); path->size += GIT_OID_HEXSZ; git_buf_puts(path, suffix); - return git_buf_lasterror(path); + return git_buf_oom(path) ? -1 : 0; } int git_indexer_write(git_indexer *idx) @@ -191,26 +657,25 @@ int git_indexer_write(git_indexer *idx) git_buf_sets(&filename, idx->pack->pack_name); git_buf_truncate(&filename, filename.size - strlen("pack")); git_buf_puts(&filename, "idx"); - - if ((error = git_buf_lasterror(&filename)) < GIT_SUCCESS) - goto cleanup; + if (git_buf_oom(&filename)) + return -1; error = git_filebuf_open(&idx->file, filename.ptr, GIT_FILEBUF_HASH_CONTENTS); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; /* Write out the header */ hdr.idx_signature = htonl(PACK_IDX_SIGNATURE); hdr.idx_version = htonl(2); error = git_filebuf_write(&idx->file, &hdr, sizeof(hdr)); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; /* Write out the fanout table */ for (i = 0; i < 256; ++i) { uint32_t n = htonl(idx->fanout[i]); error = git_filebuf_write(&idx->file, &n, sizeof(n)); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; } @@ -219,7 +684,7 @@ int git_indexer_write(git_indexer *idx) git_vector_foreach(&idx->objects, i, entry) { error = git_filebuf_write(&idx->file, &entry->oid, sizeof(git_oid)); SHA1_Update(&ctx, &entry->oid, GIT_OID_RAWSZ); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; } SHA1_Final(idx->hash.id, &ctx); @@ -227,7 +692,7 @@ int git_indexer_write(git_indexer *idx) /* Write out the CRC32 values */ git_vector_foreach(&idx->objects, i, entry) { error = git_filebuf_write(&idx->file, &entry->crc, sizeof(uint32_t)); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; } @@ -241,7 +706,7 @@ int git_indexer_write(git_indexer *idx) n = htonl(entry->offset); error = git_filebuf_write(&idx->file, &n, sizeof(uint32_t)); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; } @@ -256,16 +721,16 @@ int git_indexer_write(git_indexer *idx) split[1] = htonl(entry->offset_long & 0xffffffff); error = git_filebuf_write(&idx->file, &split, sizeof(uint32_t) * 2); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; } /* Write out the packfile trailer */ - packfile_hash = git_mwindow_open(&idx->pack->mwf, &w, idx->st.st_size - GIT_OID_RAWSZ, GIT_OID_RAWSZ, &left); + packfile_hash = git_mwindow_open(&idx->pack->mwf, &w, idx->pack->mwf.size - GIT_OID_RAWSZ, GIT_OID_RAWSZ, &left); git_mwindow_close(&w); if (packfile_hash == NULL) { - error = git__rethrow(GIT_ENOMEM, "Failed to open window to packfile hash"); + error = -1; goto cleanup; } @@ -274,19 +739,21 @@ int git_indexer_write(git_indexer *idx) git_mwindow_close(&w); error = git_filebuf_write(&idx->file, &file_hash, sizeof(git_oid)); + if (error < 0) + goto cleanup; /* Write out the index sha */ error = git_filebuf_hash(&file_hash, &idx->file); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; error = git_filebuf_write(&idx->file, &file_hash, sizeof(git_oid)); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; /* Figure out what the final name should be */ error = index_path(&filename, idx); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; /* Commit file */ @@ -294,7 +761,7 @@ int git_indexer_write(git_indexer *idx) cleanup: git_mwindow_free_all(&idx->pack->mwf); - if (error < GIT_SUCCESS) + if (error < 0) git_filebuf_cleanup(&idx->file); git_buf_free(&filename); @@ -304,7 +771,7 @@ cleanup: int git_indexer_run(git_indexer *idx, git_indexer_stats *stats) { git_mwindow_file *mwf; - off_t off = sizeof(struct git_pack_header); + git_off_t off = sizeof(struct git_pack_header); int error; struct entry *entry; unsigned int left, processed; @@ -313,10 +780,10 @@ int git_indexer_run(git_indexer *idx, git_indexer_stats *stats) mwf = &idx->pack->mwf; error = git_mwindow_file_register(mwf); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to register mwindow file"); + if (error < 0) + return error; - stats->total = idx->nr_objects; + stats->total = (unsigned int)idx->nr_objects; stats->processed = processed = 0; while (processed < idx->nr_objects) { @@ -325,62 +792,62 @@ int git_indexer_run(git_indexer *idx, git_indexer_stats *stats) struct git_pack_entry *pentry; git_mwindow *w = NULL; int i; - off_t entry_start = off; + git_off_t entry_start = off; void *packed; size_t entry_size; + char fmt[GIT_OID_HEXSZ] = {0}; - entry = git__malloc(sizeof(struct entry)); - memset(entry, 0x0, sizeof(struct entry)); + entry = git__calloc(1, sizeof(*entry)); + GITERR_CHECK_ALLOC(entry); if (off > UINT31_MAX) { entry->offset = UINT32_MAX; entry->offset_long = off; } else { - entry->offset = off; + entry->offset = (uint32_t)off; } error = git_packfile_unpack(&obj, idx->pack, &off); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to unpack object"); + if (error < 0) goto cleanup; - } /* FIXME: Parse the object instead of hashing it */ error = git_odb__hashobj(&oid, &obj); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to hash object"); + if (error < 0) { + giterr_set(GITERR_INVALID, "Failed to hash object"); goto cleanup; } pentry = git__malloc(sizeof(struct git_pack_entry)); if (pentry == NULL) { - error = GIT_ENOMEM; + error = -1; goto cleanup; } + git_oid_cpy(&pentry->sha1, &oid); pentry->offset = entry_start; + git_oid_fmt(fmt, &oid); + printf("adding %s to cache\n", fmt); error = git_vector_insert(&idx->pack->cache, pentry); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; git_oid_cpy(&entry->oid, &oid); entry->crc = crc32(0L, Z_NULL, 0); - entry_size = off - entry_start; + entry_size = (size_t)(off - entry_start); packed = git_mwindow_open(mwf, &w, entry_start, entry_size, &left); if (packed == NULL) { - error = git__rethrow(error, "Failed to open window to read packed data"); + error = -1; goto cleanup; } - entry->crc = htonl(crc32(entry->crc, packed, entry_size)); + entry->crc = htonl(crc32(entry->crc, packed, (uInt)entry_size)); git_mwindow_close(&w); /* Add the object to the list */ error = git_vector_insert(&idx->objects, entry); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to add entry to list"); + if (error < 0) goto cleanup; - } for (i = oid.id[0]; i < 256; ++i) { idx->fanout[i]++; diff --git a/src/iterator.c b/src/iterator.c index c026c3c09..3a3be1755 100644 --- a/src/iterator.c +++ b/src/iterator.c @@ -9,6 +9,7 @@ #include "tree.h" #include "ignore.h" #include "buffer.h" +#include "git2/submodule.h" typedef struct tree_iterator_frame tree_iterator_frame; struct tree_iterator_frame { @@ -34,25 +35,24 @@ static const git_tree_entry *tree_iterator__tree_entry(tree_iterator *ti) static int tree_iterator__current( git_iterator *self, const git_index_entry **entry) { - int error; tree_iterator *ti = (tree_iterator *)self; const git_tree_entry *te = tree_iterator__tree_entry(ti); *entry = NULL; if (te == NULL) - return GIT_SUCCESS; + return 0; ti->entry.mode = te->attr; git_oid_cpy(&ti->entry.oid, &te->oid); - error = git_buf_joinpath(&ti->path, ti->path.ptr, te->filename); - if (error < GIT_SUCCESS) - return error; + if (git_buf_joinpath(&ti->path, ti->path.ptr, te->filename) < 0) + return -1; + ti->entry.path = ti->path.ptr; *entry = &ti->entry; - return GIT_SUCCESS; + return 0; } static int tree_iterator__at_end(git_iterator *self) @@ -63,7 +63,8 @@ static int tree_iterator__at_end(git_iterator *self) static tree_iterator_frame *tree_iterator__alloc_frame(git_tree *tree) { tree_iterator_frame *tf = git__calloc(1, sizeof(tree_iterator_frame)); - tf->tree = tree; + if (tf != NULL) + tf->tree = tree; return tf; } @@ -75,24 +76,22 @@ static int tree_iterator__expand_tree(tree_iterator *ti) tree_iterator_frame *tf; while (te != NULL && entry_is_tree(te)) { - error = git_tree_lookup(&subtree, ti->repo, &te->oid); - if (error != GIT_SUCCESS) + if ((error = git_tree_lookup(&subtree, ti->repo, &te->oid)) < 0) return error; if ((tf = tree_iterator__alloc_frame(subtree)) == NULL) - return GIT_ENOMEM; + return -1; tf->next = ti->stack; ti->stack = tf; - error = git_buf_joinpath(&ti->path, ti->path.ptr, te->filename); - if (error < GIT_SUCCESS) - return error; + if (git_buf_joinpath(&ti->path, ti->path.ptr, te->filename) < 0) + return -1; te = tree_iterator__tree_entry(ti); } - return GIT_SUCCESS; + return 0; } static void tree_iterator__pop_frame(tree_iterator *ti) @@ -107,7 +106,7 @@ static void tree_iterator__pop_frame(tree_iterator *ti) static int tree_iterator__advance( git_iterator *self, const git_index_entry **entry) { - int error = GIT_SUCCESS; + int error = 0; tree_iterator *ti = (tree_iterator *)self; const git_tree_entry *te = NULL; @@ -123,13 +122,12 @@ static int tree_iterator__advance( break; tree_iterator__pop_frame(ti); - git_buf_rtruncate_at_char(&ti->path, '/'); } if (te && entry_is_tree(te)) error = tree_iterator__expand_tree(ti); - if (error == GIT_SUCCESS && entry != NULL) + if (!error && entry != NULL) error = tree_iterator__current(self, entry); return error; @@ -158,8 +156,7 @@ int git_iterator_for_tree( { int error; tree_iterator *ti = git__calloc(1, sizeof(tree_iterator)); - if (!ti) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(ti); ti->base.type = GIT_ITERATOR_TREE; ti->base.current = tree_iterator__current; @@ -170,11 +167,10 @@ int git_iterator_for_tree( ti->repo = repo; ti->stack = tree_iterator__alloc_frame(tree); - if ((error = tree_iterator__expand_tree(ti)) < GIT_SUCCESS) + if ((error = tree_iterator__expand_tree(ti)) < 0) git_iterator_free((git_iterator *)ti); else *iter = (git_iterator *)ti; - return error; } @@ -190,7 +186,7 @@ static int index_iterator__current( { index_iterator *ii = (index_iterator *)self; *entry = git_index_get(ii->index, ii->current); - return GIT_SUCCESS; + return 0; } static int index_iterator__at_end(git_iterator *self) @@ -207,14 +203,14 @@ static int index_iterator__advance( ii->current++; if (entry) *entry = git_index_get(ii->index, ii->current); - return GIT_SUCCESS; + return 0; } static int index_iterator__reset(git_iterator *self) { index_iterator *ii = (index_iterator *)self; ii->current = 0; - return GIT_SUCCESS; + return 0; } static void index_iterator__free(git_iterator *self) @@ -228,8 +224,7 @@ int git_iterator_for_index(git_repository *repo, git_iterator **iter) { int error; index_iterator *ii = git__calloc(1, sizeof(index_iterator)); - if (!ii) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(ii); ii->base.type = GIT_ITERATOR_INDEX; ii->base.current = index_iterator__current; @@ -239,7 +234,7 @@ int git_iterator_for_index(git_repository *repo, git_iterator **iter) ii->base.free = index_iterator__free; ii->current = 0; - if ((error = git_repository_index(&ii->index, repo)) < GIT_SUCCESS) + if ((error = git_repository_index(&ii->index, repo)) < 0) git__free(ii); else *iter = (git_iterator *)ii; @@ -269,8 +264,8 @@ static workdir_iterator_frame *workdir_iterator__alloc_frame(void) { workdir_iterator_frame *wf = git__calloc(1, sizeof(workdir_iterator_frame)); if (wf == NULL) - return wf; - if (git_vector_init(&wf->entries, 0, git_path_with_stat_cmp) != GIT_SUCCESS) { + return NULL; + if (git_vector_init(&wf->entries, 0, git_path_with_stat_cmp) != 0) { git__free(wf); return NULL; } @@ -294,11 +289,10 @@ static int workdir_iterator__expand_dir(workdir_iterator *wi) { int error; workdir_iterator_frame *wf = workdir_iterator__alloc_frame(); - if (wf == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(wf); error = git_path_dirload_with_stat(wi->path.ptr, wi->root_len, &wf->entries); - if (error < GIT_SUCCESS || wf->entries.length == 0) { + if (error < 0 || wf->entries.length == 0) { workdir_iterator__free_frame(wf); return GIT_ENOTFOUND; } @@ -309,7 +303,7 @@ static int workdir_iterator__expand_dir(workdir_iterator *wi) /* only push new ignores if this is not top level directory */ if (wi->stack->next != NULL) { - int slash_pos = git_buf_rfind_next(&wi->path, '/'); + ssize_t slash_pos = git_buf_rfind_next(&wi->path, '/'); (void)git_ignore__push_dir(&wi->ignores, &wi->path.ptr[slash_pos + 1]); } @@ -321,7 +315,7 @@ static int workdir_iterator__current( { workdir_iterator *wi = (workdir_iterator *)self; *entry = (wi->entry.path == NULL) ? NULL : &wi->entry; - return GIT_SUCCESS; + return 0; } static int workdir_iterator__at_end(git_iterator *self) @@ -341,7 +335,7 @@ static int workdir_iterator__advance( *entry = NULL; if (wi->entry.path == NULL) - return GIT_SUCCESS; + return 0; while ((wf = wi->stack) != NULL) { next = git_vector_get(&wf->entries, ++wf->index); @@ -359,13 +353,13 @@ static int workdir_iterator__advance( if (wi->stack == NULL) { memset(&wi->entry, 0, sizeof(wi->entry)); - return GIT_SUCCESS; + return 0; } } error = workdir_iterator__update_entry(wi); - if (error == GIT_SUCCESS && entry != NULL) + if (!error && entry != NULL) error = workdir_iterator__current(self, entry); return error; @@ -382,7 +376,7 @@ static int workdir_iterator__reset(git_iterator *self) } if (wi->stack) wi->stack->index = 0; - return GIT_SUCCESS; + return 0; } static void workdir_iterator__free(git_iterator *self) @@ -401,13 +395,11 @@ static void workdir_iterator__free(git_iterator *self) static int workdir_iterator__update_entry(workdir_iterator *wi) { - int error; git_path_with_stat *ps = git_vector_get(&wi->stack->entries, wi->stack->index); git_buf_truncate(&wi->path, wi->root_len); - error = git_buf_put(&wi->path, ps->path, ps->path_len); - if (error < GIT_SUCCESS) - return error; + if (git_buf_put(&wi->path, ps->path, ps->path_len) < 0) + return -1; memset(&wi->entry, 0, sizeof(wi->entry)); wi->entry.path = ps->path; @@ -419,39 +411,48 @@ static int workdir_iterator__update_entry(workdir_iterator *wi) /* if there is an error processing the entry, treat as ignored */ wi->is_ignored = 1; - /* TODO: remove shared code for struct stat conversion with index.c */ - wi->entry.ctime.seconds = (git_time_t)ps->st.st_ctime; - wi->entry.mtime.seconds = (git_time_t)ps->st.st_mtime; - wi->entry.dev = ps->st.st_rdev; - wi->entry.ino = ps->st.st_ino; + git_index__init_entry_from_stat(&ps->st, &wi->entry); + + /* need different mode here to keep directories during iteration */ wi->entry.mode = git_futils_canonical_mode(ps->st.st_mode); - wi->entry.uid = ps->st.st_uid; - wi->entry.gid = ps->st.st_gid; - wi->entry.file_size = ps->st.st_size; /* if this is a file type we don't handle, treat as ignored */ if (wi->entry.mode == 0) - return GIT_SUCCESS; + return 0; /* okay, we are far enough along to look up real ignore rule */ - error = git_ignore__lookup(&wi->ignores, wi->entry.path, &wi->is_ignored); - if (error != GIT_SUCCESS) - return GIT_SUCCESS; + if (git_ignore__lookup(&wi->ignores, wi->entry.path, &wi->is_ignored) < 0) + return 0; /* if error, ignore it and ignore file */ /* detect submodules */ - if (S_ISDIR(wi->entry.mode) && - git_path_contains(&wi->path, DOT_GIT) == GIT_SUCCESS) - wi->entry.mode = S_IFGITLINK; + if (S_ISDIR(wi->entry.mode)) { + bool is_submodule = git_path_contains(&wi->path, DOT_GIT); - return GIT_SUCCESS; + /* if there is no .git, still check submodules data */ + if (!is_submodule) { + int res = git_submodule_lookup(NULL, wi->repo, wi->entry.path); + is_submodule = (res == 0); + if (res == GIT_ENOTFOUND) + giterr_clear(); + } + + /* if submodule, mark as GITLINK and remove trailing slash */ + if (is_submodule) { + size_t len = strlen(wi->entry.path); + assert(wi->entry.path[len - 1] == '/'); + wi->entry.path[len - 1] = '\0'; + wi->entry.mode = S_IFGITLINK; + } + } + + return 0; } int git_iterator_for_workdir(git_repository *repo, git_iterator **iter) { int error; workdir_iterator *wi = git__calloc(1, sizeof(workdir_iterator)); - if (!wi) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(wi); wi->base.type = GIT_ITERATOR_WORKDIR; wi->base.current = workdir_iterator__current; @@ -461,19 +462,17 @@ int git_iterator_for_workdir(git_repository *repo, git_iterator **iter) wi->base.free = workdir_iterator__free; wi->repo = repo; - error = git_buf_sets(&wi->path, git_repository_workdir(repo)); - if (error == GIT_SUCCESS) - error = git_path_to_dir(&wi->path); - if (error == GIT_SUCCESS) - error = git_ignore__for_path(repo, "", &wi->ignores); - if (error != GIT_SUCCESS) { + if (git_buf_sets(&wi->path, git_repository_workdir(repo)) < 0 || + git_path_to_dir(&wi->path) < 0 || + git_ignore__for_path(repo, "", &wi->ignores) < 0) + { git__free(wi); - return error; + return -1; } wi->root_len = wi->path.size; - if ((error = workdir_iterator__expand_dir(wi)) < GIT_SUCCESS) + if ((error = workdir_iterator__expand_dir(wi)) < 0) git_iterator_free((git_iterator *)wi); else *iter = (git_iterator *)wi; @@ -487,7 +486,7 @@ int git_iterator_current_tree_entry( { *tree_entry = (iter->type != GIT_ITERATOR_TREE) ? NULL : tree_iterator__tree_entry((tree_iterator *)iter); - return GIT_SUCCESS; + return 0; } int git_iterator_current_is_ignored(git_iterator *iter) @@ -502,12 +501,14 @@ int git_iterator_advance_into_directory( workdir_iterator *wi = (workdir_iterator *)iter; if (iter->type == GIT_ITERATOR_WORKDIR && - wi->entry.path && S_ISDIR(wi->entry.mode)) + wi->entry.path && + S_ISDIR(wi->entry.mode) && + !S_ISGITLINK(wi->entry.mode)) { - if (workdir_iterator__expand_dir(wi) < GIT_SUCCESS) + if (workdir_iterator__expand_dir(wi) < 0) /* if error loading or if empty, skip the directory. */ return workdir_iterator__advance(iter, entry); } - return entry ? git_iterator_current(iter, entry) : GIT_SUCCESS; + return entry ? git_iterator_current(iter, entry) : 0; } diff --git a/src/khash.h b/src/khash.h new file mode 100644 index 000000000..bd67fe1f7 --- /dev/null +++ b/src/khash.h @@ -0,0 +1,608 @@ +/* The MIT License + + Copyright (c) 2008, 2009, 2011 by Attractive Chaos + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + +/* + An example: + +#include "khash.h" +KHASH_MAP_INIT_INT(32, char) +int main() { + int ret, is_missing; + khiter_t k; + khash_t(32) *h = kh_init(32); + k = kh_put(32, h, 5, &ret); + kh_value(h, k) = 10; + k = kh_get(32, h, 10); + is_missing = (k == kh_end(h)); + k = kh_get(32, h, 5); + kh_del(32, h, k); + for (k = kh_begin(h); k != kh_end(h); ++k) + if (kh_exist(h, k)) kh_value(h, k) = 1; + kh_destroy(32, h); + return 0; +} +*/ + +/* + 2011-12-29 (0.2.7): + + * Minor code clean up; no actual effect. + + 2011-09-16 (0.2.6): + + * The capacity is a power of 2. This seems to dramatically improve the + speed for simple keys. Thank Zilong Tan for the suggestion. Reference: + + - http://code.google.com/p/ulib/ + - http://nothings.org/computer/judy/ + + * Allow to optionally use linear probing which usually has better + performance for random input. Double hashing is still the default as it + is more robust to certain non-random input. + + * Added Wang's integer hash function (not used by default). This hash + function is more robust to certain non-random input. + + 2011-02-14 (0.2.5): + + * Allow to declare global functions. + + 2009-09-26 (0.2.4): + + * Improve portability + + 2008-09-19 (0.2.3): + + * Corrected the example + * Improved interfaces + + 2008-09-11 (0.2.2): + + * Improved speed a little in kh_put() + + 2008-09-10 (0.2.1): + + * Added kh_clear() + * Fixed a compiling error + + 2008-09-02 (0.2.0): + + * Changed to token concatenation which increases flexibility. + + 2008-08-31 (0.1.2): + + * Fixed a bug in kh_get(), which has not been tested previously. + + 2008-08-31 (0.1.1): + + * Added destructor +*/ + + +#ifndef __AC_KHASH_H +#define __AC_KHASH_H + +/*! + @header + + Generic hash table library. + */ + +#define AC_VERSION_KHASH_H "0.2.6" + +#include +#include +#include + +/* compipler specific configuration */ + +#if UINT_MAX == 0xffffffffu +typedef unsigned int khint32_t; +#elif ULONG_MAX == 0xffffffffu +typedef unsigned long khint32_t; +#endif + +#if ULONG_MAX == ULLONG_MAX +typedef unsigned long khint64_t; +#else +typedef unsigned long long khint64_t; +#endif + +#ifdef _MSC_VER +#define inline __inline +#endif + +typedef khint32_t khint_t; +typedef khint_t khiter_t; + +#define __ac_isempty(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2) +#define __ac_isdel(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&1) +#define __ac_iseither(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&3) +#define __ac_set_isdel_false(flag, i) (flag[i>>4]&=~(1ul<<((i&0xfU)<<1))) +#define __ac_set_isempty_false(flag, i) (flag[i>>4]&=~(2ul<<((i&0xfU)<<1))) +#define __ac_set_isboth_false(flag, i) (flag[i>>4]&=~(3ul<<((i&0xfU)<<1))) +#define __ac_set_isdel_true(flag, i) (flag[i>>4]|=1ul<<((i&0xfU)<<1)) + +#ifdef KHASH_LINEAR +#define __ac_inc(k, m) 1 +#else +#define __ac_inc(k, m) (((k)>>3 ^ (k)<<3) | 1) & (m) +#endif + +#define __ac_fsize(m) ((m) < 16? 1 : (m)>>4) + +#ifndef kroundup32 +#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x)) +#endif + +#ifndef kcalloc +#define kcalloc(N,Z) calloc(N,Z) +#endif +#ifndef kmalloc +#define kmalloc(Z) malloc(Z) +#endif +#ifndef krealloc +#define krealloc(P,Z) realloc(P,Z) +#endif +#ifndef kfree +#define kfree(P) free(P) +#endif + +static const double __ac_HASH_UPPER = 0.77; + +#define __KHASH_TYPE(name, khkey_t, khval_t) \ + typedef struct { \ + khint_t n_buckets, size, n_occupied, upper_bound; \ + khint32_t *flags; \ + khkey_t *keys; \ + khval_t *vals; \ + } kh_##name##_t; + +#define __KHASH_PROTOTYPES(name, khkey_t, khval_t) \ + extern kh_##name##_t *kh_init_##name(void); \ + extern void kh_destroy_##name(kh_##name##_t *h); \ + extern void kh_clear_##name(kh_##name##_t *h); \ + extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key); \ + extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \ + extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \ + extern void kh_del_##name(kh_##name##_t *h, khint_t x); + +#define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ + SCOPE kh_##name##_t *kh_init_##name(void) { \ + return (kh_##name##_t*)kcalloc(1, sizeof(kh_##name##_t)); \ + } \ + SCOPE void kh_destroy_##name(kh_##name##_t *h) \ + { \ + if (h) { \ + kfree((void *)h->keys); kfree(h->flags); \ + kfree((void *)h->vals); \ + kfree(h); \ + } \ + } \ + SCOPE void kh_clear_##name(kh_##name##_t *h) \ + { \ + if (h && h->flags) { \ + memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t)); \ + h->size = h->n_occupied = 0; \ + } \ + } \ + SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) \ + { \ + if (h->n_buckets) { \ + khint_t inc, k, i, last, mask; \ + mask = h->n_buckets - 1; \ + k = __hash_func(key); i = k & mask; \ + inc = __ac_inc(k, mask); last = i; /* inc==1 for linear probing */ \ + while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \ + i = (i + inc) & mask; \ + if (i == last) return h->n_buckets; \ + } \ + return __ac_iseither(h->flags, i)? h->n_buckets : i; \ + } else return 0; \ + } \ + SCOPE int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \ + { /* This function uses 0.25*n_bucktes bytes of working space instead of [sizeof(key_t+val_t)+.25]*n_buckets. */ \ + khint32_t *new_flags = 0; \ + khint_t j = 1; \ + { \ + kroundup32(new_n_buckets); \ + if (new_n_buckets < 4) new_n_buckets = 4; \ + if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0; /* requested size is too small */ \ + else { /* hash table size to be changed (shrink or expand); rehash */ \ + new_flags = (khint32_t*)kmalloc(__ac_fsize(new_n_buckets) * sizeof(khint32_t)); \ + if (!new_flags) return -1; \ + memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \ + if (h->n_buckets < new_n_buckets) { /* expand */ \ + khkey_t *new_keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \ + if (!new_keys) return -1; \ + h->keys = new_keys; \ + if (kh_is_map) { \ + khval_t *new_vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \ + if (!new_vals) return -1; \ + h->vals = new_vals; \ + } \ + } /* otherwise shrink */ \ + } \ + } \ + if (j) { /* rehashing is needed */ \ + for (j = 0; j != h->n_buckets; ++j) { \ + if (__ac_iseither(h->flags, j) == 0) { \ + khkey_t key = h->keys[j]; \ + khval_t val; \ + khint_t new_mask; \ + new_mask = new_n_buckets - 1; \ + if (kh_is_map) val = h->vals[j]; \ + __ac_set_isdel_true(h->flags, j); \ + while (1) { /* kick-out process; sort of like in Cuckoo hashing */ \ + khint_t inc, k, i; \ + k = __hash_func(key); \ + i = k & new_mask; \ + inc = __ac_inc(k, new_mask); \ + while (!__ac_isempty(new_flags, i)) i = (i + inc) & new_mask; \ + __ac_set_isempty_false(new_flags, i); \ + if (i < h->n_buckets && __ac_iseither(h->flags, i) == 0) { /* kick out the existing element */ \ + { khkey_t tmp = h->keys[i]; h->keys[i] = key; key = tmp; } \ + if (kh_is_map) { khval_t tmp = h->vals[i]; h->vals[i] = val; val = tmp; } \ + __ac_set_isdel_true(h->flags, i); /* mark it as deleted in the old hash table */ \ + } else { /* write the element and jump out of the loop */ \ + h->keys[i] = key; \ + if (kh_is_map) h->vals[i] = val; \ + break; \ + } \ + } \ + } \ + } \ + if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \ + h->keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \ + if (kh_is_map) h->vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \ + } \ + kfree(h->flags); /* free the working space */ \ + h->flags = new_flags; \ + h->n_buckets = new_n_buckets; \ + h->n_occupied = h->size; \ + h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5); \ + } \ + return 0; \ + } \ + SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) \ + { \ + khint_t x; \ + if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \ + if (h->n_buckets > (h->size<<1)) { \ + if (kh_resize_##name(h, h->n_buckets - 1) < 0) { /* clear "deleted" elements */ \ + *ret = -1; return h->n_buckets; \ + } \ + } else if (kh_resize_##name(h, h->n_buckets + 1) < 0) { /* expand the hash table */ \ + *ret = -1; return h->n_buckets; \ + } \ + } /* TODO: to implement automatically shrinking; resize() already support shrinking */ \ + { \ + khint_t inc, k, i, site, last, mask = h->n_buckets - 1; \ + x = site = h->n_buckets; k = __hash_func(key); i = k & mask; \ + if (__ac_isempty(h->flags, i)) x = i; /* for speed up */ \ + else { \ + inc = __ac_inc(k, mask); last = i; \ + while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \ + if (__ac_isdel(h->flags, i)) site = i; \ + i = (i + inc) & mask; \ + if (i == last) { x = site; break; } \ + } \ + if (x == h->n_buckets) { \ + if (__ac_isempty(h->flags, i) && site != h->n_buckets) x = site; \ + else x = i; \ + } \ + } \ + } \ + if (__ac_isempty(h->flags, x)) { /* not present at all */ \ + h->keys[x] = key; \ + __ac_set_isboth_false(h->flags, x); \ + ++h->size; ++h->n_occupied; \ + *ret = 1; \ + } else if (__ac_isdel(h->flags, x)) { /* deleted */ \ + h->keys[x] = key; \ + __ac_set_isboth_false(h->flags, x); \ + ++h->size; \ + *ret = 2; \ + } else *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \ + return x; \ + } \ + SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x) \ + { \ + if (x != h->n_buckets && !__ac_iseither(h->flags, x)) { \ + __ac_set_isdel_true(h->flags, x); \ + --h->size; \ + } \ + } + +#define KHASH_DECLARE(name, khkey_t, khval_t) \ + __KHASH_TYPE(name, khkey_t, khval_t) \ + __KHASH_PROTOTYPES(name, khkey_t, khval_t) + +#define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ + __KHASH_TYPE(name, khkey_t, khval_t) \ + __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) + +#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ + KHASH_INIT2(name, static inline, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) + +/* --- BEGIN OF HASH FUNCTIONS --- */ + +/*! @function + @abstract Integer hash function + @param key The integer [khint32_t] + @return The hash value [khint_t] + */ +#define kh_int_hash_func(key) (khint32_t)(key) +/*! @function + @abstract Integer comparison function + */ +#define kh_int_hash_equal(a, b) ((a) == (b)) +/*! @function + @abstract 64-bit integer hash function + @param key The integer [khint64_t] + @return The hash value [khint_t] + */ +#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11) +/*! @function + @abstract 64-bit integer comparison function + */ +#define kh_int64_hash_equal(a, b) ((a) == (b)) +/*! @function + @abstract const char* hash function + @param s Pointer to a null terminated string + @return The hash value + */ +static inline khint_t __ac_X31_hash_string(const char *s) +{ + khint_t h = (khint_t)*s; + if (h) for (++s ; *s; ++s) h = (h << 5) - h + (khint_t)*s; + return h; +} +/*! @function + @abstract Another interface to const char* hash function + @param key Pointer to a null terminated string [const char*] + @return The hash value [khint_t] + */ +#define kh_str_hash_func(key) __ac_X31_hash_string(key) +/*! @function + @abstract Const char* comparison function + */ +#define kh_str_hash_equal(a, b) (strcmp(a, b) == 0) + +static inline khint_t __ac_Wang_hash(khint_t key) +{ + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + return key; +} +#define kh_int_hash_func2(k) __ac_Wang_hash((khint_t)key) + +/* --- END OF HASH FUNCTIONS --- */ + +/* Other convenient macros... */ + +/*! + @abstract Type of the hash table. + @param name Name of the hash table [symbol] + */ +#define khash_t(name) kh_##name##_t + +/*! @function + @abstract Initiate a hash table. + @param name Name of the hash table [symbol] + @return Pointer to the hash table [khash_t(name)*] + */ +#define kh_init(name) kh_init_##name() + +/*! @function + @abstract Destroy a hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + */ +#define kh_destroy(name, h) kh_destroy_##name(h) + +/*! @function + @abstract Reset a hash table without deallocating memory. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + */ +#define kh_clear(name, h) kh_clear_##name(h) + +/*! @function + @abstract Resize a hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param s New size [khint_t] + */ +#define kh_resize(name, h, s) kh_resize_##name(h, s) + +/*! @function + @abstract Insert a key to the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Key [type of keys] + @param r Extra return code: 0 if the key is present in the hash table; + 1 if the bucket is empty (never used); 2 if the element in + the bucket has been deleted [int*] + @return Iterator to the inserted element [khint_t] + */ +#define kh_put(name, h, k, r) kh_put_##name(h, k, r) + +/*! @function + @abstract Retrieve a key from the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Key [type of keys] + @return Iterator to the found element, or kh_end(h) is the element is absent [khint_t] + */ +#define kh_get(name, h, k) kh_get_##name(h, k) + +/*! @function + @abstract Remove a key from the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Iterator to the element to be deleted [khint_t] + */ +#define kh_del(name, h, k) kh_del_##name(h, k) + +/*! @function + @abstract Test whether a bucket contains data. + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return 1 if containing data; 0 otherwise [int] + */ +#define kh_exist(h, x) (!__ac_iseither((h)->flags, (x))) + +/*! @function + @abstract Get key given an iterator + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return Key [type of keys] + */ +#define kh_key(h, x) ((h)->keys[x]) + +/*! @function + @abstract Get value given an iterator + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return Value [type of values] + @discussion For hash sets, calling this results in segfault. + */ +#define kh_val(h, x) ((h)->vals[x]) + +/*! @function + @abstract Alias of kh_val() + */ +#define kh_value(h, x) ((h)->vals[x]) + +/*! @function + @abstract Get the start iterator + @param h Pointer to the hash table [khash_t(name)*] + @return The start iterator [khint_t] + */ +#define kh_begin(h) (khint_t)(0) + +/*! @function + @abstract Get the end iterator + @param h Pointer to the hash table [khash_t(name)*] + @return The end iterator [khint_t] + */ +#define kh_end(h) ((h)->n_buckets) + +/*! @function + @abstract Get the number of elements in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @return Number of elements in the hash table [khint_t] + */ +#define kh_size(h) ((h)->size) + +/*! @function + @abstract Get the number of buckets in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @return Number of buckets in the hash table [khint_t] + */ +#define kh_n_buckets(h) ((h)->n_buckets) + +/*! @function + @abstract Iterate over the entries in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @param kvar Variable to which key will be assigned + @param vvar Variable to which value will be assigned + @param code Block of code to execute + */ +#define kh_foreach(h, kvar, vvar, code) { khint_t __i; \ + for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ + if (!kh_exist(h,__i)) continue; \ + (kvar) = kh_key(h,__i); \ + (vvar) = kh_val(h,__i); \ + code; \ + } } + +/*! @function + @abstract Iterate over the values in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @param vvar Variable to which value will be assigned + @param code Block of code to execute + */ +#define kh_foreach_value(h, vvar, code) { khint_t __i; \ + for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ + if (!kh_exist(h,__i)) continue; \ + (vvar) = kh_val(h,__i); \ + code; \ + } } + +/* More conenient interfaces */ + +/*! @function + @abstract Instantiate a hash set containing integer keys + @param name Name of the hash table [symbol] + */ +#define KHASH_SET_INIT_INT(name) \ + KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal) + +/*! @function + @abstract Instantiate a hash map containing integer keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] + */ +#define KHASH_MAP_INIT_INT(name, khval_t) \ + KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal) + +/*! @function + @abstract Instantiate a hash map containing 64-bit integer keys + @param name Name of the hash table [symbol] + */ +#define KHASH_SET_INIT_INT64(name) \ + KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal) + +/*! @function + @abstract Instantiate a hash map containing 64-bit integer keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] + */ +#define KHASH_MAP_INIT_INT64(name, khval_t) \ + KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal) + +typedef const char *kh_cstr_t; +/*! @function + @abstract Instantiate a hash map containing const char* keys + @param name Name of the hash table [symbol] + */ +#define KHASH_SET_INIT_STR(name) \ + KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal) + +/*! @function + @abstract Instantiate a hash map containing const char* keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] + */ +#define KHASH_MAP_INIT_STR(name, khval_t) \ + KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal) + +#endif /* __AC_KHASH_H */ diff --git a/src/map.h b/src/map.h index 0b070fa15..96d879547 100644 --- a/src/map.h +++ b/src/map.h @@ -31,6 +31,11 @@ typedef struct { /* memory mapped buffer */ #endif } git_map; +#define GIT_MMAP_VALIDATE(out, len, prot, flags) do { \ + assert(out != NULL && len > 0); \ + assert((prot & GIT_PROT_WRITE) || (prot & GIT_PROT_READ)); \ + assert((flags & GIT_MAP_FIXED) == 0); } while (0) + extern int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset); extern int p_munmap(git_map *map); diff --git a/src/mwindow.c b/src/mwindow.c index f657d9d34..b59c4d2f7 100644 --- a/src/mwindow.c +++ b/src/mwindow.c @@ -89,6 +89,7 @@ void git_mwindow_scan_lru( { git_mwindow *w, *w_l; + puts("LRU"); for (w_l = NULL, w = mwf->windows; w; w = w->next) { if (!w->inuse_cnt) { /* @@ -115,7 +116,7 @@ static int git_mwindow_close_lru(git_mwindow_file *mwf) unsigned int i; git_mwindow *lru_w = NULL, *lru_l = NULL, **list = &mwf->windows; - /* FIMXE: Does this give us any advantage? */ + /* FIXME: Does this give us any advantage? */ if(mwf->windows) git_mwindow_scan_lru(mwf, &lru_w, &lru_l); @@ -127,22 +128,23 @@ static int git_mwindow_close_lru(git_mwindow_file *mwf) list = &cur->windows; } - if (lru_w) { - ctl->mapped -= lru_w->window_map.len; - git_futils_mmap_free(&lru_w->window_map); - - if (lru_l) - lru_l->next = lru_w->next; - else - *list = lru_w->next; - - git__free(lru_w); - ctl->open_windows--; - - return GIT_SUCCESS; + if (!lru_w) { + giterr_set(GITERR_OS, "Failed to close memory window. Couldn't find LRU"); + return -1; } - return git__throw(GIT_ERROR, "Failed to close memory window. Couln't find LRU"); + ctl->mapped -= lru_w->window_map.len; + git_futils_mmap_free(&lru_w->window_map); + + if (lru_l) + lru_l->next = lru_w->next; + else + *list = lru_w->next; + + git__free(lru_w); + ctl->open_windows--; + + return 0; } static git_mwindow *new_window( @@ -158,7 +160,7 @@ static git_mwindow *new_window( w = git__malloc(sizeof(*w)); if (w == NULL) - return w; + return NULL; memset(w, 0x0, sizeof(*w)); w->offset = (offset / walign) * walign; @@ -170,7 +172,7 @@ static git_mwindow *new_window( ctl->mapped += (size_t)len; while (_mw_options.mapped_limit < ctl->mapped && - git_mwindow_close_lru(mwf) == GIT_SUCCESS) /* nop */; + git_mwindow_close_lru(mwf) == 0) /* nop */; /* * We treat _mw_options.mapped_limit as a soft limit. If we can't find a @@ -178,8 +180,10 @@ static git_mwindow *new_window( * window. */ - if (git_futils_mmap_ro(&w->window_map, fd, w->offset, (size_t)len) < GIT_SUCCESS) - goto cleanup; + if (git_futils_mmap_ro(&w->window_map, fd, w->offset, (size_t)len) < 0) { + git__free(w); + return NULL; + } ctl->mmap_calls++; ctl->open_windows++; @@ -191,10 +195,6 @@ static git_mwindow *new_window( ctl->peak_open_windows = ctl->open_windows; return w; - -cleanup: - git__free(w); - return NULL; } /* @@ -205,21 +205,20 @@ unsigned char *git_mwindow_open( git_mwindow_file *mwf, git_mwindow **cursor, git_off_t offset, - int extra, + size_t extra, unsigned int *left) { git_mwindow_ctl *ctl = &GIT_GLOBAL->mem_ctl; git_mwindow *w = *cursor; - if (!w || !(git_mwindow_contains(w, offset) && - git_mwindow_contains(w, offset + extra))) { + if (!w || !(git_mwindow_contains(w, offset) && git_mwindow_contains(w, offset + extra))) { if (w) { w->inuse_cnt--; } for (w = mwf->windows; w; w = w->next) { if (git_mwindow_contains(w, offset) && - git_mwindow_contains(w, offset + extra)) + git_mwindow_contains(w, offset + extra)) break; } @@ -248,17 +247,17 @@ unsigned char *git_mwindow_open( if (left) *left = (unsigned int)(w->window_map.len - offset); + fflush(stdout); return (unsigned char *) w->window_map.data + offset; } int git_mwindow_file_register(git_mwindow_file *mwf) { git_mwindow_ctl *ctl = &GIT_GLOBAL->mem_ctl; - int error; if (ctl->windowfiles.length == 0 && - (error = git_vector_init(&ctl->windowfiles, 8, NULL)) < GIT_SUCCESS) - return error; + git_vector_init(&ctl->windowfiles, 8, NULL) < 0) + return -1; return git_vector_insert(&ctl->windowfiles, mwf); } diff --git a/src/mwindow.h b/src/mwindow.h index 94bfb5d61..058027251 100644 --- a/src/mwindow.h +++ b/src/mwindow.h @@ -15,8 +15,8 @@ typedef struct git_mwindow { struct git_mwindow *next; git_map window_map; git_off_t offset; - unsigned int last_used; - unsigned int inuse_cnt; + size_t last_used; + size_t inuse_cnt; } git_mwindow; typedef struct git_mwindow_file { @@ -37,7 +37,7 @@ typedef struct git_mwindow_ctl { int git_mwindow_contains(git_mwindow *win, git_off_t offset); void git_mwindow_free_all(git_mwindow_file *mwf); -unsigned char *git_mwindow_open(git_mwindow_file *mwf, git_mwindow **cursor, git_off_t offset, int extra, unsigned int *left); +unsigned char *git_mwindow_open(git_mwindow_file *mwf, git_mwindow **cursor, git_off_t offset, size_t extra, unsigned int *left); void git_mwindow_scan_lru(git_mwindow_file *mwf, git_mwindow **lru_w, git_mwindow **lru_l); int git_mwindow_file_register(git_mwindow_file *mwf); void git_mwindow_close(git_mwindow **w_cursor); diff --git a/src/netops.c b/src/netops.c index 4b307af45..e2fec0b48 100644 --- a/src/netops.c +++ b/src/netops.c @@ -25,8 +25,28 @@ #include "common.h" #include "netops.h" #include "posix.h" +#include "buffer.h" -void gitno_buffer_setup(gitno_buffer *buf, char *data, unsigned int len, int fd) +#ifdef GIT_WIN32 +static void net_set_error(const char *str) +{ + int size, error = WSAGetLastError(); + LPSTR err_str = NULL; + + size = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, + 0, error, 0, (LPSTR)&err_str, 0, 0); + + giterr_set(GITERR_NET, "%s: $s", str, err_str); + LocalFree(err_str); +} +#else +static void net_set_error(const char *str) +{ + giterr_set(GITERR_NET, "%s: %s", str, strerror(errno)); +} +#endif + +void gitno_buffer_setup(gitno_buffer *buf, char *data, unsigned int len, GIT_SOCKET fd) { memset(buf, 0x0, sizeof(gitno_buffer)); memset(data, 0x0, len); @@ -40,14 +60,13 @@ int gitno_recv(gitno_buffer *buf) { int ret; - ret = recv(buf->fd, buf->data + buf->offset, buf->len - buf->offset, 0); - if (ret < 0) - return git__throw(GIT_EOSERR, "Failed to receive data: %s", strerror(errno)); - if (ret == 0) /* Orderly shutdown, so exit */ - return GIT_SUCCESS; + 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; + } buf->offset += ret; - return ret; } @@ -74,52 +93,43 @@ void gitno_consume_n(gitno_buffer *buf, size_t cons) buf->offset -= cons; } -int gitno_connect(const char *host, const char *port) +GIT_SOCKET gitno_connect(const char *host, const char *port) { - struct addrinfo *info, *p; + struct addrinfo *info = NULL, *p; struct addrinfo hints; - int ret, error = GIT_SUCCESS; - GIT_SOCKET s; + int ret; + GIT_SOCKET s = INVALID_SOCKET; memset(&hints, 0x0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; - ret = getaddrinfo(host, port, &hints, &info); - if (ret != 0) { - error = GIT_EOSERR; - info = NULL; - goto cleanup; + if ((ret = getaddrinfo(host, port, &hints, &info)) < 0) { + giterr_set(GITERR_NET, "Failed to resolve address for %s: %s", host, gai_strerror(ret)); + return INVALID_SOCKET; } for (p = info; p != NULL; p = p->ai_next) { s = socket(p->ai_family, p->ai_socktype, p->ai_protocol); -#ifdef GIT_WIN32 if (s == INVALID_SOCKET) { -#else - if (s < 0) { -#endif - error = GIT_EOSERR; - goto cleanup; + net_set_error("error creating socket"); + break; } - ret = connect(s, p->ai_addr, p->ai_addrlen); + if (connect(s, p->ai_addr, (socklen_t)p->ai_addrlen) == 0) + break; + /* If we can't connect, try the next one */ - if (ret < 0) { - continue; - } - - /* Return the socket */ - error = s; - goto cleanup; + gitno_close(s); + s = INVALID_SOCKET; } /* Oops, we couldn't connect to any address */ - error = git__throw(GIT_EOSERR, "Failed to connect: %s", strerror(errno)); + if (s == INVALID_SOCKET && p == NULL) + giterr_set(GITERR_OS, "Failed to connect to %s", host); -cleanup: freeaddrinfo(info); - return error; + return s; } int gitno_send(GIT_SOCKET s, const char *msg, size_t len, int flags) @@ -130,14 +140,16 @@ int gitno_send(GIT_SOCKET s, const char *msg, size_t len, int flags) while (off < len) { errno = 0; - ret = send(s, msg + off, len - off, flags); - if (ret < 0) - return git__throw(GIT_EOSERR, "Error sending data: %s", strerror(errno)); + ret = p_send(s, msg + off, len - off, flags); + if (ret < 0) { + net_set_error("Error sending data"); + return -1; + } off += ret; } - return off; + return (int)off; } @@ -165,35 +177,31 @@ int gitno_select_in(gitno_buffer *buf, long int sec, long int usec) FD_SET(buf->fd, &fds); /* The select(2) interface is silly */ - return select(buf->fd + 1, &fds, NULL, NULL, &tv); + return select((int)buf->fd + 1, &fds, NULL, NULL, &tv); } int gitno_extract_host_and_port(char **host, char **port, const char *url, const char *default_port) { char *colon, *slash, *delim; - int error = GIT_SUCCESS; colon = strchr(url, ':'); slash = strchr(url, '/'); - if (slash == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Malformed URL: missing /"); + if (slash == NULL) { + giterr_set(GITERR_NET, "Malformed URL: missing /"); + return -1; + } if (colon == NULL) { *port = git__strdup(default_port); } else { *port = git__strndup(colon + 1, slash - colon - 1); } - if (*port == NULL) - return GIT_ENOMEM;; - + GITERR_CHECK_ALLOC(*port); delim = colon == NULL ? slash : colon; *host = git__strndup(url, delim - url); - if (*host == NULL) { - git__free(*port); - error = GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(*host); - return error; + return 0; } diff --git a/src/netops.h b/src/netops.h index 01ad9714f..f370019ff 100644 --- a/src/netops.h +++ b/src/netops.h @@ -7,11 +7,7 @@ #ifndef INCLUDE_netops_h__ #define INCLUDE_netops_h__ -#ifndef GIT_WIN32 -typedef int GIT_SOCKET; -#else -typedef SOCKET GIT_SOCKET; -#endif +#include "posix.h" typedef struct gitno_buffer { char *data; @@ -20,12 +16,12 @@ typedef struct gitno_buffer { GIT_SOCKET fd; } gitno_buffer; -void gitno_buffer_setup(gitno_buffer *buf, char *data, unsigned int len, int fd); +void gitno_buffer_setup(gitno_buffer *buf, char *data, unsigned int len, GIT_SOCKET fd); int gitno_recv(gitno_buffer *buf); void gitno_consume(gitno_buffer *buf, const char *ptr); void gitno_consume_n(gitno_buffer *buf, size_t cons); -int gitno_connect(const char *host, const char *port); +GIT_SOCKET gitno_connect(const char *host, const char *port); int gitno_send(GIT_SOCKET s, const char *msg, size_t len, int flags); int gitno_close(GIT_SOCKET s); int gitno_send_chunk_size(int s, size_t len); diff --git a/src/notes.c b/src/notes.c index 68554c36f..4afdac0bd 100644 --- a/src/notes.c +++ b/src/notes.c @@ -9,6 +9,7 @@ #include "git2.h" #include "refs.h" +#include "config.h" static int find_subtree(git_tree **subtree, const git_oid *root, git_repository *repo, const char *target, int *fanout) @@ -21,11 +22,8 @@ static int find_subtree(git_tree **subtree, const git_oid *root, *subtree = NULL; error = git_tree_lookup(&tree, repo, root); - if (error < GIT_SUCCESS) { - if (error == GIT_ENOTFOUND) - return error; /* notes tree doesn't exist yet */ - return git__rethrow(error, "Failed to open notes tree"); - } + if (error < 0) + return error; for (i=0; ioid, &oid); note->message = git__strdup(git_blob_rawcontent(blob)); - if (note->message == NULL) - error = GIT_ENOMEM; + GITERR_CHECK_ALLOC(note->message); *out = note; @@ -240,39 +229,30 @@ static int note_remove(git_repository *repo, git_treebuilder *tb; error = find_subtree(&tree, tree_sha, repo, target, &fanout); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup subtree"); + if (error < 0) + return error; error = find_blob(&oid, tree, target + fanout); - if (error < GIT_SUCCESS) { - git_tree_free(tree); - return git__throw(GIT_ENOTFOUND, "No note found for object %s", - target); - } + if (!error) + error = git_treebuilder_create(&tb, tree); - error = git_treebuilder_create(&tb, tree); git_tree_free(tree); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create treebuilder"); + if (error < 0) + return error; error = git_treebuilder_remove(tb, target + fanout); - if (error < GIT_SUCCESS) { - git_treebuilder_free(tb); - return git__rethrow(error, "Failed to remove entry from notes tree"); - } + if (!error) + error = git_treebuilder_write(&oid, repo, tb); - error = git_treebuilder_write(&oid, repo, tb); git_treebuilder_free(tb); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to write notes tree"); + if (error < 0) + return error; /* create new notes commit */ error = git_tree_lookup(&tree, repo, &oid); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to open new notes tree"); + if (error < 0) + return error; error = git_commit_create(&oid, repo, notes_ref, author, committer, NULL, GIT_NOTES_DEFAULT_MSG_RM, @@ -280,12 +260,28 @@ static int note_remove(git_repository *repo, git_tree_free(tree); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create new notes commit"); - return error; } +static int note_get_default_ref(const char **out, git_repository *repo) +{ + int ret; + git_config *cfg; + + *out = NULL; + + if (git_repository_config__weakptr(&cfg, repo) < 0) + return -1; + + ret = git_config_get_string(cfg, "core.notesRef", out); + if (ret == GIT_ENOTFOUND) { + *out = GIT_NOTES_DEFAULT_REF; + return 0; + } + + return ret; +} + int git_note_read(git_note **out, git_repository *repo, const char *notes_ref, const git_oid *oid) { @@ -297,12 +293,12 @@ int git_note_read(git_note **out, git_repository *repo, *out = NULL; - if (!notes_ref) - notes_ref = GIT_NOTES_DEFAULT_REF; + if (!notes_ref && note_get_default_ref(¬es_ref, repo) < 0) + return -1; error = git_reference_lookup(&ref, repo, notes_ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup reference `%s`", notes_ref); + if (error < 0) + return error; assert(git_reference_type(ref) == GIT_REF_OID); @@ -311,27 +307,26 @@ int git_note_read(git_note **out, git_repository *repo, git_reference_free(ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to find notes commit object"); + if (error < 0) + return error; sha = git_commit_tree_oid(commit); git_commit_free(commit); target = git_oid_allocfmt(oid); - if (target == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(target); error = note_lookup(out, repo, sha, target); git__free(target); - return error == GIT_SUCCESS ? GIT_SUCCESS : - git__rethrow(error, "Failed to read note"); + return error; } -int git_note_create(git_oid *out, git_repository *repo, - git_signature *author, git_signature *committer, - const char *notes_ref, const git_oid *oid, - const char *note) +int git_note_create( + git_oid *out, git_repository *repo, + git_signature *author, git_signature *committer, + const char *notes_ref, const git_oid *oid, + const char *note) { int error, nparents = 0; char *target; @@ -339,14 +334,14 @@ int git_note_create(git_oid *out, git_repository *repo, git_commit *commit = NULL; git_reference *ref; - if (!notes_ref) - notes_ref = GIT_NOTES_DEFAULT_REF; + if (!notes_ref && note_get_default_ref(¬es_ref, repo) < 0) + return -1; error = git_reference_lookup(&ref, repo, notes_ref); - if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) - return git__rethrow(error, "Failed to lookup reference `%s`", notes_ref); + if (error < 0 && error != GIT_ENOTFOUND) + return error; - if (error == GIT_SUCCESS) { + if (!error) { assert(git_reference_type(ref) == GIT_REF_OID); /* lookup existing notes tree oid */ @@ -355,16 +350,15 @@ int git_note_create(git_oid *out, git_repository *repo, git_reference_free(ref); error = git_commit_lookup(&commit, repo, &sha); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to find notes commit object"); + if (error < 0) + return error; git_oid_cpy(&sha, git_commit_tree_oid(commit)); nparents++; } target = git_oid_allocfmt(oid); - if (target == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(target); error = note_write(out, repo, author, committer, notes_ref, note, nparents ? &sha : NULL, target, @@ -372,8 +366,7 @@ int git_note_create(git_oid *out, git_repository *repo, git__free(target); git_commit_free(commit); - return error == GIT_SUCCESS ? GIT_SUCCESS : - git__rethrow(error, "Failed to write note"); + return error; } int git_note_remove(git_repository *repo, const char *notes_ref, @@ -386,12 +379,13 @@ int git_note_remove(git_repository *repo, const char *notes_ref, git_commit *commit; git_reference *ref; - if (!notes_ref) - notes_ref = GIT_NOTES_DEFAULT_REF; + + if (!notes_ref && note_get_default_ref(¬es_ref, repo) < 0) + return -1; error = git_reference_lookup(&ref, repo, notes_ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup reference `%s`", notes_ref); + if (error < 0) + return error; assert(git_reference_type(ref) == GIT_REF_OID); @@ -399,22 +393,26 @@ int git_note_remove(git_repository *repo, const char *notes_ref, git_reference_free(ref); error = git_commit_lookup(&commit, repo, &sha); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to find notes commit object"); + if (error < 0) + return error; git_oid_cpy(&sha, git_commit_tree_oid(commit)); target = git_oid_allocfmt(oid); - if (target == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(target); error = note_remove(repo, author, committer, notes_ref, &sha, target, 1, &commit); git__free(target); git_commit_free(commit); - return error == GIT_SUCCESS ? GIT_SUCCESS : - git__rethrow(error, "Failed to read note"); + return error; +} + +int git_note_default_ref(const char **out, git_repository *repo) +{ + assert(repo); + return note_get_default_ref(out, repo); } const char * git_note_message(git_note *note) diff --git a/src/object.c b/src/object.c index 043001599..e02bd69ba 100644 --- a/src/object.c +++ b/src/object.c @@ -62,13 +62,13 @@ static int create_object(git_object **object_out, git_otype type) case GIT_OBJ_BLOB: case GIT_OBJ_TREE: object = git__malloc(git_object__size(type)); - if (object == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(object); memset(object, 0x0, git_object__size(type)); break; default: - return git__throw(GIT_EINVALIDTYPE, "The given type is invalid"); + giterr_set(GITERR_INVALID, "The given type is invalid"); + return -1; } object->type = type; @@ -92,8 +92,7 @@ int git_object_lookup_prefix( assert(repo && object_out && id); if (len < GIT_OID_MINPREFIXLEN) - return git__throw(GIT_EAMBIGUOUSOIDPREFIX, - "Failed to lookup object. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN); + return GIT_EAMBIGUOUS; error = git_repository_odb__weakptr(&odb, repo); if (error < GIT_SUCCESS) @@ -110,13 +109,12 @@ int git_object_lookup_prefix( if (object != NULL) { if (type != GIT_OBJ_ANY && type != object->type) { git_object_free(object); - return git__throw(GIT_EINVALIDTYPE, - "Failed to lookup object. " - "The given type does not match the type on the ODB"); + giterr_set(GITERR_INVALID, "The given type does not match the type in ODB"); + return -1; } *object_out = object; - return GIT_SUCCESS; + return 0; } /* Object was not found in the cache, let's explore the backends. @@ -147,18 +145,19 @@ int git_object_lookup_prefix( error = git_odb_read_prefix(&odb_obj, odb, &short_oid, len); } - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup object"); + if (error < 0) + return error; if (type != GIT_OBJ_ANY && type != odb_obj->raw.type) { git_odb_object_free(odb_obj); - return git__throw(GIT_EINVALIDTYPE, "Failed to lookup object. The given type does not match the type on the ODB"); + giterr_set(GITERR_INVALID, "The given type does not match the type on the ODB"); + return -1; } type = odb_obj->raw.type; - if ((error = create_object(&object, type)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup object"); + if (create_object(&object, type) < 0) + return -1; /* Initialize parent object */ git_oid_cpy(&object->cached.oid, &odb_obj->cached.oid); @@ -187,13 +186,13 @@ int git_object_lookup_prefix( git_odb_object_free(odb_obj); - if (error < GIT_SUCCESS) { + if (error < 0) { git_object__free(object); - return git__rethrow(error, "Failed to lookup object"); + return -1; } *object_out = git_cache_try_store(&repo->objects, object); - return GIT_SUCCESS; + return 0; } int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_otype type) { @@ -293,3 +292,42 @@ size_t git_object__size(git_otype type) return git_objects_table[type].size; } +int git_object__resolve_to_type(git_object **obj, git_otype type) +{ + int error = 0; + git_object *scan, *next; + + if (type == GIT_OBJ_ANY) + return 0; + + scan = *obj; + + while (!error && scan && git_object_type(scan) != type) { + + switch (git_object_type(scan)) { + case GIT_OBJ_COMMIT: + { + git_tree *tree = NULL; + error = git_commit_tree(&tree, (git_commit *)scan); + next = (git_object *)tree; + break; + } + + case GIT_OBJ_TAG: + error = git_tag_target(&next, (git_tag *)scan); + break; + + default: + giterr_set(GITERR_REFERENCE, "Object does not resolve to type"); + error = -1; + next = NULL; + break; + } + + git_object_free(scan); + scan = next; + } + + *obj = scan; + return error; +} diff --git a/src/odb.c b/src/odb.c index 81fc82ba8..934b317ed 100644 --- a/src/odb.c +++ b/src/odb.c @@ -32,10 +32,7 @@ static int format_object_header(char *hdr, size_t n, size_t obj_len, git_otype o { const char *type_str = git_object_type2string(obj_type); int len = p_snprintf(hdr, n, "%s %"PRIuZ, type_str, obj_len); - - if (len < 0 || len >= (int)n) - return git__throw(GIT_ERROR, "Cannot format object header. Length is out of bounds"); - + assert(len > 0 && len <= (int)n); return len+1; } @@ -48,13 +45,11 @@ int git_odb__hashobj(git_oid *id, git_rawobj *obj) assert(id && obj); if (!git_object_typeisloose(obj->type)) - return git__throw(GIT_ERROR, "Failed to hash object. Wrong object type"); - + return -1; if (!obj->data && obj->len != 0) - return git__throw(GIT_ERROR, "Failed to hash object. No data given"); + return -1; - if ((hdrlen = format_object_header(header, sizeof(header), obj->len, obj->type)) < 0) - return git__rethrow(hdrlen, "Failed to hash object"); + hdrlen = format_object_header(header, sizeof(header), obj->len, obj->type); vec[0].data = header; vec[0].len = hdrlen; @@ -63,7 +58,7 @@ int git_odb__hashobj(git_oid *id, git_rawobj *obj) git_hash_vec(id, vec, 2); - return GIT_SUCCESS; + return 0; } @@ -120,8 +115,6 @@ int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type) git_hash_ctx *ctx; hdr_len = format_object_header(hdr, sizeof(hdr), size, type); - if (hdr_len < 0) - return git__throw(GIT_ERROR, "Failed to format blob header. Length is out of bounds"); ctx = git_hash_new_ctx(); @@ -132,7 +125,8 @@ int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type) if (read_len < 0) { git_hash_free_ctx(ctx); - return git__throw(GIT_EOSERR, "Error when reading file: %s", strerror(errno)); + giterr_set(GITERR_OS, "Error reading file"); + return -1; } git_hash_update(ctx, buffer, read_len); @@ -142,69 +136,67 @@ int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type) git_hash_final(out, ctx); git_hash_free_ctx(ctx); - return GIT_SUCCESS; + return 0; } int git_odb__hashlink(git_oid *out, const char *path) { struct stat st; - int error; git_off_t size; + int result; - error = p_lstat(path, &st); - if (error < 0) - return git__throw(GIT_EOSERR, "Failed to stat blob. %s", strerror(errno)); + if (git_path_lstat(path, &st) < 0) + return -1; size = st.st_size; - if (!git__is_sizet(size)) - return git__throw(GIT_EOSERR, "File size overflow for 32-bit systems"); + if (!git__is_sizet(size)) { + giterr_set(GITERR_OS, "File size overflow for 32-bit systems"); + return -1; + } if (S_ISLNK(st.st_mode)) { char *link_data; ssize_t read_len; link_data = git__malloc((size_t)size); - if (link_data == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(link_data); read_len = p_readlink(path, link_data, (size_t)(size + 1)); - if (read_len != (ssize_t)size) - return git__throw(GIT_EOSERR, "Failed to read symlink data"); + if (read_len != (ssize_t)size) { + giterr_set(GITERR_OS, "Failed to read symlink data for '%s'", path); + return -1; + } - error = git_odb_hash(out, link_data, (size_t)size, GIT_OBJ_BLOB); - free(link_data); + result = git_odb_hash(out, link_data, (size_t)size, GIT_OBJ_BLOB); + git__free(link_data); } else { - int fd; - - if ((fd = p_open(path, O_RDONLY)) < 0) - return git__throw(GIT_ENOTFOUND, "Could not open '%s'", path); - - error = git_odb__hashfd(out, fd, (size_t)size, GIT_OBJ_BLOB); + int fd = git_futils_open_ro(path); + if (fd < 0) + return -1; + result = git_odb__hashfd(out, fd, (size_t)size, GIT_OBJ_BLOB); p_close(fd); } - return error; + return result; } int git_odb_hashfile(git_oid *out, const char *path, git_otype type) { - int fd, error; git_off_t size; - - if ((fd = p_open(path, O_RDONLY)) < 0) - return git__throw(GIT_ENOTFOUND, "Could not open '%s'", path); + int result, fd = git_futils_open_ro(path); + if (fd < 0) + return fd; if ((size = git_futils_filesize(fd)) < 0 || !git__is_sizet(size)) { + giterr_set(GITERR_OS, "File size overflow for 32-bit systems"); p_close(fd); - return git__throw(GIT_EOSERR, - "File size overflow. The object is too big to fit in 32-bit mode"); + return -1; } - error = git_odb__hashfd(out, fd, (size_t)size, type); - + result = git_odb__hashfd(out, fd, (size_t)size, type); p_close(fd); - return error; + return result; } int git_odb_hash(git_oid *id, const void *data, size_t len, git_otype type) @@ -242,11 +234,11 @@ static int fake_wstream__write(git_odb_stream *_stream, const char *data, size_t fake_wstream *stream = (fake_wstream *)_stream; if (stream->written + len > stream->size) - return GIT_ENOMEM; + return -1; memcpy(stream->buffer + stream->written, data, len); stream->written += len; - return GIT_SUCCESS; + return 0; } static void fake_wstream__free(git_odb_stream *_stream) @@ -262,15 +254,14 @@ static int init_fake_wstream(git_odb_stream **stream_p, git_odb_backend *backend fake_wstream *stream; stream = git__calloc(1, sizeof(fake_wstream)); - if (stream == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(stream); stream->size = size; stream->type = type; stream->buffer = git__malloc(size); if (stream->buffer == NULL) { git__free(stream); - return GIT_ENOMEM; + return -1; } stream->stream.backend = backend; @@ -281,7 +272,7 @@ static int init_fake_wstream(git_odb_stream **stream_p, git_odb_backend *backend stream->stream.mode = GIT_STREAM_WRONLY; *stream_p = (git_odb_stream *)stream; - return GIT_SUCCESS; + return 0; } /*********************************************************** @@ -305,26 +296,19 @@ static int backend_sort_cmp(const void *a, const void *b) int git_odb_new(git_odb **out) { - int error; - git_odb *db = git__calloc(1, sizeof(*db)); - if (!db) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(db); - error = git_cache_init(&db->cache, GIT_DEFAULT_CACHE_SIZE, &free_odb_object); - if (error < GIT_SUCCESS) { + if (git_cache_init(&db->cache, GIT_DEFAULT_CACHE_SIZE, &free_odb_object) < 0 || + git_vector_init(&db->backends, 4, backend_sort_cmp) < 0) + { git__free(db); - return git__rethrow(error, "Failed to create object database"); - } - - if ((error = git_vector_init(&db->backends, 4, backend_sort_cmp)) < GIT_SUCCESS) { - git__free(db); - return git__rethrow(error, "Failed to create object database"); + return -1; } *out = db; GIT_REFCOUNT_INC(db); - return GIT_SUCCESS; + return 0; } static int add_backend_internal(git_odb *odb, git_odb_backend *backend, int priority, int is_alternate) @@ -333,12 +317,11 @@ static int add_backend_internal(git_odb *odb, git_odb_backend *backend, int prio assert(odb && backend); - if (backend->odb != NULL && backend->odb != odb) - return git__throw(GIT_EBUSY, "The backend is already owned by another ODB"); + /* Check if the backend is already owned by another ODB */ + assert(!backend->odb || backend->odb == odb); internal = git__malloc(sizeof(backend_internal)); - if (internal == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(internal); internal->backend = backend; internal->priority = priority; @@ -346,12 +329,12 @@ static int add_backend_internal(git_odb *odb, git_odb_backend *backend, int prio if (git_vector_insert(&odb->backends, internal) < 0) { git__free(internal); - return GIT_ENOMEM; + return -1; } git_vector_sort(&odb->backends); internal->backend->odb = odb; - return GIT_SUCCESS; + return 0; } int git_odb_add_backend(git_odb *odb, git_odb_backend *backend, int priority) @@ -367,27 +350,18 @@ int git_odb_add_alternate(git_odb *odb, git_odb_backend *backend, int priority) static int add_default_backends(git_odb *db, const char *objects_dir, int as_alternates) { git_odb_backend *loose, *packed; - int error; /* add the loose object backend */ - error = git_odb_backend_loose(&loose, objects_dir, -1, 0); - if (error < GIT_SUCCESS) - return error; - - error = add_backend_internal(db, loose, GIT_LOOSE_PRIORITY, as_alternates); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to add backend"); + if (git_odb_backend_loose(&loose, objects_dir, -1, 0) < 0 || + add_backend_internal(db, loose, GIT_LOOSE_PRIORITY, as_alternates) < 0) + return -1; /* add the packed file backend */ - error = git_odb_backend_pack(&packed, objects_dir); - if (error < GIT_SUCCESS) - return error; + if (git_odb_backend_pack(&packed, objects_dir) < 0 || + add_backend_internal(db, packed, GIT_PACKED_PRIORITY, as_alternates) < 0) + return -1; - error = add_backend_internal(db, packed, GIT_PACKED_PRIORITY, as_alternates); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to add backend"); - - return GIT_SUCCESS; + return 0; } static int load_alternates(git_odb *odb, const char *objects_dir) @@ -396,24 +370,22 @@ static int load_alternates(git_odb *odb, const char *objects_dir) git_buf alternates_buf = GIT_BUF_INIT; char *buffer; const char *alternate; - int error; + int result = 0; - error = git_buf_joinpath(&alternates_path, objects_dir, GIT_ALTERNATES_FILE); - if (error < GIT_SUCCESS) - return error; + if (git_buf_joinpath(&alternates_path, objects_dir, GIT_ALTERNATES_FILE) < 0) + return -1; - if (git_path_exists(alternates_path.ptr) < GIT_SUCCESS) { + if (git_path_exists(alternates_path.ptr) == false) { git_buf_free(&alternates_path); - return GIT_SUCCESS; + return 0; } - if (git_futils_readbuffer(&alternates_buf, alternates_path.ptr) < GIT_SUCCESS) { + if (git_futils_readbuffer(&alternates_buf, alternates_path.ptr) < 0) { git_buf_free(&alternates_path); - return git__throw(GIT_EOSERR, "Failed to add backend. Can't read alternates"); + return -1; } buffer = (char *)alternates_buf.ptr; - error = GIT_SUCCESS; /* add each alternate as a new backend; one alternate per line */ while ((alternate = git__strtok(&buffer, "\r\n")) != NULL) { @@ -422,48 +394,41 @@ static int load_alternates(git_odb *odb, const char *objects_dir) /* relative path: build based on the current `objects` folder */ if (*alternate == '.') { - error = git_buf_joinpath(&alternates_path, objects_dir, alternate); - if (error < GIT_SUCCESS) + if ((result = git_buf_joinpath(&alternates_path, objects_dir, alternate)) < 0) break; alternate = git_buf_cstr(&alternates_path); } - if ((error = add_default_backends(odb, alternate, 1)) < GIT_SUCCESS) + if ((result = add_default_backends(odb, alternate, 1)) < 0) break; } git_buf_free(&alternates_path); git_buf_free(&alternates_buf); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to load alternates"); - return error; + return result; } int git_odb_open(git_odb **out, const char *objects_dir) { git_odb *db; - int error; assert(out && objects_dir); *out = NULL; - if ((error = git_odb_new(&db)) < 0) - return git__rethrow(error, "Failed to open ODB"); + if (git_odb_new(&db) < 0) + return -1; - if ((error = add_default_backends(db, objects_dir, 0)) < GIT_SUCCESS) - goto cleanup; - - if ((error = load_alternates(db, objects_dir)) < GIT_SUCCESS) - goto cleanup; + if (add_default_backends(db, objects_dir, 0) < 0 || + load_alternates(db, objects_dir) < 0) + { + git_odb_free(db); + return -1; + } *out = db; - return GIT_SUCCESS; - -cleanup: - git_odb_free(db); - return error; /* error already set - pass through */ + return 0; } static void odb_free(git_odb *db) @@ -497,13 +462,13 @@ int git_odb_exists(git_odb *db, const git_oid *id) { git_odb_object *object; unsigned int i; - int found = 0; + bool found = false; assert(db && id); if ((object = git_cache_get(&db->cache, id)) != NULL) { git_odb_object_free(object); - return 1; + return (int)true; } for (i = 0; i < db->backends.length && !found; ++i) { @@ -514,7 +479,7 @@ int git_odb_exists(git_odb *db, const git_oid *id) found = b->exists(b, id); } - return found; + return (int)found; } int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id) @@ -529,7 +494,7 @@ int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git *len_p = object->raw.len; *type_p = object->raw.type; git_odb_object_free(object); - return GIT_SUCCESS; + return 0; } for (i = 0; i < db->backends.length && error < 0; ++i) { @@ -540,23 +505,20 @@ int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git error = b->read_header(len_p, type_p, b, id); } - if (error == GIT_EPASSTHROUGH) - return GIT_SUCCESS; + if (!error || error == GIT_EPASSTHROUGH) + return 0; /* * no backend could read only the header. * try reading the whole object and freeing the contents */ - if (error < 0) { - if ((error = git_odb_read(&object, db, id)) < GIT_SUCCESS) - return error; /* error already set - pass through */ + if ((error = git_odb_read(&object, db, id)) < 0) + return error; /* error already set - pass along */ - *len_p = object->raw.len; - *type_p = object->raw.type; - git_odb_object_free(object); - } - - return GIT_SUCCESS; + *len_p = object->raw.len; + *type_p = object->raw.type; + git_odb_object_free(object); + return 0; } int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id) @@ -569,7 +531,7 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id) *out = git_cache_get(&db->cache, id); if (*out != NULL) - return GIT_SUCCESS; + return 0; for (i = 0; i < db->backends.length && error < 0; ++i) { backend_internal *internal = git_vector_get(&db->backends, i); @@ -579,15 +541,19 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id) error = b->read(&raw.data, &raw.len, &raw.type, b, id); } - if (error == GIT_EPASSTHROUGH || error == GIT_SUCCESS) { - *out = git_cache_try_store(&db->cache, new_odb_object(id, &raw)); - return GIT_SUCCESS; - } + /* TODO: If no backends are configured, this returns GIT_ENOTFOUND but + * will never have called giterr_set(). + */ - return git__rethrow(error, "Failed to read object"); + if (error && error != GIT_EPASSTHROUGH) + return error; + + *out = git_cache_try_store(&db->cache, new_odb_object(id, &raw)); + return 0; } -int git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len) +int git_odb_read_prefix( + git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len) { unsigned int i; int error = GIT_ENOTFOUND; @@ -598,7 +564,7 @@ int git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_ assert(out && db); if (len < GIT_OID_MINPREFIXLEN) - return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to lookup object. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN); + return git_odb__error_ambiguous("prefix length too short"); if (len > GIT_OID_HEXSZ) len = GIT_OID_HEXSZ; @@ -606,7 +572,7 @@ int git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_ if (len == GIT_OID_HEXSZ) { *out = git_cache_get(&db->cache, short_id); if (*out != NULL) - return GIT_SUCCESS; + return 0; } for (i = 0; i < db->backends.length && found < 2; ++i) { @@ -615,33 +581,24 @@ int git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_ if (b->read != NULL) { error = b->read_prefix(&full_oid, &raw.data, &raw.len, &raw.type, b, short_id, len); - switch (error) { - case GIT_SUCCESS: + if (!error) found++; - break; - case GIT_ENOTFOUND: - case GIT_EPASSTHROUGH: - break; - case GIT_EAMBIGUOUSOIDPREFIX: - return git__rethrow(error, "Failed to read object. Ambiguous sha1 prefix"); - default: - return git__rethrow(error, "Failed to read object"); - } + else if (error != GIT_ENOTFOUND && error != GIT_EPASSTHROUGH) + return error; } } - if (found == 1) { - *out = git_cache_try_store(&db->cache, new_odb_object(&full_oid, &raw)); - } else if (found > 1) { - return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to read object. Ambiguous sha1 prefix"); - } else { - return git__throw(GIT_ENOTFOUND, "Failed to read object. Object not found"); - } + if (found == 0) + return git_odb__error_notfound("no match for prefix", short_id); + if (found > 1) + return git_odb__error_ambiguous("multiple matches for prefix"); - return GIT_SUCCESS; + *out = git_cache_try_store(&db->cache, new_odb_object(&full_oid, &raw)); + return 0; } -int git_odb_write(git_oid *oid, git_odb *db, const void *data, size_t len, git_otype type) +int git_odb_write( + git_oid *oid, git_odb *db, const void *data, size_t len, git_otype type) { unsigned int i; int error = GIT_ERROR; @@ -661,24 +618,25 @@ int git_odb_write(git_oid *oid, git_odb *db, const void *data, size_t len, git_o error = b->write(oid, b, data, len, type); } - if (error == GIT_EPASSTHROUGH || error == GIT_SUCCESS) - return GIT_SUCCESS; + if (!error || error == GIT_EPASSTHROUGH) + return 0; /* if no backends were able to write the object directly, we try a streaming * write to the backends; just write the whole object into the stream in one * push */ - if ((error = git_odb_open_wstream(&stream, db, len, type)) == GIT_SUCCESS) { - stream->write(stream, data, len); - error = stream->finalize_write(oid, stream); - stream->free(stream); - return GIT_SUCCESS; - } + if ((error = git_odb_open_wstream(&stream, db, len, type)) != 0) + return error; - return git__rethrow(error, "Failed to write object"); + stream->write(stream, data, len); + error = stream->finalize_write(oid, stream); + stream->free(stream); + + return error; } -int git_odb_open_wstream(git_odb_stream **stream, git_odb *db, size_t size, git_otype type) +int git_odb_open_wstream( + git_odb_stream **stream, git_odb *db, size_t size, git_otype type) { unsigned int i; int error = GIT_ERROR; @@ -699,10 +657,10 @@ int git_odb_open_wstream(git_odb_stream **stream, git_odb *db, size_t size, git_ error = init_fake_wstream(stream, b, size, type); } - if (error == GIT_EPASSTHROUGH || error == GIT_SUCCESS) - return GIT_SUCCESS; + if (error == GIT_EPASSTHROUGH) + error = 0; - return git__rethrow(error, "Failed to open write stream"); + return error; } int git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const git_oid *oid) @@ -720,9 +678,27 @@ int git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const git_oid *oi error = b->readstream(stream, b, oid); } - if (error == GIT_EPASSTHROUGH || error == GIT_SUCCESS) - return GIT_SUCCESS; + if (error == GIT_EPASSTHROUGH) + error = 0; - return git__rethrow(error, "Failed to open read stream"); + return error; +} + +int git_odb__error_notfound(const char *message, const git_oid *oid) +{ + if (oid != NULL) { + char oid_str[GIT_OID_HEXSZ + 1]; + git_oid_tostr(oid_str, sizeof(oid_str), oid); + giterr_set(GITERR_ODB, "Object not found - %s (%s)", message, oid_str); + } else + giterr_set(GITERR_ODB, "Object not found - %s", message); + + return GIT_ENOTFOUND; +} + +int git_odb__error_ambiguous(const char *message) +{ + giterr_set(GITERR_ODB, "Ambiguous SHA1 prefix - %s", message); + return GIT_EAMBIGUOUS; } diff --git a/src/odb.h b/src/odb.h index 2f84ebea4..263e4c30b 100644 --- a/src/odb.h +++ b/src/odb.h @@ -67,4 +67,14 @@ int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type); */ int git_odb__hashlink(git_oid *out, const char *path); +/* + * Generate a GIT_ENOTFOUND error for the ODB. + */ +int git_odb__error_notfound(const char *message, const git_oid *oid); + +/* + * Generate a GIT_EAMBIGUOUS error for the ODB. + */ +int git_odb__error_ambiguous(const char *message); + #endif diff --git a/src/odb_loose.c b/src/odb_loose.c index f5f6e35ac..989b03ab2 100644 --- a/src/odb_loose.c +++ b/src/odb_loose.c @@ -61,17 +61,17 @@ static int object_file_name(git_buf *name, const char *dir, const git_oid *id) git_buf_sets(name, dir); /* expand length for 40 hex sha1 chars + 2 * '/' + '\0' */ - if (git_buf_grow(name, name->size + GIT_OID_HEXSZ + 3) < GIT_SUCCESS) - return GIT_ENOMEM; + if (git_buf_grow(name, git_buf_len(name) + GIT_OID_HEXSZ + 3) < 0) + return -1; git_path_to_dir(name); /* loose object filename: aa/aaa... (41 bytes) */ - git_oid_pathfmt(name->ptr + name->size, id); + git_oid_pathfmt(name->ptr + git_buf_len(name), id); name->size += GIT_OID_HEXSZ + 1; name->ptr[name->size] = '\0'; - return GIT_SUCCESS; + return 0; } @@ -81,7 +81,7 @@ static size_t get_binary_object_header(obj_hdr *hdr, git_buf *obj) unsigned char *data = (unsigned char *)obj->ptr; size_t shift, size, used = 0; - if (obj->size == 0) + if (git_buf_len(obj) == 0) return 0; c = data[used++]; @@ -90,7 +90,7 @@ static size_t get_binary_object_header(obj_hdr *hdr, git_buf *obj) size = c & 15; shift = 4; while (c & 0x80) { - if (obj->size <= used) + if (git_buf_len(obj) <= used) return 0; if (sizeof(size_t) * 8 <= shift) return 0; @@ -182,7 +182,7 @@ static int start_inflate(z_stream *s, git_buf *obj, void *out, size_t len) int status; init_stream(s, out, len); - set_stream_input(s, obj->ptr, obj->size); + set_stream_input(s, obj->ptr, git_buf_len(obj)); if ((status = inflateInit(s)) < Z_OK) return status; @@ -199,10 +199,12 @@ static int finish_inflate(z_stream *s) inflateEnd(s); - if ((status != Z_STREAM_END) || (s->avail_in != 0)) - return git__throw(GIT_ERROR, "Failed to finish inflation. Stream aborted prematurely"); + if ((status != Z_STREAM_END) || (s->avail_in != 0)) { + giterr_set(GITERR_ZLIB, "Failed to finish ZLib inflation. Stream aborted prematurely"); + return -1; + } - return GIT_SUCCESS; + return 0; } static int is_zlib_compressed_data(unsigned char *data) @@ -226,21 +228,24 @@ static int inflate_buffer(void *in, size_t inlen, void *out, size_t outlen) zs.next_in = in; zs.avail_in = (uInt)inlen; - if (inflateInit(&zs) < Z_OK) - return git__throw(GIT_ERROR, "Failed to inflate buffer"); + if (inflateInit(&zs) < Z_OK) { + giterr_set(GITERR_ZLIB, "Failed to inflate buffer"); + return -1; + } while (status == Z_OK) status = inflate(&zs, Z_FINISH); inflateEnd(&zs); - if ((status != Z_STREAM_END) /*|| (zs.avail_in != 0) */) - return git__throw(GIT_ERROR, "Failed to inflate buffer. Stream aborted prematurely"); + if (status != Z_STREAM_END /* || zs.avail_in != 0 */ || + zs.total_out != outlen) + { + giterr_set(GITERR_ZLIB, "Failed to inflate buffer. Stream aborted prematurely"); + return -1; + } - if (zs.total_out != outlen) - return git__throw(GIT_ERROR, "Failed to inflate buffer. Stream aborted prematurely"); - - return GIT_SUCCESS; + return 0; } static void *inflate_tail(z_stream *s, void *hb, size_t used, obj_hdr *hdr) @@ -297,24 +302,23 @@ static int inflate_packlike_loose_disk_obj(git_rawobj *out, git_buf *obj) * read the object header, which is an (uncompressed) * binary encoding of the object type and size. */ - if ((used = get_binary_object_header(&hdr, obj)) == 0) - return git__throw(GIT_ERROR, "Failed to inflate loose object. Object has no header"); - - if (!git_object_typeisloose(hdr.type)) - return git__throw(GIT_ERROR, "Failed to inflate loose object. Wrong object type"); + if ((used = get_binary_object_header(&hdr, obj)) == 0 || + !git_object_typeisloose(hdr.type)) { + giterr_set(GITERR_ODB, "Failed to inflate loose object."); + return -1; + } /* * allocate a buffer and inflate the data into it */ buf = git__malloc(hdr.size + 1); - if (!buf) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(buf); in = ((unsigned char *)obj->ptr) + used; len = obj->size - used; - if (inflate_buffer(in, len, buf, hdr.size)) { + if (inflate_buffer(in, len, buf, hdr.size) < 0) { git__free(buf); - return git__throw(GIT_ERROR, "Failed to inflate loose object. Could not inflate buffer"); + return -1; } buf[hdr.size] = '\0'; @@ -322,7 +326,7 @@ static int inflate_packlike_loose_disk_obj(git_rawobj *out, git_buf *obj) out->len = hdr.size; out->type = hdr.type; - return GIT_SUCCESS; + return 0; } static int inflate_disk_obj(git_rawobj *out, git_buf *obj) @@ -342,28 +346,27 @@ static int inflate_disk_obj(git_rawobj *out, git_buf *obj) * inflate the initial part of the io buffer in order * to parse the object header (type and size). */ - if (start_inflate(&zs, obj, head, sizeof(head)) < Z_OK) - return git__throw(GIT_ERROR, "Failed to inflate disk object. Could not inflate buffer"); - - if ((used = get_object_header(&hdr, head)) == 0) - return git__throw(GIT_ERROR, "Failed to inflate disk object. Object has no header"); - - if (!git_object_typeisloose(hdr.type)) - return git__throw(GIT_ERROR, "Failed to inflate disk object. Wrong object type"); + if (start_inflate(&zs, obj, head, sizeof(head)) < Z_OK || + (used = get_object_header(&hdr, head)) == 0 || + !git_object_typeisloose(hdr.type)) + { + giterr_set(GITERR_ODB, "Failed to inflate disk object."); + return -1; + } /* * allocate a buffer and inflate the object data into it * (including the initial sequence in the head buffer). */ if ((buf = inflate_tail(&zs, head, used, &hdr)) == NULL) - return GIT_ENOMEM; + return -1; buf[hdr.size] = '\0'; out->data = buf; out->len = hdr.size; out->type = hdr.type; - return GIT_SUCCESS; + return 0; } @@ -387,25 +390,24 @@ static int read_loose(git_rawobj *out, git_buf *loc) assert(out && loc); - if ((error = git_buf_lasterror(loc)) < GIT_SUCCESS) - return error; + if (git_buf_oom(loc)) + return -1; out->data = NULL; out->len = 0; out->type = GIT_OBJ_BAD; - if (git_futils_readbuffer(&obj, loc->ptr) < 0) - return git__throw(GIT_ENOTFOUND, "Failed to read loose object. File not found"); + if (!(error = git_futils_readbuffer(&obj, loc->ptr))) + error = inflate_disk_obj(out, &obj); - error = inflate_disk_obj(out, &obj); git_buf_free(&obj); - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to read loose object"); + return error; } static int read_header_loose(git_rawobj *out, git_buf *loc) { - int error = GIT_SUCCESS, z_return = Z_ERRNO, read_bytes; + int error = 0, z_return = Z_ERRNO, read_bytes; git_file fd; z_stream zs; obj_hdr header_obj; @@ -413,49 +415,41 @@ static int read_header_loose(git_rawobj *out, git_buf *loc) assert(out && loc); - if ((error = git_buf_lasterror(loc)) < GIT_SUCCESS) - return error; + if (git_buf_oom(loc)) + return -1; out->data = NULL; - if ((fd = p_open(loc->ptr, O_RDONLY)) < 0) - return git__throw(GIT_ENOTFOUND, "Failed to read loose object header. File not found"); + if ((fd = git_futils_open_ro(loc->ptr)) < 0) + return fd; init_stream(&zs, inflated_buffer, sizeof(inflated_buffer)); - if (inflateInit(&zs) < Z_OK) { - error = GIT_EZLIB; - goto cleanup; - } + z_return = inflateInit(&zs); - do { - if ((read_bytes = read(fd, raw_buffer, sizeof(raw_buffer))) > 0) { + while (z_return == Z_OK) { + if ((read_bytes = p_read(fd, raw_buffer, sizeof(raw_buffer))) > 0) { set_stream_input(&zs, raw_buffer, read_bytes); z_return = inflate(&zs, 0); - } else { + } else z_return = Z_STREAM_END; - break; - } - } while (z_return == Z_OK); + } if ((z_return != Z_STREAM_END && z_return != Z_BUF_ERROR) || get_object_header(&header_obj, inflated_buffer) == 0 - || git_object_typeisloose(header_obj.type) == 0) { - error = GIT_EOBJCORRUPTED; - goto cleanup; + || git_object_typeisloose(header_obj.type) == 0) + { + giterr_set(GITERR_ZLIB, "Failed to read loose object header"); + error = -1; + } else { + out->len = header_obj.size; + out->type = header_obj.type; } - out->len = header_obj.size; - out->type = header_obj.type; - -cleanup: finish_inflate(&zs); p_close(fd); - if (error < GIT_SUCCESS) - return git__throw(error, "Failed to read loose object header. Header is corrupted"); - - return GIT_SUCCESS; + return error; } static int locate_object( @@ -465,8 +459,8 @@ static int locate_object( { int error = object_file_name(object_location, backend->objects_dir, oid); - if (error == GIT_SUCCESS) - error = git_path_exists(git_buf_cstr(object_location)); + if (!error && !git_path_exists(object_location->ptr)) + return GIT_ENOTFOUND; return error; } @@ -475,12 +469,12 @@ static int locate_object( static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) { loose_locate_object_state *sstate = (loose_locate_object_state *)state; - if (pathbuf->size - sstate->dir_len != GIT_OID_HEXSZ - 2) { + if (git_buf_len(pathbuf) - sstate->dir_len != GIT_OID_HEXSZ - 2) { /* Entry cannot be an object. Continue to next entry */ - return GIT_SUCCESS; + return 0; } - if (!git_path_exists(pathbuf->ptr) && git_path_isdir(pathbuf->ptr)) { + if (git_path_isdir(pathbuf->ptr) == false) { /* We are already in the directory matching the 2 first hex characters, * compare the first ncmp characters of the oids */ if (!memcmp(sstate->short_oid + 2, @@ -495,10 +489,11 @@ static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) { sstate->found++; } } - if (sstate->found > 1) - return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Ambiguous sha1 prefix within loose objects"); - return GIT_SUCCESS; + if (sstate->found > 1) + return git_odb__error_ambiguous("multiple matches in loose objects"); + + return 0; } /* Locate an object matching a given short oid */ @@ -515,60 +510,56 @@ static int locate_object_short_oid( int error; /* prealloc memory for OBJ_DIR/xx/ */ - if ((error = git_buf_grow(object_location, dir_len + 5)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to locate object from short oid"); + if (git_buf_grow(object_location, dir_len + 5) < 0) + return -1; git_buf_sets(object_location, objects_dir); git_path_to_dir(object_location); /* save adjusted position at end of dir so it can be restored later */ - dir_len = object_location->size; + dir_len = git_buf_len(object_location); /* Convert raw oid to hex formatted oid */ git_oid_fmt((char *)state.short_oid, short_oid); /* Explore OBJ_DIR/xx/ where xx is the beginning of hex formatted short oid */ - error = git_buf_printf(object_location, "%.2s/", state.short_oid); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to locate object from short oid"); + if (git_buf_printf(object_location, "%.2s/", state.short_oid) < 0) + return -1; /* Check that directory exists */ - if (git_path_exists(object_location->ptr) || - git_path_isdir(object_location->ptr)) - return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found"); + if (git_path_isdir(object_location->ptr) == false) + return git_odb__error_notfound("no matching loose object for prefix", short_oid); - state.dir_len = object_location->size; + state.dir_len = git_buf_len(object_location); state.short_oid_len = len; state.found = 0; /* Explore directory to find a unique object matching short_oid */ - error = git_path_direach(object_location, fn_locate_object_short_oid, &state); + error = git_path_direach( + object_location, fn_locate_object_short_oid, &state); if (error) - return git__rethrow(error, "Failed to locate object from short oid"); + return error; - if (!state.found) { - return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found"); - } + if (!state.found) + return git_odb__error_notfound("no matching loose object for prefix", short_oid); /* Convert obtained hex formatted oid to raw */ error = git_oid_fromstr(res_oid, (char *)state.res_oid); - if (error) { - return git__rethrow(error, "Failed to locate object from short oid"); - } + if (error) + return error; /* Update the location according to the oid obtained */ git_buf_truncate(object_location, dir_len); - error = git_buf_grow(object_location, dir_len + GIT_OID_HEXSZ + 2); - if (error) - return git__rethrow(error, "Failed to locate object from short oid"); + if (git_buf_grow(object_location, dir_len + GIT_OID_HEXSZ + 2) < 0) + return -1; git_oid_pathfmt(object_location->ptr + dir_len, res_oid); object_location->size += GIT_OID_HEXSZ + 1; object_location->ptr[object_location->size] = '\0'; - return GIT_SUCCESS; + return 0; } @@ -591,7 +582,7 @@ static int loose_backend__read_header(size_t *len_p, git_otype *type_p, git_odb_ { git_buf object_path = GIT_BUF_INIT; git_rawobj raw; - int error = GIT_SUCCESS; + int error; assert(backend && oid); @@ -599,8 +590,8 @@ static int loose_backend__read_header(size_t *len_p, git_otype *type_p, git_odb_ raw.type = GIT_OBJ_BAD; if (locate_object(&object_path, (loose_backend *)backend, oid) < 0) - error = git__throw(GIT_ENOTFOUND, "Failed to read loose backend header. Object not found"); - else if ((error = read_header_loose(&raw, &object_path)) == GIT_SUCCESS) { + error = git_odb__error_notfound("no matching loose object", oid); + else if ((error = read_header_loose(&raw, &object_path)) == 0) { *len_p = raw.len; *type_p = raw.type; } @@ -614,20 +605,17 @@ static int loose_backend__read(void **buffer_p, size_t *len_p, git_otype *type_p { git_buf object_path = GIT_BUF_INIT; git_rawobj raw; - int error = GIT_SUCCESS; + int error = 0; assert(backend && oid); if (locate_object(&object_path, (loose_backend *)backend, oid) < 0) - error = git__throw(GIT_ENOTFOUND, "Failed to read loose backend. Object not found"); - else if ((error = read_loose(&raw, &object_path)) == GIT_SUCCESS) { + error = git_odb__error_notfound("no matching loose object", oid); + else if ((error = read_loose(&raw, &object_path)) == 0) { *buffer_p = raw.data; *len_p = raw.len; *type_p = raw.type; } - else { - git__rethrow(error, "Failed to read loose backend"); - } git_buf_free(&object_path); @@ -643,16 +631,15 @@ static int loose_backend__read_prefix( const git_oid *short_oid, unsigned int len) { - int error = GIT_SUCCESS; + int error = 0; if (len < GIT_OID_MINPREFIXLEN) - return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to read loose " - "backend. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN); + error = git_odb__error_ambiguous("prefix length too short"); - if (len >= GIT_OID_HEXSZ) { + else if (len >= GIT_OID_HEXSZ) { /* We can fall back to regular read method */ error = loose_backend__read(buffer_p, len_p, type_p, backend, short_oid); - if (error == GIT_SUCCESS) + if (!error) git_oid_cpy(out_oid, short_oid); } else { git_buf object_path = GIT_BUF_INIT; @@ -661,11 +648,9 @@ static int loose_backend__read_prefix( assert(backend && short_oid); if ((error = locate_object_short_oid(&object_path, out_oid, - (loose_backend *)backend, short_oid, len)) < 0) - git__rethrow(error, "Failed to read loose backend"); - else if ((error = read_loose(&raw, &object_path)) < GIT_SUCCESS) - git__rethrow(error, "Failed to read loose backend"); - else { + (loose_backend *)backend, short_oid, len)) == 0 && + (error = read_loose(&raw, &object_path)) == 0) + { *buffer_p = raw.data; *len_p = raw.len; *type_p = raw.type; @@ -688,47 +673,33 @@ static int loose_backend__exists(git_odb_backend *backend, const git_oid *oid) git_buf_free(&object_path); - return (error == GIT_SUCCESS); + return !error; } static int loose_backend__stream_fwrite(git_oid *oid, git_odb_stream *_stream) { loose_writestream *stream = (loose_writestream *)_stream; loose_backend *backend = (loose_backend *)_stream->backend; - - int error; git_buf final_path = GIT_BUF_INIT; + int error = 0; - if ((error = git_filebuf_hash(oid, &stream->fbuf)) < GIT_SUCCESS) - goto cleanup; - - if ((error = object_file_name(&final_path, backend->objects_dir, oid)) < GIT_SUCCESS) - goto cleanup; - - if ((error = git_buf_lasterror(&final_path)) < GIT_SUCCESS) - goto cleanup; - - if ((error = git_futils_mkpath2file(final_path.ptr, GIT_OBJECT_DIR_MODE)) < GIT_SUCCESS) - goto cleanup; - + if (git_filebuf_hash(oid, &stream->fbuf) < 0 || + object_file_name(&final_path, backend->objects_dir, oid) < 0 || + git_futils_mkpath2file(final_path.ptr, GIT_OBJECT_DIR_MODE) < 0) + error = -1; /* * Don't try to add an existing object to the repository. This * is what git does and allows us to sidestep the fact that * we're not allowed to overwrite a read-only file on Windows. */ - if (git_path_exists(final_path.ptr) == GIT_SUCCESS) { + else if (git_path_exists(final_path.ptr) == true) git_filebuf_cleanup(&stream->fbuf); - goto cleanup; - } + else + error = git_filebuf_commit_at( + &stream->fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE); - error = git_filebuf_commit_at(&stream->fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE); - -cleanup: git_buf_free(&final_path); - if (error < GIT_SUCCESS) - git__rethrow(error, "Failed to write loose backend"); - return error; } @@ -752,22 +723,18 @@ static int format_object_header(char *hdr, size_t n, size_t obj_len, git_otype o int len = snprintf(hdr, n, "%s %"PRIuZ, type_str, obj_len); assert(len > 0); /* otherwise snprintf() is broken */ - assert(((size_t) len) < n); /* otherwise the caller is broken! */ + assert(((size_t)len) < n); /* otherwise the caller is broken! */ - if (len < 0 || ((size_t) len) >= n) - return git__throw(GIT_ERROR, "Failed to format object header. Length is out of bounds"); return len+1; } static int loose_backend__stream(git_odb_stream **stream_out, git_odb_backend *_backend, size_t length, git_otype type) { loose_backend *backend; - loose_writestream *stream; - + loose_writestream *stream = NULL; char hdr[64]; git_buf tmp_path = GIT_BUF_INIT; int hdrlen; - int error; assert(_backend); @@ -775,12 +742,9 @@ static int loose_backend__stream(git_odb_stream **stream_out, git_odb_backend *_ *stream_out = NULL; hdrlen = format_object_header(hdr, sizeof(hdr), length, type); - if (hdrlen < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Failed to create loose backend stream. Object is corrupted"); stream = git__calloc(1, sizeof(loose_writestream)); - if (stream == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(stream); stream->stream.backend = _backend; stream->stream.read = NULL; /* read only */ @@ -789,36 +753,26 @@ static int loose_backend__stream(git_odb_stream **stream_out, git_odb_backend *_ stream->stream.free = &loose_backend__stream_free; stream->stream.mode = GIT_STREAM_WRONLY; - error = git_buf_joinpath(&tmp_path, backend->objects_dir, "tmp_object"); - if (error < GIT_SUCCESS) - goto cleanup; - - error = git_filebuf_open(&stream->fbuf, tmp_path.ptr, - GIT_FILEBUF_HASH_CONTENTS | - GIT_FILEBUF_TEMPORARY | - (backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT)); - if (error < GIT_SUCCESS) - goto cleanup; - - error = stream->stream.write((git_odb_stream *)stream, hdr, hdrlen); - if (error < GIT_SUCCESS) - goto cleanup; - + if (git_buf_joinpath(&tmp_path, backend->objects_dir, "tmp_object") < 0 || + git_filebuf_open(&stream->fbuf, tmp_path.ptr, + GIT_FILEBUF_HASH_CONTENTS | + GIT_FILEBUF_TEMPORARY | + (backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT)) < 0 || + stream->stream.write((git_odb_stream *)stream, hdr, hdrlen) < 0) + { + git_filebuf_cleanup(&stream->fbuf); + git__free(stream); + stream = NULL; + } git_buf_free(&tmp_path); - *stream_out = (git_odb_stream *)stream; - return GIT_SUCCESS; -cleanup: - git_buf_free(&tmp_path); - git_filebuf_cleanup(&stream->fbuf); - git__free(stream); - return git__rethrow(error, "Failed to create loose backend stream"); + return !stream ? -1 : 0; } static int loose_backend__write(git_oid *oid, git_odb_backend *_backend, const void *data, size_t len, git_otype type) { - int error, header_len; + int error = 0, header_len; git_buf final_path = GIT_BUF_INIT; char header[64]; git_filebuf fbuf = GIT_FILEBUF_INIT; @@ -827,39 +781,29 @@ static int loose_backend__write(git_oid *oid, git_odb_backend *_backend, const v backend = (loose_backend *)_backend; /* prepare the header for the file */ + header_len = format_object_header(header, sizeof(header), len, type); + + if (git_buf_joinpath(&final_path, backend->objects_dir, "tmp_object") < 0 || + git_filebuf_open(&fbuf, final_path.ptr, + GIT_FILEBUF_HASH_CONTENTS | + GIT_FILEBUF_TEMPORARY | + (backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT)) < 0) { - header_len = format_object_header(header, sizeof(header), len, type); - if (header_len < GIT_SUCCESS) - return GIT_EOBJCORRUPTED; + error = -1; + goto cleanup; } - error = git_buf_joinpath(&final_path, backend->objects_dir, "tmp_object"); - if (error < GIT_SUCCESS) - goto cleanup; - - error = git_filebuf_open(&fbuf, final_path.ptr, - GIT_FILEBUF_HASH_CONTENTS | - GIT_FILEBUF_TEMPORARY | - (backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT)); - if (error < GIT_SUCCESS) - goto cleanup; - git_filebuf_write(&fbuf, header, header_len); git_filebuf_write(&fbuf, data, len); git_filebuf_hash(oid, &fbuf); - error = object_file_name(&final_path, backend->objects_dir, oid); - if (error < GIT_SUCCESS) - goto cleanup; - - error = git_futils_mkpath2file(final_path.ptr, GIT_OBJECT_DIR_MODE); - if (error < GIT_SUCCESS) - goto cleanup; - - error = git_filebuf_commit_at(&fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE); + if (object_file_name(&final_path, backend->objects_dir, oid) < 0 || + git_futils_mkpath2file(final_path.ptr, GIT_OBJECT_DIR_MODE) < 0 || + git_filebuf_commit_at(&fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE) < 0) + error = -1; cleanup: - if (error < GIT_SUCCESS) + if (error < 0) git_filebuf_cleanup(&fbuf); git_buf_free(&final_path); return error; @@ -884,14 +828,10 @@ int git_odb_backend_loose( loose_backend *backend; backend = git__calloc(1, sizeof(loose_backend)); - if (backend == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(backend); backend->objects_dir = git__strdup(objects_dir); - if (backend->objects_dir == NULL) { - git__free(backend); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(backend->objects_dir); if (compression_level < 0) compression_level = Z_BEST_SPEED; @@ -908,5 +848,5 @@ int git_odb_backend_loose( backend->parent.free = &loose_backend__free; *backend_out = (git_odb_backend *)backend; - return GIT_SUCCESS; + return 0; } diff --git a/src/odb_pack.c b/src/odb_pack.c index 249144a3a..458f288d9 100644 --- a/src/odb_pack.c +++ b/src/odb_pack.c @@ -137,19 +137,19 @@ static int packfile_load__cb(void *_data, git_buf *path); static int packfile_refresh_all(struct pack_backend *backend); static int pack_entry_find(struct git_pack_entry *e, - struct pack_backend *backend, const git_oid *oid); + struct pack_backend *backend, const git_oid *oid); /* Can find the offset of an object given * a prefix of an identifier. - * Throws GIT_EAMBIGUOUSOIDPREFIX if short oid - * is ambiguous. + * Sets GIT_EAMBIGUOUS if short oid is ambiguous. * This method assumes that len is between * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ. */ -static int pack_entry_find_prefix(struct git_pack_entry *e, - struct pack_backend *backend, - const git_oid *short_oid, - unsigned int len); +static int pack_entry_find_prefix( + struct git_pack_entry *e, + struct pack_backend *backend, + const git_oid *short_oid, + unsigned int len); @@ -212,30 +212,25 @@ static int packfile_load__cb(void *_data, git_buf *path) struct pack_backend *backend = (struct pack_backend *)_data; struct git_pack_file *pack; int error; - size_t i; + unsigned int i; if (git__suffixcmp(path->ptr, ".idx") != 0) - return GIT_SUCCESS; /* not an index */ + return 0; /* not an index */ for (i = 0; i < backend->packs.length; ++i) { struct git_pack_file *p = git_vector_get(&backend->packs, i); - if (memcmp(p->pack_name, path->ptr, path->size - strlen(".idx")) == 0) - return GIT_SUCCESS; + if (memcmp(p->pack_name, git_buf_cstr(path), git_buf_len(path) - strlen(".idx")) == 0) + return 0; } error = git_packfile_check(&pack, path->ptr); - if (error == GIT_ENOTFOUND) { + if (error == GIT_ENOTFOUND) /* ignore missing .pack file as git does */ - return GIT_SUCCESS; - } else if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to load packfile"); + return 0; + else if (error < 0) + return error; - if (git_vector_insert(&backend->packs, pack) < GIT_SUCCESS) { - git__free(pack); - return GIT_ENOMEM; - } - - return GIT_SUCCESS; + return git_vector_insert(&backend->packs, pack); } static int packfile_refresh_all(struct pack_backend *backend) @@ -244,10 +239,10 @@ static int packfile_refresh_all(struct pack_backend *backend) struct stat st; if (backend->pack_folder == NULL) - return GIT_SUCCESS; + return 0; if (p_stat(backend->pack_folder, &st) < 0 || !S_ISDIR(st.st_mode)) - return git__throw(GIT_ENOTFOUND, "Failed to refresh packfiles. Backend not found"); + return git_odb__error_notfound("failed to refresh packfiles", NULL); if (st.st_mtime != backend->pack_folder_mtime) { git_buf path = GIT_BUF_INIT; @@ -257,27 +252,28 @@ static int packfile_refresh_all(struct pack_backend *backend) error = git_path_direach(&path, packfile_load__cb, (void *)backend); git_buf_free(&path); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to refresh packfiles"); + + if (error < 0) + return error; git_vector_sort(&backend->packs); backend->pack_folder_mtime = st.st_mtime; } - return GIT_SUCCESS; + return 0; } static int pack_entry_find(struct git_pack_entry *e, struct pack_backend *backend, const git_oid *oid) { int error; - size_t i; + unsigned int i; - if ((error = packfile_refresh_all(backend)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to find pack entry"); + if ((error = packfile_refresh_all(backend)) < 0) + return error; if (backend->last_found && - git_pack_entry_find(e, backend->last_found, oid, GIT_OID_HEXSZ) == GIT_SUCCESS) - return GIT_SUCCESS; + git_pack_entry_find(e, backend->last_found, oid, GIT_OID_HEXSZ) == 0) + return 0; for (i = 0; i < backend->packs.length; ++i) { struct git_pack_file *p; @@ -286,13 +282,13 @@ static int pack_entry_find(struct git_pack_entry *e, struct pack_backend *backen if (p == backend->last_found) continue; - if (git_pack_entry_find(e, p, oid, GIT_OID_HEXSZ) == GIT_SUCCESS) { + if (git_pack_entry_find(e, p, oid, GIT_OID_HEXSZ) == 0) { backend->last_found = p; - return GIT_SUCCESS; + return 0; } } - return git__throw(GIT_ENOTFOUND, "Failed to find pack entry"); + return git_odb__error_notfound("failed to find pack entry", oid); } static int pack_entry_find_prefix( @@ -302,19 +298,18 @@ static int pack_entry_find_prefix( unsigned int len) { int error; - size_t i; + unsigned int i; unsigned found = 0; - if ((error = packfile_refresh_all(backend)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to find pack entry"); + if ((error = packfile_refresh_all(backend)) < 0) + return error; if (backend->last_found) { error = git_pack_entry_find(e, backend->last_found, short_oid, len); - if (error == GIT_EAMBIGUOUSOIDPREFIX) { - return git__rethrow(error, "Failed to find pack entry. Ambiguous sha1 prefix"); - } else if (error == GIT_SUCCESS) { + if (error == GIT_EAMBIGUOUS) + return error; + if (!error) found = 1; - } } for (i = 0; i < backend->packs.length; ++i) { @@ -325,24 +320,21 @@ static int pack_entry_find_prefix( continue; error = git_pack_entry_find(e, p, short_oid, len); - if (error == GIT_EAMBIGUOUSOIDPREFIX) { - return git__rethrow(error, "Failed to find pack entry. Ambiguous sha1 prefix"); - } else if (error == GIT_SUCCESS) { - found++; - if (found > 1) + if (error == GIT_EAMBIGUOUS) + return error; + if (!error) { + if (++found > 1) break; backend->last_found = p; } } - if (!found) { - return git__rethrow(GIT_ENOTFOUND, "Failed to find pack entry"); - } else if (found > 1) { - return git__rethrow(GIT_EAMBIGUOUSOIDPREFIX, "Failed to find pack entry. Ambiguous sha1 prefix"); - } else { - return GIT_SUCCESS; - } - + if (!found) + return git_odb__error_notfound("no matching pack entry for prefix", short_oid); + else if (found > 1) + return git_odb__error_ambiguous("found multiple pack entries"); + else + return 0; } @@ -374,17 +366,15 @@ static int pack_backend__read(void **buffer_p, size_t *len_p, git_otype *type_p, git_rawobj raw; int error; - if ((error = pack_entry_find(&e, (struct pack_backend *)backend, oid)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to read pack backend"); - - if ((error = git_packfile_unpack(&raw, e.p, &e.offset)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to read pack backend"); + if ((error = pack_entry_find(&e, (struct pack_backend *)backend, oid)) < 0 || + (error = git_packfile_unpack(&raw, e.p, &e.offset)) < 0) + return error; *buffer_p = raw.data; *len_p = raw.len; *type_p = raw.type; - return GIT_SUCCESS; + return 0; } static int pack_backend__read_prefix( @@ -396,46 +386,44 @@ static int pack_backend__read_prefix( const git_oid *short_oid, unsigned int len) { + int error = 0; + if (len < GIT_OID_MINPREFIXLEN) - return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to read pack backend. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN); + error = git_odb__error_ambiguous("prefix length too short"); - if (len >= GIT_OID_HEXSZ) { + else if (len >= GIT_OID_HEXSZ) { /* We can fall back to regular read method */ - int error = pack_backend__read(buffer_p, len_p, type_p, backend, short_oid); - if (error == GIT_SUCCESS) + error = pack_backend__read(buffer_p, len_p, type_p, backend, short_oid); + if (!error) git_oid_cpy(out_oid, short_oid); - - return error; } else { struct git_pack_entry e; git_rawobj raw; - int error; - if ((error = pack_entry_find_prefix(&e, (struct pack_backend *)backend, short_oid, len)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to read pack backend"); - - if ((error = git_packfile_unpack(&raw, e.p, &e.offset)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to read pack backend"); - - *buffer_p = raw.data; - *len_p = raw.len; - *type_p = raw.type; - git_oid_cpy(out_oid, &e.sha1); + if ((error = pack_entry_find_prefix( + &e, (struct pack_backend *)backend, short_oid, len)) == 0 && + (error = git_packfile_unpack(&raw, e.p, &e.offset)) == 0) + { + *buffer_p = raw.data; + *len_p = raw.len; + *type_p = raw.type; + git_oid_cpy(out_oid, &e.sha1); + } } - return GIT_SUCCESS; + return error; } static int pack_backend__exists(git_odb_backend *backend, const git_oid *oid) { struct git_pack_entry e; - return pack_entry_find(&e, (struct pack_backend *)backend, oid) == GIT_SUCCESS; + return pack_entry_find(&e, (struct pack_backend *)backend, oid) == 0; } static void pack_backend__free(git_odb_backend *_backend) { struct pack_backend *backend; - size_t i; + unsigned int i; assert(_backend); @@ -455,21 +443,18 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir) { struct pack_backend *backend = NULL; git_buf path = GIT_BUF_INIT; - int error = GIT_SUCCESS; backend = git__calloc(1, sizeof(struct pack_backend)); - if (backend == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(backend); - error = git_vector_init(&backend->packs, 8, packfile_sort__cb); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_vector_init(&backend->packs, 8, packfile_sort__cb) < 0 || + git_buf_joinpath(&path, objects_dir, "pack") < 0) + { + git__free(backend); + return -1; + } - error = git_buf_joinpath(&path, objects_dir, "pack"); - if (error < GIT_SUCCESS) - goto cleanup; - - if (git_path_isdir(git_buf_cstr(&path)) == GIT_SUCCESS) { + if (git_path_isdir(git_buf_cstr(&path)) == true) { backend->pack_folder = git_buf_detach(&path); backend->pack_folder_mtime = 0; } @@ -482,10 +467,7 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir) *backend_out = (git_odb_backend *)backend; -cleanup: - if (error < GIT_SUCCESS) - git__free(backend); git_buf_free(&path); - return error; + return 0; } diff --git a/src/oid.c b/src/oid.c index 34860138d..87756010b 100644 --- a/src/oid.c +++ b/src/oid.c @@ -13,13 +13,19 @@ static char to_hex[] = "0123456789abcdef"; +static int oid_error_invalid(const char *msg) +{ + giterr_set(GITERR_INVALID, "Unable to parse OID - %s", msg); + return -1; +} + int git_oid_fromstrn(git_oid *out, const char *str, size_t length) { size_t p; int v; if (length < 4) - return git__throw(GIT_ENOTOID, "Failed to generate sha1. Given string is too short"); + return oid_error_invalid("input too short"); if (length > GIT_OID_HEXSZ) length = GIT_OID_HEXSZ; @@ -29,7 +35,7 @@ int git_oid_fromstrn(git_oid *out, const char *str, size_t length) | git__fromhex(str[p + 1]); if (v < 0) - return git__throw(GIT_ENOTOID, "Failed to generate sha1. Given string is not a valid sha1 hash"); + return oid_error_invalid("contains invalid characters"); out->id[p / 2] = (unsigned char)v; } @@ -37,7 +43,7 @@ int git_oid_fromstrn(git_oid *out, const char *str, size_t length) if (length % 2) { v = (git__fromhex(str[p + 0]) << 4); if (v < 0) - return git__throw(GIT_ENOTOID, "Failed to generate sha1. Given string is not a valid sha1 hash"); + return oid_error_invalid("contains invalid characters"); out->id[p / 2] = (unsigned char)v; p += 2; @@ -45,7 +51,7 @@ int git_oid_fromstrn(git_oid *out, const char *str, size_t length) memset(out->id + p / 2, 0, (GIT_OID_HEXSZ - p) / 2); - return GIT_SUCCESS; + return 0; } int git_oid_fromstr(git_oid *out, const char *str) @@ -109,8 +115,9 @@ char *git_oid_tostr(char *out, size_t n, const git_oid *oid) return out; } -int git_oid__parse(git_oid *oid, const char **buffer_out, - const char *buffer_end, const char *header) +int git_oid__parse( + git_oid *oid, const char **buffer_out, + const char *buffer_end, const char *header) { const size_t sha_len = GIT_OID_HEXSZ; const size_t header_len = strlen(header); @@ -118,20 +125,20 @@ int git_oid__parse(git_oid *oid, const char **buffer_out, const char *buffer = *buffer_out; if (buffer + (header_len + sha_len + 1) > buffer_end) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse OID. Buffer too small"); + return -1; if (memcmp(buffer, header, header_len) != 0) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse OID. Buffer and header do not match"); + return -1; if (buffer[header_len + sha_len] != '\n') - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse OID. Buffer not terminated correctly"); + return -1; - if (git_oid_fromstr(oid, buffer + header_len) < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse OID. Failed to generate sha1"); + if (git_oid_fromstr(oid, buffer + header_len) < 0) + return -1; *buffer_out = buffer + (header_len + sha_len + 1); - return GIT_SUCCESS; + return 0; } void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid) @@ -182,12 +189,11 @@ int git_oid_ncmp(const git_oid *oid_a, const git_oid *oid_b, unsigned int len) int git_oid_streq(const git_oid *a, const char *str) { git_oid id; - int error; - if ((error = git_oid_fromstr(&id, str)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to convert '%s' to oid.", str); + if (git_oid_fromstr(&id, str) < 0) + return -1; - return git_oid_cmp(a, &id) == 0 ? GIT_SUCCESS : GIT_ERROR; + return git_oid_cmp(a, &id) == 0 ? 0 : -1; } int git_oid_iszero(const git_oid *oid_a) @@ -216,15 +222,14 @@ struct git_oid_shorten { static int resize_trie(git_oid_shorten *self, size_t new_size) { self->nodes = git__realloc(self->nodes, new_size * sizeof(trie_node)); - if (self->nodes == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(self->nodes); if (new_size > self->size) { memset(&self->nodes[self->size], 0x0, (new_size - self->size) * sizeof(trie_node)); } self->size = new_size; - return GIT_SUCCESS; + return 0; } static trie_node *push_leaf(git_oid_shorten *os, node_index idx, int push_at, const char *oid) @@ -233,7 +238,7 @@ static trie_node *push_leaf(git_oid_shorten *os, node_index idx, int push_at, co node_index idx_leaf; if (os->node_count >= os->size) { - if (resize_trie(os, os->size * 2) < GIT_SUCCESS) + if (resize_trie(os, os->size * 2) < 0) return NULL; } @@ -255,19 +260,19 @@ git_oid_shorten *git_oid_shorten_new(size_t min_length) { git_oid_shorten *os; - os = git__malloc(sizeof(git_oid_shorten)); + assert((size_t)((int)min_length) == min_length); + + os = git__calloc(1, sizeof(git_oid_shorten)); if (os == NULL) return NULL; - memset(os, 0x0, sizeof(git_oid_shorten)); - - if (resize_trie(os, 16) < GIT_SUCCESS) { + if (resize_trie(os, 16) < 0) { git__free(os); return NULL; } os->node_count = 1; - os->min_length = min_length; + os->min_length = (int)min_length; return os; } @@ -325,24 +330,27 @@ void git_oid_shorten_free(git_oid_shorten *os) */ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid) { - int i, is_leaf; + int i; + bool is_leaf; node_index idx; if (os->full) - return GIT_ENOMEM; + return -1; if (text_oid == NULL) return os->min_length; idx = 0; - is_leaf = 0; + is_leaf = false; for (i = 0; i < GIT_OID_HEXSZ; ++i) { int c = git__fromhex(text_oid[i]); trie_node *node; - if (c == -1) - return git__throw(GIT_ENOTOID, "Failed to shorten OID. Invalid hex value"); + if (c == -1) { + giterr_set(GITERR_INVALID, "Unable to shorten OID - invalid hex value"); + return -1; + } node = &os->nodes[idx]; @@ -353,22 +361,21 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid) node->tail = NULL; node = push_leaf(os, idx, git__fromhex(tail[0]), &tail[1]); - if (node == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(node); } if (node->children[c] == 0) { if (push_leaf(os, idx, c, &text_oid[i + 1]) == NULL) - return GIT_ENOMEM; + return -1; break; } idx = node->children[c]; - is_leaf = 0; + is_leaf = false; if (idx < 0) { node->children[c] = idx = -idx; - is_leaf = 1; + is_leaf = true; } } diff --git a/src/oidmap.h b/src/oidmap.h new file mode 100644 index 000000000..858268c92 --- /dev/null +++ b/src/oidmap.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 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_oidmap_h__ +#define INCLUDE_oidmap_h__ + +#include "common.h" +#include "git2/oid.h" + +#define kmalloc git__malloc +#define kcalloc git__calloc +#define krealloc git__realloc +#define kfree git__free +#include "khash.h" + +__KHASH_TYPE(oid, const git_oid *, void *); +typedef khash_t(oid) git_oidmap; + +GIT_INLINE(khint_t) hash_git_oid(const git_oid *oid) +{ + int i; + khint_t h = 0; + for (i = 0; i < 20; ++i) + h = (h << 5) - h + oid->id[i]; + 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 inline, const git_oid *, void *, 1, hash_git_oid, hash_git_oid_equal) + +#define git_oidmap_alloc() kh_init(oid) +#define git_oidmap_free(h) kh_destroy(oid,h), h = NULL + +#endif diff --git a/src/pack.c b/src/pack.c index 0d618324b..4a6bc6ae8 100644 --- a/src/pack.c +++ b/src/pack.c @@ -17,12 +17,12 @@ #include static int packfile_open(struct git_pack_file *p); -static off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n); +static git_off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n); int packfile_unpack_compressed( git_rawobj *obj, struct git_pack_file *p, git_mwindow **w_curs, - off_t *curpos, + git_off_t *curpos, size_t size, git_otype type); @@ -34,12 +34,18 @@ int packfile_unpack_compressed( * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ. */ static int pack_entry_find_offset( - off_t *offset_out, + git_off_t *offset_out, git_oid *found_oid, struct git_pack_file *p, const git_oid *short_oid, unsigned int len); +static int packfile_error(const char *message) +{ + giterr_set(GITERR_ODB, "Invalid pack file - %s", message); + return -1; +} + /*********************************************************** * * PACK INDEX METHODS @@ -58,40 +64,31 @@ static int pack_index_check(const char *path, struct git_pack_file *p) { struct git_pack_idx_header *hdr; uint32_t version, nr, i, *index; - void *idx_map; size_t idx_size; - struct stat st; - - /* TODO: properly open the file without access time */ - git_file fd = p_open(path, O_RDONLY /*| O_NOATIME */); - int error; - + /* TODO: properly open the file without access time using O_NOATIME */ + git_file fd = git_futils_open_ro(path); if (fd < 0) - return git__throw(GIT_EOSERR, "Failed to check index. File missing or corrupted"); + return fd; - if (p_fstat(fd, &st) < GIT_SUCCESS) { + if (p_fstat(fd, &st) < 0 || + !S_ISREG(st.st_mode) || + !git__is_sizet(st.st_size) || + (idx_size = (size_t)st.st_size) < 4 * 256 + 20 + 20) + { p_close(fd); - return git__throw(GIT_EOSERR, "Failed to check index. File appears to be corrupted"); - } - - if (!git__is_sizet(st.st_size)) - return GIT_ENOMEM; - - idx_size = (size_t)st.st_size; - - if (idx_size < 4 * 256 + 20 + 20) { - p_close(fd); - return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Object is corrupted"); + giterr_set(GITERR_OS, "Failed to check pack index."); + return -1; } error = git_futils_mmap_ro(&p->index_map, fd, 0, idx_size); + p_close(fd); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to check index"); + if (error < 0) + return error; hdr = idx_map = p->index_map.data; @@ -100,7 +97,7 @@ static int pack_index_check(const char *path, struct git_pack_file *p) if (version < 2 || version > 2) { git_futils_mmap_free(&p->index_map); - return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Unsupported index version"); + return packfile_error("unsupported index version"); } } else @@ -116,7 +113,7 @@ static int pack_index_check(const char *path, struct git_pack_file *p) uint32_t n = ntohl(index[i]); if (n < nr) { git_futils_mmap_free(&p->index_map); - return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Index is non-monotonic"); + return packfile_error("index is non-monotonic"); } nr = n; } @@ -131,7 +128,7 @@ static int pack_index_check(const char *path, struct git_pack_file *p) */ if (idx_size != 4*256 + nr * 24 + 20 + 20) { git_futils_mmap_free(&p->index_map); - return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Object is corrupted"); + return packfile_error("index is corrupted"); } } else if (version == 2) { /* @@ -155,39 +152,46 @@ static int pack_index_check(const char *path, struct git_pack_file *p) if (idx_size < min_size || idx_size > max_size) { git_futils_mmap_free(&p->index_map); - return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Wrong index size"); + return packfile_error("wrong index size"); } } p->index_version = version; p->num_objects = nr; - return GIT_SUCCESS; + return 0; } static int pack_index_open(struct git_pack_file *p) { char *idx_name; int error; + size_t name_len, offset; if (p->index_map.data) - return GIT_SUCCESS; + return 0; idx_name = git__strdup(p->pack_name); - strcpy(idx_name + strlen(idx_name) - strlen(".pack"), ".idx"); + GITERR_CHECK_ALLOC(idx_name); + + name_len = strlen(idx_name); + offset = name_len - strlen(".pack"); + assert(offset < name_len); /* make sure no underflow */ + + strncpy(idx_name + offset, ".idx", name_len - offset); error = pack_index_check(idx_name, p); git__free(idx_name); - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to open index"); + return error; } static unsigned char *pack_window_open( struct git_pack_file *p, git_mwindow **w_cursor, - off_t offset, + git_off_t offset, unsigned int *left) { - if (p->mwf.fd == -1 && packfile_open(p) < GIT_SUCCESS) + if (p->mwf.fd == -1 && packfile_open(p) < 0) return NULL; /* Since packfiles end in a hash of their content and it's @@ -201,7 +205,8 @@ static unsigned char *pack_window_open( return git_mwindow_open(&p->mwf, w_cursor, offset, 20, left); } -static unsigned long packfile_unpack_header1( +static int packfile_unpack_header1( + unsigned long *usedp, size_t *sizep, git_otype *type, const unsigned char *buf, @@ -216,8 +221,13 @@ static unsigned long packfile_unpack_header1( size = c & 15; shift = 4; while (c & 0x80) { - if (len <= used || bitsizeof(long) <= shift) - return 0; + if (len <= used) + return GIT_ESHORTBUFFER; + + if (bitsizeof(long) <= shift) { + *usedp = 0; + return -1; + } c = buf[used++]; size += (c & 0x7f) << shift; @@ -225,7 +235,8 @@ static unsigned long packfile_unpack_header1( } *sizep = (size_t)size; - return used; + *usedp = used; + return 0; } int git_packfile_unpack_header( @@ -233,11 +244,12 @@ int git_packfile_unpack_header( git_otype *type_p, git_mwindow_file *mwf, git_mwindow **w_curs, - off_t *curpos) + git_off_t *curpos) { unsigned char *base; unsigned int left; unsigned long used; + int ret; /* pack_window_open() assures us we have [base, base + 20) available * as a range that we can look at at. (Its actually the hash @@ -248,37 +260,39 @@ int git_packfile_unpack_header( // base = pack_window_open(p, w_curs, *curpos, &left); base = git_mwindow_open(mwf, w_curs, *curpos, 20, &left); if (base == NULL) - return GIT_ENOMEM; + return GIT_ESHORTBUFFER; - used = packfile_unpack_header1(size_p, type_p, base, left); - - if (used == 0) - return git__throw(GIT_EOBJCORRUPTED, "Header length is zero"); + ret = packfile_unpack_header1(&used, size_p, type_p, base, left); + git_mwindow_close(w_curs); + if (ret == GIT_ESHORTBUFFER) + return ret; + else if (ret < 0) + return packfile_error("header length is zero"); *curpos += used; - return GIT_SUCCESS; + return 0; } static int packfile_unpack_delta( git_rawobj *obj, struct git_pack_file *p, git_mwindow **w_curs, - off_t *curpos, + git_off_t *curpos, size_t delta_size, git_otype delta_type, - off_t obj_offset) + git_off_t obj_offset) { - off_t base_offset; + git_off_t base_offset; git_rawobj base, delta; int error; base_offset = get_delta_base(p, w_curs, curpos, delta_type, obj_offset); - if (base_offset == 0) - return git__throw(GIT_EOBJCORRUPTED, "Delta offset is zero"); - if (base_offset < 0) - return git__rethrow(base_offset, "Failed to get delta base"); - git_mwindow_close(w_curs); + if (base_offset == 0) + return packfile_error("delta offset is zero"); + if (base_offset < 0) /* must actually be an error code */ + return (int)base_offset; + error = git_packfile_unpack(&base, p, &base_offset); /* @@ -287,35 +301,35 @@ static int packfile_unpack_delta( * * We'll need to do this in order to support thin packs. */ - if (error < GIT_SUCCESS) - return git__rethrow(error, "Corrupted delta"); + if (error < 0) + return error; error = packfile_unpack_compressed(&delta, p, w_curs, curpos, delta_size, delta_type); - if (error < GIT_SUCCESS) { + git_mwindow_close(w_curs); + if (error < 0) { git__free(base.data); - return git__rethrow(error, "Corrupted delta"); + return error; } obj->type = base.type; - error = git__delta_apply(obj, - base.data, base.len, - delta.data, delta.len); + error = git__delta_apply(obj, base.data, base.len, delta.data, delta.len); git__free(base.data); git__free(delta.data); /* TODO: we might want to cache this shit. eventually */ //add_delta_base_cache(p, base_offset, base, base_size, *type); + return error; /* error set by git__delta_apply */ } int git_packfile_unpack( - git_rawobj *obj, - struct git_pack_file *p, - off_t *obj_offset) + git_rawobj *obj, + struct git_pack_file *p, + git_off_t *obj_offset) { git_mwindow *w_curs = NULL; - off_t curpos = *obj_offset; + git_off_t curpos = *obj_offset; int error; size_t size = 0; @@ -330,8 +344,10 @@ int git_packfile_unpack( obj->type = GIT_OBJ_BAD; error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to unpack packfile"); + git_mwindow_close(&w_curs); + + if (error < 0) + return error; switch (type) { case GIT_OBJ_OFS_DELTA: @@ -351,52 +367,70 @@ int git_packfile_unpack( break; default: - error = GIT_EOBJCORRUPTED; + error = packfile_error("invalid packfile type in header");; break; } - git_mwindow_close(&w_curs); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to unpack object"); - *obj_offset = curpos; - return GIT_SUCCESS; + return error; +} + +static void *use_git_alloc(void *opaq, unsigned int count, unsigned int size) +{ + GIT_UNUSED(opaq); + return git__calloc(count, size); +} + +static void use_git_free(void *opaq, void *ptr) +{ + GIT_UNUSED(opaq); + git__free(ptr); } int packfile_unpack_compressed( - git_rawobj *obj, - struct git_pack_file *p, - git_mwindow **w_curs, - off_t *curpos, - size_t size, - git_otype type) + git_rawobj *obj, + struct git_pack_file *p, + git_mwindow **w_curs, + git_off_t *curpos, + size_t size, + git_otype type) { int st; z_stream stream; unsigned char *buffer, *in; - buffer = git__malloc(size + 1); - memset(buffer, 0x0, size + 1); + buffer = git__calloc(1, size + 1); + GITERR_CHECK_ALLOC(buffer); memset(&stream, 0, sizeof(stream)); stream.next_out = buffer; stream.avail_out = (uInt)size + 1; + stream.zalloc = use_git_alloc; + stream.zfree = use_git_free; st = inflateInit(&stream); if (st != Z_OK) { git__free(buffer); - return git__throw(GIT_EZLIB, "Error in zlib"); + giterr_set(GITERR_ZLIB, "Failed to inflate packfile"); + + return -1; } do { in = pack_window_open(p, w_curs, *curpos, &stream.avail_in); stream.next_in = in; st = inflate(&stream, Z_FINISH); + git_mwindow_close(w_curs); if (!stream.avail_out) break; /* the payload is larger than it should be */ + if (st == Z_BUF_ERROR && in == NULL) { + inflateEnd(&stream); + git__free(buffer); + return GIT_ESHORTBUFFER; + } + *curpos += stream.next_in - in; } while (st == Z_OK || st == Z_BUF_ERROR); @@ -404,30 +438,36 @@ int packfile_unpack_compressed( if ((st != Z_STREAM_END) || stream.total_out != size) { git__free(buffer); - return git__throw(GIT_EZLIB, "Error in zlib"); + giterr_set(GITERR_ZLIB, "Failed to inflate packfile"); + return -1; } obj->type = type; obj->len = size; obj->data = buffer; - return GIT_SUCCESS; + return 0; } /* * curpos is where the data starts, delta_obj_offset is the where the * header starts */ -off_t get_delta_base( - struct git_pack_file *p, - git_mwindow **w_curs, - off_t *curpos, - git_otype type, - off_t delta_obj_offset) +git_off_t get_delta_base( + struct git_pack_file *p, + git_mwindow **w_curs, + git_off_t *curpos, + git_otype type, + git_off_t delta_obj_offset) { - unsigned char *base_info = pack_window_open(p, w_curs, *curpos, NULL); - off_t base_offset; + unsigned int left = 0; + unsigned char *base_info; + git_off_t base_offset; git_oid unused; + base_info = pack_window_open(p, w_curs, *curpos, &left); + /* Assumption: the only reason this would fail is because the file is too small */ + if (base_info == NULL) + return GIT_ESHORTBUFFER; /* pack_window_open() assured us we have [base_info, base_info + 20) * as a range that we can look at without walking off the * end of the mapped window. Its actually the hash size @@ -439,6 +479,8 @@ off_t get_delta_base( unsigned char c = base_info[used++]; base_offset = c & 127; while (c & 128) { + if (left <= used) + return GIT_ESHORTBUFFER; base_offset += 1; if (!base_offset || MSB(base_offset, 7)) return 0; /* overflow */ @@ -463,8 +505,8 @@ off_t get_delta_base( } } /* The base entry _must_ be in the same pack */ - if (pack_entry_find_offset(&base_offset, &unused, p, (git_oid *)base_info, GIT_OID_HEXSZ) < GIT_SUCCESS) - return git__rethrow(GIT_EPACKCORRUPTED, "Base entry delta is not in the same pack"); + if (pack_entry_find_offset(&base_offset, &unused, p, (git_oid *)base_info, GIT_OID_HEXSZ) < 0) + return packfile_error("base entry delta is not in the same pack"); *curpos += 20; } else return 0; @@ -478,11 +520,11 @@ off_t get_delta_base( * ***********************************************************/ -static struct git_pack_file *packfile_alloc(int extra) +static struct git_pack_file *packfile_alloc(size_t extra) { - struct git_pack_file *p = git__malloc(sizeof(*p) + extra); - memset(p, 0, sizeof(*p)); - p->mwf.fd = -1; + struct git_pack_file *p = git__calloc(1, sizeof(*p) + extra); + if (p != NULL) + p->mwf.fd = -1; return p; } @@ -510,24 +552,25 @@ static int packfile_open(struct git_pack_file *p) git_oid sha1; unsigned char *idx_sha1; - if (!p->index_map.data && pack_index_open(p) < GIT_SUCCESS) - return git__throw(GIT_ENOTFOUND, "Failed to open packfile. File not found"); + assert(p->index_map.data); + + if (!p->index_map.data && pack_index_open(p) < 0) + return git_odb__error_notfound("failed to open packfile", NULL); /* TODO: open with noatime */ - p->mwf.fd = p_open(p->pack_name, O_RDONLY); - if (p->mwf.fd < 0 || p_fstat(p->mwf.fd, &st) < GIT_SUCCESS) - return git__throw(GIT_EOSERR, "Failed to open packfile. File appears to be corrupted"); + p->mwf.fd = git_futils_open_ro(p->pack_name); + if (p->mwf.fd < 0) + return p->mwf.fd; - if (git_mwindow_file_register(&p->mwf) < GIT_SUCCESS) { - p_close(p->mwf.fd); - return git__throw(GIT_ERROR, "Failed to register packfile windows"); - } + if (p_fstat(p->mwf.fd, &st) < 0 || + git_mwindow_file_register(&p->mwf) < 0) + goto cleanup; /* If we created the struct before we had the pack we lack size. */ if (!p->mwf.size) { if (!S_ISREG(st.st_mode)) goto cleanup; - p->mwf.size = (off_t)st.st_size; + p->mwf.size = (git_off_t)st.st_size; } else if (p->mwf.size != st.st_size) goto cleanup; @@ -537,44 +580,35 @@ static int packfile_open(struct git_pack_file *p) */ fd_flag = fcntl(p->mwf.fd, F_GETFD, 0); if (fd_flag < 0) - return error("cannot determine file descriptor flags"); + goto cleanup; fd_flag |= FD_CLOEXEC; if (fcntl(p->pack_fd, F_SETFD, fd_flag) == -1) - return GIT_EOSERR; + goto cleanup; #endif /* Verify we recognize this pack file format. */ - if (p_read(p->mwf.fd, &hdr, sizeof(hdr)) < GIT_SUCCESS) - goto cleanup; - - if (hdr.hdr_signature != htonl(PACK_SIGNATURE)) - goto cleanup; - - if (!pack_version_ok(hdr.hdr_version)) + if (p_read(p->mwf.fd, &hdr, sizeof(hdr)) < 0 || + hdr.hdr_signature != htonl(PACK_SIGNATURE) || + !pack_version_ok(hdr.hdr_version)) goto cleanup; /* Verify the pack matches its index. */ - if (p->num_objects != ntohl(hdr.hdr_entries)) - goto cleanup; - - if (p_lseek(p->mwf.fd, p->mwf.size - GIT_OID_RAWSZ, SEEK_SET) == -1) - goto cleanup; - - if (p_read(p->mwf.fd, sha1.id, GIT_OID_RAWSZ) < GIT_SUCCESS) + if (p->num_objects != ntohl(hdr.hdr_entries) || + p_lseek(p->mwf.fd, p->mwf.size - GIT_OID_RAWSZ, SEEK_SET) == -1 || + p_read(p->mwf.fd, sha1.id, GIT_OID_RAWSZ) < 0) goto cleanup; idx_sha1 = ((unsigned char *)p->index_map.data) + p->index_map.len - 40; - if (git_oid_cmp(&sha1, (git_oid *)idx_sha1) != 0) - goto cleanup; - - return GIT_SUCCESS; + if (git_oid_cmp(&sha1, (git_oid *)idx_sha1) == 0) + return 0; cleanup: + giterr_set(GITERR_OS, "Invalid packfile '%s'", p->pack_name); p_close(p->mwf.fd); p->mwf.fd = -1; - return git__throw(GIT_EPACKCORRUPTED, "Failed to open packfile. Pack is corrupted"); + return -1; } int git_packfile_check(struct git_pack_file **pack_out, const char *path) @@ -586,6 +620,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path) *pack_out = NULL; path_len = strlen(path); p = packfile_alloc(path_len + 2); + GITERR_CHECK_ALLOC(p); /* * Make sure a corresponding .pack file exists and that @@ -594,19 +629,19 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path) path_len -= strlen(".idx"); if (path_len < 1) { git__free(p); - return git__throw(GIT_ENOTFOUND, "Failed to check packfile. Wrong path name"); + return git_odb__error_notfound("invalid packfile path", NULL); } memcpy(p->pack_name, path, path_len); strcpy(p->pack_name + path_len, ".keep"); - if (git_path_exists(p->pack_name) == GIT_SUCCESS) + if (git_path_exists(p->pack_name) == true) p->pack_keep = 1; strcpy(p->pack_name + path_len, ".pack"); - if (p_stat(p->pack_name, &st) < GIT_SUCCESS || !S_ISREG(st.st_mode)) { + if (p_stat(p->pack_name, &st) < 0 || !S_ISREG(st.st_mode)) { git__free(p); - return git__throw(GIT_ENOTFOUND, "Failed to check packfile. File not found"); + return git_odb__error_notfound("packfile not found", NULL); } /* ok, it looks sane as far as we can check without @@ -618,11 +653,12 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path) /* see if we can parse the sha1 oid in the packfile name */ if (path_len < 40 || - git_oid_fromstr(&p->sha1, path + path_len - GIT_OID_HEXSZ) < GIT_SUCCESS) + git_oid_fromstr(&p->sha1, path + path_len - GIT_OID_HEXSZ) < 0) memset(&p->sha1, 0x0, GIT_OID_RAWSZ); *pack_out = p; - return GIT_SUCCESS; + + return 0; } /*********************************************************** @@ -631,7 +667,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path) * ***********************************************************/ -static off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n) +static git_off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n) { const unsigned char *index = p->index_map.data; index += 4 * 256; @@ -650,11 +686,11 @@ static off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n) } static int pack_entry_find_offset( - off_t *offset_out, - git_oid *found_oid, - struct git_pack_file *p, - const git_oid *short_oid, - unsigned int len) + git_off_t *offset_out, + git_oid *found_oid, + struct git_pack_file *p, + const git_oid *short_oid, + unsigned int len) { const uint32_t *level1_ofs = p->index_map.data; const unsigned char *index = p->index_map.data; @@ -667,8 +703,8 @@ static int pack_entry_find_offset( if (index == NULL) { int error; - if ((error = pack_index_open(p)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to find offset for pack entry"); + if ((error = pack_index_open(p)) < 0) + return error; assert(p->index_map.data); @@ -711,9 +747,8 @@ static int pack_entry_find_offset( if (pos < (int)p->num_objects) { current = index + pos * stride; - if (!git_oid_ncmp(short_oid, (const git_oid *)current, len)) { + if (!git_oid_ncmp(short_oid, (const git_oid *)current, len)) found = 1; - } } } @@ -726,22 +761,22 @@ static int pack_entry_find_offset( } } - if (!found) { - return git__throw(GIT_ENOTFOUND, "Failed to find offset for pack entry. Entry not found"); - } else if (found > 1) { - return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to find offset for pack entry. Ambiguous sha1 prefix within pack"); - } else { - *offset_out = nth_packed_object_offset(p, pos); - git_oid_fromraw(found_oid, current); + if (!found) + return git_odb__error_notfound("failed to find offset for pack entry", short_oid); + if (found > 1) + return git_odb__error_ambiguous("found multiple offsets for pack entry"); + *offset_out = nth_packed_object_offset(p, pos); + git_oid_fromraw(found_oid, current); #ifdef INDEX_DEBUG_LOOKUP + { unsigned char hex_sha1[GIT_OID_HEXSZ + 1]; git_oid_fmt(hex_sha1, found_oid); hex_sha1[GIT_OID_HEXSZ] = '\0'; printf("found lo=%d %s\n", lo, hex_sha1); -#endif - return GIT_SUCCESS; } +#endif + return 0; } int git_pack_entry_find( @@ -750,7 +785,7 @@ int git_pack_entry_find( const git_oid *short_oid, unsigned int len) { - off_t offset; + git_off_t offset; git_oid found_oid; int error; @@ -760,22 +795,22 @@ int git_pack_entry_find( unsigned i; for (i = 0; i < p->num_bad_objects; i++) if (git_oid_cmp(short_oid, &p->bad_object_sha1[i]) == 0) - return git__throw(GIT_ERROR, "Failed to find pack entry. Bad object found"); + return packfile_error("bad object found in packfile"); } error = pack_entry_find_offset(&offset, &found_oid, p, short_oid, len); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to find pack entry. Couldn't find offset"); + if (error < 0) + return error; /* we found a unique entry in the index; * make sure the packfile backing the index * still exists on disk */ - if (p->mwf.fd == -1 && packfile_open(p) < GIT_SUCCESS) - return git__throw(GIT_EOSERR, "Failed to find pack entry. Packfile doesn't exist on disk"); + if (p->mwf.fd == -1 && (error = packfile_open(p)) < 0) + return error; e->offset = offset; e->p = p; git_oid_cpy(&e->sha1, &found_oid); - return GIT_SUCCESS; + return 0; } diff --git a/src/pack.h b/src/pack.h index 590297847..cd7a4d2e1 100644 --- a/src/pack.h +++ b/src/pack.h @@ -70,7 +70,7 @@ struct git_pack_file { }; struct git_pack_entry { - off_t offset; + git_off_t offset; git_oid sha1; struct git_pack_file *p; }; @@ -80,13 +80,20 @@ int git_packfile_unpack_header( git_otype *type_p, git_mwindow_file *mwf, git_mwindow **w_curs, - off_t *curpos); + git_off_t *curpos); -int git_packfile_unpack(git_rawobj *obj, struct git_pack_file *p, off_t *obj_offset); +int git_packfile_unpack(git_rawobj *obj, struct git_pack_file *p, git_off_t *obj_offset); +int packfile_unpack_compressed( + git_rawobj *obj, + struct git_pack_file *p, + git_mwindow **w_curs, + git_off_t *curpos, + size_t size, + git_otype type); -off_t get_delta_base(struct git_pack_file *p, git_mwindow **w_curs, - off_t *curpos, git_otype type, - off_t delta_obj_offset); +git_off_t get_delta_base(struct git_pack_file *p, git_mwindow **w_curs, + git_off_t *curpos, git_otype type, + git_off_t delta_obj_offset); void packfile_free(struct git_pack_file *p); int git_packfile_check(struct git_pack_file **pack_out, const char *path); diff --git a/src/path.c b/src/path.c index 2e6a1eb40..703f43af1 100644 --- a/src/path.c +++ b/src/path.c @@ -50,16 +50,14 @@ int git_path_basename_r(git_buf *buffer, const char *path) while (startp > path && *(startp - 1) != '/') startp--; - len = endp - startp +1; + /* Cast is safe because max path < max int */ + len = (int)(endp - startp + 1); Exit: result = len; - if (buffer != NULL) { - if (git_buf_set(buffer, startp, len) < GIT_SUCCESS) - return git__rethrow(git_buf_lasterror(buffer), - "Could not get basename of '%s'", path); - } + if (buffer != NULL && git_buf_set(buffer, startp, len) < 0) + return -1; return result; } @@ -100,7 +98,8 @@ int git_path_dirname_r(git_buf *buffer, const char *path) endp--; } while (endp > path && *endp == '/'); - len = endp - path +1; + /* Cast is safe because max path < max int */ + len = (int)(endp - path + 1); #ifdef GIT_WIN32 /* Mimic unix behavior where '/.git' returns '/': 'C:/.git' will return @@ -115,11 +114,8 @@ int git_path_dirname_r(git_buf *buffer, const char *path) Exit: result = len; - if (buffer != NULL) { - if (git_buf_set(buffer, path, len) < GIT_SUCCESS) - return git__rethrow(git_buf_lasterror(buffer), - "Could not get dirname of '%s'", path); - } + if (buffer != NULL && git_buf_set(buffer, path, len) < 0) + return -1; return result; } @@ -153,7 +149,7 @@ char *git_path_basename(const char *path) const char *git_path_topdir(const char *path) { size_t len; - int i; + ssize_t i; assert(path); len = strlen(path); @@ -161,7 +157,7 @@ const char *git_path_topdir(const char *path) if (!len || path[len - 1] != '/') return NULL; - for (i = len - 2; i >= 0; --i) + for (i = (ssize_t)len - 2; i >= 0; --i) if (path[i] == '/') break; @@ -176,54 +172,61 @@ int git_path_root(const char *path) /* Does the root of the path look like a windows drive ? */ if (isalpha(path[0]) && (path[1] == ':')) offset += 2; + + /* Are we dealing with a windows network path? */ + else if ((path[0] == '/' && path[1] == '/') || + (path[0] == '\\' && path[1] == '\\')) + { + offset += 2; + + /* Skip the computer name segment */ + while (path[offset] && path[offset] != '/' && path[offset] != '\\') + offset++; + } #endif - if (*(path + offset) == '/') + if (path[offset] == '/' || path[offset] == '\\') return offset; - return -1; /* Not a real error. Rather a signal than the path is not rooted */ + return -1; /* Not a real error - signals that path is not rooted */ } int git_path_prettify(git_buf *path_out, const char *path, const char *base) { - int error = GIT_SUCCESS; char buf[GIT_PATH_MAX]; - git_buf_clear(path_out); + assert(path && path_out); /* construct path if needed */ if (base != NULL && git_path_root(path) < 0) { - if ((error = git_buf_joinpath(path_out, base, path)) < GIT_SUCCESS) - return error; + if (git_buf_joinpath(path_out, base, path) < 0) + return -1; path = path_out->ptr; } - if (path == NULL || p_realpath(path, buf) == NULL) - error = GIT_EOSERR; - else - error = git_buf_sets(path_out, buf); + if (p_realpath(path, buf) == NULL) { + giterr_set(GITERR_OS, "Failed to resolve path '%s'", path); + git_buf_clear(path_out); + return (errno == ENOENT) ? GIT_ENOTFOUND : -1; + } - return error; + return git_buf_sets(path_out, buf); } int git_path_prettify_dir(git_buf *path_out, const char *path, const char *base) { int error = git_path_prettify(path_out, path, base); - - if (error == GIT_SUCCESS) - error = git_path_to_dir(path_out); - - return error; + return (error < 0) ? error : git_path_to_dir(path_out); } int git_path_to_dir(git_buf *path) { if (path->asize > 0 && - path->size > 0 && - path->ptr[path->size - 1] != '/') + git_buf_len(path) > 0 && + path->ptr[git_buf_len(path) - 1] != '/') git_buf_putc(path, '/'); - return git_buf_lasterror(path); + return git_buf_oom(path) ? -1 : 0; } void git_path_string_to_dir(char* path, size_t size) @@ -238,10 +241,10 @@ void git_path_string_to_dir(char* path, size_t size) int git__percent_decode(git_buf *decoded_out, const char *input) { - int len, hi, lo, i, error = GIT_SUCCESS; + int len, hi, lo, i; assert(decoded_out && input); - len = strlen(input); + len = (int)strlen(input); git_buf_clear(decoded_out); for(i = 0; i < len; i++) @@ -264,39 +267,40 @@ int git__percent_decode(git_buf *decoded_out, const char *input) i += 2; append: - error = git_buf_putc(decoded_out, c); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to percent decode '%s'.", input); + if (git_buf_putc(decoded_out, c) < 0) + return -1; } - return error; + return 0; +} + +static int error_invalid_local_file_uri(const char *uri) +{ + giterr_set(GITERR_CONFIG, "'%s' is not a valid local file URI", uri); + return -1; } int git_path_fromurl(git_buf *local_path_out, const char *file_url) { - int error = GIT_SUCCESS, offset = 0, len; + int offset = 0, len; assert(local_path_out && file_url); if (git__prefixcmp(file_url, "file://") != 0) - return git__throw(GIT_EINVALIDPATH, - "Parsing of '%s' failed. A file Uri is expected (ie. with 'file://' scheme).", - file_url); + return error_invalid_local_file_uri(file_url); offset += 7; - len = strlen(file_url); + len = (int)strlen(file_url); if (offset < len && file_url[offset] == '/') offset++; else if (offset < len && git__prefixcmp(file_url + offset, "localhost/") == 0) offset += 10; else - return git__throw(GIT_EINVALIDPATH, - "Parsing of '%s' failed. A local file Uri is expected.", file_url); + return error_invalid_local_file_uri(file_url); if (offset >= len || file_url[offset] == '/') - return git__throw(GIT_EINVALIDPATH, - "Parsing of '%s' failed. Invalid file Uri format.", file_url); + return error_invalid_local_file_uri(file_url); #ifndef _MSC_VER offset--; /* A *nix absolute path starts with a forward slash */ @@ -304,11 +308,7 @@ int git_path_fromurl(git_buf *local_path_out, const char *file_url) git_buf_clear(local_path_out); - error = git__percent_decode(local_path_out, file_url + offset); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Parsing of '%s' failed.", file_url); - - return error; + return git__percent_decode(local_path_out, file_url + offset); } int git_path_walk_up( @@ -317,7 +317,7 @@ int git_path_walk_up( int (*cb)(void *data, git_buf *), void *data) { - int error = GIT_SUCCESS; + int error = 0; git_buf iter; ssize_t stop = 0, scan; char oldc = '\0'; @@ -325,19 +325,19 @@ int git_path_walk_up( assert(path && cb); if (ceiling != NULL) { - if (git__prefixcmp(path->ptr, ceiling) == GIT_SUCCESS) + if (git__prefixcmp(path->ptr, ceiling) == 0) stop = (ssize_t)strlen(ceiling); else - stop = path->size; + stop = git_buf_len(path); } - scan = path->size; + scan = git_buf_len(path); iter.ptr = path->ptr; - iter.size = path->size; + iter.size = git_buf_len(path); iter.asize = path->asize; while (scan >= stop) { - if ((error = cb(data, &iter)) < GIT_SUCCESS) + if ((error = cb(data, &iter)) < 0) break; iter.ptr[scan] = oldc; scan = git_buf_rfind_next(&iter, '/'); @@ -355,116 +355,123 @@ int git_path_walk_up( return error; } -int git_path_exists(const char *path) +bool git_path_exists(const char *path) { assert(path); - return p_access(path, F_OK); + return p_access(path, F_OK) == 0; } -int git_path_isdir(const char *path) +bool git_path_isdir(const char *path) { struct stat st; - if (p_stat(path, &st) < GIT_SUCCESS) - return GIT_ERROR; + if (p_stat(path, &st) < 0) + return false; - return S_ISDIR(st.st_mode) ? GIT_SUCCESS : GIT_ERROR; + return S_ISDIR(st.st_mode) != 0; } -int git_path_isfile(const char *path) +bool git_path_isfile(const char *path) { struct stat st; - int stat_error; assert(path); - stat_error = p_stat(path, &st); + if (p_stat(path, &st) < 0) + return false; - if (stat_error < GIT_SUCCESS) - return -1; - - if (!S_ISREG(st.st_mode)) - return -1; - - return 0; + return S_ISREG(st.st_mode) != 0; } -static int _check_dir_contents( +int git_path_lstat(const char *path, struct stat *st) +{ + int err = 0; + + if (p_lstat(path, st) < 0) { + err = (errno == ENOENT) ? GIT_ENOTFOUND : -1; + giterr_set(GITERR_OS, "Failed to stat file '%s'", path); + } + + return err; +} + +static bool _check_dir_contents( git_buf *dir, const char *sub, - int (*predicate)(const char *)) + bool (*predicate)(const char *)) { - int error = GIT_SUCCESS; - size_t dir_size = dir->size; + bool result; + size_t dir_size = git_buf_len(dir); size_t sub_size = strlen(sub); - /* separate allocation and join, so we can always leave git_buf valid */ - if ((error = git_buf_try_grow(dir, dir_size + sub_size + 2)) < GIT_SUCCESS) - return error; + /* leave base valid even if we could not make space for subdir */ + if (git_buf_try_grow(dir, dir_size + sub_size + 2) < 0) + return false; + + /* save excursion */ git_buf_joinpath(dir, dir->ptr, sub); - error = (*predicate)(dir->ptr); + result = predicate(dir->ptr); /* restore path */ git_buf_truncate(dir, dir_size); - - return error; + return result; } -int git_path_contains(git_buf *dir, const char *item) +bool git_path_contains(git_buf *dir, const char *item) { return _check_dir_contents(dir, item, &git_path_exists); } -int git_path_contains_dir(git_buf *base, const char *subdir) +bool git_path_contains_dir(git_buf *base, const char *subdir) { return _check_dir_contents(base, subdir, &git_path_isdir); } -int git_path_contains_file(git_buf *base, const char *file) +bool git_path_contains_file(git_buf *base, const char *file) { return _check_dir_contents(base, file, &git_path_isfile); } int git_path_find_dir(git_buf *dir, const char *path, const char *base) { - int error = GIT_SUCCESS; + int error; if (base != NULL && git_path_root(path) < 0) error = git_buf_joinpath(dir, base, path); else error = git_buf_sets(dir, path); - if (error == GIT_SUCCESS) { + if (!error) { char buf[GIT_PATH_MAX]; if (p_realpath(dir->ptr, buf) != NULL) error = git_buf_sets(dir, buf); } /* call dirname if this is not a directory */ - if (error == GIT_SUCCESS && git_path_isdir(dir->ptr) != GIT_SUCCESS) - if (git_path_dirname_r(dir, dir->ptr) < GIT_SUCCESS) - error = git_buf_lasterror(dir); + if (!error && git_path_isdir(dir->ptr) == false) + error = git_path_dirname_r(dir, dir->ptr); - if (error == GIT_SUCCESS) + if (!error) error = git_path_to_dir(dir); return error; } -int git_path_cmp(const char *name1, int len1, int isdir1, - const char *name2, int len2, int isdir2) +int git_path_cmp( + const char *name1, size_t len1, int isdir1, + const char *name2, size_t len2, int isdir2) { - int len = len1 < len2 ? len1 : len2; + size_t len = len1 < len2 ? len1 : len2; int cmp; cmp = memcmp(name1, name2, len); if (cmp) return cmp; if (len1 < len2) - return ((!isdir1 && !isdir2) ? -1 : - (isdir1 ? '/' - name2[len1] : name2[len1] - '/')); + return (!isdir1 && !isdir2) ? -1 : + (isdir1 ? '/' - name2[len1] : name2[len1] - '/'); if (len1 > len2) - return ((!isdir1 && !isdir2) ? 1 : - (isdir2 ? name1[len2] - '/' : '/' - name1[len2])); + return (!isdir1 && !isdir2) ? 1 : + (isdir2 ? name1[len2] - '/' : '/' - name1[len2]); return 0; } @@ -485,13 +492,15 @@ int git_path_direach( DIR *dir; struct dirent de_buf, *de; - if (git_path_to_dir(path) < GIT_SUCCESS) - return git_buf_lasterror(path); + if (git_path_to_dir(path) < 0) + return -1; - wd_len = path->size; - dir = opendir(path->ptr); - if (!dir) - return git__throw(GIT_EOSERR, "Failed to process `%s` tree structure. An error occured while opening the directory", path->ptr); + wd_len = git_buf_len(path); + + if ((dir = opendir(path->ptr)) == NULL) { + giterr_set(GITERR_OS, "Failed to open directory '%s'", path->ptr); + return -1; + } while (p_readdir_r(dir, &de_buf, &de) == 0 && de != NULL) { int result; @@ -499,21 +508,21 @@ int git_path_direach( if (is_dot_or_dotdot(de->d_name)) continue; - if (git_buf_puts(path, de->d_name) < GIT_SUCCESS) - return git_buf_lasterror(path); + if (git_buf_puts(path, de->d_name) < 0) + return -1; result = fn(arg, path); git_buf_truncate(path, wd_len); /* restore path */ - if (result != GIT_SUCCESS) { + if (result < 0) { closedir(dir); - return result; /* The callee is reponsible for setting the correct error message */ + return -1; } } closedir(dir); - return GIT_SUCCESS; + return 0; } int git_path_dirload( @@ -531,9 +540,10 @@ int git_path_dirload( path_len = strlen(path); assert(path_len > 0 && path_len >= prefix_len); - if ((dir = opendir(path)) == NULL) - return git__throw(GIT_EOSERR, "Failed to process `%s` tree structure." - " An error occured while opening the directory", path); + if ((dir = opendir(path)) == NULL) { + giterr_set(GITERR_OS, "Failed to open directory '%s'", path); + return -1; + } path += prefix_len; path_len -= prefix_len; @@ -550,8 +560,7 @@ int git_path_dirload( entry_path = git__malloc( path_len + need_slash + entry_len + 1 + alloc_extra); - if (entry_path == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(entry_path); if (path_len) memcpy(entry_path, path, path_len); @@ -560,19 +569,16 @@ int git_path_dirload( memcpy(&entry_path[path_len + need_slash], de->d_name, entry_len); entry_path[path_len + need_slash + entry_len] = '\0'; - if ((error = git_vector_insert(contents, entry_path)) < GIT_SUCCESS) { - git__free(entry_path); - return error; - } + if (git_vector_insert(contents, entry_path) < 0) + return -1; } closedir(dir); - if (error != GIT_SUCCESS) - return git__throw( - GIT_EOSERR, "Failed to process directory entry in `%s`", path); + if (error != 0) + giterr_set(GITERR_OS, "Failed to process directory entry in '%s'", path); - return GIT_SUCCESS; + return error; } int git_path_with_stat_cmp(const void *a, const void *b) @@ -591,11 +597,12 @@ int git_path_dirload_with_stat( git_path_with_stat *ps; git_buf full = GIT_BUF_INIT; - if ((error = git_buf_set(&full, path, prefix_len)) != GIT_SUCCESS) - return error; + if (git_buf_set(&full, path, prefix_len) < 0) + return -1; - if ((error = git_path_dirload(path, prefix_len, - sizeof(git_path_with_stat) + 1, contents)) != GIT_SUCCESS) { + error = git_path_dirload( + path, prefix_len, sizeof(git_path_with_stat) + 1, contents); + if (error < 0) { git_buf_free(&full); return error; } @@ -606,8 +613,10 @@ int git_path_dirload_with_stat( memmove(ps->path, ps, path_len + 1); ps->path_len = path_len; - git_buf_joinpath(&full, full.ptr, ps->path); - p_lstat(full.ptr, &ps->st); + if ((error = git_buf_joinpath(&full, full.ptr, ps->path)) < 0 || + (error = git_path_lstat(full.ptr, &ps->st)) < 0) + break; + git_buf_truncate(&full, prefix_len); if (S_ISDIR(ps->st.st_mode)) { diff --git a/src/path.h b/src/path.h index 981fdd6a4..fd76805e5 100644 --- a/src/path.h +++ b/src/path.h @@ -113,48 +113,55 @@ extern int git_path_fromurl(git_buf *local_path_out, const char *file_url); /** * Check if a file exists and can be accessed. - * @return GIT_SUCCESS if file exists, < 0 otherwise. + * @return true or false */ -extern int git_path_exists(const char *path); +extern bool git_path_exists(const char *path); /** * Check if the given path points to a directory. - * @return GIT_SUCCESS if it is a directory, < 0 otherwise. + * @return true or false */ -extern int git_path_isdir(const char *path); +extern bool git_path_isdir(const char *path); /** * Check if the given path points to a regular file. - * @return GIT_SUCCESS if it is a regular file, < 0 otherwise. + * @return true or false */ -extern int git_path_isfile(const char *path); +extern bool git_path_isfile(const char *path); + +/** + * Stat a file and/or link and set error if needed. + */ +extern int git_path_lstat(const char *path, struct stat *st); /** * Check if the parent directory contains the item. * * @param dir Directory to check. * @param item Item that might be in the directory. - * @return GIT_SUCCESS if item exists in directory, <0 otherwise. + * @return 0 if item exists in directory, <0 otherwise. */ -extern int git_path_contains(git_buf *dir, const char *item); +extern bool git_path_contains(git_buf *dir, const char *item); /** * Check if the given path contains the given subdirectory. * * @param parent Directory path that might contain subdir * @param subdir Subdirectory name to look for in parent - * @return GIT_SUCCESS if subdirectory exists, < 0 otherwise. + * @param append_if_exists If true, then subdir will be appended to the parent path if it does exist + * @return true if subdirectory exists, false otherwise. */ -extern int git_path_contains_dir(git_buf *parent, const char *subdir); +extern bool git_path_contains_dir(git_buf *parent, const char *subdir); /** * Check if the given path contains the given file. * * @param dir Directory path that might contain file * @param file File name to look for in parent - * @return GIT_SUCCESS if file exists, < 0 otherwise. + * @param append_if_exists If true, then file will be appended to the path if it does exist + * @return true if file exists, false otherwise. */ -extern int git_path_contains_file(git_buf *dir, const char *file); +extern bool git_path_contains_file(git_buf *dir, const char *file); /** * Clean up path, prepending base if it is not already rooted. @@ -197,14 +204,14 @@ extern int git_path_direach( * Sort function to order two paths. */ extern int git_path_cmp( - const char *name1, int len1, int isdir1, - const char *name2, int len2, int isdir2); + const char *name1, size_t len1, int isdir1, + const char *name2, size_t len2, int isdir2); /** * Invoke callback up path directory by directory until the ceiling is * reached (inclusive of a final call at the root_path). * - * Returning anything other than GIT_SUCCESS from the callback function + * Returning anything other than 0 from the callback function * will stop the iteration and propogate the error to the caller. * * @param pathbuf Buffer the function reads the directory from and diff --git a/src/pkt.c b/src/pkt.c index 51da55de1..00836bc34 100644 --- a/src/pkt.c +++ b/src/pkt.c @@ -31,13 +31,12 @@ static int flush_pkt(git_pkt **out) git_pkt *pkt; pkt = git__malloc(sizeof(git_pkt)); - if (pkt == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_FLUSH; *out = pkt; - return GIT_SUCCESS; + return 0; } /* the rest of the line will be useful for multi_ack */ @@ -48,13 +47,12 @@ static int ack_pkt(git_pkt **out, const char *line, size_t len) GIT_UNUSED(len); pkt = git__malloc(sizeof(git_pkt)); - if (pkt == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_ACK; *out = pkt; - return GIT_SUCCESS; + return 0; } static int nak_pkt(git_pkt **out) @@ -62,13 +60,12 @@ static int nak_pkt(git_pkt **out) git_pkt *pkt; pkt = git__malloc(sizeof(git_pkt)); - if (pkt == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_NAK; *out = pkt; - return GIT_SUCCESS; + return 0; } static int pack_pkt(git_pkt **out) @@ -76,13 +73,12 @@ static int pack_pkt(git_pkt **out) git_pkt *pkt; pkt = git__malloc(sizeof(git_pkt)); - if (pkt == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_PACK; *out = pkt; - return GIT_SUCCESS; + return 0; } static int comment_pkt(git_pkt **out, const char *line, size_t len) @@ -90,8 +86,7 @@ static int comment_pkt(git_pkt **out, const char *line, size_t len) git_pkt_comment *pkt; pkt = git__malloc(sizeof(git_pkt_comment) + len + 1); - if (pkt == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_COMMENT; memcpy(pkt->comment, line, len); @@ -99,7 +94,26 @@ static int comment_pkt(git_pkt **out, const char *line, size_t len) *out = (git_pkt *) pkt; - return GIT_SUCCESS; + return 0; +} + +static int err_pkt(git_pkt **out, const char *line, size_t len) +{ + git_pkt_err *pkt; + + /* Remove "ERR " from the line */ + line += 4; + len -= 4; + pkt = git__malloc(sizeof(git_pkt_err) + len + 1); + GITERR_CHECK_ALLOC(pkt); + + pkt->type = GIT_PKT_ERR; + memcpy(pkt->error, line, len); + pkt->error[len] = '\0'; + + *out = (git_pkt *) pkt; + + return 0; } /* @@ -107,25 +121,22 @@ static int comment_pkt(git_pkt **out, const char *line, size_t len) */ static int ref_pkt(git_pkt **out, const char *line, size_t len) { - git_pkt_ref *pkt; int error; + git_pkt_ref *pkt; pkt = git__malloc(sizeof(git_pkt_ref)); - if (pkt == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(pkt); memset(pkt, 0x0, sizeof(git_pkt_ref)); pkt->type = GIT_PKT_REF; - error = git_oid_fromstr(&pkt->head.oid, line); - if (error < GIT_SUCCESS) { - error = git__throw(error, "Failed to parse reference ID"); - goto out; - } + if ((error = git_oid_fromstr(&pkt->head.oid, line)) < 0) + goto error_out; /* Check for a bit of consistency */ if (line[GIT_OID_HEXSZ] != ' ') { - error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse ref. No SP"); - goto out; + giterr_set(GITERR_NET, "Error parsing pkt-line"); + error = -1; + goto error_out; } /* Jump from the name */ @@ -136,10 +147,8 @@ static int ref_pkt(git_pkt **out, const char *line, size_t len) --len; pkt->head.name = git__malloc(len + 1); - if (pkt->head.name == NULL) { - error = GIT_ENOMEM; - goto out; - } + GITERR_CHECK_ALLOC(pkt->head.name); + memcpy(pkt->head.name, line, len); pkt->head.name[len] = '\0'; @@ -147,36 +156,35 @@ static int ref_pkt(git_pkt **out, const char *line, size_t len) pkt->capabilities = strchr(pkt->head.name, '\0') + 1; } -out: - if (error < GIT_SUCCESS) - git__free(pkt); - else - *out = (git_pkt *)pkt; + *out = (git_pkt *)pkt; + return 0; +error_out: + git__free(pkt); return error; } -static ssize_t parse_len(const char *line) +static int32_t parse_len(const char *line) { char num[PKT_LEN_SIZE + 1]; int i, error; - int len; + int32_t len; const char *num_end; memcpy(num, line, PKT_LEN_SIZE); num[PKT_LEN_SIZE] = '\0'; for (i = 0; i < PKT_LEN_SIZE; ++i) { - if (!isxdigit(num[i])) - return GIT_ENOTNUM; + if (!isxdigit(num[i])) { + giterr_set(GITERR_NET, "Found invalid hex digit in length"); + return -1; + } } - error = git__strtol32(&len, num, &num_end, 16); - if (error < GIT_SUCCESS) { + if ((error = git__strtol32(&len, num, &num_end, 16)) < 0) return error; - } - return (unsigned int) len; + return len; } /* @@ -192,17 +200,18 @@ static ssize_t parse_len(const char *line) * in ASCII hexadecimal (including itself) */ -int git_pkt_parse_line(git_pkt **head, const char *line, const char **out, size_t bufflen) +int git_pkt_parse_line( + git_pkt **head, const char *line, const char **out, size_t bufflen) { - int error = GIT_SUCCESS; - size_t len; + int ret; + int32_t len; /* Not even enough for the length */ if (bufflen > 0 && bufflen < PKT_LEN_SIZE) return GIT_ESHORTBUFFER; - error = parse_len(line); - if (error < GIT_SUCCESS) { + len = parse_len(line); + if (len < 0) { /* * If we fail to parse the length, it might be because the * server is trying to send us the packfile already. @@ -212,16 +221,14 @@ int git_pkt_parse_line(git_pkt **head, const char *line, const char **out, size_ return pack_pkt(head); } - return git__throw(error, "Failed to parse pkt length"); + return (int)len; } - len = error; - /* * If we were given a buffer length, then make sure there is * enough in the buffer to satisfy this line */ - if (bufflen > 0 && bufflen < len) + if (bufflen > 0 && bufflen < (size_t)len) return GIT_ESHORTBUFFER; line += PKT_LEN_SIZE; @@ -231,7 +238,7 @@ int git_pkt_parse_line(git_pkt **head, const char *line, const char **out, size_ */ if (len == PKT_LEN_SIZE) { *out = line; - return GIT_SUCCESS; + return 0; } if (len == 0) { /* Flush pkt */ @@ -243,22 +250,24 @@ int git_pkt_parse_line(git_pkt **head, const char *line, const char **out, size_ /* Assming the minimal size is actually 4 */ if (!git__prefixcmp(line, "ACK")) - error = ack_pkt(head, line, len); + ret = ack_pkt(head, line, len); else if (!git__prefixcmp(line, "NAK")) - error = nak_pkt(head); + ret = nak_pkt(head); + else if (!git__prefixcmp(line, "ERR ")) + ret = err_pkt(head, line, len); else if (*line == '#') - error = comment_pkt(head, line, len); + ret = comment_pkt(head, line, len); else - error = ref_pkt(head, line, len); + ret = ref_pkt(head, line, len); *out = line + len; - return error; + return ret; } void git_pkt_free(git_pkt *pkt) { - if(pkt->type == GIT_PKT_REF) { + if (pkt->type == GIT_PKT_REF) { git_pkt_ref *p = (git_pkt_ref *) pkt; git__free(p->head.name); } @@ -271,7 +280,7 @@ int git_pkt_buffer_flush(git_buf *buf) return git_buf_put(buf, pkt_flush_str, strlen(pkt_flush_str)); } -int git_pkt_send_flush(int s) +int git_pkt_send_flush(GIT_SOCKET s) { return gitno_send(s, pkt_flush_str, strlen(pkt_flush_str), 0); @@ -281,33 +290,20 @@ static int buffer_want_with_caps(git_remote_head *head, git_transport_caps *caps { char capstr[20]; char oid[GIT_OID_HEXSZ +1] = {0}; - int len; + unsigned int len; if (caps->ofs_delta) - strcpy(capstr, GIT_CAP_OFS_DELTA); + strncpy(capstr, GIT_CAP_OFS_DELTA, sizeof(capstr)); - len = strlen("XXXXwant ") + GIT_OID_HEXSZ + 1 /* NUL */ + strlen(capstr) + 1 /* LF */; - git_buf_grow(buf, buf->size + len); + len = (unsigned int) + (strlen("XXXXwant ") + GIT_OID_HEXSZ + 1 /* NUL */ + + strlen(capstr) + 1 /* LF */); + git_buf_grow(buf, git_buf_len(buf) + len); git_oid_fmt(oid, &head->oid); return git_buf_printf(buf, "%04xwant %s%c%s\n", len, oid, 0, capstr); } -static int send_want_with_caps(git_remote_head *head, git_transport_caps *caps, GIT_SOCKET fd) -{ - git_buf buf = GIT_BUF_INIT; - int error; - - error = buffer_want_with_caps(head, caps, &buf); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to buffer want with caps"); - - error = gitno_send(fd, buf.ptr, buf.size, 0); - git_buf_free(&buf); - - return error; -} - /* * All "want" packets have the same length and format, so what we do * is overwrite the OID each time. @@ -316,7 +312,6 @@ static int send_want_with_caps(git_remote_head *head, git_transport_caps *caps, int git_pkt_buffer_wants(const git_vector *refs, git_transport_caps *caps, git_buf *buf) { unsigned int i = 0; - int error; git_remote_head *head; if (caps->common) { @@ -326,9 +321,8 @@ int git_pkt_buffer_wants(const git_vector *refs, git_transport_caps *caps, git_b break; } - error = buffer_want_with_caps(refs->contents[i], caps, buf); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to buffer want with caps"); + if (buffer_want_with_caps(refs->contents[i], caps, buf) < 0) + return -1; i++; } @@ -344,54 +338,13 @@ int git_pkt_buffer_wants(const git_vector *refs, git_transport_caps *caps, git_b git_buf_put(buf, pkt_want_prefix, strlen(pkt_want_prefix)); git_buf_put(buf, oid, GIT_OID_HEXSZ); git_buf_putc(buf, '\n'); + if (git_buf_oom(buf)) + return -1; } return git_pkt_buffer_flush(buf); } -int git_pkt_send_wants(const git_vector *refs, git_transport_caps *caps, int fd) -{ - unsigned int i = 0; - int error = GIT_SUCCESS; - char buf[sizeof(pkt_want_prefix) + GIT_OID_HEXSZ + 1]; - git_remote_head *head; - - memcpy(buf, pkt_want_prefix, strlen(pkt_want_prefix)); - buf[sizeof(buf) - 2] = '\n'; - buf[sizeof(buf) - 1] = '\0'; - - /* If there are common caps, find the first one */ - if (caps->common) { - for (; i < refs->length; ++i) { - head = refs->contents[i]; - if (head->local) - continue; - else - break; - } - - error = send_want_with_caps(refs->contents[i], caps, fd); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to send want pkt with caps"); - /* Increase it here so it's correct whether we run this or not */ - i++; - } - - /* Continue from where we left off */ - for (; i < refs->length; ++i) { - head = refs->contents[i]; - if (head->local) - continue; - - git_oid_fmt(buf + strlen(pkt_want_prefix), &head->oid); - error = gitno_send(fd, buf, strlen(buf), 0); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to send want pkt"); - } - - return git_pkt_send_flush(fd); -} - int git_pkt_buffer_have(git_oid *oid, git_buf *buf) { char oidhex[GIT_OID_HEXSZ + 1]; @@ -401,21 +354,7 @@ int git_pkt_buffer_have(git_oid *oid, git_buf *buf) return git_buf_printf(buf, "%s%s\n", pkt_have_prefix, oidhex); } -int git_pkt_send_have(git_oid *oid, int fd) -{ - char buf[] = "0032have 0000000000000000000000000000000000000000\n"; - - git_oid_fmt(buf + strlen(pkt_have_prefix), oid); - return gitno_send(fd, buf, strlen(buf), 0); -} - - int git_pkt_buffer_done(git_buf *buf) { return git_buf_puts(buf, pkt_done_str); } - -int git_pkt_send_done(int fd) -{ - return gitno_send(fd, pkt_done_str, strlen(pkt_done_str), 0); -} diff --git a/src/pkt.h b/src/pkt.h index b0bc0892e..75442c833 100644 --- a/src/pkt.h +++ b/src/pkt.h @@ -11,6 +11,7 @@ #include "common.h" #include "transport.h" #include "buffer.h" +#include "posix.h" #include "git2/net.h" enum git_pkt_type { @@ -22,6 +23,7 @@ enum git_pkt_type { GIT_PKT_NAK, GIT_PKT_PACK, GIT_PKT_COMMENT, + GIT_PKT_ERR, }; /* Used for multi-ack */ @@ -63,15 +65,17 @@ typedef struct { char comment[GIT_FLEX_ARRAY]; } git_pkt_comment; +typedef struct { + enum git_pkt_type type; + char error[GIT_FLEX_ARRAY]; +} git_pkt_err; + int git_pkt_parse_line(git_pkt **head, const char *line, const char **out, size_t len); int git_pkt_buffer_flush(git_buf *buf); -int git_pkt_send_flush(int s); +int git_pkt_send_flush(GIT_SOCKET s); int git_pkt_buffer_done(git_buf *buf); -int git_pkt_send_done(int s); int git_pkt_buffer_wants(const git_vector *refs, git_transport_caps *caps, git_buf *buf); -int git_pkt_send_wants(const git_vector *refs, git_transport_caps *caps, int fd); int git_pkt_buffer_have(git_oid *oid, git_buf *buf); -int git_pkt_send_have(git_oid *oid, int fd); void git_pkt_free(git_pkt *pkt); #endif diff --git a/src/pool.c b/src/pool.c new file mode 100644 index 000000000..641292d06 --- /dev/null +++ b/src/pool.c @@ -0,0 +1,294 @@ +#include "pool.h" +#ifndef GIT_WIN32 +#include +#endif + +struct git_pool_page { + git_pool_page *next; + uint32_t size; + uint32_t avail; + char data[GIT_FLEX_ARRAY]; +}; + +#define GIT_POOL_MIN_USABLE 4 +#define GIT_POOL_MIN_PAGESZ 2 * sizeof(void*) + +static void *pool_alloc_page(git_pool *pool, uint32_t size); +static void pool_insert_page(git_pool *pool, git_pool_page *page); + +int git_pool_init( + git_pool *pool, uint32_t item_size, uint32_t items_per_page) +{ + assert(pool); + + if (!item_size) + item_size = 1; + /* round up item_size for decent object alignment */ + if (item_size > 4) + item_size = (item_size + 7) & ~7; + else if (item_size == 3) + item_size = 4; + + if (!items_per_page) + items_per_page = git_pool__suggest_items_per_page(item_size); + if (item_size * items_per_page < GIT_POOL_MIN_PAGESZ) + items_per_page = (GIT_POOL_MIN_PAGESZ + item_size - 1) / item_size; + + memset(pool, 0, sizeof(git_pool)); + pool->item_size = item_size; + pool->page_size = item_size * items_per_page; + + return 0; +} + +void git_pool_clear(git_pool *pool) +{ + git_pool_page *scan, *next; + + for (scan = pool->open; scan != NULL; scan = next) { + next = scan->next; + git__free(scan); + } + pool->open = NULL; + + for (scan = pool->full; scan != NULL; scan = next) { + next = scan->next; + git__free(scan); + } + pool->full = NULL; + + pool->free_list = NULL; + + pool->items = 0; + + pool->has_string_alloc = 0; + pool->has_multi_item_alloc = 0; + pool->has_large_page_alloc = 0; +} + +void git_pool_swap(git_pool *a, git_pool *b) +{ + git_pool temp; + + if (a == b) + return; + + memcpy(&temp, a, sizeof(temp)); + memcpy(a, b, sizeof(temp)); + memcpy(b, &temp, sizeof(temp)); +} + +static void pool_insert_page(git_pool *pool, git_pool_page *page) +{ + git_pool_page *scan; + + /* If there are no open pages or this page has the most open space, + * insert it at the beginning of the list. This is the common case. + */ + if (pool->open == NULL || pool->open->avail < page->avail) { + page->next = pool->open; + pool->open = page; + return; + } + + /* Otherwise insert into sorted position. */ + for (scan = pool->open; + scan->next && scan->next->avail > page->avail; + scan = scan->next); + page->next = scan->next; + scan->next = page; +} + +static void *pool_alloc_page(git_pool *pool, uint32_t size) +{ + git_pool_page *page; + uint32_t alloc_size; + + if (size <= pool->page_size) + alloc_size = pool->page_size; + else { + alloc_size = size; + pool->has_large_page_alloc = 1; + } + + page = git__calloc(1, alloc_size + sizeof(git_pool_page)); + if (!page) + return NULL; + + page->size = alloc_size; + page->avail = alloc_size - size; + + if (page->avail > 0) + pool_insert_page(pool, page); + else { + page->next = pool->full; + pool->full = page; + } + + pool->items++; + + return page->data; +} + +GIT_INLINE(void) pool_remove_page( + git_pool *pool, git_pool_page *page, git_pool_page *prev) +{ + if (prev == NULL) + pool->open = page->next; + else + prev->next = page->next; +} + +void *git_pool_malloc(git_pool *pool, uint32_t items) +{ + git_pool_page *scan = pool->open, *prev; + uint32_t size = items * pool->item_size; + void *ptr = NULL; + + pool->has_string_alloc = 0; + if (items > 1) + pool->has_multi_item_alloc = 1; + else if (pool->free_list != NULL) { + ptr = pool->free_list; + pool->free_list = *((void **)pool->free_list); + return ptr; + } + + /* just add a block if there is no open one to accomodate this */ + if (size >= pool->page_size || !scan || scan->avail < size) + return pool_alloc_page(pool, size); + + pool->items++; + + /* find smallest block in free list with space */ + for (scan = pool->open, prev = NULL; + scan->next && scan->next->avail >= size; + prev = scan, scan = scan->next); + + /* allocate space from the block */ + ptr = &scan->data[scan->size - scan->avail]; + scan->avail -= size; + + /* move to full list if there is almost no space left */ + if (scan->avail < pool->item_size || scan->avail < GIT_POOL_MIN_USABLE) { + pool_remove_page(pool, scan, prev); + scan->next = pool->full; + pool->full = scan; + } + /* reorder list if block is now smaller than the one after it */ + else if (scan->next != NULL && scan->next->avail > scan->avail) { + pool_remove_page(pool, scan, prev); + pool_insert_page(pool, scan); + } + + return ptr; +} + +char *git_pool_strndup(git_pool *pool, const char *str, size_t n) +{ + void *ptr = NULL; + + assert(pool && str && pool->item_size == sizeof(char)); + + if ((ptr = git_pool_malloc(pool, (uint32_t)(n + 1))) != NULL) { + memcpy(ptr, str, n); + *(((char *)ptr) + n) = '\0'; + } + pool->has_string_alloc = 1; + + return ptr; +} + +char *git_pool_strdup(git_pool *pool, const char *str) +{ + assert(pool && str && pool->item_size == sizeof(char)); + + return git_pool_strndup(pool, str, strlen(str)); +} + +char *git_pool_strcat(git_pool *pool, const char *a, const char *b) +{ + void *ptr; + size_t len_a, len_b; + + assert(pool && a && b && pool->item_size == sizeof(char)); + + len_a = a ? strlen(a) : 0; + len_b = b ? strlen(b) : 0; + + if ((ptr = git_pool_malloc(pool, (uint32_t)(len_a + len_b + 1))) != NULL) { + if (len_a) + memcpy(ptr, a, len_a); + if (len_b) + memcpy(((char *)ptr) + len_a, b, len_b); + *(((char *)ptr) + len_a + len_b) = '\0'; + } + pool->has_string_alloc = 1; + + return ptr; +} + +void git_pool_free(git_pool *pool, void *ptr) +{ + assert(pool && ptr && pool->item_size >= sizeof(void*)); + + *((void **)ptr) = pool->free_list; + pool->free_list = ptr; +} + +uint32_t git_pool__open_pages(git_pool *pool) +{ + uint32_t ct = 0; + git_pool_page *scan; + for (scan = pool->open; scan != NULL; scan = scan->next) ct++; + return ct; +} + +uint32_t git_pool__full_pages(git_pool *pool) +{ + uint32_t ct = 0; + git_pool_page *scan; + for (scan = pool->full; scan != NULL; scan = scan->next) ct++; + return ct; +} + +bool git_pool__ptr_in_pool(git_pool *pool, void *ptr) +{ + git_pool_page *scan; + for (scan = pool->open; scan != NULL; scan = scan->next) + if ((void *)scan->data <= ptr && + (void *)(((char *)scan->data) + scan->size) > ptr) + return true; + for (scan = pool->full; scan != NULL; scan = scan->next) + if ((void *)scan->data <= ptr && + (void *)(((char *)scan->data) + scan->size) > ptr) + return true; + return false; +} + +uint32_t git_pool__system_page_size(void) +{ + static uint32_t size = 0; + + if (!size) { +#ifdef GIT_WIN32 + SYSTEM_INFO info; + GetSystemInfo(&info); + size = (uint32_t)info.dwPageSize; +#else + size = (uint32_t)sysconf(_SC_PAGE_SIZE); +#endif + + size -= 2 * sizeof(void *); /* allow space for malloc overhead */ + } + + return size; +} + +uint32_t git_pool__suggest_items_per_page(uint32_t item_size) +{ + uint32_t page_bytes = + git_pool__system_page_size() - sizeof(git_pool_page); + return page_bytes / item_size; +} + diff --git a/src/pool.h b/src/pool.h new file mode 100644 index 000000000..54a2861ed --- /dev/null +++ b/src/pool.h @@ -0,0 +1,125 @@ +/* + * Copyright (C) 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_pool_h__ +#define INCLUDE_pool_h__ + +#include "common.h" + +typedef struct git_pool_page git_pool_page; + +/** + * Chunked allocator. + * + * A `git_pool` can be used when you want to cheaply allocate + * multiple items of the same type and are willing to free them + * all together with a single call. The two most common cases + * are a set of fixed size items (such as lots of OIDs) or a + * bunch of strings. + * + * Internally, a `git_pool` allocates pages of memory and then + * deals out blocks from the trailing unused portion of each page. + * The pages guarantee that the number of actual allocations done + * will be much smaller than the number of items needed. + * + * For examples of how to set up a `git_pool` see `git_pool_init`. + */ +typedef struct { + git_pool_page *open; /* pages with space left */ + git_pool_page *full; /* pages with no space left */ + void *free_list; /* optional: list of freed blocks */ + uint32_t item_size; /* size of single alloc unit in bytes */ + uint32_t page_size; /* size of page in bytes */ + uint32_t items; + unsigned has_string_alloc : 1; /* was the strdup function used */ + unsigned has_multi_item_alloc : 1; /* was items ever > 1 in malloc */ + unsigned has_large_page_alloc : 1; /* are any pages > page_size */ +} git_pool; + +#define GIT_POOL_INIT_STRINGPOOL { 0, 0, 0, 1, 4000, 0, 0, 0, 0 } + +/** + * Initialize a pool. + * + * To allocation strings, use like this: + * + * git_pool_init(&string_pool, 1, 0); + * my_string = git_pool_strdup(&string_pool, your_string); + * + * To allocate items of fixed size, use like this: + * + * git_pool_init(&pool, sizeof(item), 0); + * my_item = git_pool_malloc(&pool, 1); + * + * Of course, you can use this in other ways, but those are the + * two most common patterns. + */ +extern int git_pool_init( + git_pool *pool, uint32_t item_size, uint32_t items_per_page); + +/** + * Free all items in pool + */ +extern void git_pool_clear(git_pool *pool); + +/** + * Swap two pools with one another + */ +extern void git_pool_swap(git_pool *a, git_pool *b); + +/** + * Allocate space for one or more items from a pool. + */ +extern void *git_pool_malloc(git_pool *pool, uint32_t items); + +/** + * Allocate space and duplicate string data into it. + * + * This is allowed only for pools with item_size == sizeof(char) + */ +extern char *git_pool_strndup(git_pool *pool, const char *str, size_t n); + +/** + * Allocate space and duplicate a string into it. + * + * This is allowed only for pools with item_size == sizeof(char) + */ +extern char *git_pool_strdup(git_pool *pool, const char *str); + +/** + * Allocate space for the concatenation of two strings. + * + * This is allowed only for pools with item_size == sizeof(char) + */ +extern char *git_pool_strcat(git_pool *pool, const char *a, const char *b); + +/** + * Push a block back onto the free list for the pool. + * + * This is allowed only if the item_size is >= sizeof(void*). + * + * In some cases, it is helpful to "release" an allocated block + * for reuse. Pools don't support a general purpose free, but + * they will keep a simple free blocks linked list provided the + * native block size is large enough to hold a void pointer + */ +extern void git_pool_free(git_pool *pool, void *ptr); + +/* + * Misc utilities + */ + +extern uint32_t git_pool__open_pages(git_pool *pool); + +extern uint32_t git_pool__full_pages(git_pool *pool); + +extern bool git_pool__ptr_in_pool(git_pool *pool, void *ptr); + +extern uint32_t git_pool__system_page_size(void); + +extern uint32_t git_pool__suggest_items_per_page(uint32_t item_size); + +#endif diff --git a/src/posix.c b/src/posix.c index d2364d9b4..a3f81d767 100644 --- a/src/posix.c +++ b/src/posix.c @@ -31,27 +31,25 @@ int p_getcwd(char *buffer_out, size_t size) cwd_buffer = getcwd(buffer_out, size); if (cwd_buffer == NULL) - return git__throw(GIT_EOSERR, "Failed to retrieve current working directory"); + return -1; git_path_mkposix(buffer_out); + git_path_string_to_dir(buffer_out, size); /* append trailing slash */ - git_path_string_to_dir(buffer_out, size); //Ensure the path ends with a trailing slash - - return GIT_SUCCESS; + return 0; } int p_rename(const char *from, const char *to) { if (!link(from, to)) { p_unlink(from); - return GIT_SUCCESS; + return 0; } if (!rename(from, to)) - return GIT_SUCCESS; - - return GIT_ERROR; + return 0; + return -1; } #endif @@ -60,11 +58,17 @@ int p_read(git_file fd, void *buf, size_t cnt) { char *b = buf; while (cnt) { - ssize_t r = read(fd, b, cnt); + ssize_t r; +#ifdef GIT_WIN32 + assert((size_t)((unsigned int)cnt) == cnt); + r = read(fd, b, (unsigned int)cnt); +#else + r = read(fd, b, cnt); +#endif if (r < 0) { if (errno == EINTR || errno == EAGAIN) continue; - return GIT_EOSERR; + return -1; } if (!r) break; @@ -78,18 +82,24 @@ int p_write(git_file fd, const void *buf, size_t cnt) { const char *b = buf; while (cnt) { - ssize_t r = write(fd, b, cnt); + ssize_t r; +#ifdef GIT_WIN32 + assert((size_t)((unsigned int)cnt) == cnt); + r = write(fd, b, (unsigned int)cnt); +#else + r = write(fd, b, cnt); +#endif if (r < 0) { if (errno == EINTR || errno == EAGAIN) continue; - return GIT_EOSERR; + return -1; } if (!r) { errno = EPIPE; - return GIT_EOSERR; + return -1; } cnt -= r; b += r; } - return GIT_SUCCESS; + return 0; } diff --git a/src/posix.h b/src/posix.h index fb17cba6c..752d5156f 100644 --- a/src/posix.h +++ b/src/posix.h @@ -54,6 +54,14 @@ extern int p_rename(const char *from, const char *to); #define p_rmdir(p) rmdir(p) #define p_chmod(p,m) chmod(p, m) #define p_access(p,m) access(p,m) +#define p_recv(s,b,l,f) recv(s,b,l,f) +#define p_send(s,b,l,f) send(s,b,l,f) +typedef int GIT_SOCKET; +#define INVALID_SOCKET -1 + +#else + +typedef SOCKET GIT_SOCKET; #endif diff --git a/src/pqueue.c b/src/pqueue.c index 3fbf93315..cb59c13ec 100644 --- a/src/pqueue.c +++ b/src/pqueue.c @@ -17,14 +17,14 @@ int git_pqueue_init(git_pqueue *q, size_t n, git_pqueue_cmp cmppri) assert(q); /* Need to allocate n+1 elements since element 0 isn't used. */ - if ((q->d = git__malloc((n + 1) * sizeof(void *))) == NULL) - return GIT_ENOMEM; + q->d = git__malloc((n + 1) * sizeof(void *)); + GITERR_CHECK_ALLOC(q->d); q->size = 1; q->avail = q->step = (n + 1); /* see comment above about n+1 */ q->cmppri = cmppri; - return GIT_SUCCESS; + return 0; } @@ -102,8 +102,8 @@ int git_pqueue_insert(git_pqueue *q, void *d) /* allocate more memory if necessary */ if (q->size >= q->avail) { newsize = q->size + q->step; - if ((tmp = git__realloc(q->d, sizeof(void *) * newsize)) == NULL) - return GIT_ENOMEM; + tmp = git__realloc(q->d, sizeof(void *) * newsize); + GITERR_CHECK_ALLOC(tmp); q->d = tmp; q->avail = newsize; @@ -114,7 +114,7 @@ int git_pqueue_insert(git_pqueue *q, void *d) q->d[i] = d; bubble_up(q, i); - return GIT_SUCCESS; + return 0; } diff --git a/src/protocol.c b/src/protocol.c index dd93623b3..a75354121 100644 --- a/src/protocol.c +++ b/src/protocol.c @@ -17,10 +17,12 @@ int git_protocol_store_refs(git_protocol *p, const char *data, size_t len) const char *line_end, *ptr; if (len == 0) { /* EOF */ - if (buf->size != 0) - return p->error = git__throw(GIT_ERROR, "EOF and unprocessed data"); - else + if (git_buf_len(buf) != 0) { + giterr_set(GITERR_NET, "Unexpected EOF"); + return p->error = -1; + } else { return 0; + } } git_buf_put(buf, data, len); @@ -28,23 +30,29 @@ int git_protocol_store_refs(git_protocol *p, const char *data, size_t len) while (1) { git_pkt *pkt; - if (buf->size == 0) + if (git_buf_len(buf) == 0) return 0; - error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->size); + error = git_pkt_parse_line(&pkt, ptr, &line_end, git_buf_len(buf)); if (error == GIT_ESHORTBUFFER) return 0; /* Ask for more */ - if (error < GIT_SUCCESS) - return p->error = git__rethrow(error, "Failed to parse pkt-line"); + if (error < 0) + return p->error = -1; git_buf_consume(buf, line_end); - error = git_vector_insert(refs, pkt); - if (error < GIT_SUCCESS) - return p->error = git__rethrow(error, "Failed to add pkt to list"); + + if (pkt->type == GIT_PKT_ERR) { + giterr_set(GITERR_NET, "Remote error: %s", ((git_pkt_err *)pkt)->error); + git__free(pkt); + return -1; + } + + if (git_vector_insert(refs, pkt) < 0) + return p->error = -1; if (pkt->type == GIT_PKT_FLUSH) p->flush = 1; } - return error; + return 0; } diff --git a/src/reflog.c b/src/reflog.c index e8b0b9811..3ea073e65 100644 --- a/src/reflog.c +++ b/src/reflog.c @@ -16,23 +16,21 @@ static int reflog_init(git_reflog **reflog, git_reference *ref) *reflog = NULL; - log = git__malloc(sizeof(git_reflog)); - if (log == NULL) - return GIT_ENOMEM; - - memset(log, 0x0, sizeof(git_reflog)); + log = git__calloc(1, sizeof(git_reflog)); + GITERR_CHECK_ALLOC(log); log->ref_name = git__strdup(ref->name); + GITERR_CHECK_ALLOC(log->ref_name); if (git_vector_init(&log->entries, 0, NULL) < 0) { git__free(log->ref_name); git__free(log); - return GIT_ENOMEM; + return -1; } *reflog = log; - return GIT_SUCCESS; + return 0; } static int reflog_write(const char *log_path, const char *oid_old, @@ -42,9 +40,22 @@ static int reflog_write(const char *log_path, const char *oid_old, int error; git_buf log = GIT_BUF_INIT; git_filebuf fbuf = GIT_FILEBUF_INIT; + bool trailing_newline = false; assert(log_path && oid_old && oid_new && committer); + 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_puts(&log, oid_old); git_buf_putc(&log, ' '); @@ -54,68 +65,58 @@ static int reflog_write(const char *log_path, const char *oid_old, git_buf_truncate(&log, log.size - 1); /* drop LF */ if (msg) { - if (strchr(msg, '\n')) { - git_buf_free(&log); - return git__throw(GIT_ERROR, "Reflog message cannot contain newline"); - } - git_buf_putc(&log, '\t'); git_buf_puts(&log, msg); } - git_buf_putc(&log, '\n'); + if (!trailing_newline) + git_buf_putc(&log, '\n'); - if ((error = git_buf_lasterror(&log)) < GIT_SUCCESS) { + if (git_buf_oom(&log)) { git_buf_free(&log); - return git__rethrow(error, "Failed to write reflog. Memory allocation failure"); + return -1; } - if ((error = git_filebuf_open(&fbuf, log_path, GIT_FILEBUF_APPEND)) < GIT_SUCCESS) { - git_buf_free(&log); - return git__rethrow(error, "Failed to write reflog. Cannot open reflog `%s`", log_path); + 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); } - git_filebuf_write(&fbuf, log.ptr, log.size); - error = git_filebuf_commit(&fbuf, GIT_REFLOG_FILE_MODE); - git_buf_free(&log); - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write reflog"); + return error; } static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size) { - int error = GIT_SUCCESS; const char *ptr; git_reflog_entry *entry; -#define seek_forward(_increase) { \ +#define seek_forward(_increase) do { \ if (_increase >= buf_size) { \ - if (entry->committer) \ - git__free(entry->committer); \ - git__free(entry); \ - return git__throw(GIT_ERROR, "Failed to seek forward. Buffer size exceeded"); \ + giterr_set(GITERR_INVALID, "Ran out of data while parsing reflog"); \ + goto fail; \ } \ buf += _increase; \ buf_size -= _increase; \ -} + } while (0) while (buf_size > GIT_REFLOG_SIZE_MIN) { entry = git__malloc(sizeof(git_reflog_entry)); - if (entry == NULL) - return GIT_ENOMEM; - entry->committer = NULL; + GITERR_CHECK_ALLOC(entry); - if (git_oid_fromstrn(&entry->oid_old, buf, GIT_OID_HEXSZ) < GIT_SUCCESS) { - git__free(entry); - return GIT_ERROR; - } + entry->committer = git__malloc(sizeof(git_signature)); + GITERR_CHECK_ALLOC(entry->committer); + + if (git_oid_fromstrn(&entry->oid_old, buf, GIT_OID_HEXSZ) < 0) + goto fail; seek_forward(GIT_OID_HEXSZ + 1); - if (git_oid_fromstrn(&entry->oid_cur, buf, GIT_OID_HEXSZ) < GIT_SUCCESS) { - git__free(entry); - return GIT_ERROR; - } + if (git_oid_fromstrn(&entry->oid_cur, buf, GIT_OID_HEXSZ) < 0) + goto fail; seek_forward(GIT_OID_HEXSZ + 1); ptr = buf; @@ -124,17 +125,8 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size) while (*buf && *buf != '\t' && *buf != '\n') seek_forward(1); - entry->committer = git__malloc(sizeof(git_signature)); - if (entry->committer == NULL) { - git__free(entry); - return GIT_ENOMEM; - } - - if ((error = git_signature__parse(entry->committer, &ptr, buf + 1, NULL, *buf)) < GIT_SUCCESS) { - git__free(entry->committer); - git__free(entry); - return git__rethrow(error, "Failed to parse reflog. Could not parse signature"); - } + if (git_signature__parse(entry->committer, &ptr, buf + 1, NULL, *buf) < 0) + goto fail; if (*buf == '\t') { /* We got a message. Read everything till we reach LF. */ @@ -145,19 +137,27 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size) seek_forward(1); entry->msg = git__strndup(ptr, buf - ptr); + GITERR_CHECK_ALLOC(entry->msg); } else entry->msg = NULL; while (*buf && *buf == '\n' && buf_size > 1) seek_forward(1); - if ((error = git_vector_insert(&log->entries, entry)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to parse reflog. Could not add new entry"); + if (git_vector_insert(&log->entries, entry) < 0) + goto fail; } + return 0; + #undef seek_forward - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse reflog"); +fail: + if (entry) { + git__free(entry->committer); + git__free(entry); + } + return -1; } void git_reflog_free(git_reflog *reflog) @@ -188,27 +188,23 @@ int git_reflog_read(git_reflog **reflog, git_reference *ref) *reflog = NULL; - if ((error = reflog_init(&log, ref)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to read reflog. Cannot init reflog"); + 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 (error < GIT_SUCCESS) - goto cleanup; - if ((error = git_futils_readbuffer(&log_file, log_path.ptr)) < GIT_SUCCESS) { - git__rethrow(error, "Failed to read reflog. Cannot read file `%s`", log_path.ptr); - goto cleanup; - } + if (!error) + error = git_futils_readbuffer(&log_file, log_path.ptr); - if ((error = reflog_parse(log, log_file.ptr, log_file.size)) < GIT_SUCCESS) - git__rethrow(error, "Failed to read reflog"); - else + if (!error) + error = reflog_parse(log, log_file.ptr, log_file.size); + + if (!error) *reflog = log; - -cleanup: - if (error != GIT_SUCCESS && log != NULL) + else git_reflog_free(log); + git_buf_free(&log_file); git_buf_free(&log_path); @@ -225,16 +221,15 @@ int git_reflog_write(git_reference *ref, const git_oid *oid_old, git_reference *r; const git_oid *oid; - if ((error = git_reference_resolve(&r, ref)) < GIT_SUCCESS) - return git__rethrow(error, - "Failed to write reflog. Cannot resolve reference `%s`", ref->name); + if ((error = git_reference_resolve(&r, ref)) < 0) + return error; oid = git_reference_oid(r); if (oid == NULL) { - error = git__throw(GIT_ERROR, + giterr_set(GITERR_REFERENCE, "Failed to write reflog. Cannot resolve reference `%s`", r->name); git_reference_free(r); - return error; + return -1; } git_oid_tostr(new, GIT_OID_HEXSZ+1, oid); @@ -243,23 +238,21 @@ int git_reflog_write(git_reference *ref, const git_oid *oid_old, error = git_buf_join_n(&log_path, '/', 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; - if (git_path_exists(log_path.ptr)) { + if (git_path_exists(log_path.ptr) == false) { error = git_futils_mkpath2file(log_path.ptr, GIT_REFLOG_DIR_MODE); - if (error < GIT_SUCCESS) - git__rethrow(error, - "Failed to write reflog. Cannot create reflog directory"); - } else if (git_path_isfile(log_path.ptr)) { - error = git__throw(GIT_ERROR, + } 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) { - error = git__throw(GIT_ERROR, + giterr_set(GITERR_REFERENCE, "Failed to write reflog. Old OID cannot be NULL for existing reference"); + error = -1; } - - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; if (oid_old) @@ -280,13 +273,13 @@ int git_reflog_rename(git_reference *ref, const char *new_name) git_buf old_path = GIT_BUF_INIT; git_buf new_path = GIT_BUF_INIT; - if (git_buf_join_n(&old_path, '/', 3, ref->owner->path_repository, - GIT_REFLOG_DIR, ref->name) && - git_buf_join_n(&new_path, '/', 3, ref->owner->path_repository, - GIT_REFLOG_DIR, new_name)) + if (!git_buf_join_n(&old_path, '/', 3, ref->owner->path_repository, + GIT_REFLOG_DIR, ref->name) && + !git_buf_join_n(&new_path, '/', 3, ref->owner->path_repository, + GIT_REFLOG_DIR, new_name)) error = p_rename(git_buf_cstr(&old_path), git_buf_cstr(&new_path)); else - error = GIT_ENOMEM; + error = -1; git_buf_free(&old_path); git_buf_free(&new_path); @@ -296,13 +289,13 @@ int git_reflog_rename(git_reference *ref, const char *new_name) int git_reflog_delete(git_reference *ref) { - int error = GIT_SUCCESS; + 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 = git_buf_join_n( + &path, '/', 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name); - if (error == GIT_SUCCESS && git_path_exists(path.ptr) == 0) + if (!error && git_path_exists(path.ptr)) error = p_unlink(path.ptr); git_buf_free(&path); diff --git a/src/refs.c b/src/refs.c index f3388bf53..28e8f786b 100644 --- a/src/refs.c +++ b/src/refs.c @@ -15,7 +15,10 @@ #include #include -#define MAX_NESTING_LEVEL 5 +GIT__USE_STRMAP; + +#define DEFAULT_NESTING_LEVEL 5 +#define MAX_NESTING_LEVEL 10 enum { GIT_PACKREF_HAS_PEEL = 1, @@ -29,8 +32,6 @@ struct packref { char name[GIT_FLEX_ARRAY]; }; -static const int default_table_size = 32; - static int reference_read( git_buf *file_content, time_t *mtime, @@ -61,7 +62,7 @@ static int packed_lookup(git_reference *ref); static int packed_write(git_repository *repo); /* internal helpers */ -static int reference_available(git_repository *repo, +static int reference_path_available(git_repository *repo, const char *ref, const char *old_ref); static int reference_delete(git_reference *ref); static int reference_lookup(git_reference *ref); @@ -97,98 +98,100 @@ static int reference_alloc( assert(ref_out && repo && name); reference = git__malloc(sizeof(git_reference)); - if (reference == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(reference); memset(reference, 0x0, sizeof(git_reference)); reference->owner = repo; reference->name = git__strdup(name); - if (reference->name == NULL) { - git__free(reference); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(reference->name); *ref_out = reference; - return GIT_SUCCESS; + return 0; } -static int reference_read(git_buf *file_content, time_t *mtime, const char *repo_path, const char *ref_name, int *updated) +static int reference_read( + git_buf *file_content, + time_t *mtime, + const char *repo_path, + const char *ref_name, + int *updated) { git_buf path = GIT_BUF_INIT; - int error = GIT_SUCCESS; + int result; assert(file_content && repo_path && ref_name); /* Determine the full path of the file */ - if ((error = git_buf_joinpath(&path, repo_path, ref_name)) == GIT_SUCCESS) - error = git_futils_readbuffer_updated(file_content, path.ptr, mtime, updated); + if (git_buf_joinpath(&path, repo_path, ref_name) < 0) + return -1; + result = git_futils_readbuffer_updated(file_content, path.ptr, mtime, updated); git_buf_free(&path); - - return error; + return result; } static int loose_parse_symbolic(git_reference *ref, git_buf *file_content) { - const unsigned int header_len = strlen(GIT_SYMREF); + const unsigned int header_len = (unsigned int)strlen(GIT_SYMREF); const char *refname_start; char *eol; refname_start = (const char *)file_content->ptr; - if (file_content->size < (header_len + 1)) - return git__throw(GIT_EOBJCORRUPTED, - "Failed to parse loose reference. Object too short"); + if (git_buf_len(file_content) < header_len + 1) + goto corrupt; /* * Assume we have already checked for the header * before calling this function */ - refname_start += header_len; ref->target.symbolic = git__strdup(refname_start); - if (ref->target.symbolic == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(ref->target.symbolic); /* remove newline at the end of file */ eol = strchr(ref->target.symbolic, '\n'); if (eol == NULL) - return git__throw(GIT_EOBJCORRUPTED, - "Failed to parse loose reference. Missing EOL"); + goto corrupt; *eol = '\0'; if (eol[-1] == '\r') eol[-1] = '\0'; - return GIT_SUCCESS; + return 0; + +corrupt: + giterr_set(GITERR_REFERENCE, "Corrupted loose reference file"); + return -1; } static int loose_parse_oid(git_oid *oid, git_buf *file_content) { - int error; char *buffer; buffer = (char *)file_content->ptr; /* File format: 40 chars (OID) + newline */ - if (file_content->size < GIT_OID_HEXSZ + 1) - return git__throw(GIT_EOBJCORRUPTED, - "Failed to parse loose reference. Reference too short"); + if (git_buf_len(file_content) < GIT_OID_HEXSZ + 1) + goto corrupt; - if ((error = git_oid_fromstr(oid, buffer)) < GIT_SUCCESS) - return git__rethrow(GIT_EOBJCORRUPTED, "Failed to parse loose reference."); + if (git_oid_fromstr(oid, buffer) < 0) + goto corrupt; buffer = buffer + GIT_OID_HEXSZ; if (*buffer == '\r') buffer++; if (*buffer != '\n') - return git__throw(GIT_EOBJCORRUPTED, - "Failed to parse loose reference. Missing EOL"); + goto corrupt; - return GIT_SUCCESS; + return 0; + +corrupt: + giterr_set(GITERR_REFERENCE, "Corrupted loose reference file"); + return -1; } static git_rtype loose_guess_rtype(const git_buf *full_path) @@ -198,7 +201,7 @@ static git_rtype loose_guess_rtype(const git_buf *full_path) type = GIT_REF_INVALID; - if (git_futils_readbuffer(&ref_file, full_path->ptr) == GIT_SUCCESS) { + if (git_futils_readbuffer(&ref_file, full_path->ptr) == 0) { if (git__prefixcmp((const char *)(ref_file.ptr), GIT_SYMREF) == 0) type = GIT_REF_SYMBOLIC; else @@ -211,15 +214,17 @@ static git_rtype loose_guess_rtype(const git_buf *full_path) static int loose_lookup(git_reference *ref) { - int error = GIT_SUCCESS, updated; + int result, updated; git_buf ref_file = GIT_BUF_INIT; - if (reference_read(&ref_file, &ref->mtime, - ref->owner->path_repository, ref->name, &updated) < GIT_SUCCESS) - return git__throw(GIT_ENOTFOUND, "Failed to lookup loose reference"); + result = reference_read(&ref_file, &ref->mtime, + ref->owner->path_repository, ref->name, &updated); + + if (result < 0) + return result; if (!updated) - return GIT_SUCCESS; + return 0; if (ref->flags & GIT_REF_SYMBOLIC) { git__free(ref->target.symbolic); @@ -230,18 +235,14 @@ static int loose_lookup(git_reference *ref) if (git__prefixcmp((const char *)(ref_file.ptr), GIT_SYMREF) == 0) { ref->flags |= GIT_REF_SYMBOLIC; - error = loose_parse_symbolic(ref, &ref_file); + result = loose_parse_symbolic(ref, &ref_file); } else { ref->flags |= GIT_REF_OID; - error = loose_parse_oid(&ref->target.oid, &ref_file); + result = loose_parse_oid(&ref->target.oid, &ref_file); } git_buf_free(&ref_file); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup loose reference"); - - return GIT_SUCCESS; + return result; } static int loose_lookup_to_packfile( @@ -249,54 +250,59 @@ static int loose_lookup_to_packfile( git_repository *repo, const char *name) { - int error = GIT_SUCCESS; git_buf ref_file = GIT_BUF_INIT; struct packref *ref = NULL; size_t name_len; *ref_out = NULL; - error = reference_read(&ref_file, NULL, repo->path_repository, name, NULL); - if (error < GIT_SUCCESS) - goto cleanup; + if (reference_read(&ref_file, NULL, repo->path_repository, name, NULL) < 0) + return -1; name_len = strlen(name); ref = git__malloc(sizeof(struct packref) + name_len + 1); + GITERR_CHECK_ALLOC(ref); memcpy(ref->name, name, name_len); ref->name[name_len] = 0; - error = loose_parse_oid(&ref->oid, &ref_file); - if (error < GIT_SUCCESS) - goto cleanup; + if (loose_parse_oid(&ref->oid, &ref_file) < 0) { + git_buf_free(&ref_file); + git__free(ref); + return -1; + } ref->flags = GIT_PACKREF_WAS_LOOSE; *ref_out = ref; git_buf_free(&ref_file); - return GIT_SUCCESS; - -cleanup: - git_buf_free(&ref_file); - git__free(ref); - - return git__rethrow(error, "Failed to lookup loose reference"); + return 0; } static int loose_write(git_reference *ref) { git_filebuf file = GIT_FILEBUF_INIT; git_buf ref_path = GIT_BUF_INIT; - int error; struct stat st; - error = git_buf_joinpath(&ref_path, ref->owner->path_repository, ref->name); - if (error < GIT_SUCCESS) - goto unlock; + if (git_buf_joinpath(&ref_path, ref->owner->path_repository, ref->name) < 0) + return -1; - error = git_filebuf_open(&file, ref_path.ptr, GIT_FILEBUF_FORCE); - if (error < GIT_SUCCESS) - goto unlock; + /* Remove a possibly existing empty directory hierarchy + * which name would collide with the reference name + */ + if (git_path_isdir(git_buf_cstr(&ref_path)) && + (git_futils_rmdir_r(git_buf_cstr(&ref_path), GIT_DIRREMOVAL_ONLY_EMPTY_DIRS) < 0)) { + git_buf_free(&ref_path); + return -1; + } + + if (git_filebuf_open(&file, ref_path.ptr, GIT_FILEBUF_FORCE) < 0) { + git_buf_free(&ref_path); + return -1; + } + + git_buf_free(&ref_path); if (ref->flags & GIT_REF_OID) { char oid[GIT_OID_HEXSZ + 1]; @@ -304,29 +310,18 @@ static int loose_write(git_reference *ref) git_oid_fmt(oid, &ref->target.oid); oid[GIT_OID_HEXSZ] = '\0'; - error = git_filebuf_printf(&file, "%s\n", oid); - if (error < GIT_SUCCESS) - goto unlock; + git_filebuf_printf(&file, "%s\n", oid); - } else if (ref->flags & GIT_REF_SYMBOLIC) { /* GIT_REF_SYMBOLIC */ - error = git_filebuf_printf(&file, GIT_SYMREF "%s\n", ref->target.symbolic); + } else if (ref->flags & GIT_REF_SYMBOLIC) { + git_filebuf_printf(&file, GIT_SYMREF "%s\n", ref->target.symbolic); } else { - error = git__throw(GIT_EOBJCORRUPTED, - "Failed to write reference. Invalid reference type"); - goto unlock; + assert(0); /* don't let this happen */ } - if (p_stat(ref_path.ptr, &st) == GIT_SUCCESS) + if (p_stat(ref_path.ptr, &st) == 0) ref->mtime = st.st_mtime; - git_buf_free(&ref_path); - return git_filebuf_commit(&file, GIT_REFS_FILE_MODE); - -unlock: - git_buf_free(&ref_path); - git_filebuf_cleanup(&file); - return git__rethrow(error, "Failed to write loose reference"); } static int packed_parse_peel( @@ -340,34 +335,32 @@ static int packed_parse_peel( /* Ensure it's not the first entry of the file */ if (tag_ref == NULL) - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. " - "Reference is the first entry of the file"); + goto corrupt; /* Ensure reference is a tag */ if (git__prefixcmp(tag_ref->name, GIT_REFS_TAGS_DIR) != 0) - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. Reference is not a tag"); + goto corrupt; if (buffer + GIT_OID_HEXSZ >= buffer_end) - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. Buffer too small"); + goto corrupt; /* Is this a valid object id? */ - if (git_oid_fromstr(&tag_ref->peel, buffer) < GIT_SUCCESS) - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. Not a valid object ID"); + if (git_oid_fromstr(&tag_ref->peel, buffer) < 0) + goto corrupt; buffer = buffer + GIT_OID_HEXSZ; if (*buffer == '\r') buffer++; if (*buffer != '\n') - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. Buffer not terminated correctly"); + goto corrupt; *buffer_out = buffer + 1; - return GIT_SUCCESS; + return 0; + +corrupt: + giterr_set(GITERR_REFERENCE, "The packed references file is corrupted"); + return -1; } static int packed_parse_oid( @@ -380,26 +373,20 @@ static int packed_parse_oid( const char *buffer = *buffer_out; const char *refname_begin, *refname_end; - int error = GIT_SUCCESS; size_t refname_len; git_oid id; refname_begin = (buffer + GIT_OID_HEXSZ + 1); - if (refname_begin >= buffer_end || - refname_begin[-1] != ' ') { - error = GIT_EPACKEDREFSCORRUPTED; - goto cleanup; - } + if (refname_begin >= buffer_end || refname_begin[-1] != ' ') + goto corrupt; /* Is this a valid object id? */ - if ((error = git_oid_fromstr(&id, buffer)) < GIT_SUCCESS) - goto cleanup; + if (git_oid_fromstr(&id, buffer) < 0) + goto corrupt; refname_end = memchr(refname_begin, '\n', buffer_end - refname_begin); - if (refname_end == NULL) { - error = GIT_EPACKEDREFSCORRUPTED; - goto cleanup; - } + if (refname_end == NULL) + goto corrupt; if (refname_end[-1] == '\r') refname_end--; @@ -407,6 +394,7 @@ static int packed_parse_oid( refname_len = refname_end - refname_begin; ref = git__malloc(sizeof(struct packref) + refname_len + 1); + GITERR_CHECK_ALLOC(ref); memcpy(ref->name, refname_begin, refname_len); ref->name[refname_len] = 0; @@ -418,32 +406,28 @@ static int packed_parse_oid( *ref_out = ref; *buffer_out = refname_end + 1; - return GIT_SUCCESS; + return 0; -cleanup: +corrupt: git__free(ref); - return git__rethrow(error, "Failed to parse OID of packed reference"); + giterr_set(GITERR_REFERENCE, "The packed references file is corrupted"); + return -1; } static int packed_load(git_repository *repo) { - int error = GIT_SUCCESS, updated; + int result, updated; git_buf packfile = GIT_BUF_INIT; const char *buffer_start, *buffer_end; git_refcache *ref_cache = &repo->references; /* First we make sure we have allocated the hash table */ if (ref_cache->packfile == NULL) { - ref_cache->packfile = git_hashtable_alloc( - default_table_size, git_hash__strhash_cb, git_hash__strcmp_cb); - - if (ref_cache->packfile == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + ref_cache->packfile = git_strmap_alloc(); + GITERR_CHECK_ALLOC(ref_cache->packfile); } - error = reference_read(&packfile, &ref_cache->packfile_time, + result = reference_read(&packfile, &ref_cache->packfile_time, repo->path_repository, GIT_PACKEDREFS_FILE, &updated); /* @@ -453,62 +437,59 @@ static int packed_load(git_repository *repo) * for us here, so just return. Anything else means we need to * refresh the packed refs. */ - if (error == GIT_ENOTFOUND) { - git_hashtable_clear(ref_cache->packfile); - return GIT_SUCCESS; - } else if (error < GIT_SUCCESS) { - return git__rethrow(error, "Failed to read packed refs"); - } else if (!updated) { - return GIT_SUCCESS; + if (result == GIT_ENOTFOUND) { + git_strmap_clear(ref_cache->packfile); + return 0; } + if (result < 0) + return -1; + + if (!updated) + return 0; + /* * At this point, we want to refresh the packed refs. We already * have the contents in our buffer. */ - - git_hashtable_clear(ref_cache->packfile); + git_strmap_clear(ref_cache->packfile); buffer_start = (const char *)packfile.ptr; buffer_end = (const char *)(buffer_start) + packfile.size; while (buffer_start < buffer_end && buffer_start[0] == '#') { buffer_start = strchr(buffer_start, '\n'); - if (buffer_start == NULL) { - error = GIT_EPACKEDREFSCORRUPTED; - goto cleanup; - } + if (buffer_start == NULL) + goto parse_failed; + buffer_start++; } while (buffer_start < buffer_end) { + int err; struct packref *ref = NULL; - error = packed_parse_oid(&ref, &buffer_start, buffer_end); - if (error < GIT_SUCCESS) - goto cleanup; + if (packed_parse_oid(&ref, &buffer_start, buffer_end) < 0) + goto parse_failed; if (buffer_start[0] == '^') { - error = packed_parse_peel(ref, &buffer_start, buffer_end); - if (error < GIT_SUCCESS) - goto cleanup; + if (packed_parse_peel(ref, &buffer_start, buffer_end) < 0) + goto parse_failed; } - error = git_hashtable_insert(ref_cache->packfile, ref->name, ref); - if (error < GIT_SUCCESS) { - git__free(ref); - goto cleanup; - } + git_strmap_insert(ref_cache->packfile, ref->name, ref, err); + if (err < 0) + goto parse_failed; } git_buf_free(&packfile); - return GIT_SUCCESS; + return 0; -cleanup: - git_hashtable_free(ref_cache->packfile); +parse_failed: + git_strmap_free(ref_cache->packfile); ref_cache->packfile = NULL; git_buf_free(&packfile); - return git__rethrow(error, "Failed to load packed references"); + return -1; } @@ -526,17 +507,17 @@ static int _dirent_loose_listall(void *_data, git_buf *full_path) struct dirent_list_data *data = (struct dirent_list_data *)_data; const char *file_path = full_path->ptr + data->repo_path_len; - if (git_path_isdir(full_path->ptr) == GIT_SUCCESS) + if (git_path_isdir(full_path->ptr) == true) return git_path_direach(full_path, _dirent_loose_listall, _data); /* do not add twice a reference that exists already in the packfile */ if ((data->list_flags & GIT_REF_PACKED) != 0 && - git_hashtable_lookup(data->repo->references.packfile, file_path) != NULL) - return GIT_SUCCESS; + git_strmap_exists(data->repo->references.packfile, file_path)) + return 0; if (data->list_flags != GIT_REF_LISTALL) { if ((data->list_flags & loose_guess_rtype(full_path)) == 0) - return GIT_SUCCESS; /* we are filtering out this reference */ + return 0; /* we are filtering out this reference */ } return data->callback(file_path, data->callback_payload); @@ -548,30 +529,25 @@ static int _dirent_loose_load(void *data, git_buf *full_path) void *old_ref = NULL; struct packref *ref; const char *file_path; - int error; + int err; - if (git_path_isdir(full_path->ptr) == GIT_SUCCESS) + if (git_path_isdir(full_path->ptr) == true) return git_path_direach(full_path, _dirent_loose_load, repository); file_path = full_path->ptr + strlen(repository->path_repository); - error = loose_lookup_to_packfile(&ref, repository, file_path); - if (error == GIT_SUCCESS) { + if (loose_lookup_to_packfile(&ref, repository, file_path) < 0) + return -1; - if (git_hashtable_insert2( - repository->references.packfile, - ref->name, ref, &old_ref) < GIT_SUCCESS) { - git__free(ref); - return GIT_ENOMEM; - } - - if (old_ref != NULL) - git__free(old_ref); + git_strmap_insert2( + repository->references.packfile, ref->name, ref, old_ref, err); + if (err < 0) { + git__free(ref); + return -1; } - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to load loose references into packfile"); + git__free(old_ref); + return 0; } /* @@ -582,24 +558,24 @@ static int _dirent_loose_load(void *data, git_buf *full_path) */ static int packed_loadloose(git_repository *repository) { - int error = GIT_SUCCESS; git_buf refs_path = GIT_BUF_INIT; + int result; /* the packfile must have been previously loaded! */ assert(repository->references.packfile); - if ((error = git_buf_joinpath(&refs_path, - repository->path_repository, GIT_REFS_DIR)) < GIT_SUCCESS) - return error; + if (git_buf_joinpath(&refs_path, repository->path_repository, GIT_REFS_DIR) < 0) + return -1; /* * Load all the loose files from disk into the Packfile table. * This will overwrite any old packed entries with their * updated loose versions */ - error = git_path_direach(&refs_path, _dirent_loose_load, repository); + result = git_path_direach(&refs_path, _dirent_loose_load, repository); git_buf_free(&refs_path); - return error; + + return result; } /* @@ -607,7 +583,6 @@ static int packed_loadloose(git_repository *repository) */ static int packed_write_ref(struct packref *ref, git_filebuf *file) { - int error; char oid[GIT_OID_HEXSZ + 1]; git_oid_fmt(oid, &ref->oid); @@ -628,14 +603,14 @@ static int packed_write_ref(struct packref *ref, git_filebuf *file) git_oid_fmt(peel, &ref->peel); peel[GIT_OID_HEXSZ] = 0; - error = git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel); + if (git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel) < 0) + return -1; } else { - error = git_filebuf_printf(file, "%s %s\n", oid, ref->name); + if (git_filebuf_printf(file, "%s %s\n", oid, ref->name) < 0) + return -1; } - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to write packed reference"); + return 0; } /* @@ -649,24 +624,22 @@ static int packed_write_ref(struct packref *ref, git_filebuf *file) static int packed_find_peel(git_repository *repo, struct packref *ref) { git_object *object; - int error; if (ref->flags & GIT_PACKREF_HAS_PEEL) - return GIT_SUCCESS; + return 0; /* * Only applies to tags, i.e. references * in the /refs/tags folder */ if (git__prefixcmp(ref->name, GIT_REFS_TAGS_DIR) != 0) - return GIT_SUCCESS; + return 0; /* * Find the tagged object in the repository */ - error = git_object_lookup(&object, repo, &ref->oid, GIT_OBJ_ANY); - if (error < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Failed to find packed reference"); + if (git_object_lookup(&object, repo, &ref->oid, GIT_OBJ_ANY) < 0) + return -1; /* * If the tagged object is a Tag object, we need to resolve it; @@ -690,7 +663,7 @@ static int packed_find_peel(git_repository *repo, struct packref *ref) } git_object_free(object); - return GIT_SUCCESS; + return 0; } /* @@ -708,25 +681,27 @@ static int packed_remove_loose(git_repository *repo, git_vector *packing_list) { unsigned int i; git_buf full_path = GIT_BUF_INIT; - int error = GIT_SUCCESS; + int failed = 0; for (i = 0; i < packing_list->length; ++i) { struct packref *ref = git_vector_get(packing_list, i); - int an_error; if ((ref->flags & GIT_PACKREF_WAS_LOOSE) == 0) continue; - an_error = git_buf_joinpath(&full_path, repo->path_repository, ref->name); + if (git_buf_joinpath(&full_path, repo->path_repository, ref->name) < 0) + return -1; /* critical; do not try to recover on oom */ - if (an_error == GIT_SUCCESS && - git_path_exists(full_path.ptr) == GIT_SUCCESS && - p_unlink(full_path.ptr) < GIT_SUCCESS) - an_error = GIT_EOSERR; + if (git_path_exists(full_path.ptr) == true && p_unlink(full_path.ptr) < 0) { + if (failed) + continue; - /* keep the error if we haven't seen one yet */ - if (error > an_error) - error = an_error; + giterr_set(GITERR_REFERENCE, + "Failed to remove loose reference '%s' after packing: %s", + full_path.ptr, strerror(errno)); + + failed = 1; + } /* * if we fail to remove a single file, this is *not* good, @@ -737,10 +712,7 @@ static int packed_remove_loose(git_repository *repo, git_vector *packing_list) } git_buf_free(&full_path); - - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to remove loose packed reference"); + return failed ? -1 : 0; } static int packed_sort(const void *a, const void *b) @@ -757,176 +729,228 @@ static int packed_sort(const void *a, const void *b) static int packed_write(git_repository *repo) { git_filebuf pack_file = GIT_FILEBUF_INIT; - int error; - const char *errmsg = "Failed to write packed references file"; unsigned int i; git_buf pack_file_path = GIT_BUF_INIT; git_vector packing_list; - size_t total_refs; + unsigned int total_refs; assert(repo && repo->references.packfile); - total_refs = repo->references.packfile->key_count; - if ((error = - git_vector_init(&packing_list, total_refs, packed_sort)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to init packed references list"); + total_refs = + (unsigned int)git_strmap_num_entries(repo->references.packfile); + + if (git_vector_init(&packing_list, total_refs, packed_sort) < 0) + return -1; /* Load all the packfile into a vector */ { struct packref *reference; - GIT_HASHTABLE_FOREACH_VALUE(repo->references.packfile, reference, - /* cannot fail: vector already has the right size */ + /* cannot fail: vector already has the right size */ + git_strmap_foreach_value(repo->references.packfile, reference, { git_vector_insert(&packing_list, reference); - ); + }); } /* sort the vector so the entries appear sorted on the packfile */ git_vector_sort(&packing_list); /* Now we can open the file! */ - error = git_buf_joinpath(&pack_file_path, repo->path_repository, GIT_PACKEDREFS_FILE); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_buf_joinpath(&pack_file_path, repo->path_repository, GIT_PACKEDREFS_FILE) < 0) + goto cleanup_memory; - if ((error = git_filebuf_open(&pack_file, pack_file_path.ptr, 0)) < GIT_SUCCESS) { - errmsg = "Failed to open packed references file"; - goto cleanup; - } + if (git_filebuf_open(&pack_file, pack_file_path.ptr, 0) < 0) + goto cleanup_packfile; /* Packfiles have a header... apparently * This is in fact not required, but we might as well print it * just for kicks */ - if ((error = - git_filebuf_printf(&pack_file, "%s\n", GIT_PACKEDREFS_HEADER)) < GIT_SUCCESS) { - errmsg = "Failed to write packed references file header"; - goto cleanup; - } + if (git_filebuf_printf(&pack_file, "%s\n", GIT_PACKEDREFS_HEADER) < 0) + goto cleanup_packfile; for (i = 0; i < packing_list.length; ++i) { struct packref *ref = (struct packref *)git_vector_get(&packing_list, i); - if ((error = packed_find_peel(repo, ref)) < GIT_SUCCESS) { - error = git__throw(GIT_EOBJCORRUPTED, - "A reference cannot be peeled"); - goto cleanup; - } + if (packed_find_peel(repo, ref) < 0) + goto cleanup_packfile; - if ((error = packed_write_ref(ref, &pack_file)) < GIT_SUCCESS) - goto cleanup; + if (packed_write_ref(ref, &pack_file) < 0) + goto cleanup_packfile; } -cleanup: /* if we've written all the references properly, we can commit * the packfile to make the changes effective */ - if (error == GIT_SUCCESS) { - error = git_filebuf_commit(&pack_file, GIT_PACKEDREFS_FILE_MODE); + if (git_filebuf_commit(&pack_file, GIT_PACKEDREFS_FILE_MODE) < 0) + goto cleanup_memory; - /* when and only when the packfile has been properly written, - * we can go ahead and remove the loose refs */ - if (error == GIT_SUCCESS) { - struct stat st; + /* when and only when the packfile has been properly written, + * we can go ahead and remove the loose refs */ + if (packed_remove_loose(repo, &packing_list) < 0) + goto cleanup_memory; - error = packed_remove_loose(repo, &packing_list); - - if (p_stat(pack_file_path.ptr, &st) == GIT_SUCCESS) - repo->references.packfile_time = st.st_mtime; - } - } - else git_filebuf_cleanup(&pack_file); + { + struct stat st; + if (p_stat(pack_file_path.ptr, &st) == 0) + repo->references.packfile_time = st.st_mtime; + } git_vector_free(&packing_list); git_buf_free(&pack_file_path); - if (error < GIT_SUCCESS) - git__rethrow(error, "%s", errmsg); + /* we're good now */ + return 0; - return error; +cleanup_packfile: + git_filebuf_cleanup(&pack_file); + +cleanup_memory: + git_vector_free(&packing_list); + git_buf_free(&pack_file_path); + + return -1; } +struct reference_available_t { + const char *new_ref; + const char *old_ref; + int available; +}; + static int _reference_available_cb(const char *ref, void *data) { - const char *new, *old; - const char **refs; + struct reference_available_t *d; assert(ref && data); + d = (struct reference_available_t *)data; - refs = (const char **)data; + if (!d->old_ref || strcmp(d->old_ref, ref)) { + size_t reflen = strlen(ref); + size_t newlen = strlen(d->new_ref); + size_t cmplen = reflen < newlen ? reflen : newlen; + const char *lead = reflen < newlen ? d->new_ref : ref; - new = (const char *)refs[0]; - old = (const char *)refs[1]; - - if (!old || strcmp(old, ref)) { - int reflen = strlen(ref); - int newlen = strlen(new); - int cmplen = reflen < newlen ? reflen : newlen; - const char *lead = reflen < newlen ? new : ref; - - if (!strncmp(new, ref, cmplen) && - lead[cmplen] == '/') - return GIT_EEXISTS; + if (!strncmp(d->new_ref, ref, cmplen) && lead[cmplen] == '/') { + d->available = 0; + return -1; + } } - return GIT_SUCCESS; + return 0; } -static int reference_available( +static int reference_path_available( git_repository *repo, const char *ref, const char* old_ref) { - const char *refs[2]; + struct reference_available_t data; - refs[0] = ref; - refs[1] = old_ref; + data.new_ref = ref; + data.old_ref = old_ref; + data.available = 1; if (git_reference_foreach(repo, GIT_REF_LISTALL, - _reference_available_cb, (void *)refs) < 0) { - return git__throw(GIT_EEXISTS, - "Reference name `%s` conflicts with existing reference", ref); + _reference_available_cb, (void *)&data) < 0) + return -1; + + if (!data.available) { + giterr_set(GITERR_REFERENCE, + "The path to reference '%s' collides with an existing one", ref); + return -1; } - return GIT_SUCCESS; + return 0; } static int reference_exists(int *exists, git_repository *repo, const char *ref_name) { - int error; git_buf ref_path = GIT_BUF_INIT; - error = packed_load(repo); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Cannot resolve if a reference exists"); + if (packed_load(repo) < 0) + return -1; - error = git_buf_joinpath(&ref_path, repo->path_repository, ref_name); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Cannot resolve if a reference exists"); + if (git_buf_joinpath(&ref_path, repo->path_repository, ref_name) < 0) + return -1; - if (git_path_isfile(ref_path.ptr) == GIT_SUCCESS || - git_hashtable_lookup(repo->references.packfile, ref_path.ptr) != NULL) { + if (git_path_isfile(ref_path.ptr) == true || + git_strmap_exists(repo->references.packfile, ref_path.ptr)) + { *exists = 1; } else { *exists = 0; } git_buf_free(&ref_path); - - return GIT_SUCCESS; + return 0; } +/* + * Check if a reference could be written to disk, based on: + * + * - Whether a reference with the same name already exists, + * and we are allowing or disallowing overwrites + * + * - Whether the name of the reference would collide with + * an existing path + */ +static int reference_can_write( + git_repository *repo, + const char *refname, + const char *previous_name, + int force) +{ + /* see if the reference shares a path with an existing reference; + * if a path is shared, we cannot create the reference, even when forcing */ + if (reference_path_available(repo, refname, previous_name) < 0) + return -1; + + /* check if the reference actually exists, but only if we are not forcing + * the rename. If we are forcing, it's OK to overwrite */ + if (!force) { + int exists; + + if (reference_exists(&exists, repo, refname) < 0) + return -1; + + /* We cannot proceed if the reference already exists and we're not forcing + * the rename; the existing one would be overwritten */ + if (exists) { + giterr_set(GITERR_REFERENCE, + "A reference with that name (%s) already exists", refname); + return GIT_EEXISTS; + } + } + + /* FIXME: if the reference exists and we are forcing, do we really need to + * remove the reference first? + * + * Two cases: + * + * - the reference already exists and is loose: not a problem, the file + * gets overwritten on disk + * + * - the reference already exists and is packed: we write a new one as + * loose, which by all means renders the packed one useless + */ + + return 0; +} + + static int packed_lookup(git_reference *ref) { - int error; struct packref *pack_ref = NULL; + git_strmap *packfile_refs; + khiter_t pos; - error = packed_load(ref->owner); - if (error < GIT_SUCCESS) - return git__rethrow(error, - "Failed to lookup reference from packfile"); + if (packed_load(ref->owner) < 0) + return -1; - if (ref->flags & GIT_REF_PACKED && + /* maybe the packfile hasn't changed at all, so we don't + * have to re-lookup the reference */ + if ((ref->flags & GIT_REF_PACKED) && ref->mtime == ref->owner->references.packfile_time) - return GIT_SUCCESS; + return 0; if (ref->flags & GIT_REF_SYMBOLIC) { git__free(ref->target.symbolic); @@ -934,39 +958,42 @@ static int packed_lookup(git_reference *ref) } /* Look up on the packfile */ - pack_ref = git_hashtable_lookup(ref->owner->references.packfile, ref->name); - if (pack_ref == NULL) - return git__throw(GIT_ENOTFOUND, - "Failed to lookup reference from packfile"); + packfile_refs = ref->owner->references.packfile; + pos = git_strmap_lookup_index(packfile_refs, ref->name); + if (!git_strmap_valid_index(packfile_refs, pos)) { + giterr_set(GITERR_REFERENCE, "Reference '%s' not found", ref->name); + return GIT_ENOTFOUND; + } + + pack_ref = git_strmap_value_at(packfile_refs, pos); ref->flags = GIT_REF_OID | GIT_REF_PACKED; ref->mtime = ref->owner->references.packfile_time; git_oid_cpy(&ref->target.oid, &pack_ref->oid); - return GIT_SUCCESS; + return 0; } static int reference_lookup(git_reference *ref) { - int error_loose, error_packed; + int result; - error_loose = loose_lookup(ref); - if (error_loose == GIT_SUCCESS) - return GIT_SUCCESS; + result = loose_lookup(ref); + if (result == 0) + return 0; - error_packed = packed_lookup(ref); - if (error_packed == GIT_SUCCESS) - return GIT_SUCCESS; + /* only try to lookup this reference on the packfile if it + * wasn't found on the loose refs; not if there was a critical error */ + if (result == GIT_ENOTFOUND) { + giterr_clear(); + result = packed_lookup(ref); + if (result == 0) + return 0; + } + /* unexpected error; free the reference */ git_reference_free(ref); - - if (error_loose != GIT_ENOTFOUND) - return git__rethrow(error_loose, "Failed to lookup reference"); - - if (error_packed != GIT_ENOTFOUND) - return git__rethrow(error_packed, "Failed to lookup reference"); - - return git__throw(GIT_ENOTFOUND, "Reference not found"); + return result; } /* @@ -976,7 +1003,7 @@ static int reference_lookup(git_reference *ref) */ static int reference_delete(git_reference *ref) { - int error; + int result; assert(ref); @@ -984,17 +1011,28 @@ static int reference_delete(git_reference *ref) * We need to reload the packfile, remove the reference from the * packing list, and repack */ if (ref->flags & GIT_REF_PACKED) { + git_strmap *packfile_refs; struct packref *packref; + khiter_t pos; + /* load the existing packfile */ - if ((error = packed_load(ref->owner)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to delete reference"); + if (packed_load(ref->owner) < 0) + return -1; - if (git_hashtable_remove2(ref->owner->references.packfile, - ref->name, (void **) &packref) < GIT_SUCCESS) - return git__throw(GIT_ENOTFOUND, "Reference not found"); + packfile_refs = ref->owner->references.packfile; + pos = git_strmap_lookup_index(packfile_refs, ref->name); + if (!git_strmap_valid_index(packfile_refs, pos)) { + giterr_set(GITERR_REFERENCE, + "Reference %s stopped existing in the packfile", ref->name); + return -1; + } - git__free (packref); - error = packed_write(ref->owner); + packref = git_strmap_value_at(packfile_refs, pos); + git_strmap_delete_at(packfile_refs, pos); + + git__free(packref); + if (packed_write(ref->owner) < 0) + return -1; /* If the reference is loose, we can just remove the reference * from the filesystem */ @@ -1002,66 +1040,114 @@ static int reference_delete(git_reference *ref) git_reference *ref_in_pack; git_buf full_path = GIT_BUF_INIT; - error = git_buf_joinpath(&full_path, ref->owner->path_repository, ref->name); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_buf_joinpath(&full_path, ref->owner->path_repository, ref->name) < 0) + return -1; - error = p_unlink(full_path.ptr); + result = p_unlink(full_path.ptr); git_buf_free(&full_path); /* done with path at this point */ - if (error < GIT_SUCCESS) - goto cleanup; + + if (result < 0) { + giterr_set(GITERR_OS, "Failed to unlink '%s'", full_path.ptr); + return -1; + } /* When deleting a loose reference, we have to ensure that an older * packed version of it doesn't exist */ - if (git_reference_lookup(&ref_in_pack, ref->owner, - ref->name) == GIT_SUCCESS) { + if (git_reference_lookup(&ref_in_pack, ref->owner, ref->name) == 0) { assert((ref_in_pack->flags & GIT_REF_PACKED) != 0); - error = git_reference_delete(ref_in_pack); + return git_reference_delete(ref_in_pack); } + + giterr_clear(); } -cleanup: - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to delete reference"); + return 0; } int git_reference_delete(git_reference *ref) { - int error = reference_delete(ref); - if (error < GIT_SUCCESS) - return error; - + int result = reference_delete(ref); git_reference_free(ref); - return GIT_SUCCESS; + return result; } - int git_reference_lookup(git_reference **ref_out, git_repository *repo, const char *name) +{ + return git_reference_lookup_resolved(ref_out, repo, name, 0); +} + +int git_reference_name_to_oid( + git_oid *out, git_repository *repo, const char *name) { int error; - char normalized_name[GIT_REFNAME_MAX]; - git_reference *ref = NULL; + git_reference *ref; + + if ((error = git_reference_lookup_resolved(&ref, repo, name, -1)) < 0) + return error; + + git_oid_cpy(out, git_reference_oid(ref)); + git_reference_free(ref); + return 0; +} + +int git_reference_lookup_resolved( + git_reference **ref_out, + git_repository *repo, + const char *name, + int max_nesting) +{ + git_reference *scan; + int result, nesting; assert(ref_out && repo && name); *ref_out = NULL; - error = normalize_name(normalized_name, sizeof(normalized_name), name, 0); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup reference"); + if (max_nesting > MAX_NESTING_LEVEL) + max_nesting = MAX_NESTING_LEVEL; + else if (max_nesting < 0) + max_nesting = DEFAULT_NESTING_LEVEL; - error = reference_alloc(&ref, repo, normalized_name); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup reference"); + scan = git__calloc(1, sizeof(git_reference)); + GITERR_CHECK_ALLOC(scan); - error = reference_lookup(ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup reference"); + scan->name = git__calloc(GIT_REFNAME_MAX + 1, sizeof(char)); + GITERR_CHECK_ALLOC(scan->name); - *ref_out = ref; - return GIT_SUCCESS; + if ((result = normalize_name(scan->name, GIT_REFNAME_MAX, name, 0)) < 0) { + git_reference_free(scan); + return result; + } + + scan->target.symbolic = git__strdup(scan->name); + GITERR_CHECK_ALLOC(scan->target.symbolic); + + scan->owner = repo; + scan->flags = GIT_REF_SYMBOLIC; + + for (nesting = max_nesting; + nesting >= 0 && (scan->flags & GIT_REF_SYMBOLIC) != 0; + nesting--) + { + if (nesting != max_nesting) + strncpy(scan->name, scan->target.symbolic, GIT_REFNAME_MAX); + + scan->mtime = 0; + + if ((result = reference_lookup(scan)) < 0) + return result; /* lookup git_reference_free on scan already */ + } + + if ((scan->flags & GIT_REF_OID) == 0 && max_nesting != 0) { + giterr_set(GITERR_REFERENCE, + "Cannot resolve reference (>%u levels deep)", max_nesting); + git_reference_free(scan); + return -1; + } + + *ref_out = scan; + return 0; } /** @@ -1126,43 +1212,32 @@ int git_reference_create_symbolic( int force) { char normalized[GIT_REFNAME_MAX]; - int ref_exists, error = GIT_SUCCESS; git_reference *ref = NULL; - error = normalize_name(normalized, sizeof(normalized), name, 0); - if (error < GIT_SUCCESS) - goto cleanup; + if (normalize_name(normalized, sizeof(normalized), name, 0) < 0) + return -1; - if ((error = reference_exists(&ref_exists, repo, normalized) < GIT_SUCCESS)) - return git__rethrow(error, "Failed to create symbolic reference"); + if (reference_can_write(repo, normalized, NULL, force) < 0) + return -1; - if (ref_exists && !force) - return git__throw(GIT_EEXISTS, - "Failed to create symbolic reference. Reference already exists"); - - error = reference_alloc(&ref, repo, normalized); - if (error < GIT_SUCCESS) - goto cleanup; + if (reference_alloc(&ref, repo, normalized) < 0) + return -1; ref->flags |= GIT_REF_SYMBOLIC; /* set the target; this will normalize the name automatically * and write the reference on disk */ - error = git_reference_set_target(ref, target); - if (error < GIT_SUCCESS) - goto cleanup; - + if (git_reference_set_target(ref, target) < 0) { + git_reference_free(ref); + return -1; + } if (ref_out == NULL) { git_reference_free(ref); } else { *ref_out = ref; } - return GIT_SUCCESS; - -cleanup: - git_reference_free(ref); - return git__rethrow(error, "Failed to create symbolic reference"); + return 0; } int git_reference_create_oid( @@ -1172,34 +1247,25 @@ int git_reference_create_oid( const git_oid *id, int force) { - int error = GIT_SUCCESS, ref_exists; git_reference *ref = NULL; char normalized[GIT_REFNAME_MAX]; - error = normalize_name(normalized, sizeof(normalized), name, 1); - if (error < GIT_SUCCESS) - goto cleanup; + if (normalize_name(normalized, sizeof(normalized), name, 1) < 0) + return -1; - if ((error = reference_exists(&ref_exists, repo, normalized) < GIT_SUCCESS)) - return git__rethrow(error, "Failed to create OID reference"); + if (reference_can_write(repo, normalized, NULL, force) < 0) + return -1; - if (ref_exists && !force) - return git__throw(GIT_EEXISTS, - "Failed to create OID reference. Reference already exists"); - - if ((error = reference_available(repo, name, NULL)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to create reference"); - - error = reference_alloc(&ref, repo, name); - if (error < GIT_SUCCESS) - goto cleanup; + if (reference_alloc(&ref, repo, name) < 0) + return -1; ref->flags |= GIT_REF_OID; /* set the oid; this will write the reference on disk */ - error = git_reference_set_oid(ref, id); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_reference_set_oid(ref, id) < 0) { + git_reference_free(ref); + return -1; + } if (ref_out == NULL) { git_reference_free(ref); @@ -1207,13 +1273,8 @@ int git_reference_create_oid( *ref_out = ref; } - return GIT_SUCCESS; - -cleanup: - git_reference_free(ref); - return git__rethrow(error, "Failed to create reference OID"); + return 0; } - /* * Change the OID target of a reference. * @@ -1225,38 +1286,31 @@ cleanup: */ int git_reference_set_oid(git_reference *ref, const git_oid *id) { - int error = GIT_SUCCESS, exists; git_odb *odb = NULL; - if ((ref->flags & GIT_REF_OID) == 0) - return git__throw(GIT_EINVALIDREFSTATE, - "Failed to set OID target of reference. Not an OID reference"); + if ((ref->flags & GIT_REF_OID) == 0) { + giterr_set(GITERR_REFERENCE, "Cannot set OID on symbolic reference"); + return -1; + } assert(ref->owner); - error = git_repository_odb__weakptr(&odb, ref->owner); - if (error < GIT_SUCCESS) - return error; - - exists = git_odb_exists(odb, id); - - git_odb_free(odb); + if (git_repository_odb__weakptr(&odb, ref->owner) < 0) + return -1; /* Don't let the user create references to OIDs that * don't exist in the ODB */ - if (!exists) - return git__throw(GIT_ENOTFOUND, - "Failed to set OID target of reference. OID doesn't exist in ODB"); + if (!git_odb_exists(odb, id)) { + giterr_set(GITERR_REFERENCE, + "Target OID for the reference doesn't exist on the repository"); + return -1; + } /* Update the OID value on `ref` */ git_oid_cpy(&ref->target.oid, id); /* Write back to disk */ - error = loose_write(ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to set OID target of reference"); - - return GIT_SUCCESS; + return loose_write(ref); } /* @@ -1268,82 +1322,44 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id) */ int git_reference_set_target(git_reference *ref, const char *target) { - int error; char normalized[GIT_REFNAME_MAX]; - if ((ref->flags & GIT_REF_SYMBOLIC) == 0) - return git__throw(GIT_EINVALIDREFSTATE, - "Failed to set reference target. Not a symbolic reference"); + if ((ref->flags & GIT_REF_SYMBOLIC) == 0) { + giterr_set(GITERR_REFERENCE, + "Cannot set symbolic target on a direct reference"); + return -1; + } - error = normalize_name(normalized, sizeof(normalized), target, 0); - if (error < GIT_SUCCESS) - return git__rethrow(error, - "Failed to set reference target. Invalid target name"); + if (normalize_name(normalized, sizeof(normalized), target, 0)) + return -1; git__free(ref->target.symbolic); ref->target.symbolic = git__strdup(normalized); - if (ref->target.symbolic == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(ref->target.symbolic); return loose_write(ref); } int git_reference_rename(git_reference *ref, const char *new_name, int force) { - int error; + int result; git_buf aux_path = GIT_BUF_INIT; char normalized[GIT_REFNAME_MAX]; const char *head_target = NULL; - git_reference *existing_ref = NULL, *head = NULL; + git_reference *head = NULL; - error = normalize_name(normalized, sizeof(normalized), - new_name, ref->flags & GIT_REF_OID); + if (normalize_name(normalized, sizeof(normalized), + new_name, ref->flags & GIT_REF_OID) < 0) + return -1; - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to rename reference. Invalid name"); - - new_name = normalized; - - /* If we are forcing the rename, try to lookup a reference with the - * new one. If the lookup succeeds, we need to delete that ref - * before the renaming can proceed */ - if (force) { - error = git_reference_lookup(&existing_ref, ref->owner, new_name); - - if (error == GIT_SUCCESS) { - error = git_reference_delete(existing_ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, - "Failed to rename reference. " - "The existing reference cannot be deleted"); - } else if (error != GIT_ENOTFOUND) - goto cleanup; - - /* If we're not forcing the rename, check if the reference exists. - * If it does, renaming cannot continue */ - } else { - int exists; - - error = reference_exists(&exists, ref->owner, normalized); - if (error < GIT_SUCCESS) - goto cleanup; - - if (exists) - return git__throw(GIT_EEXISTS, - "Failed to rename reference. Reference already exists"); - } - - if ((error = reference_available(ref->owner, new_name, ref->name)) < GIT_SUCCESS) - return git__rethrow(error, - "Failed to rename reference. Reference already exists"); + if (reference_can_write(ref->owner, normalized, ref->name, force) < 0) + return -1; /* Initialize path now so we won't get an allocation failure once - * we actually start removing things. - */ - error = git_buf_joinpath(&aux_path, ref->owner->path_repository, new_name); - if (error < GIT_SUCCESS) - goto cleanup; + * we actually start removing things. */ + if (git_buf_joinpath(&aux_path, ref->owner->path_repository, new_name) < 0) + return -1; /* * Now delete the old ref and remove an possibly existing directory @@ -1351,57 +1367,54 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force) * method deletes the ref from disk but doesn't free the pointer, so * we can still access the ref's attributes for creating the new one */ - if ((error = reference_delete(ref)) < GIT_SUCCESS) + if (reference_delete(ref) < 0) goto cleanup; - if (git_path_exists(aux_path.ptr) == GIT_SUCCESS) { - if (git_path_isdir(aux_path.ptr) == GIT_SUCCESS) { - if ((error = git_futils_rmdir_r(aux_path.ptr, 0)) < GIT_SUCCESS) - goto rollback; - } else goto rollback; - } - /* * Finally we can create the new reference. */ if (ref->flags & GIT_REF_SYMBOLIC) { - error = git_reference_create_symbolic( - NULL, ref->owner, new_name, ref->target.symbolic, 0); + result = git_reference_create_symbolic( + NULL, ref->owner, new_name, ref->target.symbolic, force); } else { - error = git_reference_create_oid( - NULL, ref->owner, new_name, &ref->target.oid, 0); + result = git_reference_create_oid( + NULL, ref->owner, new_name, &ref->target.oid, force); } - if (error < GIT_SUCCESS) + if (result < 0) goto rollback; /* * Check if we have to update HEAD. */ - error = git_reference_lookup(&head, ref->owner, GIT_HEAD_FILE); - if (error < GIT_SUCCESS) + if (git_reference_lookup(&head, ref->owner, GIT_HEAD_FILE) < 0) { + giterr_set(GITERR_REFERENCE, + "Failed to update HEAD after renaming reference"); goto cleanup; + } head_target = git_reference_target(head); if (head_target && !strcmp(head_target, ref->name)) { - error = git_reference_create_symbolic( - &head, ref->owner, "HEAD", new_name, 1); - - if (error < GIT_SUCCESS) + if (git_reference_create_symbolic(&head, ref->owner, "HEAD", new_name, 1) < 0) { + giterr_set(GITERR_REFERENCE, + "Failed to update HEAD after renaming reference"); goto cleanup; + } } /* * Rename the reflog file. */ - error = git_buf_join_n(&aux_path, '/', 3, ref->owner->path_repository, - GIT_REFLOG_DIR, ref->name); - if (error < GIT_SUCCESS) + if (git_buf_join_n(&aux_path, '/', 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name) < 0) goto cleanup; - if (git_path_exists(aux_path.ptr) == GIT_SUCCESS) - error = git_reflog_rename(ref, new_name); + if (git_path_exists(aux_path.ptr) == true) { + if (git_reflog_rename(ref, new_name) < 0) + goto cleanup; + } else { + giterr_clear(); + } /* * Change the name of the reference given by the user. @@ -1412,92 +1425,49 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force) /* The reference is no longer packed */ ref->flags &= ~GIT_REF_PACKED; -cleanup: - /* We no longer need the newly created reference nor the head */ git_reference_free(head); git_buf_free(&aux_path); - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to rename reference"); + return 0; + +cleanup: + git_reference_free(head); + git_buf_free(&aux_path); + return -1; rollback: /* - * Try to create the old reference again. + * Try to create the old reference again, ignore failures */ if (ref->flags & GIT_REF_SYMBOLIC) - error = git_reference_create_symbolic( + git_reference_create_symbolic( NULL, ref->owner, ref->name, ref->target.symbolic, 0); else - error = git_reference_create_oid( + git_reference_create_oid( NULL, ref->owner, ref->name, &ref->target.oid, 0); /* The reference is no longer packed */ ref->flags &= ~GIT_REF_PACKED; git_buf_free(&aux_path); - - return error == GIT_SUCCESS ? - git__rethrow(GIT_ERROR, "Failed to rename reference. Did rollback") : - git__rethrow(error, "Failed to rename reference. Failed to rollback"); + return -1; } int git_reference_resolve(git_reference **ref_out, git_reference *ref) { - int error, i = 0; - git_repository *repo; - - assert(ref); - - *ref_out = NULL; - repo = ref->owner; - - /* If the reference is already resolved, we need to return a - * copy. Instead of duplicating `ref`, we look it up again to - * ensure the copy is out to date */ if (ref->flags & GIT_REF_OID) return git_reference_lookup(ref_out, ref->owner, ref->name); - - /* Otherwise, keep iterating until the reference is resolved */ - for (i = 0; i < MAX_NESTING_LEVEL; ++i) { - git_reference *new_ref; - - error = git_reference_lookup(&new_ref, repo, ref->target.symbolic); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to resolve reference"); - - /* Free intermediate references, except for the original one - * we've received */ - if (i > 0) - git_reference_free(ref); - - ref = new_ref; - - /* When the reference we've just looked up is an OID, we've - * successfully resolved the symbolic ref */ - if (ref->flags & GIT_REF_OID) { - *ref_out = ref; - return GIT_SUCCESS; - } - } - - return git__throw(GIT_ENOMEM, - "Failed to resolve reference. Reference is too nested"); + else + return git_reference_lookup_resolved(ref_out, ref->owner, ref->target.symbolic, -1); } int git_reference_packall(git_repository *repo) { - int error; + if (packed_load(repo) < 0 || /* load the existing packfile */ + packed_loadloose(repo) < 0 || /* add all the loose refs */ + packed_write(repo) < 0) /* write back to disk */ + return -1; - /* load the existing packfile */ - if ((error = packed_load(repo)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to pack references"); - - /* update it in-memory with all the loose references */ - if ((error = packed_loadloose(repo)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to pack references"); - - /* write it back to disk */ - return packed_write(repo); + return 0; } int git_reference_foreach( @@ -1506,22 +1476,23 @@ int git_reference_foreach( int (*callback)(const char *, void *), void *payload) { - int error; + int result; struct dirent_list_data data; git_buf refs_path = GIT_BUF_INIT; /* list all the packed references first */ if (list_flags & GIT_REF_PACKED) { const char *ref_name; + void *ref; + GIT_UNUSED(ref); - if ((error = packed_load(repo)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to list references"); + if (packed_load(repo) < 0) + return -1; - GIT_HASHTABLE_FOREACH_KEY(repo->references.packfile, ref_name, - if ((error = callback(ref_name, payload)) < GIT_SUCCESS) - return git__throw(error, - "Failed to list references. User callback failed"); - ); + git_strmap_foreach(repo->references.packfile, ref_name, ref, { + if (callback(ref_name, payload) < 0) + return 0; + }); } /* now list the loose references, trying not to @@ -1533,15 +1504,13 @@ int git_reference_foreach( data.callback = callback; data.callback_payload = payload; - if ((error = git_buf_joinpath(&refs_path, - repo->path_repository, GIT_REFS_DIR)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to alloc space for references"); - - error = git_path_direach(&refs_path, _dirent_loose_listall, &data); + if (git_buf_joinpath(&refs_path, repo->path_repository, GIT_REFS_DIR) < 0) + return -1; + result = git_path_direach(&refs_path, _dirent_loose_listall, &data); git_buf_free(&refs_path); - return error; + return result; } static int cb__reflist_add(const char *ref, void *data) @@ -1554,7 +1523,6 @@ int git_reference_listall( git_repository *repo, unsigned int list_flags) { - int error; git_vector ref_list; assert(array && repo); @@ -1562,33 +1530,25 @@ int git_reference_listall( array->strings = NULL; array->count = 0; - if (git_vector_init(&ref_list, 8, NULL) < GIT_SUCCESS) - return GIT_ENOMEM; + if (git_vector_init(&ref_list, 8, NULL) < 0) + return -1; - error = git_reference_foreach( - repo, list_flags, &cb__reflist_add, (void *)&ref_list); - - if (error < GIT_SUCCESS) { + if (git_reference_foreach( + repo, list_flags, &cb__reflist_add, (void *)&ref_list) < 0) { git_vector_free(&ref_list); - return error; + return -1; } array->strings = (char **)ref_list.contents; array->count = ref_list.length; - return GIT_SUCCESS; + return 0; } int git_reference_reload(git_reference *ref) { - int error = reference_lookup(ref); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to reload reference"); - - return GIT_SUCCESS; + return reference_lookup(ref); } - void git_repository__refcache_free(git_refcache *refs) { assert(refs); @@ -1596,10 +1556,11 @@ void git_repository__refcache_free(git_refcache *refs) if (refs->packfile) { struct packref *reference; - GIT_HASHTABLE_FOREACH_VALUE( - refs->packfile, reference, git__free(reference)); + git_strmap_foreach_value(refs->packfile, reference, { + git__free(reference); + }); - git_hashtable_free(refs->packfile); + git_strmap_free(refs->packfile); } } @@ -1643,33 +1604,26 @@ static int normalize_name( /* A refname can not be empty */ if (name_end == name) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name is empty"); + goto invalid_name; /* A refname can not end with a dot or a slash */ if (*(name_end - 1) == '.' || *(name_end - 1) == '/') - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name ends with dot or slash"); + goto invalid_name; while (current < name_end && out_size) { if (!is_valid_ref_char(*current)) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. " - "Reference name contains invalid characters"); + goto invalid_name; if (buffer_out > buffer_out_start) { char prev = *(buffer_out - 1); /* A refname can not start with a dot nor contain a double dot */ if (*current == '.' && ((prev == '.') || (prev == '/'))) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. " - "Reference name starts with a dot or contains a double dot"); + goto invalid_name; /* '@{' is forbidden within a refname */ if (*current == '{' && prev == '@') - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name contains '@{'"); + goto invalid_name; /* Prevent multiple slashes from being added to the output */ if (*current == '/' && prev == '/') { @@ -1686,7 +1640,7 @@ static int normalize_name( } if (!out_size) - return git__throw(GIT_EINVALIDREFNAME, "Reference name is too long"); + goto invalid_name; /* Object id refname have to contain at least one slash, except * for HEAD in a detached state or MERGE_HEAD if we're in the @@ -1696,13 +1650,11 @@ static int normalize_name( strcmp(name, GIT_HEAD_FILE) != 0 && strcmp(name, GIT_MERGE_HEAD_FILE) != 0 && strcmp(name, GIT_FETCH_HEAD_FILE) != 0) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name contains no slashes"); + goto invalid_name; /* A refname can not end with ".lock" */ if (!git__suffixcmp(name, GIT_FILELOCK_EXTENSION)) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name ends with '.lock'"); + goto invalid_name; *buffer_out = '\0'; @@ -1712,11 +1664,13 @@ static int normalize_name( */ if (is_oid_ref && !(git__prefixcmp(buffer_out_start, GIT_REFS_DIR) || strcmp(buffer_out_start, GIT_HEAD_FILE))) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. " - "Reference name does not start with 'refs/'"); + goto invalid_name; - return GIT_SUCCESS; + return 0; + +invalid_name: + giterr_set(GITERR_REFERENCE, "The given reference name is not valid"); + return -1; } int git_reference__normalize_name( @@ -1734,3 +1688,20 @@ int git_reference__normalize_name_oid( { return normalize_name(buffer_out, out_size, name, 1); } + +#define GIT_REF_TYPEMASK (GIT_REF_OID | GIT_REF_SYMBOLIC) + +int git_reference_cmp(git_reference *ref1, git_reference *ref2) +{ + assert(ref1 && ref2); + + /* let's put symbolic refs before OIDs */ + if ((ref1->flags & GIT_REF_TYPEMASK) != (ref2->flags & GIT_REF_TYPEMASK)) + return (ref1->flags & GIT_REF_SYMBOLIC) ? -1 : 1; + + if (ref1->flags & GIT_REF_SYMBOLIC) + return strcmp(ref1->target.symbolic, ref2->target.symbolic); + + return git_oid_cmp(&ref1->target.oid, &ref2->target.oid); +} + diff --git a/src/refs.h b/src/refs.h index 13b9abf15..369e91e1c 100644 --- a/src/refs.h +++ b/src/refs.h @@ -10,7 +10,7 @@ #include "common.h" #include "git2/oid.h" #include "git2/refs.h" -#include "hashtable.h" +#include "strmap.h" #define GIT_REFS_DIR "refs/" #define GIT_REFS_HEADS_DIR GIT_REFS_DIR "heads/" @@ -46,7 +46,7 @@ struct git_reference { }; typedef struct { - git_hashtable *packfile; + git_strmap *packfile; time_t packfile_time; } git_refcache; @@ -55,4 +55,27 @@ void git_repository__refcache_free(git_refcache *refs); int git_reference__normalize_name(char *buffer_out, size_t out_size, const char *name); int git_reference__normalize_name_oid(char *buffer_out, size_t out_size, const char *name); +/** + * Lookup a reference by name and try to resolve to an OID. + * + * You can control how many dereferences this will attempt to resolve the + * reference with the `max_deref` parameter, or pass -1 to use a sane + * default. If you pass 0 for `max_deref`, this will not attempt to resolve + * the reference. For any value of `max_deref` other than 0, not + * successfully resolving the reference will be reported as an error. + + * The generated reference must be freed by the user. + * + * @param reference_out Pointer to the looked-up reference + * @param repo The repository to look up the reference + * @param name The long name for the reference (e.g. HEAD, ref/heads/master, refs/tags/v0.1.0, ...) + * @param max_deref Maximum number of dereferences to make of symbolic refs, 0 means simple lookup, < 0 means use default reasonable value + * @return 0 on success or < 0 on error; not being able to resolve the reference is an error unless 0 was passed for max_deref + */ +int git_reference_lookup_resolved( + git_reference **reference_out, + git_repository *repo, + const char *name, + int max_deref); + #endif diff --git a/src/refspec.c b/src/refspec.c index a27141431..ee4d3a158 100644 --- a/src/refspec.c +++ b/src/refspec.c @@ -10,6 +10,7 @@ #include "common.h" #include "refspec.h" #include "util.h" +#include "posix.h" int git_refspec_parse(git_refspec *refspec, const char *str) { @@ -25,24 +26,21 @@ int git_refspec_parse(git_refspec *refspec, const char *str) delim = strchr(str, ':'); if (delim == NULL) { refspec->src = git__strdup(str); - if (refspec->src == NULL) - return GIT_ENOMEM; - - return GIT_SUCCESS; + GITERR_CHECK_ALLOC(refspec->src); + return 0; } refspec->src = git__strndup(str, delim - str); - if (refspec->src == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(refspec->src); refspec->dst = git__strdup(delim + 1); if (refspec->dst == NULL) { git__free(refspec->src); refspec->src = NULL; - return GIT_ENOMEM; + return -1; } - return GIT_SUCCESS; + return 0; } const char *git_refspec_src(const git_refspec *refspec) @@ -55,9 +53,12 @@ const char *git_refspec_dst(const git_refspec *refspec) return refspec == NULL ? NULL : refspec->dst; } -int git_refspec_src_match(const git_refspec *refspec, const char *refname) +int git_refspec_src_matches(const git_refspec *refspec, const char *refname) { - return (refspec == NULL || refspec->src == NULL) ? GIT_ENOMATCH : git__fnmatch(refspec->src, refname, 0); + if (refspec == NULL || refspec->src == NULL) + return false; + + return (p_fnmatch(refspec->src, refname, 0) == 0); } int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, const char *name) @@ -65,8 +66,10 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con size_t baselen, namelen; baselen = strlen(spec->dst); - if (outlen <= baselen) - return git__throw(GIT_EINVALIDREFNAME, "Reference name too long"); + if (outlen <= baselen) { + giterr_set(GITERR_INVALID, "Reference name too long"); + return GIT_ESHORTBUFFER; + } /* * No '*' at the end means that it's mapped to one specific local @@ -74,7 +77,7 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con */ if (spec->dst[baselen - 1] != '*') { memcpy(out, spec->dst, baselen + 1); /* include '\0' */ - return GIT_SUCCESS; + return 0; } /* There's a '*' at the end, so remove its length */ @@ -85,29 +88,35 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con namelen = strlen(name); - if (outlen <= baselen + namelen) - return git__throw(GIT_EINVALIDREFNAME, "Reference name too long"); + if (outlen <= baselen + namelen) { + giterr_set(GITERR_INVALID, "Reference name too long"); + return GIT_ESHORTBUFFER; + } memcpy(out, spec->dst, baselen); memcpy(out + baselen, name, namelen + 1); - return GIT_SUCCESS; + return 0; } int git_refspec_transform_r(git_buf *out, const git_refspec *spec, const char *name) { - if (git_buf_sets(out, spec->dst) < GIT_SUCCESS) - return git_buf_lasterror(out); + if (git_buf_sets(out, spec->dst) < 0) + return -1; /* * No '*' at the end means that it's mapped to one specific local * branch, so no actual transformation is needed. */ - if (out->size > 0 && out->ptr[out->size - 1] != '*') - return GIT_SUCCESS; + if (git_buf_len(out) > 0 && out->ptr[git_buf_len(out) - 1] != '*') + return 0; - git_buf_truncate(out, out->size - 1); /* remove trailing '*' */ + git_buf_truncate(out, git_buf_len(out) - 1); /* remove trailing '*' */ git_buf_puts(out, name + strlen(spec->src) - 1); - return git_buf_lasterror(out); + if (git_buf_oom(out)) + return -1; + + return 0; } + diff --git a/src/remote.c b/src/remote.c index 52b6aacc9..98c256929 100644 --- a/src/remote.c +++ b/src/remote.c @@ -29,30 +29,26 @@ static int refspec_parse(git_refspec *refspec, const char *str) } delim = strchr(str, ':'); - if (delim == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse refspec. No ':'"); - - refspec->src = git__strndup(str, delim - str); - if (refspec->src == NULL) - return GIT_ENOMEM; - - refspec->dst = git__strdup(delim + 1); - if (refspec->dst == NULL) { - git__free(refspec->src); - refspec->src = NULL; - return GIT_ENOMEM; + if (delim == NULL) { + giterr_set(GITERR_NET, "Invalid refspec, missing ':'"); + return -1; } - return GIT_SUCCESS; + refspec->src = git__strndup(str, delim - str); + GITERR_CHECK_ALLOC(refspec->src); + + refspec->dst = git__strdup(delim + 1); + GITERR_CHECK_ALLOC(refspec->dst); + + return 0; } static int parse_remote_refspec(git_config *cfg, git_refspec *refspec, const char *var) { - const char *val; int error; + const char *val; - error = git_config_get_string(cfg, var, &val); - if (error < GIT_SUCCESS) + if ((error = git_config_get_string(cfg, var, &val)) < 0) return error; return refspec_parse(refspec, val); @@ -66,33 +62,24 @@ int git_remote_new(git_remote **out, git_repository *repo, const char *url, cons assert(out && repo && url); remote = git__malloc(sizeof(git_remote)); - if (remote == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(remote); memset(remote, 0x0, sizeof(git_remote)); remote->repo = repo; - if (git_vector_init(&remote->refs, 32, NULL) < 0) { - git_remote_free(remote); - return GIT_ENOMEM; - } + if (git_vector_init(&remote->refs, 32, NULL) < 0) + return -1; remote->url = git__strdup(url); - if (remote->url == NULL) { - git_remote_free(remote); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(remote->url); if (name != NULL) { remote->name = git__strdup(name); - if (remote->name == NULL) { - git_remote_free(remote); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(remote->name); } *out = remote; - return GIT_SUCCESS; + return 0; } int git_remote_load(git_remote **out, git_repository *repo, const char *name) @@ -100,87 +87,68 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name) git_remote *remote; git_buf buf = GIT_BUF_INIT; const char *val; - int error; + int error = 0; git_config *config; assert(out && repo && name); - error = git_repository_config__weakptr(&config, repo); - if (error < GIT_SUCCESS) - return error; + if (git_repository_config__weakptr(&config, repo) < 0) + return -1; remote = git__malloc(sizeof(git_remote)); - if (remote == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(remote); memset(remote, 0x0, sizeof(git_remote)); remote->name = git__strdup(name); - if (remote->name == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + GITERR_CHECK_ALLOC(remote->name); - if (git_vector_init(&remote->refs, 32, NULL) < 0) { - error = GIT_ENOMEM; - goto cleanup; - } + if (git_vector_init(&remote->refs, 32, NULL) < 0) + return -1; - git_buf_printf(&buf, "remote.%s.url", name); - if (git_buf_oom(&buf)) { - error = GIT_ENOMEM; - goto cleanup; - } + if (git_buf_printf(&buf, "remote.%s.url", name) < 0) + return -1; - error = git_config_get_string(config, git_buf_cstr(&buf), &val); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Remote's url doesn't exist"); + if (git_config_get_string(config, git_buf_cstr(&buf), &val) < 0) { + error = -1; goto cleanup; } remote->repo = repo; remote->url = git__strdup(val); - if (remote->url == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + GITERR_CHECK_ALLOC(remote->url); git_buf_clear(&buf); - git_buf_printf(&buf, "remote.%s.fetch", name); - if (git_buf_oom(&buf)) { - error = GIT_ENOMEM; - goto cleanup; - } + if (git_buf_printf(&buf, "remote.%s.fetch", name) < 0) + return -1; error = parse_remote_refspec(config, &remote->fetch, git_buf_cstr(&buf)); if (error == GIT_ENOTFOUND) - error = GIT_SUCCESS; + error = 0; - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to get fetch refspec"); + if (error < 0) { + error = -1; goto cleanup; } git_buf_clear(&buf); - git_buf_printf(&buf, "remote.%s.push", name); - if (git_buf_oom(&buf)) { - error = GIT_ENOMEM; - goto cleanup; - } + if (git_buf_printf(&buf, "remote.%s.push", name) < 0) + return -1; error = parse_remote_refspec(config, &remote->push, git_buf_cstr(&buf)); - /* Not finding push is fine */ if (error == GIT_ENOTFOUND) - error = GIT_SUCCESS; + error = 0; - if (error < GIT_SUCCESS) + if (error < 0) { + error = -1; goto cleanup; + } *out = remote; cleanup: git_buf_free(&buf); - if (error < GIT_SUCCESS) + if (error < 0) git_remote_free(remote); return error; @@ -188,52 +156,53 @@ cleanup: int git_remote_save(const git_remote *remote) { - int error; git_config *config; git_buf buf = GIT_BUF_INIT, value = GIT_BUF_INIT; - error = git_repository_config__weakptr(&config, remote->repo); - if (error < GIT_SUCCESS) - return error; + if (git_repository_config__weakptr(&config, remote->repo) < 0) + return -1; - git_buf_printf(&buf, "remote.%s.%s", remote->name, "url"); - if (git_buf_oom(&buf)) - return GIT_ENOMEM; + if (git_buf_printf(&buf, "remote.%s.%s", remote->name, "url") < 0) + return -1; - error = git_config_set_string(config, git_buf_cstr(&buf), remote->url); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_config_set_string(config, git_buf_cstr(&buf), remote->url) < 0) { + git_buf_free(&buf); + return -1; + } if (remote->fetch.src != NULL && remote->fetch.dst != NULL) { git_buf_clear(&buf); git_buf_clear(&value); - git_buf_printf(&buf, "remote.%s.%s", remote->name, "fetch"); + git_buf_printf(&buf, "remote.%s.fetch", remote->name); git_buf_printf(&value, "%s:%s", remote->fetch.src, remote->fetch.dst); if (git_buf_oom(&buf) || git_buf_oom(&value)) - return GIT_ENOMEM; + return -1; - error = git_config_set_string(config, git_buf_cstr(&buf), git_buf_cstr(&value)); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_config_set_string(config, git_buf_cstr(&buf), git_buf_cstr(&value)) < 0) + goto on_error; } if (remote->push.src != NULL && remote->push.dst != NULL) { git_buf_clear(&buf); git_buf_clear(&value); - git_buf_printf(&buf, "remote.%s.%s", remote->name, "push"); + git_buf_printf(&buf, "remote.%s.push", remote->name); git_buf_printf(&value, "%s:%s", remote->push.src, remote->push.dst); if (git_buf_oom(&buf) || git_buf_oom(&value)) - return GIT_ENOMEM; + return -1; - error = git_config_set_string(config, git_buf_cstr(&buf), git_buf_cstr(&value)); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_config_set_string(config, git_buf_cstr(&buf), git_buf_cstr(&value)) < 0) + goto on_error; } -cleanup: git_buf_free(&buf); git_buf_free(&value); - return error; + + return 0; + +on_error: + git_buf_free(&buf); + git_buf_free(&value); + return -1; } const char *git_remote_name(git_remote *remote) @@ -250,21 +219,19 @@ const char *git_remote_url(git_remote *remote) int git_remote_set_fetchspec(git_remote *remote, const char *spec) { - int error; git_refspec refspec; assert(remote && spec); - error = refspec_parse(&refspec, spec); - if (error != GIT_SUCCESS) - return error; + if (refspec_parse(&refspec, spec) < 0) + return -1; git__free(remote->fetch.src); git__free(remote->fetch.dst); remote->fetch.src = refspec.src; remote->fetch.dst = refspec.dst; - return GIT_SUCCESS; + return 0; } const git_refspec *git_remote_fetchspec(git_remote *remote) @@ -275,21 +242,19 @@ const git_refspec *git_remote_fetchspec(git_remote *remote) int git_remote_set_pushspec(git_remote *remote, const char *spec) { - int error; git_refspec refspec; assert(remote && spec); - error = refspec_parse(&refspec, spec); - if (error != GIT_SUCCESS) - return error; + if (refspec_parse(&refspec, spec) < 0) + return -1; git__free(remote->push.src); git__free(remote->push.dst); remote->push.src = refspec.src; remote->push.dst = refspec.dst; - return GIT_SUCCESS; + return 0; } const git_refspec *git_remote_pushspec(git_remote *remote) @@ -300,57 +265,56 @@ const git_refspec *git_remote_pushspec(git_remote *remote) int git_remote_connect(git_remote *remote, int direction) { - int error; git_transport *t; assert(remote); - error = git_transport_new(&t, remote->url); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create transport"); + if (git_transport_new(&t, remote->url) < 0) + return -1; - error = t->connect(t, direction); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to connect the transport"); - goto cleanup; + if (t->connect(t, direction) < 0) { + goto on_error; } remote->transport = t; -cleanup: - if (error < GIT_SUCCESS) - t->free(t); + return 0; - return error; +on_error: + t->free(t); + return -1; } int git_remote_ls(git_remote *remote, git_headlist_cb list_cb, void *payload) { assert(remote); - if (!remote->transport || !remote->transport->connected) - return git__throw(GIT_ERROR, "The remote is not connected"); + if (!remote->transport || !remote->transport->connected) { + giterr_set(GITERR_NET, "The remote is not connected"); + return -1; + } return remote->transport->ls(remote->transport, list_cb, payload); } -int git_remote_download(char **filename, git_remote *remote) +int git_remote_download(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats) { int error; - assert(filename && remote); + assert(remote && bytes && stats); if ((error = git_fetch_negotiate(remote)) < 0) - return git__rethrow(error, "Error negotiating"); + return error; - return git_fetch_download_pack(filename, remote); + return git_fetch_download_pack(remote, bytes, stats); } -int git_remote_update_tips(git_remote *remote) +int git_remote_update_tips(git_remote *remote, int (*cb)(const char *refname, const git_oid *a, const git_oid *b)) { - int error = GIT_SUCCESS; + int error = 0; unsigned int i = 0; git_buf refname = GIT_BUF_INIT; + git_oid old; git_vector *refs = &remote->refs; git_remote_head *head; git_reference *ref; @@ -364,31 +328,47 @@ int git_remote_update_tips(git_remote *remote) /* HEAD is only allowed to be the first in the list */ head = refs->contents[0]; if (!strcmp(head->name, GIT_HEAD_FILE)) { - error = git_reference_create_oid(&ref, remote->repo, GIT_FETCH_HEAD_FILE, &head->oid, 1); - i = 1; - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to update FETCH_HEAD"); + if (git_reference_create_oid(&ref, remote->repo, GIT_FETCH_HEAD_FILE, &head->oid, 1) < 0) + return -1; + i = 1; git_reference_free(ref); } for (; i < refs->length; ++i) { head = refs->contents[i]; - error = git_refspec_transform_r(&refname, spec, head->name); - if (error < GIT_SUCCESS) - break; + if (git_refspec_transform_r(&refname, spec, head->name) < 0) + goto on_error; - error = git_reference_create_oid(&ref, remote->repo, refname.ptr, &head->oid, 1); - if (error < GIT_SUCCESS) + error = git_reference_name_to_oid(&old, remote->repo, refname.ptr); + if (error < 0 && error != GIT_ENOTFOUND) + goto on_error; + + if (error == GIT_ENOTFOUND) + memset(&old, 0, GIT_OID_RAWSZ); + + if (!git_oid_cmp(&old, &head->oid)) + continue; + + if (git_reference_create_oid(&ref, remote->repo, refname.ptr, &head->oid, 1) < 0) break; git_reference_free(ref); + + if (cb != NULL) { + if (cb(refname.ptr, &old, &head->oid) < 0) + goto on_error; + } } git_buf_free(&refname); + return 0; + +on_error: + git_buf_free(&refname); + return -1; - return error; } int git_remote_connected(git_remote *remote) @@ -401,13 +381,8 @@ void git_remote_disconnect(git_remote *remote) { assert(remote); - if (remote->transport != NULL) { - if (remote->transport->connected) + if (remote->transport != NULL && remote->transport->connected) remote->transport->close(remote->transport); - - remote->transport->free(remote->transport); - remote->transport = NULL; - } } void git_remote_free(git_remote *remote) @@ -415,14 +390,21 @@ void git_remote_free(git_remote *remote) if (remote == NULL) return; + if (remote->transport != NULL) { + git_remote_disconnect(remote); + + remote->transport->free(remote->transport); + remote->transport = NULL; + } + + git_vector_free(&remote->refs); + git__free(remote->fetch.src); git__free(remote->fetch.dst); git__free(remote->push.src); git__free(remote->push.dst); git__free(remote->url); git__free(remote->name); - git_vector_free(&remote->refs); - git_remote_disconnect(remote); git__free(remote); } @@ -436,20 +418,17 @@ static int remote_list_cb(const char *name, const char *value, void *data_) struct cb_data *data = (struct cb_data *)data_; size_t nmatch = 2; regmatch_t pmatch[2]; - int error; GIT_UNUSED(value); if (!regexec(data->preg, name, nmatch, pmatch, 0)) { char *remote_name = git__strndup(&name[pmatch[1].rm_so], pmatch[1].rm_eo - pmatch[1].rm_so); - if (remote_name == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(remote_name); - error = git_vector_insert(data->list, remote_name); - if (error < GIT_SUCCESS) - return error; + if (git_vector_insert(data->list, remote_name) < 0) + return -1; } - return GIT_SUCCESS; + return 0; } int git_remote_list(git_strarray *remotes_list, git_repository *repo) @@ -460,27 +439,26 @@ int git_remote_list(git_strarray *remotes_list, git_repository *repo) struct cb_data data; int error; - error = git_repository_config__weakptr(&cfg, repo); - if (error < GIT_SUCCESS) - return error; + if (git_repository_config__weakptr(&cfg, repo) < 0) + return -1; - error = git_vector_init(&list, 4, NULL); - if (error < GIT_SUCCESS) - return error; + if (git_vector_init(&list, 4, NULL) < 0) + return -1; - error = regcomp(&preg, "^remote\\.(.*)\\.url$", REG_EXTENDED); - if (error < 0) - return GIT_EOSERR; + if (regcomp(&preg, "^remote\\.(.*)\\.url$", REG_EXTENDED) < 0) { + giterr_set(GITERR_OS, "Remote catch regex failed to compile"); + return -1; + } data.list = &list; data.preg = &preg; error = git_config_foreach(cfg, remote_list_cb, &data); regfree(&preg); - if (error < GIT_SUCCESS) { + if (error < 0) { size_t i; char *elem; git_vector_foreach(&list, i, elem) { - free(elem); + git__free(elem); } git_vector_free(&list); @@ -490,5 +468,5 @@ int git_remote_list(git_strarray *remotes_list, git_repository *repo) remotes_list->strings = (char **)list.contents; remotes_list->count = list.length; - return GIT_SUCCESS; + return 0; } diff --git a/src/repository.c b/src/repository.c index 1f8306991..d4de38104 100644 --- a/src/repository.c +++ b/src/repository.c @@ -5,6 +5,7 @@ * a Linking Exception. For full terms see the included COPYING file. */ #include +#include #include "git2/object.h" @@ -20,7 +21,7 @@ #define GIT_OBJECTS_INFO_DIR GIT_OBJECTS_DIR "info/" #define GIT_OBJECTS_PACK_DIR GIT_OBJECTS_DIR "pack/" -#define GIT_FILE_CONTENT_PREFIX "gitdir: " +#define GIT_FILE_CONTENT_PREFIX "gitdir:" #define GIT_BRANCH_MASTER "master" @@ -64,6 +65,7 @@ void git_repository_free(git_repository *repo) git_cache_free(&repo->objects); git_repository__refcache_free(&repo->references); git_attr_cache_flush(repo); + git_submodule_config_free(repo); git__free(repo->path_repository); git__free(repo->workdir); @@ -80,35 +82,31 @@ void git_repository_free(git_repository *repo) * * Open a repository object from its path */ -static int quickcheck_repository_dir(git_buf *repository_path) +static bool valid_repository_path(git_buf *repository_path) { /* Check OBJECTS_DIR first, since it will generate the longest path name */ - if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR) < 0) - return GIT_ERROR; + if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR) == false) + return false; /* Ensure HEAD file exists */ - if (git_path_contains_file(repository_path, GIT_HEAD_FILE) < 0) - return GIT_ERROR; + if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false) + return false; - if (git_path_contains_dir(repository_path, GIT_REFS_DIR) < 0) - return GIT_ERROR; + if (git_path_contains_dir(repository_path, GIT_REFS_DIR) == false) + return false; - return GIT_SUCCESS; + return true; } - static git_repository *repository_alloc(void) { - int error; - git_repository *repo = git__malloc(sizeof(git_repository)); if (!repo) return NULL; memset(repo, 0x0, sizeof(git_repository)); - error = git_cache_init(&repo->objects, GIT_DEFAULT_CACHE_SIZE, &git_object__free); - if (error < GIT_SUCCESS) { + if (git_cache_init(&repo->objects, GIT_DEFAULT_CACHE_SIZE, &git_object__free) < 0) { git__free(repo); return NULL; } @@ -121,295 +119,53 @@ static git_repository *repository_alloc(void) static int load_config_data(git_repository *repo) { - int error, is_bare; + int is_bare; git_config *config; - error = git_repository_config__weakptr(&config, repo); - if (error < GIT_SUCCESS) - return error; + if (git_repository_config__weakptr(&config, repo) < 0) + return -1; - error = git_config_get_bool(config, "core.bare", &is_bare); - if (error == GIT_SUCCESS) - repo->is_bare = is_bare; + if (git_config_get_bool(config, "core.bare", &is_bare) < 0) + return -1; /* FIXME: We assume that a missing core.bare + variable is an error. Is this right? */ - /* TODO: what else can we load/cache here? */ - - return GIT_SUCCESS; + repo->is_bare = is_bare; + return 0; } -static int load_workdir(git_repository *repo) +static int load_workdir(git_repository *repo, git_buf *parent_path) { - int error; - git_buf workdir_buf = GIT_BUF_INIT; + int error; + git_config *config; + const char *worktree; + git_buf worktree_buf = GIT_BUF_INIT; if (repo->is_bare) - return GIT_SUCCESS; + return 0; - git_path_dirname_r(&workdir_buf, repo->path_repository); - git_path_to_dir(&workdir_buf); + if (git_repository_config__weakptr(&config, repo) < 0) + return -1; - if ((error = git_buf_lasterror(&workdir_buf)) == GIT_SUCCESS) - repo->workdir = git_buf_detach(&workdir_buf); - - git_buf_free(&workdir_buf); - - return error; -} - -int git_repository_open(git_repository **repo_out, const char *path) -{ - int error = GIT_SUCCESS; - git_buf path_buf = GIT_BUF_INIT; - git_repository *repo = NULL; - - error = git_path_prettify_dir(&path_buf, path, NULL); - if (error < GIT_SUCCESS) - goto cleanup; - - /** - * Check if the path we've been given is actually the path - * of the working dir, by testing if it contains a `.git` - * folder inside of it. - */ - if (git_path_contains_dir(&path_buf, GIT_DIR) == GIT_SUCCESS) - git_buf_joinpath(&path_buf, path_buf.ptr, GIT_DIR); - - if (quickcheck_repository_dir(&path_buf) < GIT_SUCCESS) { - error = git__throw(GIT_ENOTAREPO, - "The given path (%s) is not a valid Git repository", git_buf_cstr(&path_buf)); - goto cleanup; - } - - repo = repository_alloc(); - if (repo == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } - - repo->path_repository = git_buf_detach(&path_buf); - if (repo->path_repository == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } - - error = load_config_data(repo); - if (error < GIT_SUCCESS) - goto cleanup; - - error = load_workdir(repo); - if (error < GIT_SUCCESS) - goto cleanup; - - *repo_out = repo; - return GIT_SUCCESS; - - cleanup: - git_repository_free(repo); - git_buf_free(&path_buf); - return error; -} - -static int load_config( - git_config **out, - git_repository *repo, - const char *global_config_path, - const char *system_config_path) -{ - git_buf config_path = GIT_BUF_INIT; - int error; - git_config *cfg = NULL; - - assert(repo && out); - - error = git_config_new(&cfg); - if (error < GIT_SUCCESS) + error = git_config_get_string(config, "core.worktree", &worktree); + if (!error && worktree != NULL) + repo->workdir = git__strdup(worktree); + else if (error != GIT_ENOTFOUND) return error; + else { + giterr_clear(); - error = git_buf_joinpath(&config_path, repo->path_repository, - GIT_CONFIG_FILENAME_INREPO); - if (error < GIT_SUCCESS) - goto cleanup; - - error = git_config_add_file_ondisk(cfg, config_path.ptr, 3); - git_buf_free(&config_path); /* done with config_path now */ - if (error < GIT_SUCCESS) - goto cleanup; - - if (global_config_path != NULL) { - error = git_config_add_file_ondisk(cfg, global_config_path, 2); - if (error < GIT_SUCCESS) - goto cleanup; + if (parent_path && git_path_isdir(parent_path->ptr)) + repo->workdir = git_buf_detach(parent_path); + else { + git_path_dirname_r(&worktree_buf, repo->path_repository); + git_path_to_dir(&worktree_buf); + repo->workdir = git_buf_detach(&worktree_buf); + } } - if (system_config_path != NULL) { - error = git_config_add_file_ondisk(cfg, system_config_path, 1); - if (error < GIT_SUCCESS) - goto cleanup; - } + GITERR_CHECK_ALLOC(repo->workdir); - *out = cfg; - return GIT_SUCCESS; - -cleanup: - git_config_free(cfg); - *out = NULL; - return error; -} - -int git_repository_config__weakptr(git_config **out, git_repository *repo) -{ - if (repo->_config == NULL) { - int error; - git_buf global_buf = GIT_BUF_INIT, system_buf = GIT_BUF_INIT; - - const char *global_config_path = NULL; - const char *system_config_path = NULL; - - if (git_config_find_global_r(&global_buf) == GIT_SUCCESS) - global_config_path = global_buf.ptr; - - if (git_config_find_system_r(&system_buf) == GIT_SUCCESS) - system_config_path = system_buf.ptr; - - error = load_config(&repo->_config, repo, global_config_path, system_config_path); - - git_buf_free(&global_buf); - git_buf_free(&system_buf); - - if (error < GIT_SUCCESS) - return error; - - GIT_REFCOUNT_OWN(repo->_config, repo); - } - - *out = repo->_config; - return GIT_SUCCESS; -} - -int git_repository_config(git_config **out, git_repository *repo) -{ - int error = git_repository_config__weakptr(out, repo); - - if (error == GIT_SUCCESS) { - GIT_REFCOUNT_INC(*out); - } - - return error; -} - -void git_repository_set_config(git_repository *repo, git_config *config) -{ - assert(repo && config); - - drop_config(repo); - - repo->_config = config; - GIT_REFCOUNT_OWN(repo->_config, repo); -} - -int git_repository_odb__weakptr(git_odb **out, git_repository *repo) -{ - assert(repo && out); - - if (repo->_odb == NULL) { - int error; - git_buf odb_path = GIT_BUF_INIT; - - error = git_buf_joinpath(&odb_path, repo->path_repository, GIT_OBJECTS_DIR); - if (error < GIT_SUCCESS) - return error; - - error = git_odb_open(&repo->_odb, odb_path.ptr); - git_buf_free(&odb_path); /* done with path */ - if (error < GIT_SUCCESS) - return error; - - GIT_REFCOUNT_OWN(repo->_odb, repo); - } - - *out = repo->_odb; - return GIT_SUCCESS; -} - -int git_repository_odb(git_odb **out, git_repository *repo) -{ - int error = git_repository_odb__weakptr(out, repo); - - if (error == GIT_SUCCESS) { - GIT_REFCOUNT_INC(*out); - } - - return error; -} - -void git_repository_set_odb(git_repository *repo, git_odb *odb) -{ - assert(repo && odb); - - drop_odb(repo); - - repo->_odb = odb; - GIT_REFCOUNT_OWN(repo->_odb, repo); -} - -int git_repository_index__weakptr(git_index **out, git_repository *repo) -{ - assert(out && repo); - - if (repo->_index == NULL) { - int error; - git_buf index_path = GIT_BUF_INIT; - - error = git_buf_joinpath(&index_path, repo->path_repository, GIT_INDEX_FILE); - if (error < GIT_SUCCESS) - return error; - - error = git_index_open(&repo->_index, index_path.ptr); - git_buf_free(&index_path); /* done with path */ - if (error < GIT_SUCCESS) - return error; - - GIT_REFCOUNT_OWN(repo->_index, repo); - } - - *out = repo->_index; - return GIT_SUCCESS; -} - -int git_repository_index(git_index **out, git_repository *repo) -{ - int error = git_repository_index__weakptr(out, repo); - - if (error == GIT_SUCCESS) { - GIT_REFCOUNT_INC(*out); - } - - return error; -} - -void git_repository_set_index(git_repository *repo, git_index *index) -{ - assert(repo && index); - - drop_index(repo); - - repo->_index = index; - GIT_REFCOUNT_OWN(repo->_index, repo); -} - - -static int retrieve_device(dev_t *device_out, const char *path) -{ - struct stat path_info; - - assert(device_out); - - if (p_lstat(path, &path_info)) - return git__throw(GIT_EOSERR, "Failed to get file informations: %s", path); - - *device_out = path_info.st_dev; - - return GIT_SUCCESS; + return 0; } /* @@ -420,28 +176,27 @@ static int retrieve_device(dev_t *device_out, const char *path) * the stack could remove directories name limits, but at the cost of doing * repeated malloc/frees inside the loop below, so let's not do it now. */ -static int retrieve_ceiling_directories_offset( +static int find_ceiling_dir_offset( const char *path, const char *ceiling_directories) { char buf[GIT_PATH_MAX + 1]; char buf2[GIT_PATH_MAX + 1]; const char *ceil, *sep; - int len, max_len = -1; - int min_len; + size_t len, max_len = 0, min_len; assert(path); - min_len = git_path_root(path) + 1; + min_len = (size_t)(git_path_root(path) + 1); if (ceiling_directories == NULL || min_len == 0) - return min_len; + return (int)min_len; for (sep = ceil = ceiling_directories; *sep; ceil = sep + 1) { for (sep = ceil; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++); len = sep - ceil; - if (len == 0 || len >= (int)sizeof(buf) || git_path_root(ceil) == -1) + if (len == 0 || len >= sizeof(buf) || git_path_root(ceil) == -1) continue; strncpy(buf, ceil, len); @@ -462,7 +217,7 @@ static int retrieve_ceiling_directories_offset( } } - return max_len <= min_len ? min_len : max_len; + return (int)(max_len <= min_len ? min_len : max_len); } /* @@ -470,38 +225,167 @@ static int retrieve_ceiling_directories_offset( * it points to. Before calling, set `path_out` to the base directory that * should be used if the contents of `file_path` are a relative path. */ -static int read_gitfile(git_buf *path_out, const char *file_path, const char *base_path) +static int read_gitfile(git_buf *path_out, const char *file_path) { + int error = 0; git_buf file = GIT_BUF_INIT; - int error; + size_t prefix_len = strlen(GIT_FILE_CONTENT_PREFIX); assert(path_out && file_path); - error = git_futils_readbuffer(&file, file_path); - if (error < GIT_SUCCESS) - return error; - - if (git__prefixcmp((char *)file.ptr, GIT_FILE_CONTENT_PREFIX)) { - git_buf_free(&file); - return git__throw(GIT_ENOTFOUND, "Invalid gitfile format `%s`", file_path); - } + if (git_futils_readbuffer(&file, file_path) < 0) + return -1; git_buf_rtrim(&file); - if (strlen(GIT_FILE_CONTENT_PREFIX) == file.size) { - git_buf_free(&file); - return git__throw(GIT_ENOTFOUND, "No path in git file `%s`", file_path); + if (file.size <= prefix_len || + memcmp(file.ptr, GIT_FILE_CONTENT_PREFIX, prefix_len) != 0) + { + giterr_set(GITERR_REPOSITORY, "The `.git` file at '%s' is malformed", file_path); + error = -1; + } + else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) { + const char *gitlink = ((const char *)file.ptr) + prefix_len; + while (*gitlink && isspace(*gitlink)) gitlink++; + error = git_path_prettify_dir(path_out, gitlink, path_out->ptr); } - error = git_path_prettify_dir(path_out, - ((char *)file.ptr) + strlen(GIT_FILE_CONTENT_PREFIX), base_path); - git_buf_free(&file); + return error; +} - if (error == GIT_SUCCESS && git_path_exists(path_out->ptr) == 0) - return GIT_SUCCESS; +static int find_repo( + git_buf *repo_path, + git_buf *parent_path, + const char *start_path, + uint32_t flags, + const char *ceiling_dirs) +{ + int error; + git_buf path = GIT_BUF_INIT; + struct stat st; + dev_t initial_device = 0; + bool try_with_dot_git = false; + int ceiling_offset; - return git__throw(GIT_EOBJCORRUPTED, "The `.git` file points to a nonexistent path"); + git_buf_free(repo_path); + + if ((error = git_path_prettify_dir(&path, start_path, NULL)) < 0) + return error; + + ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs); + + if ((error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0) + return error; + + while (!error && !git_buf_len(repo_path)) { + if (p_stat(path.ptr, &st) == 0) { + /* check that we have not crossed device boundaries */ + if (initial_device == 0) + initial_device = st.st_dev; + else if (st.st_dev != initial_device && + (flags & GIT_REPOSITORY_OPEN_CROSS_FS) == 0) + break; + + if (S_ISDIR(st.st_mode)) { + if (valid_repository_path(&path)) { + git_path_to_dir(&path); + git_buf_set(repo_path, path.ptr, path.size); + break; + } + } + else if (S_ISREG(st.st_mode)) { + git_buf repo_link = GIT_BUF_INIT; + + if (!(error = read_gitfile(&repo_link, path.ptr))) { + if (valid_repository_path(&repo_link)) + git_buf_swap(repo_path, &repo_link); + + git_buf_free(&repo_link); + break; + } + git_buf_free(&repo_link); + } + } + + /* move up one directory level */ + if (git_path_dirname_r(&path, path.ptr) < 0) { + error = -1; + break; + } + + if (try_with_dot_git) { + /* if we tried original dir with and without .git AND either hit + * directory ceiling or NO_SEARCH was requested, then be done. + */ + if (path.ptr[ceiling_offset] == '\0' || + (flags & GIT_REPOSITORY_OPEN_NO_SEARCH) != 0) + break; + /* otherwise look first for .git item */ + error = git_buf_joinpath(&path, path.ptr, DOT_GIT); + } + try_with_dot_git = !try_with_dot_git; + } + + if (!error && parent_path != NULL) { + if (!git_buf_len(repo_path)) + git_buf_clear(parent_path); + else { + git_path_dirname_r(parent_path, path.ptr); + git_path_to_dir(parent_path); + } + if (git_buf_oom(parent_path)) + return -1; + } + + git_buf_free(&path); + + if (!git_buf_len(repo_path) && !error) { + giterr_set(GITERR_REPOSITORY, + "Could not find repository from '%s'", start_path); + error = GIT_ENOTFOUND; + } + + return error; +} + +int git_repository_open_ext( + git_repository **repo_ptr, + const char *start_path, + uint32_t flags, + const char *ceiling_dirs) +{ + int error; + git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT; + git_repository *repo; + + *repo_ptr = NULL; + + if ((error = find_repo(&path, &parent, start_path, flags, ceiling_dirs)) < 0) + return error; + + repo = repository_alloc(); + GITERR_CHECK_ALLOC(repo); + + repo->path_repository = git_buf_detach(&path); + GITERR_CHECK_ALLOC(repo->path_repository); + + if ((error = load_config_data(repo)) < 0 || + (error = load_workdir(repo, &parent)) < 0) + { + git_repository_free(repo); + return error; + } + + git_buf_free(&parent); + *repo_ptr = repo; + return 0; +} + +int git_repository_open(git_repository **repo_out, const char *path) +{ + return git_repository_open_ext( + repo_out, path, GIT_REPOSITORY_OPEN_NO_SEARCH, NULL); } int git_repository_discover( @@ -511,221 +395,297 @@ int git_repository_discover( int across_fs, const char *ceiling_dirs) { - int error, ceiling_offset; - git_buf bare_path = GIT_BUF_INIT; - git_buf normal_path = GIT_BUF_INIT; - git_buf *found_path = NULL; - dev_t current_device = 0; + git_buf path = GIT_BUF_INIT; + uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0; - assert(start_path && repository_path); + assert(start_path && repository_path && size > 0); *repository_path = '\0'; - error = git_path_prettify_dir(&bare_path, start_path, NULL); - if (error < GIT_SUCCESS) - goto cleanup; + if (find_repo(&path, NULL, start_path, flags, ceiling_dirs) < 0) + return -1; - if (!across_fs) { - error = retrieve_device(¤t_device, bare_path.ptr); - if (error < GIT_SUCCESS) - goto cleanup; + if (size < (size_t)(path.size + 1)) { + giterr_set(GITERR_REPOSITORY, + "The given buffer is too long to store the discovered path"); + git_buf_free(&path); + return -1; } - ceiling_offset = retrieve_ceiling_directories_offset(bare_path.ptr, ceiling_dirs); + /* success: we discovered a repository */ + git_buf_copy_cstr(repository_path, size, &path); + git_buf_free(&path); + return 0; +} - while(1) { - error = git_buf_joinpath(&normal_path, bare_path.ptr, DOT_GIT); - if (error < GIT_SUCCESS) - break; +static int load_config( + git_config **out, + git_repository *repo, + const char *global_config_path, + const char *system_config_path) +{ + git_buf config_path = GIT_BUF_INIT; + git_config *cfg = NULL; - /** - * If the `.git` file is regular instead of - * a directory, it should contain the path of the actual git repository - */ - if (git_path_isfile(normal_path.ptr) == GIT_SUCCESS) { - git_buf gitfile_path = GIT_BUF_INIT; + assert(repo && out); - error = read_gitfile(&gitfile_path, normal_path.ptr, bare_path.ptr); - if (error < GIT_SUCCESS) - git__rethrow(error, "Unable to read git file `%s`", normal_path.ptr); - else if ((error = quickcheck_repository_dir(&gitfile_path)) < GIT_SUCCESS) - git__throw(GIT_ENOTFOUND, - "The `.git` file found at '%s' points " - "to a nonexistent git folder", normal_path.ptr); - else { - git_buf_swap(&normal_path, &gitfile_path); - found_path = &normal_path; - } + if (git_config_new(&cfg) < 0) + return -1; - git_buf_free(&gitfile_path); - break; - } + if (git_buf_joinpath( + &config_path, repo->path_repository, GIT_CONFIG_FILENAME_INREPO) < 0) + goto on_error; - /** - * If the `.git` file is a folder, we check inside of it - */ - if (git_path_isdir(normal_path.ptr) == GIT_SUCCESS) { - error = quickcheck_repository_dir(&normal_path); - if (error == GIT_SUCCESS) { - found_path = &normal_path; - break; - } - } + if (git_config_add_file_ondisk(cfg, config_path.ptr, 3) < 0) + goto on_error; - /** - * Otherwise, the repository may be bare, let's check - * the root anyway - */ - error = quickcheck_repository_dir(&bare_path); - if (error == GIT_SUCCESS) { - found_path = &bare_path; - break; - } + git_buf_free(&config_path); - /** - * If we didn't find it, walk up the tree - */ - error = git_path_dirname_r(&normal_path, bare_path.ptr); - if (error < GIT_SUCCESS) { - git__rethrow(GIT_EOSERR, "Failed to dirname '%s'", bare_path.ptr); - break; - } - - git_buf_swap(&bare_path, &normal_path); - - if (!across_fs) { - dev_t new_device; - error = retrieve_device(&new_device, bare_path.ptr); - - if (error < GIT_SUCCESS || current_device != new_device) { - error = git__throw(GIT_ENOTAREPO, - "Not a git repository (or any parent up to mount parent %s)\n" - "Stopping at filesystem boundary.", normal_path.ptr); - break; - } - current_device = new_device; - } - - /* nothing has been found, lets try the parent directory - * but stop if we hit one of the ceiling directories - */ - if (bare_path.ptr[ceiling_offset] == '\0') { - error = git__throw(GIT_ENOTAREPO, - "Not a git repository (or any of the parent directories): %s", start_path); - break; - } + if (global_config_path != NULL) { + if (git_config_add_file_ondisk(cfg, global_config_path, 2) < 0) + goto on_error; } - assert(found_path || error != GIT_SUCCESS); - - if (found_path) { - if ((error = git_path_to_dir(found_path)) < GIT_SUCCESS) - git__rethrow(error, "Could not convert git repository to directory"); - else if (size < (size_t)(found_path->size + 1)) - error = git__throw(GIT_ESHORTBUFFER, - "The repository buffer is not long enough to " - "handle the repository path `%s`", found_path->ptr); - else - git_buf_copy_cstr(repository_path, size, found_path); + if (system_config_path != NULL) { + if (git_config_add_file_ondisk(cfg, system_config_path, 1) < 0) + goto on_error; } -cleanup: - git_buf_free(&bare_path); - git_buf_free(&normal_path); - return error; + *out = cfg; + return 0; + +on_error: + git_buf_free(&config_path); + git_config_free(cfg); + *out = NULL; + return -1; +} + +int git_repository_config__weakptr(git_config **out, git_repository *repo) +{ + if (repo->_config == NULL) { + git_buf global_buf = GIT_BUF_INIT, system_buf = GIT_BUF_INIT; + int res; + + const char *global_config_path = NULL; + const char *system_config_path = NULL; + + if (git_config_find_global_r(&global_buf) == 0) + global_config_path = global_buf.ptr; + + if (git_config_find_system_r(&system_buf) == 0) + system_config_path = system_buf.ptr; + + res = load_config(&repo->_config, repo, global_config_path, system_config_path); + + git_buf_free(&global_buf); + git_buf_free(&system_buf); + + if (res < 0) + return -1; + + GIT_REFCOUNT_OWN(repo->_config, repo); + } + + *out = repo->_config; + return 0; +} + +int git_repository_config(git_config **out, git_repository *repo) +{ + if (git_repository_config__weakptr(out, repo) < 0) + return -1; + + GIT_REFCOUNT_INC(*out); + return 0; +} + +void git_repository_set_config(git_repository *repo, git_config *config) +{ + assert(repo && config); + + drop_config(repo); + + repo->_config = config; + GIT_REFCOUNT_OWN(repo->_config, repo); +} + +int git_repository_odb__weakptr(git_odb **out, git_repository *repo) +{ + assert(repo && out); + + if (repo->_odb == NULL) { + git_buf odb_path = GIT_BUF_INIT; + int res; + + if (git_buf_joinpath(&odb_path, repo->path_repository, GIT_OBJECTS_DIR) < 0) + return -1; + + res = git_odb_open(&repo->_odb, odb_path.ptr); + git_buf_free(&odb_path); /* done with path */ + + if (res < 0) + return -1; + + GIT_REFCOUNT_OWN(repo->_odb, repo); + } + + *out = repo->_odb; + return 0; +} + +int git_repository_odb(git_odb **out, git_repository *repo) +{ + if (git_repository_odb__weakptr(out, repo) < 0) + return -1; + + GIT_REFCOUNT_INC(*out); + return 0; +} + +void git_repository_set_odb(git_repository *repo, git_odb *odb) +{ + assert(repo && odb); + + drop_odb(repo); + + repo->_odb = odb; + GIT_REFCOUNT_OWN(repo->_odb, repo); + GIT_REFCOUNT_INC(odb); +} + +int git_repository_index__weakptr(git_index **out, git_repository *repo) +{ + assert(out && repo); + + if (repo->_index == NULL) { + int res; + git_buf index_path = GIT_BUF_INIT; + + if (git_buf_joinpath(&index_path, repo->path_repository, GIT_INDEX_FILE) < 0) + return -1; + + res = git_index_open(&repo->_index, index_path.ptr); + git_buf_free(&index_path); /* done with path */ + + if (res < 0) + return -1; + + GIT_REFCOUNT_OWN(repo->_index, repo); + } + + *out = repo->_index; + return 0; +} + +int git_repository_index(git_index **out, git_repository *repo) +{ + if (git_repository_index__weakptr(out, repo) < 0) + return -1; + + GIT_REFCOUNT_INC(*out); + return 0; +} + +void git_repository_set_index(git_repository *repo, git_index *index) +{ + assert(repo && index); + + drop_index(repo); + + repo->_index = index; + GIT_REFCOUNT_OWN(repo->_index, repo); + GIT_REFCOUNT_INC(index); } static int check_repositoryformatversion(git_repository *repo) { git_config *config; - int version, error = GIT_SUCCESS; + int version; - if ((error = git_repository_config(&config, repo)) < GIT_SUCCESS) - return git__throw(error, "Failed to open config file."); + if (git_repository_config__weakptr(&config, repo) < 0) + return -1; - error = git_config_get_int32(config, GIT_CONFIG_CORE_REPOSITORYFORMATVERSION, &version); + if (git_config_get_int32(config, GIT_CONFIG_CORE_REPOSITORYFORMATVERSION, &version) < 0) + return -1; - if (GIT_REPOSITORYFORMATVERSION < version) - error = git__throw(GIT_ERROR, "Unsupported git repository version (Expected version <= %d, found %d).", GIT_REPOSITORYFORMATVERSION, version); + if (GIT_REPOSITORYFORMATVERSION < version) { + giterr_set(GITERR_REPOSITORY, + "Unsupported repository version %d. Only versions up to %d are supported.", + version, GIT_REPOSITORYFORMATVERSION); + return -1; + } - git_config_free(config); - - return error; + return 0; } static int repo_init_reinit(git_repository **repo_out, const char *repository_path, int is_bare) { - int error; git_repository *repo = NULL; - if ((error = git_repository_open(&repo, repository_path)) < GIT_SUCCESS) - goto error; + GIT_UNUSED(is_bare); - if ((error = check_repositoryformatversion(repo)) < GIT_SUCCESS) - goto error; + if (git_repository_open(&repo, repository_path) < 0) + return -1; + + if (check_repositoryformatversion(repo) < 0) { + git_repository_free(repo); + return -1; + } /* TODO: reinitialize the templates */ *repo_out = repo; - - return GIT_SUCCESS; - -error: - git_repository_free(repo); - - return git__rethrow(error, - "Failed to reinitialize the %srepository at '%s'. ", - is_bare ? "bare " : "", repository_path); + return 0; } static int repo_init_createhead(const char *git_dir) { - int error; git_buf ref_path = GIT_BUF_INIT; git_filebuf ref = GIT_FILEBUF_INIT; - if (!(error = git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE)) && - !(error = git_filebuf_open(&ref, ref_path.ptr, 0)) && - !(error = git_filebuf_printf(&ref, "ref: refs/heads/master\n"))) - error = git_filebuf_commit(&ref, GIT_REFS_FILE_MODE); + if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 || + git_filebuf_open(&ref, ref_path.ptr, 0) < 0 || + git_filebuf_printf(&ref, "ref: refs/heads/master\n") < 0 || + git_filebuf_commit(&ref, GIT_REFS_FILE_MODE) < 0) + return -1; git_buf_free(&ref_path); - return error; + return 0; } static int repo_init_config(const char *git_dir, int is_bare) { git_buf cfg_path = GIT_BUF_INIT; git_config *config = NULL; - int error = GIT_SUCCESS; #define SET_REPO_CONFIG(type, name, val) {\ - error = git_config_set_##type(config, name, val);\ - if (error < GIT_SUCCESS)\ - goto cleanup;\ + if (git_config_set_##type(config, name, val) < 0) { \ + git_buf_free(&cfg_path); \ + git_config_free(config); \ + return -1; } \ } - error = git_buf_joinpath(&cfg_path, git_dir, GIT_CONFIG_FILENAME_INREPO); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_buf_joinpath(&cfg_path, git_dir, GIT_CONFIG_FILENAME_INREPO) < 0) + return -1; - error = git_config_open_ondisk(&config, cfg_path.ptr); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_config_open_ondisk(&config, cfg_path.ptr) < 0) { + git_buf_free(&cfg_path); + return -1; + } SET_REPO_CONFIG(bool, "core.bare", is_bare); SET_REPO_CONFIG(int32, GIT_CONFIG_CORE_REPOSITORYFORMATVERSION, GIT_REPOSITORYFORMATVERSION); /* TODO: what other defaults? */ -cleanup: git_buf_free(&cfg_path); git_config_free(config); - return error; + return 0; } static int repo_init_structure(const char *git_dir, int is_bare) { - int error, i; + int i; struct { const char *dir; mode_t mode; } dirs[] = { { GIT_OBJECTS_INFO_DIR, GIT_OBJECT_DIR_MODE }, /* '/objects/info/' */ { GIT_OBJECTS_PACK_DIR, GIT_OBJECT_DIR_MODE }, /* '/objects/pack/' */ @@ -735,136 +695,102 @@ static int repo_init_structure(const char *git_dir, int is_bare) }; /* Make the base directory */ - error = git_futils_mkdir_r(git_dir, NULL, is_bare ? - GIT_BARE_DIR_MODE : GIT_DIR_MODE); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to initialize repository structure. Could not mkdir"); + if (git_futils_mkdir_r(git_dir, NULL, is_bare ? GIT_BARE_DIR_MODE : GIT_DIR_MODE) < 0) + return -1; /* Hides the ".git" directory */ if (!is_bare) { #ifdef GIT_WIN32 - error = p_hide_directory__w32(git_dir); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to initialize repository structure"); + if (p_hide_directory__w32(git_dir) < 0) { + giterr_set(GITERR_REPOSITORY, + "Failed to mark Git repository folder as hidden"); + return -1; + } #endif } /* Make subdirectories as needed */ for (i = 0; dirs[i].dir != NULL; ++i) { - error = git_futils_mkdir_r(dirs[i].dir, git_dir, dirs[i].mode); - if (error < GIT_SUCCESS) - return git__rethrow(error, - "Failed to create repository folder `%s`", dirs[i].dir); + if (git_futils_mkdir_r(dirs[i].dir, git_dir, dirs[i].mode) < 0) + return -1; } /* TODO: what's left? templates? */ - - return error; + return 0; } int git_repository_init(git_repository **repo_out, const char *path, unsigned is_bare) { - int error = GIT_SUCCESS; - git_repository *repo = NULL; git_buf repository_path = GIT_BUF_INIT; assert(repo_out && path); - error = git_buf_joinpath(&repository_path, path, is_bare ? "" : GIT_DIR); - if (error < GIT_SUCCESS) - return error; + if (git_buf_joinpath(&repository_path, path, is_bare ? "" : GIT_DIR) < 0) + return -1; - if (git_path_isdir(repository_path.ptr) == GIT_SUCCESS) { - if (quickcheck_repository_dir(&repository_path) == GIT_SUCCESS) { - error = repo_init_reinit(repo_out, repository_path.ptr, is_bare); + if (git_path_isdir(repository_path.ptr) == true) { + if (valid_repository_path(&repository_path) == true) { + int res = repo_init_reinit(repo_out, repository_path.ptr, is_bare); git_buf_free(&repository_path); - return error; + return res; } } - if (!(error = repo_init_structure(repository_path.ptr, is_bare)) && - !(error = repo_init_config(repository_path.ptr, is_bare)) && - !(error = repo_init_createhead(repository_path.ptr))) - error = git_repository_open(repo_out, repository_path.ptr); - else - git_repository_free(repo); + if (repo_init_structure(repository_path.ptr, is_bare) < 0 || + repo_init_config(repository_path.ptr, is_bare) < 0 || + repo_init_createhead(repository_path.ptr) < 0 || + git_repository_open(repo_out, repository_path.ptr) < 0) { + git_buf_free(&repository_path); + return -1; + } git_buf_free(&repository_path); - - if (error != GIT_SUCCESS) - git__rethrow(error, "Failed to (re)init the repository `%s`", path); - - return error; + return 0; } int git_repository_head_detached(git_repository *repo) { git_reference *ref; - int error; - size_t _size; - git_otype type; git_odb *odb = NULL; + int exists; - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) - return error; + if (git_repository_odb__weakptr(&odb, repo) < 0) + return -1; - error = git_reference_lookup(&ref, repo, GIT_HEAD_FILE); - if (error < GIT_SUCCESS) - return error; + if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0) + return -1; if (git_reference_type(ref) == GIT_REF_SYMBOLIC) { git_reference_free(ref); return 0; } - error = git_odb_read_header(&_size, &type, odb, git_reference_oid(ref)); + exists = git_odb_exists(odb, git_reference_oid(ref)); git_reference_free(ref); - - if (error < GIT_SUCCESS) - return error; - - if (type != GIT_OBJ_COMMIT) - return git__throw(GIT_EOBJCORRUPTED, "HEAD is not a commit"); - - return 1; + return exists; } int git_repository_head(git_reference **head_out, git_repository *repo) { - git_reference *ref, *resolved_ref; - int error; - - *head_out = NULL; - - error = git_reference_lookup(&ref, repo, GIT_HEAD_FILE); - if (error < GIT_SUCCESS) - return git__rethrow(GIT_ENOTAREPO, "Failed to locate the HEAD"); - - error = git_reference_resolve(&resolved_ref, ref); - if (error < GIT_SUCCESS) { - git_reference_free(ref); - return git__rethrow(error, "Failed to resolve the HEAD"); - } - - git_reference_free(ref); - - *head_out = resolved_ref; - return GIT_SUCCESS; + return git_reference_lookup_resolved(head_out, repo, GIT_HEAD_FILE, -1); } int git_repository_head_orphan(git_repository *repo) { - git_reference *ref; + git_reference *ref = NULL; int error; error = git_repository_head(&ref, repo); + git_reference_free(ref); - if (error == GIT_SUCCESS) - git_reference_free(ref); + if (error == GIT_ENOTFOUND) + return 1; - return error == GIT_ENOTFOUND ? 1 : error; + if (error < 0) + return -1; + + return 0; } int git_repository_is_empty(git_repository *repo) @@ -872,9 +798,8 @@ int git_repository_is_empty(git_repository *repo) git_reference *head = NULL, *branch = NULL; int error; - error = git_reference_lookup(&head, repo, "HEAD"); - if (error < GIT_SUCCESS) - return git__throw(error, "Corrupted repository. HEAD does not exist"); + if (git_reference_lookup(&head, repo, "HEAD") < 0) + return -1; if (git_reference_type(head) != GIT_REF_SYMBOLIC) { git_reference_free(head); @@ -891,7 +816,13 @@ int git_repository_is_empty(git_repository *repo) git_reference_free(head); git_reference_free(branch); - return error == GIT_ENOTFOUND ? 1 : error; + if (error == GIT_ENOTFOUND) + return 1; + + if (error < 0) + return -1; + + return 0; } const char *git_repository_path(git_repository *repo) @@ -912,16 +843,18 @@ const char *git_repository_workdir(git_repository *repo) int git_repository_set_workdir(git_repository *repo, const char *workdir) { + git_buf path = GIT_BUF_INIT; + assert(repo && workdir); - free(repo->workdir); + if (git_path_prettify_dir(&path, workdir, NULL) < 0) + return -1; - repo->workdir = git__strdup(workdir); - if (repo->workdir == NULL) - return GIT_ENOMEM; + git__free(repo->workdir); + repo->workdir = git_buf_detach(&path); repo->is_bare = 0; - return GIT_SUCCESS; + return 0; } int git_repository_is_bare(git_repository *repo) @@ -929,3 +862,23 @@ int git_repository_is_bare(git_repository *repo) assert(repo); return repo->is_bare; } + +int git_repository_head_tree(git_tree **tree, git_repository *repo) +{ + git_oid head_oid; + git_object *obj = NULL; + + if (git_reference_name_to_oid(&head_oid, repo, GIT_HEAD_FILE) < 0) { + /* cannot resolve HEAD - probably brand new repo */ + giterr_clear(); + *tree = NULL; + return 0; + } + + if (git_object_lookup(&obj, repo, &head_oid, GIT_OBJ_ANY) < 0 || + git_object__resolve_to_type(&obj, GIT_OBJ_TREE) < 0) + return -1; + + *tree = (git_tree *)obj; + return 0; +} diff --git a/src/repository.h b/src/repository.h index b5dcc1340..91c69a655 100644 --- a/src/repository.h +++ b/src/repository.h @@ -13,13 +13,13 @@ #include "git2/repository.h" #include "git2/object.h" -#include "hashtable.h" #include "index.h" #include "cache.h" #include "refs.h" #include "buffer.h" #include "odb.h" #include "attr.h" +#include "strmap.h" #define DOT_GIT ".git" #define GIT_DIR DOT_GIT "/" @@ -83,6 +83,7 @@ struct git_repository { git_cache objects; git_refcache references; git_attr_cache attrcache; + git_strmap *submodules; char *path_repository; char *workdir; @@ -97,9 +98,18 @@ struct git_repository { * export */ void git_object__free(void *object); +int git_object__resolve_to_type(git_object **obj, git_otype type); + int git_oid__parse(git_oid *oid, const char **buffer_out, const char *buffer_end, const char *header); void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid); +GIT_INLINE(git_attr_cache *) git_repository_attr_cache(git_repository *repo) +{ + return &repo->attrcache; +} + +int git_repository_head_tree(git_tree **tree, git_repository *repo); + /* * Weak pointers to repository internals. * @@ -120,4 +130,9 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo); int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar); void git_repository__cvar_cache_clear(git_repository *repo); +/* + * Submodule cache + */ +extern void git_submodule_config_free(git_repository *repo); + #endif diff --git a/src/revwalk.c b/src/revwalk.c index 997771f08..1b539787f 100644 --- a/src/revwalk.c +++ b/src/revwalk.c @@ -8,20 +8,30 @@ #include "common.h" #include "commit.h" #include "odb.h" -#include "hashtable.h" #include "pqueue.h" +#include "pool.h" +#include "oidmap.h" #include "git2/revwalk.h" +#include "git2/merge.h" #include +GIT__USE_OIDMAP; + +#define PARENT1 (1 << 0) +#define PARENT2 (1 << 1) +#define RESULT (1 << 2) +#define STALE (1 << 3) + typedef struct commit_object { git_oid oid; uint32_t time; unsigned int seen:1, uninteresting:1, topo_delay:1, - parsed:1; + parsed:1, + flags : 4; unsigned short in_degree; unsigned short out_degree; @@ -38,7 +48,8 @@ struct git_revwalk { git_repository *repo; git_odb *odb; - git_hashtable *commits; + git_oidmap *commits; + git_pool commit_pool; commit_list *iterator_topo; commit_list *iterator_rand; @@ -48,22 +59,47 @@ struct git_revwalk { int (*get_next)(commit_object **, git_revwalk *); int (*enqueue)(git_revwalk *, commit_object *); - git_vector memory_alloc; - size_t chunk_size; - unsigned walking:1; unsigned int sorting; + + /* merge base calculation */ + commit_object *one; + git_vector twos; }; +static int commit_time_cmp(void *a, void *b) +{ + commit_object *commit_a = (commit_object *)a; + commit_object *commit_b = (commit_object *)b; + + return (commit_a->time < commit_b->time); +} + static commit_list *commit_list_insert(commit_object *item, commit_list **list_p) { commit_list *new_list = git__malloc(sizeof(commit_list)); - new_list->item = item; - new_list->next = *list_p; + if (new_list != NULL) { + new_list->item = item; + new_list->next = *list_p; + } *list_p = new_list; return new_list; } +static commit_list *commit_list_insert_by_date(commit_object *item, commit_list **list_p) +{ + commit_list **pp = list_p; + commit_list *p; + + while ((p = *pp) != NULL) { + if (commit_time_cmp(p->item, item) < 0) + break; + + pp = &p->next; + } + + return commit_list_insert(item, pp); +} static void commit_list_free(commit_list **list_p) { commit_list *list = *list_p; @@ -89,68 +125,36 @@ static commit_object *commit_list_pop(commit_list **stack) return item; } -static int commit_time_cmp(void *a, void *b) -{ - commit_object *commit_a = (commit_object *)a; - commit_object *commit_b = (commit_object *)b; - - return (commit_a->time < commit_b->time); -} - -static uint32_t object_table_hash(const void *key, int hash_id) -{ - uint32_t r; - const git_oid *id = key; - - memcpy(&r, id->id + (hash_id * sizeof(uint32_t)), sizeof(r)); - return r; -} - -#define COMMITS_PER_CHUNK 128 -#define CHUNK_STEP 64 -#define PARENTS_PER_COMMIT ((CHUNK_STEP - sizeof(commit_object)) / sizeof(commit_object *)) - -static int alloc_chunk(git_revwalk *walk) -{ - void *chunk; - - chunk = git__calloc(COMMITS_PER_CHUNK, CHUNK_STEP); - if (chunk == NULL) - return GIT_ENOMEM; - - walk->chunk_size = 0; - return git_vector_insert(&walk->memory_alloc, chunk); -} +#define PARENTS_PER_COMMIT 2 +#define COMMIT_ALLOC \ + (sizeof(commit_object) + PARENTS_PER_COMMIT * sizeof(commit_object *)) static commit_object *alloc_commit(git_revwalk *walk) { - unsigned char *chunk; - - if (walk->chunk_size == COMMITS_PER_CHUNK) - alloc_chunk(walk); - - chunk = git_vector_get(&walk->memory_alloc, walk->memory_alloc.length - 1); - chunk += (walk->chunk_size * CHUNK_STEP); - walk->chunk_size++; - - return (commit_object *)chunk; + return (commit_object *)git_pool_malloc(&walk->commit_pool, COMMIT_ALLOC); } -static commit_object **alloc_parents(commit_object *commit, size_t n_parents) +static commit_object **alloc_parents( + git_revwalk *walk, commit_object *commit, size_t n_parents) { if (n_parents <= PARENTS_PER_COMMIT) - return (commit_object **)((unsigned char *)commit + sizeof(commit_object)); + return (commit_object **)((char *)commit + sizeof(commit_object)); - return git__malloc(n_parents * sizeof(commit_object *)); + return (commit_object **)git_pool_malloc( + &walk->commit_pool, (uint32_t)(n_parents * sizeof(commit_object *))); } static commit_object *commit_lookup(git_revwalk *walk, const git_oid *oid) { commit_object *commit; + khiter_t pos; + int ret; - if ((commit = git_hashtable_lookup(walk->commits, oid)) != NULL) - return commit; + /* lookup and reserve space if not already present */ + pos = kh_get(oid, walk->commits, oid); + if (pos != kh_end(walk->commits)) + return kh_value(walk->commits, pos); commit = alloc_commit(walk); if (commit == NULL) @@ -158,17 +162,16 @@ static commit_object *commit_lookup(git_revwalk *walk, const git_oid *oid) git_oid_cpy(&commit->oid, oid); - if (git_hashtable_insert(walk->commits, &commit->oid, commit) < GIT_SUCCESS) { - git__free(commit); - return NULL; - } + pos = kh_put(oid, walk->commits, &commit->oid, &ret); + assert(ret != 0); + kh_value(walk->commits, pos) = commit; return commit; } static int commit_quick_parse(git_revwalk *walk, commit_object *commit, git_rawobj *raw) { - const int parent_len = strlen("parent ") + GIT_OID_HEXSZ + 1; + const size_t parent_len = strlen("parent ") + GIT_OID_HEXSZ + 1; unsigned char *buffer = raw->data; unsigned char *buffer_end = buffer + raw->len; @@ -185,39 +188,44 @@ static int commit_quick_parse(git_revwalk *walk, commit_object *commit, git_rawo buffer += parent_len; } - commit->parents = alloc_parents(commit, parents); - if (commit->parents == NULL) - return GIT_ENOMEM; + commit->parents = alloc_parents(walk, commit, parents); + GITERR_CHECK_ALLOC(commit->parents); buffer = parents_start; for (i = 0; i < parents; ++i) { git_oid oid; - if (git_oid_fromstr(&oid, (char *)buffer + strlen("parent ")) < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse commit. Parent object is corrupted"); + if (git_oid_fromstr(&oid, (char *)buffer + strlen("parent ")) < 0) + return -1; commit->parents[i] = commit_lookup(walk, &oid); if (commit->parents[i] == NULL) - return GIT_ENOMEM; + return -1; buffer += parent_len; } commit->out_degree = (unsigned short)parents; - if ((buffer = memchr(buffer, '\n', buffer_end - buffer)) == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse commit. Object is corrupted"); + if ((buffer = memchr(buffer, '\n', buffer_end - buffer)) == NULL) { + giterr_set(GITERR_ODB, "Failed to parse commit. Object is corrupted"); + return -1; + } buffer = memchr(buffer, '>', buffer_end - buffer); - if (buffer == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse commit. Can't find author"); + if (buffer == NULL) { + giterr_set(GITERR_ODB, "Failed to parse commit. Can't find author"); + return -1; + } - if (git__strtol32(&commit_time, (char *)buffer + 2, NULL, 10) < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse commit. Can't parse commit time"); + if (git__strtol32(&commit_time, (char *)buffer + 2, NULL, 10) < 0) { + giterr_set(GITERR_ODB, "Failed to parse commit. Can't parse commit time"); + return -1; + } commit->time = (time_t)commit_time; commit->parsed = 1; - return GIT_SUCCESS; + return 0; } static int commit_parse(git_revwalk *walk, commit_object *commit) @@ -226,19 +234,159 @@ static int commit_parse(git_revwalk *walk, commit_object *commit) int error; if (commit->parsed) - return GIT_SUCCESS; + return 0; - if ((error = git_odb_read(&obj, walk->odb, &commit->oid)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to parse commit. Can't read object"); + if ((error = git_odb_read(&obj, walk->odb, &commit->oid)) < 0) + return error; if (obj->raw.type != GIT_OBJ_COMMIT) { git_odb_object_free(obj); - return git__throw(GIT_EOBJTYPE, "Failed to parse commit. Object is no commit object"); + giterr_set(GITERR_INVALID, "Failed to parse commit. Object is no commit object"); + return -1; } error = commit_quick_parse(walk, commit, &obj->raw); git_odb_object_free(obj); - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse commit"); + return error; +} + +static int interesting(git_pqueue *list) +{ + unsigned int i; + for (i = 1; i < git_pqueue_size(list); i++) { + commit_object *commit = list->d[i]; + if ((commit->flags & STALE) == 0) + return 1; + } + + return 0; +} + +static int merge_bases_many(commit_list **out, git_revwalk *walk, commit_object *one, git_vector *twos) +{ + int error; + unsigned int i; + commit_object *two; + commit_list *result = NULL, *tmp = NULL; + git_pqueue list; + + /* if the commit is repeated, we have a our merge base already */ + git_vector_foreach(twos, i, two) { + if (one == two) + return commit_list_insert(one, out) ? 0 : -1; + } + + if (git_pqueue_init(&list, twos->length * 2, commit_time_cmp) < 0) + return -1; + + if (commit_parse(walk, one) < 0) + return -1; + + one->flags |= PARENT1; + if (git_pqueue_insert(&list, one) < 0) + return -1; + + git_vector_foreach(twos, i, two) { + commit_parse(walk, two); + two->flags |= PARENT2; + if (git_pqueue_insert(&list, two) < 0) + return -1; + } + + /* as long as there are non-STALE commits */ + while (interesting(&list)) { + commit_object *commit; + int flags; + + commit = git_pqueue_pop(&list); + + flags = commit->flags & (PARENT1 | PARENT2 | STALE); + if (flags == (PARENT1 | PARENT2)) { + if (!(commit->flags & RESULT)) { + commit->flags |= RESULT; + if (commit_list_insert(commit, &result) == NULL) + return -1; + } + /* we mark the parents of a merge stale */ + flags |= STALE; + } + + for (i = 0; i < commit->out_degree; i++) { + commit_object *p = commit->parents[i]; + if ((p->flags & flags) == flags) + continue; + + if ((error = commit_parse(walk, p)) < GIT_SUCCESS) + return error; + + p->flags |= flags; + if (git_pqueue_insert(&list, p) < 0) + return -1; + } + } + + git_pqueue_free(&list); + + /* filter out any stale commits in the results */ + tmp = result; + result = NULL; + + while (tmp) { + struct commit_list *next = tmp->next; + if (!(tmp->item->flags & STALE)) + if (commit_list_insert_by_date(tmp->item, &result) == NULL) + return -1; + + git__free(tmp); + tmp = next; + } + + *out = result; + return 0; +} + +int git_merge_base(git_oid *out, git_repository *repo, git_oid *one, git_oid *two) +{ + git_revwalk *walk; + git_vector list; + commit_list *result = NULL; + commit_object *commit; + void *contents[1]; + + if (git_revwalk_new(&walk, repo) < 0) + return -1; + + commit = commit_lookup(walk, two); + if (commit == NULL) + goto on_error; + + /* This is just one value, so we can do it on the stack */ + memset(&list, 0x0, sizeof(git_vector)); + contents[0] = commit; + list.length = 1; + list.contents = contents; + + commit = commit_lookup(walk, one); + if (commit == NULL) + goto on_error; + + if (merge_bases_many(&result, walk, commit, &list) < 0) + goto on_error; + + if (!result) { + git_revwalk_free(walk); + return GIT_ENOTFOUND; + } + + git_oid_cpy(out, &result->item->oid); + commit_list_free(&result); + git_revwalk_free(walk); + + return 0; + +on_error: + git_revwalk_free(walk); + return -1; } static void mark_uninteresting(commit_object *commit) @@ -248,6 +396,10 @@ static void mark_uninteresting(commit_object *commit) commit->uninteresting = 1; + /* This means we've reached a merge base, so there's no need to walk any more */ + if ((commit->flags & (RESULT | STALE)) == RESULT) + return; + for (i = 0; i < commit->out_degree; ++i) if (!commit->parents[i]->uninteresting) mark_uninteresting(commit->parents[i]); @@ -261,12 +413,12 @@ static int process_commit(git_revwalk *walk, commit_object *commit, int hide) mark_uninteresting(commit); if (commit->seen) - return GIT_SUCCESS; + return 0; commit->seen = 1; - if ((error = commit_parse(walk, commit)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to process commit"); + if ((error = commit_parse(walk, commit)) < 0) + return error; return walk->enqueue(walk, commit); } @@ -274,13 +426,12 @@ static int process_commit(git_revwalk *walk, commit_object *commit, int hide) static int process_commit_parents(git_revwalk *walk, commit_object *commit) { unsigned short i; - int error = GIT_SUCCESS; + int error = 0; - for (i = 0; i < commit->out_degree && error == GIT_SUCCESS; ++i) { + for (i = 0; i < commit->out_degree && !error; ++i) error = process_commit(walk, commit->parents[i], commit->uninteresting); - } - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to process commit parents"); + return error; } static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting) @@ -289,9 +440,17 @@ static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting) commit = commit_lookup(walk, oid); if (commit == NULL) - return git__throw(GIT_ENOTFOUND, "Failed to push commit. Object not found"); + return -1; /* error already reported by failed lookup */ - return process_commit(walk, commit, uninteresting); + commit->uninteresting = uninteresting; + if (walk->one == NULL && !uninteresting) { + walk->one = commit; + } else { + if (git_vector_insert(&walk->twos, commit) < 0) + return -1; + } + + return 0; } int git_revwalk_push(git_revwalk *walk, const git_oid *oid) @@ -307,6 +466,16 @@ int git_revwalk_hide(git_revwalk *walk, const git_oid *oid) return push_commit(walk, oid, 1); } +static int push_ref(git_revwalk *walk, const char *refname, int hide) +{ + git_oid oid; + + if (git_reference_name_to_oid(&oid, walk->repo, refname) < 0) + return -1; + + return push_commit(walk, &oid, hide); +} + struct push_cb_data { git_revwalk *walk; const char *glob; @@ -317,30 +486,16 @@ static int push_glob_cb(const char *refname, void *data_) { struct push_cb_data *data = (struct push_cb_data *)data_; - if (!git__fnmatch(data->glob, refname, 0)) { - git_reference *ref, *resolved; - int error; + if (!p_fnmatch(data->glob, refname, 0)) + return push_ref(data->walk, refname, data->hide); - error = git_reference_lookup(&ref, data->walk->repo, refname); - if (error < GIT_SUCCESS) - return error; - error = git_reference_resolve(&resolved, ref); - git_reference_free(ref); - if (error < GIT_SUCCESS) - return error; - error = push_commit(data->walk, git_reference_oid(resolved), data->hide); - git_reference_free(resolved); - return error; - } - - return GIT_SUCCESS; + return 0; } static int push_glob(git_revwalk *walk, const char *glob, int hide) { git_buf buf = GIT_BUF_INIT; struct push_cb_data data; - int error; regex_t preg; assert(walk && glob); @@ -355,28 +510,33 @@ static int push_glob(git_revwalk *walk, const char *glob, int hide) /* If no '?', '*' or '[' exist, we append '/ *' to the glob */ memset(&preg, 0x0, sizeof(regex_t)); if (regcomp(&preg, "[?*[]", REG_EXTENDED)) { - error = git__throw(GIT_EOSERR, "Regex failed to compile"); - goto cleanup; + giterr_set(GITERR_OS, "Regex failed to compile"); + git_buf_free(&buf); + return -1; } if (regexec(&preg, glob, 0, NULL, 0)) git_buf_puts(&buf, "/*"); - if (git_buf_oom(&buf)) { - error = GIT_ENOMEM; - goto cleanup; - } + if (git_buf_oom(&buf)) + goto on_error; data.walk = walk; data.glob = git_buf_cstr(&buf); data.hide = hide; - error = git_reference_foreach(walk->repo, GIT_REF_LISTALL, push_glob_cb, &data); + if (git_reference_foreach( + walk->repo, GIT_REF_LISTALL, push_glob_cb, &data) < 0) + goto on_error; -cleanup: regfree(&preg); git_buf_free(&buf); - return error; + return 0; + +on_error: + regfree(&preg); + git_buf_free(&buf); + return -1; } int git_revwalk_push_glob(git_revwalk *walk, const char *glob) @@ -391,37 +551,28 @@ int git_revwalk_hide_glob(git_revwalk *walk, const char *glob) return push_glob(walk, glob, 1); } -static int push_head(git_revwalk *walk, int hide) -{ - git_reference *ref, *resolved; - int error; - - error = git_reference_lookup(&ref, walk->repo, "HEAD"); - if (error < GIT_SUCCESS) { - return error; - } - error = git_reference_resolve(&resolved, ref); - if (error < GIT_SUCCESS) { - return error; - } - git_reference_free(ref); - - error = push_commit(walk, git_reference_oid(resolved), hide); - - git_reference_free(resolved); - return error; -} - int git_revwalk_push_head(git_revwalk *walk) { assert(walk); - return push_head(walk, 0); + return push_ref(walk, GIT_HEAD_FILE, 0); } int git_revwalk_hide_head(git_revwalk *walk) { assert(walk); - return push_head(walk, 1); + return push_ref(walk, GIT_HEAD_FILE, 1); +} + +int git_revwalk_push_ref(git_revwalk *walk, const char *refname) +{ + assert(walk && refname); + return push_ref(walk, refname, 0); +} + +int git_revwalk_hide_ref(git_revwalk *walk, const char *refname) +{ + assert(walk && refname); + return push_ref(walk, refname, 1); } static int revwalk_enqueue_timesort(git_revwalk *walk, commit_object *commit) @@ -431,7 +582,7 @@ static int revwalk_enqueue_timesort(git_revwalk *walk, commit_object *commit) static int revwalk_enqueue_unsorted(git_revwalk *walk, commit_object *commit) { - return commit_list_insert(commit, &walk->iterator_rand) ? GIT_SUCCESS : GIT_ENOMEM; + return commit_list_insert(commit, &walk->iterator_rand) ? 0 : -1; } static int revwalk_next_timesort(commit_object **object_out, git_revwalk *walk) @@ -440,16 +591,16 @@ static int revwalk_next_timesort(commit_object **object_out, git_revwalk *walk) commit_object *next; while ((next = git_pqueue_pop(&walk->iterator_time)) != NULL) { - if ((error = process_commit_parents(walk, next)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to load next revision"); + if ((error = process_commit_parents(walk, next)) < 0) + return error; if (!next->uninteresting) { *object_out = next; - return GIT_SUCCESS; + return 0; } } - return git__throw(GIT_EREVWALKOVER, "Failed to load next revision"); + return GIT_EREVWALKOVER; } static int revwalk_next_unsorted(commit_object **object_out, git_revwalk *walk) @@ -458,16 +609,16 @@ static int revwalk_next_unsorted(commit_object **object_out, git_revwalk *walk) commit_object *next; while ((next = commit_list_pop(&walk->iterator_rand)) != NULL) { - if ((error = process_commit_parents(walk, next)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to load next revision"); + if ((error = process_commit_parents(walk, next)) < 0) + return error; if (!next->uninteresting) { *object_out = next; - return GIT_SUCCESS; + return 0; } } - return git__throw(GIT_EREVWALKOVER, "Failed to load next revision"); + return GIT_EREVWALKOVER; } static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk) @@ -478,7 +629,7 @@ static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk) for (;;) { next = commit_list_pop(&walk->iterator_topo); if (next == NULL) - return git__throw(GIT_EREVWALKOVER, "Failed to load next revision"); + return GIT_EREVWALKOVER; if (next->in_degree > 0) { next->topo_delay = 1; @@ -490,58 +641,83 @@ static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk) if (--parent->in_degree == 0 && parent->topo_delay) { parent->topo_delay = 0; - commit_list_insert(parent, &walk->iterator_topo); + if (commit_list_insert(parent, &walk->iterator_topo) == NULL) + return -1; } } *object_out = next; - return GIT_SUCCESS; + return 0; } } static int revwalk_next_reverse(commit_object **object_out, git_revwalk *walk) { *object_out = commit_list_pop(&walk->iterator_reverse); - return *object_out ? GIT_SUCCESS : GIT_EREVWALKOVER; + return *object_out ? 0 : GIT_EREVWALKOVER; } static int prepare_walk(git_revwalk *walk) { int error; - commit_object *next; + unsigned int i; + commit_object *next, *two; + commit_list *bases = NULL; + + /* + * If walk->one is NULL, there were no positive references, + * so we know that the walk is already over. + */ + if (walk->one == NULL) + return GIT_EREVWALKOVER; + + /* first figure out what the merge bases are */ + if (merge_bases_many(&bases, walk, walk->one, &walk->twos) < 0) + return -1; + + commit_list_free(&bases); + if (process_commit(walk, walk->one, walk->one->uninteresting) < 0) + return -1; + + git_vector_foreach(&walk->twos, i, two) { + if (process_commit(walk, two, two->uninteresting) < 0) + return -1; + } if (walk->sorting & GIT_SORT_TOPOLOGICAL) { unsigned short i; - while ((error = walk->get_next(&next, walk)) == GIT_SUCCESS) { + while ((error = walk->get_next(&next, walk)) == 0) { for (i = 0; i < next->out_degree; ++i) { commit_object *parent = next->parents[i]; parent->in_degree++; } - commit_list_insert(next, &walk->iterator_topo); + if (commit_list_insert(next, &walk->iterator_topo) == NULL) + return -1; } if (error != GIT_EREVWALKOVER) - return git__rethrow(error, "Failed to prepare revision walk"); + return error; walk->get_next = &revwalk_next_toposort; } if (walk->sorting & GIT_SORT_REVERSE) { - while ((error = walk->get_next(&next, walk)) == GIT_SUCCESS) - commit_list_insert(next, &walk->iterator_reverse); + while ((error = walk->get_next(&next, walk)) == 0) + if (commit_list_insert(next, &walk->iterator_reverse) == NULL) + return -1; if (error != GIT_EREVWALKOVER) - return git__rethrow(error, "Failed to prepare revision walk"); + return error; walk->get_next = &revwalk_next_reverse; } walk->walking = 1; - return GIT_SUCCESS; + return 0; } @@ -550,69 +726,48 @@ static int prepare_walk(git_revwalk *walk) int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo) { - int error; git_revwalk *walk; walk = git__malloc(sizeof(git_revwalk)); - if (walk == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(walk); memset(walk, 0x0, sizeof(git_revwalk)); - walk->commits = git_hashtable_alloc(64, - object_table_hash, - (git_hash_keyeq_ptr)git_oid_cmp); + walk->commits = git_oidmap_alloc(); + GITERR_CHECK_ALLOC(walk->commits); - if (walk->commits == NULL) { - git__free(walk); - return GIT_ENOMEM; - } - - git_pqueue_init(&walk->iterator_time, 8, commit_time_cmp); - git_vector_init(&walk->memory_alloc, 8, NULL); - alloc_chunk(walk); + if (git_pqueue_init(&walk->iterator_time, 8, commit_time_cmp) < 0 || + git_vector_init(&walk->twos, 4, NULL) < 0 || + git_pool_init(&walk->commit_pool, 1, + git_pool__suggest_items_per_page(COMMIT_ALLOC) * COMMIT_ALLOC) < 0) + return -1; walk->get_next = &revwalk_next_unsorted; walk->enqueue = &revwalk_enqueue_unsorted; walk->repo = repo; - error = git_repository_odb(&walk->odb, repo); - if (error < GIT_SUCCESS) { + if (git_repository_odb(&walk->odb, repo) < 0) { git_revwalk_free(walk); - return error; + return -1; } *revwalk_out = walk; - return GIT_SUCCESS; + return 0; } void git_revwalk_free(git_revwalk *walk) { - unsigned int i; - commit_object *commit; - if (walk == NULL) return; git_revwalk_reset(walk); git_odb_free(walk->odb); - /* if the parent has more than PARENTS_PER_COMMIT parents, - * we had to allocate a separate array for those parents. - * make sure it's being free'd */ - GIT_HASHTABLE_FOREACH_VALUE(walk->commits, commit, { - if (commit->out_degree > PARENTS_PER_COMMIT) - git__free(commit->parents); - }); - - git_hashtable_free(walk->commits); + git_oidmap_free(walk->commits); + git_pool_clear(&walk->commit_pool); git_pqueue_free(&walk->iterator_time); - - for (i = 0; i < walk->memory_alloc.length; ++i) - git__free(git_vector_get(&walk->memory_alloc, i)); - - git_vector_free(&walk->memory_alloc); + git_vector_free(&walk->twos); git__free(walk); } @@ -648,8 +803,8 @@ int git_revwalk_next(git_oid *oid, git_revwalk *walk) assert(walk && oid); if (!walk->walking) { - if ((error = prepare_walk(walk)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to load next revision"); + if ((error = prepare_walk(walk)) < 0) + return error; } error = walk->get_next(&next, walk); @@ -659,11 +814,10 @@ int git_revwalk_next(git_oid *oid, git_revwalk *walk) return GIT_EREVWALKOVER; } - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to load next revision"); + if (!error) + git_oid_cpy(oid, &next->oid); - git_oid_cpy(oid, &next->oid); - return GIT_SUCCESS; + return error; } void git_revwalk_reset(git_revwalk *walk) @@ -672,12 +826,12 @@ void git_revwalk_reset(git_revwalk *walk) assert(walk); - GIT_HASHTABLE_FOREACH_VALUE(walk->commits, commit, + kh_foreach_value(walk->commits, commit, { commit->seen = 0; commit->in_degree = 0; commit->topo_delay = 0; commit->uninteresting = 0; - ); + }); git_pqueue_clear(&walk->iterator_time); commit_list_free(&walk->iterator_topo); diff --git a/src/sha1.c b/src/sha1.c index af3c2d2d0..8aaedeb8f 100644 --- a/src/sha1.c +++ b/src/sha1.c @@ -232,7 +232,7 @@ void git__blk_SHA1_Init(blk_SHA_CTX *ctx) ctx->H[4] = 0xc3d2e1f0; } -void git__blk_SHA1_Update(blk_SHA_CTX *ctx, const void *data, unsigned long len) +void git__blk_SHA1_Update(blk_SHA_CTX *ctx, const void *data, size_t len) { unsigned int lenW = ctx->size & 63; @@ -242,7 +242,7 @@ void git__blk_SHA1_Update(blk_SHA_CTX *ctx, const void *data, unsigned long len) if (lenW) { unsigned int left = 64 - lenW; if (len < left) - left = len; + left = (unsigned int)len; memcpy(lenW + (char *)ctx->W, data, left); lenW = (lenW + left) & 63; len -= left; diff --git a/src/sha1.h b/src/sha1.h index 117e93106..93a244d76 100644 --- a/src/sha1.h +++ b/src/sha1.h @@ -12,7 +12,7 @@ typedef struct { } blk_SHA_CTX; void git__blk_SHA1_Init(blk_SHA_CTX *ctx); -void git__blk_SHA1_Update(blk_SHA_CTX *ctx, const void *dataIn, unsigned long len); +void git__blk_SHA1_Update(blk_SHA_CTX *ctx, const void *dataIn, size_t len); void git__blk_SHA1_Final(unsigned char hashout[20], blk_SHA_CTX *ctx); #define SHA_CTX blk_SHA_CTX diff --git a/src/sha1_lookup.c b/src/sha1_lookup.c index 58d70aeb7..096da1739 100644 --- a/src/sha1_lookup.c +++ b/src/sha1_lookup.c @@ -158,7 +158,8 @@ int sha1_entry_pos(const void *table, #endif if (!(lo <= mi && mi < hi)) { - return git__throw(GIT_ERROR, "Assertion failure. Binary search invariant is false"); + giterr_set(GITERR_INVALID, "Assertion failure. Binary search invariant is false"); + return -1; } mi_key = base + elem_size * mi + key_offset; diff --git a/src/signature.c b/src/signature.c index 1b6ba2149..4d6d11c70 100644 --- a/src/signature.c +++ b/src/signature.c @@ -38,31 +38,38 @@ static const char *skip_trailing_spaces(const char *buffer_start, const char *bu return buffer_end; } +static int signature_error(const char *msg) +{ + giterr_set(GITERR_INVALID, "Failed to parse signature - %s", msg); + return -1; +} + static int process_trimming(const char *input, char **storage, const char *input_end, int fail_when_empty) { const char *left, *right; - int trimmed_input_length; + size_t trimmed_input_length; + + assert(storage); left = skip_leading_spaces(input, input_end); right = skip_trailing_spaces(input, input_end - 1); if (right < left) { if (fail_when_empty) - return git__throw(GIT_EINVALIDARGS, "Failed to trim. Input is either empty or only contains spaces"); - else - right = left - 1; + return signature_error("input is either empty of contains only spaces"); + + right = left - 1; } trimmed_input_length = right - left + 1; *storage = git__malloc(trimmed_input_length + 1); - if (*storage == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(*storage); memcpy(*storage, left, trimmed_input_length); (*storage)[trimmed_input_length] = 0; - return GIT_SUCCESS; + return 0; } int git_signature_new(git_signature **sig_out, const char *name, const char *email, git_time_t time, int offset) @@ -74,23 +81,14 @@ int git_signature_new(git_signature **sig_out, const char *name, const char *ema *sig_out = NULL; - if ((p = git__malloc(sizeof(git_signature))) == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + p = git__calloc(1, sizeof(git_signature)); + GITERR_CHECK_ALLOC(p); - memset(p, 0x0, sizeof(git_signature)); - - error = process_trimming(name, &p->name, name + strlen(name), 1); - if (error < GIT_SUCCESS) { - git__rethrow(GIT_EINVALIDARGS, "Failed to create signature. 'name' argument is invalid"); - goto cleanup; - } - - error = process_trimming(email, &p->email, email + strlen(email), 1); - if (error < GIT_SUCCESS) { - git__rethrow(GIT_EINVALIDARGS, "Failed to create signature. 'email' argument is invalid"); - goto cleanup; + if ((error = process_trimming(name, &p->name, name + strlen(name), 1)) < 0 || + (error = process_trimming(email, &p->email, email + strlen(email), 1)) < 0) + { + git_signature_free(p); + return error; } p->when.time = time; @@ -98,24 +96,19 @@ int git_signature_new(git_signature **sig_out, const char *name, const char *ema *sig_out = p; - return error; - -cleanup: - git_signature_free(p); - return error; + return 0; } git_signature *git_signature_dup(const git_signature *sig) { git_signature *new; - if (git_signature_new(&new, sig->name, sig->email, sig->when.time, sig->when.offset) < GIT_SUCCESS) + if (git_signature_new(&new, sig->name, sig->email, sig->when.time, sig->when.offset) < 0) return NULL; return new; } int git_signature_now(git_signature **sig_out, const char *name, const char *email) { - int error; time_t now; time_t offset; struct tm *utc_tm, *local_tm; @@ -148,12 +141,18 @@ int git_signature_now(git_signature **sig_out, const char *name, const char *ema if (local_tm->tm_isdst) offset += 60; - if ((error = git_signature_new(&sig, name, email, now, (int)offset)) < GIT_SUCCESS) - return error; + if (git_signature_new(&sig, name, email, now, (int)offset) < 0) + return -1; *sig_out = sig; - return error; + return 0; +} + +static int timezone_error(const char *msg) +{ + giterr_set(GITERR_INVALID, "Failed to parse TZ offset - %s", msg); + return -1; } static int parse_timezone_offset(const char *buffer, int *offset_out) @@ -172,28 +171,28 @@ static int parse_timezone_offset(const char *buffer, int *offset_out) } if (offset_start[0] != '-' && offset_start[0] != '+') - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. It doesn't start with '+' or '-'"); + return timezone_error("does not start with '+' or '-'"); if (offset_start[1] < '0' || offset_start[1] > '9') - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset."); + return timezone_error("expected initial digit"); if (git__strtol32(&dec_offset, offset_start + 1, &offset_end, 10) < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. It isn't a number"); + return timezone_error("not a valid number"); if (offset_end - offset_start != 5) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. Invalid length"); + return timezone_error("invalid length"); if (dec_offset > 1400) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. Value too large"); + return timezone_error("value too large"); hours = dec_offset / 100; mins = dec_offset % 100; if (hours > 14) // see http://www.worldtimezone.com/faq.html - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. Hour value too large"); + return timezone_error("hour value too large"); if (mins > 59) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. Minute value too large"); + return timezone_error("minutes value too large"); offset = (hours * 60) + mins; @@ -202,22 +201,22 @@ static int parse_timezone_offset(const char *buffer, int *offset_out) *offset_out = offset; - return GIT_SUCCESS; + return 0; } static int process_next_token(const char **buffer_out, char **storage, const char *token_end, const char *right_boundary) { int error = process_trimming(*buffer_out, storage, token_end, 0); - if (error < GIT_SUCCESS) + if (error < 0) return error; *buffer_out = token_end + 1; if (*buffer_out > right_boundary) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Signature too short"); + return signature_error("signature is too short"); - return GIT_SUCCESS; + return 0; } static const char *scan_for_previous_token(const char *buffer, const char *left_boundary) @@ -241,17 +240,17 @@ static int parse_time(git_time_t *time_out, const char *buffer) int time; int error; - if (*buffer == '+' || *buffer == '-') - return git__throw(GIT_ERROR, "Failed while parsing time. '%s' rather look like a timezone offset.", buffer); + if (*buffer == '+' || *buffer == '-') { + giterr_set(GITERR_INVALID, "Failed while parsing time. '%s' actually looks like a timezone offset.", buffer); + return -1; + } error = git__strtol32(&time, buffer, &buffer, 10); - if (error < GIT_SUCCESS) - return error; + if (!error) + *time_out = (git_time_t)time; - *time_out = (git_time_t)time; - - return GIT_SUCCESS; + return error; } int git_signature__parse(git_signature *sig, const char **buffer_out, @@ -259,40 +258,40 @@ int git_signature__parse(git_signature *sig, const char **buffer_out, { const char *buffer = *buffer_out; const char *line_end, *name_end, *email_end, *tz_start, *time_start; - int error = GIT_SUCCESS; + int error = 0; memset(sig, 0x0, sizeof(git_signature)); if ((line_end = memchr(buffer, ender, buffer_end - buffer)) == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. No newline given"); + return signature_error("no newline given"); if (header) { const size_t header_len = strlen(header); if (memcmp(buffer, header, header_len) != 0) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Expected prefix '%s' doesn't match actual", header); + return signature_error("expected prefix doesn't match actual"); buffer += header_len; } if (buffer > line_end) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Signature too short"); + return signature_error("signature too short"); if ((name_end = strchr(buffer, '<')) == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Cannot find '<' in signature"); + return signature_error("character '<' not allowed in signature"); if ((email_end = strchr(name_end, '>')) == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Cannot find '>' in signature"); + return signature_error("character '>' not allowed in signature"); if (email_end < name_end) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Malformed e-mail"); + return signature_error("malformed e-mail"); error = process_next_token(&buffer, &sig->name, name_end, line_end); - if (error < GIT_SUCCESS) + if (error < 0) return error; error = process_next_token(&buffer, &sig->email, email_end, line_end); - if (error < GIT_SUCCESS) + if (error < 0) return error; tz_start = scan_for_previous_token(line_end - 1, buffer); @@ -301,19 +300,19 @@ int git_signature__parse(git_signature *sig, const char **buffer_out, goto clean_exit; /* No timezone nor date */ time_start = scan_for_previous_token(tz_start - 1, buffer); - if (time_start == NULL || parse_time(&sig->when.time, time_start) < GIT_SUCCESS) { + if (time_start == NULL || parse_time(&sig->when.time, time_start) < 0) { /* The tz_start might point at the time */ parse_time(&sig->when.time, tz_start); goto clean_exit; } - if (parse_timezone_offset(tz_start, &sig->when.offset) < GIT_SUCCESS) { + if (parse_timezone_offset(tz_start, &sig->when.offset) < 0) { sig->when.time = 0; /* Bogus timezone, we reset the time */ } clean_exit: *buffer_out = line_end + 1; - return GIT_SUCCESS; + return 0; } void git_signature__writebuf(git_buf *buf, const char *header, const git_signature *sig) diff --git a/src/status.c b/src/status.c index 106e5005d..ff8535c66 100644 --- a/src/status.c +++ b/src/status.c @@ -15,6 +15,159 @@ #include "repository.h" #include "ignore.h" +#include "git2/diff.h" +#include "diff.h" + +static unsigned int index_delta2status(git_delta_t index_status) +{ + unsigned int st = GIT_STATUS_CURRENT; + + switch (index_status) { + case GIT_DELTA_ADDED: + case GIT_DELTA_COPIED: + case GIT_DELTA_RENAMED: + st = GIT_STATUS_INDEX_NEW; + break; + case GIT_DELTA_DELETED: + st = GIT_STATUS_INDEX_DELETED; + break; + case GIT_DELTA_MODIFIED: + st = GIT_STATUS_INDEX_MODIFIED; + break; + default: + break; + } + + return st; +} + +static unsigned int workdir_delta2status(git_delta_t workdir_status) +{ + unsigned int st = GIT_STATUS_CURRENT; + + switch (workdir_status) { + case GIT_DELTA_ADDED: + case GIT_DELTA_COPIED: + case GIT_DELTA_RENAMED: + case GIT_DELTA_UNTRACKED: + st = GIT_STATUS_WT_NEW; + break; + case GIT_DELTA_DELETED: + st = GIT_STATUS_WT_DELETED; + break; + case GIT_DELTA_MODIFIED: + st = GIT_STATUS_WT_MODIFIED; + break; + case GIT_DELTA_IGNORED: + st = GIT_STATUS_IGNORED; + break; + default: + break; + } + + return st; +} + +int git_status_foreach_ext( + git_repository *repo, + git_status_options *opts, + int (*cb)(const char *, unsigned int, void *), + void *cbdata) +{ + int err = 0, cmp; + git_diff_options diffopt; + git_diff_list *idx2head = NULL, *wd2idx = NULL; + git_tree *head = NULL; + 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; + + assert(show <= GIT_STATUS_SHOW_INDEX_THEN_WORKDIR); + + if ((err = git_repository_head_tree(&head, repo)) < 0) + return err; + + memset(&diffopt, 0, sizeof(diffopt)); + memcpy(&diffopt.pathspec, &opts->pathspec, sizeof(diffopt.pathspec)); + + if ((opts->flags & GIT_STATUS_OPT_INCLUDE_UNTRACKED) != 0) + diffopt.flags = diffopt.flags | GIT_DIFF_INCLUDE_UNTRACKED; + if ((opts->flags & GIT_STATUS_OPT_INCLUDE_IGNORED) != 0) + diffopt.flags = diffopt.flags | GIT_DIFF_INCLUDE_IGNORED; + if ((opts->flags & GIT_STATUS_OPT_INCLUDE_UNMODIFIED) != 0) + diffopt.flags = diffopt.flags | GIT_DIFF_INCLUDE_UNMODIFIED; + if ((opts->flags & GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS) != 0) + diffopt.flags = diffopt.flags | GIT_DIFF_RECURSE_UNTRACKED_DIRS; + /* TODO: support EXCLUDE_SUBMODULES flag */ + + if (show != GIT_STATUS_SHOW_WORKDIR_ONLY && head != NULL && + (err = git_diff_index_to_tree(repo, &diffopt, head, &idx2head)) < 0) + goto cleanup; + + if (show != GIT_STATUS_SHOW_INDEX_ONLY && + (err = git_diff_workdir_to_index(repo, &diffopt, &wd2idx)) < 0) + goto cleanup; + + if (show == GIT_STATUS_SHOW_INDEX_THEN_WORKDIR) { + for (i = 0; !err && i < idx2head->deltas.length; i++) { + i2h = GIT_VECTOR_GET(&idx2head->deltas, i); + err = cb(i2h->old_file.path, index_delta2status(i2h->status), cbdata); + } + git_diff_list_free(idx2head); + idx2head = NULL; + } + + i_max = idx2head ? idx2head->deltas.length : 0; + j_max = wd2idx ? wd2idx->deltas.length : 0; + + for (i = 0, j = 0; !err && (i < i_max || j < j_max); ) { + i2h = idx2head ? GIT_VECTOR_GET(&idx2head->deltas,i) : NULL; + w2i = wd2idx ? GIT_VECTOR_GET(&wd2idx->deltas,j) : NULL; + + cmp = !w2i ? -1 : !i2h ? 1 : strcmp(i2h->old_file.path, w2i->old_file.path); + + if (cmp < 0) { + err = cb(i2h->old_file.path, index_delta2status(i2h->status), cbdata); + i++; + } else if (cmp > 0) { + err = cb(w2i->old_file.path, workdir_delta2status(w2i->status), cbdata); + j++; + } else { + err = cb(i2h->old_file.path, index_delta2status(i2h->status) | + workdir_delta2status(w2i->status), cbdata); + i++; j++; + } + } + +cleanup: + git_tree_free(head); + git_diff_list_free(idx2head); + git_diff_list_free(wd2idx); + return err; +} + +int git_status_foreach( + git_repository *repo, + int (*callback)(const char *, unsigned int, void *), + void *payload) +{ + git_status_options opts; + + memset(&opts, 0, sizeof(opts)); + opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR; + opts.flags = GIT_STATUS_OPT_INCLUDE_IGNORED | + GIT_STATUS_OPT_INCLUDE_UNTRACKED | + GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS; + + return git_status_foreach_ext(repo, &opts, callback, payload); +} + + +/* + * the old stuff + */ + struct status_entry { git_index_time mtime; @@ -76,15 +229,17 @@ static int status_entry_update_from_workdir(struct status_entry *e, const char* { struct stat filest; - if (p_stat(full_path, &filest) < GIT_SUCCESS) - return git__throw(GIT_EOSERR, "Failed to determine status of file '%s'. Can't read file", full_path); + if (p_stat(full_path, &filest) < 0) { + giterr_set(GITERR_OS, "Cannot access file '%s'", full_path); + return GIT_ENOTFOUND; + } if (e->mtime.seconds == (git_time_t)filest.st_mtime) git_oid_cpy(&e->wt_oid, &e->index_oid); else git_odb_hashfile(&e->wt_oid, full_path, GIT_OBJ_BLOB); - return GIT_SUCCESS; + return 0; } static int status_entry_update_flags(struct status_entry *e) @@ -115,7 +270,7 @@ static int status_entry_update_flags(struct status_entry *e) else if (git_oid_cmp(&e->index_oid, &e->wt_oid) != 0) e->status_flags |= GIT_STATUS_WT_MODIFIED; - return GIT_SUCCESS; + return 0; } static int status_entry_is_ignorable(struct status_entry *e) @@ -126,432 +281,17 @@ static int status_entry_is_ignorable(struct status_entry *e) static int status_entry_update_ignore(struct status_entry *e, git_ignores *ignores, const char *path) { - int error, ignored; + int ignored; - if ((error = git_ignore__lookup(ignores, path, &ignored)) == GIT_SUCCESS && - ignored) + if (git_ignore__lookup(ignores, path, &ignored) < 0) + return -1; + + if (ignored) + /* toggle off WT_NEW and on IGNORED */ e->status_flags = (e->status_flags & ~GIT_STATUS_WT_NEW) | GIT_STATUS_IGNORED; - return error; -} - -struct status_st { - git_repository *repo; - git_vector *vector; - git_index *index; - git_tree *tree; - git_ignores *ignores; - - int workdir_path_len; - git_buf head_tree_relative_path; - int head_tree_relative_path_len; - unsigned int tree_position; - unsigned int index_position; - int is_dir:1; -}; - -static int retrieve_head_tree(git_tree **tree_out, git_repository *repo) -{ - git_reference *resolved_head_ref; - git_commit *head_commit = NULL; - git_tree *tree; - int error = GIT_SUCCESS; - - *tree_out = NULL; - - error = git_repository_head(&resolved_head_ref, repo); - /* - * We assume that a situation where HEAD exists but can not be resolved is valid. - * A new repository fits this description for instance. - */ - if (error == GIT_ENOTFOUND) - return GIT_SUCCESS; - if (error < GIT_SUCCESS) - return git__rethrow(error, "HEAD can't be resolved"); - - if ((error = git_commit_lookup(&head_commit, repo, git_reference_oid(resolved_head_ref))) < GIT_SUCCESS) - return git__rethrow(error, "The tip of HEAD can't be retrieved"); - - git_reference_free(resolved_head_ref); - - if ((error = git_commit_tree(&tree, head_commit)) < GIT_SUCCESS) { - error = git__rethrow(error, "The tree of HEAD can't be retrieved"); - goto exit; - } - - *tree_out = tree; - -exit: - git_commit_free(head_commit); - return error; -} - -enum path_type { - GIT_STATUS_PATH_NULL, - GIT_STATUS_PATH_IGNORE, - GIT_STATUS_PATH_FILE, - GIT_STATUS_PATH_FOLDER, -}; - -static int dirent_cb(void *state, git_buf *full_path); -static int alphasorted_futils_direach( - git_buf *path, int (*fn)(void *, git_buf *), void *arg); - -static int process_folder( - struct status_st *st, - const git_tree_entry *tree_entry, - git_buf *full_path, - enum path_type path_type) -{ - git_object *subtree = NULL; - git_tree *pushed_tree = NULL; - int error, pushed_tree_position = 0; - git_otype tree_entry_type = GIT_OBJ_BAD; - - if (tree_entry != NULL) { - tree_entry_type = git_tree_entry_type(tree_entry); - - switch (tree_entry_type) { - case GIT_OBJ_TREE: - error = git_tree_entry_2object(&subtree, ((git_object *)(st->tree))->repo, tree_entry); - pushed_tree = st->tree; - pushed_tree_position = st->tree_position; - st->tree = (git_tree *)subtree; - st->tree_position = 0; - st->head_tree_relative_path_len += 1 + tree_entry->filename_len; /* path + '/' + name */ - break; - - case GIT_OBJ_BLOB: - /* No op */ - break; - - case GIT_OBJ_COMMIT: - /* TODO: proper submodule support */ - break; - - default: - return git__throw(GIT_EINVALIDTYPE, "Unexpected tree entry type"); - } - } - - - if (full_path != NULL && path_type == GIT_STATUS_PATH_FOLDER) { - git_ignores ignores, *old_ignores; - - if ((error = git_ignore__for_path(st->repo, - full_path->ptr + st->workdir_path_len, &ignores)) == GIT_SUCCESS) - { - old_ignores = st->ignores; - st->ignores = &ignores; - - error = alphasorted_futils_direach(full_path, dirent_cb, st); - - git_ignore__free(st->ignores); - st->ignores = old_ignores; - } - } else { - error = dirent_cb(st, NULL); - } - - if (tree_entry_type == GIT_OBJ_TREE) { - git_object_free(subtree); - st->head_tree_relative_path_len -= 1 + tree_entry->filename_len; - st->tree = pushed_tree; - st->tree_position = pushed_tree_position; - st->tree_position++; - } - - return error; -} - -static int store_if_changed(struct status_st *st, struct status_entry *e) -{ - int error; - if ((error = status_entry_update_flags(e)) < GIT_SUCCESS) - return git__throw(error, "Failed to process the file '%s'. It doesn't exist in the workdir, in the HEAD nor in the index", e->path); - - if (status_entry_is_ignorable(e) && - (error = status_entry_update_ignore(e, st->ignores, e->path)) < GIT_SUCCESS) - return error; - - if (e->status_flags == GIT_STATUS_CURRENT) { - git__free(e); - return GIT_SUCCESS; - } - - return git_vector_insert(st->vector, e); -} - -static int determine_status( - struct status_st *st, - int in_head, int in_index, int in_workdir, - const git_tree_entry *tree_entry, - const git_index_entry *index_entry, - git_buf *full_path, - const char *status_path, - enum path_type path_type) -{ - struct status_entry *e; - int error = GIT_SUCCESS; - git_otype tree_entry_type = GIT_OBJ_BAD; - - if (tree_entry != NULL) - tree_entry_type = git_tree_entry_type(tree_entry); - - /* If we're dealing with a directory in the workdir, let's recursively tackle it first */ - if (path_type == GIT_STATUS_PATH_FOLDER) - return process_folder(st, tree_entry, full_path, path_type); - - /* Are we dealing with a file somewhere? */ - if (in_workdir || in_index || (in_head && tree_entry_type == GIT_OBJ_BLOB)) { - e = status_entry_new(NULL, status_path); - - if (in_head && tree_entry_type == GIT_OBJ_BLOB) { - status_entry_update_from_tree_entry(e, tree_entry); - st->tree_position++; - } - - if (in_index) { - status_entry_update_from_index_entry(e, index_entry); - st->index_position++; - } - - if (in_workdir) - if ((error = status_entry_update_from_workdir( - e, full_path->ptr)) < GIT_SUCCESS) - return error; /* The callee has already set the error message */ - - return store_if_changed(st, e); - } - - /* Are we dealing with a subtree? */ - if (tree_entry_type == GIT_OBJ_TREE) { - assert(in_head && !in_index && !in_workdir); - return process_folder(st, tree_entry, full_path, path_type); - } - - /* We're dealing with something else -- most likely a submodule; - * skip it for now */ - if (in_head) - st->tree_position++; - if (in_index) - st->index_position++; - return GIT_SUCCESS; -} - -static int path_type_from(git_buf *full_path, int is_dir) -{ - if (full_path == NULL) - return GIT_STATUS_PATH_NULL; - - if (!is_dir) - return GIT_STATUS_PATH_FILE; - - if (!git__suffixcmp(full_path->ptr, "/" DOT_GIT "/")) - return GIT_STATUS_PATH_IGNORE; - - return GIT_STATUS_PATH_FOLDER; -} - -static const char *status_path(const char *first, const char *second, const char *third) -{ - /* At least one of them can not be NULL */ - assert(first != NULL || second != NULL || third != NULL); - - /* TODO: Fixme. Ensure that when non null, they're all equal */ - if (first != NULL) - return first; - - if (second != NULL) - return second; - - return third; -} - -static int compare(const char *left, const char *right) -{ - if (left == NULL && right == NULL) - return 0; - - if (left == NULL) - return 1; - - if (right == NULL) - return -1; - - return strcmp(left, right); -} - -/* Greatly inspired from JGit IndexTreeWalker */ -/* https://github.com/spearce/jgit/blob/ed47e29c777accfa78c6f50685a5df2b8f5b8ff5/org.spearce.jgit/src/org/spearce/jgit/lib/IndexTreeWalker.java#L88 */ - -static int dirent_cb(void *state, git_buf *a) -{ - const git_tree_entry *m; - const git_index_entry *entry; - enum path_type path_type; - int cmpma, cmpmi, cmpai, error; - const char *pm, *pa, *pi; - const char *m_name, *i_name, *a_name; - struct status_st *st = (struct status_st *)state; - - path_type = path_type_from(a, st->is_dir); - - if (path_type == GIT_STATUS_PATH_IGNORE) - return GIT_SUCCESS; /* Let's skip the ".git" directory */ - - a_name = (path_type != GIT_STATUS_PATH_NULL) ? a->ptr + st->workdir_path_len : NULL; - - while (1) { - if (st->tree == NULL) - m = NULL; - else - m = git_tree_entry_byindex(st->tree, st->tree_position); - - entry = git_index_get(st->index, st->index_position); - - if ((m == NULL) && (a == NULL) && (entry == NULL)) - return GIT_SUCCESS; - - if (m != NULL) { - git_buf_truncate(&st->head_tree_relative_path, - st->head_tree_relative_path_len); - git_buf_joinpath(&st->head_tree_relative_path, - st->head_tree_relative_path.ptr, m->filename); - /* When the tree entry is a folder, append a forward slash to its name */ - if (git_tree_entry_type(m) == GIT_OBJ_TREE) - git_path_to_dir(&st->head_tree_relative_path); - - error = git_buf_lasterror(&st->head_tree_relative_path); - if (error < GIT_SUCCESS) - return git__rethrow(error, "An error occured while " - "determining the status of '%s'", a->ptr); - - m_name = st->head_tree_relative_path.ptr; - } else - m_name = NULL; - - i_name = (entry != NULL) ? entry->path : NULL; - - cmpma = compare(m_name, a_name); - cmpmi = compare(m_name, i_name); - cmpai = compare(a_name, i_name); - - pm = ((cmpma <= 0) && (cmpmi <= 0)) ? m_name : NULL; - pa = ((cmpma >= 0) && (cmpai <= 0)) ? a_name : NULL; - pi = ((cmpmi >= 0) && (cmpai >= 0)) ? i_name : NULL; - - if ((error = determine_status(st, pm != NULL, pi != NULL, pa != NULL, - m, entry, a, status_path(pm, pi, pa), path_type)) < GIT_SUCCESS) - return git__rethrow(error, "An error occured while determining the status of '%s'", a->ptr); - - if ((pa != NULL) || (path_type == GIT_STATUS_PATH_FOLDER)) - return GIT_SUCCESS; - } -} - -static int status_cmp(const void *a, const void *b) -{ - const struct status_entry *entry_a = (const struct status_entry *)(a); - const struct status_entry *entry_b = (const struct status_entry *)(b); - - return strcmp(entry_a->path, entry_b->path); -} - -#define DEFAULT_SIZE 16 - -int git_status_foreach( - git_repository *repo, - int (*callback)(const char *, unsigned int, void *), - void *payload) -{ - git_vector entries; - git_ignores ignores; - git_index *index = NULL; - git_buf temp_path = GIT_BUF_INIT; - struct status_st dirent_st = {0}; - int error = GIT_SUCCESS; - unsigned int i; - git_tree *tree; - struct status_entry *e; - const char *workdir; - - if ((workdir = git_repository_workdir(repo)) == NULL) - return git__throw(GIT_ERROR, - "Cannot retrieve status on a bare repository"); - - if ((error = git_repository_index__weakptr(&index, repo)) < GIT_SUCCESS) { - return git__rethrow(error, - "Failed to determine statuses. Index can't be opened"); - } - - if ((error = retrieve_head_tree(&tree, repo)) < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to determine statuses"); - goto exit; - } - - git_vector_init(&entries, DEFAULT_SIZE, status_cmp); - - dirent_st.repo = repo; - dirent_st.vector = &entries; - dirent_st.index = index; - dirent_st.tree = tree; - dirent_st.ignores = &ignores; - dirent_st.workdir_path_len = strlen(workdir); - git_buf_init(&dirent_st.head_tree_relative_path, 0); - dirent_st.head_tree_relative_path_len = 0; - dirent_st.tree_position = 0; - dirent_st.index_position = 0; - dirent_st.is_dir = 1; - - if (git_path_isdir(workdir)) { - error = git__throw(GIT_EINVALIDPATH, - "Failed to determine status of file '%s'. " - "The given path doesn't lead to a folder", workdir); - goto exit; - } - - git_buf_sets(&temp_path, workdir); - - error = git_ignore__for_path(repo, "", dirent_st.ignores); - if (error < GIT_SUCCESS) - goto exit; - - error = alphasorted_futils_direach( - &temp_path, dirent_cb, &dirent_st); - - if (error < GIT_SUCCESS) - error = git__rethrow(error, - "Failed to determine statuses. " - "An error occured while processing the working directory"); - - if ((error == GIT_SUCCESS) && - ((error = dirent_cb(&dirent_st, NULL)) < GIT_SUCCESS)) - error = git__rethrow(error, - "Failed to determine statuses. " - "An error occured while post-processing the HEAD tree and the index"); - - for (i = 0; i < entries.length; ++i) { - e = (struct status_entry *)git_vector_get(&entries, i); - - if (error == GIT_SUCCESS) { - error = callback(e->path, e->status_flags, payload); - if (error < GIT_SUCCESS) - error = git__rethrow(error, - "Failed to determine statuses. User callback failed"); - } - - git__free(e); - } - -exit: - git_buf_free(&dirent_st.head_tree_relative_path); - git_buf_free(&temp_path); - git_vector_free(&entries); - git_ignore__free(&ignores); - git_tree_free(tree); - return error; + return 0; } static int recurse_tree_entry(git_tree *tree, struct status_entry *e, const char *path) @@ -559,236 +299,117 @@ static int recurse_tree_entry(git_tree *tree, struct status_entry *e, const char char *dir_sep; const git_tree_entry *tree_entry; git_tree *subtree; - int error = GIT_SUCCESS; + int error; dir_sep = strchr(path, '/'); if (!dir_sep) { - tree_entry = git_tree_entry_byname(tree, path); - if (tree_entry == NULL) - return GIT_SUCCESS; /* The leaf doesn't exist in the tree*/ - - status_entry_update_from_tree_entry(e, tree_entry); - return GIT_SUCCESS; + if ((tree_entry = git_tree_entry_byname(tree, path)) != NULL) + /* The leaf exists in the tree*/ + status_entry_update_from_tree_entry(e, tree_entry); + return 0; } /* Retrieve subtree name */ *dir_sep = '\0'; - tree_entry = git_tree_entry_byname(tree, path); - if (tree_entry == NULL) - return GIT_SUCCESS; /* The subtree doesn't exist in the tree*/ + if ((tree_entry = git_tree_entry_byname(tree, path)) == NULL) + return 0; /* The subtree doesn't exist in the tree*/ *dir_sep = '/'; /* Retreive subtree */ - if ((error = git_tree_lookup(&subtree, tree->object.repo, &tree_entry->oid)) < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Can't find tree object '%s'", tree_entry->filename); + error = git_tree_lookup(&subtree, tree->object.repo, &tree_entry->oid); + if (!error) { + error = recurse_tree_entry(subtree, e, dir_sep+1); + git_tree_free(subtree); + } - error = recurse_tree_entry(subtree, e, dir_sep+1); - git_tree_free(subtree); return error; } -int git_status_file(unsigned int *status_flags, git_repository *repo, const char *path) +int git_status_file( + unsigned int *status_flags, git_repository *repo, const char *path) { struct status_entry *e; git_index *index = NULL; git_buf temp_path = GIT_BUF_INIT; - int error = GIT_SUCCESS; + int error = 0; git_tree *tree = NULL; const char *workdir; assert(status_flags && repo && path); - if ((workdir = git_repository_workdir(repo)) == NULL) - return git__throw(GIT_ERROR, - "Cannot retrieve status on a bare repository"); + if ((workdir = git_repository_workdir(repo)) == NULL) { + giterr_set(GITERR_OS, "Cannot get file status from bare repo"); + return GIT_ENOTFOUND; + } - if ((error = git_buf_joinpath(&temp_path, workdir, path)) < GIT_SUCCESS) - return git__rethrow(error, - "Failed to determine status of file '%s'", path); + if (git_buf_joinpath(&temp_path, workdir, path) < 0) + return -1; - if (git_path_isdir(temp_path.ptr) == GIT_SUCCESS) { + if (git_path_isdir(temp_path.ptr)) { + giterr_set(GITERR_OS, "Cannot get file status for directory '%s'", temp_path.ptr); git_buf_free(&temp_path); - return git__throw(GIT_EINVALIDPATH, - "Failed to determine status of file '%s'. " - "Given path leads to a folder, not a file", path); + return GIT_ENOTFOUND; } e = status_entry_new(NULL, path); - if (e == NULL) { - git_buf_free(&temp_path); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(e); /* Find file in Workdir */ - if (git_path_exists(temp_path.ptr) == GIT_SUCCESS) { - if ((error = status_entry_update_from_workdir(e, temp_path.ptr)) < GIT_SUCCESS) - goto cleanup; /* The callee has already set the error message */ - } + if (git_path_exists(temp_path.ptr) == true && + (error = status_entry_update_from_workdir(e, temp_path.ptr)) < 0) + goto cleanup; /* Find file in Index */ - if ((error = git_repository_index__weakptr(&index, repo)) < GIT_SUCCESS) { - git__rethrow(error, - "Failed to determine status of file '%s'." - "Index can't be opened", path); + if ((error = git_repository_index__weakptr(&index, repo)) < 0) goto cleanup; - } - status_entry_update_from_index(e, index); - if ((error = retrieve_head_tree(&tree, repo)) < GIT_SUCCESS) { - git__rethrow(error, - "Failed to determine status of file '%s'", path); + /* Try to find file in HEAD */ + if ((error = git_repository_head_tree(&tree, repo)) < 0) goto cleanup; - } - /* If the repository is not empty, try and locate the file in HEAD */ if (tree != NULL) { - if ((error = git_buf_sets(&temp_path, path)) < GIT_SUCCESS) { - git__rethrow(error, - "Failed to determine status of file '%s'", path); + if ((error = git_buf_sets(&temp_path, path)) < 0 || + (error = recurse_tree_entry(tree, e, temp_path.ptr)) < 0) goto cleanup; - } - - error = recurse_tree_entry(tree, e, temp_path.ptr); - if (error < GIT_SUCCESS) { - git__rethrow(error, - "Failed to determine status of file '%s'. " - "An error occured while processing the tree", path); - goto cleanup; - } } /* Determine status */ - if ((error = status_entry_update_flags(e)) < GIT_SUCCESS) { - git__throw(error, "Nonexistent file"); - goto cleanup; - } + if ((error = status_entry_update_flags(e)) < 0) + giterr_set(GITERR_OS, "Cannot find file '%s' to determine status", path); - if (status_entry_is_ignorable(e)) { + if (!error && status_entry_is_ignorable(e)) { git_ignores ignores; - if ((error = git_ignore__for_path(repo, path, &ignores)) == GIT_SUCCESS) + if ((error = git_ignore__for_path(repo, path, &ignores)) == 0) error = status_entry_update_ignore(e, &ignores, path); git_ignore__free(&ignores); - - if (error < GIT_SUCCESS) - goto cleanup; } - *status_flags = e->status_flags; + if (!error) + *status_flags = e->status_flags; cleanup: git_buf_free(&temp_path); git_tree_free(tree); git__free(e); + return error; } -/* - * git_path_direach is not supposed to return entries in an ordered manner. - * alphasorted_futils_direach wraps git_path_direach and invokes the callback - * function by passing it alphabeticcally sorted paths parameters. - * - */ - -static char *alphasorted_dirent_info_new(const git_buf *path) -{ - char *di = git__malloc(path->size + 2); - if (!di) - return di; - - git_buf_copy_cstr(di, path->size + 1, path); - - if (git_path_isdir(path->ptr) == GIT_SUCCESS) { - /* - * Append a forward slash to the name to force folders - * to be ordered in a similar way than in a tree - * - * The file "subdir" should appear before the file "subdir.txt" - * The folder "subdir" should appear after the file "subdir.txt" - */ - di[path->size] = '/'; - di[path->size + 1] = '\0'; - } - - return di; -} - -static int alphasorted_dirent_cb(void *state, git_buf *full_path) -{ - char *entry; - git_vector *entry_names; - - entry_names = (git_vector *)state; - entry = alphasorted_dirent_info_new(full_path); - - if (entry == NULL) - return GIT_ENOMEM; - - if (git_vector_insert(entry_names, entry) < GIT_SUCCESS) { - git__free(entry); - return GIT_ENOMEM; - } - - return GIT_SUCCESS; -} - -static int alphasorted_futils_direach( - git_buf *path, - int (*fn)(void *, git_buf *), - void *arg) -{ - char *entry; - git_vector entry_names; - unsigned int idx; - int error = GIT_SUCCESS; - git_buf entry_path = GIT_BUF_INIT; - - if (git_vector_init(&entry_names, 16, git__strcmp_cb) < GIT_SUCCESS) - return GIT_ENOMEM; - - error = git_path_direach(path, alphasorted_dirent_cb, &entry_names); - - git_vector_sort(&entry_names); - - for (idx = 0; idx < entry_names.length; ++idx) { - entry = (char *)git_vector_get(&entry_names, idx); - - /* We have to walk the entire vector even if there was an error, - * in order to free up memory, but we stop making callbacks after - * an error. - */ - if (error == GIT_SUCCESS) - error = git_buf_sets(&entry_path, entry); - - if (error == GIT_SUCCESS) { - ((struct status_st *)arg)->is_dir = - (entry[entry_path.size - 1] == '/'); - error = fn(arg, &entry_path); - } - - git__free(entry); - } - - git_buf_free(&entry_path); - git_vector_free(&entry_names); - return error; -} - - int git_status_should_ignore(git_repository *repo, const char *path, int *ignored) { int error; git_ignores ignores; - if ((error = git_ignore__for_path(repo, path, &ignores)) == GIT_SUCCESS) - error = git_ignore__lookup(&ignores, path, ignored); + if (git_ignore__for_path(repo, path, &ignores) < 0) + return -1; + error = git_ignore__lookup(&ignores, path, ignored); git_ignore__free(&ignores); - return error; } diff --git a/src/strmap.h b/src/strmap.h new file mode 100644 index 000000000..da5ca0dba --- /dev/null +++ b/src/strmap.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 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_strmap_h__ +#define INCLUDE_strmap_h__ + +#include "common.h" + +#define kmalloc git__malloc +#define kcalloc git__calloc +#define krealloc git__realloc +#define kfree git__free +#include "khash.h" + +__KHASH_TYPE(str, const char *, void *); +typedef khash_t(str) git_strmap; + +#define GIT__USE_STRMAP \ + __KHASH_IMPL(str, static inline, const char *, void *, 1, kh_str_hash_func, kh_str_hash_equal) + +#define git_strmap_alloc() kh_init(str) +#define git_strmap_free(h) kh_destroy(str, h), h = NULL +#define git_strmap_clear(h) kh_clear(str, h) + +#define git_strmap_num_entries(h) kh_size(h) + +#define git_strmap_lookup_index(h, k) kh_get(str, h, k) +#define git_strmap_valid_index(h, idx) (idx != kh_end(h)) + +#define git_strmap_exists(h, k) (kh_get(str, h, k) != kh_end(h)) + +#define git_strmap_value_at(h, idx) kh_val(h, idx) +#define git_strmap_set_value_at(h, idx, v) kh_val(h, idx) = v +#define git_strmap_delete_at(h, idx) kh_del(str, h, idx) + +#define git_strmap_insert(h, key, val, rval) do { \ + khiter_t __pos = kh_put(str, h, key, &rval); \ + if (rval >= 0) { \ + if (rval == 0) kh_key(h, __pos) = key; \ + kh_val(h, __pos) = val; \ + } } while (0) + +#define git_strmap_insert2(h, key, val, oldv, rval) do { \ + khiter_t __pos = kh_put(str, h, key, &rval); \ + if (rval >= 0) { \ + if (rval == 0) { \ + oldv = kh_val(h, __pos); \ + kh_key(h, __pos) = key; \ + } else { oldv = NULL; } \ + kh_val(h, __pos) = val; \ + } } while (0) + +#define git_strmap_delete(h, key) do { \ + khiter_t __pos = git_strmap_lookup_index(h, key); \ + if (git_strmap_valid_index(h, __pos)) \ + git_strmap_delete_at(h, __pos); } while (0) + +#define git_strmap_foreach kh_foreach +#define git_strmap_foreach_value kh_foreach_value + +#endif diff --git a/src/submodule.c b/src/submodule.c new file mode 100644 index 000000000..1b5b59f45 --- /dev/null +++ b/src/submodule.c @@ -0,0 +1,384 @@ +/* + * Copyright (C) 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. + */ + +#include "common.h" +#include "git2/config.h" +#include "git2/types.h" +#include "git2/repository.h" +#include "git2/index.h" +#include "git2/submodule.h" +#include "buffer.h" +#include "vector.h" +#include "posix.h" +#include "config_file.h" +#include "config.h" +#include "repository.h" + +static git_cvar_map _sm_update_map[] = { + {GIT_CVAR_STRING, "checkout", GIT_SUBMODULE_UPDATE_CHECKOUT}, + {GIT_CVAR_STRING, "rebase", GIT_SUBMODULE_UPDATE_REBASE}, + {GIT_CVAR_STRING, "merge", GIT_SUBMODULE_UPDATE_MERGE} +}; + +static git_cvar_map _sm_ignore_map[] = { + {GIT_CVAR_STRING, "all", GIT_SUBMODULE_IGNORE_ALL}, + {GIT_CVAR_STRING, "dirty", GIT_SUBMODULE_IGNORE_DIRTY}, + {GIT_CVAR_STRING, "untracked", GIT_SUBMODULE_IGNORE_UNTRACKED}, + {GIT_CVAR_STRING, "none", GIT_SUBMODULE_IGNORE_NONE} +}; + +static inline khint_t str_hash_no_trailing_slash(const char *s) +{ + khint_t h; + + for (h = 0; *s; ++s) + if (s[1] || *s != '/') + h = (h << 5) - h + *s; + + return h; +} + +static inline int str_equal_no_trailing_slash(const char *a, const char *b) +{ + size_t alen = a ? strlen(a) : 0; + size_t blen = b ? strlen(b) : 0; + + if (alen && a[alen] == '/') + alen--; + if (blen && b[blen] == '/') + blen--; + + return (alen == blen && strncmp(a, b, alen) == 0); +} + +__KHASH_IMPL(str, static inline, const char *, void *, 1, str_hash_no_trailing_slash, str_equal_no_trailing_slash); + +static git_submodule *submodule_alloc(const char *name) +{ + git_submodule *sm = git__calloc(1, sizeof(git_submodule)); + if (sm == NULL) + return sm; + + sm->path = sm->name = git__strdup(name); + if (!sm->name) { + git__free(sm); + return NULL; + } + + return sm; +} + +static void submodule_release(git_submodule *sm, int decr) +{ + if (!sm) + return; + + sm->refcount -= decr; + + if (sm->refcount == 0) { + if (sm->name != sm->path) + git__free(sm->path); + git__free(sm->name); + git__free(sm->url); + git__free(sm); + } +} + +static int submodule_from_entry( + git_strmap *smcfg, git_index_entry *entry) +{ + git_submodule *sm; + void *old_sm; + khiter_t pos; + int error; + + pos = git_strmap_lookup_index(smcfg, entry->path); + + if (git_strmap_valid_index(smcfg, pos)) + sm = git_strmap_value_at(smcfg, pos); + else + sm = submodule_alloc(entry->path); + + git_oid_cpy(&sm->oid, &entry->oid); + + if (strcmp(sm->path, entry->path) != 0) { + if (sm->path != sm->name) { + git__free(sm->path); + sm->path = sm->name; + } + sm->path = git__strdup(entry->path); + if (!sm->path) + goto fail; + } + + git_strmap_insert2(smcfg, sm->path, sm, old_sm, error); + if (error < 0) + goto fail; + sm->refcount++; + + if (old_sm && ((git_submodule *)old_sm) != sm) { + /* TODO: log warning about multiple entrys for same submodule path */ + submodule_release(old_sm, 1); + } + + return 0; + +fail: + submodule_release(sm, 0); + return -1; +} + +static int submodule_from_config( + const char *key, const char *value, void *data) +{ + git_strmap *smcfg = data; + const char *namestart; + const char *property; + git_buf name = GIT_BUF_INIT; + git_submodule *sm; + void *old_sm = NULL; + bool is_path; + khiter_t pos; + int error; + + if (git__prefixcmp(key, "submodule.") != 0) + return 0; + + namestart = key + strlen("submodule."); + property = strrchr(namestart, '.'); + if (property == NULL) + return 0; + property++; + is_path = (strcmp(property, "path") == 0); + + if (git_buf_set(&name, namestart, property - namestart - 1) < 0) + return -1; + + pos = git_strmap_lookup_index(smcfg, name.ptr); + if (!git_strmap_valid_index(smcfg, pos) && is_path) + pos = git_strmap_lookup_index(smcfg, value); + if (!git_strmap_valid_index(smcfg, pos)) + sm = submodule_alloc(name.ptr); + else + sm = git_strmap_value_at(smcfg, pos); + if (!sm) + goto fail; + + if (strcmp(sm->name, name.ptr) != 0) { + assert(sm->path == sm->name); + sm->name = git_buf_detach(&name); + + git_strmap_insert2(smcfg, sm->name, sm, old_sm, error); + if (error < 0) + goto fail; + sm->refcount++; + } + else if (is_path && strcmp(sm->path, value) != 0) { + assert(sm->path == sm->name); + sm->path = git__strdup(value); + if (sm->path == NULL) + goto fail; + + git_strmap_insert2(smcfg, sm->path, sm, old_sm, error); + if (error < 0) + goto fail; + sm->refcount++; + } + git_buf_free(&name); + + if (old_sm && ((git_submodule *)old_sm) != sm) { + /* TODO: log warning about multiple submodules with same path */ + submodule_release(old_sm, 1); + } + + if (is_path) + return 0; + + /* copy other properties into submodule entry */ + if (strcmp(property, "url") == 0) { + if (sm->url) { + git__free(sm->url); + sm->url = NULL; + } + if ((sm->url = git__strdup(value)) == NULL) + goto fail; + } + else if (strcmp(property, "update") == 0) { + int val; + if (git_config_lookup_map_value( + _sm_update_map, ARRAY_SIZE(_sm_update_map), value, &val) < 0) { + giterr_set(GITERR_INVALID, + "Invalid value for submodule update property: '%s'", value); + goto fail; + } + sm->update = (git_submodule_update_t)val; + } + else if (strcmp(property, "fetchRecurseSubmodules") == 0) { + if (git_config_parse_bool(&sm->fetch_recurse, value) < 0) + goto fail; + } + else if (strcmp(property, "ignore") == 0) { + int val; + if (git_config_lookup_map_value( + _sm_ignore_map, ARRAY_SIZE(_sm_ignore_map), value, &val) < 0) { + giterr_set(GITERR_INVALID, + "Invalid value for submodule ignore property: '%s'", value); + goto fail; + } + sm->ignore = (git_submodule_ignore_t)val; + } + /* ignore other unknown submodule properties */ + + return 0; + +fail: + submodule_release(sm, 0); + git_buf_free(&name); + return -1; +} + +static int load_submodule_config(git_repository *repo) +{ + int error; + git_index *index; + unsigned int i, max_i; + git_oid gitmodules_oid; + git_strmap *smcfg; + struct git_config_file *mods = NULL; + + if (repo->submodules) + return 0; + + /* submodule data is kept in a hashtable with each submodule stored + * under both its name and its path. These are usually the same, but + * that is not guaranteed. + */ + smcfg = git_strmap_alloc(); + GITERR_CHECK_ALLOC(smcfg); + + /* scan index for gitmodules (and .gitmodules entry) */ + if ((error = git_repository_index__weakptr(&index, repo)) < 0) + goto cleanup; + memset(&gitmodules_oid, 0, sizeof(gitmodules_oid)); + max_i = git_index_entrycount(index); + + for (i = 0; i < max_i; i++) { + git_index_entry *entry = git_index_get(index, i); + if (S_ISGITLINK(entry->mode)) { + if ((error = submodule_from_entry(smcfg, entry)) < 0) + goto cleanup; + } + else if (strcmp(entry->path, ".gitmodules") == 0) + git_oid_cpy(&gitmodules_oid, &entry->oid); + } + + /* load .gitmodules from workdir if it exists */ + if (git_repository_workdir(repo) != NULL) { + /* look in workdir for .gitmodules */ + git_buf path = GIT_BUF_INIT; + if (!git_buf_joinpath( + &path, git_repository_workdir(repo), ".gitmodules") && + git_path_isfile(path.ptr)) + { + if (!(error = git_config_file__ondisk(&mods, path.ptr))) + error = git_config_file_open(mods); + } + git_buf_free(&path); + } + + /* load .gitmodules from object cache if not in workdir */ + if (!error && mods == NULL && !git_oid_iszero(&gitmodules_oid)) { + /* TODO: is it worth loading gitmodules from object cache? */ + } + + /* process .gitmodules info */ + if (!error && mods != NULL) + error = git_config_file_foreach(mods, submodule_from_config, smcfg); + + /* store submodule config in repo */ + if (!error) + repo->submodules = smcfg; + +cleanup: + if (mods != NULL) + git_config_file_free(mods); + if (error) + git_strmap_free(smcfg); + return error; +} + +void git_submodule_config_free(git_repository *repo) +{ + git_strmap *smcfg = repo->submodules; + git_submodule *sm; + + repo->submodules = NULL; + + if (smcfg == NULL) + return; + + git_strmap_foreach_value(smcfg, sm, { + submodule_release(sm,1); + }); + git_strmap_free(smcfg); +} + +static int submodule_cmp(const void *a, const void *b) +{ + return strcmp(((git_submodule *)a)->name, ((git_submodule *)b)->name); +} + +int git_submodule_foreach( + git_repository *repo, + int (*callback)(const char *name, void *payload), + void *payload) +{ + int error; + git_submodule *sm; + git_vector seen = GIT_VECTOR_INIT; + seen._cmp = submodule_cmp; + + if ((error = load_submodule_config(repo)) < 0) + return error; + + git_strmap_foreach_value(repo->submodules, sm, { + /* usually the following will not come into play */ + if (sm->refcount > 1) { + if (git_vector_bsearch(&seen, sm) != GIT_ENOTFOUND) + continue; + if ((error = git_vector_insert(&seen, sm)) < 0) + break; + } + + if ((error = callback(sm->name, payload)) < 0) + break; + }); + + git_vector_free(&seen); + + return error; +} + +int git_submodule_lookup( + git_submodule **sm_ptr, /* NULL allowed if user only wants to test */ + git_repository *repo, + const char *name) /* trailing slash is allowed */ +{ + khiter_t pos; + + if (load_submodule_config(repo) < 0) + return -1; + + pos = git_strmap_lookup_index(repo->submodules, name); + if (!git_strmap_valid_index(repo->submodules, pos)) + return GIT_ENOTFOUND; + + if (sm_ptr) + *sm_ptr = git_strmap_value_at(repo->submodules, pos); + + return 0; +} diff --git a/src/tag.c b/src/tag.c index 6076eb6e8..aa549fdd0 100644 --- a/src/tag.c +++ b/src/tag.c @@ -61,26 +61,32 @@ const char *git_tag_message(git_tag *t) return t->message; } +static int tag_error(const char *str) +{ + giterr_set(GITERR_TAG, "Failed to parse tag. %s", str); + return -1; +} + int git_tag__parse_buffer(git_tag *tag, const char *buffer, size_t length) { static const char *tag_types[] = { NULL, "commit\n", "tree\n", "blob\n", "tag\n" }; - unsigned int i, text_len; + unsigned int i; + size_t text_len; char *search; - int error; const char *buffer_end = buffer + length; - if ((error = git_oid__parse(&tag->target, &buffer, buffer_end, "object ")) < 0) - return git__rethrow(error, "Failed to parse tag. Object field invalid"); + if (git_oid__parse(&tag->target, &buffer, buffer_end, "object ") < 0) + return tag_error("Object field invalid"); if (buffer + 5 >= buffer_end) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tag. Object too short"); + return tag_error("Object too short"); if (memcmp(buffer, "type ", 5) != 0) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tag. Type field not found"); + return tag_error("Type field not found"); buffer += 5; tag->type = GIT_OBJ_BAD; @@ -89,7 +95,7 @@ int git_tag__parse_buffer(git_tag *tag, const char *buffer, size_t length) size_t type_length = strlen(tag_types[i]); if (buffer + type_length >= buffer_end) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tag. Object too short"); + return tag_error("Object too short"); if (memcmp(buffer, tag_types[i], type_length) == 0) { tag->type = i; @@ -99,25 +105,24 @@ int git_tag__parse_buffer(git_tag *tag, const char *buffer, size_t length) } if (tag->type == GIT_OBJ_BAD) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tag. Invalid object type"); + return tag_error("Invalid object type"); if (buffer + 4 >= buffer_end) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tag. Object too short"); + return tag_error("Object too short"); if (memcmp(buffer, "tag ", 4) != 0) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tag. Tag field not found"); + return tag_error("Tag field not found"); buffer += 4; search = memchr(buffer, '\n', buffer_end - buffer); if (search == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tag. Object too short"); + return tag_error("Object too short"); text_len = search - buffer; tag->tag_name = git__malloc(text_len + 1); - if (tag->tag_name == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(tag->tag_name); memcpy(tag->tag_name, buffer, text_len); tag->tag_name[text_len] = '\0'; @@ -127,27 +132,24 @@ int git_tag__parse_buffer(git_tag *tag, const char *buffer, size_t length) tag->tagger = NULL; if (*buffer != '\n') { tag->tagger = git__malloc(sizeof(git_signature)); - if (tag->tagger == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(tag->tagger); - if ((error = git_signature__parse(tag->tagger, &buffer, buffer_end, "tagger ", '\n') != 0)) { - return git__rethrow(error, "Failed to parse tag"); - } + if (git_signature__parse(tag->tagger, &buffer, buffer_end, "tagger ", '\n') < 0) + return -1; } if( *buffer != '\n' ) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tag. No new line before message"); + return tag_error("No new line before message"); text_len = buffer_end - ++buffer; tag->message = git__malloc(text_len + 1); - if (tag->message == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(tag->message); memcpy(tag->message, buffer, text_len); tag->message[text_len] = '\0'; - return GIT_SUCCESS; + return 0; } static int retrieve_tag_reference( @@ -161,17 +163,28 @@ static int retrieve_tag_reference( *tag_reference_out = NULL; - error = git_buf_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to retrieve tag reference"); + if (git_buf_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name) < 0) + return -1; error = git_reference_lookup(&tag_ref, repo, ref_name_out->ptr); if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to retrieve tag reference"); + return error; /* Be it not foundo or corrupted */ *tag_reference_out = tag_ref; - return GIT_SUCCESS; + return 0; +} + +static int retrieve_tag_reference_oid( + git_oid *oid, + git_buf *ref_name_out, + git_repository *repo, + const char *tag_name) +{ + if (git_buf_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name) < 0) + return -1; + + return git_reference_name_to_oid(oid, repo, ref_name_out->ptr); } static int write_tag_annotation( @@ -182,7 +195,6 @@ static int write_tag_annotation( const git_signature *tagger, const char *message) { - int error = GIT_SUCCESS; git_buf tag = GIT_BUF_INIT; git_odb *odb; @@ -193,25 +205,20 @@ static int write_tag_annotation( git_buf_putc(&tag, '\n'); git_buf_puts(&tag, message); - error = git_buf_lasterror(&tag); - if (error < GIT_SUCCESS) { - git_buf_free(&tag); - return git__rethrow(error, "Not enough memory to build the tag data"); - } + if (git_buf_oom(&tag)) + goto on_error; - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) { - git_buf_free(&tag); - return error; - } + if (git_repository_odb__weakptr(&odb, repo) < 0) + goto on_error; + + if (git_odb_write(oid, odb, tag.ptr, tag.size, GIT_OBJ_TAG) < 0) + goto on_error; - error = git_odb_write(oid, odb, tag.ptr, tag.size, GIT_OBJ_TAG); git_buf_free(&tag); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create tag annotation"); - - return error; + return 0; +on_error: + git_buf_free(&tag); + return -1; } static int git_tag_create__internal( @@ -227,51 +234,38 @@ static int git_tag_create__internal( git_reference *new_ref = NULL; git_buf ref_name = GIT_BUF_INIT; - int error, should_update_ref = 0; - const char *errmsg = "Failed to create tag"; + int error; assert(repo && tag_name && target); assert(!create_tag_annotation || (tagger && message)); - if (git_object_owner(target) != repo) - return git__throw(GIT_EINVALIDARGS, - "The given target does not belong to this repository"); + if (git_object_owner(target) != repo) { + giterr_set(GITERR_INVALID, "The given target does not belong to this repository"); + return -1; + } - error = retrieve_tag_reference(&new_ref, &ref_name, repo, tag_name); + error = retrieve_tag_reference_oid(oid, &ref_name, repo, tag_name); if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) - goto cleanup; + return -1; /** Ensure the tag name doesn't conflict with an already existing * reference unless overwriting has explictly been requested **/ - if (new_ref != NULL) { - if (!allow_ref_overwrite) { - git_oid_cpy(oid, git_reference_oid(new_ref)); - error = GIT_EEXISTS; - errmsg = "Tag already exists"; - goto cleanup; - } else { - should_update_ref = 1; - } + if (error == 0 && !allow_ref_overwrite) { + git_buf_free(&ref_name); + giterr_set(GITERR_TAG, "Tag already exists"); + return GIT_EEXISTS; } if (create_tag_annotation) { - if ((error = write_tag_annotation(oid, repo, tag_name, target, tagger, message)) < GIT_SUCCESS) - goto cleanup; + if (write_tag_annotation(oid, repo, tag_name, target, tagger, message) < 0) + return -1; } else git_oid_cpy(oid, git_object_id(target)); - if (!should_update_ref) - error = git_reference_create_oid(&new_ref, repo, ref_name.ptr, oid, 0); - else - error = git_reference_set_oid(new_ref, oid); + error = git_reference_create_oid(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite); -cleanup: git_reference_free(new_ref); git_buf_free(&ref_name); - - if (error < GIT_SUCCESS) - git__rethrow(error, "%s", errmsg); - return error; } @@ -300,8 +294,7 @@ int git_tag_create_lightweight( int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *buffer, int allow_ref_overwrite) { git_tag tag; - int error, should_update_ref = 0; - const char *errmsg = "Failed to create tag"; + int error; git_odb *odb; git_odb_stream *stream; git_odb_object *target_obj; @@ -313,71 +306,66 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu memset(&tag, 0, sizeof(tag)); - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) - return error; + if (git_repository_odb__weakptr(&odb, repo) < 0) + return -1; /* validate the buffer */ - if ((error = git_tag__parse_buffer(&tag, buffer, strlen(buffer))) < GIT_SUCCESS) - goto cleanup; + if (git_tag__parse_buffer(&tag, buffer, strlen(buffer)) < 0) + return -1; /* validate the target */ - if ((error = git_odb_read(&target_obj, odb, &tag.target)) < GIT_SUCCESS) - goto cleanup; + if (git_odb_read(&target_obj, odb, &tag.target) < 0) + goto on_error; if (tag.type != target_obj->raw.type) { - error = GIT_EINVALIDTYPE; - errmsg = "The type for the given target is invalid"; - goto cleanup; + giterr_set(GITERR_TAG, "The type for the given target is invalid"); + goto on_error; } - git_odb_object_free(target_obj); - - error = retrieve_tag_reference(&new_ref, &ref_name, repo, tag.tag_name); + error = retrieve_tag_reference_oid(oid, &ref_name, repo, tag.tag_name); if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) - goto cleanup; + goto on_error; + + /* We don't need these objects after this */ + git_signature_free(tag.tagger); + git__free(tag.tag_name); + git__free(tag.message); + git_odb_object_free(target_obj); /** Ensure the tag name doesn't conflict with an already existing * reference unless overwriting has explictly been requested **/ - if (new_ref != NULL) { - if (!allow_ref_overwrite) { - git_oid_cpy(oid, git_reference_oid(new_ref)); - error = GIT_EEXISTS; - errmsg = "Tag already exists"; - goto cleanup; - } else { - should_update_ref = 1; - } + if (error == 0 && !allow_ref_overwrite) { + giterr_set(GITERR_TAG, "Tag already exists"); + return GIT_EEXISTS; } /* write the buffer */ - if ((error = git_odb_open_wstream(&stream, odb, strlen(buffer), GIT_OBJ_TAG)) < GIT_SUCCESS) - goto cleanup; + if (git_odb_open_wstream(&stream, odb, strlen(buffer), GIT_OBJ_TAG) < 0) + return -1; stream->write(stream, buffer, strlen(buffer)); error = stream->finalize_write(oid, stream); stream->free(stream); - if (error < GIT_SUCCESS) - goto cleanup; + if (error < 0) { + git_buf_free(&ref_name); + return -1; + } - if (!should_update_ref) - error = git_reference_create_oid(&new_ref, repo, ref_name.ptr, oid, 0); - else - error = git_reference_set_oid(new_ref, oid); + error = git_reference_create_oid(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite); -cleanup: git_reference_free(new_ref); + git_buf_free(&ref_name); + + return error; + +on_error: git_signature_free(tag.tagger); git__free(tag.tag_name); git__free(tag.message); - git_buf_free(&ref_name); - - if (error < GIT_SUCCESS) - git__rethrow(error, "%s", errmsg); - - return error; + git_odb_object_free(target_obj); + return -1; } int git_tag_delete(git_repository *repo, const char *tag_name) @@ -390,8 +378,8 @@ int git_tag_delete(git_repository *repo, const char *tag_name) git_buf_free(&ref_name); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to delete tag"); + if (error < 0) + return -1; return git_reference_delete(tag_ref); } @@ -414,13 +402,13 @@ static int tag_list_cb(const char *tag_name, void *payload) tag_filter_data *filter; if (git__prefixcmp(tag_name, GIT_REFS_TAGS_DIR) != 0) - return GIT_SUCCESS; + return 0; filter = (tag_filter_data *)payload; if (!*filter->pattern || p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == GIT_SUCCESS) return git_vector_insert(filter->taglist, git__strdup(tag_name)); - return GIT_SUCCESS; + return 0; } int git_tag_list_match(git_strarray *tag_names, const char *pattern, git_repository *repo) @@ -432,23 +420,43 @@ int git_tag_list_match(git_strarray *tag_names, const char *pattern, git_reposit assert(tag_names && repo && pattern); if (git_vector_init(&taglist, 8, NULL) < GIT_SUCCESS) - return GIT_ENOMEM; + return -1; filter.taglist = &taglist; filter.pattern = pattern; error = git_reference_foreach(repo, GIT_REF_OID|GIT_REF_PACKED, &tag_list_cb, (void *)&filter); - if (error < GIT_SUCCESS) { + if (error < 0) { git_vector_free(&taglist); - return git__rethrow(error, "Failed to list tags"); + return -1; } tag_names->strings = (char **)taglist.contents; tag_names->count = taglist.length; - return GIT_SUCCESS; + return 0; } int git_tag_list(git_strarray *tag_names, git_repository *repo) { return git_tag_list_match(tag_names, "", repo); } + +int git_tag_peel(git_object **tag_target, git_tag *tag) +{ + int error; + git_object *target; + + assert(tag_target && tag); + + if (git_tag_target(&target, tag) < 0) + return -1; + + if (git_object_type(target) == GIT_OBJ_TAG) { + error = git_tag_peel(tag_target, (git_tag *)target); + git_object_free(target); + return error; + } + + *tag_target = target; + return 0; +} diff --git a/src/transport.c b/src/transport.c index 4910f2433..bc4248d5b 100644 --- a/src/transport.c +++ b/src/transport.c @@ -54,7 +54,8 @@ static git_transport_cb transport_find_fn(const char *url) int git_transport_dummy(git_transport **transport) { GIT_UNUSED(transport); - return git__throw(GIT_ENOTIMPLEMENTED, "This protocol isn't implemented. Sorry"); + giterr_set(GITERR_NET, "This transport isn't implemented. Sorry"); + return -1; } int git_transport_new(git_transport **out, const char *url) @@ -65,16 +66,17 @@ int git_transport_new(git_transport **out, const char *url) fn = transport_find_fn(url); - if (fn == NULL) - return git__throw(GIT_EINVALIDARGS, "Unsupported URL or non-existent path"); + if (fn == NULL) { + giterr_set(GITERR_NET, "Unsupported URL protocol"); + return -1; + } error = fn(&transport); if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create new transport"); + return error; transport->url = git__strdup(url); - if (transport->url == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(transport->url); *out = transport; diff --git a/src/transport.h b/src/transport.h index 63dd7dab6..125df2745 100644 --- a/src/transport.h +++ b/src/transport.h @@ -8,6 +8,7 @@ #define INCLUDE_transport_h__ #include "git2/net.h" +#include "git2/indexer.h" #include "vector.h" #define GIT_CAP_OFS_DELTA "ofs-delta" @@ -65,23 +66,15 @@ struct git_transport { * Push the changes over */ int (*push)(struct git_transport *transport); - /** - * Send a 'done' message - */ - int (*send_done)(struct git_transport *transport); /** * Negotiate the minimal amount of objects that need to be * retrieved */ int (*negotiate_fetch)(struct git_transport *transport, git_repository *repo, const git_vector *wants); - /** - * Send a flush - */ - int (*send_flush)(struct git_transport *transport); /** * Download the packfile */ - int (*download_pack)(char **out, struct git_transport *transport, git_repository *repo); + int (*download_pack)(struct git_transport *transport, git_repository *repo, git_off_t *bytes, git_indexer_stats *stats); /** * Fetch the changes */ diff --git a/src/transports/git.c b/src/transports/git.c index 88e7e8160..c51b1670f 100644 --- a/src/transports/git.c +++ b/src/transports/git.c @@ -46,11 +46,13 @@ static int gen_proto(git_buf *request, const char *cmd, const char *url) char *delim, *repo; char default_command[] = "git-upload-pack"; char host[] = "host="; - int len; + size_t len; delim = strchr(url, '/'); - if (delim == NULL) - return git__throw(GIT_EOBJCORRUPTED, "Failed to create proto-request: malformed URL"); + if (delim == NULL) { + giterr_set(GITERR_NET, "Malformed URL"); + return -1; + } repo = delim; @@ -64,11 +66,15 @@ static int gen_proto(git_buf *request, const char *cmd, const char *url) len = 4 + strlen(cmd) + 1 + strlen(repo) + 1 + strlen(host) + (delim - url) + 1; git_buf_grow(request, len); - git_buf_printf(request, "%04x%s %s%c%s", len, cmd, repo, 0, host); + git_buf_printf(request, "%04x%s %s%c%s", + (unsigned int)(len & 0x0FFFF), cmd, repo, 0, host); git_buf_put(request, url, delim - url); git_buf_putc(request, '\0'); - return git_buf_lasterror(request); + if (git_buf_oom(request)) + return -1; + + return 0; } static int send_request(GIT_SOCKET s, const char *cmd, const char *url) @@ -77,7 +83,7 @@ static int send_request(GIT_SOCKET s, const char *cmd, const char *url) git_buf request = GIT_BUF_INIT; error = gen_proto(&request, cmd, url); - if (error < GIT_SUCCESS) + if (error < 0) goto cleanup; error = gitno_send(s, request.ptr, request.size, 0); @@ -102,9 +108,8 @@ static int do_connect(transport_git *t, const char *url) if (!git__prefixcmp(url, prefix)) url += strlen(prefix); - error = gitno_extract_host_and_port(&host, &port, url, GIT_DEFAULT_PORT); - if (error < GIT_SUCCESS) - return error; + if (gitno_extract_host_and_port(&host, &port, url, GIT_DEFAULT_PORT) < 0) + return -1; s = gitno_connect(host, port); connected = 1; @@ -115,9 +120,11 @@ static int do_connect(transport_git *t, const char *url) git__free(port); if (error < GIT_SUCCESS && s > 0) - close(s); - if (!connected) - error = git__throw(GIT_EOSERR, "Failed to connect to any of the addresses"); + gitno_close(s); + if (!connected) { + giterr_set(GITERR_NET, "Failed to connect to the host"); + return -1; + } return error; } @@ -128,33 +135,30 @@ static int do_connect(transport_git *t, const char *url) static int store_refs(transport_git *t) { gitno_buffer *buf = &t->buf; - int error = GIT_SUCCESS; + int ret = 0; while (1) { - error = gitno_recv(buf); - if (error < GIT_SUCCESS) - return git__rethrow(GIT_EOSERR, "Failed to receive data"); - if (error == GIT_SUCCESS) /* Orderly shutdown, so exit */ - return GIT_SUCCESS; + if ((ret = gitno_recv(buf)) < 0) + return -1; + if (ret == 0) /* Orderly shutdown, so exit */ + return 0; - error = git_protocol_store_refs(&t->proto, buf->data, buf->offset); - if (error == GIT_ESHORTBUFFER) { + ret = git_protocol_store_refs(&t->proto, buf->data, buf->offset); + if (ret == GIT_ESHORTBUFFER) { gitno_consume_n(buf, buf->len); continue; } - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to store refs"); + if (ret < 0) + return ret; gitno_consume_n(buf, buf->offset); if (t->proto.flush) { /* No more refs */ t->proto.flush = 0; - return GIT_SUCCESS; + return 0; } } - - return error; } static int detect_caps(transport_git *t) @@ -167,7 +171,7 @@ static int detect_caps(transport_git *t) pkt = git_vector_get(refs, 0); /* No refs or capabilites, odd but not a problem */ if (pkt == NULL || pkt->capabilities == NULL) - return GIT_SUCCESS; + return 0; ptr = pkt->capabilities; while (ptr != NULL && *ptr != '\0') { @@ -184,7 +188,7 @@ static int detect_caps(transport_git *t) ptr = strchr(ptr, ' '); } - return GIT_SUCCESS; + return 0; } /* @@ -194,36 +198,33 @@ static int detect_caps(transport_git *t) static int git_connect(git_transport *transport, int direction) { transport_git *t = (transport_git *) transport; - int error = GIT_SUCCESS; - if (direction == GIT_DIR_PUSH) - return git__throw(GIT_EINVALIDARGS, "Pushing is not supported with the git protocol"); + if (direction == GIT_DIR_PUSH) { + giterr_set(GITERR_NET, "Pushing over git:// is not supported"); + return -1; + } t->parent.direction = direction; - error = git_vector_init(&t->refs, 16, NULL); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_vector_init(&t->refs, 16, NULL) < 0) + return -1; /* Connect and ask for the refs */ - error = do_connect(t, transport->url); - if (error < GIT_SUCCESS) - return error; + if (do_connect(t, transport->url) < 0) + goto cleanup; gitno_buffer_setup(&t->buf, t->buff, sizeof(t->buff), t->socket); t->parent.connected = 1; - error = store_refs(t); - if (error < GIT_SUCCESS) - return error; + if (store_refs(t) < 0) + goto cleanup; - error = detect_caps(t); + if (detect_caps(t) < 0) + goto cleanup; + return 0; cleanup: - if (error < GIT_SUCCESS) { - git_vector_free(&t->refs); - } - - return error; + git_vector_free(&t->refs); + return -1; } static int git_ls(git_transport *transport, git_headlist_cb list_cb, void *opaque) @@ -241,149 +242,129 @@ static int git_ls(git_transport *transport, git_headlist_cb list_cb, void *opaqu pkt = (git_pkt_ref *)p; - if (list_cb(&pkt->head, opaque) < 0) - return git__throw(GIT_ERROR, - "The user callback returned an error code"); + if (list_cb(&pkt->head, opaque) < 0) { + giterr_set(GITERR_NET, "User callback returned error"); + return -1; + } } - return GIT_SUCCESS; + 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_ESHORTBUFFER) + 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_reference *ref; - git_strarray refs; git_oid oid; int error; unsigned int i; + git_buf data = GIT_BUF_INIT; gitno_buffer *buf = &t->buf; - error = git_pkt_send_wants(wants, &t->caps, t->socket); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to send wants list"); + if (git_pkt_buffer_wants(wants, &t->caps, &data) < 0) + return -1; - error = git_reference_listall(&refs, repo, GIT_REF_LISTALL); - if (error < GIT_ERROR) - return git__rethrow(error, "Failed to list all references"); + if (git_fetch_setup_walk(&walk, repo) < 0) + goto on_error; - error = git_revwalk_new(&walk, repo); - if (error < GIT_ERROR) { - error = git__rethrow(error, "Failed to list all references"); - goto cleanup; - } - git_revwalk_sorting(walk, GIT_SORT_TIME); - - for (i = 0; i < refs.count; ++i) { - /* No tags */ - if (!git__prefixcmp(refs.strings[i], GIT_REFS_TAGS_DIR)) - continue; - - error = git_reference_lookup(&ref, repo, refs.strings[i]); - if (error < GIT_ERROR) { - error = git__rethrow(error, "Failed to lookup %s", refs.strings[i]); - goto cleanup; - } - - if (git_reference_type(ref) == GIT_REF_SYMBOLIC) - continue; - - error = git_revwalk_push(walk, git_reference_oid(ref)); - if (error < GIT_ERROR) { - error = git__rethrow(error, "Failed to push %s", refs.strings[i]); - goto cleanup; - } - } - git_strarray_free(&refs); + if (gitno_send(t->socket, 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)) == GIT_SUCCESS) { - error = git_pkt_send_have(&oid, t->socket); + while ((error = git_revwalk_next(&oid, walk)) == 0) { + git_pkt_buffer_have(&oid, &data); i++; if (i % 20 == 0) { - const char *ptr = buf->data, *line_end; - git_pkt *pkt; - git_pkt_send_flush(t->socket); - while (1) { - /* Wait for max. 1 second */ - error = gitno_select_in(buf, 1, 0); - if (error < GIT_SUCCESS) { - error = git__throw(GIT_EOSERR, "Error in select"); - } else if (error == 0) { - /* - * Some servers don't respond immediately, so if this - * happens, we keep sending information until it - * answers. - */ - break; - } + int pkt_type; - error = gitno_recv(buf); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Error receiving data"); - goto cleanup; - } - error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->offset); - if (error == GIT_ESHORTBUFFER) - continue; - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to get answer"); - goto cleanup; - } + git_pkt_buffer_flush(&data); + if (git_buf_oom(&data)) + goto on_error; - gitno_consume(buf, line_end); + if (gitno_send(t->socket, data.ptr, data.size, 0) < 0) + goto on_error; - if (pkt->type == GIT_PKT_ACK) { - git__free(pkt); - error = GIT_SUCCESS; - goto done; - } else if (pkt->type == GIT_PKT_NAK) { - git__free(pkt); - break; - } else { - error = git__throw(GIT_ERROR, "Got unexpected pkt type"); - goto cleanup; - } + 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 == GIT_EREVWALKOVER) - error = GIT_SUCCESS; + if (error < 0 && error != GIT_EREVWALKOVER) + goto on_error; -done: - git_pkt_send_flush(t->socket); - git_pkt_send_done(t->socket); + /* 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(t->socket, data.ptr, data.size, 0) < 0) + goto on_error; -cleanup: + git_buf_free(&data); git_revwalk_free(walk); + return 0; - return error; +on_error: + git_buf_free(&data); + git_revwalk_free(walk); + return -1; } -static int git_send_flush(git_transport *transport) +static int git_download_pack(git_transport *transport, git_repository *repo, git_off_t *bytes, git_indexer_stats *stats) { transport_git *t = (transport_git *) transport; - - return git_pkt_send_flush(t->socket); -} - -static int git_send_done(git_transport *transport) -{ - transport_git *t = (transport_git *) transport; - - return git_pkt_send_done(t->socket); -} - -static int git_download_pack(char **out, git_transport *transport, git_repository *repo) -{ - transport_git *t = (transport_git *) transport; - int error = GIT_SUCCESS; + int error = 0, read_bytes; gitno_buffer *buf = &t->buf; git_pkt *pkt; const char *line_end, *ptr; @@ -391,7 +372,7 @@ static int git_download_pack(char **out, git_transport *transport, git_repositor /* * For now, we ignore everything and wait for the pack */ - while (1) { + do { ptr = buf->data; /* Whilst we're searching for the pack */ while (1) { @@ -408,7 +389,7 @@ static int git_download_pack(char **out, git_transport *transport, git_repositor if (pkt->type == GIT_PKT_PACK) { git__free(pkt); - return git_fetch__download_pack(out, buf->data, buf->offset, t->socket, repo); + return git_fetch__download_pack(buf->data, buf->offset, t->socket, repo, bytes, stats); } /* For now we don't care about anything */ @@ -416,34 +397,28 @@ static int git_download_pack(char **out, git_transport *transport, git_repositor gitno_consume(buf, line_end); } - error = gitno_recv(buf); - if (error < GIT_SUCCESS) - return git__rethrow(GIT_EOSERR, "Failed to receive data"); - if (error == 0) { /* Orderly shutdown */ - return GIT_SUCCESS; - } + read_bytes = gitno_recv(buf); + } while (read_bytes); - } + return read_bytes; } - static int git_close(git_transport *transport) { transport_git *t = (transport_git*) transport; - int error; /* Can't do anything if there's an error, so don't bother checking */ git_pkt_send_flush(t->socket); - error = gitno_close(t->socket); - - if (error < 0) - error = git__throw(GIT_EOSERR, "Failed to close socket"); + if (gitno_close(t->socket) < 0) { + giterr_set(GITERR_NET, "Failed to close socket"); + return -1; + } #ifdef GIT_WIN32 WSACleanup(); #endif - return error; + return 0; } static void git_free(git_transport *transport) @@ -472,16 +447,13 @@ int git_transport_git(git_transport **out) #endif t = git__malloc(sizeof(transport_git)); - if (t == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(t); memset(t, 0x0, sizeof(transport_git)); t->parent.connect = git_connect; t->parent.ls = git_ls; t->parent.negotiate_fetch = git_negotiate_fetch; - t->parent.send_flush = git_send_flush; - t->parent.send_done = git_send_done; t->parent.download_pack = git_download_pack; t->parent.close = git_close; t->parent.free = git_free; @@ -494,9 +466,10 @@ int git_transport_git(git_transport **out) ret = WSAStartup(MAKEWORD(2,2), &t->wsd); if (ret != 0) { git_free(*out); - return git__throw(GIT_EOSERR, "Winsock init failed"); + giterr_set(GITERR_NET, "Winsock init failed"); + return -1; } #endif - return GIT_SUCCESS; + return 0; } diff --git a/src/transports/http.c b/src/transports/http.c index 2842d08fd..1b2b5eb89 100644 --- a/src/transports/http.c +++ b/src/transports/http.c @@ -32,7 +32,7 @@ typedef struct { git_protocol proto; git_vector refs; git_vector common; - int socket; + GIT_SOCKET socket; git_buf buf; git_remote_head **heads; int error; @@ -77,7 +77,10 @@ static int gen_request(git_buf *buf, const char *url, const char *host, const ch } git_buf_puts(buf, "\r\n"); - return git_buf_lasterror(buf); + if (git_buf_oom(buf)) + return -1; + + return 0; } static int do_connect(transport_http *t, const char *host, const char *port) @@ -85,16 +88,15 @@ static int do_connect(transport_http *t, const char *host, const char *port) GIT_SOCKET s = -1; if (t->parent.connected && http_should_keep_alive(&t->parser)) - return GIT_SUCCESS; + return 0; + + if ((s = gitno_connect(host, port)) < 0) + return -1; - s = gitno_connect(host, port); - if (s < GIT_SUCCESS) { - return git__rethrow(s, "Failed to connect to host"); - } t->socket = s; t->parent.connected = 1; - return GIT_SUCCESS; + return 0; } /* @@ -116,8 +118,7 @@ static int on_header_field(http_parser *parser, const char *str, size_t len) t->ct_finished = 1; t->ct_found = 0; t->content_type = git__strdup(git_buf_cstr(buf)); - if (t->content_type == NULL) - return t->error = GIT_ENOMEM; + GITERR_CHECK_ALLOC(t->content_type); git_buf_clear(buf); } @@ -164,19 +165,25 @@ static int on_headers_complete(http_parser *parser) transport_http *t = (transport_http *) parser->data; git_buf *buf = &t->buf; + /* The content-type is text/plain for 404, so don't validate */ + if (parser->status_code == 404) { + git_buf_clear(buf); + return 0; + } + if (t->content_type == NULL) { t->content_type = git__strdup(git_buf_cstr(buf)); if (t->content_type == NULL) - return t->error = GIT_ENOMEM; + return t->error = -1; } git_buf_clear(buf); git_buf_printf(buf, "application/x-git-%s-advertisement", t->service); if (git_buf_oom(buf)) - return GIT_ENOMEM; + return t->error = -1; if (strcmp(t->content_type, git_buf_cstr(buf))) - return t->error = git__throw(GIT_EOBJCORRUPTED, "Content-Type '%s' is wrong", t->content_type); + return t->error = -1; git_buf_clear(buf); return 0; @@ -186,6 +193,10 @@ 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); } @@ -194,16 +205,22 @@ static int on_message_complete(http_parser *parser) transport_http *t = (transport_http *) parser->data; t->transfer_finished = 1; + + if (parser->status_code == 404) { + giterr_set(GITERR_NET, "Remote error: %s", git_buf_cstr(&t->buf)); + t->error = -1; + } + return 0; } static int store_refs(transport_http *t) { - int error = GIT_SUCCESS; http_parser_settings settings; char buffer[1024]; gitno_buffer buf; git_pkt *pkt; + int ret; http_parser_init(&t->parser, HTTP_RESPONSE); t->parser.data = t; @@ -219,83 +236,76 @@ static int store_refs(transport_http *t) while(1) { size_t parsed; - error = gitno_recv(&buf); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Error receiving data from network"); + 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 < GIT_SUCCESS) - return git__rethrow(t->error, "Error parsing HTTP data"); + if (parsed != buf.offset || t->error < 0) + return t->error; gitno_consume_n(&buf, parsed); - if (error == 0 || t->transfer_finished) - return GIT_SUCCESS; + if (ret == 0 || t->transfer_finished) + return 0; } pkt = git_vector_get(&t->refs, 0); - if (pkt == NULL || pkt->type != GIT_PKT_COMMENT) - return t->error = git__throw(GIT_EOBJCORRUPTED, "Not a valid smart HTTP response"); - else + 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); + } - return error; + return 0; } static int http_connect(git_transport *transport, int direction) { transport_http *t = (transport_http *) transport; - int error; + int ret; git_buf request = GIT_BUF_INIT; const char *service = "upload-pack"; const char *url = t->parent.url, *prefix = "http://"; - if (direction == GIT_DIR_PUSH) - return git__throw(GIT_EINVALIDARGS, "Pushing over HTTP is not supported"); + if (direction == GIT_DIR_PUSH) { + giterr_set(GITERR_NET, "Pushing over HTTP is not implemented"); + return -1; + } t->parent.direction = direction; - error = git_vector_init(&t->refs, 16, NULL); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to init refs vector"); + if (git_vector_init(&t->refs, 16, NULL) < 0) + return -1; if (!git__prefixcmp(url, prefix)) url += strlen(prefix); - error = gitno_extract_host_and_port(&t->host, &t->port, url, "80"); - if (error < GIT_SUCCESS) + if ((ret = gitno_extract_host_and_port(&t->host, &t->port, url, "80")) < 0) goto cleanup; t->service = git__strdup(service); - if (t->service == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + GITERR_CHECK_ALLOC(t->service); - error = do_connect(t, t->host, t->port); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to connect to host"); + if ((ret = do_connect(t, t->host, t->port)) < 0) goto cleanup; - } /* Generate and send the HTTP request */ - error = gen_request(&request, url, t->host, "GET", service, 0, 1); - if (error < GIT_SUCCESS) { - error = git__throw(error, "Failed to generate request"); + if ((ret = gen_request(&request, url, t->host, "GET", service, 0, 1)) < 0) { + giterr_set(GITERR_NET, "Failed to generate request"); goto cleanup; } - error = gitno_send(t->socket, request.ptr, request.size, 0); - if (error < GIT_SUCCESS) - error = git__rethrow(error, "Failed to send the HTTP request"); + if ((ret = gitno_send(t->socket, request.ptr, request.size, 0)) < 0) + goto cleanup; - error = store_refs(t); + ret = store_refs(t); cleanup: git_buf_free(&request); git_buf_clear(&t->buf); - return error; + return ret; } static int http_ls(git_transport *transport, git_headlist_cb list_cb, void *opaque) @@ -309,12 +319,13 @@ static int http_ls(git_transport *transport, git_headlist_cb list_cb, void *opaq if (p->type != GIT_PKT_REF) continue; - if (list_cb(&p->head, opaque) < 0) - return git__throw(GIT_ERROR, - "The user callback returned an error code"); + if (list_cb(&p->head, opaque) < 0) { + giterr_set(GITERR_NET, "The user callback returned error"); + return -1; + } } - return GIT_SUCCESS; + return 0; } static int on_body_parse_response(http_parser *parser, const char *str, size_t len) @@ -326,10 +337,12 @@ static int on_body_parse_response(http_parser *parser, const char *str, size_t l const char *line_end, *ptr; if (len == 0) { /* EOF */ - if (buf->size != 0) - return t->error = git__throw(GIT_ERROR, "EOF and unprocessed data"); - else + 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); @@ -337,15 +350,15 @@ static int on_body_parse_response(http_parser *parser, const char *str, size_t l while (1) { git_pkt *pkt; - if (buf->size == 0) + if (git_buf_len(buf) == 0) return 0; - error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->size); + error = git_pkt_parse_line(&pkt, ptr, &line_end, git_buf_len(buf)); if (error == GIT_ESHORTBUFFER) { return 0; /* Ask for more */ } if (error < GIT_SUCCESS) - return t->error = git__rethrow(error, "Failed to parse pkt-line"); + return t->error = -1; git_buf_consume(buf, line_end); @@ -365,9 +378,8 @@ static int on_body_parse_response(http_parser *parser, const char *str, size_t l continue; } - error = git_vector_insert(common, pkt); - if (error < GIT_SUCCESS) - return t->error = git__rethrow(error, "Failed to add pkt to list"); + if (git_vector_insert(common, pkt) < 0) + return -1; } return error; @@ -376,7 +388,7 @@ static int on_body_parse_response(http_parser *parser, const char *str, size_t l static int parse_response(transport_http *t) { - int error = GIT_SUCCESS; + int ret = 0; http_parser_settings settings; char buffer[1024]; gitno_buffer buf; @@ -396,74 +408,28 @@ static int parse_response(transport_http *t) while(1) { size_t parsed; - error = gitno_recv(&buf); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Error receiving data from network"); + 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 < GIT_SUCCESS) - return git__rethrow(t->error, "Error parsing HTTP data"); + if (parsed != buf.offset || t->error < 0) + return t->error; gitno_consume_n(&buf, parsed); - if (error == 0 || t->transfer_finished || t->pack_ready) { - return GIT_SUCCESS; + if (ret == 0 || t->transfer_finished || t->pack_ready) { + return 0; } } - return error; -} - -static int setup_walk(git_revwalk **out, git_repository *repo) -{ - git_revwalk *walk; - git_strarray refs; - unsigned int i; - git_reference *ref; - int error; - - error = git_reference_listall(&refs, repo, GIT_REF_LISTALL); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to list references"); - - error = git_revwalk_new(&walk, repo); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to setup walk"); - - git_revwalk_sorting(walk, GIT_SORT_TIME); - - for (i = 0; i < refs.count; ++i) { - /* No tags */ - if (!git__prefixcmp(refs.strings[i], GIT_REFS_TAGS_DIR)) - continue; - - error = git_reference_lookup(&ref, repo, refs.strings[i]); - if (error < GIT_ERROR) { - error = git__rethrow(error, "Failed to lookup %s", refs.strings[i]); - goto cleanup; - } - - if (git_reference_type(ref) == GIT_REF_SYMBOLIC) - continue; - error = git_revwalk_push(walk, git_reference_oid(ref)); - if (error < GIT_ERROR) { - error = git__rethrow(error, "Failed to push %s", refs.strings[i]); - goto cleanup; - } - } - - *out = walk; -cleanup: - git_strarray_free(&refs); - - return error; + return ret; } static int http_negotiate_fetch(git_transport *transport, git_repository *repo, const git_vector *wants) { transport_http *t = (transport_http *) transport; - int error; + int ret; unsigned int i; char buff[128]; gitno_buffer buf; @@ -479,82 +445,55 @@ static int http_negotiate_fetch(git_transport *transport, git_repository *repo, if (!git__prefixcmp(url, prefix)) url += strlen(prefix); - error = git_vector_init(common, 16, NULL); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to init common vector"); + if (git_vector_init(common, 16, NULL) < 0) + return -1; - error = setup_walk(&walk, repo); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to setup walk"); - goto cleanup; - } + if (git_fetch_setup_walk(&walk, repo) < 0) + return -1; do { - error = do_connect(t, t->host, t->port); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to connect to host"); + if ((ret = do_connect(t, t->host, t->port)) < 0) goto cleanup; - } - error = git_pkt_buffer_wants(wants, &t->caps, &data); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to send wants"); + 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) { - error = git_pkt_buffer_have(&pkt->oid, &data); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to buffer common have"); + if ((ret = git_pkt_buffer_have(&pkt->oid, &data)) < 0) goto cleanup; - } } i = 0; - while ((i < 20) && ((error = git_revwalk_next(&oid, walk)) == GIT_SUCCESS)) { - error = git_pkt_buffer_have(&oid, &data); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to buffer have"); + 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); - error = gen_request(&request, url, t->host, "POST", "upload-pack", data.size, 0); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to generate request"); + if ((ret = gen_request(&request, url, t->host, "POST", "upload-pack", data.size, 0)) < 0) goto cleanup; - } - error = gitno_send(t->socket, request.ptr, request.size, 0); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to send request"); + if ((ret = gitno_send(t->socket, request.ptr, request.size, 0)) < 0) goto cleanup; - } - error = gitno_send(t->socket, data.ptr, data.size, 0); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to send data"); + if ((ret = gitno_send(t->socket, data.ptr, data.size, 0)) < 0) goto cleanup; - } git_buf_clear(&request); git_buf_clear(&data); - if (error < GIT_SUCCESS || i >= 256) + if (ret < GIT_SUCCESS || i >= 256) break; - error = parse_response(t); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Error parsing the response"); + if ((ret = parse_response(t)) < 0) goto cleanup; - } if (t->pack_ready) { - error = GIT_SUCCESS; + ret = 0; goto cleanup; } @@ -564,11 +503,12 @@ cleanup: git_buf_free(&request); git_buf_free(&data); git_revwalk_free(walk); - return error; + return ret; } typedef struct { - git_filebuf *file; + git_indexer_stream *idx; + git_indexer_stats *stats; transport_http *transport; } download_pack_cbdata; @@ -584,10 +524,10 @@ static int on_body_download_pack(http_parser *parser, const char *str, size_t le { download_pack_cbdata *data = (download_pack_cbdata *) parser->data; transport_http *t = data->transport; - git_filebuf *file = data->file; + git_indexer_stream *idx = data->idx; + git_indexer_stats *stats = data->stats; - - return t->error = git_filebuf_write(file, str, len); + return t->error = git_indexer_stream_add(idx, str, len, stats); } /* @@ -596,96 +536,81 @@ static int on_body_download_pack(http_parser *parser, const char *str, size_t le * the simple downloader. Furthermore, we're using keep-alive * connections, so the simple downloader would just hang. */ -static int http_download_pack(char **out, git_transport *transport, git_repository *repo) +static int http_download_pack(git_transport *transport, git_repository *repo, git_off_t *bytes, git_indexer_stats *stats) { transport_http *t = (transport_http *) transport; git_buf *oldbuf = &t->buf; - int error = GIT_SUCCESS; + int recvd; http_parser_settings settings; char buffer[1024]; gitno_buffer buf; + git_indexer_stream *idx = NULL; download_pack_cbdata data; - git_filebuf file = GIT_FILEBUF_INIT; - git_buf path = GIT_BUF_INIT; - char suff[] = "/objects/pack/pack-received\0"; + + gitno_buffer_setup(&buf, buffer, sizeof(buffer), t->socket); + + if (memcmp(oldbuf->ptr, "PACK", strlen("PACK"))) { + giterr_set(GITERR_NET, "The pack doesn't start with a pack signature"); + return -1; + } + + if (git_indexer_stream_new(&idx, git_repository_path(repo)) < 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. */ - data.file = &file; + 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); - gitno_buffer_setup(&buf, buffer, sizeof(buffer), t->socket); + if (git_indexer_stream_add(idx, git_buf_cstr(oldbuf), git_buf_len(oldbuf), stats) < 0) + goto on_error; - if (memcmp(oldbuf->ptr, "PACK", strlen("PACK"))) { - return git__throw(GIT_ERROR, "The pack doesn't start with the signature"); - } - - error = git_buf_joinpath(&path, repo->path_repository, suff); - if (error < GIT_SUCCESS) - goto cleanup; - - error = git_filebuf_open(&file, path.ptr, GIT_FILEBUF_TEMPORARY); - if (error < GIT_SUCCESS) - goto cleanup; - - /* Part of the packfile has been received, don't loose it */ - error = git_filebuf_write(&file, oldbuf->ptr, oldbuf->size); - if (error < GIT_SUCCESS) - goto cleanup; - - while(1) { + do { size_t parsed; - error = gitno_recv(&buf); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Error receiving data from network"); + if ((recvd = gitno_recv(&buf)) < 0) + goto on_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 < GIT_SUCCESS) - return git__rethrow(t->error, "Error parsing HTTP data"); + if (parsed != buf.offset || t->error < 0) + goto on_error; + *bytes += recvd; gitno_consume_n(&buf, parsed); + } while (recvd > 0 && !t->transfer_finished); - if (error == 0 || t->transfer_finished) { - break; - } - } + if (git_indexer_stream_finalize(idx, stats) < 0) + goto on_error; - *out = git__strdup(file.path_lock); - if (*out == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + git_indexer_stream_free(idx); + return 0; - /* A bit dodgy, but we need to keep the pack at the temporary path */ - error = git_filebuf_commit_at(&file, file.path_lock, GIT_PACK_FILE_MODE); - -cleanup: - if (error < GIT_SUCCESS) - git_filebuf_cleanup(&file); - git_buf_free(&path); - - return error; +on_error: + git_indexer_stream_free(idx); + return -1; } static int http_close(git_transport *transport) { transport_http *t = (transport_http *) transport; - int error; - error = gitno_close(t->socket); - if (error < 0) - return git__throw(GIT_EOSERR, "Failed to close the socket: %s", strerror(errno)); + if (gitno_close(t->socket) < 0) { + giterr_set(GITERR_OS, "Failed to close the socket: %s", strerror(errno)); + return -1; + } - return GIT_SUCCESS; + return 0; } @@ -729,8 +654,7 @@ int git_transport_http(git_transport **out) transport_http *t; t = git__malloc(sizeof(transport_http)); - if (t == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(t); memset(t, 0x0, sizeof(transport_http)); @@ -748,10 +672,11 @@ int git_transport_http(git_transport **out) * before any socket calls can be performed */ if (WSAStartup(MAKEWORD(2,2), &t->wsd) != 0) { http_free((git_transport *) t); - return git__throw(GIT_EOSERR, "Winsock init failed"); + giterr_set(GITERR_OS, "Winsock init failed"); + return -1; } #endif *out = (git_transport *) t; - return GIT_SUCCESS; + return 0; } diff --git a/src/transports/local.c b/src/transports/local.c index eb24db0fd..5dc350103 100644 --- a/src/transports/local.c +++ b/src/transports/local.c @@ -26,110 +26,94 @@ static int add_ref(transport_local *t, const char *name) { const char peeled[] = "^{}"; git_remote_head *head; - git_reference *ref, *resolved_ref; - git_object *obj = NULL; - int error = GIT_SUCCESS, peel_len, ret; + git_object *obj = NULL, *target = NULL; + git_buf buf = GIT_BUF_INIT; head = git__malloc(sizeof(git_remote_head)); - if (head == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(head); head->name = git__strdup(name); - if (head->name == NULL) { - error = GIT_ENOMEM; - goto out; + 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); + git__free(head); + return -1; } - error = git_reference_lookup(&ref, t->repo, name); - if (error < GIT_SUCCESS) - goto out; - - error = git_reference_resolve(&resolved_ref, ref); - if (error < GIT_SUCCESS) - goto out; - - git_oid_cpy(&head->oid, git_reference_oid(resolved_ref)); - - error = git_vector_insert(&t->refs, head); - if (error < GIT_SUCCESS) - goto out; - /* If it's not a tag, we don't need to try to peel it */ if (git__prefixcmp(name, GIT_REFS_TAGS_DIR)) - goto out; + return 0; - error = git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY); - if (error < GIT_SUCCESS) { - git__rethrow(error, "Failed to lookup object"); - } + if (git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY) < 0) + return -1; head = NULL; /* If it's not an annotated tag, just get out */ - if (git_object_type(obj) != GIT_OBJ_TAG) - goto out; + if (git_object_type(obj) != GIT_OBJ_TAG) { + git_object_free(obj); + return 0; + } /* And if it's a tag, peel it, and add it to the list */ head = git__malloc(sizeof(git_remote_head)); - peel_len = strlen(name) + strlen(peeled); - head->name = git__malloc(peel_len + 1); - ret = p_snprintf(head->name, peel_len + 1, "%s%s", name, peeled); + GITERR_CHECK_ALLOC(head); + if (git_buf_join(&buf, 0, name, peeled) < 0) + return -1; - assert(ret < peel_len + 1); - (void)ret; + head->name = git_buf_detach(&buf); - git_oid_cpy(&head->oid, git_tag_target_oid((git_tag *) obj)); - - error = git_vector_insert(&t->refs, head); - if (error < GIT_SUCCESS) - goto out; - - out: - git_reference_free(ref); - git_reference_free(resolved_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); - if (head && error < GIT_SUCCESS) { - git__free(head->name); - git__free(head); - } + git_object_free(target); - return error; + if (git_vector_insert(&t->refs, head) < 0) + return -1; + + return 0; + +on_error: + git_object_free(obj); + git_object_free(target); + return -1; } static int store_refs(transport_local *t) { - int error; unsigned int i; git_strarray ref_names = {0}; assert(t); - error = git_vector_init(&t->refs, ref_names.count, NULL); - if (error < GIT_SUCCESS) - return error; - - error = git_reference_listall(&ref_names, t->repo, GIT_REF_LISTALL); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to list remote heads"); + if (git_reference_listall(&ref_names, t->repo, GIT_REF_LISTALL) < 0 || + git_vector_init(&t->refs, (unsigned int)ref_names.count, NULL) < 0) + goto on_error; /* Sort the references first */ git__tsort((void **)ref_names.strings, ref_names.count, &git__strcmp_cb); /* Add HEAD */ - error = add_ref(t, GIT_HEAD_FILE); - if (error < GIT_SUCCESS) - goto cleanup; + if (add_ref(t, GIT_HEAD_FILE) < 0) + goto on_error; for (i = 0; i < ref_names.count; ++i) { - error = add_ref(t, ref_names.strings[i]); - if (error < GIT_SUCCESS) - goto cleanup; + if (add_ref(t, ref_names.strings[i]) < 0) + goto on_error; } -cleanup: git_strarray_free(&ref_names); - return error; + return 0; + +on_error: + git_vector_free(&t->refs); + git_strarray_free(&ref_names); + return -1; } static int local_ls(git_transport *transport, git_headlist_cb list_cb, void *payload) @@ -143,11 +127,10 @@ static int local_ls(git_transport *transport, git_headlist_cb list_cb, void *pay git_vector_foreach(refs, i, h) { if (list_cb(h, payload) < 0) - return git__throw(GIT_ERROR, - "The user callback returned an error code"); + return -1; } - return GIT_SUCCESS; + return 0; } /* @@ -166,32 +149,31 @@ static int local_connect(git_transport *transport, int direction) /* The repo layer doesn't want the prefix */ if (!git__prefixcmp(transport->url, "file://")) { - error = git_path_fromurl(&buf, transport->url); - if (error < GIT_SUCCESS) { + if (git_path_fromurl(&buf, transport->url) < 0) { git_buf_free(&buf); - return git__rethrow(error, "Failed to parse remote path"); + return -1; } path = git_buf_cstr(&buf); - } else /* We assume transport->url is already a path */ + } else { /* We assume transport->url is already a path */ path = transport->url; + } error = git_repository_open(&repo, path); git_buf_free(&buf); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to open remote"); + if (error < 0) + return -1; t->repo = repo; - error = store_refs(t); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to retrieve references"); + if (store_refs(t) < 0) + return -1; t->parent.connected = 1; - return GIT_SUCCESS; + return 0; } static int local_close(git_transport *transport) @@ -201,7 +183,7 @@ static int local_close(git_transport *transport) git_repository_free(t->repo); t->repo = NULL; - return GIT_SUCCESS; + return 0; } static void local_free(git_transport *transport) @@ -232,8 +214,7 @@ int git_transport_local(git_transport **out) transport_local *t; t = git__malloc(sizeof(transport_local)); - if (t == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(t); memset(t, 0x0, sizeof(transport_local)); @@ -244,5 +225,5 @@ int git_transport_local(git_transport **out) *out = (git_transport *) t; - return GIT_SUCCESS; + return 0; } diff --git a/src/tree-cache.c b/src/tree-cache.c index 9baa06a99..ebc2c6807 100644 --- a/src/tree-cache.c +++ b/src/tree-cache.c @@ -82,24 +82,19 @@ static int read_tree_internal(git_tree_cache **out, git_tree_cache *tree = NULL; const char *name_start, *buffer; int count; - int error = GIT_SUCCESS; size_t name_len; buffer = name_start = *buffer_in; - if ((buffer = memchr(buffer, '\0', buffer_end - buffer)) == NULL) { - error = GIT_EOBJCORRUPTED; - goto cleanup; - } + if ((buffer = memchr(buffer, '\0', buffer_end - buffer)) == NULL) + goto corrupted; - if (++buffer >= buffer_end) { - error = GIT_EOBJCORRUPTED; - goto cleanup; - } + if (++buffer >= buffer_end) + goto corrupted; name_len = strlen(name_start); - if ((tree = git__malloc(sizeof(git_tree_cache) + name_len + 1)) == NULL) - return GIT_ENOMEM; + tree = git__malloc(sizeof(git_tree_cache) + name_len + 1); + GITERR_CHECK_ALLOC(tree); memset(tree, 0x0, sizeof(git_tree_cache)); tree->parent = parent; @@ -109,39 +104,28 @@ static int read_tree_internal(git_tree_cache **out, tree->name[name_len] = '\0'; /* Blank-terminated ASCII decimal number of entries in this tree */ - if (git__strtol32(&count, buffer, &buffer, 10) < GIT_SUCCESS || count < -1) { - error = GIT_EOBJCORRUPTED; - goto cleanup; - } + if (git__strtol32(&count, buffer, &buffer, 10) < 0 || count < -1) + goto corrupted; tree->entries = count; - if (*buffer != ' ' || ++buffer >= buffer_end) { - error = GIT_EOBJCORRUPTED; - goto cleanup; - } + if (*buffer != ' ' || ++buffer >= buffer_end) + goto corrupted; /* Number of children of the tree, newline-terminated */ - if (git__strtol32(&count, buffer, &buffer, 10) < GIT_SUCCESS || - count < 0) { - error = GIT_EOBJCORRUPTED; - goto cleanup; - } + if (git__strtol32(&count, buffer, &buffer, 10) < 0 || count < 0) + goto corrupted; tree->children_count = count; - if (*buffer != '\n' || ++buffer > buffer_end) { - error = GIT_EOBJCORRUPTED; - goto cleanup; - } + if (*buffer != '\n' || ++buffer > buffer_end) + goto corrupted; /* The SHA1 is only there if it's not invalidated */ if (tree->entries >= 0) { /* 160-bit SHA-1 for this tree and it's children */ - if (buffer + GIT_OID_RAWSZ > buffer_end) { - error = GIT_EOBJCORRUPTED; - goto cleanup; - } + if (buffer + GIT_OID_RAWSZ > buffer_end) + goto corrupted; git_oid_fromraw(&tree->oid, (const unsigned char *)buffer); buffer += GIT_OID_RAWSZ; @@ -150,40 +134,39 @@ static int read_tree_internal(git_tree_cache **out, /* Parse children: */ if (tree->children_count > 0) { unsigned int i; - int err; tree->children = git__malloc(tree->children_count * sizeof(git_tree_cache *)); - if (tree->children == NULL) - goto cleanup; + GITERR_CHECK_ALLOC(tree->children); for (i = 0; i < tree->children_count; ++i) { - err = read_tree_internal(&tree->children[i], &buffer, buffer_end, tree); - - if (err < GIT_SUCCESS) - goto cleanup; + if (read_tree_internal(&tree->children[i], &buffer, buffer_end, tree) < 0) + return -1; } } *buffer_in = buffer; *out = tree; - return GIT_SUCCESS; + return 0; - cleanup: + corrupted: git_tree_cache_free(tree); - return error; + giterr_set(GITERR_INDEX, "Corruped TREE extension in index"); + return -1; } int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size) { const char *buffer_end = buffer + buffer_size; - int error; - error = read_tree_internal(tree, &buffer, buffer_end, NULL); + if (read_tree_internal(tree, &buffer, buffer_end, NULL) < 0) + return -1; - if (buffer < buffer_end) - return GIT_EOBJCORRUPTED; + if (buffer < buffer_end) { + giterr_set(GITERR_INDEX, "Corruped TREE extension in index (unexpected trailing data)"); + return -1; + } - return error; + return 0; } void git_tree_cache_free(git_tree_cache *tree) diff --git a/src/tree.c b/src/tree.c index 8a0971abd..7e2bfc102 100644 --- a/src/tree.c +++ b/src/tree.c @@ -201,41 +201,38 @@ unsigned int git_tree_entrycount(git_tree *tree) return tree->entries.length; } +static int tree_error(const char *str) +{ + giterr_set(GITERR_TREE, "%s", str); + return -1; +} + static int tree_parse_buffer(git_tree *tree, const char *buffer, const char *buffer_end) { - int error = GIT_SUCCESS; - - if (git_vector_init(&tree->entries, DEFAULT_TREE_SIZE, entry_sort_cmp) < GIT_SUCCESS) - return GIT_ENOMEM; + if (git_vector_init(&tree->entries, DEFAULT_TREE_SIZE, entry_sort_cmp) < 0) + return -1; while (buffer < buffer_end) { git_tree_entry *entry; int tmp; entry = git__calloc(1, sizeof(git_tree_entry)); - if (entry == NULL) { - error = GIT_ENOMEM; - break; - } + GITERR_CHECK_ALLOC(entry); - if (git_vector_insert(&tree->entries, entry) < GIT_SUCCESS) - return GIT_ENOMEM; + if (git_vector_insert(&tree->entries, entry) < 0) + return -1; - if (git__strtol32(&tmp, buffer, &buffer, 8) < GIT_SUCCESS || + if (git__strtol32(&tmp, buffer, &buffer, 8) < 0 || !buffer || !valid_attributes(tmp)) - return git__throw(GIT_EOBJCORRUPTED, "Failed to parse tree. Can't parse attributes"); + return tree_error("Failed to parse tree. Can't parse attributes"); entry->attr = tmp; - if (*buffer++ != ' ') { - error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse tree. Object it corrupted"); - break; - } + if (*buffer++ != ' ') + return tree_error("Failed to parse tree. Object is corrupted"); - if (memchr(buffer, 0, buffer_end - buffer) == NULL) { - error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse tree. Object it corrupted"); - break; - } + if (memchr(buffer, 0, buffer_end - buffer) == NULL) + return tree_error("Failed to parse tree. Object is corrupted"); entry->filename = git__strdup(buffer); entry->filename_len = strlen(buffer); @@ -249,7 +246,7 @@ static int tree_parse_buffer(git_tree *tree, const char *buffer, const char *buf buffer += GIT_OID_RAWSZ; } - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse buffer"); + return 0; } int git_tree__parse(git_tree *tree, git_odb_object *obj) @@ -280,10 +277,9 @@ static int append_entry(git_treebuilder *bld, const char *filename, const git_oi { git_tree_entry *entry; - if ((entry = git__malloc(sizeof(git_tree_entry))) == NULL) - return GIT_ENOMEM; + entry = git__calloc(1, sizeof(git_tree_entry)); + GITERR_CHECK_ALLOC(entry); - memset(entry, 0x0, sizeof(git_tree_entry)); entry->filename = git__strdup(filename); entry->filename_len = strlen(entry->filename); @@ -291,9 +287,9 @@ static int append_entry(git_treebuilder *bld, const char *filename, const git_oi entry->attr = attributes; if (git_vector_insert(&bld->entries, entry) < 0) - return GIT_ENOMEM; + return -1; - return GIT_SUCCESS; + return 0; } static int write_tree( @@ -318,7 +314,7 @@ static int write_tree( error = git_treebuilder_create(&bld, NULL); if (bld == NULL) { - return GIT_ENOMEM; + return -1; } /* @@ -354,16 +350,13 @@ static int write_tree( char *subdir, *last_comp; subdir = git__strndup(entry->path, next_slash - entry->path); - if (subdir == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + GITERR_CHECK_ALLOC(subdir); /* Write out the subtree */ written = write_tree(&sub_oid, repo, index, subdir, i); if (written < 0) { - error = git__rethrow(written, "Failed to write subtree %s", subdir); - goto cleanup; + tree_error("Failed to write subtree"); + goto on_error; } else { i = written - 1; /* -1 because of the loop increment */ } @@ -382,51 +375,49 @@ static int write_tree( } error = append_entry(bld, last_comp, &sub_oid, S_IFDIR); git__free(subdir); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to insert dir"); - goto cleanup; + if (error < 0) { + tree_error("Failed to insert dir"); + goto on_error; } } else { error = append_entry(bld, filename, &entry->oid, entry->mode); - if (error < GIT_SUCCESS) { - error = git__rethrow(error, "Failed to insert file"); + if (error < 0) { + tree_error("Failed to insert file"); + goto on_error; } } } - error = git_treebuilder_write(oid, repo, bld); - if (error < GIT_SUCCESS) - error = git__rethrow(error, "Failed to write tree to db"); + if (git_treebuilder_write(oid, repo, bld) < 0) + goto on_error; - cleanup: git_treebuilder_free(bld); + return i; - if (error < GIT_SUCCESS) - return error; - else - return i; +on_error: + git_treebuilder_free(bld); + return -1; } int git_tree_create_fromindex(git_oid *oid, git_index *index) { + int ret; git_repository *repo; - int error; repo = (git_repository *)GIT_REFCOUNT_OWNER(index); if (repo == NULL) - return git__throw(GIT_EBAREINDEX, - "Failed to create tree. " - "The index file is not backed up by an existing repository"); + return tree_error("Failed to create tree. " + "The index file is not backed up by an existing repository"); if (index->tree != NULL && index->tree->entries >= 0) { git_oid_cpy(oid, &index->tree->oid); - return GIT_SUCCESS; + return 0; } /* The tree cache didn't help us */ - error = write_tree(oid, repo, index, "", 0); - return (error < GIT_SUCCESS) ? git__rethrow(error, "Failed to create tree") : GIT_SUCCESS; + ret = write_tree(oid, repo, index, "", 0); + return ret < 0 ? ret : 0; } static void sort_entries(git_treebuilder *bld) @@ -442,30 +433,29 @@ int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source) assert(builder_p); bld = git__calloc(1, sizeof(git_treebuilder)); - if (bld == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(bld); if (source != NULL) source_entries = source->entries.length; - if (git_vector_init(&bld->entries, source_entries, entry_sort_cmp) < GIT_SUCCESS) { - git__free(bld); - return GIT_ENOMEM; - } + if (git_vector_init(&bld->entries, source_entries, entry_sort_cmp) < 0) + goto on_error; if (source != NULL) { for (i = 0; i < source->entries.length; ++i) { git_tree_entry *entry_src = source->entries.contents[i]; - if (append_entry(bld, entry_src->filename, &entry_src->oid, entry_src->attr) < 0) { - git_treebuilder_free(bld); - return GIT_ENOMEM; - } + if (append_entry(bld, entry_src->filename, &entry_src->oid, entry_src->attr) < 0) + goto on_error; } } *builder_p = bld; - return GIT_SUCCESS; + return 0; + +on_error: + git_treebuilder_free(bld); + return -1; } int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, const char *filename, const git_oid *id, unsigned int attributes) @@ -476,10 +466,10 @@ int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, con assert(bld && id && filename); if (!valid_attributes(attributes)) - return git__throw(GIT_ERROR, "Failed to insert entry. Invalid attributes"); + return tree_error("Failed to insert entry. Invalid attributes"); if (!valid_entry_name(filename)) - return git__throw(GIT_ERROR, "Failed to insert entry. Invalid name for a tree entry"); + return tree_error("Failed to insert entry. Invalid name for a tree entry"); pos = tree_key_search(&bld->entries, filename); @@ -488,10 +478,9 @@ int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, con if (entry->removed) entry->removed = 0; } else { - if ((entry = git__malloc(sizeof(git_tree_entry))) == NULL) - return GIT_ENOMEM; + entry = git__calloc(1, sizeof(git_tree_entry)); + GITERR_CHECK_ALLOC(entry); - memset(entry, 0x0, sizeof(git_tree_entry)); entry->filename = git__strdup(filename); entry->filename_len = strlen(entry->filename); } @@ -501,13 +490,13 @@ int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, con if (pos == GIT_ENOTFOUND) { if (git_vector_insert(&bld->entries, entry) < 0) - return GIT_ENOMEM; + return -1; } if (entry_out != NULL) *entry_out = entry; - return GIT_SUCCESS; + return 0; } static git_tree_entry *treebuilder_get(git_treebuilder *bld, const char *filename) @@ -538,16 +527,15 @@ int git_treebuilder_remove(git_treebuilder *bld, const char *filename) git_tree_entry *remove_ptr = treebuilder_get(bld, filename); if (remove_ptr == NULL || remove_ptr->removed) - return git__throw(GIT_ENOTFOUND, "Failed to remove entry. File isn't in the tree"); + return tree_error("Failed to remove entry. File isn't in the tree"); remove_ptr->removed = 1; - return GIT_SUCCESS; + return 0; } int git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *bld) { unsigned int i; - int error; git_buf tree = GIT_BUF_INIT; git_odb *odb; @@ -569,21 +557,22 @@ int git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *b git_buf_put(&tree, (char *)entry->oid.id, GIT_OID_RAWSZ); } - if ((error = git_buf_lasterror(&tree)) < GIT_SUCCESS) { - git_buf_free(&tree); - return git__rethrow(error, "Not enough memory to build the tree data"); - } + if (git_buf_oom(&tree)) + goto on_error; - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) { - git_buf_free(&tree); - return error; - } + if (git_repository_odb__weakptr(&odb, repo) < 0) + goto on_error; + + + if (git_odb_write(oid, odb, tree.ptr, tree.size, GIT_OBJ_TREE) < 0) + goto on_error; - error = git_odb_write(oid, odb, tree.ptr, tree.size, GIT_OBJ_TREE); git_buf_free(&tree); + return 0; - return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write tree"); +on_error: + git_buf_free(&tree); + return -1; } void git_treebuilder_filter(git_treebuilder *bld, int (*filter)(const git_tree_entry *, void *), void *payload) @@ -624,16 +613,18 @@ static int tree_frompath( git_tree **parent_out, git_tree *root, git_buf *treeentry_path, - int offset) + size_t offset) { char *slash_pos = NULL; const git_tree_entry* entry; int error = GIT_SUCCESS; git_tree *subtree; - if (!*(treeentry_path->ptr + offset)) - return git__rethrow(GIT_EINVALIDPATH, + if (!*(treeentry_path->ptr + offset)) { + giterr_set(GITERR_INVALID, "Invalid relative path to a tree entry '%s'.", treeentry_path->ptr); + return -1; + } slash_pos = (char *)strchr(treeentry_path->ptr + offset, '/'); @@ -644,9 +635,11 @@ static int tree_frompath( git_object_id((const git_object *)root) ); - if (slash_pos == treeentry_path->ptr + offset) - return git__rethrow(GIT_EINVALIDPATH, + if (slash_pos == treeentry_path->ptr + offset) { + giterr_set(GITERR_INVALID, "Invalid relative path to a tree entry '%s'.", treeentry_path->ptr); + return -1; + } *slash_pos = '\0'; @@ -655,14 +648,15 @@ static int tree_frompath( if (slash_pos != NULL) *slash_pos = '/'; - if (entry == NULL) - return git__rethrow(GIT_ENOTFOUND, + if (entry == NULL) { + giterr_set(GITERR_TREE, "No tree entry can be found from " "the given tree and relative path '%s'.", treeentry_path->ptr); + return GIT_ENOTFOUND; + } - error = git_tree_lookup(&subtree, root->object.repo, &entry->oid); - if (error < GIT_SUCCESS) + if (git_tree_lookup(&subtree, root->object.repo, &entry->oid) < 0) return error; error = tree_frompath( @@ -686,7 +680,7 @@ int git_tree_get_subtree( assert(subtree && root && subtree_path); - if ((error = git_buf_sets(&buffer, subtree_path)) == GIT_SUCCESS) + if ((error = git_buf_sets(&buffer, subtree_path)) == 0) error = tree_frompath(subtree, root, &buffer, 0); git_buf_free(&buffer); @@ -711,7 +705,7 @@ static int tree_walk_post( if (entry_is_tree(entry)) { git_tree *subtree; - size_t path_len = path->size; + size_t path_len = git_buf_len(path); if ((error = git_tree_lookup( &subtree, tree->object.repo, &entry->oid)) < 0) @@ -720,19 +714,19 @@ static int tree_walk_post( /* append the next entry to the path */ git_buf_puts(path, entry->filename); git_buf_putc(path, '/'); - if ((error = git_buf_lasterror(path)) < GIT_SUCCESS) - break; - error = tree_walk_post(subtree, callback, path, payload); - if (error < GIT_SUCCESS) - break; + if (git_buf_oom(path)) + return -1; + + if (tree_walk_post(subtree, callback, path, payload) < 0) + return -1; git_buf_truncate(path, path_len); git_tree_free(subtree); } } - return error; + return 0; } int git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payload) @@ -746,14 +740,12 @@ int git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payl break; case GIT_TREEWALK_PRE: - error = git__throw(GIT_ENOTIMPLEMENTED, - "Preorder tree walking is still not implemented"); - break; + tree_error("Preorder tree walking is still not implemented"); + return -1; default: - error = git__throw(GIT_EINVALIDARGS, - "Invalid walking mode for tree walk"); - break; + giterr_set(GITERR_INVALID, "Invalid walking mode for tree walk"); + return -1; } git_buf_free(&root_path); @@ -792,7 +784,7 @@ static int signal_additions(git_tree *tree, int start, int end, git_tree_diff_cb { git_tree_diff_data diff; git_tree_entry *entry; - int i, error; + int i; if (end < 0) end = git_tree_entrycount(tree); @@ -802,12 +794,11 @@ static int signal_additions(git_tree *tree, int start, int end, git_tree_diff_cb entry = git_vector_get(&tree->entries, i); mark_add(&diff, entry); - error = cb(&diff, data); - if (error < GIT_SUCCESS) - return error; + if (cb(&diff, data) < 0) + return -1; } - return GIT_SUCCESS; + return 0; } static int signal_addition(git_tree_entry *entry, git_tree_diff_cb cb, void *data) @@ -825,7 +816,7 @@ static int signal_deletions(git_tree *tree, int start, int end, git_tree_diff_cb { git_tree_diff_data diff; git_tree_entry *entry; - int i, error; + int i; if (end < 0) end = git_tree_entrycount(tree); @@ -835,12 +826,11 @@ static int signal_deletions(git_tree *tree, int start, int end, git_tree_diff_cb entry = git_vector_get(&tree->entries, i); mark_del(&diff, entry); - error = cb(&diff, data); - if (error < GIT_SUCCESS) - return error; + if (cb(&diff, data) < 0) + return -1; } - return GIT_SUCCESS; + return 0; } static int signal_deletion(git_tree_entry *entry, git_tree_diff_cb cb, void *data) @@ -872,14 +862,14 @@ int git_tree_diff(git_tree *a, git_tree *b, git_tree_diff_cb cb, void *data) unsigned int i_a = 0, i_b = 0; /* Counters for trees a and b */ git_tree_entry *entry_a = NULL, *entry_b = NULL; git_tree_diff_data diff; - int error = GIT_SUCCESS, cmp; + int cmp; while (1) { entry_a = a == NULL ? NULL : git_vector_get(&a->entries, i_a); entry_b = b == NULL ? NULL : git_vector_get(&b->entries, i_b); if (!entry_a && !entry_b) - goto exit; + return 0; memset(&diff, 0x0, sizeof(git_tree_diff_data)); @@ -910,29 +900,28 @@ int git_tree_diff(git_tree *a, git_tree *b, git_tree_diff_cb cb, void *data) /* If they're not both dirs or both files, it's add + del */ if (S_ISDIR(entry_a->attr) != S_ISDIR(entry_b->attr)) { - if ((error = signal_addition(entry_a, cb, data)) < 0) - goto exit; - if ((error = signal_deletion(entry_b, cb, data)) < 0) - goto exit; + if (signal_addition(entry_a, cb, data) < 0) + return -1; + if (signal_deletion(entry_b, cb, data) < 0) + return -1; } /* Otherwise consider it a modification */ - if ((error = signal_modification(entry_a, entry_b, cb, data)) < 0) - goto exit; + if (signal_modification(entry_a, entry_b, cb, data) < 0) + return -1; } else if (cmp < 0) { i_a++; - if ((error = signal_deletion(entry_a, cb, data)) < 0) - goto exit; + if (signal_deletion(entry_a, cb, data) < 0) + return -1; } else if (cmp > 0) { i_b++; - if ((error = signal_addition(entry_b, cb, data)) < 0) - goto exit; + if (signal_addition(entry_b, cb, data) < 0) + return -1; } } -exit: - return error; + return 0; } struct diff_index_cbdata { @@ -977,53 +966,49 @@ static int diff_index_cb(const char *root, git_tree_entry *tentry, void *data) git_index_entry *ientry = git_index_get(cbdata->index, cbdata->i); git_tree_entry fake_entry; git_buf fn_buf = GIT_BUF_INIT; - int cmp, error = GIT_SUCCESS; + int cmp; if (entry_is_tree(tentry)) - return GIT_SUCCESS; + return 0; + + if (!ientry) + return signal_deletion(tentry, cbdata->cb, cbdata->data); git_buf_puts(&fn_buf, root); git_buf_puts(&fn_buf, tentry->filename); - if (!ientry) { - error = signal_deletion(tentry, cbdata->cb, cbdata->data); - git_buf_free(&fn_buf); - goto exit; - } - /* Like with 'git diff-index', the index is the right side*/ cmp = strcmp(git_buf_cstr(&fn_buf), ientry->path); git_buf_free(&fn_buf); if (cmp == 0) { cbdata->i++; if (!cmp_tentry_ientry(tentry, ientry)) - goto exit; + return 0; /* modification */ make_tentry(&fake_entry, ientry); - if ((error = signal_modification(tentry, &fake_entry, cbdata->cb, cbdata->data)) < 0) - goto exit; + if (signal_modification(tentry, &fake_entry, cbdata->cb, cbdata->data) < 0) + return -1; } else if (cmp < 0) { /* deletion */ memcpy(&fake_entry, tentry, sizeof(git_tree_entry)); - if ((error = signal_deletion(tentry, cbdata->cb, cbdata->data)) < 0) - goto exit; + if (signal_deletion(tentry, cbdata->cb, cbdata->data) < 0) + return -1; } else { /* addition */ cbdata->i++; make_tentry(&fake_entry, ientry); - if ((error = signal_addition(&fake_entry, cbdata->cb, cbdata->data)) < 0) - goto exit; + if (signal_addition(&fake_entry, cbdata->cb, cbdata->data) < 0) + return -1; /* * The index has an addition. This means that we need to use * the next entry in the index without advancing the tree * walker, so call ourselves with the same tree state. */ - if ((error = diff_index_cb(root, tentry, data)) < 0) - goto exit; + if (diff_index_cb(root, tentry, data) < 0) + return -1;; } - exit: - return error; + return 0; } int git_tree_diff_index_recursive(git_tree *tree, git_index *index, git_tree_diff_cb cb, void *data) diff --git a/src/tree.h b/src/tree.h index 0bff41312..fd00afde5 100644 --- a/src/tree.h +++ b/src/tree.h @@ -32,7 +32,7 @@ struct git_treebuilder { GIT_INLINE(unsigned int) entry_is_tree(const struct git_tree_entry *e) { - return e->attr & 040000; + return (S_ISDIR(e->attr) && !S_ISGITLINK(e->attr)); } void git_tree__free(git_tree *tree); diff --git a/src/tsort.c b/src/tsort.c index 6fbec5b2a..f54c21e50 100644 --- a/src/tsort.c +++ b/src/tsort.c @@ -30,8 +30,10 @@ static int binsearch(void **dst, const void *x, size_t size, cmp_ptr_t cmp) int l, c, r; void *lx, *cx; + assert(size > 0); + l = 0; - r = size - 1; + r = (int)size - 1; c = r >> 1; lx = dst[l]; @@ -84,7 +86,7 @@ static void bisort(void **dst, size_t start, size_t size, cmp_ptr_t cmp) /* Else we need to find the right place, shift everything over, and squeeze in */ x = dst[i]; location = binsearch(dst, x, i, cmp); - for (j = i - 1; j >= location; j--) { + for (j = (int)i - 1; j >= location; j--) { dst[j + 1] = dst[j]; } dst[location] = x; @@ -104,7 +106,7 @@ struct tsort_store { void **storage; }; -static void reverse_elements(void **dst, int start, int end) +static void reverse_elements(void **dst, ssize_t start, ssize_t end) { while (start < end) { void *tmp = dst[start]; @@ -116,7 +118,7 @@ static void reverse_elements(void **dst, int start, int end) } } -static int count_run(void **dst, ssize_t start, ssize_t size, struct tsort_store *store) +static ssize_t count_run(void **dst, ssize_t start, ssize_t size, struct tsort_store *store) { ssize_t curr = start + 2; @@ -148,7 +150,7 @@ static int count_run(void **dst, ssize_t start, ssize_t size, struct tsort_store } } -static int compute_minrun(size_t n) +static size_t compute_minrun(size_t n) { int r = 0; while (n >= 64) { @@ -158,19 +160,19 @@ static int compute_minrun(size_t n) return n + r; } -static int check_invariant(struct tsort_run *stack, int stack_curr) +static int check_invariant(struct tsort_run *stack, ssize_t stack_curr) { if (stack_curr < 2) return 1; else if (stack_curr == 2) { - const int A = stack[stack_curr - 2].length; - const int B = stack[stack_curr - 1].length; + const ssize_t A = stack[stack_curr - 2].length; + const ssize_t B = stack[stack_curr - 1].length; return (A > B); } else { - const int A = stack[stack_curr - 3].length; - const int B = stack[stack_curr - 2].length; - const int C = stack[stack_curr - 1].length; + const ssize_t A = stack[stack_curr - 3].length; + const ssize_t B = stack[stack_curr - 2].length; + const ssize_t C = stack[stack_curr - 1].length; return !((A <= B + C) || (B <= C)); } } @@ -195,7 +197,7 @@ static int resize(struct tsort_store *store, size_t new_size) return 0; } -static void merge(void **dst, const struct tsort_run *stack, int stack_curr, struct tsort_store *store) +static void merge(void **dst, const struct tsort_run *stack, ssize_t stack_curr, struct tsort_store *store) { const ssize_t A = stack[stack_curr - 2].length; const ssize_t B = stack[stack_curr - 1].length; @@ -343,7 +345,7 @@ void git__tsort(void **dst, size_t size, cmp_ptr_t cmp) } /* compute the minimum run length */ - minrun = compute_minrun(size); + minrun = (ssize_t)compute_minrun(size); /* temporary storage for merges */ store->alloc = 0; diff --git a/src/unix/map.c b/src/unix/map.c index 67a73e43c..772f4e247 100644 --- a/src/unix/map.c +++ b/src/unix/map.c @@ -17,12 +17,7 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offs int mprot = 0; int mflag = 0; - assert((out != NULL) && (len > 0)); - - if ((out == NULL) || (len == 0)) { - errno = EINVAL; - return git__throw(GIT_ERROR, "Failed to mmap. No map or zero length"); - } + GIT_MMAP_VALIDATE(out, len, prot, flags); out->data = NULL; out->len = 0; @@ -31,39 +26,28 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offs mprot = PROT_WRITE; else if (prot & GIT_PROT_READ) mprot = PROT_READ; - else { - errno = EINVAL; - return git__throw(GIT_ERROR, "Failed to mmap. Invalid protection parameters"); - } if ((flags & GIT_MAP_TYPE) == GIT_MAP_SHARED) mflag = MAP_SHARED; else if ((flags & GIT_MAP_TYPE) == GIT_MAP_PRIVATE) mflag = MAP_PRIVATE; - if (flags & GIT_MAP_FIXED) { - errno = EINVAL; - return git__throw(GIT_ERROR, "Failed to mmap. FIXED not set"); + out->data = mmap(NULL, len, mprot, mflag, fd, offset); + if (!out->data || out->data == MAP_FAILED) { + giterr_set(GITERR_OS, "Failed to mmap. Could not write data"); + return -1; } - out->data = mmap(NULL, len, mprot, mflag, fd, offset); - if (!out->data || out->data == MAP_FAILED) - return git__throw(GIT_EOSERR, "Failed to mmap. Could not write data"); out->len = len; - return GIT_SUCCESS; + return 0; } int p_munmap(git_map *map) { assert(map != NULL); - - if (!map) - return git__throw(GIT_ERROR, "Failed to munmap. Map does not exist"); - munmap(map->data, map->len); - - return GIT_SUCCESS; + return 0; } #endif diff --git a/src/util.c b/src/util.c index 1fb01170b..20a627ea8 100644 --- a/src/util.c +++ b/src/util.c @@ -31,19 +31,33 @@ void git_strarray_free(git_strarray *array) git__free(array->strings); } -int git__fnmatch(const char *pattern, const char *name, int flags) +int git_strarray_copy(git_strarray *tgt, const git_strarray *src) { - int ret; + size_t i; - ret = p_fnmatch(pattern, name, flags); - switch (ret) { - case 0: - return GIT_SUCCESS; - case FNM_NOMATCH: - return GIT_ENOMATCH; - default: - return git__throw(GIT_EOSERR, "Error trying to match path"); + assert(tgt && src); + + memset(tgt, 0, sizeof(*tgt)); + + if (!src->count) + return 0; + + tgt->strings = git__calloc(src->count, sizeof(char *)); + GITERR_CHECK_ALLOC(tgt->strings); + + for (i = 0; i < src->count; ++i) { + tgt->strings[tgt->count] = git__strdup(src->strings[i]); + + if (!tgt->strings[tgt->count]) { + git_strarray_free(tgt); + memset(tgt, 0, sizeof(*tgt)); + return -1; + } + + tgt->count++; } + + return 0; } int git__strtol64(int64_t *result, const char *nptr, const char **endptr, int base) @@ -111,34 +125,40 @@ int git__strtol64(int64_t *result, const char *nptr, const char **endptr, int ba } Return: - if (ndig == 0) - return git__throw(GIT_ENOTNUM, "Failed to convert string to long. Not a number"); + if (ndig == 0) { + giterr_set(GITERR_INVALID, "Failed to convert string to long. Not a number"); + return -1; + } if (endptr) *endptr = p; - if (ovfl) - return git__throw(GIT_EOVERFLOW, "Failed to convert string to long. Overflow error"); + if (ovfl) { + giterr_set(GITERR_INVALID, "Failed to convert string to long. Overflow error"); + return -1; + } *result = neg ? -n : n; - return GIT_SUCCESS; + return 0; } int git__strtol32(int32_t *result, const char *nptr, const char **endptr, int base) { - int error = GIT_SUCCESS; + int error; int32_t tmp_int; int64_t tmp_long; - if ((error = git__strtol64(&tmp_long, nptr, endptr, base)) < GIT_SUCCESS) + if ((error = git__strtol64(&tmp_long, nptr, endptr, base)) < 0) return error; tmp_int = tmp_long & 0xFFFFFFFF; - if (tmp_int != tmp_long) - return git__throw(GIT_EOVERFLOW, "Failed to convert. '%s' is too large", nptr); + if (tmp_int != tmp_long) { + giterr_set(GITERR_INVALID, "Failed to convert. '%s' is too large", nptr); + return -1; + } *result = tmp_int; - + return error; } @@ -355,23 +375,27 @@ int git__bsearch( int (*compare)(const void *, const void *), size_t *position) { - int lim, cmp; + unsigned int lim; + int cmp = -1; void **part, **base = array; - for (lim = array_len; lim != 0; lim >>= 1) { + for (lim = (unsigned int)array_len; lim != 0; lim >>= 1) { part = base + (lim >> 1); cmp = (*compare)(key, *part); if (cmp == 0) { - *position = (part - array); - return GIT_SUCCESS; - } else if (cmp > 0) { /* key > p; take right partition */ + base = part; + break; + } + if (cmp > 0) { /* key > p; take right partition */ base = part + 1; lim--; } /* else take left partition */ } - *position = (base - array); - return GIT_ENOTFOUND; + if (position) + *position = (base - array); + + return (cmp == 0) ? 0 : -1; } /** diff --git a/src/util.h b/src/util.h index f77c91dfd..a76800141 100644 --- a/src/util.h +++ b/src/util.h @@ -22,24 +22,21 @@ GIT_INLINE(void *) git__malloc(size_t len) { void *ptr = malloc(len); - if (!ptr) - git__throw(GIT_ENOMEM, "Out of memory. Failed to allocate %d bytes.", (int)len); + if (!ptr) giterr_set_oom(); return ptr; } GIT_INLINE(void *) git__calloc(size_t nelem, size_t elsize) { void *ptr = calloc(nelem, elsize); - if (!ptr) - git__throw(GIT_ENOMEM, "Out of memory. Failed to allocate %d bytes.", (int)elsize); + if (!ptr) giterr_set_oom(); return ptr; } GIT_INLINE(char *) git__strdup(const char *str) { char *ptr = strdup(str); - if (!ptr) - git__throw(GIT_ENOMEM, "Out of memory. Failed to duplicate string"); + if (!ptr) giterr_set_oom(); return ptr; } @@ -54,7 +51,7 @@ GIT_INLINE(char *) git__strndup(const char *str, size_t n) ptr = (char*)malloc(length + 1); if (!ptr) { - git__throw(GIT_ENOMEM, "Out of memory. Failed to duplicate string"); + giterr_set_oom(); return NULL; } @@ -67,8 +64,7 @@ GIT_INLINE(char *) git__strndup(const char *str, size_t n) GIT_INLINE(void *) git__realloc(void *ptr, size_t size) { void *new_ptr = realloc(ptr, size); - if (!new_ptr) - git__throw(GIT_ENOMEM, "Out of memory. Failed to allocate %d bytes.", (int)size); + if (!new_ptr) giterr_set_oom(); return new_ptr; } @@ -109,10 +105,13 @@ GIT_INLINE(const char *) git__next_line(const char *s) return s; } -extern int git__fnmatch(const char *pattern, const char *name, int flags); - extern void git__tsort(void **dst, size_t size, int (*cmp)(const void *, const void *)); +/** + * @param position If non-NULL, this will be set to the position where the + * element is or would be inserted if not found. + * @return pos (>=0) if found or -1 if not found + */ extern int git__bsearch( void **array, size_t array_len, @@ -178,4 +177,21 @@ GIT_INLINE(int) git__ishex(const char *str) return 1; } +GIT_INLINE(size_t) git__size_t_bitmask(size_t v) +{ + v--; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + + return v; +} + +GIT_INLINE(size_t) git__size_t_powerof2(size_t v) +{ + return git__size_t_bitmask(v) + 1; +} + #endif /* INCLUDE_util_h__ */ diff --git a/src/vector.c b/src/vector.c index 7513ea3f0..304f324f0 100644 --- a/src/vector.c +++ b/src/vector.c @@ -10,7 +10,7 @@ #include "vector.h" static const double resize_factor = 1.75; -static const size_t minimum_size = 8; +static const unsigned int minimum_size = 8; static int resize_vector(git_vector *v) { @@ -19,10 +19,9 @@ static int resize_vector(git_vector *v) v->_alloc_size = minimum_size; v->contents = git__realloc(v->contents, v->_alloc_size * sizeof(void *)); - if (v->contents == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(v->contents); - return GIT_SUCCESS; + return 0; } void git_vector_free(git_vector *v) @@ -52,30 +51,29 @@ int git_vector_init(git_vector *v, unsigned int initial_size, git_vector_cmp cmp v->sorted = 1; v->contents = git__malloc(v->_alloc_size * sizeof(void *)); - if (v->contents == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(v->contents); - return GIT_SUCCESS; + return 0; } int git_vector_insert(git_vector *v, void *element) { assert(v); - if (v->length >= v->_alloc_size) { - if (resize_vector(v) < 0) - return GIT_ENOMEM; - } + if (v->length >= v->_alloc_size && + resize_vector(v) < 0) + return -1; v->contents[v->length++] = element; v->sorted = 0; - return GIT_SUCCESS; + return 0; } -int git_vector_insert_sorted(git_vector *v, void *element, int (*on_dup)(void **old, void *new)) +int git_vector_insert_sorted( + git_vector *v, void *element, int (*on_dup)(void **old, void *new)) { - int error = GIT_SUCCESS; + int result; size_t pos; assert(v && v->_cmp); @@ -83,22 +81,18 @@ int git_vector_insert_sorted(git_vector *v, void *element, int (*on_dup)(void ** if (!v->sorted) git_vector_sort(v); - if (v->length >= v->_alloc_size) { - if (resize_vector(v) < 0) - return GIT_ENOMEM; - } + if (v->length >= v->_alloc_size && + resize_vector(v) < 0) + return -1; - error = git__bsearch(v->contents, v->length, element, v->_cmp, &pos); - - /* If we found the element and have a duplicate handler callback, - * invoke it. If it returns an error, then cancel insert, otherwise + /* If we find the element and have a duplicate handler callback, + * invoke it. If it returns non-zero, then cancel insert, otherwise * proceed with normal insert. */ - if (error == GIT_SUCCESS && on_dup != NULL) { - error = on_dup(&v->contents[pos], element); - if (error != GIT_SUCCESS) - return error; - } + if (git__bsearch(v->contents, v->length, element, v->_cmp, &pos) >= 0 && + on_dup != NULL && + (result = on_dup(&v->contents[pos], element)) < 0) + return result; /* shift elements to the right */ if (pos < v->length) { @@ -108,8 +102,7 @@ int git_vector_insert_sorted(git_vector *v, void *element, int (*on_dup)(void ** v->contents[pos] = element; v->length++; - - return GIT_SUCCESS; + return 0; } void git_vector_sort(git_vector *v) @@ -130,16 +123,14 @@ int git_vector_bsearch2(git_vector *v, git_vector_cmp key_lookup, const void *ke assert(v && key && key_lookup); /* need comparison function to sort the vector */ - if (v->_cmp == NULL) - return git__throw(GIT_ENOTFOUND, "Can't sort vector. No comparison function set"); + assert(v->_cmp != NULL); git_vector_sort(v); - if (git__bsearch(v->contents, v->length, key, key_lookup, - &pos) == GIT_SUCCESS) + if (git__bsearch(v->contents, v->length, key, key_lookup, &pos) >= 0) return (int)pos; - return git__throw(GIT_ENOTFOUND, "Can't find element"); + return GIT_ENOTFOUND; } int git_vector_search2(git_vector *v, git_vector_cmp key_lookup, const void *key) @@ -153,7 +144,7 @@ int git_vector_search2(git_vector *v, git_vector_cmp key_lookup, const void *key return i; } - return git__throw(GIT_ENOTFOUND, "Can't find element"); + return GIT_ENOTFOUND; } static int strict_comparison(const void *a, const void *b) @@ -178,13 +169,13 @@ int git_vector_remove(git_vector *v, unsigned int idx) assert(v); if (idx >= v->length || v->length == 0) - return git__throw(GIT_ENOTFOUND, "Can't remove element. Index out of bounds"); + return GIT_ENOTFOUND; for (i = idx; i < v->length - 1; ++i) v->contents[i] = v->contents[i + 1]; v->length--; - return GIT_SUCCESS; + return 0; } void git_vector_pop(git_vector *v) diff --git a/src/vector.h b/src/vector.h index 180edbf7c..5bc27914a 100644 --- a/src/vector.h +++ b/src/vector.h @@ -44,6 +44,8 @@ GIT_INLINE(const void *) git_vector_get_const(const git_vector *v, unsigned int return (position < v->length) ? v->contents[position] : NULL; } +#define GIT_VECTOR_GET(V,I) ((I) < (V)->length ? (V)->contents[(I)] : NULL) + GIT_INLINE(void *) git_vector_last(git_vector *v) { return (v->length > 0) ? git_vector_get(v, v->length - 1) : NULL; diff --git a/src/win32/dir.c b/src/win32/dir.c index 035e2b685..bc3d40fa5 100644 --- a/src/win32/dir.c +++ b/src/win32/dir.c @@ -27,8 +27,8 @@ static int init_filter(char *filter, size_t n, const char *dir) git__DIR *git__opendir(const char *dir) { char filter[4096]; - wchar_t* filter_w; - git__DIR *new; + wchar_t* filter_w = NULL; + git__DIR *new = NULL; if (!dir || !init_filter(filter, sizeof(filter), dir)) return NULL; @@ -37,25 +37,29 @@ git__DIR *git__opendir(const char *dir) if (!new) return NULL; - new->dir = git__malloc(strlen(dir)+1); - if (!new->dir) { - git__free(new); - return NULL; - } - strcpy(new->dir, dir); + new->dir = git__strdup(dir); + if (!new->dir) + goto fail; filter_w = gitwin_to_utf16(filter); + if (!filter_w) + goto fail; + new->h = FindFirstFileW(filter_w, &new->f); git__free(filter_w); if (new->h == INVALID_HANDLE_VALUE) { - git__free(new->dir); - git__free(new); - return NULL; + giterr_set(GITERR_OS, "Could not open directory '%s'", dir); + goto fail; } - new->first = 1; + new->first = 1; return new; + +fail: + git__free(new->dir); + git__free(new); + return NULL; } int git__readdir_ext( @@ -67,22 +71,32 @@ int git__readdir_ext( if (!d || !entry || !result || d->h == INVALID_HANDLE_VALUE) return -1; + *result = NULL; + if (d->first) d->first = 0; else if (!FindNextFileW(d->h, &d->f)) { - *result = NULL; - return 0; + if (GetLastError() == ERROR_NO_MORE_FILES) + return 0; + giterr_set(GITERR_OS, "Could not read from directory '%s'", d->dir); + return -1; } if (wcslen(d->f.cFileName) >= sizeof(entry->d_name)) return -1; entry->d_ino = 0; - WideCharToMultiByte( + + if (WideCharToMultiByte( gitwin_get_codepage(), 0, d->f.cFileName, -1, - entry->d_name, GIT_PATH_MAX, NULL, NULL); + entry->d_name, GIT_PATH_MAX, NULL, NULL) == 0) + { + giterr_set(GITERR_OS, "Could not convert filename to UTF-8"); + return -1; + } *result = entry; + if (is_dir != NULL) *is_dir = ((d->f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0); @@ -102,32 +116,40 @@ void git__rewinddir(git__DIR *d) char filter[4096]; wchar_t* filter_w; - if (d) { - if (d->h != INVALID_HANDLE_VALUE) - FindClose(d->h); + if (!d) + return; + + if (d->h != INVALID_HANDLE_VALUE) { + FindClose(d->h); d->h = INVALID_HANDLE_VALUE; d->first = 0; - - if (init_filter(filter, sizeof(filter), d->dir)) { - filter_w = gitwin_to_utf16(filter); - d->h = FindFirstFileW(filter_w, &d->f); - git__free(filter_w); - - if (d->h != INVALID_HANDLE_VALUE) - d->first = 1; - } } + + if (!init_filter(filter, sizeof(filter), d->dir) || + (filter_w = gitwin_to_utf16(filter)) == NULL) + return; + + d->h = FindFirstFileW(filter_w, &d->f); + git__free(filter_w); + + if (d->h == INVALID_HANDLE_VALUE) + giterr_set(GITERR_OS, "Could not open directory '%s'", d->dir); + else + d->first = 1; } int git__closedir(git__DIR *d) { - if (d) { - if (d->h != INVALID_HANDLE_VALUE) - FindClose(d->h); - if (d->dir) - git__free(d->dir); - git__free(d); + if (!d) + return 0; + + if (d->h != INVALID_HANDLE_VALUE) { + FindClose(d->h); + d->h = INVALID_HANDLE_VALUE; } + git__free(d->dir); + d->dir = NULL; + git__free(d); return 0; } diff --git a/src/win32/map.c b/src/win32/map.c index 60adf0f94..f730120cc 100644 --- a/src/win32/map.c +++ b/src/win32/map.c @@ -33,12 +33,7 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offs git_off_t page_start; git_off_t page_offset; - assert((out != NULL) && (len > 0)); - - if ((out == NULL) || (len == 0)) { - errno = EINVAL; - return git__throw(GIT_ERROR, "Failed to mmap. No map or zero length"); - } + GIT_MMAP_VALIDATE(out, len, prot, flags); out->data = NULL; out->len = 0; @@ -46,86 +41,75 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offs if (fh == INVALID_HANDLE_VALUE) { errno = EBADF; - return git__throw(GIT_ERROR, "Failed to mmap. Invalid handle value"); + giterr_set(GITERR_OS, "Failed to mmap. Invalid handle value"); + return -1; } if (prot & GIT_PROT_WRITE) fmap_prot |= PAGE_READWRITE; else if (prot & GIT_PROT_READ) fmap_prot |= PAGE_READONLY; - else { - errno = EINVAL; - return git__throw(GIT_ERROR, "Failed to mmap. Invalid protection parameters"); - } if (prot & GIT_PROT_WRITE) view_prot |= FILE_MAP_WRITE; if (prot & GIT_PROT_READ) view_prot |= FILE_MAP_READ; - if (flags & GIT_MAP_FIXED) { - errno = EINVAL; - return git__throw(GIT_ERROR, "Failed to mmap. FIXED not set"); - } - page_start = (offset / page_size) * page_size; page_offset = offset - page_start; if (page_offset != 0) { /* offset must be multiple of page size */ errno = EINVAL; - return git__throw(GIT_ERROR, "Failed to mmap. Offset must be multiple of page size"); + giterr_set(GITERR_OS, "Failed to mmap. Offset must be multiple of page size"); + return -1; } out->fmh = CreateFileMapping(fh, NULL, fmap_prot, 0, 0, NULL); if (!out->fmh || out->fmh == INVALID_HANDLE_VALUE) { - /* errno = ? */ + giterr_set(GITERR_OS, "Failed to mmap. Invalid handle value"); out->fmh = NULL; - return git__throw(GIT_ERROR, "Failed to mmap. Invalid handle value"); + return -1; } assert(sizeof(git_off_t) == 8); + off_low = (DWORD)(page_start); off_hi = (DWORD)(page_start >> 32); out->data = MapViewOfFile(out->fmh, view_prot, off_hi, off_low, len); if (!out->data) { - /* errno = ? */ + giterr_set(GITERR_OS, "Failed to mmap. No data written"); CloseHandle(out->fmh); out->fmh = NULL; - return git__throw(GIT_ERROR, "Failed to mmap. No data written"); + return -1; } out->len = len; - return GIT_SUCCESS; + return 0; } int p_munmap(git_map *map) { - assert(map != NULL); + int error = 0; - if (!map) - return git__throw(GIT_ERROR, "Failed to munmap. Map does not exist"); + assert(map != NULL); if (map->data) { if (!UnmapViewOfFile(map->data)) { - /* errno = ? */ - CloseHandle(map->fmh); - map->data = NULL; - map->fmh = NULL; - return git__throw(GIT_ERROR, "Failed to munmap. Could not unmap view of file"); + giterr_set(GITERR_OS, "Failed to munmap. Could not unmap view of file"); + error = -1; } map->data = NULL; } if (map->fmh) { if (!CloseHandle(map->fmh)) { - /* errno = ? */ - map->fmh = NULL; - return git__throw(GIT_ERROR, "Failed to munmap. Could not close handle"); + giterr_set(GITERR_OS, "Failed to munmap. Could not close handle"); + error = -1; } map->fmh = NULL; } - return GIT_SUCCESS; + return error; } diff --git a/src/win32/posix.h b/src/win32/posix.h index 60adc9666..d13d3e39b 100644 --- a/src/win32/posix.h +++ b/src/win32/posix.h @@ -49,5 +49,7 @@ extern int p_open(const char *path, int flags); extern int p_creat(const char *path, mode_t mode); extern int p_getcwd(char *buffer_out, size_t size); extern int p_rename(const char *from, const char *to); +extern int p_recv(GIT_SOCKET socket, void *buffer, size_t length, int flags); +extern int p_send(GIT_SOCKET socket, const void *buffer, size_t length, int flags); #endif diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c index 91585aeae..8af664165 100644 --- a/src/win32/posix_w32.c +++ b/src/win32/posix_w32.c @@ -4,7 +4,7 @@ * This file is part of libgit2, distributed under the GNU GPL v2 with * a Linking Exception. For full terms see the included COPYING file. */ -#include "posix.h" +#include "../posix.h" #include "path.h" #include "utf-conv.h" #include @@ -17,10 +17,11 @@ int p_unlink(const char *path) int ret = 0; wchar_t* buf; - buf = gitwin_to_utf16(path); - _wchmod(buf, 0666); - ret = _wunlink(buf); - git__free(buf); + if ((buf = gitwin_to_utf16(path)) != NULL) { + _wchmod(buf, 0666); + ret = _wunlink(buf); + git__free(buf); + } return ret; } @@ -60,6 +61,8 @@ static int do_lstat(const char *file_name, struct stat *buf) { WIN32_FILE_ATTRIBUTE_DATA fdata; wchar_t* fbuf = gitwin_to_utf16(file_name); + if (!fbuf) + return -1; if (GetFileAttributesExW(fbuf, GetFileExInfoStandard, &fdata)) { int fMode = S_IREAD; @@ -87,54 +90,43 @@ static int do_lstat(const char *file_name, struct stat *buf) buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime)); git__free(fbuf); - return GIT_SUCCESS; + return 0; } git__free(fbuf); - - switch (GetLastError()) { - case ERROR_ACCESS_DENIED: - case ERROR_SHARING_VIOLATION: - case ERROR_LOCK_VIOLATION: - case ERROR_SHARING_BUFFER_EXCEEDED: - return GIT_EOSERR; - - case ERROR_BUFFER_OVERFLOW: - case ERROR_NOT_ENOUGH_MEMORY: - return GIT_ENOMEM; - - default: - return GIT_EINVALIDPATH; - } + return -1; } int p_lstat(const char *file_name, struct stat *buf) { - int namelen, error; - char alt_name[GIT_PATH_MAX]; + int error; + size_t namelen; + char *alt_name; - if ((error = do_lstat(file_name, buf)) == GIT_SUCCESS) - return GIT_SUCCESS; + if (do_lstat(file_name, buf) == 0) + return 0; /* if file_name ended in a '/', Windows returned ENOENT; * try again without trailing slashes */ - if (error != GIT_EINVALIDPATH) - return git__throw(GIT_EOSERR, "Failed to lstat file"); - namelen = strlen(file_name); if (namelen && file_name[namelen-1] != '/') - return git__throw(GIT_EOSERR, "Failed to lstat file"); + return -1; while (namelen && file_name[namelen-1] == '/') --namelen; - if (!namelen || namelen >= GIT_PATH_MAX) - return git__throw(GIT_ENOMEM, "Failed to lstat file"); + if (!namelen) + return -1; - memcpy(alt_name, file_name, namelen); - alt_name[namelen] = 0; - return do_lstat(alt_name, buf); + alt_name = git__strndup(file_name, namelen); + if (!alt_name) + return -1; + + error = do_lstat(alt_name, buf); + + git__free(alt_name); + return error; } int p_readlink(const char *link, char *target, size_t target_len) @@ -145,6 +137,9 @@ int p_readlink(const char *link, char *target, size_t target_len) DWORD dwRet; wchar_t* link_w; wchar_t* target_w; + int error = 0; + + assert(link && target && target_len > 0); /* * Try to load the pointer to pGetFinalPath dynamically, because @@ -156,12 +151,15 @@ int p_readlink(const char *link, char *target, size_t target_len) if (library != NULL) pGetFinalPath = (fpath_func)GetProcAddress(library, "GetFinalPathNameByHandleW"); - if (pGetFinalPath == NULL) - return git__throw(GIT_EOSERR, + if (pGetFinalPath == NULL) { + giterr_set(GITERR_OS, "'GetFinalPathNameByHandleW' is not available in this platform"); + return -1; + } } link_w = gitwin_to_utf16(link); + GITERR_CHECK_ALLOC(link_w); hFile = CreateFileW(link_w, // file to open GENERIC_READ, // open for reading @@ -173,50 +171,49 @@ int p_readlink(const char *link, char *target, size_t target_len) git__free(link_w); - if (hFile == INVALID_HANDLE_VALUE) - return GIT_EOSERR; - - if (target_len <= 0) { - return GIT_EINVALIDARGS; + if (hFile == INVALID_HANDLE_VALUE) { + giterr_set(GITERR_OS, "Cannot open '%s' for reading", link); + return -1; } target_w = (wchar_t*)git__malloc(target_len * sizeof(wchar_t)); + GITERR_CHECK_ALLOC(target_w); - dwRet = pGetFinalPath(hFile, target_w, target_len, 0x0); - if (dwRet >= target_len) { - git__free(target_w); - CloseHandle(hFile); - return GIT_ENOMEM; - } - - if (!WideCharToMultiByte(CP_UTF8, 0, target_w, -1, target, target_len * sizeof(char), NULL, NULL)) { - git__free(target_w); - return GIT_EOSERR; - } + dwRet = pGetFinalPath(hFile, target_w, (DWORD)target_len, 0x0); + if (dwRet == 0 || + dwRet >= target_len || + !WideCharToMultiByte(CP_UTF8, 0, target_w, -1, target, + (int)(target_len * sizeof(char)), NULL, NULL)) + error = -1; git__free(target_w); CloseHandle(hFile); - if (dwRet > 4) { - /* Skip first 4 characters if they are "\\?\" */ - if (target[0] == '\\' && target[1] == '\\' && target[2] == '?' && target[3] == '\\') { - char tmp[GIT_PATH_MAX]; - unsigned int offset = 4; - dwRet -= 4; + if (error) + return error; - /* \??\UNC\ */ - if (dwRet > 7 && target[4] == 'U' && target[5] == 'N' && target[6] == 'C') { - offset += 2; - dwRet -= 2; - target[offset] = '\\'; - } + /* Skip first 4 characters if they are "\\?\" */ + if (dwRet > 4 && + target[0] == '\\' && target[1] == '\\' && + target[2] == '?' && target[3] == '\\') + { + unsigned int offset = 4; + dwRet -= 4; - memcpy(tmp, target + offset, dwRet); - memcpy(target, tmp, dwRet); + /* \??\UNC\ */ + if (dwRet > 7 && + target[4] == 'U' && target[5] == 'N' && target[6] == 'C') + { + offset += 2; + dwRet -= 2; + target[offset] = '\\'; } + + memmove(target, target + offset, dwRet); } target[dwRet] = '\0'; + return dwRet; } @@ -224,8 +221,9 @@ int p_open(const char *path, int flags) { int fd; wchar_t* buf = gitwin_to_utf16(path); + if (!buf) + return -1; fd = _wopen(buf, flags | _O_BINARY); - git__free(buf); return fd; } @@ -234,24 +232,31 @@ int p_creat(const char *path, mode_t mode) { int fd; wchar_t* buf = gitwin_to_utf16(path); + if (!buf) + return -1; fd = _wopen(buf, _O_WRONLY | _O_CREAT | _O_TRUNC | _O_BINARY, mode); - git__free(buf); return fd; } int p_getcwd(char *buffer_out, size_t size) { - wchar_t* buf = (wchar_t*)git__malloc(sizeof(wchar_t) * (int)size); + int ret; + wchar_t* buf; + + if ((size_t)((int)size) != size) + return -1; + + buf = (wchar_t*)git__malloc(sizeof(wchar_t) * (int)size); + GITERR_CHECK_ALLOC(buf); + _wgetcwd(buf, (int)size); - if (!WideCharToMultiByte(CP_UTF8, 0, buf, -1, buffer_out, size, NULL, NULL)) { - git__free(buf); - return GIT_EOSERR; - } + ret = WideCharToMultiByte( + CP_UTF8, 0, buf, -1, buffer_out, (int)size, NULL, NULL); git__free(buf); - return GIT_SUCCESS; + return !ret ? -1 : 0; } int p_stat(const char* path, struct stat* buf) @@ -262,8 +267,10 @@ int p_stat(const char* path, struct stat* buf) int p_chdir(const char* path) { wchar_t* buf = gitwin_to_utf16(path); - int ret = _wchdir(buf); - + int ret; + if (!buf) + return -1; + ret = _wchdir(buf); git__free(buf); return ret; } @@ -271,8 +278,10 @@ int p_chdir(const char* path) int p_chmod(const char* path, mode_t mode) { wchar_t* buf = gitwin_to_utf16(path); - int ret = _wchmod(buf, mode); - + int ret; + if (!buf) + return -1; + ret = _wchmod(buf, mode); git__free(buf); return ret; } @@ -280,26 +289,25 @@ int p_chmod(const char* path, mode_t mode) int p_rmdir(const char* path) { wchar_t* buf = gitwin_to_utf16(path); - int ret = _wrmdir(buf); - + int ret; + if (!buf) + return -1; + ret = _wrmdir(buf); git__free(buf); return ret; } int p_hide_directory__w32(const char *path) { - int error; + int res; wchar_t* buf = gitwin_to_utf16(path); + if (!buf) + return -1; - error = SetFileAttributesW(buf, FILE_ATTRIBUTE_HIDDEN) != 0 ? - GIT_SUCCESS : GIT_ERROR; /* MSDN states a "non zero" value indicates a success */ - + res = SetFileAttributesW(buf, FILE_ATTRIBUTE_HIDDEN); git__free(buf); - if (error < GIT_SUCCESS) - error = git__throw(GIT_EOSERR, "Failed to hide directory '%s'", path); - - return error; + return (res != 0) ? 0 : -1; /* MSDN states a "non zero" value indicates a success */ } char *p_realpath(const char *orig_path, char *buffer) @@ -308,6 +316,9 @@ char *p_realpath(const char *orig_path, char *buffer) wchar_t* orig_path_w = gitwin_to_utf16(orig_path); wchar_t* buffer_w = (wchar_t*)git__malloc(GIT_PATH_MAX * sizeof(wchar_t)); + if (!orig_path_w || !buffer_w) + return NULL; + ret = GetFullPathNameW(orig_path_w, GIT_PATH_MAX, buffer_w, NULL); git__free(orig_path_w); @@ -341,8 +352,12 @@ done: int p_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr) { #ifdef _MSC_VER - int len = _vsnprintf(buffer, count, format, argptr); - return (len < 0) ? _vscprintf(format, argptr) : len; + int len; + + if (count == 0 || (len = _vsnprintf(buffer, count, format, argptr)) < 0) + return _vscprintf(format, argptr); + + return len; #else /* MinGW */ return vsnprintf(buffer, count, format, argptr); #endif @@ -366,10 +381,10 @@ int p_mkstemp(char *tmp_path) { #if defined(_MSC_VER) if (_mktemp_s(tmp_path, strlen(tmp_path) + 1) != 0) - return GIT_EOSERR; + return -1; #else if (_mktemp(tmp_path) == NULL) - return GIT_EOSERR; + return -1; #endif return p_creat(tmp_path, 0744); @@ -378,15 +393,17 @@ int p_mkstemp(char *tmp_path) int p_setenv(const char* name, const char* value, int overwrite) { if (overwrite != 1) - return EINVAL; + return -1; - return (SetEnvironmentVariableA(name, value) == 0 ? GIT_EOSERR : GIT_SUCCESS); + return (SetEnvironmentVariableA(name, value) == 0 ? -1 : 0); } int p_access(const char* path, mode_t mode) { wchar_t *buf = gitwin_to_utf16(path); int ret; + if (!buf) + return -1; ret = _waccess(buf, mode); git__free(buf); @@ -394,16 +411,35 @@ int p_access(const char* path, mode_t mode) return ret; } -extern int p_rename(const char *from, const char *to) +int p_rename(const char *from, const char *to) { wchar_t *wfrom = gitwin_to_utf16(from); wchar_t *wto = gitwin_to_utf16(to); int ret; - ret = MoveFileExW(wfrom, wto, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) ? GIT_SUCCESS : GIT_EOSERR; + if (!wfrom || !wto) + return -1; + + ret = MoveFileExW(wfrom, wto, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) ? 0 : -1; git__free(wfrom); git__free(wto); return ret; } + +int p_recv(GIT_SOCKET socket, void *buffer, size_t length, int flags) +{ + if ((size_t)((int)length) != length) + return -1; /* giterr_set will be done by caller */ + + return recv(socket, buffer, (int)length, flags); +} + +int p_send(GIT_SOCKET socket, const void *buffer, size_t length, int flags) +{ + if ((size_t)((int)length) != length) + return -1; /* giterr_set will be done by caller */ + + return send(socket, buffer, (int)length, flags); +} diff --git a/src/win32/pthread.c b/src/win32/pthread.c index 3db536848..3a186c8d9 100644 --- a/src/win32/pthread.c +++ b/src/win32/pthread.c @@ -7,13 +7,16 @@ #include "pthread.h" -int pthread_create(pthread_t *GIT_RESTRICT thread, - const pthread_attr_t *GIT_RESTRICT attr, - void *(*start_routine)(void*), void *GIT_RESTRICT arg) +int pthread_create( + pthread_t *GIT_RESTRICT thread, + const pthread_attr_t *GIT_RESTRICT attr, + void *(*start_routine)(void*), + void *GIT_RESTRICT arg) { GIT_UNUSED(attr); - *thread = (pthread_t) CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)start_routine, arg, 0, NULL); - return *thread ? GIT_SUCCESS : git__throw(GIT_EOSERR, "Failed to create pthread"); + *thread = (pthread_t) CreateThread( + NULL, 0, (LPTHREAD_START_ROUTINE)start_routine, arg, 0, NULL); + return *thread ? 0 : -1; } int pthread_join(pthread_t thread, void **value_ptr) diff --git a/src/win32/utf-conv.c b/src/win32/utf-conv.c index 3c8be81d1..fbcb69d0a 100644 --- a/src/win32/utf-conv.c +++ b/src/win32/utf-conv.c @@ -31,25 +31,24 @@ void gitwin_set_utf8(void) wchar_t* gitwin_to_utf16(const char* str) { wchar_t* ret; - int cb; + size_t cb; - if (!str) { + if (!str) return NULL; - } cb = strlen(str) * sizeof(wchar_t); - if (cb == 0) { - ret = (wchar_t*)git__malloc(sizeof(wchar_t)); - ret[0] = 0; - return ret; - } + if (cb == 0) + return (wchar_t *)git__calloc(1, sizeof(wchar_t)); /* Add space for null terminator */ cb += sizeof(wchar_t); - ret = (wchar_t*)git__malloc(cb); + ret = (wchar_t *)git__malloc(cb); + if (!ret) + return NULL; - if (MultiByteToWideChar(_active_codepage, 0, str, -1, ret, cb) == 0) { + if (MultiByteToWideChar(_active_codepage, 0, str, -1, ret, (int)cb) == 0) { + giterr_set(GITERR_OS, "Could not convert string to UTF-16"); git__free(ret); ret = NULL; } @@ -59,31 +58,33 @@ wchar_t* gitwin_to_utf16(const char* str) int gitwin_append_utf16(wchar_t *buffer, const char *str, size_t len) { - return MultiByteToWideChar(_active_codepage, 0, str, -1, buffer, len); + int result = MultiByteToWideChar(_active_codepage, 0, str, -1, buffer, (int)len); + if (result == 0) + giterr_set(GITERR_OS, "Could not convert string to UTF-16"); + return result; } char* gitwin_from_utf16(const wchar_t* str) { char* ret; - int cb; + size_t cb; - if (!str) { + if (!str) return NULL; - } cb = wcslen(str) * sizeof(char); - if (cb == 0) { - ret = (char*)git__malloc(sizeof(char)); - ret[0] = 0; - return ret; - } + if (cb == 0) + return (char *)git__calloc(1, sizeof(char)); /* Add space for null terminator */ cb += sizeof(char); ret = (char*)git__malloc(cb); + if (!ret) + return NULL; - if (WideCharToMultiByte(_active_codepage, 0, str, -1, ret, cb, NULL, NULL) == 0) { + if (WideCharToMultiByte(_active_codepage, 0, str, -1, ret, (int)cb, NULL, NULL) == 0) { + giterr_set(GITERR_OS, "Could not convert string to UTF-8"); git__free(ret); ret = NULL; } diff --git a/src/xdiff/xemit.c b/src/xdiff/xemit.c index 8b7d417a1..e3e63d902 100644 --- a/src/xdiff/xemit.c +++ b/src/xdiff/xemit.c @@ -40,7 +40,7 @@ static long xdl_get_rec(xdfile_t *xdf, long ri, char const **rec) { static int xdl_emit_record(xdfile_t *xdf, long ri, char const *pre, xdemitcb_t *ecb) { - long size, psize = strlen(pre); + long size, psize = (long)strlen(pre); char const *rec; size = xdl_get_rec(xdf, ri, &rec); diff --git a/src/xdiff/xmerge.c b/src/xdiff/xmerge.c index 9e13b25ab..84e424672 100644 --- a/src/xdiff/xmerge.c +++ b/src/xdiff/xmerge.c @@ -149,9 +149,9 @@ static int fill_conflict_hunk(xdfenv_t *xe1, const char *name1, int size, int i, int style, xdmerge_t *m, char *dest, int marker_size) { - int marker1_size = (name1 ? strlen(name1) + 1 : 0); - int marker2_size = (name2 ? strlen(name2) + 1 : 0); - int marker3_size = (name3 ? strlen(name3) + 1 : 0); + int marker1_size = (name1 ? (int)strlen(name1) + 1 : 0); + int marker2_size = (name2 ? (int)strlen(name2) + 1 : 0); + int marker3_size = (name3 ? (int)strlen(name3) + 1 : 0); if (marker_size <= 0) marker_size = DEFAULT_CONFLICT_MARKER_SIZE; diff --git a/src/xdiff/xutils.c b/src/xdiff/xutils.c index 9dea04bba..bb7bdee49 100644 --- a/src/xdiff/xutils.c +++ b/src/xdiff/xutils.c @@ -62,14 +62,14 @@ int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize, void *xdl_mmfile_first(mmfile_t *mmf, long *size) { - *size = mmf->size; + *size = (long)mmf->size; return mmf->ptr; } long xdl_mmfile_size(mmfile_t *mmf) { - return mmf->size; + return (long)mmf->size; } @@ -321,7 +321,7 @@ int xdl_num_out(char *out, long val) { *str++ = '0'; *str = '\0'; - return str - out; + return (int)(str - out); } diff --git a/tests-clar/attr/attr_expect.h b/tests-clar/attr/attr_expect.h index b064eac65..df1e1044b 100644 --- a/tests-clar/attr/attr_expect.h +++ b/tests-clar/attr/attr_expect.h @@ -34,7 +34,7 @@ GIT_INLINE(void) attr_check_expected( break; case EXPECT_STRING: - cl_assert_strequal(expected_str, value); + cl_assert_equal_s(expected_str, value); break; } } diff --git a/tests-clar/attr/file.c b/tests-clar/attr/file.c index 132b906cd..d19708838 100644 --- a/tests-clar/attr/file.c +++ b/tests-clar/attr/file.c @@ -11,23 +11,22 @@ void test_attr_file__simple_read(void) git_attr_assignment *assign; git_attr_rule *rule; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr0"), file)); - cl_assert_strequal(cl_fixture("attr/attr0"), file->path); + cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr0"))); + + cl_assert_equal_s(cl_fixture("attr/attr0"), file->key + 2); cl_assert(file->rules.length == 1); rule = get_rule(0); cl_assert(rule != NULL); - cl_assert_strequal("*", rule->match.pattern); + cl_assert_equal_s("*", rule->match.pattern); cl_assert(rule->match.length == 1); - cl_assert(rule->match.flags == 0); + cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0); cl_assert(rule->assigns.length == 1); assign = get_assign(rule, 0); cl_assert(assign != NULL); - cl_assert_strequal("binary", assign->name); + cl_assert_equal_s("binary", assign->name); cl_assert(GIT_ATTR_TRUE(assign->value)); - cl_assert(!assign->is_allocated); git_attr_file__free(file); } @@ -38,9 +37,9 @@ void test_attr_file__match_variants(void) git_attr_rule *rule; git_attr_assignment *assign; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr1"), file)); - cl_assert_strequal(cl_fixture("attr/attr1"), file->path); + cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr1"))); + + cl_assert_equal_s(cl_fixture("attr/attr1"), file->key + 2); cl_assert(file->rules.length == 10); /* let's do a thorough check of this rule, then just verify @@ -48,51 +47,52 @@ void test_attr_file__match_variants(void) */ rule = get_rule(0); cl_assert(rule); - cl_assert_strequal("pat0", rule->match.pattern); + cl_assert_equal_s("pat0", rule->match.pattern); cl_assert(rule->match.length == strlen("pat0")); cl_assert(rule->match.flags == 0); cl_assert(rule->assigns.length == 1); assign = get_assign(rule,0); - cl_assert_strequal("attr0", assign->name); + cl_assert_equal_s("attr0", assign->name); cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name)); cl_assert(GIT_ATTR_TRUE(assign->value)); - cl_assert(!assign->is_allocated); rule = get_rule(1); - cl_assert_strequal("pat1", rule->match.pattern); + cl_assert_equal_s("pat1", rule->match.pattern); cl_assert(rule->match.length == strlen("pat1")); cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_NEGATIVE); rule = get_rule(2); - cl_assert_strequal("pat2", rule->match.pattern); + cl_assert_equal_s("pat2", rule->match.pattern); cl_assert(rule->match.length == strlen("pat2")); cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_DIRECTORY); rule = get_rule(3); - cl_assert_strequal("pat3dir/pat3file", rule->match.pattern); + cl_assert_equal_s("pat3dir/pat3file", rule->match.pattern); cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_FULLPATH); rule = get_rule(4); - cl_assert_strequal("pat4.*", rule->match.pattern); - cl_assert(rule->match.flags == 0); + cl_assert_equal_s("pat4.*", rule->match.pattern); + cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0); rule = get_rule(5); - cl_assert_strequal("*.pat5", rule->match.pattern); + cl_assert_equal_s("*.pat5", rule->match.pattern); + cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0); rule = get_rule(7); - cl_assert_strequal("pat7[a-e]??[xyz]", rule->match.pattern); + cl_assert_equal_s("pat7[a-e]??[xyz]", rule->match.pattern); cl_assert(rule->assigns.length == 1); + cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0); assign = get_assign(rule,0); - cl_assert_strequal("attr7", assign->name); + cl_assert_equal_s("attr7", assign->name); cl_assert(GIT_ATTR_TRUE(assign->value)); rule = get_rule(8); - cl_assert_strequal("pat8 with spaces", rule->match.pattern); + cl_assert_equal_s("pat8 with spaces", rule->match.pattern); cl_assert(rule->match.length == strlen("pat8 with spaces")); cl_assert(rule->match.flags == 0); rule = get_rule(9); - cl_assert_strequal("pat9", rule->match.pattern); + cl_assert_equal_s("pat9", rule->match.pattern); git_attr_file__free(file); } @@ -109,9 +109,9 @@ static void check_one_assign( git_attr_rule *rule = get_rule(rule_idx); git_attr_assignment *assign = get_assign(rule, assign_idx); - cl_assert_strequal(pattern, rule->match.pattern); + cl_assert_equal_s(pattern, rule->match.pattern); cl_assert(rule->assigns.length == 1); - cl_assert_strequal(name, assign->name); + cl_assert_equal_s(name, assign->name); cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name)); attr_check_expected(expected, expected_str, assign->value); @@ -123,9 +123,9 @@ void test_attr_file__assign_variants(void) git_attr_rule *rule; git_attr_assignment *assign; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr2"), file)); - cl_assert_strequal(cl_fixture("attr/attr2"), file->path); + cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr2"))); + + cl_assert_equal_s(cl_fixture("attr/attr2"), file->key + 2); cl_assert(file->rules.length == 11); check_one_assign(file, 0, 0, "pat0", "simple", EXPECT_TRUE, NULL); @@ -138,45 +138,45 @@ void test_attr_file__assign_variants(void) check_one_assign(file, 7, 0, "pat6", "negempty", EXPECT_FALSE, NULL); rule = get_rule(8); - cl_assert_strequal("pat7", rule->match.pattern); + cl_assert_equal_s("pat7", rule->match.pattern); cl_assert(rule->assigns.length == 5); /* assignments will be sorted by hash value, so we have to do * lookups by search instead of by position */ assign = git_attr_rule__lookup_assignment(rule, "multiple"); cl_assert(assign); - cl_assert_strequal("multiple", assign->name); + cl_assert_equal_s("multiple", assign->name); cl_assert(GIT_ATTR_TRUE(assign->value)); assign = git_attr_rule__lookup_assignment(rule, "single"); cl_assert(assign); - cl_assert_strequal("single", assign->name); + cl_assert_equal_s("single", assign->name); cl_assert(GIT_ATTR_FALSE(assign->value)); assign = git_attr_rule__lookup_assignment(rule, "values"); cl_assert(assign); - cl_assert_strequal("values", assign->name); - cl_assert_strequal("1", assign->value); + cl_assert_equal_s("values", assign->name); + cl_assert_equal_s("1", assign->value); assign = git_attr_rule__lookup_assignment(rule, "also"); cl_assert(assign); - cl_assert_strequal("also", assign->name); - cl_assert_strequal("a-really-long-value/*", assign->value); + cl_assert_equal_s("also", assign->name); + cl_assert_equal_s("a-really-long-value/*", assign->value); assign = git_attr_rule__lookup_assignment(rule, "happy"); cl_assert(assign); - cl_assert_strequal("happy", assign->name); - cl_assert_strequal("yes!", assign->value); + cl_assert_equal_s("happy", assign->name); + cl_assert_equal_s("yes!", assign->value); assign = git_attr_rule__lookup_assignment(rule, "other"); cl_assert(!assign); rule = get_rule(9); - cl_assert_strequal("pat8", rule->match.pattern); + cl_assert_equal_s("pat8", rule->match.pattern); cl_assert(rule->assigns.length == 2); assign = git_attr_rule__lookup_assignment(rule, "again"); cl_assert(assign); - cl_assert_strequal("again", assign->name); + cl_assert_equal_s("again", assign->name); cl_assert(GIT_ATTR_TRUE(assign->value)); assign = git_attr_rule__lookup_assignment(rule, "another"); cl_assert(assign); - cl_assert_strequal("another", assign->name); - cl_assert_strequal("12321", assign->value); + cl_assert_equal_s("another", assign->name); + cl_assert_equal_s("12321", assign->value); check_one_assign(file, 10, 0, "pat9", "at-eof", EXPECT_FALSE, NULL); @@ -189,39 +189,38 @@ void test_attr_file__check_attr_examples(void) git_attr_rule *rule; git_attr_assignment *assign; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr3"), file)); - cl_assert_strequal(cl_fixture("attr/attr3"), file->path); + cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr3"))); + cl_assert_equal_s(cl_fixture("attr/attr3"), file->key + 2); cl_assert(file->rules.length == 3); rule = get_rule(0); - cl_assert_strequal("*.java", rule->match.pattern); + cl_assert_equal_s("*.java", rule->match.pattern); cl_assert(rule->assigns.length == 3); assign = git_attr_rule__lookup_assignment(rule, "diff"); - cl_assert_strequal("diff", assign->name); - cl_assert_strequal("java", assign->value); + cl_assert_equal_s("diff", assign->name); + cl_assert_equal_s("java", assign->value); assign = git_attr_rule__lookup_assignment(rule, "crlf"); - cl_assert_strequal("crlf", assign->name); + cl_assert_equal_s("crlf", assign->name); cl_assert(GIT_ATTR_FALSE(assign->value)); assign = git_attr_rule__lookup_assignment(rule, "myAttr"); - cl_assert_strequal("myAttr", assign->name); + cl_assert_equal_s("myAttr", assign->name); cl_assert(GIT_ATTR_TRUE(assign->value)); assign = git_attr_rule__lookup_assignment(rule, "missing"); cl_assert(assign == NULL); rule = get_rule(1); - cl_assert_strequal("NoMyAttr.java", rule->match.pattern); + cl_assert_equal_s("NoMyAttr.java", rule->match.pattern); cl_assert(rule->assigns.length == 1); assign = get_assign(rule, 0); - cl_assert_strequal("myAttr", assign->name); - cl_assert(assign->value == NULL); + cl_assert_equal_s("myAttr", assign->name); + cl_assert(GIT_ATTR_UNSPECIFIED(assign->value)); rule = get_rule(2); - cl_assert_strequal("README", rule->match.pattern); + cl_assert_equal_s("README", rule->match.pattern); cl_assert(rule->assigns.length == 1); assign = get_assign(rule, 0); - cl_assert_strequal("caveat", assign->name); - cl_assert_strequal("unspecified", assign->value); + cl_assert_equal_s("caveat", assign->name); + cl_assert_equal_s("unspecified", assign->value); git_attr_file__free(file); } diff --git a/tests-clar/attr/flags.c b/tests-clar/attr/flags.c new file mode 100644 index 000000000..5081de8b2 --- /dev/null +++ b/tests-clar/attr/flags.c @@ -0,0 +1,108 @@ +#include "clar_libgit2.h" +#include "git2/attr.h" + +void test_attr_flags__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +void test_attr_flags__bare(void) +{ + git_repository *repo = cl_git_sandbox_init("testrepo.git"); + const char *value; + + cl_assert(git_repository_is_bare(repo)); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM, "README.md", "diff", &value)); + cl_assert(GIT_ATTR_UNSPECIFIED(value)); +} + +void test_attr_flags__index_vs_workdir(void) +{ + git_repository *repo = cl_git_sandbox_init("attr_index"); + const char *value; + + cl_assert(!git_repository_is_bare(repo)); + + /* wd then index */ + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX, + "README.md", "bar", &value)); + cl_assert(GIT_ATTR_FALSE(value)); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX, + "README.md", "blargh", &value)); + cl_assert_equal_s(value, "goop"); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX, + "README.txt", "foo", &value)); + cl_assert(GIT_ATTR_FALSE(value)); + + /* index then wd */ + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE, + "README.md", "bar", &value)); + cl_assert(GIT_ATTR_TRUE(value)); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE, + "README.md", "blargh", &value)); + cl_assert_equal_s(value, "garble"); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE, + "README.txt", "foo", &value)); + cl_assert(GIT_ATTR_TRUE(value)); +} + +void test_attr_flags__subdir(void) +{ + git_repository *repo = cl_git_sandbox_init("attr_index"); + const char *value; + + /* wd then index */ + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX, + "sub/sub/README.md", "bar", &value)); + cl_assert_equal_s(value, "1234"); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX, + "sub/sub/README.txt", "another", &value)); + cl_assert_equal_s(value, "one"); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX, + "sub/sub/README.txt", "again", &value)); + cl_assert(GIT_ATTR_TRUE(value)); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX, + "sub/sub/README.txt", "beep", &value)); + cl_assert_equal_s(value, "10"); + + /* index then wd */ + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE, + "sub/sub/README.md", "bar", &value)); + cl_assert_equal_s(value, "1337"); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE, + "sub/sub/README.txt", "another", &value)); + cl_assert_equal_s(value, "one"); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE, + "sub/sub/README.txt", "again", &value)); + cl_assert(GIT_ATTR_TRUE(value)); + + cl_git_pass(git_attr_get( + repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE, + "sub/sub/README.txt", "beep", &value)); + cl_assert_equal_s(value, "5"); +} + diff --git a/tests-clar/attr/lookup.c b/tests-clar/attr/lookup.c index 19396182e..b2a6aac64 100644 --- a/tests-clar/attr/lookup.c +++ b/tests-clar/attr/lookup.c @@ -9,14 +9,13 @@ void test_attr_lookup__simple(void) git_attr_path path; const char *value = NULL; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr0"), file)); - cl_assert_strequal(cl_fixture("attr/attr0"), file->path); + cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr0"))); + cl_assert_equal_s(cl_fixture("attr/attr0"), file->key + 2); cl_assert(file->rules.length == 1); cl_git_pass(git_attr_path__init(&path, "test", NULL)); - cl_assert_strequal("test", path.path); - cl_assert_strequal("test", path.basename); + cl_assert_equal_s("test", path.path); + cl_assert_equal_s("test", path.basename); cl_assert(!path.is_dir); cl_git_pass(git_attr_file__lookup_one(file,&path,"binary",&value)); @@ -25,6 +24,7 @@ void test_attr_lookup__simple(void) cl_git_pass(git_attr_file__lookup_one(file,&path,"missing",&value)); cl_assert(!value); + git_attr_path__free(&path); git_attr_file__free(file); } @@ -45,6 +45,8 @@ static void run_test_cases(git_attr_file *file, struct attr_expected *cases, int cl_git_pass(error); attr_check_expected(c->expected, c->expected_str, value); + + git_attr_path__free(&path); } } @@ -83,7 +85,7 @@ void test_attr_lookup__match_variants(void) { "/not/pat2/yousee", "attr2", EXPECT_UNDEFINED, NULL }, /* path match */ { "pat3file", "attr3", EXPECT_UNDEFINED, NULL }, - { "/pat3dir/pat3file", "attr3", EXPECT_UNDEFINED, NULL }, + { "/pat3dir/pat3file", "attr3", EXPECT_TRUE, NULL }, { "pat3dir/pat3file", "attr3", EXPECT_TRUE, NULL }, /* pattern* match */ { "pat4.txt", "attr4", EXPECT_TRUE, NULL }, @@ -101,7 +103,7 @@ void test_attr_lookup__match_variants(void) { "pat6/pat6/.pat6", "attr6", EXPECT_TRUE, NULL }, { "pat6/pat6/extra/foobar.pat6", "attr6", EXPECT_UNDEFINED, NULL }, { "/prefix/pat6/pat6/foobar.pat6", "attr6", EXPECT_UNDEFINED, NULL }, - { "/pat6/pat6/foobar.pat6", "attr6", EXPECT_UNDEFINED, NULL }, + { "/pat6/pat6/foobar.pat6", "attr6", EXPECT_TRUE, NULL }, /* complex pattern */ { "pat7a12z", "attr7", EXPECT_TRUE, NULL }, { "pat7e__x", "attr7", EXPECT_TRUE, NULL }, @@ -127,23 +129,24 @@ void test_attr_lookup__match_variants(void) { NULL, NULL, 0, NULL } }; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr1"), file)); - cl_assert_strequal(cl_fixture("attr/attr1"), file->path); + cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr1"))); + cl_assert_equal_s(cl_fixture("attr/attr1"), file->key + 2); cl_assert(file->rules.length == 10); cl_git_pass(git_attr_path__init(&path, "/testing/for/pat0", NULL)); - cl_assert_strequal("pat0", path.basename); + cl_assert_equal_s("pat0", path.basename); run_test_cases(file, cases, 0); run_test_cases(file, dir_cases, 1); git_attr_file__free(file); + git_attr_path__free(&path); } void test_attr_lookup__assign_variants(void) { git_attr_file *file; + struct attr_expected cases[] = { /* pat0 -> simple assign */ { "pat0", "simple", EXPECT_TRUE, NULL }, @@ -187,8 +190,7 @@ void test_attr_lookup__assign_variants(void) { NULL, NULL, 0, NULL } }; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr2"), file)); + cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr2"))); cl_assert(file->rules.length == 11); run_test_cases(file, cases, 0); @@ -199,6 +201,7 @@ void test_attr_lookup__assign_variants(void) void test_attr_lookup__check_attr_examples(void) { git_attr_file *file; + struct attr_expected cases[] = { { "foo.java", "diff", EXPECT_STRING, "java" }, { "foo.java", "crlf", EXPECT_FALSE, NULL }, @@ -222,8 +225,7 @@ void test_attr_lookup__check_attr_examples(void) { NULL, NULL, 0, NULL } }; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr3"), file)); + cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr3"))); cl_assert(file->rules.length == 3); run_test_cases(file, cases, 0); @@ -234,6 +236,7 @@ void test_attr_lookup__check_attr_examples(void) void test_attr_lookup__from_buffer(void) { git_attr_file *file; + struct attr_expected cases[] = { { "abc", "foo", EXPECT_TRUE, NULL }, { "abc", "bar", EXPECT_TRUE, NULL }, @@ -247,8 +250,10 @@ void test_attr_lookup__from_buffer(void) { NULL, NULL, 0, NULL } }; - cl_git_pass(git_attr_file__new(&file)); - cl_git_pass(git_attr_file__from_buffer(NULL, "a* foo\nabc bar\n* baz", file)); + cl_git_pass(git_attr_file__new(&file, 0, NULL, NULL)); + + cl_git_pass(git_attr_file__parse_buffer(NULL, "a* foo\nabc bar\n* baz", file)); + cl_assert(file->rules.length == 3); run_test_cases(file, cases, 0); diff --git a/tests-clar/attr/repo.c b/tests-clar/attr/repo.c index 4de4afaa7..006a49081 100644 --- a/tests-clar/attr/repo.c +++ b/tests-clar/attr/repo.c @@ -14,17 +14,13 @@ void test_attr_repo__initialize(void) * Also rename gitattributes to .gitattributes, because it contains * macro definitions which are only allowed in the root. */ - cl_fixture_sandbox("attr"); - cl_git_pass(p_rename("attr/.gitted", "attr/.git")); - cl_git_pass(p_rename("attr/gitattributes", "attr/.gitattributes")); - cl_git_pass(git_repository_open(&g_repo, "attr/.git")); + g_repo = cl_git_sandbox_init("attr"); } void test_attr_repo__cleanup(void) { - git_repository_free(g_repo); + cl_git_sandbox_cleanup(); g_repo = NULL; - cl_fixture_cleanup("attr"); } void test_attr_repo__get_one(void) @@ -68,13 +64,13 @@ void test_attr_repo__get_one(void) for (scan = test_cases; scan->path != NULL; scan++) { const char *value; - cl_git_pass(git_attr_get(g_repo, scan->path, scan->attr, &value)); + cl_git_pass(git_attr_get(g_repo, 0, scan->path, scan->attr, &value)); attr_check_expected(scan->expected, scan->expected_str, value); } - cl_git_pass(git_attr_cache__is_cached(g_repo, ".git/info/attributes")); - cl_git_pass(git_attr_cache__is_cached(g_repo, ".gitattributes")); - cl_git_pass(git_attr_cache__is_cached(g_repo, "sub/.gitattributes")); + cl_assert(git_attr_cache__is_cached(g_repo, 0, ".git/info/attributes")); + cl_assert(git_attr_cache__is_cached(g_repo, 0, ".gitattributes")); + cl_assert(git_attr_cache__is_cached(g_repo, 0, "sub/.gitattributes")); } void test_attr_repo__get_many(void) @@ -82,26 +78,26 @@ void test_attr_repo__get_many(void) const char *names[4] = { "repoattr", "rootattr", "missingattr", "subattr" }; const char *values[4]; - cl_git_pass(git_attr_get_many(g_repo, "root_test1", 4, names, values)); + cl_git_pass(git_attr_get_many(g_repo, 0, "root_test1", 4, names, values)); cl_assert(GIT_ATTR_TRUE(values[0])); cl_assert(GIT_ATTR_TRUE(values[1])); cl_assert(GIT_ATTR_UNSPECIFIED(values[2])); cl_assert(GIT_ATTR_UNSPECIFIED(values[3])); - cl_git_pass(git_attr_get_many(g_repo, "root_test2", 4, names, values)); + cl_git_pass(git_attr_get_many(g_repo, 0, "root_test2", 4, names, values)); cl_assert(GIT_ATTR_TRUE(values[0])); cl_assert(GIT_ATTR_FALSE(values[1])); cl_assert(GIT_ATTR_UNSPECIFIED(values[2])); cl_assert(GIT_ATTR_UNSPECIFIED(values[3])); - cl_git_pass(git_attr_get_many(g_repo, "sub/subdir_test1", 4, names, values)); + cl_git_pass(git_attr_get_many(g_repo, 0, "sub/subdir_test1", 4, names, values)); cl_assert(GIT_ATTR_TRUE(values[0])); cl_assert(GIT_ATTR_TRUE(values[1])); cl_assert(GIT_ATTR_UNSPECIFIED(values[2])); - cl_assert_strequal("yes", values[3]); + cl_assert_equal_s("yes", values[3]); } static int count_attrs( @@ -114,7 +110,7 @@ static int count_attrs( *((int *)payload) += 1; - return GIT_SUCCESS; + return 0; } void test_attr_repo__foreach(void) @@ -122,16 +118,17 @@ void test_attr_repo__foreach(void) int count; count = 0; - cl_git_pass(git_attr_foreach(g_repo, "root_test1", &count_attrs, &count)); + cl_git_pass(git_attr_foreach( + g_repo, 0, "root_test1", &count_attrs, &count)); cl_assert(count == 2); count = 0; - cl_git_pass(git_attr_foreach(g_repo, "sub/subdir_test1", + cl_git_pass(git_attr_foreach(g_repo, 0, "sub/subdir_test1", &count_attrs, &count)); cl_assert(count == 4); /* repoattr, rootattr, subattr, negattr */ count = 0; - cl_git_pass(git_attr_foreach(g_repo, "sub/subdir_test2.txt", + cl_git_pass(git_attr_foreach(g_repo, 0, "sub/subdir_test2.txt", &count_attrs, &count)); cl_assert(count == 6); /* repoattr, rootattr, subattr, reposub, negattr, another */ } @@ -140,19 +137,19 @@ void test_attr_repo__manpage_example(void) { const char *value; - cl_git_pass(git_attr_get(g_repo, "sub/abc", "foo", &value)); + cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "foo", &value)); cl_assert(GIT_ATTR_TRUE(value)); - cl_git_pass(git_attr_get(g_repo, "sub/abc", "bar", &value)); + cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "bar", &value)); cl_assert(GIT_ATTR_UNSPECIFIED(value)); - cl_git_pass(git_attr_get(g_repo, "sub/abc", "baz", &value)); + cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "baz", &value)); cl_assert(GIT_ATTR_FALSE(value)); - cl_git_pass(git_attr_get(g_repo, "sub/abc", "merge", &value)); - cl_assert_strequal("filfre", value); + cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "merge", &value)); + cl_assert_equal_s("filfre", value); - cl_git_pass(git_attr_get(g_repo, "sub/abc", "frotz", &value)); + cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "frotz", &value)); cl_assert(GIT_ATTR_UNSPECIFIED(value)); } @@ -163,7 +160,7 @@ void test_attr_repo__macros(void) const char *names3[3] = { "macro2", "multi2", "multi3" }; const char *values[5]; - cl_git_pass(git_attr_get_many(g_repo, "binfile", 5, names, values)); + cl_git_pass(git_attr_get_many(g_repo, 0, "binfile", 5, names, values)); cl_assert(GIT_ATTR_TRUE(values[0])); cl_assert(GIT_ATTR_TRUE(values[1])); @@ -171,19 +168,19 @@ void test_attr_repo__macros(void) cl_assert(GIT_ATTR_FALSE(values[3])); cl_assert(GIT_ATTR_UNSPECIFIED(values[4])); - cl_git_pass(git_attr_get_many(g_repo, "macro_test", 5, names2, values)); + cl_git_pass(git_attr_get_many(g_repo, 0, "macro_test", 5, names2, values)); cl_assert(GIT_ATTR_TRUE(values[0])); cl_assert(GIT_ATTR_TRUE(values[1])); cl_assert(GIT_ATTR_FALSE(values[2])); cl_assert(GIT_ATTR_UNSPECIFIED(values[3])); - cl_assert_strequal("77", values[4]); + cl_assert_equal_s("77", values[4]); - cl_git_pass(git_attr_get_many(g_repo, "macro_test", 3, names3, values)); + cl_git_pass(git_attr_get_many(g_repo, 0, "macro_test", 3, names3, values)); cl_assert(GIT_ATTR_TRUE(values[0])); cl_assert(GIT_ATTR_FALSE(values[1])); - cl_assert_strequal("answer", values[2]); + cl_assert_equal_s("answer", values[2]); } void test_attr_repo__bad_macros(void) @@ -192,7 +189,7 @@ void test_attr_repo__bad_macros(void) "firstmacro", "secondmacro", "thirdmacro" }; const char *values[6]; - cl_git_pass(git_attr_get_many(g_repo, "macro_bad", 6, names, values)); + cl_git_pass(git_attr_get_many(g_repo, 0, "macro_bad", 6, names, values)); /* these three just confirm that the "mymacro" rule ran */ cl_assert(GIT_ATTR_UNSPECIFIED(values[0])); @@ -222,7 +219,55 @@ void test_attr_repo__bad_macros(void) * -firstmacro secondmacro="hahaha" thirdmacro */ cl_assert(GIT_ATTR_FALSE(values[3])); - cl_assert_strequal("hahaha", values[4]); + cl_assert_equal_s("hahaha", values[4]); cl_assert(GIT_ATTR_TRUE(values[5])); } +#define CONTENT "I'm going to be dynamically processed\r\n" \ + "And my line endings...\r\n" \ + "...are going to be\n" \ + "normalized!\r\n" + +#define GITATTR "* text=auto\n" \ + "*.txt text\n" \ + "*.data binary\n" + +static void add_to_workdir(const char *filename, const char *content) +{ + git_buf buf = GIT_BUF_INIT; + + cl_git_pass(git_buf_joinpath(&buf, "attr", filename)); + cl_git_rewritefile(git_buf_cstr(&buf), content); + + git_buf_free(&buf); +} + +static void assert_proper_normalization(git_index *index, const char *filename, const char *expected_sha) +{ + int index_pos; + git_index_entry *entry; + + add_to_workdir(filename, CONTENT); + cl_git_pass(git_index_add(index, filename, 0)); + + index_pos = git_index_find(index, filename); + cl_assert(index_pos >= 0); + + entry = git_index_get(index, index_pos); + cl_assert_equal_i(0, git_oid_streq(&entry->oid, expected_sha)); +} + +void test_attr_repo__staging_properly_normalizes_line_endings_according_to_gitattributes_directives(void) +{ + git_index* index; + + cl_git_pass(git_repository_index(&index, g_repo)); + + add_to_workdir(".gitattributes", GITATTR); + + assert_proper_normalization(index, "text.txt", "22c74203bace3c2e950278c7ab08da0fca9f4e9b"); + assert_proper_normalization(index, "huh.dunno", "22c74203bace3c2e950278c7ab08da0fca9f4e9b"); + assert_proper_normalization(index, "binary.data", "66eeff1fcbacf589e6d70aa70edd3fce5be2b37c"); + + git_index_free(index); +} diff --git a/tests-clar/buf/basic.c b/tests-clar/buf/basic.c index 5d4a5fff9..d558757a9 100644 --- a/tests-clar/buf/basic.c +++ b/tests-clar/buf/basic.c @@ -8,7 +8,7 @@ void test_buf_basic__resize(void) git_buf buf1 = GIT_BUF_INIT; git_buf_puts(&buf1, test_string); cl_assert(git_buf_oom(&buf1) == 0); - cl_assert_strequal(git_buf_cstr(&buf1), test_string); + cl_assert_equal_s(git_buf_cstr(&buf1), test_string); git_buf_puts(&buf1, test_string); cl_assert(strlen(git_buf_cstr(&buf1)) == strlen(test_string) * 2); @@ -20,10 +20,10 @@ void test_buf_basic__printf(void) git_buf buf2 = GIT_BUF_INIT; git_buf_printf(&buf2, "%s %s %d ", "shoop", "da", 23); cl_assert(git_buf_oom(&buf2) == 0); - cl_assert_strequal(git_buf_cstr(&buf2), "shoop da 23 "); + cl_assert_equal_s(git_buf_cstr(&buf2), "shoop da 23 "); git_buf_printf(&buf2, "%s %d", "woop", 42); cl_assert(git_buf_oom(&buf2) == 0); - cl_assert_strequal(git_buf_cstr(&buf2), "shoop da 23 woop 42"); + cl_assert_equal_s(git_buf_cstr(&buf2), "shoop da 23 woop 42"); git_buf_free(&buf2); } diff --git a/tests-clar/clar b/tests-clar/clar index a718a00ec..2c70da038 100755 --- a/tests-clar/clar +++ b/tests-clar/clar @@ -87,7 +87,7 @@ class ClarTestBuilder: if not self.suite_data: raise RuntimeError( - 'No tests found under "%s"' % folder_name) + 'No tests found under "%s"' % path) def render(self): main_file = os.path.join(self.path, 'clar_main.c') @@ -214,7 +214,7 @@ static const struct clar_func _clar_cb_${suite_name}[] = { content = bytearray(content, 'utf_8') content = base64.b64decode(content) content = zlib.decompress(content) - return str(content) + return str(content, 'utf-8') else: content = base64.b64decode(content) return zlib.decompress(content) @@ -297,13 +297,13 @@ static const struct clar_func _clar_cb_${suite_name}[] = { CLAR_FILES = { -"clar.c" : r"""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""", +"clar.c" : r"""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""", "clar_print_default.c" : r"""eJyFU01P4zAQPSe/YqgU1a5Cuadi98ap4rLaE6DIxA5YSu3InnQPK/479jgFB9FycuZ53vObj5QeBeoOjlZL6Abh2tFpg602Gln4AFQe285OBmuIsZ80qhPQWeMRulfhYJMujDgoz8v/ZcGiJP+k78qCpHu22lshlYRKJjXfQOUfzaqG+CJfvJCrZgp/UDhUMpAC+laWZ6rwrxNK+8/8XEkElHPWJeBcBQnKmB9YRt6Vn0YfTfJYkCunRuuwpVzPLlqnHPJtpsOp0x7d1GFKowTY0EF2T09CaCyHO6GHyamG+hokeO6q8k1TeWCV5/AQgko+wcM1hiOml0VBqte/qNAsjr2I4cpYkMp3To+o7YLS6yFnDNqE8U2HZ+W+6MzowhecFmHOS009+BfK0j2w+SJ7HK5u4f7vfs+D/DmdLJ0vp3N5f6yJTlm+5sl62Me0M1klCehD35X8uj+RsFsixMlWuuqC38SG37C+W0MD6+36B380Ifb9f0gmbjZgrB1hc7Pc3uTokrR4Dru6kA6DqGG73ZLwUbSDDlfCvYw7Cn38KVmMa0gzK479XJ5HGWZBeE0UnjjKSDaHb+U7mrWGAw==""", "clar_print_tap.c" : r"""eJyNVMFu2zAMPVtfwbgIYBu2gWK3BmuxnYthh+02wFBtORXmSIYkZxiG/vso2m6lJF12skk9ko+PlJh13MkWjlp20A7cNKORyjVSSZfhDzhhXdPqSbkSvG0n6cTqaLWyDtpnbqCYDxQ/CJuzPyzJfMr8LXy3ugLgiW/FEYU+S799+gpHYazUCm4//FBpvmMvjL1D2T5PrtO/1HXa3iGM0WZ2/A/d2BcE7xhLZA/ZJkqYvPZwAyO3VnTAhwG2HRHLbI7NlAFJbCwRgxVRYM/lgIEYxA9a7U+jg4IlxiVxtjXNbV1vu/Nq78tIaUlDNR3WEVtnptbNMAJAQZ9AOkR7Lda6AFVVzSMLfDhzy/cC7mBr35qo7udeDnYfw63A8Uv3+460OMtGowE4y0b+GOqbhwtQ74+RPYp+Cen9MXKQakV2IdL7G5TjSZh8XY/lqBO2NXJ0fqM3H+HL98fHcFkAAsApgeAoj5Wu6/ra5dCKVie8sLQP/hrOF2I2ifXsmNePJryW2lq/hNVCDIkvK/oAqdIO9M8UxUjx48/ChK8mlmMJ0SdyRozaLDtnsysd0Fizy29ORPMGiqJAkv5DCga4f5fgT0gnKoE7WXqBqcCRN4PEI272445MzIQB3i5hWd9+oWHxNZrwtUk/o0iAvxug/T2eAqiET5HPOYXqssV8YX8BFTvXlQ==""", "clar_sandbox.c" : r"""eJyNVV1P20AQfLZ/xRIkYpNATItaVSkPlaBVVEoiEgQSRJaxz+SEfY7uLmkD4r931+fEHwRahBST3Zudmb0xSgeahxDOAgl+mATSnwd6dnvsffk07du2MmUutM2VvwwSHvk6nedNTpgJpc3RffrCtZ9tazz5NvEnoDSetngMDkE4VO7CntIu7JyA59qWJZleSAHeum9n7A/Gp4NLPHCotJ9mEXObfcWzE4QhU6pAvfaHP104Idi+/VLjHHNR5ZszvV/EMZNdUPyJ+RoSJh4M9V0ei4jF4F8PLj5+sK0Cx6gsupdoUJgthIYTOO43egw+E0s0SqrbKfagIVZr8muEulpdoKf848x8Xo3PLkeXw++D87OWDdYLSgSrmMRJb5xJcDjieH3g8LUc34dOh7s5fGM2Nj8wjQ/OhgifojGWMRm/JFPplOZiwWhKXnm9Xmo1I1CmFOF85ay9w1J37RxBV5ZkWS82/tpWbx8GMegZo24uM5EytC3KmBJt9DNYQSBWesbFQxe0XIHOYKEY9HA+7PfsN0i1qN4qeDVpmWKNWYUYktpliWIG+gfTE5bORwTqnF4PL09dc6wLBq5x+XaZiHhsdE1mXIFaKc3SjaCEPzIUUNNC4sOFlLlwLlmoMyy+I+7wTWWH78la/3lwVA3AMuMR5JFeCBWI6D7749B3eUyJQCXv3pQC1L7z2qVqvBoYiWoiwhmqQJZIs2JIrHyZVsCaKUQ/eRL5BQWjdMOjcnup4OuAJ3lyWjkeWXOT/7QobZvIrl8a9YCXHEy8s7hKy8UAVd885JZtIRhOQ7/xoS6iqf4ZcPUikyku7YnldGnRo+F4cAOY1N+BjEAlgZoxlS+5EmXrVZRJRBni5j54sY+7fB+W1ShBu9feRG2ziAYGKTuAoym9cbHfDKrXO50SjO7R+tqVXdAhpt1yOducxTHYtMUyYpQ+Ykzmvvrndhr/GMx6DAJdu+px77PnbT1QCTieosE1nujpxdX5+atDhYFlquoXOEf4/wjB3t62O7/9/hGKyVWV6FYvavT+AhbcW38=""", "clar_fixtures.c" : r"""eJyFUV1LwzAUfW5+xZU9rLUVJ4ggZQ9DFAUfZEwQSglZmrBAl5Qkk6n43236tWbKfMvNOfecc+81llhBgSppLNAN0XCOuNjbnWa4InYTjpE1MSzxuD1Vki2L0BcKTKfn0EYgu57d3uRpjYhPhi1opSwumUwRCvo3zMFYXT9C5xA5stWSVh9hI5FAa+wUFG//osgJCA5tmQ1SF3CVw9kcppfTCAWBj8ZxDg3UN4/zZ7MaHBrHSBw7vpcJ4mGS5Ijtai9qnannNqk1q7myXU+KvhGaCF4wDnfPiyV+eHpbvS7v8cti9YjGq6Yl7lzCkxfo1L0j/lJOwOtrUrwrUcDBBRsii7Xan3bjBlNVL2WUzuMkgGlJdLuIP21oyYjcVf/a6G3ozXTQPRqmsZkwWQiOfgAVGffP""", "clar_fs.c" : r"""eJylVdtu20YQfSa/YkAD8TKWY8dJX6L0wXDEVqgsBhINN7UFhiGX1qIkl9hd+dLG/57ZCynJUWEkfZE0s7NnZufMGe2xsqAlpJfj6ZsT399DgzUUojhKo8npb3Mg+ud8PBlNE/hq/NP4LJ5G49n5aTKOp71zNJvFs4vx06DzPz6MZ6HvS5UplkO+zAS89EtWUd7KtM3UkuS8kcqdGE/o/+t71tYm/ArTi8lk6HuS/UNTBRVtbtRyAGzo+x4rgaQ2zMaFvucJqlaicdd8z15AHKkE/rbxIQI6+DqrKp4TF3YAJ2GH/AxwTeu8fTBRA0jtl0Xp0K+sucAsx9suzPPauX2v5AIIMxYweO9AhnBwwELAbvTFXLGFrmf/aF+X4/Uu2L++3scEjwjmitRnQ/+x7/0tZ0XXecIaBTUv6AC22i/5SuRPnQWVynAy/z3CSYg/zpPZxVkCJQLp4m2YvYqVbJHrEHU7bJgG+y7IZNBQf1HBz2nNxQN5oeEHoDnnJdlOHYa2aa18dRetmlxziI8ZOl8bCV5ruk3u3ptw9OlUnaeMquxGorOfd/OcKs2kpEKlBFuMibHUuKUCm8gbW1aoOTge4HFwyZqC30l4EgdlhmYR+J4tVVBK1q0wpnv0U4JkKmqygxTDQEdfFKcfRpNRMsKx6zgzM7oLL+c4oz9A80aSs/jjp40U6bpmA46t0vgVzZpVS7TLApg3lOwe55A6ivMqE04hwcsgtCB7tJK0KxdH0pdLWlUpXylii3IVZuLm9mphsPXg6gsrqeXECtwH+Kl7jF96sLj4m6z1i773cGw1VLYCb5dEqoIKodnzgvmDVLQGtLl4B5/t7c+Q40ZwFL66bgLNmUfvmSKHr0Onsg5eT4LFp/c0vyWm1uPFwBTdBd9lTGGwvjCAF7b+Ad4b9mq9HP05TubJaXIxJ/b8f3DZU2lNU9Ivi+G2VNcL1dopLh3dt17IuC0LpHVDwuvA9TLtT21LrHm1EXlo9ly/s/4rwC5C1z00g6MvrDnK22DovCYoOJz1jpPFpsaN6412udkJndTNwdtF/zdiFF6vpMJxlNKIfD12hjQj7MiwD4qD7jkovbfcSEvtlVlTfOH3uxX+rKg3NL3B0dvFrh6I+rselNtN6F68oxk/+2araVBLuv3SZ6RvZL5q3BVi9r52bTgeUfZNwUr/G9kaoSs=""", -"clar.h" : r"""eJy9Vctu2zAQPEdfwVo9WIIQp9c0DWAENmLACIrUQXojaHIVEZVJlaQaAUX/vSQlP/Rw3PTgk6nlDmd2d0iHPBUMUoTx3XL6iFezbyt8j3EQ2iAX0IsHIRc0LxmgG21YzteX2W0Q/JKcIZoThTHRGpQZBxdcGESlYNxwKZLgwq61jWREoTjlOSR1Sm5ZOruglFSdGANNFS+asxxQZ7LMGSZrqUz0eacBazCY5kBEWYx9bBw3n1H9HUcJqheyID9LsOAtNtUtqDs25Knrj+/CfPF99fQ4w1+nq/vgUJ2D8sqUCsbtMn0MC7JpsTRhTQRby+o9kK26NyAh2J6nQTCJ4wDFaOrnYduGNoQqqdErNxmCqsg55Qb5XqMNaE1ewOZPdpO3rJtSG1zYieKxBagEuSlE7UH7nQjdfkFXiXXLfLGcYexWy8WDX43mpaBeACV5jlJiZ8+u0QiF+zMT9CnqEbvM08Q3R3lnVQHUAENpS4CRXsMJBTXJafoPx+u2/Mr21RFzjYQ0yKgShni3s7rLgP74jzlRhzvToK6iPvOZJzUk4QyDuopOXCoh//E6NZKGbtjD03I5fBU6oMOe90BN6TtE2811+nHTnapjb7c9Q9+CPVF7r3Rhb9biU7qIwUrmUlFnInuafQ8nr0QJLl666r2AAZ8cc8cK7EtbX4bL0fBj0TC959TnGoJYqdyPcSRQAS2dq65HA57zOjZgMsnspiMhLlf7+j7+hsqAEvhw50+w/TP4C4S1nfY=""" +"clar.h" : r"""eJy9VU1P4zAQPZNfYZo9JJUFlCMLSAi1AqlCKyjavVmO4xBrEyfYztLVav874yRtmq922QOX1pnxzHvOe+O4IpIhjxAht8ubR7KaP63IHSGOC0EheS/uuEKypAg5utQmTERwEl87zq9MhIglVBFCtebKeM6RkAaxTIbCiExi5wjWGiIxVWgaiYTjaksCKJ0sVypTnVjINVMir3vZQh1nRRISGmTK+F8HOBD+WtCEaG+3Dx5/gKa9ADQe6ys8WzBUNNRl04ZobghLOJVF7pUxb1o/+tXz1MeoWmQ5fS14Q4FEulVq27oisvKVIi3uf6yeH+fk283qztnlYEvF2hSKe20VyhiRNG2h1GFNZRhk64+UbNjtKXE5WCJynNPp1EFTdFO+UlAVpZSpTKM3YWLE13kimDCotAJKudb0hcP+060xATUttCE5iEI8KFAYWZP4bR+WGR9dX6EzDGZe3C/nhNjV8v6hXE0WhWQlAUaTBEUUrBleoAlym54YzfwesN15GPhyFHe+zjkzPERRi4DJSg4HGNROPAh/PH5uwFfwXi2w0EhmBhlV8CHcjVa3MWc//0MnZus+Sagzv4/8yUoNUfgEoc78A0Mls38cp5rS0IQ9PC+Xw6PQKdp9572i+ujbirabq+3jpjt0jsZuDULfgj1SjVe6ZXvPUm7pVgyeZJEpZk0E3eA+PH2jSgr50mVfEhjwyZg7Vhxu2moYTibDl0WN9JGu36sSFBbK/hkLwtecFdZVF5MBz61+53A42nFe93SdL7OeYX3eprTNQdLHHqTxluGW4OTJlLxSoVNqWFwOg57BL8yRXZ6PXJjbT/cMi2Fg4UESgMUgsCsaELEfJPCCGQ7GQI6PIe1j+zcMFDRAwX6g3MtnOD/fmSQPIj66ukIehHcksiqm3MRZCPpZWtRKVYn05Q9fG64k2c38dTbf63eIKlZw""" } if __name__ == '__main__': main() diff --git a/tests-clar/clar_helpers.c b/tests-clar/clar_helpers.c index e90bb8737..697614095 100644 --- a/tests-clar/clar_helpers.c +++ b/tests-clar/clar_helpers.c @@ -28,16 +28,26 @@ void cl_git_mkfile(const char *filename, const char *content) cl_must_pass(p_close(fd)); } -void cl_git_append2file(const char *filename, const char *new_content) +void cl_git_write2file(const char *filename, const char *new_content, int flags) { - int fd = p_creat(filename, 0644); - cl_assert(fd != 0); + int fd = open(filename, flags, 0644); + cl_assert(fd >= 0); if (!new_content) new_content = "\n"; cl_must_pass(p_write(fd, new_content, strlen(new_content))); cl_must_pass(p_close(fd)); } +void cl_git_append2file(const char *filename, const char *new_content) +{ + cl_git_write2file(filename, new_content, O_WRONLY | O_CREAT | O_APPEND); +} + +void cl_git_rewritefile(const char *filename, const char *new_content) +{ + cl_git_write2file(filename, new_content, O_WRONLY | O_CREAT | O_TRUNC); +} + static const char *_cl_sandbox = NULL; static git_repository *_cl_repo = NULL; @@ -49,13 +59,14 @@ git_repository *cl_git_sandbox_init(const char *sandbox) cl_fixture_sandbox(sandbox); _cl_sandbox = sandbox; - p_chdir(sandbox); + cl_git_pass(p_chdir(sandbox)); - /* Rename `sandbox/.gitted` to `sandbox/.git` which must be done since - * we cannot store a folder named `.git` inside the fixtures folder of - * our libgit2 repo. + /* If this is not a bare repo, then rename `sandbox/.gitted` to + * `sandbox/.git` which must be done since we cannot store a folder + * named `.git` inside the fixtures folder of our libgit2 repo. */ - cl_git_pass(p_rename(".gitted", ".git")); + if (p_access(".gitted", F_OK) == 0) + cl_git_pass(p_rename(".gitted", ".git")); /* If we have `gitattributes`, rename to `.gitattributes`. This may * be necessary if we don't want the attributes to be applied in the @@ -68,7 +79,7 @@ git_repository *cl_git_sandbox_init(const char *sandbox) if (p_access("gitignore", F_OK) == 0) cl_git_pass(p_rename("gitignore", ".gitignore")); - p_chdir(".."); + cl_git_pass(p_chdir("..")); /* Now open the sandbox repository and make it available for tests */ cl_git_pass(git_repository_open(&_cl_repo, sandbox)); diff --git a/tests-clar/clar_libgit2.h b/tests-clar/clar_libgit2.h index 5c034a385..63bc703d7 100644 --- a/tests-clar/clar_libgit2.h +++ b/tests-clar/clar_libgit2.h @@ -13,9 +13,9 @@ * return error codes! */ #define cl_git_pass(expr) do { \ - git_clearerror(); \ - if ((expr) != GIT_SUCCESS) \ - clar__assert(0, __FILE__, __LINE__, "Function call failed: " #expr, git_lasterror(), 1); \ + giterr_clear(); \ + if ((expr) != 0) \ + clar__assert(0, __FILE__, __LINE__, "Function call failed: " #expr, giterr_last()->message, 1); \ } while(0) /** @@ -25,26 +25,6 @@ */ #define cl_git_fail(expr) cl_must_fail(expr) -/** - * Wrapper for string comparison that knows about nulls. - */ -#define cl_assert_strequal(a,b) \ - cl_assert_strequal_internal(a,b,__FILE__,__LINE__,"string mismatch: " #a " != " #b) - -GIT_INLINE(void) cl_assert_strequal_internal( - const char *a, const char *b, const char *file, int line, const char *err) -{ - int match = (a == NULL || b == NULL) ? (a == b) : (strcmp(a, b) == 0); - if (!match) { - char buf[4096]; - snprintf(buf, 4096, "'%s' != '%s'", a, b); - clar__assert(0, file, line, err, buf, 1); - } -} - -#define cl_assert_intequal(a,b) \ - do { if ((a) != (b)) { char buf[128]; snprintf(buf,128,"%d != %d",(a),(b)); clar__assert(0,__FILE__,__LINE__,#a " != " #b,buf,1); } } while (0) - /* * Some utility macros for building long strings */ @@ -57,6 +37,8 @@ GIT_INLINE(void) cl_assert_strequal_internal( /* Write the contents of a buffer to disk */ void cl_git_mkfile(const char *filename, const char *content); void cl_git_append2file(const char *filename, const char *new_content); +void cl_git_rewritefile(const char *filename, const char *new_content); +void cl_git_write2file(const char *filename, const char *new_content, int mode); /* Git sandbox setup helpers */ diff --git a/tests-clar/config/new.c b/tests-clar/config/new.c index 651e73931..78e8ec828 100644 --- a/tests-clar/config/new.c +++ b/tests-clar/config/new.c @@ -26,9 +26,9 @@ void test_config_new__write_new_config(void) cl_git_pass(git_config_add_file(config, file, 0)); cl_git_pass(git_config_get_string(config, "color.ui", &out)); - cl_assert_strequal(out, "auto"); + cl_assert_equal_s(out, "auto"); cl_git_pass(git_config_get_string(config, "core.editor", &out)); - cl_assert_strequal(out, "ed"); + cl_assert_equal_s(out, "ed"); git_config_free(config); diff --git a/tests-clar/config/read.c b/tests-clar/config/read.c index 2813048e9..3e9a8d4bf 100644 --- a/tests-clar/config/read.c +++ b/tests-clar/config/read.c @@ -28,9 +28,9 @@ void test_config_read__case_sensitive(void) cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config1"))); cl_git_pass(git_config_get_string(cfg, "this.that.other", &str)); - cl_assert_strequal(str, "true"); + cl_assert_equal_s(str, "true"); cl_git_pass(git_config_get_string(cfg, "this.That.other", &str)); - cl_assert_strequal(str, "yes"); + cl_assert_equal_s(str, "yes"); cl_git_pass(git_config_get_bool(cfg, "this.that.other", &i)); cl_assert(i == 1); @@ -55,7 +55,7 @@ void test_config_read__multiline_value(void) cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config2"))); cl_git_pass(git_config_get_string(cfg, "this.That.and", &str)); - cl_assert_strequal(str, "one one one two two three three"); + cl_assert_equal_s(str, "one one one two two three three"); git_config_free(cfg); } @@ -71,7 +71,7 @@ void test_config_read__subsection_header(void) cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config3"))); cl_git_pass(git_config_get_string(cfg, "section.subsection.var", &str)); - cl_assert_strequal(str, "hello"); + cl_assert_equal_s(str, "hello"); /* The subsection is transformed to lower-case */ cl_must_fail(git_config_get_string(cfg, "section.subSectIon.var", &str)); @@ -171,10 +171,22 @@ void test_config_read__prefixes(void) cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9"))); cl_git_pass(git_config_get_string(cfg, "remote.ab.url", &str)); - cl_assert_strequal(str, "http://example.com/git/ab"); + cl_assert_equal_s(str, "http://example.com/git/ab"); cl_git_pass(git_config_get_string(cfg, "remote.abba.url", &str)); - cl_assert_strequal(str, "http://example.com/git/abba"); + cl_assert_equal_s(str, "http://example.com/git/abba"); + + git_config_free(cfg); +} + +void test_config_read__escaping_quotes(void) +{ + git_config *cfg; + const char *str; + + cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config13"))); + cl_git_pass(git_config_get_string(cfg, "core.editor", &str)); + cl_assert(strcmp(str, "\"C:/Program Files/Nonsense/bah.exe\" \"--some option\"") == 0); git_config_free(cfg); } diff --git a/tests-clar/config/stress.c b/tests-clar/config/stress.c index e3b1114f0..54a61ad67 100644 --- a/tests-clar/config/stress.c +++ b/tests-clar/config/stress.c @@ -27,7 +27,7 @@ void test_config_stress__dont_break_on_invalid_input(void) struct git_config_file *file; git_config *config; - cl_git_pass(git_path_exists("git-test-config")); + cl_assert(git_path_exists("git-test-config")); cl_git_pass(git_config_file__ondisk(&file, "git-test-config")); cl_git_pass(git_config_new(&config)); cl_git_pass(git_config_add_file(config, file, 0)); @@ -37,3 +37,25 @@ void test_config_stress__dont_break_on_invalid_input(void) git_config_free(config); } + +void test_config_stress__comments(void) +{ + struct git_config_file *file; + git_config *config; + const char *str; + + cl_git_pass(git_config_file__ondisk(&file, cl_fixture("config/config12"))); + cl_git_pass(git_config_new(&config)); + cl_git_pass(git_config_add_file(config, file, 0)); + + cl_git_pass(git_config_get_string(config, "some.section.other", &str)); + cl_assert(!strcmp(str, "hello! \" ; ; ; ")); + + cl_git_pass(git_config_get_string(config, "some.section.multi", &str)); + cl_assert(!strcmp(str, "hi, this is a ; multiline comment # with ;\n special chars and other stuff !@#")); + + cl_git_pass(git_config_get_string(config, "some.section.back", &str)); + cl_assert(!strcmp(str, "this is \ba phrase")); + + git_config_free(config); +} diff --git a/tests-clar/core/buffer.c b/tests-clar/core/buffer.c index 870525b36..9294ccdfd 100644 --- a/tests-clar/core/buffer.c +++ b/tests-clar/core/buffer.c @@ -19,11 +19,11 @@ void test_core_buffer__0(void) git_buf_puts(&buf, test_string); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(test_string, git_buf_cstr(&buf)); + cl_assert_equal_s(test_string, git_buf_cstr(&buf)); git_buf_puts(&buf, test_string); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(test_string_x2, git_buf_cstr(&buf)); + cl_assert_equal_s(test_string_x2, git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -35,11 +35,11 @@ void test_core_buffer__1(void) git_buf_printf(&buf, "%s %s %d ", "shoop", "da", 23); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal("shoop da 23 ", git_buf_cstr(&buf)); + cl_assert_equal_s("shoop da 23 ", git_buf_cstr(&buf)); git_buf_printf(&buf, "%s %d", "woop", 42); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal("shoop da 23 woop 42", git_buf_cstr(&buf)); + cl_assert_equal_s("shoop da 23 woop 42", git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -59,7 +59,7 @@ void test_core_buffer__2(void) cl_assert(buf.asize == 0); /* empty buffer should be empty string */ - cl_assert_strequal("", git_buf_cstr(&buf)); + cl_assert_equal_s("", git_buf_cstr(&buf)); cl_assert(buf.size == 0); /* cl_assert(buf.asize == 0); -- should not assume what git_buf does */ @@ -71,38 +71,38 @@ void test_core_buffer__2(void) /* add letter */ git_buf_putc(&buf, '+'); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal("+", git_buf_cstr(&buf)); + cl_assert_equal_s("+", git_buf_cstr(&buf)); /* add letter again */ git_buf_putc(&buf, '+'); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal("++", git_buf_cstr(&buf)); + cl_assert_equal_s("++", git_buf_cstr(&buf)); /* let's try that a few times */ for (i = 0; i < 16; ++i) { git_buf_putc(&buf, '+'); cl_assert(git_buf_oom(&buf) == 0); } - cl_assert_strequal("++++++++++++++++++", git_buf_cstr(&buf)); + cl_assert_equal_s("++++++++++++++++++", git_buf_cstr(&buf)); git_buf_free(&buf); /* add data */ git_buf_put(&buf, "xo", 2); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal("xo", git_buf_cstr(&buf)); + cl_assert_equal_s("xo", git_buf_cstr(&buf)); /* add letter again */ git_buf_put(&buf, "xo", 2); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal("xoxo", git_buf_cstr(&buf)); + cl_assert_equal_s("xoxo", git_buf_cstr(&buf)); /* let's try that a few times */ for (i = 0; i < 16; ++i) { git_buf_put(&buf, "xo", 2); cl_assert(git_buf_oom(&buf) == 0); } - cl_assert_strequal("xoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxo", + cl_assert_equal_s("xoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxo", git_buf_cstr(&buf)); git_buf_free(&buf); @@ -110,21 +110,21 @@ void test_core_buffer__2(void) /* set to string */ git_buf_sets(&buf, test_string); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(test_string, git_buf_cstr(&buf)); + cl_assert_equal_s(test_string, git_buf_cstr(&buf)); /* append string */ git_buf_puts(&buf, test_string); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(test_string_x2, git_buf_cstr(&buf)); + cl_assert_equal_s(test_string_x2, git_buf_cstr(&buf)); /* set to string again (should overwrite - not append) */ git_buf_sets(&buf, test_string); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(test_string, git_buf_cstr(&buf)); + cl_assert_equal_s(test_string, git_buf_cstr(&buf)); /* test clear */ git_buf_clear(&buf); - cl_assert_strequal("", git_buf_cstr(&buf)); + cl_assert_equal_s("", git_buf_cstr(&buf)); git_buf_free(&buf); @@ -133,27 +133,27 @@ void test_core_buffer__2(void) cl_assert(git_buf_oom(&buf) == 0); git_buf_copy_cstr(data, sizeof(data), &buf); - cl_assert_strequal(REP4("0123456789"), data); + cl_assert_equal_s(REP4("0123456789"), data); git_buf_copy_cstr(data, 11, &buf); - cl_assert_strequal("0123456789", data); + cl_assert_equal_s("0123456789", data); git_buf_copy_cstr(data, 3, &buf); - cl_assert_strequal("01", data); + cl_assert_equal_s("01", data); git_buf_copy_cstr(data, 1, &buf); - cl_assert_strequal("", data); + cl_assert_equal_s("", data); git_buf_copy_cstr(data, sizeof(data), &buf); - cl_assert_strequal(REP4("0123456789"), data); + cl_assert_equal_s(REP4("0123456789"), data); git_buf_sets(&buf, REP256("x")); git_buf_copy_cstr(data, sizeof(data), &buf); /* since sizeof(data) == 128, only 127 bytes should be copied */ - cl_assert_strequal(REP4(REP16("x")) REP16("x") REP16("x") + cl_assert_equal_s(REP4(REP16("x")) REP16("x") REP16("x") REP16("x") "xxxxxxxxxxxxxxx", data); git_buf_free(&buf); git_buf_copy_cstr(data, sizeof(data), &buf); - cl_assert_strequal("", data); + cl_assert_equal_s("", data); } /* let's do some tests with larger buffers to push our limits */ @@ -164,17 +164,17 @@ void test_core_buffer__3(void) /* set to string */ git_buf_set(&buf, test_4096, 4096); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(test_4096, git_buf_cstr(&buf)); + cl_assert_equal_s(test_4096, git_buf_cstr(&buf)); /* append string */ git_buf_puts(&buf, test_4096); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(test_8192, git_buf_cstr(&buf)); + cl_assert_equal_s(test_8192, git_buf_cstr(&buf)); /* set to string again (should overwrite - not append) */ git_buf_set(&buf, test_4096, 4096); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(test_4096, git_buf_cstr(&buf)); + cl_assert_equal_s(test_4096, git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -192,22 +192,22 @@ void test_core_buffer__4(void) cl_assert(strlen(git_buf_cstr(&buf)) == (size_t)((i + 1) * 2)); } /* we have appended 1234 10x and removed the first 20 letters */ - cl_assert_strequal("12341234123412341234", git_buf_cstr(&buf)); + cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf)); git_buf_consume(&buf, NULL); - cl_assert_strequal("12341234123412341234", git_buf_cstr(&buf)); + cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf)); git_buf_consume(&buf, "invalid pointer"); - cl_assert_strequal("12341234123412341234", git_buf_cstr(&buf)); + cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf)); git_buf_consume(&buf, buf.ptr); - cl_assert_strequal("12341234123412341234", git_buf_cstr(&buf)); + cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf)); git_buf_consume(&buf, buf.ptr + 1); - cl_assert_strequal("2341234123412341234", git_buf_cstr(&buf)); + cl_assert_equal_s("2341234123412341234", git_buf_cstr(&buf)); git_buf_consume(&buf, buf.ptr + buf.size); - cl_assert_strequal("", git_buf_cstr(&buf)); + cl_assert_equal_s("", git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -227,7 +227,7 @@ check_buf_append( cl_assert(git_buf_oom(&tgt) == 0); git_buf_puts(&tgt, data_b); cl_assert(git_buf_oom(&tgt) == 0); - cl_assert_strequal(expected_data, git_buf_cstr(&tgt)); + cl_assert_equal_s(expected_data, git_buf_cstr(&tgt)); cl_assert(tgt.size == expected_size); if (expected_asize > 0) cl_assert(tgt.asize == expected_asize); @@ -250,27 +250,27 @@ check_buf_append_abc( git_buf_sets(&buf, buf_a); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(buf_a, git_buf_cstr(&buf)); + cl_assert_equal_s(buf_a, git_buf_cstr(&buf)); git_buf_puts(&buf, buf_b); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(expected_ab, git_buf_cstr(&buf)); + cl_assert_equal_s(expected_ab, git_buf_cstr(&buf)); git_buf_puts(&buf, buf_c); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(expected_abc, git_buf_cstr(&buf)); + cl_assert_equal_s(expected_abc, git_buf_cstr(&buf)); git_buf_puts(&buf, buf_a); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(expected_abca, git_buf_cstr(&buf)); + cl_assert_equal_s(expected_abca, git_buf_cstr(&buf)); git_buf_puts(&buf, buf_b); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(expected_abcab, git_buf_cstr(&buf)); + cl_assert_equal_s(expected_abcab, git_buf_cstr(&buf)); git_buf_puts(&buf, buf_c); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(expected_abcabc, git_buf_cstr(&buf)); + cl_assert_equal_s(expected_abcabc, git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -330,13 +330,13 @@ void test_core_buffer__6(void) git_buf_sets(&b, "bar"); cl_assert(git_buf_oom(&b) == 0); - cl_assert_strequal("foo", git_buf_cstr(&a)); - cl_assert_strequal("bar", git_buf_cstr(&b)); + cl_assert_equal_s("foo", git_buf_cstr(&a)); + cl_assert_equal_s("bar", git_buf_cstr(&b)); git_buf_swap(&a, &b); - cl_assert_strequal("bar", git_buf_cstr(&a)); - cl_assert_strequal("foo", git_buf_cstr(&b)); + cl_assert_equal_s("bar", git_buf_cstr(&a)); + cl_assert_equal_s("foo", git_buf_cstr(&b)); git_buf_free(&a); git_buf_free(&b); @@ -352,25 +352,25 @@ void test_core_buffer__7(void) git_buf_sets(&a, "foo"); cl_assert(git_buf_oom(&a) == 0); - cl_assert_strequal("foo", git_buf_cstr(&a)); + cl_assert_equal_s("foo", git_buf_cstr(&a)); b = git_buf_detach(&a); - cl_assert_strequal("foo", b); - cl_assert_strequal("", a.ptr); + cl_assert_equal_s("foo", b); + cl_assert_equal_s("", a.ptr); git__free(b); b = git_buf_detach(&a); - cl_assert_strequal(NULL, b); - cl_assert_strequal("", a.ptr); + cl_assert_equal_s(NULL, b); + cl_assert_equal_s("", a.ptr); git_buf_free(&a); b = git__strdup(fun); git_buf_attach(&a, b, 0); - cl_assert_strequal(fun, a.ptr); + cl_assert_equal_s(fun, a.ptr); cl_assert(a.size == strlen(fun)); cl_assert(a.asize == strlen(fun) + 1); @@ -379,7 +379,7 @@ void test_core_buffer__7(void) b = git__strdup(fun); git_buf_attach(&a, b, strlen(fun) + 1); - cl_assert_strequal(fun, a.ptr); + cl_assert_equal_s(fun, a.ptr); cl_assert(a.size == strlen(fun)); cl_assert(a.asize == strlen(fun) + 1); @@ -398,7 +398,7 @@ check_joinbuf_2( git_buf_join(&buf, sep, a, b); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(expected, git_buf_cstr(&buf)); + cl_assert_equal_s(expected, git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -416,7 +416,7 @@ check_joinbuf_n_2( git_buf_join_n(&buf, sep, 1, b); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(expected, git_buf_cstr(&buf)); + cl_assert_equal_s(expected, git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -433,7 +433,7 @@ check_joinbuf_n_4( git_buf buf = GIT_BUF_INIT; git_buf_join_n(&buf, sep, 4, a, b, c, d); cl_assert(git_buf_oom(&buf) == 0); - cl_assert_strequal(expected, git_buf_cstr(&buf)); + cl_assert_equal_s(expected, git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -444,15 +444,15 @@ void test_core_buffer__8(void) git_buf_join_n(&a, '/', 1, "foo"); cl_assert(git_buf_oom(&a) == 0); - cl_assert_strequal("foo", git_buf_cstr(&a)); + cl_assert_equal_s("foo", git_buf_cstr(&a)); git_buf_join_n(&a, '/', 1, "bar"); cl_assert(git_buf_oom(&a) == 0); - cl_assert_strequal("foo/bar", git_buf_cstr(&a)); + cl_assert_equal_s("foo/bar", git_buf_cstr(&a)); git_buf_join_n(&a, '/', 1, "baz"); cl_assert(git_buf_oom(&a) == 0); - cl_assert_strequal("foo/bar/baz", git_buf_cstr(&a)); + cl_assert_equal_s("foo/bar/baz", git_buf_cstr(&a)); git_buf_free(&a); @@ -536,7 +536,7 @@ void test_core_buffer__9(void) for (j = 0; j < sizeof(b) / sizeof(char*); ++j) { for (i = 0; i < sizeof(a) / sizeof(char*); ++i) { git_buf_join(&buf, separator, a[i], b[j]); - cl_assert_strequal(*expect, buf.ptr); + cl_assert_equal_s(*expect, buf.ptr); expect++; } } @@ -544,3 +544,20 @@ void test_core_buffer__9(void) git_buf_free(&buf); } + +void test_core_buffer__10(void) +{ + git_buf a = GIT_BUF_INIT; + + cl_git_pass(git_buf_join_n(&a, '/', 1, "test")); + cl_assert_equal_s(a.ptr, "test"); + cl_git_pass(git_buf_join_n(&a, '/', 1, "string")); + cl_assert_equal_s(a.ptr, "test/string"); + git_buf_clear(&a); + cl_git_pass(git_buf_join_n(&a, '/', 3, "test", "string", "join")); + cl_assert_equal_s(a.ptr, "test/string/join"); + cl_git_pass(git_buf_join_n(&a, '/', 2, a.ptr, "more")); + cl_assert_equal_s(a.ptr, "test/string/join/test/string/join/more"); + + git_buf_free(&a); +} diff --git a/tests-clar/core/errors.c b/tests-clar/core/errors.c new file mode 100644 index 000000000..0be3e7aca --- /dev/null +++ b/tests-clar/core/errors.c @@ -0,0 +1,60 @@ +#include "clar_libgit2.h" +#include "common.h" +#include "util.h" +#include "posix.h" + +void test_core_errors__new_school(void) +{ + char *str_in_error; + + giterr_clear(); + cl_assert(giterr_last() == NULL); + + giterr_set_oom(); /* internal fn */ + + cl_assert(giterr_last() != NULL); + cl_assert(giterr_last()->klass == GITERR_NOMEMORY); + str_in_error = strstr(giterr_last()->message, "memory"); + cl_assert(str_in_error != NULL); + + giterr_clear(); + + giterr_set(GITERR_REPOSITORY, "This is a test"); /* internal fn */ + + cl_assert(giterr_last() != NULL); + str_in_error = strstr(giterr_last()->message, "This is a test"); + cl_assert(str_in_error != NULL); + + giterr_clear(); + cl_assert(giterr_last() == NULL); + + do { + struct stat st; + memset(&st, 0, sizeof(st)); + assert(p_lstat("this_file_does_not_exist", &st) < 0); + GIT_UNUSED(st); + } while (false); + giterr_set(GITERR_OS, "stat failed"); /* internal fn */ + + cl_assert(giterr_last() != NULL); + str_in_error = strstr(giterr_last()->message, "stat failed"); + cl_assert(str_in_error != NULL); + cl_assert(git__prefixcmp(str_in_error, "stat failed: ") == 0); + cl_assert(strlen(str_in_error) > strlen("stat failed: ")); + +#ifdef GIT_WIN32 + giterr_clear(); + + /* The MSDN docs use this to generate a sample error */ + cl_assert(GetProcessId(NULL) == 0); + giterr_set(GITERR_OS, "GetProcessId failed"); /* internal fn */ + + cl_assert(giterr_last() != NULL); + str_in_error = strstr(giterr_last()->message, "GetProcessId failed"); + cl_assert(str_in_error != NULL); + cl_assert(git__prefixcmp(str_in_error, "GetProcessId failed: ") == 0); + cl_assert(strlen(str_in_error) > strlen("GetProcessId failed: ")); +#endif + + giterr_clear(); +} diff --git a/tests-clar/core/filebuf.c b/tests-clar/core/filebuf.c index 29d6bca74..eab8a26eb 100644 --- a/tests-clar/core/filebuf.c +++ b/tests-clar/core/filebuf.c @@ -14,7 +14,7 @@ void test_core_filebuf__0(void) cl_must_pass(p_close(fd)); cl_git_fail(git_filebuf_open(&file, test, 0)); - cl_git_pass(git_path_exists(testlock)); + cl_assert(git_path_exists(testlock)); cl_must_pass(p_unlink(testlock)); } @@ -56,20 +56,6 @@ void test_core_filebuf__2(void) cl_must_pass(p_unlink(test)); } - -/* make sure git_filebuf_open won't reopen an open buffer */ -void test_core_filebuf__3(void) -{ - git_filebuf file = GIT_FILEBUF_INIT; - char test[] = "test"; - - cl_git_pass(git_filebuf_open(&file, test, 0)); - cl_git_fail(git_filebuf_open(&file, test, 0)); - - git_filebuf_cleanup(&file); -} - - /* make sure git_filebuf_cleanup clears the buffer */ void test_core_filebuf__4(void) { diff --git a/tests-clar/core/oid.c b/tests-clar/core/oid.c index 60361c42c..c89713955 100644 --- a/tests-clar/core/oid.c +++ b/tests-clar/core/oid.c @@ -10,9 +10,9 @@ void test_core_oid__initialize(void) void test_core_oid__streq(void) { - cl_assert(git_oid_streq(&id, str_oid) == GIT_SUCCESS); - cl_assert(git_oid_streq(&id, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef") == GIT_ERROR); + cl_assert(git_oid_streq(&id, str_oid) == 0); + cl_assert(git_oid_streq(&id, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef") == -1); - cl_assert(git_oid_streq(&id, "deadbeef") == GIT_ENOTOID); - cl_assert(git_oid_streq(&id, "I'm not an oid.... :)") == GIT_ENOTOID); + cl_assert(git_oid_streq(&id, "deadbeef") == -1); + cl_assert(git_oid_streq(&id, "I'm not an oid.... :)") == -1); } diff --git a/tests-clar/core/path.c b/tests-clar/core/path.c index c07362f1d..f02e0f761 100644 --- a/tests-clar/core/path.c +++ b/tests-clar/core/path.c @@ -8,11 +8,11 @@ check_dirname(const char *A, const char *B) char *dir2; cl_assert(git_path_dirname_r(&dir, A) >= 0); - cl_assert_strequal(B, dir.ptr); + cl_assert_equal_s(B, dir.ptr); git_buf_free(&dir); cl_assert((dir2 = git_path_dirname(A)) != NULL); - cl_assert_strequal(B, dir2); + cl_assert_equal_s(B, dir2); git__free(dir2); } @@ -23,11 +23,11 @@ check_basename(const char *A, const char *B) char *base2; cl_assert(git_path_basename_r(&base, A) >= 0); - cl_assert_strequal(B, base.ptr); + cl_assert_equal_s(B, base.ptr); git_buf_free(&base); cl_assert((base2 = git_path_basename(A)) != NULL); - cl_assert_strequal(B, base2); + cl_assert_equal_s(B, base2); git__free(base2); } @@ -37,7 +37,7 @@ check_topdir(const char *A, const char *B) const char *dir; cl_assert((dir = git_path_topdir(A)) != NULL); - cl_assert_strequal(B, dir); + cl_assert_equal_s(B, dir); } static void @@ -46,7 +46,7 @@ check_joinpath(const char *path_a, const char *path_b, const char *expected_path git_buf joined_path = GIT_BUF_INIT; cl_git_pass(git_buf_joinpath(&joined_path, path_a, path_b)); - cl_assert_strequal(expected_path, joined_path.ptr); + cl_assert_equal_s(expected_path, joined_path.ptr); git_buf_free(&joined_path); } @@ -63,7 +63,7 @@ check_joinpath_n( cl_git_pass(git_buf_join_n(&joined_path, '/', 4, path_a, path_b, path_c, path_d)); - cl_assert_strequal(expected_path, joined_path.ptr); + cl_assert_equal_s(expected_path, joined_path.ptr); git_buf_free(&joined_path); } @@ -189,7 +189,7 @@ check_path_to_dir( git_buf_sets(&tgt, path); cl_git_pass(git_path_to_dir(&tgt)); - cl_assert_strequal(expected, tgt.ptr); + cl_assert_equal_s(expected, tgt.ptr); git_buf_free(&tgt); } @@ -197,16 +197,18 @@ check_path_to_dir( static void check_string_to_dir( const char* path, - int maxlen, + size_t maxlen, const char* expected) { - int len = strlen(path); + size_t len = strlen(path); char *buf = git__malloc(len + 2); + cl_assert(buf); + strncpy(buf, path, len + 2); git_path_string_to_dir(buf, maxlen); - cl_assert_strequal(expected, buf); + cl_assert_equal_s(expected, buf); git__free(buf); } @@ -247,28 +249,28 @@ void test_core_path__08_self_join(void) asize = path.asize; cl_git_pass(git_buf_sets(&path, "/foo")); - cl_assert_strequal(path.ptr, "/foo"); + cl_assert_equal_s(path.ptr, "/foo"); cl_assert(asize < path.asize); asize = path.asize; cl_git_pass(git_buf_joinpath(&path, path.ptr, "this is a new string")); - cl_assert_strequal(path.ptr, "/foo/this is a new string"); + cl_assert_equal_s(path.ptr, "/foo/this is a new string"); cl_assert(asize < path.asize); asize = path.asize; cl_git_pass(git_buf_joinpath(&path, path.ptr, "/grow the buffer, grow the buffer, grow the buffer")); - cl_assert_strequal(path.ptr, "/foo/this is a new string/grow the buffer, grow the buffer, grow the buffer"); + cl_assert_equal_s(path.ptr, "/foo/this is a new string/grow the buffer, grow the buffer, grow the buffer"); cl_assert(asize < path.asize); git_buf_free(&path); cl_git_pass(git_buf_sets(&path, "/foo/bar")); cl_git_pass(git_buf_joinpath(&path, path.ptr + 4, "baz")); - cl_assert_strequal(path.ptr, "/bar/baz"); + cl_assert_equal_s(path.ptr, "/bar/baz"); asize = path.asize; cl_git_pass(git_buf_joinpath(&path, path.ptr + 4, "somethinglongenoughtorealloc")); - cl_assert_strequal(path.ptr, "/baz/somethinglongenoughtorealloc"); + cl_assert_equal_s(path.ptr, "/baz/somethinglongenoughtorealloc"); cl_assert(asize < path.asize); git_buf_free(&path); @@ -279,7 +281,7 @@ static void check_percent_decoding(const char *expected_result, const char *inpu git_buf buf = GIT_BUF_INIT; cl_git_pass(git__percent_decode(&buf, input)); - cl_assert_strequal(expected_result, git_buf_cstr(&buf)); + cl_assert_equal_s(expected_result, git_buf_cstr(&buf)); git_buf_free(&buf); } @@ -306,7 +308,7 @@ static void check_fromurl(const char *expected_result, const char *input, int sh if (!should_fail) { cl_git_pass(git_path_fromurl(&buf, input)); - cl_assert_strequal(expected_result, git_buf_cstr(&buf)); + cl_assert_equal_s(expected_result, git_buf_cstr(&buf)); } else cl_git_fail(git_path_fromurl(&buf, input)); @@ -346,9 +348,9 @@ static int check_one_walkup_step(void *ref, git_buf *path) { check_walkup_info *info = (check_walkup_info *)ref; cl_assert(info->expect[info->expect_idx] != NULL); - cl_assert_strequal(info->expect[info->expect_idx], path->ptr); + cl_assert_equal_s(info->expect[info->expect_idx], path->ptr); info->expect_idx++; - return GIT_SUCCESS; + return 0; } void test_core_path__11_walkup(void) @@ -380,7 +382,7 @@ void test_core_path__11_walkup(void) git_path_walk_up(&p, root[j], check_one_walkup_step, &info) ); - cl_assert_strequal(p.ptr, expect[i]); + cl_assert_equal_s(p.ptr, expect[i]); /* skip to next run of expectations */ while (expect[i] != NULL) i++; @@ -388,3 +390,18 @@ void test_core_path__11_walkup(void) git_buf_free(&p); } + +void test_core_path__12_offset_to_path_root(void) +{ + cl_assert(git_path_root("non/rooted/path") == -1); + cl_assert(git_path_root("/rooted/path") == 0); + +#ifdef GIT_WIN32 + /* Windows specific tests */ + cl_assert(git_path_root("C:non/rooted/path") == -1); + cl_assert(git_path_root("C:/rooted/path") == 2); + cl_assert(git_path_root("//computername/sharefolder/resource") == 14); + cl_assert(git_path_root("//computername/sharefolder") == 14); + cl_assert(git_path_root("//computername") == -1); +#endif +} diff --git a/tests-clar/core/pool.c b/tests-clar/core/pool.c new file mode 100644 index 000000000..5ed97366f --- /dev/null +++ b/tests-clar/core/pool.c @@ -0,0 +1,85 @@ +#include "clar_libgit2.h" +#include "pool.h" +#include "git2/oid.h" + +void test_core_pool__0(void) +{ + int i; + git_pool p; + void *ptr; + + cl_git_pass(git_pool_init(&p, 1, 4000)); + + for (i = 1; i < 10000; i *= 2) { + ptr = git_pool_malloc(&p, i); + cl_assert(ptr != NULL); + cl_assert(git_pool__ptr_in_pool(&p, ptr)); + cl_assert(!git_pool__ptr_in_pool(&p, &i)); + } + + /* 1+2+4+8+16+32+64+128+256+512+1024 -> original block */ + /* 2048 -> 1 block */ + /* 4096 -> 1 block */ + /* 8192 -> 1 block */ + + cl_assert(git_pool__open_pages(&p) + git_pool__full_pages(&p) == 4); + + git_pool_clear(&p); +} + +void test_core_pool__1(void) +{ + int i; + git_pool p; + + cl_git_pass(git_pool_init(&p, 1, 4000)); + + for (i = 2010; i > 0; i--) + cl_assert(git_pool_malloc(&p, i) != NULL); + + /* with fixed page size, allocation must end up with these values */ + cl_assert(git_pool__open_pages(&p) == 1); + cl_assert(git_pool__full_pages(&p) == 505); + + git_pool_clear(&p); + + cl_git_pass(git_pool_init(&p, 1, 4100)); + + for (i = 2010; i > 0; i--) + cl_assert(git_pool_malloc(&p, i) != NULL); + + /* with fixed page size, allocation must end up with these values */ + cl_assert(git_pool__open_pages(&p) == 1); + cl_assert(git_pool__full_pages(&p) == 492); + + git_pool_clear(&p); +} + +static char to_hex[] = "0123456789abcdef"; + +void test_core_pool__2(void) +{ + git_pool p; + char oid_hex[GIT_OID_HEXSZ]; + git_oid *oid; + int i, j; + + memset(oid_hex, '0', sizeof(oid_hex)); + + cl_git_pass(git_pool_init(&p, sizeof(git_oid), 100)); + + for (i = 1000; i < 10000; i++) { + oid = git_pool_malloc(&p, 1); + cl_assert(oid != NULL); + + for (j = 0; j < 8; j++) + oid_hex[j] = to_hex[(i >> (4 * j)) & 0x0f]; + cl_git_pass(git_oid_fromstr(oid, oid_hex)); + } + + /* with fixed page size, allocation must end up with these values */ + cl_assert(git_pool__open_pages(&p) == 0); + cl_assert(git_pool__full_pages(&p) == 90); + + git_pool_clear(&p); +} diff --git a/tests-clar/core/rmdir.c b/tests-clar/core/rmdir.c index 66b647587..530f1f908 100644 --- a/tests-clar/core/rmdir.c +++ b/tests-clar/core/rmdir.c @@ -30,25 +30,39 @@ void test_core_rmdir__initialize(void) /* make sure empty dir can be deleted recusively */ void test_core_rmdir__delete_recursive(void) { - cl_git_pass(git_futils_rmdir_r(empty_tmp_dir, 0)); + cl_git_pass(git_futils_rmdir_r(empty_tmp_dir, GIT_DIRREMOVAL_EMPTY_HIERARCHY)); } /* make sure non-empty dir cannot be deleted recusively */ void test_core_rmdir__fail_to_delete_non_empty_dir(void) { git_buf file = GIT_BUF_INIT; - int fd; cl_git_pass(git_buf_joinpath(&file, empty_tmp_dir, "/two/file.txt")); - fd = p_creat(file.ptr, 0666); - cl_assert(fd >= 0); + cl_git_mkfile(git_buf_cstr(&file), "dummy"); - cl_must_pass(p_close(fd)); - cl_git_fail(git_futils_rmdir_r(empty_tmp_dir, 0)); + cl_git_fail(git_futils_rmdir_r(empty_tmp_dir, GIT_DIRREMOVAL_EMPTY_HIERARCHY)); cl_must_pass(p_unlink(file.ptr)); - cl_git_pass(git_futils_rmdir_r(empty_tmp_dir, 0)); + cl_git_pass(git_futils_rmdir_r(empty_tmp_dir, GIT_DIRREMOVAL_EMPTY_HIERARCHY)); + + git_buf_free(&file); +} + +void test_core_rmdir__can_skip__non_empty_dir(void) +{ + git_buf file = GIT_BUF_INIT; + + cl_git_pass(git_buf_joinpath(&file, empty_tmp_dir, "/two/file.txt")); + + cl_git_mkfile(git_buf_cstr(&file), "dummy"); + + cl_git_pass(git_futils_rmdir_r(empty_tmp_dir, GIT_DIRREMOVAL_ONLY_EMPTY_DIRS)); + cl_assert(git_path_exists(git_buf_cstr(&file)) == true); + + cl_git_pass(git_futils_rmdir_r(empty_tmp_dir, GIT_DIRREMOVAL_FILES_AND_DIRS)); + cl_assert(git_path_exists(empty_tmp_dir) == false); git_buf_free(&file); } diff --git a/tests-clar/core/strmap.c b/tests-clar/core/strmap.c new file mode 100644 index 000000000..f34a4f89f --- /dev/null +++ b/tests-clar/core/strmap.c @@ -0,0 +1,102 @@ +#include "clar_libgit2.h" +#include "strmap.h" + +GIT__USE_STRMAP; + +void test_core_strmap__0(void) +{ + git_strmap *table = git_strmap_alloc(); + cl_assert(table != NULL); + cl_assert(git_strmap_num_entries(table) == 0); + git_strmap_free(table); +} + +static void insert_strings(git_strmap *table, int count) +{ + int i, j, over, err; + char *str; + + for (i = 0; i < count; ++i) { + str = malloc(10); + for (j = 0; j < 10; ++j) + str[j] = 'a' + (i % 26); + str[9] = '\0'; + + /* if > 26, then encode larger value in first letters */ + for (j = 0, over = i / 26; over > 0; j++, over = over / 26) + str[j] = 'A' + (over % 26); + + git_strmap_insert(table, str, str, err); + cl_assert(err >= 0); + } + + cl_assert((int)git_strmap_num_entries(table) == count); +} + +void test_core_strmap__1(void) +{ + int i; + char *str; + git_strmap *table = git_strmap_alloc(); + cl_assert(table != NULL); + + insert_strings(table, 20); + + cl_assert(git_strmap_exists(table, "aaaaaaaaa")); + cl_assert(git_strmap_exists(table, "ggggggggg")); + cl_assert(!git_strmap_exists(table, "aaaaaaaab")); + cl_assert(!git_strmap_exists(table, "abcdefghi")); + + i = 0; + git_strmap_foreach_value(table, str, { i++; free(str); }); + cl_assert(i == 20); + + git_strmap_free(table); +} + +void test_core_strmap__2(void) +{ + khiter_t pos; + int i; + char *str; + git_strmap *table = git_strmap_alloc(); + cl_assert(table != NULL); + + insert_strings(table, 20); + + cl_assert(git_strmap_exists(table, "aaaaaaaaa")); + cl_assert(git_strmap_exists(table, "ggggggggg")); + cl_assert(!git_strmap_exists(table, "aaaaaaaab")); + cl_assert(!git_strmap_exists(table, "abcdefghi")); + + cl_assert(git_strmap_exists(table, "bbbbbbbbb")); + pos = git_strmap_lookup_index(table, "bbbbbbbbb"); + cl_assert(git_strmap_valid_index(table, pos)); + cl_assert_equal_s(git_strmap_value_at(table, pos), "bbbbbbbbb"); + free(git_strmap_value_at(table, pos)); + git_strmap_delete_at(table, pos); + + cl_assert(!git_strmap_exists(table, "bbbbbbbbb")); + + i = 0; + git_strmap_foreach_value(table, str, { i++; free(str); }); + cl_assert(i == 19); + + git_strmap_free(table); +} + +void test_core_strmap__3(void) +{ + int i; + char *str; + git_strmap *table = git_strmap_alloc(); + cl_assert(table != NULL); + + insert_strings(table, 10000); + + i = 0; + git_strmap_foreach_value(table, str, { i++; free(str); }); + cl_assert(i == 10000); + + git_strmap_free(table); +} diff --git a/tests-clar/diff/diff_helpers.c b/tests-clar/diff/diff_helpers.c index d8eca7d9b..74a44ab99 100644 --- a/tests-clar/diff/diff_helpers.c +++ b/tests-clar/diff/diff_helpers.c @@ -5,10 +5,10 @@ git_tree *resolve_commit_oid_to_tree( git_repository *repo, const char *partial_oid) { - size_t len = strlen(partial_oid); + unsigned int len = (unsigned int)strlen(partial_oid); git_oid oid; - git_object *obj; - git_tree *tree; + git_object *obj = NULL; + git_tree *tree = NULL; if (git_oid_fromstrn(&oid, partial_oid, len) == 0) git_object_lookup_prefix(&obj, repo, &oid, len, GIT_OBJ_ANY); @@ -27,7 +27,9 @@ int diff_file_fn( float progress) { diff_expects *e = cb_data; - (void)progress; + + GIT_UNUSED(progress); + e->files++; switch (delta->status) { case GIT_DELTA_ADDED: e->file_adds++; break; @@ -48,9 +50,11 @@ int diff_hunk_fn( size_t header_len) { diff_expects *e = cb_data; - (void)delta; - (void)header; - (void)header_len; + + GIT_UNUSED(delta); + GIT_UNUSED(header); + GIT_UNUSED(header_len); + e->hunks++; e->hunk_old_lines += range->old_lines; e->hunk_new_lines += range->new_lines; @@ -60,14 +64,18 @@ int diff_hunk_fn( int diff_line_fn( void *cb_data, git_diff_delta *delta, + git_diff_range *range, char line_origin, const char *content, size_t content_len) { diff_expects *e = cb_data; - (void)delta; - (void)content; - (void)content_len; + + GIT_UNUSED(delta); + GIT_UNUSED(range); + GIT_UNUSED(content); + GIT_UNUSED(content_len); + e->lines++; switch (line_origin) { case GIT_DIFF_LINE_CONTEXT: diff --git a/tests-clar/diff/diff_helpers.h b/tests-clar/diff/diff_helpers.h index 010d156fa..ca8c40177 100644 --- a/tests-clar/diff/diff_helpers.h +++ b/tests-clar/diff/diff_helpers.h @@ -37,6 +37,7 @@ extern int diff_hunk_fn( extern int diff_line_fn( void *cb_data, git_diff_delta *delta, + git_diff_range *range, char line_origin, const char *content, size_t content_len); diff --git a/tests-clar/diff/iterator.c b/tests-clar/diff/iterator.c index 3953fd83f..0ec2326eb 100644 --- a/tests-clar/diff/iterator.c +++ b/tests-clar/diff/iterator.c @@ -37,7 +37,7 @@ static void tree_iterator_test( while (entry != NULL) { if (expected_values != NULL) - cl_assert_strequal(expected_values[count], entry->path); + cl_assert_equal_s(expected_values[count], entry->path); count++; @@ -139,6 +139,40 @@ void test_diff_iterator__tree_3(void) tree_iterator_test("status", "0017bd4ab1e", 8, expected_tree_3); } +/* $ git ls-tree -r --name-only 24fa9a9fc4e202313e24b648087495441dab432b */ +const char *expected_tree_4[] = { + "attr0", + "attr1", + "attr2", + "attr3", + "binfile", + "gitattributes", + "macro_bad", + "macro_test", + "root_test1", + "root_test2", + "root_test3", + "root_test4.txt", + "sub/abc", + "sub/file", + "sub/sub/file", + "sub/sub/subsub.txt", + "sub/subdir_test1", + "sub/subdir_test2.txt", + "subdir/.gitattributes", + "subdir/abc", + "subdir/subdir_test1", + "subdir/subdir_test2.txt", + "subdir2/subdir2_test1", + NULL +}; + +void test_diff_iterator__tree_4(void) +{ + tree_iterator_test( + "attr", "24fa9a9fc4e202313e24b648087495441dab432b", + 23, expected_tree_4); +} /* -- INDEX ITERATOR TESTS -- */ @@ -158,7 +192,7 @@ static void index_iterator_test( while (entry != NULL) { if (expected_names != NULL) - cl_assert_strequal(expected_names[count], entry->path); + cl_assert_equal_s(expected_names[count], entry->path); if (expected_oids != NULL) { git_oid oid; @@ -188,6 +222,12 @@ static const char *expected_index_0[] = { "root_test2", "root_test3", "root_test4.txt", + "sub/abc", + "sub/file", + "sub/sub/file", + "sub/sub/subsub.txt", + "sub/subdir_test1", + "sub/subdir_test2.txt", "subdir/.gitattributes", "subdir/abc", "subdir/subdir_test1", @@ -208,6 +248,12 @@ static const char *expected_index_oids_0[] = { "4d713dc48e6b1bd75b0d61ad078ba9ca3a56745d", "108bb4e7fd7b16490dc33ff7d972151e73d7166e", "fe773770c5a6cc7185580c9204b1ff18a33ff3fc", + "3e42ffc54a663f9401cc25843d6c0e71a33e4249", + "45b983be36b73c0788dc9cbcb76cbb80fc7bb057", + "45b983be36b73c0788dc9cbcb76cbb80fc7bb057", + "9e5bdc47d6a80f2be0ea3049ad74231b94609242", + "e563cf4758f0d646f1b14b76016aa17fa9e549a4", + "fb5067b1aef3ac1ada4b379dbcb7d17255df7d78", "99eae476896f4907224978b88e5ecaa6c5bb67a9", "3e42ffc54a663f9401cc25843d6c0e71a33e4249", "e563cf4758f0d646f1b14b76016aa17fa9e549a4", @@ -217,7 +263,7 @@ static const char *expected_index_oids_0[] = { void test_diff_iterator__index_0(void) { - index_iterator_test("attr", 17, expected_index_0, expected_index_oids_0); + index_iterator_test("attr", 23, expected_index_0, expected_index_oids_0); } static const char *expected_index_1[] = { @@ -284,7 +330,7 @@ static void workdir_iterator_test( } if (expected_names != NULL) - cl_assert_strequal(expected_names[count_all], entry->path); + cl_assert_equal_s(expected_names[count_all], entry->path); if (an_ignored_name && strcmp(an_ignored_name,entry->path)==0) cl_assert(ignored); diff --git a/tests-clar/diff/patch.c b/tests-clar/diff/patch.c new file mode 100644 index 000000000..05e748667 --- /dev/null +++ b/tests-clar/diff/patch.c @@ -0,0 +1,99 @@ +#include "clar_libgit2.h" +#include "diff_helpers.h" + +static git_repository *g_repo = NULL; + +void test_diff_patch__initialize(void) +{ + g_repo = cl_git_sandbox_init("status"); +} + +void test_diff_patch__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +#define EXPECTED_HEADER "diff --git a/subdir.txt b/subdir.txt\n" \ + "deleted file mode 100644\n" \ + "index e8ee89e..0000000\n" \ + "--- a/subdir.txt\n" \ + "+++ /dev/null\n" + +#define EXPECTED_HUNK "@@ -1,2 +0,0 @@\n" + +static int check_removal_cb( + void *cb_data, + git_diff_delta *delta, + git_diff_range *range, + char line_origin, + const char *formatted_output, + size_t output_len) +{ + GIT_UNUSED(cb_data); + GIT_UNUSED(output_len); + + switch (line_origin) { + case GIT_DIFF_LINE_FILE_HDR: + cl_assert_equal_s(EXPECTED_HEADER, formatted_output); + cl_assert(range == NULL); + goto check_delta; + + case GIT_DIFF_LINE_HUNK_HDR: + cl_assert_equal_s(EXPECTED_HUNK, formatted_output); + /* Fall through */ + + case GIT_DIFF_LINE_CONTEXT: + case GIT_DIFF_LINE_DELETION: + goto check_range; + + default: + /* unexpected code path */ + return -1; + } + +check_range: + cl_assert(range != NULL); + cl_assert_equal_i(1, range->old_start); + cl_assert_equal_i(2, range->old_lines); + cl_assert_equal_i(0, range->new_start); + cl_assert_equal_i(0, range->new_lines); + +check_delta: + cl_assert_equal_s("subdir.txt", delta->old_file.path); + cl_assert_equal_s("subdir.txt", delta->new_file.path); + cl_assert_equal_i(GIT_DELTA_DELETED, delta->status); + + return 0; +} + +void test_diff_patch__can_properly_display_the_removal_of_a_file(void) +{ + /* + * $ git diff 26a125e..735b6a2 + * diff --git a/subdir.txt b/subdir.txt + * deleted file mode 100644 + * index e8ee89e..0000000 + * --- a/subdir.txt + * +++ /dev/null + * @@ -1,2 +0,0 @@ + * -Is it a bird? + * -Is it a plane? + */ + + const char *one_sha = "26a125e"; + const char *another_sha = "735b6a2"; + git_tree *one, *another; + git_diff_list *diff; + + one = resolve_commit_oid_to_tree(g_repo, one_sha); + another = resolve_commit_oid_to_tree(g_repo, another_sha); + + cl_git_pass(git_diff_tree_to_tree(g_repo, NULL, one, another, &diff)); + + cl_git_pass(git_diff_print_patch(diff, NULL, check_removal_cb)); + + git_diff_list_free(diff); + + git_tree_free(another); + git_tree_free(one); +} diff --git a/tests-clar/diff/tree.c b/tests-clar/diff/tree.c index 91e1343cc..06f51a16b 100644 --- a/tests-clar/diff/tree.c +++ b/tests-clar/diff/tree.c @@ -5,7 +5,6 @@ static git_repository *g_repo = NULL; void test_diff_tree__initialize(void) { - g_repo = cl_git_sandbox_init("attr"); } void test_diff_tree__cleanup(void) @@ -19,15 +18,16 @@ void test_diff_tree__0(void) const char *a_commit = "605812a"; const char *b_commit = "370fe9ec22"; const char *c_commit = "f5b0af1fb4f5c"; - git_tree *a = resolve_commit_oid_to_tree(g_repo, a_commit); - git_tree *b = resolve_commit_oid_to_tree(g_repo, b_commit); - git_tree *c = resolve_commit_oid_to_tree(g_repo, c_commit); + git_tree *a, *b, *c; git_diff_options opts = {0}; git_diff_list *diff = NULL; diff_expects exp; - cl_assert(a); - cl_assert(b); + g_repo = cl_git_sandbox_init("attr"); + + cl_assert((a = resolve_commit_oid_to_tree(g_repo, a_commit)) != NULL); + cl_assert((b = resolve_commit_oid_to_tree(g_repo, b_commit)) != NULL); + cl_assert((c = resolve_commit_oid_to_tree(g_repo, c_commit)) != NULL); opts.context_lines = 1; opts.interhunk_lines = 1; @@ -87,12 +87,7 @@ void test_diff_tree__options(void) const char *b_commit = "605812ab7fe421fdd"; const char *c_commit = "f5b0af1fb4f5"; const char *d_commit = "a97cc019851"; - - git_tree *a = resolve_commit_oid_to_tree(g_repo, a_commit); - git_tree *b = resolve_commit_oid_to_tree(g_repo, b_commit); - git_tree *c = resolve_commit_oid_to_tree(g_repo, c_commit); - git_tree *d = resolve_commit_oid_to_tree(g_repo, d_commit); - + git_tree *a, *b, *c, *d; git_diff_options opts = {0}; git_diff_list *diff = NULL; diff_expects actual; @@ -133,8 +128,12 @@ void test_diff_tree__options(void) diff_expects *expected; int i; - cl_assert(a); - cl_assert(b); + g_repo = cl_git_sandbox_init("attr"); + + cl_assert((a = resolve_commit_oid_to_tree(g_repo, a_commit)) != NULL); + cl_assert((b = resolve_commit_oid_to_tree(g_repo, b_commit)) != NULL); + cl_assert((c = resolve_commit_oid_to_tree(g_repo, c_commit)) != NULL); + cl_assert((d = resolve_commit_oid_to_tree(g_repo, d_commit)) != NULL); for (i = 0; test_expects[i].files > 0; i++) { memset(&actual, 0, sizeof(actual)); /* clear accumulator */ @@ -149,15 +148,15 @@ void test_diff_tree__options(void) diff, &actual, diff_file_fn, diff_hunk_fn, diff_line_fn)); expected = &test_expects[i]; - cl_assert_intequal(actual.files, expected->files); - cl_assert_intequal(actual.file_adds, expected->file_adds); - cl_assert_intequal(actual.file_dels, expected->file_dels); - cl_assert_intequal(actual.file_mods, expected->file_mods); - cl_assert_intequal(actual.hunks, expected->hunks); - cl_assert_intequal(actual.lines, expected->lines); - cl_assert_intequal(actual.line_ctxt, expected->line_ctxt); - cl_assert_intequal(actual.line_adds, expected->line_adds); - cl_assert_intequal(actual.line_dels, expected->line_dels); + cl_assert_equal_i(actual.files, expected->files); + cl_assert_equal_i(actual.file_adds, expected->file_adds); + cl_assert_equal_i(actual.file_dels, expected->file_dels); + cl_assert_equal_i(actual.file_mods, expected->file_mods); + cl_assert_equal_i(actual.hunks, expected->hunks); + cl_assert_equal_i(actual.lines, expected->lines); + cl_assert_equal_i(actual.line_ctxt, expected->line_ctxt); + cl_assert_equal_i(actual.line_adds, expected->line_adds); + cl_assert_equal_i(actual.line_dels, expected->line_dels); git_diff_list_free(diff); diff = NULL; @@ -168,3 +167,44 @@ void test_diff_tree__options(void) git_tree_free(c); git_tree_free(d); } + +void test_diff_tree__bare(void) +{ + const char *a_commit = "8496071c1b46c85"; + const char *b_commit = "be3563ae3f79"; + git_tree *a, *b; + git_diff_options opts = {0}; + git_diff_list *diff = NULL; + diff_expects exp; + + g_repo = cl_git_sandbox_init("testrepo.git"); + + cl_assert((a = resolve_commit_oid_to_tree(g_repo, a_commit)) != NULL); + cl_assert((b = resolve_commit_oid_to_tree(g_repo, b_commit)) != NULL); + + opts.context_lines = 1; + opts.interhunk_lines = 1; + + memset(&exp, 0, sizeof(exp)); + + cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, a, b, &diff)); + + cl_git_pass(git_diff_foreach( + diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn)); + + cl_assert(exp.files == 3); + cl_assert(exp.file_adds == 2); + cl_assert(exp.file_dels == 0); + cl_assert(exp.file_mods == 1); + + cl_assert(exp.hunks == 3); + + cl_assert(exp.lines == 4); + cl_assert(exp.line_ctxt == 0); + cl_assert(exp.line_adds == 3); + cl_assert(exp.line_dels == 1); + + git_diff_list_free(diff); + git_tree_free(a); + git_tree_free(b); +} diff --git a/tests-clar/diff/workdir.c b/tests-clar/diff/workdir.c index 9fefdbb03..1ea1af86a 100644 --- a/tests-clar/diff/workdir.c +++ b/tests-clar/diff/workdir.c @@ -37,19 +37,19 @@ void test_diff_workdir__to_index(void) * - git diff * - mv .git .gitted */ - cl_assert_intequal(12, exp.files); - cl_assert_intequal(0, exp.file_adds); - cl_assert_intequal(4, exp.file_dels); - cl_assert_intequal(4, exp.file_mods); - cl_assert_intequal(1, exp.file_ignored); - cl_assert_intequal(3, exp.file_untracked); + cl_assert_equal_i(12, exp.files); + cl_assert_equal_i(0, exp.file_adds); + cl_assert_equal_i(4, exp.file_dels); + cl_assert_equal_i(4, exp.file_mods); + cl_assert_equal_i(1, exp.file_ignored); + cl_assert_equal_i(3, exp.file_untracked); - cl_assert_intequal(8, exp.hunks); + cl_assert_equal_i(8, exp.hunks); - cl_assert_intequal(14, exp.lines); - cl_assert_intequal(5, exp.line_ctxt); - cl_assert_intequal(4, exp.line_adds); - cl_assert_intequal(5, exp.line_dels); + cl_assert_equal_i(14, exp.lines); + cl_assert_equal_i(5, exp.line_ctxt); + cl_assert_equal_i(4, exp.line_adds); + cl_assert_equal_i(5, exp.line_dels); git_diff_list_free(diff); } @@ -164,6 +164,79 @@ void test_diff_workdir__to_tree(void) git_tree_free(b); } +void test_diff_workdir__to_index_with_pathspec(void) +{ + git_diff_options opts = {0}; + git_diff_list *diff = NULL; + diff_expects exp; + char *pathspec = NULL; + + opts.context_lines = 3; + opts.interhunk_lines = 1; + opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; + opts.pathspec.strings = &pathspec; + opts.pathspec.count = 1; + + memset(&exp, 0, sizeof(exp)); + + cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL)); + + cl_assert_equal_i(12, exp.files); + cl_assert_equal_i(0, exp.file_adds); + cl_assert_equal_i(4, exp.file_dels); + cl_assert_equal_i(4, exp.file_mods); + cl_assert_equal_i(1, exp.file_ignored); + cl_assert_equal_i(3, exp.file_untracked); + + git_diff_list_free(diff); + + memset(&exp, 0, sizeof(exp)); + pathspec = "modified_file"; + + cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL)); + + cl_assert_equal_i(1, exp.files); + cl_assert_equal_i(0, exp.file_adds); + cl_assert_equal_i(0, exp.file_dels); + cl_assert_equal_i(1, exp.file_mods); + cl_assert_equal_i(0, exp.file_ignored); + cl_assert_equal_i(0, exp.file_untracked); + + git_diff_list_free(diff); + + memset(&exp, 0, sizeof(exp)); + pathspec = "subdir"; + + cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL)); + + cl_assert_equal_i(3, exp.files); + cl_assert_equal_i(0, exp.file_adds); + cl_assert_equal_i(1, exp.file_dels); + cl_assert_equal_i(1, exp.file_mods); + cl_assert_equal_i(0, exp.file_ignored); + cl_assert_equal_i(1, exp.file_untracked); + + git_diff_list_free(diff); + + memset(&exp, 0, sizeof(exp)); + pathspec = "*_deleted"; + + cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL)); + + cl_assert_equal_i(2, exp.files); + cl_assert_equal_i(0, exp.file_adds); + cl_assert_equal_i(2, exp.file_dels); + cl_assert_equal_i(0, exp.file_mods); + cl_assert_equal_i(0, exp.file_ignored); + cl_assert_equal_i(0, exp.file_untracked); + + git_diff_list_free(diff); +} + /* PREPARATION OF TEST DATA * * Since there is no command line equivalent of git_diff_workdir_to_tree, diff --git a/tests-clar/hash/table.c b/tests-clar/hash/table.c deleted file mode 100644 index e69d38618..000000000 --- a/tests-clar/hash/table.c +++ /dev/null @@ -1,162 +0,0 @@ -#include "clar_libgit2.h" - -#include "hashtable.h" -#include "hash.h" - - -// Helpers -typedef struct _aux_object { - int __bulk; - git_oid id; - int visited; -} table_item; - -static uint32_t hash_func(const void *key, int hash_id) -{ - uint32_t r; - const git_oid *id = (const git_oid *)key; - - memcpy(&r, id->id + (hash_id * sizeof(uint32_t)), sizeof(r)); - return r; -} - -static int hash_cmpkey(const void *a, const void *b) -{ - return git_oid_cmp((const git_oid*)a, (const git_oid*)b); -} - - -void test_hash_table__new(void) -{ - // create a new hashtable - git_hashtable *table = NULL; - - table = git_hashtable_alloc(55, hash_func, hash_cmpkey); - cl_assert(table != NULL); - cl_assert(table->size_mask + 1 == 64); - - git_hashtable_free(table); -} - -void test_hash_table__fill(void) -{ - // fill the hashtable with random entries - const int objects_n = 32; - int i; - table_item *objects; - git_hashtable *table = NULL; - - table = git_hashtable_alloc(objects_n * 2, hash_func, hash_cmpkey); - cl_assert(table != NULL); - - objects = (table_item *)git__malloc(objects_n * sizeof(table_item)); - memset(objects, 0x0, objects_n * sizeof(table_item)); - - /* populate the hash table */ - for (i = 0; i < objects_n; ++i) { - git_hash_buf(&(objects[i].id), &i, sizeof(int)); - cl_git_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i]))); - } - - /* make sure all the inserted objects can be found */ - for (i = 0; i < objects_n; ++i) { - git_oid id; - table_item *ob; - - git_hash_buf(&id, &i, sizeof(int)); - ob = (table_item *)git_hashtable_lookup(table, &id); - - cl_assert(ob != NULL); - cl_assert(ob == &(objects[i])); - } - - /* make sure we cannot find inexisting objects */ - for (i = 0; i < 50; ++i) { - int hash_id; - git_oid id; - - hash_id = (rand() % 50000) + objects_n; - git_hash_buf(&id, &hash_id, sizeof(int)); - cl_assert(git_hashtable_lookup(table, &id) == NULL); - } - - git_hashtable_free(table); - git__free(objects); -} - - -void test_hash_table__resize(void) -{ - // make sure the table resizes automatically - const int objects_n = 64; - int i; - unsigned int old_size; - table_item *objects; - git_hashtable *table = NULL; - - table = git_hashtable_alloc(objects_n, hash_func, hash_cmpkey); - cl_assert(table != NULL); - - objects = (table_item*)git__malloc(objects_n * sizeof(table_item)); - memset(objects, 0x0, objects_n * sizeof(table_item)); - - old_size = table->size_mask + 1; - - /* populate the hash table -- should be automatically resized */ - for (i = 0; i < objects_n; ++i) { - git_hash_buf(&(objects[i].id), &i, sizeof(int)); - cl_git_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i]))); - } - - cl_assert(table->size_mask > old_size); - - /* make sure all the inserted objects can be found */ - for (i = 0; i < objects_n; ++i) { - git_oid id; - table_item *ob; - - git_hash_buf(&id, &i, sizeof(int)); - ob = (table_item *)git_hashtable_lookup(table, &id); - - cl_assert(ob != NULL); - cl_assert(ob == &(objects[i])); - } - - git_hashtable_free(table); - git__free(objects); -} - - -void test_hash_table__iterate(void) -{ - // iterate through all the contents of the table - - const int objects_n = 32; - int i; - table_item *objects, *ob; - - git_hashtable *table = NULL; - - table = git_hashtable_alloc(objects_n * 2, hash_func, hash_cmpkey); - cl_assert(table != NULL); - - objects = git__malloc(objects_n * sizeof(table_item)); - memset(objects, 0x0, objects_n * sizeof(table_item)); - - /* populate the hash table */ - for (i = 0; i < objects_n; ++i) { - git_hash_buf(&(objects[i].id), &i, sizeof(int)); - cl_git_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i]))); - } - - GIT_HASHTABLE_FOREACH_VALUE(table, ob, ob->visited = 1); - - /* make sure all nodes have been visited */ - for (i = 0; i < objects_n; ++i) - { - cl_assert(objects[i].visited); - } - - git_hashtable_free(table); - git__free(objects); -} diff --git a/tests-clar/index/tests.c b/tests-clar/index/tests.c index a8ca2eece..3d01b7cfb 100644 --- a/tests-clar/index/tests.c +++ b/tests-clar/index/tests.c @@ -107,7 +107,7 @@ void test_index_tests__default_test_index(void) for (i = 0; i < ARRAY_SIZE(test_entries); ++i) { git_index_entry *e = entries[test_entries[i].index]; - cl_assert_strequal(e->path, test_entries[i].path); + cl_assert_equal_s(e->path, test_entries[i].path); cl_assert(e->mtime.seconds == test_entries[i].mtime); cl_assert(e->file_size == test_entries[i].file_size); } diff --git a/tests-clar/network/createremotethenload.c b/tests-clar/network/createremotethenload.c index a805e2ddf..45931d376 100644 --- a/tests-clar/network/createremotethenload.c +++ b/tests-clar/network/createremotethenload.c @@ -28,6 +28,6 @@ void test_network_createremotethenload__cleanup(void) void test_network_createremotethenload__parsing(void) { - cl_assert_strequal(git_remote_name(_remote), "origin"); - cl_assert_strequal(git_remote_url(_remote), url); + cl_assert_equal_s(git_remote_name(_remote), "origin"); + cl_assert_equal_s(git_remote_url(_remote), url); } diff --git a/tests-clar/network/remotelocal.c b/tests-clar/network/remotelocal.c index 81af77756..e154226d9 100644 --- a/tests-clar/network/remotelocal.c +++ b/tests-clar/network/remotelocal.c @@ -71,6 +71,16 @@ static int count_ref__cb(git_remote_head *head, void *payload) return GIT_SUCCESS; } +static int ensure_peeled__cb(git_remote_head *head, void *payload) +{ + GIT_UNUSED(payload); + + if(strcmp(head->name, "refs/tags/test^{}") != 0) + return 0; + + return git_oid_streq(&head->oid, "e90810b8df3e80c413d903f631643c716887138d"); +} + static void connect_to_local_repository(const char *local_repository) { build_local_file_url(&file_path_buf, local_repository); @@ -88,7 +98,7 @@ void test_network_remotelocal__retrieve_advertised_references(void) cl_git_pass(git_remote_ls(remote, &count_ref__cb, &how_many_refs)); - cl_assert(how_many_refs == 12); /* 1 HEAD + 9 refs + 2 peeled tags */ + cl_assert(how_many_refs == 14); /* 1 HEAD + 6 heads + 1 lightweight tag + 3 annotated tags + 3 peeled target */ } void test_network_remotelocal__retrieve_advertised_references_from_spaced_repository(void) @@ -102,7 +112,17 @@ 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(how_many_refs == 12); /* 1 HEAD */ + cl_assert(how_many_refs == 14); /* 1 HEAD + 6 heads + 1 lightweight tag + 3 annotated tags + 3 peeled target */ + + git_remote_free(remote); /* Disconnect from the "spaced repo" before the cleanup */ + remote = NULL; cl_fixture_cleanup("spaced testrepo.git"); } + +void test_network_remotelocal__nested_tags_are_completely_peeled(void) +{ + connect_to_local_repository(cl_fixture("testrepo.git")); + + cl_git_pass(git_remote_ls(remote, &ensure_peeled__cb, NULL)); +} diff --git a/tests-clar/network/remotes.c b/tests-clar/network/remotes.c index 5dc5f3387..766a461b9 100644 --- a/tests-clar/network/remotes.c +++ b/tests-clar/network/remotes.c @@ -27,8 +27,8 @@ void test_network_remotes__cleanup(void) void test_network_remotes__parsing(void) { - cl_assert_strequal(git_remote_name(_remote), "test"); - cl_assert_strequal(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); + cl_assert_equal_s(git_remote_name(_remote), "test"); + cl_assert_equal_s(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); } void test_network_remotes__parsing_ssh_remote(void) @@ -53,24 +53,24 @@ void test_network_remotes__unsupported_transport_methods_are_unsupported(void) void test_network_remotes__refspec_parsing(void) { - cl_assert_strequal(git_refspec_src(_refspec), "refs/heads/*"); - cl_assert_strequal(git_refspec_dst(_refspec), "refs/remotes/test/*"); + cl_assert_equal_s(git_refspec_src(_refspec), "refs/heads/*"); + cl_assert_equal_s(git_refspec_dst(_refspec), "refs/remotes/test/*"); } void test_network_remotes__set_fetchspec(void) { cl_git_pass(git_remote_set_fetchspec(_remote, "refs/*:refs/*")); _refspec = git_remote_fetchspec(_remote); - cl_assert_strequal(git_refspec_src(_refspec), "refs/*"); - cl_assert_strequal(git_refspec_dst(_refspec), "refs/*"); + cl_assert_equal_s(git_refspec_src(_refspec), "refs/*"); + cl_assert_equal_s(git_refspec_dst(_refspec), "refs/*"); } void test_network_remotes__set_pushspec(void) { cl_git_pass(git_remote_set_pushspec(_remote, "refs/*:refs/*")); _refspec = git_remote_pushspec(_remote); - cl_assert_strequal(git_refspec_src(_refspec), "refs/*"); - cl_assert_strequal(git_refspec_dst(_refspec), "refs/*"); + cl_assert_equal_s(git_refspec_src(_refspec), "refs/*"); + cl_assert_equal_s(git_refspec_dst(_refspec), "refs/*"); } void test_network_remotes__save(void) @@ -90,19 +90,19 @@ void test_network_remotes__save(void) _refspec = git_remote_fetchspec(_remote); cl_assert(_refspec != NULL); - cl_assert_strequal(git_refspec_src(_refspec), "refs/heads/*"); - cl_assert_strequal(git_refspec_dst(_refspec), "refs/remotes/upstream/*"); + cl_assert_equal_s(git_refspec_src(_refspec), "refs/heads/*"); + cl_assert_equal_s(git_refspec_dst(_refspec), "refs/remotes/upstream/*"); _refspec = git_remote_pushspec(_remote); cl_assert(_refspec != NULL); - cl_assert_strequal(git_refspec_src(_refspec), "refs/heads/*"); - cl_assert_strequal(git_refspec_dst(_refspec), "refs/heads/*"); + cl_assert_equal_s(git_refspec_src(_refspec), "refs/heads/*"); + cl_assert_equal_s(git_refspec_dst(_refspec), "refs/heads/*"); } void test_network_remotes__fnmatch(void) { - cl_git_pass(git_refspec_src_match(_refspec, "refs/heads/master")); - cl_git_pass(git_refspec_src_match(_refspec, "refs/heads/multi/level/branch")); + cl_assert(git_refspec_src_matches(_refspec, "refs/heads/master")); + cl_assert(git_refspec_src_matches(_refspec, "refs/heads/multi/level/branch")); } void test_network_remotes__transform(void) @@ -111,7 +111,7 @@ void test_network_remotes__transform(void) memset(ref, 0x0, sizeof(ref)); cl_git_pass(git_refspec_transform(ref, sizeof(ref), _refspec, "refs/heads/master")); - cl_assert_strequal(ref, "refs/remotes/test/master"); + cl_assert_equal_s(ref, "refs/remotes/test/master"); } void test_network_remotes__transform_r(void) @@ -119,7 +119,7 @@ void test_network_remotes__transform_r(void) git_buf buf = GIT_BUF_INIT; cl_git_pass(git_refspec_transform_r(&buf, _refspec, "refs/heads/master")); - cl_assert_strequal(git_buf_cstr(&buf), "refs/remotes/test/master"); + cl_assert_equal_s(git_buf_cstr(&buf), "refs/remotes/test/master"); git_buf_free(&buf); } diff --git a/tests-clar/notes/notes.c b/tests-clar/notes/notes.c index bb5a85dd1..ca82ab29c 100644 --- a/tests-clar/notes/notes.c +++ b/tests-clar/notes/notes.c @@ -33,11 +33,11 @@ void test_notes_notes__1(void) cl_git_pass(git_note_read(&_note, _repo, NULL, &oid)); - cl_assert_strequal(git_note_message(_note), "hello world\n"); + cl_assert_equal_s(git_note_message(_note), "hello world\n"); cl_assert(!git_oid_cmp(git_note_oid(_note), ¬e_oid)); cl_git_pass(git_blob_lookup(&_blob, _repo, ¬e_oid)); - cl_assert_strequal(git_note_message(_note), git_blob_rawcontent(_blob)); + cl_assert_equal_s(git_note_message(_note), git_blob_rawcontent(_blob)); cl_git_fail(git_note_create(¬e_oid, _repo, _sig, _sig, NULL, &oid, "hello world\n")); cl_git_fail(git_note_create(¬e_oid, _repo, _sig, _sig, "refs/notes/some/namespace", &oid, "hello world\n")); diff --git a/tests-clar/notes/notesref.c b/tests-clar/notes/notesref.c new file mode 100644 index 000000000..79ad0afee --- /dev/null +++ b/tests-clar/notes/notesref.c @@ -0,0 +1,57 @@ +#include "clar_libgit2.h" + +#include "notes.h" + +static git_repository *_repo; +static git_note *_note; +static git_signature *_sig; +static git_config *_cfg; + +void test_notes_notesref__initialize(void) +{ + cl_fixture_sandbox("testrepo.git"); + cl_git_pass(git_repository_open(&_repo, "testrepo.git")); +} + +void test_notes_notesref__cleanup(void) +{ + git_note_free(_note); + git_signature_free(_sig); + git_config_free(_cfg); + + git_repository_free(_repo); + cl_fixture_cleanup("testrepo.git"); +} + +void test_notes_notesref__config_corenotesref(void) +{ + git_oid oid, note_oid; + const char *default_ref; + + cl_git_pass(git_signature_now(&_sig, "alice", "alice@example.com")); + cl_git_pass(git_oid_fromstr(&oid, "8496071c1b46c854b31185ea97743be6a8774479")); + + cl_git_pass(git_repository_config(&_cfg, _repo)); + + cl_git_pass(git_config_set_string(_cfg, "core.notesRef", "refs/notes/mydefaultnotesref")); + + cl_git_pass(git_note_create(¬e_oid, _repo, _sig, _sig, NULL, &oid, "test123test\n")); + + cl_git_pass(git_note_read(&_note, _repo, NULL, &oid)); + cl_assert(!strcmp(git_note_message(_note), "test123test\n")); + cl_assert(!git_oid_cmp(git_note_oid(_note), ¬e_oid)); + + git_note_free(_note); + + cl_git_pass(git_note_read(&_note, _repo, "refs/notes/mydefaultnotesref", &oid)); + cl_assert(!strcmp(git_note_message(_note), "test123test\n")); + cl_assert(!git_oid_cmp(git_note_oid(_note), ¬e_oid)); + + cl_git_pass(git_note_default_ref(&default_ref, _repo)); + cl_assert(!strcmp(default_ref, "refs/notes/mydefaultnotesref")); + + cl_git_pass(git_config_delete(_cfg, "core.notesRef")); + + cl_git_pass(git_note_default_ref(&default_ref, _repo)); + cl_assert(!strcmp(default_ref, GIT_NOTES_DEFAULT_REF)); +} diff --git a/tests-clar/object/raw/compare.c b/tests-clar/object/raw/compare.c index 6dc6d713f..1c9ce4b81 100644 --- a/tests-clar/object/raw/compare.c +++ b/tests-clar/object/raw/compare.c @@ -87,7 +87,7 @@ void test_object_raw_compare__compare_fmt_oids(void) /* Format produced the right result */ out[GIT_OID_HEXSZ] = '\0'; - cl_assert_strequal(exp, out); + cl_assert_equal_s(exp, out); } void test_object_raw_compare__compare_allocfmt_oids(void) @@ -100,7 +100,7 @@ void test_object_raw_compare__compare_allocfmt_oids(void) out = git_oid_allocfmt(&in); cl_assert(out); - cl_assert_strequal(exp, out); + cl_assert_equal_s(exp, out); git__free(out); } @@ -120,5 +120,5 @@ void test_object_raw_compare__compare_pathfmt_oids(void) /* Format produced the right result */ out[GIT_OID_HEXSZ + 1] = '\0'; - cl_assert_strequal(exp2, out); + cl_assert_equal_s(exp2, out); } diff --git a/tests-clar/object/raw/convert.c b/tests-clar/object/raw/convert.c index 4e7aecf6f..7f310ddf0 100644 --- a/tests-clar/object/raw/convert.c +++ b/tests-clar/object/raw/convert.c @@ -45,7 +45,7 @@ void test_object_raw_convert__succeed_on_oid_to_string_conversion(void) /* returns out as hex formatted c-string */ str = git_oid_tostr(out, sizeof(out), &in); cl_assert(str && str == out && *(str+GIT_OID_HEXSZ) == '\0'); - cl_assert_strequal(exp, out); + cl_assert_equal_s(exp, out); } void test_object_raw_convert__succeed_on_oid_to_string_conversion_big(void) @@ -66,7 +66,7 @@ void test_object_raw_convert__succeed_on_oid_to_string_conversion_big(void) /* returns big as hex formatted c-string */ str = git_oid_tostr(big, sizeof(big), &in); cl_assert(str && str == big && *(str+GIT_OID_HEXSZ) == '\0'); - cl_assert_strequal(exp, big); + cl_assert_equal_s(exp, big); /* check tail material is untouched */ cl_assert(str && str == big && *(str+GIT_OID_HEXSZ+1) == 'X'); diff --git a/tests-clar/object/raw/type2string.c b/tests-clar/object/raw/type2string.c index 2092d2c97..a3585487f 100644 --- a/tests-clar/object/raw/type2string.c +++ b/tests-clar/object/raw/type2string.c @@ -6,19 +6,19 @@ void test_object_raw_type2string__convert_type_to_string(void) { - cl_assert_strequal(git_object_type2string(GIT_OBJ_BAD), ""); - cl_assert_strequal(git_object_type2string(GIT_OBJ__EXT1), ""); - cl_assert_strequal(git_object_type2string(GIT_OBJ_COMMIT), "commit"); - cl_assert_strequal(git_object_type2string(GIT_OBJ_TREE), "tree"); - cl_assert_strequal(git_object_type2string(GIT_OBJ_BLOB), "blob"); - cl_assert_strequal(git_object_type2string(GIT_OBJ_TAG), "tag"); - cl_assert_strequal(git_object_type2string(GIT_OBJ__EXT2), ""); - cl_assert_strequal(git_object_type2string(GIT_OBJ_OFS_DELTA), "OFS_DELTA"); - cl_assert_strequal(git_object_type2string(GIT_OBJ_REF_DELTA), "REF_DELTA"); + cl_assert_equal_s(git_object_type2string(GIT_OBJ_BAD), ""); + cl_assert_equal_s(git_object_type2string(GIT_OBJ__EXT1), ""); + cl_assert_equal_s(git_object_type2string(GIT_OBJ_COMMIT), "commit"); + cl_assert_equal_s(git_object_type2string(GIT_OBJ_TREE), "tree"); + cl_assert_equal_s(git_object_type2string(GIT_OBJ_BLOB), "blob"); + cl_assert_equal_s(git_object_type2string(GIT_OBJ_TAG), "tag"); + cl_assert_equal_s(git_object_type2string(GIT_OBJ__EXT2), ""); + cl_assert_equal_s(git_object_type2string(GIT_OBJ_OFS_DELTA), "OFS_DELTA"); + cl_assert_equal_s(git_object_type2string(GIT_OBJ_REF_DELTA), "REF_DELTA"); - cl_assert_strequal(git_object_type2string(-2), ""); - cl_assert_strequal(git_object_type2string(8), ""); - cl_assert_strequal(git_object_type2string(1234), ""); + cl_assert_equal_s(git_object_type2string(-2), ""); + cl_assert_equal_s(git_object_type2string(8), ""); + cl_assert_equal_s(git_object_type2string(1234), ""); } void test_object_raw_type2string__convert_string_to_type(void) diff --git a/tests-clar/object/raw/write.c b/tests-clar/object/raw/write.c index 885d3364a..1b28d0df7 100644 --- a/tests-clar/object/raw/write.c +++ b/tests-clar/object/raw/write.c @@ -38,8 +38,8 @@ static void streaming_write(git_oid *oid, git_odb *odb, git_rawobj *raw) static void check_object_files(object_data *d) { - cl_git_pass(git_path_exists(d->dir)); - cl_git_pass(git_path_exists(d->file)); + cl_assert(git_path_exists(d->dir)); + cl_assert(git_path_exists(d->file)); } static void cmp_objects(git_rawobj *o1, git_rawobj *o2) diff --git a/tests-clar/object/tag/peel.c b/tests-clar/object/tag/peel.c new file mode 100644 index 000000000..97c5a7dd3 --- /dev/null +++ b/tests-clar/object/tag/peel.c @@ -0,0 +1,56 @@ +#include "clar_libgit2.h" +#include "tag.h" + +static git_repository *repo; +static git_tag *tag; +static git_object *target; + +void test_object_tag_peel__initialize(void) +{ + cl_fixture_sandbox("testrepo.git"); + cl_git_pass(git_repository_open(&repo, "testrepo.git")); +} + +void test_object_tag_peel__cleanup(void) +{ + git_tag_free(tag); + git_object_free(target); + git_repository_free(repo); + + cl_fixture_cleanup("testrepo.git"); +} + +static void retrieve_tag_from_oid(git_tag **tag_out, git_repository *repo, const char *sha) +{ + git_oid oid; + + cl_git_pass(git_oid_fromstr(&oid, sha)); + cl_git_pass(git_tag_lookup(tag_out, repo, &oid)); +} + +void test_object_tag_peel__can_peel_to_a_commit(void) +{ + retrieve_tag_from_oid(&tag, repo, "7b4384978d2493e851f9cca7858815fac9b10980"); + + cl_git_pass(git_tag_peel(&target, tag)); + cl_assert(git_object_type(target) == GIT_OBJ_COMMIT); + cl_git_pass(git_oid_streq(git_object_id(target), "e90810b8df3e80c413d903f631643c716887138d")); +} + +void test_object_tag_peel__can_peel_several_nested_tags_to_a_commit(void) +{ + retrieve_tag_from_oid(&tag, repo, "b25fa35b38051e4ae45d4222e795f9df2e43f1d1"); + + cl_git_pass(git_tag_peel(&target, tag)); + cl_assert(git_object_type(target) == GIT_OBJ_COMMIT); + cl_git_pass(git_oid_streq(git_object_id(target), "e90810b8df3e80c413d903f631643c716887138d")); +} + +void test_object_tag_peel__can_peel_to_a_non_commit(void) +{ + retrieve_tag_from_oid(&tag, repo, "521d87c1ec3aef9824daf6d96cc0ae3710766d91"); + + cl_git_pass(git_tag_peel(&target, tag)); + cl_assert(git_object_type(target) == GIT_OBJ_BLOB); + cl_git_pass(git_oid_streq(git_object_id(target), "1385f264afb75a56a5bec74243be9b367ba4ca08")); +} diff --git a/tests-clar/object/tag/read.c b/tests-clar/object/tag/read.c index 2ab31e59d..cfeb3aeee 100644 --- a/tests-clar/object/tag/read.c +++ b/tests-clar/object/tag/read.c @@ -56,7 +56,7 @@ void test_object_tag_read__parse(void) cl_git_pass(git_tag_lookup(&tag1, g_repo, &id1)); - cl_assert_strequal(git_tag_name(tag1), "test"); + cl_assert_equal_s(git_tag_name(tag1), "test"); cl_assert(git_tag_type(tag1) == GIT_OBJ_TAG); cl_git_pass(git_tag_target((git_object **)&tag2, tag1)); @@ -115,7 +115,7 @@ void test_object_tag_read__parse_without_tagger(void) cl_git_pass(git_tag_lookup(&bad_tag, bad_tag_repo, &id)); cl_assert(bad_tag != NULL); - cl_assert_strequal(git_tag_name(bad_tag), "e90810b"); + cl_assert_equal_s(git_tag_name(bad_tag), "e90810b"); cl_assert(git_oid_cmp(&id, git_tag_id(bad_tag)) == 0); cl_assert(bad_tag->tagger == NULL); diff --git a/tests-clar/object/tag/write.c b/tests-clar/object/tag/write.c index 791e1acfa..cb196b64e 100644 --- a/tests-clar/object/tag/write.c +++ b/tests-clar/object/tag/write.c @@ -50,12 +50,12 @@ void test_object_tag_write__basic(void) /* Check attributes were set correctly */ tagger1 = git_tag_tagger(tag); cl_assert(tagger1 != NULL); - cl_assert_strequal(tagger1->name, tagger_name); - cl_assert_strequal(tagger1->email, tagger_email); + cl_assert_equal_s(tagger1->name, tagger_name); + cl_assert_equal_s(tagger1->email, tagger_email); cl_assert(tagger1->when.time == 123456789); cl_assert(tagger1->when.offset == 60); - cl_assert_strequal(git_tag_message(tag), tagger_message); + cl_assert_equal_s(git_tag_message(tag), tagger_message); cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/the-tag")); cl_assert(git_oid_cmp(git_reference_oid(ref_tag), &tag_id) == 0); diff --git a/tests-clar/object/tree/diff.c b/tests-clar/object/tree/diff.c index 011080c07..631fc3be4 100644 --- a/tests-clar/object/tree/diff.c +++ b/tests-clar/object/tree/diff.c @@ -18,13 +18,13 @@ static void diff_cmp(const git_tree_diff_data *a, const git_tree_diff_data *b) cl_assert(a->status - b->status == 0); - cl_assert_strequal(a->path, b->path); + cl_assert_equal_s(a->path, b->path); } static int diff_cb(const git_tree_diff_data *diff, void *data) { diff_cmp(diff, data); - return GIT_SUCCESS; + return 0; } static void test_diff(git_tree *a, git_tree *b, git_tree_diff_cb cb, void *data) @@ -126,7 +126,7 @@ static int diff_more_cb(const git_tree_diff_data *diff, void *data) more_data->expect_idx = (more_data->expect_idx + 1) % ARRAY_SIZE(more_data->expect); - return GIT_SUCCESS; + return 0; } void test_object_tree_diff__more(void) diff --git a/tests-clar/object/tree/frompath.c b/tests-clar/object/tree/frompath.c index 35d863efa..ea0add37b 100644 --- a/tests-clar/object/tree/frompath.c +++ b/tests-clar/object/tree/frompath.c @@ -24,10 +24,7 @@ void test_object_tree_frompath__cleanup(void) cl_fixture_cleanup("testrepo.git"); } -static void assert_tree_from_path(git_tree *root, - const char *path, - git_error expected_result, - const char *expected_raw_oid) +static void assert_tree_from_path(git_tree *root, const char *path, int expected_result, const char *expected_raw_oid) { git_tree *containing_tree = NULL; @@ -43,6 +40,12 @@ static void assert_tree_from_path(git_tree *root, git_tree_free(containing_tree); } +static void assert_tree_from_path_klass(git_tree *root, const char *path, int expected_result, const char *expected_raw_oid) +{ + assert_tree_from_path(root, path, GIT_ERROR, expected_raw_oid); + cl_assert(giterr_last()->klass == expected_result); +} + void test_object_tree_frompath__retrieve_tree_from_path_to_treeentry(void) { /* Will return self if given a one path segment... */ @@ -69,10 +72,10 @@ void test_object_tree_frompath__fail_when_processing_an_unknown_tree_segment(voi void test_object_tree_frompath__fail_when_processing_an_invalid_path(void) { - assert_tree_from_path(tree, "/", GIT_EINVALIDPATH, NULL); - assert_tree_from_path(tree, "/ab", GIT_EINVALIDPATH, NULL); - assert_tree_from_path(tree, "/ab/de", GIT_EINVALIDPATH, NULL); - assert_tree_from_path(tree, "ab/", GIT_EINVALIDPATH, NULL); - assert_tree_from_path(tree, "ab//de", GIT_EINVALIDPATH, NULL); - assert_tree_from_path(tree, "ab/de/", GIT_EINVALIDPATH, NULL); + assert_tree_from_path_klass(tree, "/", GITERR_INVALID, NULL); + assert_tree_from_path_klass(tree, "/ab", GITERR_INVALID, NULL); + assert_tree_from_path_klass(tree, "/ab/de", GITERR_INVALID, NULL); + assert_tree_from_path_klass(tree, "ab/", GITERR_INVALID, NULL); + assert_tree_from_path_klass(tree, "ab//de", GITERR_INVALID, NULL); + assert_tree_from_path_klass(tree, "ab/de/", GITERR_INVALID, NULL); } diff --git a/tests-clar/object/tree/read.c b/tests-clar/object/tree/read.c index fc2b44b86..362508f91 100644 --- a/tests-clar/object/tree/read.c +++ b/tests-clar/object/tree/read.c @@ -59,13 +59,13 @@ void test_object_tree_read__two(void) cl_assert(obj != NULL); git_object_free(obj); obj = NULL; - cl_assert(git_object_lookup(&obj, g_repo, &id, GIT_OBJ_BLOB) == GIT_EINVALIDTYPE); + cl_git_fail(git_object_lookup(&obj, g_repo, &id, GIT_OBJ_BLOB)); cl_assert(obj == NULL); entry = git_tree_entry_byname(tree, "README"); cl_assert(entry != NULL); - cl_assert_strequal(git_tree_entry_name(entry), "README"); + cl_assert_equal_s(git_tree_entry_name(entry), "README"); cl_git_pass(git_tree_entry_2object(&obj, g_repo, entry)); cl_assert(obj != NULL); diff --git a/tests-clar/refs/branches/create.c b/tests-clar/refs/branches/create.c new file mode 100644 index 000000000..ad7e1fd2c --- /dev/null +++ b/tests-clar/refs/branches/create.c @@ -0,0 +1,113 @@ +#include "clar_libgit2.h" +#include "refs.h" +#include "branch.h" + +static git_repository *repo; +static git_oid branch_target_oid; +static git_object *target; + +void test_refs_branches_create__initialize(void) +{ + cl_fixture_sandbox("testrepo.git"); + cl_git_pass(git_repository_open(&repo, "testrepo.git")); +} + +void test_refs_branches_create__cleanup(void) +{ + git_object_free(target); + git_repository_free(repo); + + cl_fixture_cleanup("testrepo.git"); +} + +static void retrieve_target_from_oid(git_object **object_out, git_repository *repo, const char *sha) +{ + git_oid oid; + + cl_git_pass(git_oid_fromstr(&oid, sha)); + cl_git_pass(git_object_lookup(object_out, repo, &oid, GIT_OBJ_ANY)); +} + +static void retrieve_known_commit(git_object **object, git_repository *repo) +{ + retrieve_target_from_oid(object, repo, "e90810b8df3e80c413d903f631643c716887138d"); +} + +#define NEW_BRANCH_NAME "new-branch-on-the-block" + +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); +} + +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)); +} + +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); +} + +void test_refs_branches_create__creating_a_branch_targeting_a_tag_dereferences_it_to_its_commit(void) +{ + /* 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")); +} + +void test_refs_branches_create__can_not_create_a_branch_pointing_to_a_non_commit_object(void) +{ + /* 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)); + 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)); +} diff --git a/tests-clar/refs/branches/delete.c b/tests-clar/refs/branches/delete.c new file mode 100644 index 000000000..095893020 --- /dev/null +++ b/tests-clar/refs/branches/delete.c @@ -0,0 +1,76 @@ +#include "clar_libgit2.h" +#include "refs.h" +#include "branch.h" + +static git_repository *repo; +static git_reference *fake_remote; + +void test_refs_branches_delete__initialize(void) +{ + git_oid id; + + cl_fixture_sandbox("testrepo.git"); + cl_git_pass(git_repository_open(&repo, "testrepo.git")); + + cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); + cl_git_pass(git_reference_create_oid(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0)); +} + +void test_refs_branches_delete__cleanup(void) +{ + git_reference_free(fake_remote); + git_repository_free(repo); + + cl_fixture_cleanup("testrepo.git"); +} + +void test_refs_branches_delete__can_not_delete_a_non_existing_branch(void) +{ + cl_git_fail(git_branch_delete(repo, "i-am-not-a-local-branch", GIT_BRANCH_LOCAL)); + cl_git_fail(git_branch_delete(repo, "neither/a-remote-one", GIT_BRANCH_REMOTE)); +} + +void test_refs_branches_delete__can_not_delete_a_branch_pointed_at_by_HEAD(void) +{ + git_reference *head; + + /* Ensure HEAD targets the local master branch */ + cl_git_pass(git_reference_lookup(&head, repo, GIT_HEAD_FILE)); + cl_assert(strcmp("refs/heads/master", git_reference_target(head)) == 0); + git_reference_free(head); + + cl_git_fail(git_branch_delete(repo, "master", GIT_BRANCH_LOCAL)); +} + +void test_refs_branches_delete__can_not_delete_a_branch_if_HEAD_is_missing(void) +{ + git_reference *head; + + cl_git_pass(git_reference_lookup(&head, repo, GIT_HEAD_FILE)); + git_reference_delete(head); + + cl_git_fail(git_branch_delete(repo, "br2", GIT_BRANCH_LOCAL)); +} + +void test_refs_branches_delete__can_delete_a_branch_pointed_at_by_detached_HEAD(void) +{ + git_reference *master, *head; + + /* Detach HEAD and make it target the commit that "master" points to */ + cl_git_pass(git_reference_lookup(&master, repo, "refs/heads/master")); + cl_git_pass(git_reference_create_oid(&head, repo, "HEAD", git_reference_oid(master), 1)); + git_reference_free(head); + git_reference_free(master); + + cl_git_pass(git_branch_delete(repo, "master", GIT_BRANCH_LOCAL)); +} + +void test_refs_branches_delete__can_delete_a_local_branch(void) +{ + cl_git_pass(git_branch_delete(repo, "br2", GIT_BRANCH_LOCAL)); +} + +void test_refs_branches_delete__can_delete_a_remote_branch(void) +{ + cl_git_pass(git_branch_delete(repo, "nulltoken/master", GIT_BRANCH_REMOTE)); +} diff --git a/tests-clar/refs/branches/listall.c b/tests-clar/refs/branches/listall.c new file mode 100644 index 000000000..391177368 --- /dev/null +++ b/tests-clar/refs/branches/listall.c @@ -0,0 +1,49 @@ +#include "clar_libgit2.h" +#include "refs.h" +#include "branch.h" + +static git_repository *repo; +static git_strarray branch_list; +static git_reference *fake_remote; + +void test_refs_branches_listall__initialize(void) +{ + git_oid id; + + cl_fixture_sandbox("testrepo.git"); + cl_git_pass(git_repository_open(&repo, "testrepo.git")); + + cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); + cl_git_pass(git_reference_create_oid(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0)); +} + +void test_refs_branches_listall__cleanup(void) +{ + git_strarray_free(&branch_list); + git_reference_free(fake_remote); + git_repository_free(repo); + + cl_fixture_cleanup("testrepo.git"); +} + +static void assert_retrieval(unsigned int flags, unsigned int expected_count) +{ + cl_git_pass(git_branch_list(&branch_list, repo, flags)); + + cl_assert(branch_list.count == expected_count); +} + +void test_refs_branches_listall__retrieve_all_branches(void) +{ + assert_retrieval(GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE, 6 + 1); +} + +void test_refs_branches_listall__retrieve_remote_branches(void) +{ + assert_retrieval(GIT_BRANCH_REMOTE, 1); +} + +void test_refs_branches_listall__retrieve_local_branches(void) +{ + assert_retrieval(GIT_BRANCH_LOCAL, 6); +} diff --git a/tests-clar/refs/branches/move.c b/tests-clar/refs/branches/move.c new file mode 100644 index 000000000..208bb460e --- /dev/null +++ b/tests-clar/refs/branches/move.c @@ -0,0 +1,62 @@ +#include "clar_libgit2.h" +#include "branch.h" + +static git_repository *repo; + +void test_refs_branches_move__initialize(void) +{ + cl_fixture_sandbox("testrepo.git"); + cl_git_pass(git_repository_open(&repo, "testrepo.git")); +} + +void test_refs_branches_move__cleanup(void) +{ + git_repository_free(repo); + + cl_fixture_cleanup("testrepo.git"); +} + +#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)); +} + +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)); + + /* Upward */ + cl_git_pass(git_branch_move(repo, "somewhere/" NEW_BRANCH_NAME, "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)); + + /* Upward */ + cl_git_pass(git_branch_move(repo, "br2/" NEW_BRANCH_NAME, "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)); +} + +void test_refs_branches_move__can_not_move_a_non_existing_branch(void) +{ + cl_git_fail(git_branch_move(repo, "i-am-no-branch", NEW_BRANCH_NAME, 0)); +} + +void test_refs_branches_move__can_force_move_over_an_existing_branch(void) +{ + cl_git_pass(git_branch_move(repo, "br2", "master", 1)); +} + +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)); +} diff --git a/tests-clar/refs/create.c b/tests-clar/refs/create.c index 3674022c0..dde4c5745 100644 --- a/tests-clar/refs/create.c +++ b/tests-clar/refs/create.c @@ -42,7 +42,7 @@ void test_refs_create__symbolic(void) cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head_tracker)); cl_assert(git_reference_type(looked_up_ref) & GIT_REF_SYMBOLIC); cl_assert(git_reference_is_packed(looked_up_ref) == 0); - cl_assert_strequal(looked_up_ref->name, new_head_tracker); + cl_assert_equal_s(looked_up_ref->name, new_head_tracker); /* ...peeled.. */ cl_git_pass(git_reference_resolve(&resolved_ref, looked_up_ref)); @@ -112,7 +112,7 @@ void test_refs_create__oid(void) cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head)); cl_assert(git_reference_type(looked_up_ref) & GIT_REF_OID); cl_assert(git_reference_is_packed(looked_up_ref) == 0); - cl_assert_strequal(looked_up_ref->name, new_head); + cl_assert_equal_s(looked_up_ref->name, new_head); /* ...and that it points to the current master tip */ cl_assert(git_oid_cmp(&id, git_reference_oid(looked_up_ref)) == 0); diff --git a/tests-clar/refs/delete.c b/tests-clar/refs/delete.c index cc3b93653..912f41456 100644 --- a/tests-clar/refs/delete.c +++ b/tests-clar/refs/delete.c @@ -31,7 +31,7 @@ void test_refs_delete__packed_loose(void) /* Ensure the loose reference exists on the file system */ cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, packed_test_head_name)); - cl_git_pass(git_path_exists(temp_path.ptr)); + cl_assert(git_path_exists(temp_path.ptr)); /* Lookup the reference */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_test_head_name)); @@ -46,7 +46,7 @@ void test_refs_delete__packed_loose(void) cl_git_fail(git_reference_lookup(&another_looked_up_ref, g_repo, packed_test_head_name)); /* Ensure the loose reference doesn't exist any longer on the file system */ - cl_git_pass(!git_path_exists(temp_path.ptr)); + cl_assert(!git_path_exists(temp_path.ptr)); git_reference_free(another_looked_up_ref); git_buf_free(&temp_path); diff --git a/tests-clar/refs/lookup.c b/tests-clar/refs/lookup.c new file mode 100644 index 000000000..ab563ac2b --- /dev/null +++ b/tests-clar/refs/lookup.c @@ -0,0 +1,42 @@ +#include "clar_libgit2.h" +#include "refs.h" + +static git_repository *g_repo; + +void test_refs_lookup__initialize(void) +{ + g_repo = cl_git_sandbox_init("testrepo.git"); +} + +void test_refs_lookup__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +void test_refs_lookup__with_resolve(void) +{ + git_reference *a, *b, *temp; + + cl_git_pass(git_reference_lookup(&temp, g_repo, "HEAD")); + cl_git_pass(git_reference_resolve(&a, temp)); + git_reference_free(temp); + + cl_git_pass(git_reference_lookup_resolved(&b, g_repo, "HEAD", 5)); + cl_assert(git_reference_cmp(a, b) == 0); + git_reference_free(b); + + cl_git_pass(git_reference_lookup_resolved(&b, g_repo, "head-tracker", 5)); + cl_assert(git_reference_cmp(a, b) == 0); + git_reference_free(b); + + git_reference_free(a); +} + +void test_refs_lookup__oid(void) +{ + git_oid tag, expected; + + cl_git_pass(git_reference_name_to_oid(&tag, g_repo, "refs/tags/point_to_blob")); + cl_git_pass(git_oid_fromstr(&expected, "1385f264afb75a56a5bec74243be9b367ba4ca08")); + cl_assert(git_oid_cmp(&tag, &expected) == 0); +} diff --git a/tests-clar/refs/overwrite.c b/tests-clar/refs/overwrite.c index 5c6fd54bd..410e39a84 100644 --- a/tests-clar/refs/overwrite.c +++ b/tests-clar/refs/overwrite.c @@ -34,7 +34,7 @@ void test_refs_overwrite__symbolic(void) /* Ensure it points to the right place*/ cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name)); cl_assert(git_reference_type(ref) & GIT_REF_SYMBOLIC); - cl_assert_strequal(git_reference_target(ref), ref_branch_name); + cl_assert_equal_s(git_reference_target(ref), ref_branch_name); git_reference_free(ref); /* Ensure we can't create it unless we force it to */ @@ -45,7 +45,7 @@ void test_refs_overwrite__symbolic(void) /* Ensure it points to the right place */ cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name)); cl_assert(git_reference_type(ref) & GIT_REF_SYMBOLIC); - cl_assert_strequal(git_reference_target(ref), ref_master_name); + cl_assert_equal_s(git_reference_target(ref), ref_master_name); git_reference_free(ref); git_reference_free(branch_ref); @@ -103,7 +103,7 @@ void test_refs_overwrite__object_id_with_symbolic(void) /* Ensure it points to the right place */ cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name)); cl_assert(git_reference_type(ref) & GIT_REF_SYMBOLIC); - cl_assert_strequal(git_reference_target(ref), ref_master_name); + cl_assert_equal_s(git_reference_target(ref), ref_master_name); git_reference_free(ref); } diff --git a/tests-clar/refs/pack.c b/tests-clar/refs/pack.c index dca83d1ef..305594c28 100644 --- a/tests-clar/refs/pack.c +++ b/tests-clar/refs/pack.c @@ -39,7 +39,7 @@ void test_refs_pack__loose(void) /* Ensure a known loose ref can be looked up */ cl_git_pass(git_reference_lookup(&reference, g_repo, loose_tag_ref_name)); cl_assert(git_reference_is_packed(reference) == 0); - cl_assert_strequal(reference->name, loose_tag_ref_name); + cl_assert_equal_s(reference->name, loose_tag_ref_name); git_reference_free(reference); /* @@ -51,16 +51,16 @@ void test_refs_pack__loose(void) /* Ensure the packed-refs file exists */ cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, GIT_PACKEDREFS_FILE)); - cl_git_pass(git_path_exists(temp_path.ptr)); + cl_assert(git_path_exists(temp_path.ptr)); /* Ensure the known ref can still be looked up but is now packed */ cl_git_pass(git_reference_lookup(&reference, g_repo, loose_tag_ref_name)); cl_assert(git_reference_is_packed(reference)); - cl_assert_strequal(reference->name, loose_tag_ref_name); + cl_assert_equal_s(reference->name, loose_tag_ref_name); /* Ensure the known ref has been removed from the loose folder structure */ cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, loose_tag_ref_name)); - cl_git_pass(!git_path_exists(temp_path.ptr)); + cl_assert(!git_path_exists(temp_path.ptr)); git_reference_free(reference); git_buf_free(&temp_path); diff --git a/tests-clar/refs/read.c b/tests-clar/refs/read.c index c7e88abe4..d7111b232 100644 --- a/tests-clar/refs/read.c +++ b/tests-clar/refs/read.c @@ -34,7 +34,7 @@ void test_refs_read__loose_tag(void) cl_git_pass(git_reference_lookup(&reference, g_repo, loose_tag_ref_name)); cl_assert(git_reference_type(reference) & GIT_REF_OID); cl_assert(git_reference_is_packed(reference) == 0); - cl_assert_strequal(reference->name, loose_tag_ref_name); + cl_assert_equal_s(reference->name, loose_tag_ref_name); cl_git_pass(git_object_lookup(&object, g_repo, git_reference_oid(reference), GIT_OBJ_ANY)); cl_assert(object != NULL); @@ -42,7 +42,7 @@ void test_refs_read__loose_tag(void) /* Ensure the name of the tag matches the name of the reference */ cl_git_pass(git_buf_joinpath(&ref_name_from_tag_name, GIT_REFS_TAGS_DIR, git_tag_name((git_tag *)object))); - cl_assert_strequal(ref_name_from_tag_name.ptr, loose_tag_ref_name); + cl_assert_equal_s(ref_name_from_tag_name.ptr, loose_tag_ref_name); git_buf_free(&ref_name_from_tag_name); git_object_free(object); @@ -71,7 +71,7 @@ void test_refs_read__symbolic(void) cl_git_pass(git_reference_lookup(&reference, g_repo, GIT_HEAD_FILE)); cl_assert(git_reference_type(reference) & GIT_REF_SYMBOLIC); cl_assert(git_reference_is_packed(reference) == 0); - cl_assert_strequal(reference->name, GIT_HEAD_FILE); + cl_assert_equal_s(reference->name, GIT_HEAD_FILE); cl_git_pass(git_reference_resolve(&resolved_ref, reference)); cl_assert(git_reference_type(resolved_ref) == GIT_REF_OID); @@ -99,7 +99,7 @@ void test_refs_read__nested_symbolic(void) cl_git_pass(git_reference_lookup(&reference, g_repo, head_tracker_sym_ref_name)); cl_assert(git_reference_type(reference) & GIT_REF_SYMBOLIC); cl_assert(git_reference_is_packed(reference) == 0); - cl_assert_strequal(reference->name, head_tracker_sym_ref_name); + cl_assert_equal_s(reference->name, head_tracker_sym_ref_name); cl_git_pass(git_reference_resolve(&resolved_ref, reference)); cl_assert(git_reference_type(resolved_ref) == GIT_REF_OID); @@ -167,7 +167,7 @@ void test_refs_read__packed(void) cl_git_pass(git_reference_lookup(&reference, g_repo, packed_head_name)); cl_assert(git_reference_type(reference) & GIT_REF_OID); cl_assert(git_reference_is_packed(reference)); - cl_assert_strequal(reference->name, packed_head_name); + cl_assert_equal_s(reference->name, packed_head_name); cl_git_pass(git_object_lookup(&object, g_repo, git_reference_oid(reference), GIT_OBJ_ANY)); cl_assert(object != NULL); @@ -188,7 +188,7 @@ void test_refs_read__loose_first(void) cl_git_pass(git_reference_lookup(&reference, g_repo, packed_test_head_name)); cl_assert(git_reference_type(reference) & GIT_REF_OID); cl_assert(git_reference_is_packed(reference) == 0); - cl_assert_strequal(reference->name, packed_test_head_name); + cl_assert_equal_s(reference->name, packed_test_head_name); git_reference_free(reference); } diff --git a/tests-clar/refs/reflog.c b/tests-clar/refs/reflog.c index 8000e4851..1bc51b2b8 100644 --- a/tests-clar/refs/reflog.c +++ b/tests-clar/refs/reflog.c @@ -16,8 +16,8 @@ static git_repository *g_repo; static void assert_signature(git_signature *expected, git_signature *actual) { cl_assert(actual); - cl_assert_strequal(expected->name, actual->name); - cl_assert_strequal(expected->email, actual->email); + cl_assert_equal_s(expected->name, actual->name); + cl_assert_equal_s(expected->email, actual->email); cl_assert(expected->when.offset == actual->when.offset); cl_assert(expected->when.time == actual->when.time); } @@ -73,18 +73,18 @@ void test_refs_reflog__write_then_read(void) entry = (git_reflog_entry *)git_vector_get(&reflog->entries, 0); assert_signature(committer, entry->committer); git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_old); - cl_assert_strequal("0000000000000000000000000000000000000000", oid_str); + cl_assert_equal_s("0000000000000000000000000000000000000000", oid_str); git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_cur); - cl_assert_strequal(current_master_tip, oid_str); + cl_assert_equal_s(current_master_tip, oid_str); cl_assert(entry->msg == NULL); entry = (git_reflog_entry *)git_vector_get(&reflog->entries, 1); assert_signature(committer, entry->committer); git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_old); - cl_assert_strequal(current_master_tip, oid_str); + cl_assert_equal_s(current_master_tip, oid_str); git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_cur); - cl_assert_strequal(current_master_tip, oid_str); - cl_assert_strequal(commit_msg, entry->msg); + cl_assert_equal_s(current_master_tip, oid_str); + cl_assert_equal_s(commit_msg, entry->msg); git_signature_free(committer); git_reflog_free(reflog); diff --git a/tests-clar/refs/rename.c b/tests-clar/refs/rename.c index 8e7c93c97..4b917ef6d 100644 --- a/tests-clar/refs/rename.c +++ b/tests-clar/refs/rename.c @@ -38,7 +38,7 @@ void test_refs_rename__loose(void) /* Ensure the ref doesn't exist on the file system */ cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, new_name)); - cl_git_pass(!git_path_exists(temp_path.ptr)); + cl_assert(!git_path_exists(temp_path.ptr)); /* Retrieval of the reference to rename */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, loose_tag_ref_name)); @@ -48,14 +48,14 @@ void test_refs_rename__loose(void) /* Now that the reference is renamed... */ cl_git_pass(git_reference_rename(looked_up_ref, new_name, 0)); - cl_assert_strequal(looked_up_ref->name, new_name); + cl_assert_equal_s(looked_up_ref->name, new_name); /* ...It can't be looked-up with the old name... */ cl_git_fail(git_reference_lookup(&another_looked_up_ref, g_repo, loose_tag_ref_name)); /* ...but the new name works ok... */ cl_git_pass(git_reference_lookup(&another_looked_up_ref, g_repo, new_name)); - cl_assert_strequal(another_looked_up_ref->name, new_name); + cl_assert_equal_s(another_looked_up_ref->name, new_name); /* .. the ref is still loose... */ cl_assert(git_reference_is_packed(another_looked_up_ref) == 0); @@ -63,7 +63,7 @@ void test_refs_rename__loose(void) /* ...and the ref can be found in the file system */ cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, new_name)); - cl_git_pass(git_path_exists(temp_path.ptr)); + cl_assert(git_path_exists(temp_path.ptr)); git_reference_free(looked_up_ref); git_reference_free(another_looked_up_ref); @@ -79,7 +79,7 @@ void test_refs_rename__packed(void) /* Ensure the ref doesn't exist on the file system */ cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, packed_head_name)); - cl_git_pass(!git_path_exists(temp_path.ptr)); + cl_assert(!git_path_exists(temp_path.ptr)); /* The reference can however be looked-up... */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name)); @@ -89,14 +89,14 @@ void test_refs_rename__packed(void) /* Now that the reference is renamed... */ cl_git_pass(git_reference_rename(looked_up_ref, brand_new_name, 0)); - cl_assert_strequal(looked_up_ref->name, brand_new_name); + cl_assert_equal_s(looked_up_ref->name, brand_new_name); /* ...It can't be looked-up with the old name... */ cl_git_fail(git_reference_lookup(&another_looked_up_ref, g_repo, packed_head_name)); /* ...but the new name works ok... */ cl_git_pass(git_reference_lookup(&another_looked_up_ref, g_repo, brand_new_name)); - cl_assert_strequal(another_looked_up_ref->name, brand_new_name); + cl_assert_equal_s(another_looked_up_ref->name, brand_new_name); /* .. the ref is no longer packed... */ cl_assert(git_reference_is_packed(another_looked_up_ref) == 0); @@ -104,7 +104,7 @@ void test_refs_rename__packed(void) /* ...and the ref now happily lives in the file system */ cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, brand_new_name)); - cl_git_pass(git_path_exists(temp_path.ptr)); + cl_assert(git_path_exists(temp_path.ptr)); git_reference_free(looked_up_ref); git_reference_free(another_looked_up_ref); @@ -120,7 +120,7 @@ void test_refs_rename__packed_doesnt_pack_others(void) /* Ensure the other reference exists on the file system */ cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, packed_test_head_name)); - cl_git_pass(git_path_exists(temp_path.ptr)); + cl_assert(git_path_exists(temp_path.ptr)); /* Lookup the other reference */ cl_git_pass(git_reference_lookup(&another_looked_up_ref, g_repo, packed_test_head_name)); @@ -145,7 +145,7 @@ void test_refs_rename__packed_doesnt_pack_others(void) cl_assert(git_reference_is_packed(another_looked_up_ref) == 0); /* Ensure the other ref still exists on the file system */ - cl_git_pass(git_path_exists(temp_path.ptr)); + cl_assert(git_path_exists(temp_path.ptr)); git_reference_free(looked_up_ref); git_reference_free(another_looked_up_ref); @@ -166,7 +166,7 @@ void test_refs_rename__name_collision(void) /* Failure to rename it hasn't corrupted its state */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name)); - cl_assert_strequal(looked_up_ref->name, packed_head_name); + cl_assert_equal_s(looked_up_ref->name, packed_head_name); git_reference_free(looked_up_ref); } @@ -188,7 +188,7 @@ void test_refs_rename__invalid_name(void) /* Failure to rename it hasn't corrupted its state */ git_reference_free(looked_up_ref); cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_test_head_name)); - cl_assert_strequal(looked_up_ref->name, packed_test_head_name); + cl_assert_equal_s(looked_up_ref->name, packed_test_head_name); git_reference_free(looked_up_ref); } @@ -209,7 +209,7 @@ void test_refs_rename__force_loose_packed(void) /* Check we actually renamed it */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_test_head_name)); - cl_assert_strequal(looked_up_ref->name, packed_test_head_name); + cl_assert_equal_s(looked_up_ref->name, packed_test_head_name); cl_assert(!git_oid_cmp(&oid, git_reference_oid(looked_up_ref))); git_reference_free(looked_up_ref); @@ -233,7 +233,7 @@ void test_refs_rename__force_loose(void) /* Check we actually renamed it */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, "refs/heads/test")); - cl_assert_strequal(looked_up_ref->name, "refs/heads/test"); + cl_assert_equal_s(looked_up_ref->name, "refs/heads/test"); cl_assert(!git_oid_cmp(&oid, git_reference_oid(looked_up_ref))); git_reference_free(looked_up_ref); @@ -298,7 +298,7 @@ void test_refs_rename__prefix(void) /* Check we actually renamed it */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new)); - cl_assert_strequal(looked_up_ref->name, ref_two_name_new); + cl_assert_equal_s(looked_up_ref->name, ref_two_name_new); git_reference_free(looked_up_ref); cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name)); @@ -331,7 +331,7 @@ void test_refs_rename__move_up(void) /* Check we actually renamed it */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name)); - cl_assert_strequal(looked_up_ref->name, ref_two_name); + cl_assert_equal_s(looked_up_ref->name, ref_two_name); git_reference_free(looked_up_ref); cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new)); git_reference_free(ref); diff --git a/tests-clar/refs/unicode.c b/tests-clar/refs/unicode.c new file mode 100644 index 000000000..889c85666 --- /dev/null +++ b/tests-clar/refs/unicode.c @@ -0,0 +1,42 @@ +#include "clar_libgit2.h" + +static git_repository *repo; + +void test_refs_unicode__initialize(void) +{ + cl_fixture_sandbox("testrepo.git"); + + cl_git_pass(git_repository_open(&repo, "testrepo.git")); +} + +void test_refs_unicode__cleanup(void) +{ + git_repository_free(repo); + cl_fixture_cleanup("testrepo.git"); +} + +void test_refs_unicode__create_and_lookup(void) +{ + git_reference *ref0, *ref1, *ref2; + git_repository *repo2; + + const char *REFNAME = "refs/heads/" "\305" "ngstr" "\366" "m"; + const char *master = "refs/heads/master"; + + /* Create the reference */ + cl_git_pass(git_reference_lookup(&ref0, repo, master)); + cl_git_pass(git_reference_create_oid(&ref1, repo, REFNAME, git_reference_oid(ref0), 0)); + cl_assert(strcmp(REFNAME, git_reference_name(ref1)) == 0); + + /* Lookup the reference in a different instance of the repository */ + cl_git_pass(git_repository_open(&repo2, "testrepo.git")); + cl_git_pass(git_reference_lookup(&ref2, repo2, REFNAME)); + + cl_assert(git_oid_cmp(git_reference_oid(ref1), git_reference_oid(ref2)) == 0); + cl_assert(strcmp(REFNAME, git_reference_name(ref2)) == 0); + + git_reference_free(ref0); + git_reference_free(ref1); + git_reference_free(ref2); + git_repository_free(repo2); +} diff --git a/tests-clar/repo/discover.c b/tests-clar/repo/discover.c index 072e3265e..6b17d6dba 100644 --- a/tests-clar/repo/discover.c +++ b/tests-clar/repo/discover.c @@ -30,7 +30,7 @@ static void ensure_repository_discover(const char *start_path, char found_path[GIT_PATH_MAX]; cl_git_pass(git_repository_discover(found_path, sizeof(found_path), start_path, 0, ceiling_dirs)); //across_fs is always 0 as we can't automate the filesystem change tests - cl_assert_strequal(found_path, expected_path); + cl_assert_equal_s(found_path, expected_path); } static void write_file(const char *path, const char *content) @@ -38,7 +38,7 @@ static void write_file(const char *path, const char *content) git_file file; int error; - if (git_path_exists(path) == GIT_SUCCESS) { + if (git_path_exists(path)) { cl_git_pass(p_unlink(path)); } @@ -60,10 +60,11 @@ static void append_ceiling_dir(git_buf *ceiling_dirs, const char *path) if (ceiling_dirs->size > 0) git_buf_puts(ceiling_dirs, ceiling_separator); + git_buf_puts(ceiling_dirs, pretty_path.ptr); - - git_buf_free(&pretty_path); - cl_git_pass(git_buf_lasterror(ceiling_dirs)); + + git_buf_free(&pretty_path); + cl_assert(git_buf_oom(ceiling_dirs) == 0); } void test_repo_discover__0(void) @@ -81,7 +82,7 @@ void test_repo_discover__0(void) append_ceiling_dir(&ceiling_dirs_buf, TEMP_REPO_FOLDER); ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf); - cl_assert(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs) == GIT_ENOTAREPO); + cl_git_fail(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs)); cl_git_pass(git_repository_init(&repo, DISCOVER_FOLDER, 1)); cl_git_pass(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs)); diff --git a/tests-clar/repo/getters.c b/tests-clar/repo/getters.c index a0d437983..966de1f16 100644 --- a/tests-clar/repo/getters.c +++ b/tests-clar/repo/getters.c @@ -68,3 +68,19 @@ void test_repo_getters__head_orphan(void) git_reference_free(ref); git_repository_free(repo); } + +void test_repo_getters__retrieving_the_odb_honors_the_refcount(void) +{ + git_odb *odb; + git_repository *repo; + + cl_git_pass(git_repository_open(&repo, "testrepo.git")); + + cl_git_pass(git_repository_odb(&odb, repo)); + cl_assert(((git_refcount *)odb)->refcount == 2); + + git_repository_free(repo); + cl_assert(((git_refcount *)odb)->refcount == 1); + + git_odb_free(odb); +} diff --git a/tests-clar/repo/open.c b/tests-clar/repo/open.c index c3a7dadbd..1813887ec 100644 --- a/tests-clar/repo/open.c +++ b/tests-clar/repo/open.c @@ -1,25 +1,28 @@ #include "clar_libgit2.h" -#include "posix.h" - -static git_repository *repo; +#include "fileops.h" +#include void test_repo_open__cleanup(void) { - git_repository_free(repo); + cl_git_sandbox_cleanup(); + + if (git_path_isdir("alternate")) + git_futils_rmdir_r("alternate", 1); } void test_repo_open__bare_empty_repo(void) { - cl_git_pass(git_repository_open(&repo, cl_fixture("empty_bare.git"))); + git_repository *repo = cl_git_sandbox_init("empty_bare.git"); cl_assert(git_repository_path(repo) != NULL); cl_assert(git__suffixcmp(git_repository_path(repo), "/") == 0); - cl_assert(git_repository_workdir(repo) == NULL); } void test_repo_open__standard_empty_repo_through_gitdir(void) { + git_repository *repo; + cl_git_pass(git_repository_open(&repo, cl_fixture("empty_standard_repo/.gitted"))); cl_assert(git_repository_path(repo) != NULL); @@ -27,20 +30,247 @@ void test_repo_open__standard_empty_repo_through_gitdir(void) cl_assert(git_repository_workdir(repo) != NULL); cl_assert(git__suffixcmp(git_repository_workdir(repo), "/") == 0); + + git_repository_free(repo); } void test_repo_open__standard_empty_repo_through_workdir(void) { - cl_fixture_sandbox("empty_standard_repo"); - cl_git_pass(p_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git")); - - cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); + git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); cl_assert(git_repository_path(repo) != NULL); cl_assert(git__suffixcmp(git_repository_path(repo), "/") == 0); cl_assert(git_repository_workdir(repo) != NULL); cl_assert(git__suffixcmp(git_repository_workdir(repo), "/") == 0); - - cl_fixture_cleanup("empty_standard_repo"); +} + + +void test_repo_open__open_with_discover(void) +{ + static const char *variants[] = { + "attr", "attr/", "attr/.git", "attr/.git/", + "attr/sub", "attr/sub/", "attr/sub/sub", "attr/sub/sub/", + NULL + }; + git_repository *repo; + const char **scan; + + cl_fixture_sandbox("attr"); + cl_git_pass(p_rename("attr/.gitted", "attr/.git")); + + for (scan = variants; *scan != NULL; scan++) { + cl_git_pass(git_repository_open_ext(&repo, *scan, 0, NULL)); + cl_assert(git__suffixcmp(git_repository_path(repo), "attr/.git/") == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo), "attr/") == 0); + git_repository_free(repo); + } + + cl_fixture_cleanup("attr"); +} + +void test_repo_open__gitlinked(void) +{ + /* need to have both repo dir and workdir set up correctly */ + git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); + git_repository *repo2; + + cl_must_pass(p_mkdir("alternate", 0777)); + cl_git_mkfile("alternate/.git", "gitdir: ../empty_standard_repo/.git"); + + cl_git_pass(git_repository_open(&repo2, "alternate")); + + cl_assert(git_repository_path(repo2) != NULL); + cl_assert_(git__suffixcmp(git_repository_path(repo2), "empty_standard_repo/.git/") == 0, git_repository_path(repo2)); + cl_assert_equal_s(git_repository_path(repo), git_repository_path(repo2)); + + cl_assert(git_repository_workdir(repo2) != NULL); + cl_assert_(git__suffixcmp(git_repository_workdir(repo2), "alternate/") == 0, git_repository_workdir(repo2)); + + git_repository_free(repo2); +} + +void test_repo_open__from_git_new_workdir(void) +{ + /* The git-new-workdir script that ships with git sets up a bunch of + * symlinks to create a second workdir that shares the object db with + * another checkout. Libgit2 can open a repo that has been configured + * this way. + */ + cl_git_sandbox_init("empty_standard_repo"); + +#ifndef GIT_WIN32 + git_repository *repo2; + git_buf link_tgt = GIT_BUF_INIT, link = GIT_BUF_INIT, body = GIT_BUF_INIT; + const char **scan; + int link_fd; + static const char *links[] = { + "config", "refs", "logs/refs", "objects", "info", "hooks", + "packed-refs", "remotes", "rr-cache", "svn", NULL + }; + static const char *copies[] = { + "HEAD", NULL + }; + + cl_git_pass(p_mkdir("alternate", 0777)); + cl_git_pass(p_mkdir("alternate/.git", 0777)); + + for (scan = links; *scan != NULL; scan++) { + git_buf_joinpath(&link_tgt, "empty_standard_repo/.git", *scan); + if (git_path_exists(link_tgt.ptr)) { + git_buf_joinpath(&link_tgt, "../../empty_standard_repo/.git", *scan); + git_buf_joinpath(&link, "alternate/.git", *scan); + if (strchr(*scan, '/')) + git_futils_mkpath2file(link.ptr, 0777); + cl_assert_(symlink(link_tgt.ptr, link.ptr) == 0, strerror(errno)); + } + } + for (scan = copies; *scan != NULL; scan++) { + git_buf_joinpath(&link_tgt, "empty_standard_repo/.git", *scan); + if (git_path_exists(link_tgt.ptr)) { + git_buf_joinpath(&link, "alternate/.git", *scan); + cl_git_pass(git_futils_readbuffer(&body, link_tgt.ptr)); + + cl_assert((link_fd = git_futils_creat_withpath(link.ptr, 0777, 0666)) >= 0); + cl_must_pass(p_write(link_fd, body.ptr, body.size)); + p_close(link_fd); + } + } + + git_buf_free(&link_tgt); + git_buf_free(&link); + git_buf_free(&body); + + + cl_git_pass(git_repository_open(&repo2, "alternate")); + + cl_assert(git_repository_path(repo2) != NULL); + cl_assert_(git__suffixcmp(git_repository_path(repo2), "alternate/.git/") == 0, git_repository_path(repo2)); + + cl_assert(git_repository_workdir(repo2) != NULL); + cl_assert_(git__suffixcmp(git_repository_workdir(repo2), "alternate/") == 0, git_repository_workdir(repo2)); + + git_repository_free(repo2); +#endif +} + +void test_repo_open__failures(void) +{ + git_repository *base, *repo; + git_buf ceiling = GIT_BUF_INIT; + + base = cl_git_sandbox_init("attr"); + cl_git_pass(git_buf_sets(&ceiling, git_repository_workdir(base))); + + /* fail with no searching */ + cl_git_fail(git_repository_open(&repo, "attr/sub")); + cl_git_fail(git_repository_open_ext( + &repo, "attr/sub", GIT_REPOSITORY_OPEN_NO_SEARCH, NULL)); + + /* fail with ceiling too low */ + cl_git_pass(git_buf_joinpath(&ceiling, ceiling.ptr, "sub")); + cl_git_fail(git_repository_open_ext(&repo, "attr/sub", 0, ceiling.ptr)); + + /* fail with no repo */ + cl_git_pass(p_mkdir("alternate", 0777)); + cl_git_pass(p_mkdir("alternate/.git", 0777)); + cl_git_fail(git_repository_open_ext(&repo, "alternate", 0, NULL)); + cl_git_fail(git_repository_open_ext(&repo, "alternate/.git", 0, NULL)); + + git_buf_free(&ceiling); +} + +void test_repo_open__bad_gitlinks(void) +{ + git_repository *repo; + static const char *bad_links[] = { + "garbage\n", "gitdir", "gitdir:\n", "gitdir: foobar", + "gitdir: ../invalid", "gitdir: ../invalid2", + "gitdir: ../attr/.git with extra stuff", + NULL + }; + const char **scan; + + cl_git_sandbox_init("attr"); + + cl_git_pass(p_mkdir("alternate", 0777)); + cl_git_pass(p_mkdir("invalid", 0777)); + cl_git_pass(git_futils_mkdir_r("invalid2/.git", NULL, 0777)); + + for (scan = bad_links; *scan != NULL; scan++) { + cl_git_rewritefile("alternate/.git", *scan); + cl_git_fail(git_repository_open_ext(&repo, "alternate", 0, NULL)); + } + + git_futils_rmdir_r("invalid", 1); + git_futils_rmdir_r("invalid2", 1); +} + +#ifdef GIT_WIN32 +static void unposix_path(git_buf *path) +{ + char *src, *tgt; + + src = tgt = path->ptr; + + /* convert "/d/..." to "d:\..." */ + if (src[0] == '/' && isalpha(src[1]) && src[2] == '/') { + *tgt++ = src[1]; + *tgt++ = ':'; + *tgt++ = '\\'; + src += 3; + } + + while (*src) { + *tgt++ = (*src == '/') ? '\\' : *src; + src++; + } + + *tgt = '\0'; +} +#endif + +void test_repo_open__win32_path(void) +{ +#ifdef GIT_WIN32 + git_repository *repo = cl_git_sandbox_init("empty_standard_repo"), *repo2; + git_buf winpath = GIT_BUF_INIT; + static const char *repo_path = "empty_standard_repo/.git/"; + static const char *repo_wd = "empty_standard_repo/"; + + cl_assert(git__suffixcmp(git_repository_path(repo), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo), repo_wd) == 0); + + cl_git_pass(git_buf_sets(&winpath, git_repository_path(repo))); + unposix_path(&winpath); + cl_git_pass(git_repository_open(&repo2, winpath.ptr)); + cl_assert(git__suffixcmp(git_repository_path(repo2), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo2), repo_wd) == 0); + git_repository_free(repo2); + + cl_git_pass(git_buf_sets(&winpath, git_repository_path(repo))); + git_buf_truncate(&winpath, winpath.size - 1); /* remove trailing '/' */ + unposix_path(&winpath); + cl_git_pass(git_repository_open(&repo2, winpath.ptr)); + cl_assert(git__suffixcmp(git_repository_path(repo2), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo2), repo_wd) == 0); + git_repository_free(repo2); + + cl_git_pass(git_buf_sets(&winpath, git_repository_workdir(repo))); + unposix_path(&winpath); + cl_git_pass(git_repository_open(&repo2, winpath.ptr)); + cl_assert(git__suffixcmp(git_repository_path(repo2), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo2), repo_wd) == 0); + git_repository_free(repo2); + + cl_git_pass(git_buf_sets(&winpath, git_repository_workdir(repo))); + git_buf_truncate(&winpath, winpath.size - 1); /* remove trailing '/' */ + unposix_path(&winpath); + cl_git_pass(git_repository_open(&repo2, winpath.ptr)); + cl_assert(git__suffixcmp(git_repository_path(repo2), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo2), repo_wd) == 0); + git_repository_free(repo2); + + git_buf_free(&winpath); +#endif } diff --git a/tests-clar/repo/setters.c b/tests-clar/repo/setters.c new file mode 100644 index 000000000..6242d8541 --- /dev/null +++ b/tests-clar/repo/setters.c @@ -0,0 +1,80 @@ +#include "clar_libgit2.h" +#include "buffer.h" +#include "posix.h" +#include "util.h" + +static git_repository *repo; + +void test_repo_setters__initialize(void) +{ + cl_fixture_sandbox("testrepo.git"); + cl_git_pass(git_repository_open(&repo, "testrepo.git")); + cl_must_pass(p_mkdir("new_workdir", 0777)); +} + +void test_repo_setters__cleanup(void) +{ + git_repository_free(repo); + cl_fixture_cleanup("testrepo.git"); + cl_must_pass(p_rmdir("new_workdir")); +} + +void test_repo_setters__setting_a_workdir_turns_a_bare_repository_into_a_standard_one(void) +{ + cl_assert(git_repository_is_bare(repo) == 1); + + cl_assert(git_repository_workdir(repo) == NULL); + cl_git_pass(git_repository_set_workdir(repo, "./new_workdir")); + + cl_assert(git_repository_workdir(repo) != NULL); + cl_assert(git_repository_is_bare(repo) == 0); +} + +void test_repo_setters__setting_a_workdir_prettifies_its_path(void) +{ + cl_git_pass(git_repository_set_workdir(repo, "./new_workdir")); + + cl_assert(git__suffixcmp(git_repository_workdir(repo), "/") == 0); +} + +void test_repo_setters__setting_a_new_index_on_a_repo_which_has_already_loaded_one_properly_honors_the_refcount(void) +{ + git_index *new_index; + + cl_git_pass(git_index_open(&new_index, "./my-index")); + cl_assert(((git_refcount *)new_index)->refcount == 1); + + git_repository_set_index(repo, new_index); + cl_assert(((git_refcount *)new_index)->refcount == 2); + + git_repository_free(repo); + cl_assert(((git_refcount *)new_index)->refcount == 1); + + git_index_free(new_index); + + /* + * Ensure the cleanup method won't try to free the repo as it's already been taken care of + */ + repo = NULL; +} + +void test_repo_setters__setting_a_new_odb_on_a_repo_which_already_loaded_one_properly_honors_the_refcount(void) +{ + git_odb *new_odb; + + cl_git_pass(git_odb_open(&new_odb, "./testrepo.git/objects")); + cl_assert(((git_refcount *)new_odb)->refcount == 1); + + git_repository_set_odb(repo, new_odb); + cl_assert(((git_refcount *)new_odb)->refcount == 2); + + git_repository_free(repo); + cl_assert(((git_refcount *)new_odb)->refcount == 1); + + git_odb_free(new_odb); + + /* + * Ensure the cleanup method won't try to free the repo as it's already been taken care of + */ + repo = NULL; +} diff --git a/tests-clar/resources/attr/.gitted/index b/tests-clar/resources/attr/.gitted/index index 19fa99d5b..1d60eab8f 100644 Binary files a/tests-clar/resources/attr/.gitted/index and b/tests-clar/resources/attr/.gitted/index differ diff --git a/tests-clar/resources/attr/.gitted/logs/HEAD b/tests-clar/resources/attr/.gitted/logs/HEAD index 68fcff2c5..73f00f345 100644 --- a/tests-clar/resources/attr/.gitted/logs/HEAD +++ b/tests-clar/resources/attr/.gitted/logs/HEAD @@ -4,3 +4,5 @@ a5d76cad53f66f1312bd995909a5bab3c0820770 370fe9ec224ce33e71f9e5ec2bd1142ce9937a6a Russell Belfer 1327611749 -0800 commit: Updating files so we can do diffs 370fe9ec224ce33e71f9e5ec2bd1142ce9937a6a f5b0af1fb4f5c0cd7aad880711d368a07333c307 Russell Belfer 1327621027 -0800 commit: Updating test data f5b0af1fb4f5c0cd7aad880711d368a07333c307 a97cc019851d401a4f1d091cb91a15890a0dd1ba Russell Belfer 1328653313 -0800 commit: Some whitespace only changes for testing purposes +a97cc019851d401a4f1d091cb91a15890a0dd1ba 217878ab49e1314388ea2e32dc6fdb58a1b969e0 Russell Belfer 1332734901 -0700 commit: added files in sub/sub +217878ab49e1314388ea2e32dc6fdb58a1b969e0 24fa9a9fc4e202313e24b648087495441dab432b Russell Belfer 1332735555 -0700 commit: adding more files in sub for tree status diff --git a/tests-clar/resources/attr/.gitted/logs/refs/heads/master b/tests-clar/resources/attr/.gitted/logs/refs/heads/master index 68fcff2c5..73f00f345 100644 --- a/tests-clar/resources/attr/.gitted/logs/refs/heads/master +++ b/tests-clar/resources/attr/.gitted/logs/refs/heads/master @@ -4,3 +4,5 @@ a5d76cad53f66f1312bd995909a5bab3c0820770 370fe9ec224ce33e71f9e5ec2bd1142ce9937a6a Russell Belfer 1327611749 -0800 commit: Updating files so we can do diffs 370fe9ec224ce33e71f9e5ec2bd1142ce9937a6a f5b0af1fb4f5c0cd7aad880711d368a07333c307 Russell Belfer 1327621027 -0800 commit: Updating test data f5b0af1fb4f5c0cd7aad880711d368a07333c307 a97cc019851d401a4f1d091cb91a15890a0dd1ba Russell Belfer 1328653313 -0800 commit: Some whitespace only changes for testing purposes +a97cc019851d401a4f1d091cb91a15890a0dd1ba 217878ab49e1314388ea2e32dc6fdb58a1b969e0 Russell Belfer 1332734901 -0700 commit: added files in sub/sub +217878ab49e1314388ea2e32dc6fdb58a1b969e0 24fa9a9fc4e202313e24b648087495441dab432b Russell Belfer 1332735555 -0700 commit: adding more files in sub for tree status diff --git a/tests-clar/resources/attr/.gitted/objects/21/7878ab49e1314388ea2e32dc6fdb58a1b969e0 b/tests-clar/resources/attr/.gitted/objects/21/7878ab49e1314388ea2e32dc6fdb58a1b969e0 new file mode 100644 index 000000000..b537899f2 --- /dev/null +++ b/tests-clar/resources/attr/.gitted/objects/21/7878ab49e1314388ea2e32dc6fdb58a1b969e0 @@ -0,0 +1,4 @@ +xQ +0D)nD#xmvJ߀7cx0Iۺ -+e"v☝pwcJH1x%HL>Dd xC\ʤzᔶd0Z#mغڰ +y +>{qK \ No newline at end of file diff --git a/tests-clar/resources/attr/.gitted/objects/24/fa9a9fc4e202313e24b648087495441dab432b b/tests-clar/resources/attr/.gitted/objects/24/fa9a9fc4e202313e24b648087495441dab432b new file mode 100644 index 000000000..e7099bbaa Binary files /dev/null and b/tests-clar/resources/attr/.gitted/objects/24/fa9a9fc4e202313e24b648087495441dab432b differ diff --git a/tests-clar/resources/attr/.gitted/objects/45/5a314fa848d52ae1f11d254da4f60858fc97f4 b/tests-clar/resources/attr/.gitted/objects/45/5a314fa848d52ae1f11d254da4f60858fc97f4 new file mode 100644 index 000000000..f90f0d79c Binary files /dev/null and b/tests-clar/resources/attr/.gitted/objects/45/5a314fa848d52ae1f11d254da4f60858fc97f4 differ diff --git a/tests/resources/testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 b/tests-clar/resources/attr/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 rename to tests-clar/resources/attr/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 diff --git a/tests-clar/resources/attr/.gitted/objects/4e/49ba8c5b6c32ff28cd9dcb60be34df50fcc485 b/tests-clar/resources/attr/.gitted/objects/4e/49ba8c5b6c32ff28cd9dcb60be34df50fcc485 new file mode 100644 index 000000000..6fcc549b4 Binary files /dev/null and b/tests-clar/resources/attr/.gitted/objects/4e/49ba8c5b6c32ff28cd9dcb60be34df50fcc485 differ diff --git a/tests-clar/resources/attr/.gitted/objects/93/61f40bb97239cf55811892e14de2e344168ba1 b/tests-clar/resources/attr/.gitted/objects/93/61f40bb97239cf55811892e14de2e344168ba1 new file mode 100644 index 000000000..4b57836cd Binary files /dev/null and b/tests-clar/resources/attr/.gitted/objects/93/61f40bb97239cf55811892e14de2e344168ba1 differ diff --git a/tests-clar/resources/attr/.gitted/objects/9e/5bdc47d6a80f2be0ea3049ad74231b94609242 b/tests-clar/resources/attr/.gitted/objects/9e/5bdc47d6a80f2be0ea3049ad74231b94609242 new file mode 100644 index 000000000..d6385ec8d Binary files /dev/null and b/tests-clar/resources/attr/.gitted/objects/9e/5bdc47d6a80f2be0ea3049ad74231b94609242 differ diff --git a/tests-clar/resources/attr/.gitted/objects/ce/39a97a7fb1fa90bcf5e711249c1e507476ae0e b/tests-clar/resources/attr/.gitted/objects/ce/39a97a7fb1fa90bcf5e711249c1e507476ae0e new file mode 100644 index 000000000..1005f944a Binary files /dev/null and b/tests-clar/resources/attr/.gitted/objects/ce/39a97a7fb1fa90bcf5e711249c1e507476ae0e differ diff --git a/tests-clar/resources/attr/.gitted/objects/ec/b97df2a174987475ac816e3847fc8e9f6c596b b/tests-clar/resources/attr/.gitted/objects/ec/b97df2a174987475ac816e3847fc8e9f6c596b new file mode 100644 index 000000000..44d703b2e Binary files /dev/null and b/tests-clar/resources/attr/.gitted/objects/ec/b97df2a174987475ac816e3847fc8e9f6c596b differ diff --git a/tests-clar/resources/attr/.gitted/refs/heads/master b/tests-clar/resources/attr/.gitted/refs/heads/master index 7f8bbe3e7..8768776b3 100644 --- a/tests-clar/resources/attr/.gitted/refs/heads/master +++ b/tests-clar/resources/attr/.gitted/refs/heads/master @@ -1 +1 @@ -a97cc019851d401a4f1d091cb91a15890a0dd1ba +24fa9a9fc4e202313e24b648087495441dab432b diff --git a/tests/resources/testrepo/.gitted/HEAD b/tests-clar/resources/attr_index/.gitted/HEAD similarity index 100% rename from tests/resources/testrepo/.gitted/HEAD rename to tests-clar/resources/attr_index/.gitted/HEAD diff --git a/tests-clar/resources/attr_index/.gitted/config b/tests-clar/resources/attr_index/.gitted/config new file mode 100644 index 000000000..af107929f --- /dev/null +++ b/tests-clar/resources/attr_index/.gitted/config @@ -0,0 +1,6 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true diff --git a/tests-clar/resources/attr_index/.gitted/description b/tests-clar/resources/attr_index/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests-clar/resources/attr_index/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests-clar/resources/attr_index/.gitted/index b/tests-clar/resources/attr_index/.gitted/index new file mode 100644 index 000000000..d87480332 Binary files /dev/null and b/tests-clar/resources/attr_index/.gitted/index differ diff --git a/tests-clar/resources/attr_index/.gitted/info/exclude b/tests-clar/resources/attr_index/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests-clar/resources/attr_index/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests-clar/resources/attr_index/.gitted/info/refs b/tests-clar/resources/attr_index/.gitted/info/refs new file mode 100644 index 000000000..60feca293 --- /dev/null +++ b/tests-clar/resources/attr_index/.gitted/info/refs @@ -0,0 +1 @@ +58f7cf825b553ef7c26e5b9f8a23599c1a9ca296 refs/heads/master diff --git a/tests-clar/resources/attr_index/.gitted/logs/HEAD b/tests-clar/resources/attr_index/.gitted/logs/HEAD new file mode 100644 index 000000000..ffd298c04 --- /dev/null +++ b/tests-clar/resources/attr_index/.gitted/logs/HEAD @@ -0,0 +1,4 @@ +0000000000000000000000000000000000000000 67c1640e91ccbaf0793591be09bf572cf40c9a53 Russell Belfer 1335817070 -0700 commit (initial): Initial commit +67c1640e91ccbaf0793591be09bf572cf40c9a53 d441d7d88f52c28c2b23940ce4c33756748425f9 Russell Belfer 1335817296 -0700 commit: Adding some files in subtrees +d441d7d88f52c28c2b23940ce4c33756748425f9 67c1640e91ccbaf0793591be09bf572cf40c9a53 Russell Belfer 1335817353 -0700 HEAD^: updating HEAD +67c1640e91ccbaf0793591be09bf572cf40c9a53 58f7cf825b553ef7c26e5b9f8a23599c1a9ca296 Russell Belfer 1335817372 -0700 commit: Adding subtree data diff --git a/tests-clar/resources/attr_index/.gitted/logs/refs/heads/master b/tests-clar/resources/attr_index/.gitted/logs/refs/heads/master new file mode 100644 index 000000000..ffd298c04 --- /dev/null +++ b/tests-clar/resources/attr_index/.gitted/logs/refs/heads/master @@ -0,0 +1,4 @@ +0000000000000000000000000000000000000000 67c1640e91ccbaf0793591be09bf572cf40c9a53 Russell Belfer 1335817070 -0700 commit (initial): Initial commit +67c1640e91ccbaf0793591be09bf572cf40c9a53 d441d7d88f52c28c2b23940ce4c33756748425f9 Russell Belfer 1335817296 -0700 commit: Adding some files in subtrees +d441d7d88f52c28c2b23940ce4c33756748425f9 67c1640e91ccbaf0793591be09bf572cf40c9a53 Russell Belfer 1335817353 -0700 HEAD^: updating HEAD +67c1640e91ccbaf0793591be09bf572cf40c9a53 58f7cf825b553ef7c26e5b9f8a23599c1a9ca296 Russell Belfer 1335817372 -0700 commit: Adding subtree data diff --git a/tests-clar/resources/attr_index/.gitted/objects/38/12cfef36615db1788d4e63f90028007e17a348 b/tests-clar/resources/attr_index/.gitted/objects/38/12cfef36615db1788d4e63f90028007e17a348 new file mode 100644 index 000000000..ee2991571 --- /dev/null +++ b/tests-clar/resources/attr_index/.gitted/objects/38/12cfef36615db1788d4e63f90028007e17a348 @@ -0,0 +1,3 @@ +x[ + E*@PJ +]&`w 'oMKDq45DF#!!=VZD.L:%L}!dCg*qв-LUkz~6閷W}}>g˾{f% G \ No newline at end of file diff --git a/tests-clar/resources/attr_index/.gitted/objects/59/d942b8be2784bc96db9b22202c10815c9a077b b/tests-clar/resources/attr_index/.gitted/objects/59/d942b8be2784bc96db9b22202c10815c9a077b new file mode 100644 index 000000000..ff33737db --- /dev/null +++ b/tests-clar/resources/attr_index/.gitted/objects/59/d942b8be2784bc96db9b22202c10815c9a077b @@ -0,0 +1 @@ +x 0 @@kR@] 1331989635 +0100 commit (initial): Initial commit +4d383e87f0371ba8fa353f3912db6862b2625e85 e38fcc7a6060f5eb5b876e836b52ae4769363f21 nulltoken 1332227062 +0100 commit (amend): Initial commit diff --git a/tests-clar/resources/issue_592/.gitted/logs/refs/heads/master b/tests-clar/resources/issue_592/.gitted/logs/refs/heads/master new file mode 100644 index 000000000..f19fe35a6 --- /dev/null +++ b/tests-clar/resources/issue_592/.gitted/logs/refs/heads/master @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000 4d383e87f0371ba8fa353f3912db6862b2625e85 nulltoken 1331989635 +0100 commit (initial): Initial commit +4d383e87f0371ba8fa353f3912db6862b2625e85 e38fcc7a6060f5eb5b876e836b52ae4769363f21 nulltoken 1332227062 +0100 commit (amend): Initial commit diff --git a/tests-clar/resources/issue_592/.gitted/objects/06/07ee9d4ccce8e4c4fa13c2c7d727e7faba4e0e b/tests-clar/resources/issue_592/.gitted/objects/06/07ee9d4ccce8e4c4fa13c2c7d727e7faba4e0e new file mode 100644 index 000000000..05dec10f7 Binary files /dev/null and b/tests-clar/resources/issue_592/.gitted/objects/06/07ee9d4ccce8e4c4fa13c2c7d727e7faba4e0e differ diff --git a/tests-clar/resources/issue_592/.gitted/objects/49/363a72a90d9424240258cd3759f23788ecf1d8 b/tests-clar/resources/issue_592/.gitted/objects/49/363a72a90d9424240258cd3759f23788ecf1d8 new file mode 100644 index 000000000..e997e1b49 Binary files /dev/null and b/tests-clar/resources/issue_592/.gitted/objects/49/363a72a90d9424240258cd3759f23788ecf1d8 differ diff --git a/tests-clar/resources/issue_592/.gitted/objects/4d/383e87f0371ba8fa353f3912db6862b2625e85 b/tests-clar/resources/issue_592/.gitted/objects/4d/383e87f0371ba8fa353f3912db6862b2625e85 new file mode 100644 index 000000000..c49a8be58 --- /dev/null +++ b/tests-clar/resources/issue_592/.gitted/objects/4d/383e87f0371ba8fa353f3912db6862b2625e85 @@ -0,0 +1,2 @@ +xM +0]o/IDz bz H9v2t =k,p+͏>4U=^(tAF2̟3sL|%cYuZv{=r_G}K> \ No newline at end of file diff --git a/tests-clar/resources/issue_592/.gitted/objects/71/44be264b61825fbff68046fe999bdfe96a1792 b/tests-clar/resources/issue_592/.gitted/objects/71/44be264b61825fbff68046fe999bdfe96a1792 new file mode 100644 index 000000000..25d44d938 Binary files /dev/null and b/tests-clar/resources/issue_592/.gitted/objects/71/44be264b61825fbff68046fe999bdfe96a1792 differ diff --git a/tests-clar/resources/issue_592/.gitted/objects/be/de83ee10b5b3f00239660b00acec2d55fd0b84 b/tests-clar/resources/issue_592/.gitted/objects/be/de83ee10b5b3f00239660b00acec2d55fd0b84 new file mode 100644 index 000000000..1d6e38d37 Binary files /dev/null and b/tests-clar/resources/issue_592/.gitted/objects/be/de83ee10b5b3f00239660b00acec2d55fd0b84 differ diff --git a/tests-clar/resources/issue_592/.gitted/objects/e3/8fcc7a6060f5eb5b876e836b52ae4769363f21 b/tests-clar/resources/issue_592/.gitted/objects/e3/8fcc7a6060f5eb5b876e836b52ae4769363f21 new file mode 100644 index 000000000..36c5b9aab Binary files /dev/null and b/tests-clar/resources/issue_592/.gitted/objects/e3/8fcc7a6060f5eb5b876e836b52ae4769363f21 differ diff --git a/tests-clar/resources/issue_592/.gitted/objects/f1/adef63cb08891a0942b76fc4b9c50c6c494bc7 b/tests-clar/resources/issue_592/.gitted/objects/f1/adef63cb08891a0942b76fc4b9c50c6c494bc7 new file mode 100644 index 000000000..c08ecd5ed Binary files /dev/null and b/tests-clar/resources/issue_592/.gitted/objects/f1/adef63cb08891a0942b76fc4b9c50c6c494bc7 differ diff --git a/tests-clar/resources/issue_592/.gitted/refs/heads/master b/tests-clar/resources/issue_592/.gitted/refs/heads/master new file mode 100644 index 000000000..1f6669628 --- /dev/null +++ b/tests-clar/resources/issue_592/.gitted/refs/heads/master @@ -0,0 +1 @@ +e38fcc7a6060f5eb5b876e836b52ae4769363f21 diff --git a/tests-clar/resources/issue_592/a.txt b/tests-clar/resources/issue_592/a.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests-clar/resources/issue_592/a.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests-clar/resources/issue_592/c/a.txt b/tests-clar/resources/issue_592/c/a.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests-clar/resources/issue_592/c/a.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests-clar/resources/issue_592/l.txt b/tests-clar/resources/issue_592/l.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests-clar/resources/issue_592/l.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests-clar/resources/issue_592/t/a.txt b/tests-clar/resources/issue_592/t/a.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests-clar/resources/issue_592/t/a.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests-clar/resources/issue_592/t/b.txt b/tests-clar/resources/issue_592/t/b.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests-clar/resources/issue_592/t/b.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests-clar/resources/submodules/.gitted/HEAD b/tests-clar/resources/submodules/.gitted/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests-clar/resources/submodules/.gitted/config b/tests-clar/resources/submodules/.gitted/config new file mode 100644 index 000000000..af107929f --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/config @@ -0,0 +1,6 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true diff --git a/tests-clar/resources/submodules/.gitted/description b/tests-clar/resources/submodules/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests-clar/resources/submodules/.gitted/index b/tests-clar/resources/submodules/.gitted/index new file mode 100644 index 000000000..97bf8ef51 Binary files /dev/null and b/tests-clar/resources/submodules/.gitted/index differ diff --git a/tests-clar/resources/submodules/.gitted/info/exclude b/tests-clar/resources/submodules/.gitted/info/exclude new file mode 100644 index 000000000..dfc411579 --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/info/exclude @@ -0,0 +1,8 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ +ignored + diff --git a/tests-clar/resources/submodules/.gitted/info/refs b/tests-clar/resources/submodules/.gitted/info/refs new file mode 100644 index 000000000..ba17abdde --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/info/refs @@ -0,0 +1 @@ +09176a980273d801a3e37cc45c84af1366501ed9 refs/heads/master diff --git a/tests-clar/resources/submodules/.gitted/logs/HEAD b/tests-clar/resources/submodules/.gitted/logs/HEAD new file mode 100644 index 000000000..87a7bdafc --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/logs/HEAD @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000 09176a980273d801a3e37cc45c84af1366501ed9 Russell Belfer 1332365253 -0700 commit (initial): initial commit +09176a980273d801a3e37cc45c84af1366501ed9 97896810b3210244a62a82458b8e0819ecfc6850 Russell Belfer 1332780781 -0700 commit: Setting up gitmodules diff --git a/tests-clar/resources/submodules/.gitted/logs/refs/heads/master b/tests-clar/resources/submodules/.gitted/logs/refs/heads/master new file mode 100644 index 000000000..87a7bdafc --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/logs/refs/heads/master @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000 09176a980273d801a3e37cc45c84af1366501ed9 Russell Belfer 1332365253 -0700 commit (initial): initial commit +09176a980273d801a3e37cc45c84af1366501ed9 97896810b3210244a62a82458b8e0819ecfc6850 Russell Belfer 1332780781 -0700 commit: Setting up gitmodules diff --git a/tests-clar/resources/submodules/.gitted/objects/26/a3b32a9b7d97486c5557f5902e8ac94638145e b/tests-clar/resources/submodules/.gitted/objects/26/a3b32a9b7d97486c5557f5902e8ac94638145e new file mode 100644 index 000000000..2c3c2cb61 --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/objects/26/a3b32a9b7d97486c5557f5902e8ac94638145e @@ -0,0 +1,2 @@ +x%= +0 F])0"I*|-t{?2ilV8$mvkk*F DA=(=|=6 DAv=A}&'O$= \ No newline at end of file diff --git a/tests-clar/resources/submodules/.gitted/objects/78/308c9251cf4eee8b25a76c7d2790c73d797357 b/tests-clar/resources/submodules/.gitted/objects/78/308c9251cf4eee8b25a76c7d2790c73d797357 new file mode 100644 index 000000000..c85fb5512 Binary files /dev/null and b/tests-clar/resources/submodules/.gitted/objects/78/308c9251cf4eee8b25a76c7d2790c73d797357 differ diff --git a/tests-clar/resources/submodules/.gitted/objects/97/896810b3210244a62a82458b8e0819ecfc6850 b/tests-clar/resources/submodules/.gitted/objects/97/896810b3210244a62a82458b8e0819ecfc6850 new file mode 100644 index 000000000..1c8dbdf9f --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/objects/97/896810b3210244a62a82458b8e0819ecfc6850 @@ -0,0 +1,3 @@ +x[ +0E*fʤS K4ݿwׅ9p2MCFP @u..p!OYdiYU'̕8XbPn6 +ħԞ1[q}0qc[W#1fR:SZ+Y+{tdlvOmu_}5i` K \ No newline at end of file diff --git a/tests-clar/resources/submodules/.gitted/objects/b6/0fd986699ba4e9e68bea07cf8e793f323ef888 b/tests-clar/resources/submodules/.gitted/objects/b6/0fd986699ba4e9e68bea07cf8e793f323ef888 new file mode 100644 index 000000000..3d78bd6be Binary files /dev/null and b/tests-clar/resources/submodules/.gitted/objects/b6/0fd986699ba4e9e68bea07cf8e793f323ef888 differ diff --git a/tests-clar/resources/submodules/.gitted/objects/d5/f7fc3f74f7dec08280f370a975b112e8f60818 b/tests-clar/resources/submodules/.gitted/objects/d5/f7fc3f74f7dec08280f370a975b112e8f60818 new file mode 100644 index 000000000..6e0b49e86 Binary files /dev/null and b/tests-clar/resources/submodules/.gitted/objects/d5/f7fc3f74f7dec08280f370a975b112e8f60818 differ diff --git a/tests-clar/resources/submodules/.gitted/objects/e3/50052cc767cd1fcb37e84e9a89e701925be4ae b/tests-clar/resources/submodules/.gitted/objects/e3/50052cc767cd1fcb37e84e9a89e701925be4ae new file mode 100644 index 000000000..082a58941 Binary files /dev/null and b/tests-clar/resources/submodules/.gitted/objects/e3/50052cc767cd1fcb37e84e9a89e701925be4ae differ diff --git a/tests-clar/resources/submodules/.gitted/objects/info/packs b/tests-clar/resources/submodules/.gitted/objects/info/packs new file mode 100644 index 000000000..0785ef698 --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/objects/info/packs @@ -0,0 +1,2 @@ +P pack-b69d04bb39ac274669e2184e45bd90015d02ef5b.pack + diff --git a/tests-clar/resources/submodules/.gitted/objects/pack/pack-b69d04bb39ac274669e2184e45bd90015d02ef5b.idx b/tests-clar/resources/submodules/.gitted/objects/pack/pack-b69d04bb39ac274669e2184e45bd90015d02ef5b.idx new file mode 100644 index 000000000..810fc3181 Binary files /dev/null and b/tests-clar/resources/submodules/.gitted/objects/pack/pack-b69d04bb39ac274669e2184e45bd90015d02ef5b.idx differ diff --git a/tests-clar/resources/submodules/.gitted/objects/pack/pack-b69d04bb39ac274669e2184e45bd90015d02ef5b.pack b/tests-clar/resources/submodules/.gitted/objects/pack/pack-b69d04bb39ac274669e2184e45bd90015d02ef5b.pack new file mode 100644 index 000000000..c25c4a73f Binary files /dev/null and b/tests-clar/resources/submodules/.gitted/objects/pack/pack-b69d04bb39ac274669e2184e45bd90015d02ef5b.pack differ diff --git a/tests-clar/resources/submodules/.gitted/packed-refs b/tests-clar/resources/submodules/.gitted/packed-refs new file mode 100644 index 000000000..a6450691e --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +09176a980273d801a3e37cc45c84af1366501ed9 refs/heads/master diff --git a/tests-clar/resources/submodules/.gitted/refs/heads/master b/tests-clar/resources/submodules/.gitted/refs/heads/master new file mode 100644 index 000000000..32b935853 --- /dev/null +++ b/tests-clar/resources/submodules/.gitted/refs/heads/master @@ -0,0 +1 @@ +97896810b3210244a62a82458b8e0819ecfc6850 diff --git a/tests-clar/resources/submodules/added b/tests-clar/resources/submodules/added new file mode 100644 index 000000000..d5f7fc3f7 --- /dev/null +++ b/tests-clar/resources/submodules/added @@ -0,0 +1 @@ +added diff --git a/tests-clar/resources/submodules/gitmodules b/tests-clar/resources/submodules/gitmodules new file mode 100644 index 000000000..1262f8bb0 --- /dev/null +++ b/tests-clar/resources/submodules/gitmodules @@ -0,0 +1,3 @@ +[submodule "testrepo"] + path = testrepo + url = \ No newline at end of file diff --git a/tests-clar/resources/submodules/ignored b/tests-clar/resources/submodules/ignored new file mode 100644 index 000000000..092bfb9bd --- /dev/null +++ b/tests-clar/resources/submodules/ignored @@ -0,0 +1 @@ +yo diff --git a/tests-clar/resources/submodules/modified b/tests-clar/resources/submodules/modified new file mode 100644 index 000000000..452216e1d --- /dev/null +++ b/tests-clar/resources/submodules/modified @@ -0,0 +1,2 @@ +changed + diff --git a/tests-clar/resources/submodules/testrepo/.gitted/HEAD b/tests-clar/resources/submodules/testrepo/.gitted/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests-clar/resources/submodules/testrepo/.gitted/config b/tests-clar/resources/submodules/testrepo/.gitted/config new file mode 100644 index 000000000..d6dcad12b --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/.gitted/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests/resources/testrepo.git +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests-clar/resources/submodules/testrepo/.gitted/description b/tests-clar/resources/submodules/testrepo/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests-clar/resources/submodules/testrepo/.gitted/index b/tests-clar/resources/submodules/testrepo/.gitted/index new file mode 100644 index 000000000..3eb8d84fe Binary files /dev/null and b/tests-clar/resources/submodules/testrepo/.gitted/index differ diff --git a/tests-clar/resources/submodules/testrepo/.gitted/info/exclude b/tests-clar/resources/submodules/testrepo/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests-clar/resources/submodules/testrepo/.gitted/logs/HEAD b/tests-clar/resources/submodules/testrepo/.gitted/logs/HEAD new file mode 100644 index 000000000..147643a30 --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/.gitted/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 a65fedf39aefe402d3bb6e24df4d4f5fe4547750 Russell Belfer 1332366307 -0700 clone: from /Users/rb/src/libgit2/tests/resources/testrepo.git diff --git a/tests-clar/resources/submodules/testrepo/.gitted/logs/refs/heads/master b/tests-clar/resources/submodules/testrepo/.gitted/logs/refs/heads/master new file mode 100644 index 000000000..147643a30 --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/.gitted/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 a65fedf39aefe402d3bb6e24df4d4f5fe4547750 Russell Belfer 1332366307 -0700 clone: from /Users/rb/src/libgit2/tests/resources/testrepo.git diff --git a/tests/resources/testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 b/tests-clar/resources/submodules/testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 diff --git a/tests/resources/testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 b/tests-clar/resources/submodules/testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 diff --git a/tests/resources/testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd b/tests-clar/resources/submodules/testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd similarity index 100% rename from tests/resources/testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd rename to tests-clar/resources/submodules/testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd diff --git a/tests/resources/testrepo/.gitted/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b b/tests-clar/resources/submodules/testrepo/.gitted/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b similarity index 100% rename from tests/resources/testrepo/.gitted/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b rename to tests-clar/resources/submodules/testrepo/.gitted/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b diff --git a/tests/resources/testrepo/.gitted/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d b/tests-clar/resources/submodules/testrepo/.gitted/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d similarity index 100% rename from tests/resources/testrepo/.gitted/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d rename to tests-clar/resources/submodules/testrepo/.gitted/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d diff --git a/tests/resources/testrepo/.gitted/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 b/tests-clar/resources/submodules/testrepo/.gitted/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 diff --git a/tests/resources/testrepo/.gitted/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc b/tests-clar/resources/submodules/testrepo/.gitted/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc similarity index 100% rename from tests/resources/testrepo/.gitted/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc rename to tests-clar/resources/submodules/testrepo/.gitted/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc diff --git a/tests-clar/resources/submodules/testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 b/tests-clar/resources/submodules/testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 new file mode 100644 index 000000000..7ca4ceed5 Binary files /dev/null and b/tests-clar/resources/submodules/testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 differ diff --git a/tests/resources/testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 b/tests-clar/resources/submodules/testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 diff --git a/tests/resources/testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 b/tests-clar/resources/submodules/testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 diff --git a/tests/resources/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a b/tests-clar/resources/submodules/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a similarity index 100% rename from tests/resources/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a rename to tests-clar/resources/submodules/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a diff --git a/tests/resources/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af b/tests-clar/resources/submodules/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af similarity index 100% rename from tests/resources/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af rename to tests-clar/resources/submodules/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af diff --git a/tests/resources/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 b/tests-clar/resources/submodules/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 diff --git a/tests/resources/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d b/tests-clar/resources/submodules/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d similarity index 100% rename from tests/resources/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d rename to tests-clar/resources/submodules/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d diff --git a/tests/resources/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 b/tests-clar/resources/submodules/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 diff --git a/tests/resources/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 b/tests-clar/resources/submodules/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 diff --git a/tests/resources/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 b/tests-clar/resources/submodules/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 diff --git a/tests/resources/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a b/tests-clar/resources/submodules/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a similarity index 100% rename from tests/resources/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a rename to tests-clar/resources/submodules/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a diff --git a/tests/resources/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f b/tests-clar/resources/submodules/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f similarity index 100% rename from tests/resources/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f rename to tests-clar/resources/submodules/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f diff --git a/tests/resources/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 b/tests-clar/resources/submodules/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 diff --git a/tests/resources/testrepo/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd b/tests-clar/resources/submodules/testrepo/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd similarity index 100% rename from tests/resources/testrepo/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd rename to tests-clar/resources/submodules/testrepo/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd diff --git a/tests/resources/testrepo/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 b/tests-clar/resources/submodules/testrepo/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 diff --git a/tests/resources/testrepo/.gitted/objects/ae/90f12eea699729ed24555e40b9fd669da12a12 b/tests-clar/resources/submodules/testrepo/.gitted/objects/ae/90f12eea699729ed24555e40b9fd669da12a12 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/ae/90f12eea699729ed24555e40b9fd669da12a12 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/ae/90f12eea699729ed24555e40b9fd669da12a12 diff --git a/tests/resources/testrepo/.gitted/objects/b2/5fa35b38051e4ae45d4222e795f9df2e43f1d1 b/tests-clar/resources/submodules/testrepo/.gitted/objects/b2/5fa35b38051e4ae45d4222e795f9df2e43f1d1 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/b2/5fa35b38051e4ae45d4222e795f9df2e43f1d1 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/b2/5fa35b38051e4ae45d4222e795f9df2e43f1d1 diff --git a/tests/resources/testrepo/.gitted/objects/b6/361fc6a97178d8fc8639fdeed71c775ab52593 b/tests-clar/resources/submodules/testrepo/.gitted/objects/b6/361fc6a97178d8fc8639fdeed71c775ab52593 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/b6/361fc6a97178d8fc8639fdeed71c775ab52593 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/b6/361fc6a97178d8fc8639fdeed71c775ab52593 diff --git a/tests/resources/testrepo/.gitted/objects/be/3563ae3f795b2b4353bcce3a527ad0a4f7f644 b/tests-clar/resources/submodules/testrepo/.gitted/objects/be/3563ae3f795b2b4353bcce3a527ad0a4f7f644 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/be/3563ae3f795b2b4353bcce3a527ad0a4f7f644 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/be/3563ae3f795b2b4353bcce3a527ad0a4f7f644 diff --git a/tests/resources/testrepo/.gitted/objects/c4/7800c7266a2be04c571c04d5a6614691ea99bd b/tests-clar/resources/submodules/testrepo/.gitted/objects/c4/7800c7266a2be04c571c04d5a6614691ea99bd similarity index 100% rename from tests/resources/testrepo/.gitted/objects/c4/7800c7266a2be04c571c04d5a6614691ea99bd rename to tests-clar/resources/submodules/testrepo/.gitted/objects/c4/7800c7266a2be04c571c04d5a6614691ea99bd diff --git a/tests/resources/testrepo/.gitted/objects/d6/c93164c249c8000205dd4ec5cbca1b516d487f b/tests-clar/resources/submodules/testrepo/.gitted/objects/d6/c93164c249c8000205dd4ec5cbca1b516d487f similarity index 100% rename from tests/resources/testrepo/.gitted/objects/d6/c93164c249c8000205dd4ec5cbca1b516d487f rename to tests-clar/resources/submodules/testrepo/.gitted/objects/d6/c93164c249c8000205dd4ec5cbca1b516d487f diff --git a/tests/resources/testrepo/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests-clar/resources/submodules/testrepo/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/tests/resources/testrepo/.gitted/objects/e7/b4ad382349ff96dd8199000580b9b1e2042eb0 b/tests-clar/resources/submodules/testrepo/.gitted/objects/e7/b4ad382349ff96dd8199000580b9b1e2042eb0 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/e7/b4ad382349ff96dd8199000580b9b1e2042eb0 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/e7/b4ad382349ff96dd8199000580b9b1e2042eb0 diff --git a/tests/resources/testrepo/.gitted/objects/f1/425cef211cc08caa31e7b545ffb232acb098c3 b/tests-clar/resources/submodules/testrepo/.gitted/objects/f1/425cef211cc08caa31e7b545ffb232acb098c3 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/f1/425cef211cc08caa31e7b545ffb232acb098c3 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/f1/425cef211cc08caa31e7b545ffb232acb098c3 diff --git a/tests/resources/testrepo/.gitted/objects/f6/0079018b664e4e79329a7ef9559c8d9e0378d1 b/tests-clar/resources/submodules/testrepo/.gitted/objects/f6/0079018b664e4e79329a7ef9559c8d9e0378d1 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/f6/0079018b664e4e79329a7ef9559c8d9e0378d1 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/f6/0079018b664e4e79329a7ef9559c8d9e0378d1 diff --git a/tests/resources/testrepo/.gitted/objects/fa/49b077972391ad58037050f2a75f74e3671e92 b/tests-clar/resources/submodules/testrepo/.gitted/objects/fa/49b077972391ad58037050f2a75f74e3671e92 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/fa/49b077972391ad58037050f2a75f74e3671e92 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/fa/49b077972391ad58037050f2a75f74e3671e92 diff --git a/tests/resources/testrepo/.gitted/objects/fd/093bff70906175335656e6ce6ae05783708765 b/tests-clar/resources/submodules/testrepo/.gitted/objects/fd/093bff70906175335656e6ce6ae05783708765 similarity index 100% rename from tests/resources/testrepo/.gitted/objects/fd/093bff70906175335656e6ce6ae05783708765 rename to tests-clar/resources/submodules/testrepo/.gitted/objects/fd/093bff70906175335656e6ce6ae05783708765 diff --git a/tests/resources/testrepo/.gitted/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx b/tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx similarity index 100% rename from tests/resources/testrepo/.gitted/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx rename to tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx diff --git a/tests/resources/testrepo/.gitted/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.pack b/tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.pack similarity index 100% rename from tests/resources/testrepo/.gitted/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.pack rename to tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.pack diff --git a/tests/resources/testrepo/.gitted/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx b/tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx similarity index 100% rename from tests/resources/testrepo/.gitted/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx rename to tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx diff --git a/tests/resources/testrepo/.gitted/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.pack b/tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.pack similarity index 100% rename from tests/resources/testrepo/.gitted/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.pack rename to tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.pack diff --git a/tests/resources/testrepo/.gitted/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx b/tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx similarity index 100% rename from tests/resources/testrepo/.gitted/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx rename to tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx diff --git a/tests/resources/testrepo/.gitted/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.pack b/tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.pack similarity index 100% rename from tests/resources/testrepo/.gitted/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.pack rename to tests-clar/resources/submodules/testrepo/.gitted/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.pack diff --git a/tests-clar/resources/submodules/testrepo/.gitted/packed-refs b/tests-clar/resources/submodules/testrepo/.gitted/packed-refs new file mode 100644 index 000000000..9c0433e1c --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/.gitted/packed-refs @@ -0,0 +1,12 @@ +# pack-refs with: peeled +b25fa35b38051e4ae45d4222e795f9df2e43f1d1 refs/tags/test +^e90810b8df3e80c413d903f631643c716887138d +1385f264afb75a56a5bec74243be9b367ba4ca08 refs/tags/point_to_blob +7b4384978d2493e851f9cca7858815fac9b10980 refs/tags/e90810b +^e90810b8df3e80c413d903f631643c716887138d +e90810b8df3e80c413d903f631643c716887138d refs/remotes/origin/test +763d71aadf09a7951596c9746c024e7eece7c7af refs/remotes/origin/subtrees +4a202b346bb0fb0db7eff3cffeb3c70babbd2045 refs/remotes/origin/packed-test +41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9 refs/remotes/origin/packed +a65fedf39aefe402d3bb6e24df4d4f5fe4547750 refs/remotes/origin/master +a4a7dce85cf63874e984719f4fdd239f5145052f refs/remotes/origin/br2 diff --git a/tests/resources/testrepo/.gitted/refs/heads/master b/tests-clar/resources/submodules/testrepo/.gitted/refs/heads/master similarity index 100% rename from tests/resources/testrepo/.gitted/refs/heads/master rename to tests-clar/resources/submodules/testrepo/.gitted/refs/heads/master diff --git a/tests-clar/resources/submodules/testrepo/.gitted/refs/remotes/origin/HEAD b/tests-clar/resources/submodules/testrepo/.gitted/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/.gitted/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests-clar/resources/submodules/testrepo/README b/tests-clar/resources/submodules/testrepo/README new file mode 100644 index 000000000..a8233120f --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/README @@ -0,0 +1 @@ +hey there diff --git a/tests-clar/resources/submodules/testrepo/branch_file.txt b/tests-clar/resources/submodules/testrepo/branch_file.txt new file mode 100644 index 000000000..3697d64be --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/branch_file.txt @@ -0,0 +1,2 @@ +hi +bye! diff --git a/tests-clar/resources/submodules/testrepo/new.txt b/tests-clar/resources/submodules/testrepo/new.txt new file mode 100644 index 000000000..a71586c1d --- /dev/null +++ b/tests-clar/resources/submodules/testrepo/new.txt @@ -0,0 +1 @@ +my new file diff --git a/tests-clar/resources/submodules/unmodified b/tests-clar/resources/submodules/unmodified new file mode 100644 index 000000000..092bfb9bd --- /dev/null +++ b/tests-clar/resources/submodules/unmodified @@ -0,0 +1 @@ +yo diff --git a/tests-clar/resources/submodules/untracked b/tests-clar/resources/submodules/untracked new file mode 100644 index 000000000..092bfb9bd --- /dev/null +++ b/tests-clar/resources/submodules/untracked @@ -0,0 +1 @@ +yo diff --git a/tests-clar/resources/testrepo.git/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 b/tests-clar/resources/testrepo.git/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 new file mode 100644 index 000000000..351cff823 Binary files /dev/null and b/tests-clar/resources/testrepo.git/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 differ diff --git a/tests-clar/resources/testrepo.git/refs/tags/annotated_tag_to_blob b/tests-clar/resources/testrepo.git/refs/tags/annotated_tag_to_blob new file mode 100644 index 000000000..6c146d6e3 --- /dev/null +++ b/tests-clar/resources/testrepo.git/refs/tags/annotated_tag_to_blob @@ -0,0 +1 @@ +521d87c1ec3aef9824daf6d96cc0ae3710766d91 diff --git a/tests-clar/revwalk/basic.c b/tests-clar/revwalk/basic.c index cc88ec65b..7d54ce990 100644 --- a/tests-clar/revwalk/basic.c +++ b/tests-clar/revwalk/basic.c @@ -148,14 +148,13 @@ void test_revwalk_basic__push_head(void) cl_assert(i == 7); } -void test_revwalk_basic__push_head_hide_glob(void) +void test_revwalk_basic__push_head_hide_ref(void) { int i = 0; git_oid oid; cl_git_pass(git_revwalk_push_head(_walk)); - /* This is a hack, as we know this will only match the packed-test branch */ - cl_git_pass(git_revwalk_hide_glob(_walk, "heads/packed-test*")); + cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed-test")); while (git_revwalk_next(&oid, _walk) == GIT_SUCCESS) { i++; @@ -164,3 +163,19 @@ void test_revwalk_basic__push_head_hide_glob(void) /* git log HEAD --oneline --not refs/heads/packed-test | wc -l => 4 */ cl_assert(i == 4); } + +void test_revwalk_basic__push_head_hide_ref_nobase(void) +{ + int i = 0; + git_oid oid; + + cl_git_pass(git_revwalk_push_head(_walk)); + cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed")); + + while (git_revwalk_next(&oid, _walk) == GIT_SUCCESS) { + i++; + } + + /* git log HEAD --oneline --not refs/heads/packed | wc -l => 7 */ + cl_assert(i == 7); +} diff --git a/tests-clar/revwalk/mergebase.c b/tests-clar/revwalk/mergebase.c new file mode 100644 index 000000000..91bc6ae8c --- /dev/null +++ b/tests-clar/revwalk/mergebase.c @@ -0,0 +1,37 @@ +#include "clar_libgit2.h" + +static git_repository *_repo; + +void test_revwalk_mergebase__initialize(void) +{ + cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git"))); +} + +void test_revwalk_mergebase__cleanup(void) +{ + git_repository_free(_repo); +} + +void test_revwalk_mergebase__single1(void) +{ + git_oid result, one, two, expected; + + git_oid_fromstr(&one, "c47800c7266a2be04c571c04d5a6614691ea99bd "); + git_oid_fromstr(&two, "9fd738e8f7967c078dceed8190330fc8648ee56a"); + git_oid_fromstr(&expected, "5b5b025afb0b4c913b4c338a42934a3863bf3644"); + + cl_git_pass(git_merge_base(&result, _repo, &one, &two)); + cl_assert(git_oid_cmp(&result, &expected) == 0); +} + +void test_revwalk_mergebase__single2(void) +{ + git_oid result, one, two, expected; + + git_oid_fromstr(&one, "763d71aadf09a7951596c9746c024e7eece7c7af"); + git_oid_fromstr(&two, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); + git_oid_fromstr(&expected, "c47800c7266a2be04c571c04d5a6614691ea99bd"); + + cl_git_pass(git_merge_base(&result, _repo, &one, &two)); + cl_assert(git_oid_cmp(&result, &expected) == 0); +} diff --git a/tests-clar/status/ignore.c b/tests-clar/status/ignore.c index 99cb9e8b8..e92d6a577 100644 --- a/tests-clar/status/ignore.c +++ b/tests-clar/status/ignore.c @@ -47,6 +47,34 @@ void test_status_ignore__0(void) } /* confirm that ignore files were cached */ - cl_git_pass(git_attr_cache__is_cached(g_repo, ".git/info/exclude")); - cl_git_pass(git_attr_cache__is_cached(g_repo, ".gitignore")); + cl_assert(git_attr_cache__is_cached(g_repo, 0, ".git/info/exclude")); + cl_assert(git_attr_cache__is_cached(g_repo, 0, ".gitignore")); } + + +void test_status_ignore__1(void) +{ + int ignored; + + cl_git_rewritefile("attr/.gitignore", "/*.txt\n/dir/\n"); + git_attr_cache_flush(g_repo); + + cl_git_pass(git_status_should_ignore(g_repo, "root_test4.txt", &ignored)); + cl_assert(ignored); + + cl_git_pass(git_status_should_ignore(g_repo, "sub/subdir_test2.txt", &ignored)); + cl_assert(!ignored); + + cl_git_pass(git_status_should_ignore(g_repo, "dir", &ignored)); + cl_assert(ignored); + + cl_git_pass(git_status_should_ignore(g_repo, "dir/", &ignored)); + cl_assert(ignored); + + cl_git_pass(git_status_should_ignore(g_repo, "sub/dir", &ignored)); + cl_assert(!ignored); + + cl_git_pass(git_status_should_ignore(g_repo, "sub/dir/", &ignored)); + cl_assert(!ignored); +} + diff --git a/tests-clar/status/status_data.h b/tests-clar/status/status_data.h index 1a68648f4..7f078bf60 100644 --- a/tests-clar/status/status_data.h +++ b/tests-clar/status/status_data.h @@ -1,13 +1,15 @@ struct status_entry_counts { - int wrong_status_flags_count; - int wrong_sorted_path; - int entry_count; + size_t wrong_status_flags_count; + size_t wrong_sorted_path; + size_t entry_count; const unsigned int* expected_statuses; const char** expected_paths; - int expected_entry_count; + size_t expected_entry_count; }; +/* entries for a plain copy of tests/resources/status */ + static const char *entry_paths0[] = { "file_deleted", "ignored_file", @@ -48,3 +50,153 @@ static const unsigned int entry_statuses0[] = { static const size_t entry_count0 = 15; +/* entries for a copy of tests/resources/status with all content + * deleted from the working directory + */ + +static const char *entry_paths2[] = { + "current_file", + "file_deleted", + "modified_file", + "staged_changes", + "staged_changes_file_deleted", + "staged_changes_modified_file", + "staged_delete_file_deleted", + "staged_delete_modified_file", + "staged_new_file", + "staged_new_file_deleted_file", + "staged_new_file_modified_file", + "subdir.txt", + "subdir/current_file", + "subdir/deleted_file", + "subdir/modified_file", +}; + +static const unsigned int entry_statuses2[] = { + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_INDEX_DELETED, + GIT_STATUS_INDEX_DELETED, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, +}; + +static const size_t entry_count2 = 15; + +/* entries for a copy of tests/resources/status with some mods */ + +static const char *entry_paths3[] = { + ".HEADER", + "42-is-not-prime.sigh", + "README.md", + "current_file", + "current_file/", + "file_deleted", + "ignored_file", + "modified_file", + "new_file", + "staged_changes", + "staged_changes_file_deleted", + "staged_changes_modified_file", + "staged_delete_file_deleted", + "staged_delete_modified_file", + "staged_new_file", + "staged_new_file_deleted_file", + "staged_new_file_modified_file", + "subdir", + "subdir/current_file", + "subdir/deleted_file", + "subdir/modified_file", +}; + +static const unsigned int entry_statuses3[] = { + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_DELETED, + GIT_STATUS_IGNORED, + GIT_STATUS_WT_MODIFIED, + GIT_STATUS_WT_NEW, + GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_INDEX_DELETED, + GIT_STATUS_WT_NEW | GIT_STATUS_INDEX_DELETED, + GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, +}; + +static const size_t entry_count3 = 21; + + +/* entries for a copy of tests/resources/status with some mods + * and different options to the status call + */ + +static const char *entry_paths4[] = { + ".new_file", + "current_file", + "current_file/current_file", + "current_file/modified_file", + "current_file/new_file", + "file_deleted", + "modified_file", + "new_file", + "staged_changes", + "staged_changes_file_deleted", + "staged_changes_modified_file", + "staged_delete_file_deleted", + "staged_delete_modified_file", + "staged_new_file", + "staged_new_file_deleted_file", + "staged_new_file_modified_file", + "subdir", + "subdir/current_file", + "subdir/deleted_file", + "subdir/modified_file", + "zzz_new_dir/new_file", + "zzz_new_file" +}; + +static const unsigned int entry_statuses4[] = { + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_MODIFIED, + GIT_STATUS_WT_NEW, + GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED, + GIT_STATUS_INDEX_DELETED, + GIT_STATUS_WT_NEW | GIT_STATUS_INDEX_DELETED, + GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_NEW, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_DELETED, + GIT_STATUS_WT_NEW, + GIT_STATUS_WT_NEW, +}; + +static const size_t entry_count4 = 22; diff --git a/tests-clar/status/submodules.c b/tests-clar/status/submodules.c new file mode 100644 index 000000000..969158825 --- /dev/null +++ b/tests-clar/status/submodules.c @@ -0,0 +1,117 @@ +#include "clar_libgit2.h" +#include "buffer.h" +#include "path.h" +#include "posix.h" + +static git_repository *g_repo = NULL; + +void test_status_submodules__initialize(void) +{ + git_buf modpath = GIT_BUF_INIT; + + g_repo = cl_git_sandbox_init("submodules"); + + cl_fixture_sandbox("testrepo.git"); + + cl_git_pass(git_buf_sets(&modpath, git_repository_workdir(g_repo))); + cl_assert(git_path_dirname_r(&modpath, modpath.ptr) >= 0); + cl_git_pass(git_buf_joinpath(&modpath, modpath.ptr, "testrepo.git\n")); + + p_rename("submodules/gitmodules", "submodules/.gitmodules"); + cl_git_append2file("submodules/.gitmodules", modpath.ptr); + git_buf_free(&modpath); + + p_rename("submodules/testrepo/.gitted", "submodules/testrepo/.git"); +} + +void test_status_submodules__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +void test_status_submodules__api(void) +{ + git_submodule *sm; + + cl_assert(git_submodule_lookup(NULL, g_repo, "nonexistent") == GIT_ENOTFOUND); + + cl_assert(git_submodule_lookup(NULL, g_repo, "modified") == GIT_ENOTFOUND); + + cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo")); + cl_assert(sm != NULL); + cl_assert_equal_s("testrepo", sm->name); + cl_assert_equal_s("testrepo", sm->path); +} + +static int +cb_status__submodule_count(const char *p, unsigned int s, void *payload) +{ + volatile int *count = (int *)payload; + + GIT_UNUSED(p); + GIT_UNUSED(s); + + (*count)++; + + return 0; +} + +void test_status_submodules__0(void) +{ + int counts = 0; + + cl_assert(git_path_isdir("submodules/.git")); + cl_assert(git_path_isdir("submodules/testrepo/.git")); + cl_assert(git_path_isfile("submodules/.gitmodules")); + + cl_git_pass( + git_status_foreach(g_repo, cb_status__submodule_count, &counts) + ); + + cl_assert(counts == 6); +} + +static const char *expected_files[] = { + ".gitmodules", + "added", + "deleted", + "ignored", + "modified", + "untracked" +}; + +static unsigned int expected_status[] = { + GIT_STATUS_WT_MODIFIED, + GIT_STATUS_INDEX_NEW, + GIT_STATUS_INDEX_DELETED, + GIT_STATUS_IGNORED, + GIT_STATUS_WT_MODIFIED, + GIT_STATUS_WT_NEW +}; + +static int +cb_status__match(const char *p, unsigned int s, void *payload) +{ + volatile int *index = (int *)payload; + + cl_assert_equal_s(expected_files[*index], p); + cl_assert(expected_status[*index] == s); + (*index)++; + + return 0; +} + +void test_status_submodules__1(void) +{ + int index = 0; + + cl_assert(git_path_isdir("submodules/.git")); + cl_assert(git_path_isdir("submodules/testrepo/.git")); + cl_assert(git_path_isfile("submodules/.gitmodules")); + + cl_git_pass( + git_status_foreach(g_repo, cb_status__match, &index) + ); + + cl_assert(index == 6); +} diff --git a/tests-clar/status/worktree.c b/tests-clar/status/worktree.c index 132ec1fc1..8f48cf16a 100644 --- a/tests-clar/status/worktree.c +++ b/tests-clar/status/worktree.c @@ -2,7 +2,9 @@ #include "fileops.h" #include "ignore.h" #include "status_data.h" - +#include "posix.h" +#include "util.h" +#include "path.h" /** * Auxiliary methods @@ -27,7 +29,7 @@ cb_status__normal( const char *path, unsigned int status_flags, void *payload) exit: counts->entry_count++; - return GIT_SUCCESS; + return 0; } static int @@ -40,10 +42,9 @@ cb_status__count(const char *p, unsigned int s, void *payload) (*count)++; - return GIT_SUCCESS; + return 0; } - /** * Initializer * @@ -68,6 +69,7 @@ void test_status_worktree__cleanup(void) /** * Tests - Status determination on a working tree */ +/* this test is equivalent to t18-status.c:statuscb0 */ void test_status_worktree__whole_repository(void) { struct status_entry_counts counts; @@ -87,6 +89,7 @@ void test_status_worktree__whole_repository(void) cl_assert(counts.wrong_sorted_path == 0); } +/* this test is equivalent to t18-status.c:statuscb1 */ void test_status_worktree__empty_repository(void) { int count = 0; @@ -97,6 +100,122 @@ void test_status_worktree__empty_repository(void) cl_assert(count == 0); } +static int remove_file_cb(void *data, git_buf *file) +{ + const char *filename = git_buf_cstr(file); + + GIT_UNUSED(data); + + if (git__suffixcmp(filename, ".git") == 0) + return 0; + + if (git_path_isdir(filename)) + cl_git_pass(git_futils_rmdir_r(filename, GIT_DIRREMOVAL_FILES_AND_DIRS)); + else + cl_git_pass(p_unlink(git_buf_cstr(file))); + + return 0; +} + +/* this test is equivalent to t18-status.c:statuscb2 */ +void test_status_worktree__purged_worktree(void) +{ + struct status_entry_counts counts; + git_repository *repo = cl_git_sandbox_init("status"); + git_buf workdir = GIT_BUF_INIT; + + /* first purge the contents of the worktree */ + cl_git_pass(git_buf_sets(&workdir, git_repository_workdir(repo))); + cl_git_pass(git_path_direach(&workdir, remove_file_cb, NULL)); + git_buf_free(&workdir); + + /* now get status */ + memset(&counts, 0x0, sizeof(struct status_entry_counts)); + counts.expected_entry_count = entry_count2; + counts.expected_paths = entry_paths2; + counts.expected_statuses = entry_statuses2; + + cl_git_pass( + git_status_foreach(repo, cb_status__normal, &counts) + ); + + cl_assert(counts.entry_count == counts.expected_entry_count); + cl_assert(counts.wrong_status_flags_count == 0); + cl_assert(counts.wrong_sorted_path == 0); +} + +/* this test is similar to t18-status.c:statuscb3 */ +void test_status_worktree__swap_subdir_and_file(void) +{ + struct status_entry_counts counts; + git_repository *repo = cl_git_sandbox_init("status"); + git_status_options opts; + + /* first alter the contents of the worktree */ + cl_git_pass(p_rename("status/current_file", "status/swap")); + cl_git_pass(p_rename("status/subdir", "status/current_file")); + cl_git_pass(p_rename("status/swap", "status/subdir")); + + cl_git_mkfile("status/.HEADER", "dummy"); + cl_git_mkfile("status/42-is-not-prime.sigh", "dummy"); + cl_git_mkfile("status/README.md", "dummy"); + + /* now get status */ + memset(&counts, 0x0, sizeof(struct status_entry_counts)); + counts.expected_entry_count = entry_count3; + counts.expected_paths = entry_paths3; + counts.expected_statuses = entry_statuses3; + + memset(&opts, 0, sizeof(opts)); + opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | + GIT_STATUS_OPT_INCLUDE_IGNORED; + + cl_git_pass( + git_status_foreach_ext(repo, &opts, cb_status__normal, &counts) + ); + + cl_assert(counts.entry_count == counts.expected_entry_count); + cl_assert(counts.wrong_status_flags_count == 0); + cl_assert(counts.wrong_sorted_path == 0); + +} + +void test_status_worktree__swap_subdir_with_recurse_and_pathspec(void) +{ + struct status_entry_counts counts; + git_repository *repo = cl_git_sandbox_init("status"); + git_status_options opts; + + /* first alter the contents of the worktree */ + cl_git_pass(p_rename("status/current_file", "status/swap")); + cl_git_pass(p_rename("status/subdir", "status/current_file")); + cl_git_pass(p_rename("status/swap", "status/subdir")); + cl_git_mkfile("status/.new_file", "dummy"); + cl_git_pass(git_futils_mkdir_r("status/zzz_new_dir", NULL, 0777)); + cl_git_mkfile("status/zzz_new_dir/new_file", "dummy"); + cl_git_mkfile("status/zzz_new_file", "dummy"); + + /* now get status */ + memset(&counts, 0x0, sizeof(struct status_entry_counts)); + counts.expected_entry_count = entry_count4; + counts.expected_paths = entry_paths4; + counts.expected_statuses = entry_statuses4; + + memset(&opts, 0, sizeof(opts)); + opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | + GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS; + /* TODO: set pathspec to "current_file" eventually */ + + cl_git_pass( + git_status_foreach_ext(repo, &opts, cb_status__normal, &counts) + ); + + cl_assert(counts.entry_count == counts.expected_entry_count); + cl_assert(counts.wrong_status_flags_count == 0); + cl_assert(counts.wrong_sorted_path == 0); +} + +/* this test is equivalent to t18-status.c:singlestatus0 */ void test_status_worktree__single_file(void) { int i; @@ -111,6 +230,54 @@ void test_status_worktree__single_file(void) } } +/* this test is equivalent to t18-status.c:singlestatus1 */ +void test_status_worktree__single_nonexistent_file(void) +{ + int error; + unsigned int status_flags; + git_repository *repo = cl_git_sandbox_init("status"); + + error = git_status_file(&status_flags, repo, "nonexistent"); + cl_git_fail(error); + cl_assert(error == GIT_ENOTFOUND); +} + +/* this test is equivalent to t18-status.c:singlestatus2 */ +void test_status_worktree__single_nonexistent_file_empty_repo(void) +{ + int error; + unsigned int status_flags; + git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); + + error = git_status_file(&status_flags, repo, "nonexistent"); + cl_git_fail(error); + cl_assert(error == GIT_ENOTFOUND); +} + +/* this test is equivalent to t18-status.c:singlestatus3 */ +void test_status_worktree__single_file_empty_repo(void) +{ + unsigned int status_flags; + git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); + + cl_git_mkfile("empty_standard_repo/new_file", "new_file\n"); + + cl_git_pass(git_status_file(&status_flags, repo, "new_file")); + cl_assert(status_flags == GIT_STATUS_WT_NEW); +} + +/* this test is equivalent to t18-status.c:singlestatus4 */ +void test_status_worktree__single_folder(void) +{ + int error; + unsigned int status_flags; + git_repository *repo = cl_git_sandbox_init("status"); + + error = git_status_file(&status_flags, repo, "subdir"); + cl_git_fail(error); +} + + void test_status_worktree__ignores(void) { int i, ignored; @@ -133,3 +300,87 @@ void test_status_worktree__ignores(void) ); cl_assert(ignored); } + +static int cb_status__check_592(const char *p, unsigned int s, void *payload) +{ + GIT_UNUSED(payload); + + if (s != GIT_STATUS_WT_DELETED || (payload != NULL && strcmp(p, (const char *)payload) != 0)) + return -1; + + return 0; +} + +void test_status_worktree__issue_592(void) +{ + git_repository *repo; + git_buf path = GIT_BUF_INIT; + + repo = cl_git_sandbox_init("issue_592"); + cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "l.txt")); + cl_git_pass(p_unlink(git_buf_cstr(&path))); + + cl_git_pass(git_status_foreach(repo, cb_status__check_592, "l.txt")); + + git_buf_free(&path); +} + +void test_status_worktree__issue_592_2(void) +{ + git_repository *repo; + git_buf path = GIT_BUF_INIT; + + repo = cl_git_sandbox_init("issue_592"); + cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "c/a.txt")); + cl_git_pass(p_unlink(git_buf_cstr(&path))); + + cl_git_pass(git_status_foreach(repo, cb_status__check_592, "c/a.txt")); + + git_buf_free(&path); +} + +void test_status_worktree__issue_592_3(void) +{ + git_repository *repo; + git_buf path = GIT_BUF_INIT; + + repo = cl_git_sandbox_init("issue_592"); + + cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "c")); + cl_git_pass(git_futils_rmdir_r(git_buf_cstr(&path), GIT_DIRREMOVAL_FILES_AND_DIRS)); + + cl_git_pass(git_status_foreach(repo, cb_status__check_592, "c/a.txt")); + + git_buf_free(&path); +} + +void test_status_worktree__issue_592_4(void) +{ + git_repository *repo; + git_buf path = GIT_BUF_INIT; + + repo = cl_git_sandbox_init("issue_592"); + + cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "t/b.txt")); + cl_git_pass(p_unlink(git_buf_cstr(&path))); + + cl_git_pass(git_status_foreach(repo, cb_status__check_592, "t/b.txt")); + + git_buf_free(&path); +} + +void test_status_worktree__issue_592_5(void) +{ + git_repository *repo; + git_buf path = GIT_BUF_INIT; + + repo = cl_git_sandbox_init("issue_592"); + + cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "t")); + cl_git_pass(git_futils_rmdir_r(git_buf_cstr(&path), GIT_DIRREMOVAL_FILES_AND_DIRS)); + cl_git_pass(p_mkdir(git_buf_cstr(&path), 0777)); + + cl_git_pass(git_status_foreach(repo, cb_status__check_592, NULL)); + + git_buf_free(&path); +} diff --git a/tests/resources/testrepo/.gitted/config b/tests/resources/testrepo/.gitted/config deleted file mode 100644 index 1a5aacdfa..000000000 Binary files a/tests/resources/testrepo/.gitted/config and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/head-tracker b/tests/resources/testrepo/.gitted/head-tracker deleted file mode 100644 index 40d876b4c..000000000 Binary files a/tests/resources/testrepo/.gitted/head-tracker and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/index b/tests/resources/testrepo/.gitted/index deleted file mode 100644 index a27fb9c96..000000000 Binary files a/tests/resources/testrepo/.gitted/index and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/packed-refs b/tests/resources/testrepo/.gitted/packed-refs deleted file mode 100644 index 52f5e876f..000000000 Binary files a/tests/resources/testrepo/.gitted/packed-refs and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/refs/heads/br2 b/tests/resources/testrepo/.gitted/refs/heads/br2 deleted file mode 100644 index aab87e5e7..000000000 Binary files a/tests/resources/testrepo/.gitted/refs/heads/br2 and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/refs/heads/packed-test b/tests/resources/testrepo/.gitted/refs/heads/packed-test deleted file mode 100644 index f2c14ad83..000000000 Binary files a/tests/resources/testrepo/.gitted/refs/heads/packed-test and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/refs/heads/subtrees b/tests/resources/testrepo/.gitted/refs/heads/subtrees deleted file mode 100644 index ad27e0b13..000000000 Binary files a/tests/resources/testrepo/.gitted/refs/heads/subtrees and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/refs/heads/test b/tests/resources/testrepo/.gitted/refs/heads/test deleted file mode 100644 index 399c4c73e..000000000 Binary files a/tests/resources/testrepo/.gitted/refs/heads/test and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/refs/tags/e90810b b/tests/resources/testrepo/.gitted/refs/tags/e90810b deleted file mode 100644 index 584495d3c..000000000 Binary files a/tests/resources/testrepo/.gitted/refs/tags/e90810b and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/refs/tags/point_to_blob b/tests/resources/testrepo/.gitted/refs/tags/point_to_blob deleted file mode 100644 index f874a3ffc..000000000 Binary files a/tests/resources/testrepo/.gitted/refs/tags/point_to_blob and /dev/null differ diff --git a/tests/resources/testrepo/.gitted/refs/tags/test b/tests/resources/testrepo/.gitted/refs/tags/test deleted file mode 100644 index 6ee952a03..000000000 Binary files a/tests/resources/testrepo/.gitted/refs/tags/test and /dev/null differ