static void origin_decref(git_blame__origin *o)
{
if (o && --o->refcnt <= 0) {
if (o->previous)
origin_decref(o->previous);
git_blob_free(o->blob);
git_commit_free(o->commit);
git__free(o);
}
}
void git_repository_free(git_repository *repo)
{
if (repo == NULL)
return;
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);
drop_config(repo);
drop_index(repo);
drop_odb(repo);
git__free(repo);
}
int git_odb__hashlink(git_oid *out, const char *path)
{
struct stat st;
git_off_t size;
int result;
if (git_path_lstat(path, &st) < 0)
return -1;
size = st.st_size;
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 = (char*) git__malloc((size_t)(size + 1));
GITERR_CHECK_ALLOC(link_data);
read_len = p_readlink(path, link_data, (size_t)size);
link_data[size] = '\0';
if (read_len != (ssize_t)size) {
giterr_set(GITERR_OS, "Failed to read symlink data for '%s'", path);
git__free(link_data);
return -1;
}
result = git_odb_hash(out, link_data, (size_t)size, GIT_OBJ_BLOB);
git__free(link_data);
} else {
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 result;
}
void test_online_clone__cleanup(void)
{
if (g_repo) {
git_repository_free(g_repo);
g_repo = NULL;
}
cl_fixture_cleanup("./foo");
git__free(_remote_url);
git__free(_remote_user);
git__free(_remote_pass);
git__free(_remote_ssh_pubkey);
git__free(_remote_ssh_privkey);
git__free(_remote_ssh_passphrase);
git__free(_remote_ssh_fingerprint);
git__free(_remote_proxy_url);
git__free(_remote_proxy_user);
git__free(_remote_proxy_pass);
}
static void shutdown_common(void)
{
int pos;
/* Shutdown subsystems that have registered */
for (pos = git_atomic_get(&git__n_shutdown_callbacks);
pos > 0;
pos = git_atomic_dec(&git__n_shutdown_callbacks)) {
git_global_shutdown_fn cb = git__swap(
git__shutdown_callbacks[pos - 1], NULL);
if (cb != NULL)
cb();
}
git__free(git__user_agent);
git__free(git__ssl_ciphers);
}
static void stransport_free(git_stream *stream)
{
stransport_stream *st = (stransport_stream *) stream;
git_stream_free(st->io);
CFRelease(st->ctx);
if (st->der_data)
CFRelease(st->der_data);
git__free(st);
}
void git_object__free(void *obj)
{
git_otype type = ((git_object *)obj)->cached.type;
if (type < 0 || ((size_t)type) >= ARRAY_SIZE(git_objects_table) ||
!git_objects_table[type].free)
git__free(obj);
else
git_objects_table[type].free(obj);
}
static void ssh_key_free(struct git_cred *cred)
{
git_cred_ssh_key *c =
(git_cred_ssh_key *)cred;
git__free(c->username);
git__free(c->publickey);
git__free(c->privatekey);
if (c->passphrase) {
/* Zero the memory which previously held the passphrase */
size_t pass_len = strlen(c->passphrase);
git__memzero(c->passphrase, pass_len);
git__free(c->passphrase);
}
git__memzero(c, sizeof(*c));
git__free(c);
}
void git_vector_free(git_vector *v)
{
assert(v);
git__free(v->contents);
v->contents = NULL;
v->length = 0;
v->_alloc_size = 0;
}
/**
* Free the TLS data associated with this thread.
* This should only be used by the thread as it
* is exiting.
*/
void git__free_tls_data(void)
{
void *ptr = TlsGetValue(_tls_index);
if (!ptr)
return;
git__global_state_cleanup(ptr);
git__free(ptr);
TlsSetValue(_tls_index, NULL);
}
void git_error_state_free(git_error_state *state)
{
if (!state)
return;
if (!state->oom)
git__free(state->error_msg.message);
memset(state, 0, sizeof(git_error_state));
}
int p_access(const char* path, mode_t mode)
{
wchar_t *buf = gitwin_to_utf16(path);
int ret;
ret = _waccess(buf, mode);
git__free(buf);
return ret;
}
int git_revparse(
git_revspec *revspec,
git_repository *repo,
const char *spec)
{
const char *dotdot;
int error = 0;
assert(revspec && repo && spec);
memset(revspec, 0x0, sizeof(*revspec));
if ((dotdot = strstr(spec, "..")) != NULL) {
char *lstr;
const char *rstr;
revspec->flags = GIT_REVPARSE_RANGE;
/*
* Following git.git, don't allow '..' because it makes command line
* arguments which can be either paths or revisions ambiguous when the
* path is almost certainly intended. The empty range '...' is still
* allowed.
*/
if (!git__strcmp(spec, "..")) {
giterr_set(GITERR_INVALID, "Invalid pattern '..'");
return GIT_EINVALIDSPEC;
}
lstr = git__substrdup(spec, dotdot - spec);
rstr = dotdot + 2;
if (dotdot[2] == '.') {
revspec->flags |= GIT_REVPARSE_MERGE_BASE;
rstr++;
}
error = git_revparse_single(
&revspec->from,
repo,
*lstr == '\0' ? "HEAD" : lstr);
if (!error) {
error = git_revparse_single(
&revspec->to,
repo,
*rstr == '\0' ? "HEAD" : rstr);
}
git__free((void*)lstr);
} else {
revspec->flags = GIT_REVPARSE_SINGLE;
error = git_revparse_single(&revspec->from, repo, spec);
}
return error;
}
static int fallback_cred_acquire_cb(
git_cred **cred,
const char *url,
const char *username_from_url,
unsigned int allowed_types,
void *payload)
{
int error = 1;
GIT_UNUSED(username_from_url);
GIT_UNUSED(payload);
/* If the target URI supports integrated Windows authentication
* as an authentication mechanism */
if (GIT_CREDTYPE_DEFAULT & allowed_types) {
wchar_t *wide_url;
/* Convert URL to wide characters */
if (git__utf8_to_16_alloc(&wide_url, url) < 0) {
giterr_set(GITERR_OS, "Failed to convert string to wide form");
return -1;
}
if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED))) {
IInternetSecurityManager* pISM;
/* And if the target URI is in the My Computer, Intranet, or Trusted zones */
if (SUCCEEDED(CoCreateInstance(&CLSID_InternetSecurityManager, NULL,
CLSCTX_ALL, &IID_IInternetSecurityManager, (void **)&pISM))) {
DWORD dwZone;
if (SUCCEEDED(pISM->lpVtbl->MapUrlToZone(pISM, wide_url, &dwZone, 0)) &&
(URLZONE_LOCAL_MACHINE == dwZone ||
URLZONE_INTRANET == dwZone ||
URLZONE_TRUSTED == dwZone)) {
git_cred *existing = *cred;
if (existing)
existing->free(existing);
/* Then use default Windows credentials to authenticate this request */
error = git_cred_default_new(cred);
}
pISM->lpVtbl->Release(pISM);
}
CoUninitialize();
}
git__free(wide_url);
}
return error;
}
static int _git_uploadpack_ls(
git_subtransport *t,
const char *url,
git_smart_subtransport_stream **stream)
{
char *host=NULL, *port=NULL, *path=NULL, *user=NULL, *pass=NULL;
const char *stream_url = url;
git_proto_stream *s;
int error;
*stream = NULL;
if (!git__prefixcmp(url, prefix_git))
stream_url += strlen(prefix_git);
if ((error = gitno_extract_url_parts(&host, &port, &path, &user, &pass, url, GIT_DEFAULT_PORT)) < 0)
return error;
error = git_proto_stream_alloc(t, stream_url, cmd_uploadpack, host, port, stream);
git__free(host);
git__free(port);
git__free(path);
git__free(user);
git__free(pass);
if (error < 0) {
git_proto_stream_free(*stream);
return error;
}
s = (git_proto_stream *) *stream;
if ((error = git_stream_connect(s->io)) < 0) {
git_proto_stream_free(*stream);
return error;
}
t->current_stream = s;
return 0;
}
git_commit_list_node *git_commit_list_pop(git_commit_list **stack)
{
git_commit_list *top = *stack;
git_commit_list_node *item = top ? top->item : NULL;
if (top) {
*stack = top->next;
git__free(top);
}
return item;
}
static void cleanup_chmod_root(void *ref)
{
mode_t *mode = ref;
if (*mode != 0) {
(void)p_umask(*mode);
git__free(mode);
}
git_futils_rmdir_r("r", NULL, GIT_RMDIR_EMPTY_HIERARCHY);
}
void git_pkt_free(git_pkt *pkt)
{
if (pkt->type == GIT_PKT_REF) {
git_pkt_ref *p = (git_pkt_ref *) pkt;
git__free(p->head.name);
}
if (pkt->type == GIT_PKT_OK) {
git_pkt_ok *p = (git_pkt_ok *) pkt;
git__free(p->ref);
}
if (pkt->type == GIT_PKT_NG) {
git_pkt_ng *p = (git_pkt_ng *) pkt;
git__free(p->ref);
git__free(p->msg);
}
git__free(pkt);
}
static void clear_parents(git_commit *commit)
{
unsigned int i;
for (i = 0; i < commit->parent_ids.length; ++i) {
git_oid *parent = git_vector_get(&commit->parent_ids, i);
git__free(parent);
}
git_vector_clear(&commit->parent_ids);
}
void git_diff_driver_registry_free(git_diff_driver_registry *reg)
{
git_diff_driver *drv;
if (!reg)
return;
git_strmap_foreach_value(reg->drivers, drv, git_diff_driver_free(drv));
git_strmap_free(reg->drivers);
git__free(reg);
}
int git_repository_set_namespace(git_repository *repo, const char *nnamespace)
{
git__free(repo->nnamespace);
if (nnamespace == NULL) {
repo->nnamespace = NULL;
return 0;
}
return (repo->nnamespace = git__strdup(nnamespace)) ? 0 : -1;
}
void git_repository_free(git_repository *repo)
{
if (repo == NULL)
return;
git_repository__cleanup(repo);
git_cache_free(&repo->objects);
git_diff_driver_registry_free(repo->diff_drivers);
repo->diff_drivers = NULL;
git__free(repo->path_repository);
git__free(repo->workdir);
git__free(repo->nnamespace);
git__free(repo->name_8dot3);
git__memzero(repo, sizeof(*repo));
git__free(repo);
}
int git_remote_set_url(git_remote *remote, const char* url)
{
assert(remote);
assert(url);
git__free(remote->url);
remote->url = git__strdup(url);
GITERR_CHECK_ALLOC(remote->url);
return 0;
}
static void odb_free(git_odb *db)
{
size_t i;
for (i = 0; i < db->backends.length; ++i) {
backend_internal *internal = (backend_internal *) git_vector_get(&db->backends, i);
git_odb_backend *backend = internal->backend;
if (backend->free) backend->free(backend);
else git__free(backend);
git__free(internal);
}
git_vector_free(&db->backends);
git_cache_free(&db->own_cache);
git__memzero(db, sizeof(*db));
git__free(db);
}
char *cl_getenv(const char *name)
{
wchar_t *wide_name, *wide_value;
char *utf8_value = NULL;
DWORD value_len;
cl_assert(git__utf8_to_16_alloc(&wide_name, name) >= 0);
value_len = GetEnvironmentVariableW(wide_name, NULL, 0);
if (value_len) {
cl_assert(wide_value = git__malloc(value_len * sizeof(wchar_t)));
cl_assert(GetEnvironmentVariableW(wide_name, wide_value, value_len));
cl_assert(git__utf16_to_8_alloc(&utf8_value, wide_value) >= 0);
git__free(wide_value);
}
git__free(wide_name);
return utf8_value;
}
static void config_memory_free(git_config_backend *_backend)
{
config_memory_backend *backend = (config_memory_backend *)_backend;
if (backend == NULL)
return;
git_config_entries_free(backend->entries);
git_buf_dispose(&backend->cfg);
git__free(backend);
}
static void set_error(int error_class, char *string)
{
git_error *error = &GIT_GLOBAL->error_t;
git__free(error->message);
error->message = string;
error->klass = error_class;
GIT_GLOBAL->last_error = error;
}
static void shutdown_ssl_locking(void)
{
int num_locks, i;
num_locks = CRYPTO_num_locks();
CRYPTO_set_locking_callback(NULL);
for (i = 0; i < num_locks; ++i)
git_mutex_free(openssl_locks);
git__free(openssl_locks);
}
int git_cred_ssh_publickey_new(
git_cred **cred,
const char *username,
const char *publickey,
const char *privatekey,
const char *passphrase)
{
git_cred_ssh_publickey *c;
if (!cred)
return -1;
c = (git_cred_ssh_publickey *)git__malloc(sizeof(git_cred_ssh_publickey));
GITERR_CHECK_ALLOC(c);
memset(c, 0, sizeof(git_cred_ssh_publickey));
c->parent.credtype = GIT_CREDTYPE_SSH_PUBLICKEY;
c->parent.free = ssh_publickey_free;
c->username = git__strdup(username);
if (!c->username) {
git__free(c);
return -1;
}
c->privatekey = git__strdup(privatekey);
if (!c->privatekey) {
git__free(c->username);
git__free(c);
return -1;
}
if (publickey != NULL)
c->publickey = git__strdup(publickey);
if (passphrase != NULL)
c->passphrase = git__strdup(passphrase);
*cred = &c->parent;
return 0;
}
static int parse_header_git_newfilemode(
git_patch_parsed *patch,
git_patch_parse_ctx *ctx)
{
git__free((char *)patch->base.delta->new_file.path);
patch->base.delta->new_file.path = NULL;
patch->base.delta->status = GIT_DELTA_ADDED;
patch->base.delta->nfiles = 1;
return parse_header_mode(&patch->base.delta->new_file.mode, ctx);
}
