static void *cache_raw(void *arg) { int i; git_oid oid; git_odb *odb; git_odb_object *odb_obj; cl_git_pass(git_repository_odb(&odb, g_repo)); for (i = ((int *)arg)[1]; g_data[i].sha != NULL; i += 2) { cl_git_pass(git_oid_fromstr(&oid, g_data[i].sha)); cl_git_pass(git_odb_read(&odb_obj, odb, &oid)); cl_assert(g_data[i].type == git_odb_object_type(odb_obj)); git_odb_object_free(odb_obj); } for (i = 0; i < ((int *)arg)[1]; i += 2) { cl_git_pass(git_oid_fromstr(&oid, g_data[i].sha)); cl_git_pass(git_odb_read(&odb_obj, odb, &oid)); cl_assert(g_data[i].type == git_odb_object_type(odb_obj)); git_odb_object_free(odb_obj); } git_odb_free(odb); return arg; }
static VALUE backend_read_blob(VALUE rb_obj, VALUE rb_oid) { git_oid oid; git_odb *odb; git_odb_object *g_obj; git_otype type; int error, size; char *data; VALUE rb_content; odb = DATA_PTR(rb_obj); error = git_oid_fromstr(&oid, RSTRING_PTR(rb_oid)); backend_exception_check(error); error = git_odb_read(&g_obj, odb, &oid); backend_exception_check(error); data = (char *)git_odb_object_data(g_obj); size = git_odb_object_size(g_obj); type = git_odb_object_type(g_obj); if (type != GIT_OBJ_BLOB) { git_odb_object_free(g_obj); rb_raise(rb_eArgError, "oid does not belong to a blob"); } rb_content = backend_str_new(data, size, NULL); git_odb_object_free(g_obj); return rb_content; }
int git_odb_read_header(git_rawobj *out, git_odb *db, const git_oid *id) { unsigned int i; int error = GIT_ENOTFOUND; assert(out && db && id); for (i = 0; i < db->backends.length && error < 0; ++i) { backend_internal *internal = git_vector_get(&db->backends, i); git_odb_backend *b = internal->backend; if (b->read_header != NULL) error = b->read_header(out, b, id); } /* * no backend could read only the header. * try reading the whole object and freeing the contents */ if (error < 0) { error = git_odb_read(out, db, id); git_rawobj_close(out); } return error; }
int git_merge_file_input_from_diff_file( git_merge_file_input *input, git_repository *repo, const git_diff_file *file) { git_odb *odb = NULL; int error = 0; assert(input && repo && file); if (file->mode == 0) return 0; if ((error = git_repository_odb(&odb, repo)) < 0 || (error = git_odb_read(&input->odb_object, odb, &file->oid)) < 0) goto done; input->mode = file->mode; input->path = git__strdup(file->path); input->mmfile.size = git_odb_object_size(input->odb_object); input->mmfile.ptr = (char *)git_odb_object_data(input->odb_object); if (input->label == NULL) input->label = file->path; done: git_odb_free(odb); return error; }
void test_odb_backend_simple__read_with_hash_mismatch_fails(void) { const fake_object objs[] = { { "1234567890123456789012345678901234567890", "nonmatching content" }, { NULL, NULL } }; setup_backend(objs); cl_git_pass(git_oid_fromstr(&_oid, objs[0].oid)); cl_git_fail_with(GIT_EMISMATCH, git_odb_read(&_obj, _odb, &_oid)); }
void test_odb_backend_simple__read_of_nonexisting_object_fails(void) { const fake_object objs[] = { { "f6ea0495187600e7b2288c8ac19c5886383a4632", "foobar" }, { NULL, NULL } }; setup_backend(objs); cl_git_pass(git_oid_fromstr(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633")); cl_git_fail_with(GIT_ENOTFOUND, git_odb_read(&_obj, _odb, &_oid)); }
void test_odb_backend_simple__read_prefix_succeeds(void) { const fake_object objs[] = { { "f6ea0495187600e7b2288c8ac19c5886383a4632", "foobar" }, { NULL, NULL } }; setup_backend(objs); cl_git_pass(git_oid_fromstr(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4632")); cl_git_pass(git_odb_read(&_obj, _odb, &_oid)); assert_object_contains(_obj, objs[0].content); }
void test_object_cache__cache_everything(void) { int i, start; git_oid oid; git_odb_object *odb_obj; git_object *obj; git_odb *odb; git_libgit2_opts( GIT_OPT_SET_CACHE_OBJECT_LIMIT, (int)GIT_OBJ_BLOB, (size_t)32767); cl_git_pass(git_repository_open(&g_repo, cl_fixture("testrepo.git"))); cl_git_pass(git_repository_odb(&odb, g_repo)); start = (int)git_cache_size(&g_repo->objects); for (i = 0; g_data[i].sha != NULL; ++i) { int count = (int)git_cache_size(&g_repo->objects); cl_git_pass(git_oid_fromstr(&oid, g_data[i].sha)); /* alternate between loading raw and parsed objects */ if ((i & 1) == 0) { cl_git_pass(git_odb_read(&odb_obj, odb, &oid)); cl_assert(g_data[i].type == git_odb_object_type(odb_obj)); git_odb_object_free(odb_obj); } else { cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY)); cl_assert(g_data[i].type == git_object_type(obj)); git_object_free(obj); } cl_assert_equal_i(count + 1, (int)git_cache_size(&g_repo->objects)); } cl_assert_equal_i(i, (int)git_cache_size(&g_repo->objects) - start); git_odb_free(odb); for (i = 0; g_data[i].sha != NULL; ++i) { int count = (int)git_cache_size(&g_repo->objects); cl_git_pass(git_oid_fromstr(&oid, g_data[i].sha)); cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY)); cl_assert(g_data[i].type == git_object_type(obj)); git_object_free(obj); cl_assert_equal_i(count, (int)git_cache_size(&g_repo->objects)); } }
void test_odb_backend_simple__read_with_hash_mismatch_succeeds_without_verification(void) { const fake_object objs[] = { { "1234567890123456789012345678901234567890", "nonmatching content" }, { NULL, NULL } }; setup_backend(objs); cl_git_pass(git_oid_fromstr(&_oid, objs[0].oid)); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0)); cl_git_pass(git_odb_read(&_obj, _odb, &_oid)); assert_object_contains(_obj, objs[0].content); }
void test_odb_packed__mass_read(void) { unsigned int i; for (i = 0; i < ARRAY_SIZE(packed_objects); ++i) { git_oid id; git_odb_object *obj; cl_git_pass(git_oid_fromstr(&id, packed_objects[i])); cl_assert(git_odb_exists(_odb, &id) == 1); cl_git_pass(git_odb_read(&obj, _odb, &id)); git_odb_object_free(obj); } }
int git_object__source_open(git_object *object) { int error; assert(object && !object->in_memory); if (object->source.open) git_object__source_close(object); error = git_odb_read(&object->source.raw, object->repo->db, &object->id); if (error < GIT_SUCCESS) return error; object->source.open = 1; return GIT_SUCCESS; }
void test_odb_backend_simple__null_oid_is_ignored(void) { const fake_object objs[] = { { "0000000000000000000000000000000000000000", "null oid content" }, { NULL, NULL } }; git_oid null_oid = {{0}}; git_odb_object *obj; setup_backend(objs); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0)); cl_assert(!git_odb_exists(_odb, &null_oid)); cl_git_fail_with(GIT_ENOTFOUND, git_odb_read(&obj, _odb, &null_oid)); cl_assert(giterr_last() && strstr(giterr_last()->message, "null OID")); }
static void test_read_object(object_data *data) { git_oid id; git_odb_object *obj; git_odb *odb; write_object_files(data); cl_git_pass(git_odb_open(&odb, "test-objects")); cl_git_pass(git_oid_fromstr(&id, data->id)); cl_git_pass(git_odb_read(&obj, odb, &id)); cmp_objects((git_rawobj *)&obj->raw, data); git_odb_object_free(obj); git_odb_free(odb); }
int git_odb__read_header_or_object( git_odb_object **out, size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id) { size_t i; int error = GIT_ENOTFOUND; git_odb_object *object; assert(db && id && out && len_p && type_p); if ((object = git_cache_get_raw(odb_cache(db), id)) != NULL) { *len_p = object->cached.size; *type_p = object->cached.type; *out = object; return 0; } *out = NULL; for (i = 0; i < db->backends.length && error < 0; ++i) { backend_internal *internal = (backend_internal *) git_vector_get(&db->backends, i); git_odb_backend *b = internal->backend; if (b->read_header != NULL) error = b->read_header(len_p, type_p, b, id); } if (!error || error == GIT_PASSTHROUGH) return 0; /* * no backend could read only the header. * try reading the whole object and freeing the contents */ if ((error = git_odb_read(&object, db, id)) < 0) return error; /* error already set - pass along */ *len_p = object->cached.size; *type_p = object->cached.type; *out = object; return 0; }
void test_odb_largefiles__read_into_memory_rejected_on_32bit(void) { git_oid oid; git_odb_object *obj = NULL; #ifdef GIT_ARCH_64 cl_skip(); #endif if (!cl_is_env_set("GITTEST_INVASIVE_FS_SIZE") || !cl_is_env_set("GITTEST_INVASIVE_MEMORY") || !cl_is_env_set("GITTEST_SLOW")) cl_skip(); writefile(&oid); cl_git_fail(git_odb_read(&obj, odb, &oid)); git_odb_object_free(obj); }
static ERL_NIF_TERM geef_object_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { char path[MAXBUFLEN]; char sha[MAXBUFLEN]; (void)memset(&path, '\0', sizeof(path)); (void)memset(&sha, '\0', sizeof(sha)); if (enif_get_string(env, argv[0], path, sizeof(path), ERL_NIF_LATIN1) < 1) return enif_make_badarg(env); if (enif_get_string(env, argv[1], sha, sizeof(sha), ERL_NIF_LATIN1) < 1) return enif_make_badarg(env); git_odb *odb; git_odb_open(&odb, path); git_oid oid; git_oid_fromstr(&oid, sha); int error; git_odb_object *obj; error = git_odb_read(&obj, odb, &oid); if (error) { git_odb_free(odb); return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "object does not exist", ERL_NIF_LATIN1)); } size_t len; len = git_odb_object_size(obj); ErlNifBinary ibin; enif_alloc_binary(len, &ibin); memcpy(ibin.data, git_odb_object_data(obj), len); git_odb_free(odb); return enif_make_binary(env, &ibin); }
static int commit_parse(git_revwalk *walk, commit_object *commit) { git_odb_object *obj; int error; if (commit->parsed) return GIT_SUCCESS; if ((error = git_odb_read(&obj, walk->repo->db, &commit->oid)) < GIT_SUCCESS) return error; if (obj->raw.type != GIT_OBJ_COMMIT) { git_odb_object_close(obj); return GIT_EOBJTYPE; } error = commit_quick_parse(walk, commit, &obj->raw); git_odb_object_close(obj); return error; }
int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit) { git_odb_object *obj; int error; if (commit->parsed) return 0; if ((error = git_odb_read(&obj, walk->odb, &commit->oid)) < 0) return error; if (obj->raw.type != GIT_OBJ_COMMIT) { giterr_set(GITERR_INVALID, "Object is no commit object"); error = -1; } else error = commit_quick_parse(walk, commit, &obj->raw); git_odb_object_free(obj); return error; }
static gboolean checksum_object_id (struct TreeWalkData *twdata, const git_oid *oid, GError **error) { gboolean ret = FALSE; int r; git_odb_object *odbobj = NULL; r = git_odb_read (&odbobj, twdata->odb, oid); if (!handle_libgit_ret (r, error)) goto out; checksum_odb_object (twdata->evtag, odbobj); ret = TRUE; out: if (odbobj) git_odb_object_free (odbobj); return ret; }
void test_odb_packed__read_header_0(void) { unsigned int i; for (i = 0; i < ARRAY_SIZE(packed_objects); ++i) { git_oid id; git_odb_object *obj; size_t len; git_object_t type; cl_git_pass(git_oid_fromstr(&id, packed_objects[i])); cl_git_pass(git_odb_read(&obj, _odb, &id)); cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); cl_assert(obj->cached.size == len); cl_assert(obj->cached.type == type); git_odb_object_free(obj); } }
static void test_read_object(object_data *data) { git_oid id; git_odb_object *obj; git_odb *odb; git_rawobj tmp; write_object_files(data); cl_git_pass(git_odb_open(&odb, "test-objects")); cl_git_pass(git_oid_fromstr(&id, data->id)); cl_git_pass(git_odb_read(&obj, odb, &id)); tmp.data = obj->buffer; tmp.len = obj->cached.size; tmp.type = obj->cached.type; cmp_objects(&tmp, data); git_odb_object_free(obj); git_odb_free(odb); }
int git_commit_parse_existing(git_commit *commit) { int error = 0; git_obj commit_obj; if (commit->parsed) return 0; error = git_odb_read(&commit_obj, commit->object.pool->db, &commit->object.id); if (error < 0) return error; if (commit_obj.type != GIT_OBJ_COMMIT) { error = GIT_EOBJTYPE; goto cleanup; } error = git_commit__parse_buffer(commit, commit_obj.data, commit_obj.len); cleanup: git_obj_close(&commit_obj); return error; }
int each_object(const git_oid *id, void *payload){ struct pl *p=payload; git_odb_object *out; check_error(git_odb_read(&out,p->odb,id),"odb_read"); struct object *oo=(struct object *)malloc(sizeof(struct object)); oo->size=git_odb_object_size(out); git_oid_tostr(oo->strid,GIT_OID_HEXSZ+1,id); /* if(osize>1024*1024) { osize /= 1024 *1024; uom='M'; } else if (osize > 10*1024){ osize /= 1024; uom='K'; }*/ oo->otype=git_odb_object_type(out); git_odb_object_free(out); ary_add(p->ary,(void*)oo); //printf("%05d: %s %5ld%c %s\n",p->count++,strid,osize,uom,git_object_type2string(otype)); return 0; }
void test_odb_packed__read_header_1(void) { unsigned int i; for (i = 0; i < ARRAY_SIZE(loose_objects); ++i) { git_oid id; git_odb_object *obj; size_t len; git_otype type; cl_git_pass(git_oid_fromstr(&id, loose_objects[i])); cl_assert(git_odb_exists(_odb, &id) == 1); cl_git_pass(git_odb_read(&obj, _odb, &id)); cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); cl_assert(obj->raw.len == len); cl_assert(obj->raw.type == type); git_odb_object_free(obj); } }
int git_object_lookup_prefix( git_object **object_out, git_repository *repo, const git_oid *id, size_t len, git_otype type) { git_object *object = NULL; git_odb *odb = NULL; git_odb_object *odb_obj = NULL; int error = 0; assert(repo && object_out && id); if (len < GIT_OID_MINPREFIXLEN) { giterr_set(GITERR_OBJECT, "Ambiguous lookup - OID prefix is too short"); return GIT_EAMBIGUOUS; } error = git_repository_odb__weakptr(&odb, repo); if (error < 0) return error; if (len > GIT_OID_HEXSZ) len = GIT_OID_HEXSZ; if (len == GIT_OID_HEXSZ) { git_cached_obj *cached = NULL; /* We want to match the full id : we can first look up in the cache, * since there is no need to check for non ambiguousity */ cached = git_cache_get_any(&repo->objects, id); if (cached != NULL) { if (cached->flags == GIT_CACHE_STORE_PARSED) { object = (git_object *)cached; if (type != GIT_OBJ_ANY && type != object->cached.type) { git_object_free(object); giterr_set(GITERR_INVALID, "The requested type does not match the type in ODB"); return GIT_ENOTFOUND; } *object_out = object; return 0; } else if (cached->flags == GIT_CACHE_STORE_RAW) { odb_obj = (git_odb_object *)cached; } else { assert(!"Wrong caching type in the global object cache"); } } else { /* Object was not found in the cache, let's explore the backends. * We could just use git_odb_read_unique_short_oid, * it is the same cost for packed and loose object backends, * but it may be much more costly for sqlite and hiredis. */ error = git_odb_read(&odb_obj, odb, id); } } else { git_oid short_oid; /* We copy the first len*4 bits from id and fill the remaining with 0s */ memcpy(short_oid.id, id->id, (len + 1) / 2); if (len % 2) short_oid.id[len / 2] &= 0xF0; memset(short_oid.id + (len + 1) / 2, 0, (GIT_OID_HEXSZ - len) / 2); /* If len < GIT_OID_HEXSZ (a strict short oid was given), we have * 2 options : * - We always search in the cache first. If we find that short oid is * ambiguous, we can stop. But in all the other cases, we must then * explore all the backends (to find an object if there was match, * or to check that oid is not ambiguous if we have found 1 match in * the cache) * - We never explore the cache, go right to exploring the backends * We chose the latter : we explore directly the backends. */ error = git_odb_read_prefix(&odb_obj, odb, &short_oid, len); } if (error < 0) return error; error = git_object__from_odb_object(object_out, repo, odb_obj, type); git_odb_object_free(odb_obj); return error; }
int git_commit_extract_signature(git_buf *signature, git_buf *signed_data, git_repository *repo, git_oid *commit_id, const char *field) { git_odb_object *obj; git_odb *odb; const char *buf; const char *h, *eol; int error; git_buf_clear(signature); git_buf_clear(signed_data); if (!field) field = "gpgsig"; if ((error = git_repository_odb__weakptr(&odb, repo)) < 0) return error; if ((error = git_odb_read(&obj, odb, commit_id)) < 0) return error; if (obj->cached.type != GIT_OBJECT_COMMIT) { giterr_set(GITERR_INVALID, "the requested type does not match the type in ODB"); error = GIT_ENOTFOUND; goto cleanup; } buf = git_odb_object_data(obj); while ((h = strchr(buf, '\n')) && h[1] != '\0') { h++; if (git__prefixcmp(buf, field)) { if (git_buf_put(signed_data, buf, h - buf) < 0) return -1; buf = h; continue; } h = buf; h += strlen(field); eol = strchr(h, '\n'); if (h[0] != ' ') { buf = h; continue; } if (!eol) goto malformed; h++; /* skip the SP */ git_buf_put(signature, h, eol - h); if (git_buf_oom(signature)) goto oom; /* If the next line starts with SP, it's multi-line, we must continue */ while (eol[1] == ' ') { git_buf_putc(signature, '\n'); h = eol + 2; eol = strchr(h, '\n'); if (!eol) goto malformed; git_buf_put(signature, h, eol - h); } if (git_buf_oom(signature)) goto oom; error = git_buf_puts(signed_data, eol+1); git_odb_object_free(obj); return error; } giterr_set(GITERR_OBJECT, "this commit is not signed"); error = GIT_ENOTFOUND; goto cleanup; malformed: giterr_set(GITERR_OBJECT, "malformed header"); error = -1; goto cleanup; oom: giterr_set_oom(); error = -1; goto cleanup; cleanup: git_odb_object_free(obj); git_buf_clear(signature); git_buf_clear(signed_data); return error; }
int main (int argc, char** argv) { // ### Opening the Repository // There are a couple of methods for opening a repository, this being the simplest. // There are also [methods][me] for specifying the index file and work tree locations, here // we are assuming they are in the normal places. // // [me]: http://libgit2.github.com/libgit2/#HEAD/group/repository git_repository *repo; if (argc > 1) { git_repository_open(&repo, argv[1]); } else { git_repository_open(&repo, "/opt/libgit2-test/.git"); } // ### SHA-1 Value Conversions // For our first example, we will convert a 40 character hex value to the 20 byte raw SHA1 value. printf("*Hex to Raw*\n"); char hex[] = "fd6e612585290339ea8bf39c692a7ff6a29cb7c3"; // The `git_oid` is the structure that keeps the SHA value. We will use this throughout the example // for storing the value of the current SHA key we're working with. git_oid oid; git_oid_fromstr(&oid, hex); // Once we've converted the string into the oid value, we can get the raw value of the SHA. printf("Raw 20 bytes: [%.20s]\n", (&oid)->id); // Next we will convert the 20 byte raw SHA1 value to a human readable 40 char hex value. printf("\n*Raw to Hex*\n"); char out[41]; out[40] = '\0'; // If you have a oid, you can easily get the hex value of the SHA as well. git_oid_fmt(out, &oid); printf("SHA hex string: %s\n", out); // ### Working with the Object Database // **libgit2** provides [direct access][odb] to the object database. // The object database is where the actual objects are stored in Git. For // working with raw objects, we'll need to get this structure from the // repository. // [odb]: http://libgit2.github.com/libgit2/#HEAD/group/odb git_odb *odb; git_repository_odb(&odb, repo); // #### Raw Object Reading printf("\n*Raw Object Read*\n"); git_odb_object *obj; git_otype otype; const unsigned char *data; const char *str_type; int error; // We can read raw objects directly from the object database if we have the oid (SHA) // of the object. This allows us to access objects without knowing thier type and inspect // the raw bytes unparsed. error = git_odb_read(&obj, odb, &oid); // A raw object only has three properties - the type (commit, blob, tree or tag), the size // of the raw data and the raw, unparsed data itself. For a commit or tag, that raw data // is human readable plain ASCII text. For a blob it is just file contents, so it could be // text or binary data. For a tree it is a special binary format, so it's unlikely to be // hugely helpful as a raw object. data = (const unsigned char *)git_odb_object_data(obj); otype = git_odb_object_type(obj); // We provide methods to convert from the object type which is an enum, to a string // representation of that value (and vice-versa). str_type = git_object_type2string(otype); printf("object length and type: %d, %s\n", (int)git_odb_object_size(obj), str_type); // For proper memory management, close the object when you are done with it or it will leak // memory. git_odb_object_free(obj); // #### Raw Object Writing printf("\n*Raw Object Write*\n"); // You can also write raw object data to Git. This is pretty cool because it gives you // direct access to the key/value properties of Git. Here we'll write a new blob object // that just contains a simple string. Notice that we have to specify the object type as // the `git_otype` enum. git_odb_write(&oid, odb, "test data", sizeof("test data") - 1, GIT_OBJ_BLOB); // Now that we've written the object, we can check out what SHA1 was generated when the // object was written to our database. git_oid_fmt(out, &oid); printf("Written Object: %s\n", out); // ### Object Parsing // libgit2 has methods to parse every object type in Git so you don't have to work directly // with the raw data. This is much faster and simpler than trying to deal with the raw data // yourself. // #### Commit Parsing // [Parsing commit objects][pco] is simple and gives you access to all the data in the commit // - the // author (name, email, datetime), committer (same), tree, message, encoding and parent(s). // [pco]: http://libgit2.github.com/libgit2/#HEAD/group/commit printf("\n*Commit Parsing*\n"); git_commit *commit; git_oid_fromstr(&oid, "f0877d0b841d75172ec404fc9370173dfffc20d1"); error = git_commit_lookup(&commit, repo, &oid); const git_signature *author, *cmtter; const char *message; time_t ctime; unsigned int parents, p; // Each of the properties of the commit object are accessible via methods, including commonly // needed variations, such as `git_commit_time` which returns the author time and `_message` // which gives you the commit message. message = git_commit_message(commit); author = git_commit_author(commit); cmtter = git_commit_committer(commit); ctime = git_commit_time(commit); // The author and committer methods return [git_signature] structures, which give you name, email // and `when`, which is a `git_time` structure, giving you a timestamp and timezone offset. printf("Author: %s (%s)\n", author->name, author->email); // Commits can have zero or more parents. The first (root) commit will have no parents, most commits // will have one, which is the commit it was based on, and merge commits will have two or more. // Commits can technically have any number, though it's pretty rare to have more than two. parents = git_commit_parentcount(commit); for (p = 0;p < parents;p++) { git_commit *parent; git_commit_parent(&parent, commit, p); git_oid_fmt(out, git_commit_id(parent)); printf("Parent: %s\n", out); git_commit_free(parent); } // Don't forget to close the object to prevent memory leaks. You will have to do this for // all the objects you open and parse. git_commit_free(commit); // #### Writing Commits // // libgit2 provides a couple of methods to create commit objects easily as well. There are four // different create signatures, we'll just show one of them here. You can read about the other // ones in the [commit API docs][cd]. // [cd]: http://libgit2.github.com/libgit2/#HEAD/group/commit printf("\n*Commit Writing*\n"); git_oid tree_id, parent_id, commit_id; git_tree *tree; git_commit *parent; // Creating signatures for an authoring identity and time is pretty simple - you will need to have // this to create a commit in order to specify who created it and when. Default values for the name // and email should be found in the `user.name` and `user.email` configuration options. See the `config` // section of this example file to see how to access config values. git_signature_new((git_signature **)&author, "Scott Chacon", "*****@*****.**", 123456789, 60); git_signature_new((git_signature **)&cmtter, "Scott A Chacon", "*****@*****.**", 987654321, 90); // Commit objects need a tree to point to and optionally one or more parents. Here we're creating oid // objects to create the commit with, but you can also use git_oid_fromstr(&tree_id, "28873d96b4e8f4e33ea30f4c682fd325f7ba56ac"); git_tree_lookup(&tree, repo, &tree_id); git_oid_fromstr(&parent_id, "f0877d0b841d75172ec404fc9370173dfffc20d1"); git_commit_lookup(&parent, repo, &parent_id); // Here we actually create the commit object with a single call with all the values we need to create // the commit. The SHA key is written to the `commit_id` variable here. git_commit_create_v( &commit_id, /* out id */ repo, NULL, /* do not update the HEAD */ author, cmtter, NULL, /* use default message encoding */ "example commit", tree, 1, parent); // Now we can take a look at the commit SHA we've generated. git_oid_fmt(out, &commit_id); printf("New Commit: %s\n", out); // #### Tag Parsing // You can parse and create tags with the [tag management API][tm], which functions very similarly // to the commit lookup, parsing and creation methods, since the objects themselves are very similar. // [tm]: http://libgit2.github.com/libgit2/#HEAD/group/tag printf("\n*Tag Parsing*\n"); git_tag *tag; const char *tmessage, *tname; git_otype ttype; // We create an oid for the tag object if we know the SHA and look it up in the repository the same // way that we would a commit (or any other) object. git_oid_fromstr(&oid, "bc422d45275aca289c51d79830b45cecebff7c3a"); error = git_tag_lookup(&tag, repo, &oid); // Now that we have the tag object, we can extract the information it generally contains: the target // (usually a commit object), the type of the target object (usually 'commit'), the name ('v1.0'), // the tagger (a git_signature - name, email, timestamp), and the tag message. git_tag_target((git_object **)&commit, tag); tname = git_tag_name(tag); // "test" ttype = git_tag_type(tag); // GIT_OBJ_COMMIT (otype enum) tmessage = git_tag_message(tag); // "tag message\n" printf("Tag Message: %s\n", tmessage); git_commit_free(commit); // #### Tree Parsing // [Tree parsing][tp] is a bit different than the other objects, in that we have a subtype which is the // tree entry. This is not an actual object type in Git, but a useful structure for parsing and // traversing tree entries. // // [tp]: http://libgit2.github.com/libgit2/#HEAD/group/tree printf("\n*Tree Parsing*\n"); const git_tree_entry *entry; git_object *objt; // Create the oid and lookup the tree object just like the other objects. git_oid_fromstr(&oid, "2a741c18ac5ff082a7caaec6e74db3075a1906b5"); git_tree_lookup(&tree, repo, &oid); // Getting the count of entries in the tree so you can iterate over them if you want to. int cnt = git_tree_entrycount(tree); // 3 printf("tree entries: %d\n", cnt); entry = git_tree_entry_byindex(tree, 0); printf("Entry name: %s\n", git_tree_entry_name(entry)); // "hello.c" // You can also access tree entries by name if you know the name of the entry you're looking for. entry = git_tree_entry_byname(tree, "hello.c"); git_tree_entry_name(entry); // "hello.c" // Once you have the entry object, you can access the content or subtree (or commit, in the case // of submodules) that it points to. You can also get the mode if you want. git_tree_entry_to_object(&objt, repo, entry); // blob // Remember to close the looked-up object once you are done using it git_object_free(objt); // #### Blob Parsing // // The last object type is the simplest and requires the least parsing help. Blobs are just file // contents and can contain anything, there is no structure to it. The main advantage to using the // [simple blob api][ba] is that when you're creating blobs you don't have to calculate the size // of the content. There is also a helper for reading a file from disk and writing it to the db and // getting the oid back so you don't have to do all those steps yourself. // // [ba]: http://libgit2.github.com/libgit2/#HEAD/group/blob printf("\n*Blob Parsing*\n"); git_blob *blob; git_oid_fromstr(&oid, "af7574ea73f7b166f869ef1a39be126d9a186ae0"); git_blob_lookup(&blob, repo, &oid); // You can access a buffer with the raw contents of the blob directly. // Note that this buffer may not be contain ASCII data for certain blobs (e.g. binary files): // do not consider the buffer a NULL-terminated string, and use the `git_blob_rawsize` attribute to // find out its exact size in bytes printf("Blob Size: %ld\n", git_blob_rawsize(blob)); // 8 git_blob_rawcontent(blob); // "content" // ### Revwalking // // The libgit2 [revision walking api][rw] provides methods to traverse the directed graph created // by the parent pointers of the commit objects. Since all commits point back to the commit that // came directly before them, you can walk this parentage as a graph and find all the commits that // were ancestors of (reachable from) a given starting point. This can allow you to create `git log` // type functionality. // // [rw]: http://libgit2.github.com/libgit2/#HEAD/group/revwalk printf("\n*Revwalking*\n"); git_revwalk *walk; git_commit *wcommit; git_oid_fromstr(&oid, "f0877d0b841d75172ec404fc9370173dfffc20d1"); // To use the revwalker, create a new walker, tell it how you want to sort the output and then push // one or more starting points onto the walker. If you want to emulate the output of `git log` you // would push the SHA of the commit that HEAD points to into the walker and then start traversing them. // You can also 'hide' commits that you want to stop at or not see any of their ancestors. So if you // want to emulate `git log branch1..branch2`, you would push the oid of `branch2` and hide the oid // of `branch1`. git_revwalk_new(&walk, repo); git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE); git_revwalk_push(walk, &oid); const git_signature *cauth; const char *cmsg; // Now that we have the starting point pushed onto the walker, we can start asking for ancestors. It // will return them in the sorting order we asked for as commit oids. // We can then lookup and parse the commited pointed at by the returned OID; // note that this operation is specially fast since the raw contents of the commit object will // be cached in memory while ((git_revwalk_next(&oid, walk)) == 0) { error = git_commit_lookup(&wcommit, repo, &oid); cmsg = git_commit_message(wcommit); cauth = git_commit_author(wcommit); printf("%s (%s)\n", cmsg, cauth->email); git_commit_free(wcommit); } // Like the other objects, be sure to free the revwalker when you're done to prevent memory leaks. // Also, make sure that the repository being walked it not deallocated while the walk is in // progress, or it will result in undefined behavior git_revwalk_free(walk); // ### Index File Manipulation // // The [index file API][gi] allows you to read, traverse, update and write the Git index file // (sometimes thought of as the staging area). // // [gi]: http://libgit2.github.com/libgit2/#HEAD/group/index printf("\n*Index Walking*\n"); git_index *index; unsigned int i, ecount; // You can either open the index from the standard location in an open repository, as we're doing // here, or you can open and manipulate any index file with `git_index_open_bare()`. The index // for the repository will be located and loaded from disk. git_repository_index(&index, repo); // For each entry in the index, you can get a bunch of information including the SHA (oid), path // and mode which map to the tree objects that are written out. It also has filesystem properties // to help determine what to inspect for changes (ctime, mtime, dev, ino, uid, gid, file_size and flags) // All these properties are exported publicly in the `git_index_entry` struct ecount = git_index_entrycount(index); for (i = 0; i < ecount; ++i) { git_index_entry *e = git_index_get(index, i); printf("path: %s\n", e->path); printf("mtime: %d\n", (int)e->mtime.seconds); printf("fs: %d\n", (int)e->file_size); } git_index_free(index); // ### References // // The [reference API][ref] allows you to list, resolve, create and update references such as // branches, tags and remote references (everything in the .git/refs directory). // // [ref]: http://libgit2.github.com/libgit2/#HEAD/group/reference printf("\n*Reference Listing*\n"); // Here we will implement something like `git for-each-ref` simply listing out all available // references and the object SHA they resolve to. git_strarray ref_list; git_reference_list(&ref_list, repo, GIT_REF_LISTALL); const char *refname; git_reference *ref; // Now that we have the list of reference names, we can lookup each ref one at a time and // resolve them to the SHA, then print both values out. for (i = 0; i < ref_list.count; ++i) { refname = ref_list.strings[i]; git_reference_lookup(&ref, repo, refname); switch (git_reference_type(ref)) { case GIT_REF_OID: git_oid_fmt(out, git_reference_oid(ref)); printf("%s [%s]\n", refname, out); break; case GIT_REF_SYMBOLIC: printf("%s => %s\n", refname, git_reference_target(ref)); break; default: fprintf(stderr, "Unexpected reference type\n"); exit(1); } } git_strarray_free(&ref_list); // ### Config Files // // The [config API][config] allows you to list and updatee config values in // any of the accessible config file locations (system, global, local). // // [config]: http://libgit2.github.com/libgit2/#HEAD/group/config printf("\n*Config Listing*\n"); const char *email; int32_t j; git_config *cfg; // Open a config object so we can read global values from it. git_config_open_ondisk(&cfg, "~/.gitconfig"); git_config_get_int32(cfg, "help.autocorrect", &j); printf("Autocorrect: %d\n", j); git_config_get_string(cfg, "user.email", &email); printf("Email: %s\n", email); // Finally, when you're done with the repository, you can free it as well. git_repository_free(repo); return 0; }
/* The wiki handler */ static int wiki_handler(request_rec *r) { wiki_conf *conf; git_repository *repo; const git_oid *tree_oid; char *path; const git_oid *oid; char hash[41]; hash[40] = '\0'; int ret; int type; MMIOT *doc; if (strcmp(r->handler, "wiki")) { return DECLINED; } if (r->header_only) { return OK; } conf = (wiki_conf *) ap_get_module_config(r->per_dir_config, &wiki_module); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "filename=%s", r->filename); if (conf->basepath) { path = ltrim(conf->basepath, r->parsed_uri.path); } else { path = r->parsed_uri.path + 1; } ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "path=%s", path); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "r->content_type=%s", r->content_type); if (conf->repo == NULL) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "WikiRepository is not set."); return HTTP_INTERNAL_SERVER_ERROR; } ret = git_repository_open(&repo, conf->repo); if (ret) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "Cannot open git repository.(%s)", conf->repo); return HTTP_INTERNAL_SERVER_ERROR; } tree_oid = lookup_master_tree(repo); if (tree_oid == NULL) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "Not found master tree."); git_repository_free(repo); } type = lookup_object_oid(r, repo, tree_oid, path, &oid); if (type == WIKI_NOTFOUND) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "Object is not found."); git_repository_free(repo); return HTTP_NOT_FOUND; } else if(type == WIKI_DIR) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "Directory listing is not implement yet."); git_repository_free(repo); return HTTP_FORBIDDEN; } else if(type == WIKI_ERROR) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "Error at lookup."); git_repository_free(repo); return HTTP_NOT_FOUND; } git_oid_fmt(hash, oid); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "object hash=%s", hash); const char *data; size_t size; git_odb *odb; ret = git_repository_odb(&odb, repo); git_odb_object *odb_object; ret = git_odb_read(&odb_object, odb, oid); data = git_odb_object_data(odb_object); size = git_odb_object_size(odb_object); git_odb_object_free(odb_object); // is this safe? if (type == WIKI_FOUND) { ap_rwrite(data, size, r); } else if(type == WIKI_MARKDOWN) { r->content_type = "text/html"; doc = mkd_string(data, size, 0); if (doc == NULL) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mkd_string() returned NULL\n"); git_repository_free(repo); return HTTP_INTERNAL_SERVER_ERROR; } wiki_output(doc, r); mkd_cleanup(doc); } else { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "Unknown Error.\n"); git_repository_free(repo); return HTTP_INTERNAL_SERVER_ERROR; } git_repository_free(repo); return OK; }
int cmd_cat_file(int argc, const char **argv) { /* Uncomment when it passes the tests */ please_git_do_it_for_me(); char opt; if (argc != 2 && argc !=3) please_git_do_it_for_me(); if (argc == 3){ if ((strcmp(argv[1], "blob") == 0) || (strcmp(argv[1], "tree") == 0) || (strcmp(argv[1], "commit") == 0) || (strcmp(argv[1], "tag") == 0 )) opt = '0'; else opt = argv[1][1]; } else if (argc == 2 && (strcmp(argv[1], "--batch") == 0)) opt = 'a'; git_repository *repo = get_git_repository(); git_oid oid; if (git_oid_fromstr(&oid, (const char *)argv[argc-1])) please_git_do_it_for_me(); git_odb *odb; git_repository_odb(&odb, repo); git_odb_object *odb_object; if(git_odb_read(&odb_object, odb, &oid) == GIT_ENOTFOUND) libgit_error(); size_t size = git_odb_object_size(odb_object); git_otype type = git_odb_object_type(odb_object); const char *type_string = git_object_type2string(type); switch (opt) { case 'p': if (strcmp(type_string, "tree") == 0) { printf("vous etes là\n"); char ** arg = malloc(2); strcpy(arg[0], "ls-tree"); strcpy(arg[1], argv[2]); int e = cmd_ls_tree(2, (const char **)arg); if (e == 0 ) printf("succes\n"); else printf("echec\n"); } else { for(int i=0; i < (int)size; i++) printf("%c", *((char *)git_odb_object_data(odb_object)+i)); } break; case 't': printf("%s\n",type_string); break; case 's': printf("%zu\n",size); break; case 'e': if(git_odb_exists(odb, &oid) == 1) { return 0; } break; case '0' : if (strcmp(type_string, argv[1]) == 0) { for (int i=0; i < (int)size; i++) printf("%c", *((char *)git_odb_object_data(odb_object)+i)); } else please_git_do_it_for_me(); break; case 'a' : please_git_do_it_for_me(); // if (strbuf_read(&buf, 0, 4096) < 0) // die_errno("could not read from stdin"); // // git_oid id; // if (git_oid_mkstr(&id, buf.buf)) // please_git_do_it_for_me(); // // git_odb_object *odb_object1; // if(git_odb_read(&odb_object1, odb, &id) == GIT_ENOTFOUND) // libgit_error(); // size_t size1 = git_odb_object_size(odb_object1); // git_otype type1 = git_odb_object_type(odb_object1); // // printf("bla bla %s %s %zu\n",buf.buf, git_object_type2string(type1), size1); // for(int i=0; i < (int)size1; i++) // printf("%c", *((char *)git_odb_object_data(odb_object1)+i)); // fflush(stdout); break; } //git_odb_object_close(odb_object); return EXIT_SUCCESS; }
/** Entry point for this command */ int main(int argc, char *argv[]) { git_repository *repo; struct opts o = { ".", NULL, 0, 0 }; git_object *obj = NULL; char oidstr[GIT_OID_HEXSZ + 1]; git_libgit2_init(); parse_opts(&o, argc, argv); check_lg2(git_repository_open_ext(&repo, o.dir, 0, NULL), "Could not open repository", NULL); check_lg2(git_revparse_single(&obj, repo, o.rev), "Could not resolve", o.rev); if (o.verbose) { char oidstr[GIT_OID_HEXSZ + 1]; git_oid_tostr(oidstr, sizeof(oidstr), git_object_id(obj)); printf("%s %s\n--\n", git_object_type2string(git_object_type(obj)), oidstr); } switch (o.action) { case SHOW_TYPE: printf("%s\n", git_object_type2string(git_object_type(obj))); break; case SHOW_SIZE: { git_odb *odb; git_odb_object *odbobj; check_lg2(git_repository_odb(&odb, repo), "Could not open ODB", NULL); check_lg2(git_odb_read(&odbobj, odb, git_object_id(obj)), "Could not find obj", NULL); printf("%ld\n", (long)git_odb_object_size(odbobj)); git_odb_object_free(odbobj); git_odb_free(odb); } break; case SHOW_NONE: /* just want return result */ break; case SHOW_PRETTY: switch (git_object_type(obj)) { case GIT_OBJ_BLOB: show_blob((const git_blob *)obj); break; case GIT_OBJ_COMMIT: show_commit((const git_commit *)obj); break; case GIT_OBJ_TREE: show_tree((const git_tree *)obj); break; case GIT_OBJ_TAG: show_tag((const git_tag *)obj); break; default: printf("unknown %s\n", oidstr); break; } break; } git_object_free(obj); git_repository_free(repo); git_libgit2_shutdown(); return 0; }