global: Properly use `git__` memory wrappers

Ensure that all memory related functions (malloc, calloc, strdup, free,
etc) are using their respective `git__` wrappers.

examples/network/fetch.c

@@ -119,7 +119,7 @@ int fetch(git_repository *repo, int argc, char **argv)
   if (error < GIT_SUCCESS)
     return error;
 
-  free(packname);
+  git__free(packname);
   git_indexer_free(idx);
   git_remote_free(remote);
 

include/git2/oid.h

@@ -100,7 +100,7 @@ GIT_EXTERN(void) git_oid_pathfmt(char *str, const git_oid *oid);
  *
  * @param oid the oid structure to format
  * @return the c-string; NULL if memory is exhausted. Caller must
- *			deallocate the string with free().
+ *			deallocate the string with git__free().
  */
 GIT_EXTERN(char *) git_oid_allocfmt(const git_oid *oid);
 

src/blob.c

@@ -27,7 +27,7 @@ size_t git_blob_rawsize(git_blob *blob)
 void git_blob__free(git_blob *blob)
 {
 	git_odb_object_close(blob->odb_object);
-	free(blob);
+	git__free(blob);
 }
 
 int git_blob__parse(git_blob *blob, git_odb_object *odb_obj)

src/buffer.c

@@ -97,7 +97,7 @@ const char *git_buf_cstr(git_buf *buf)
 
 void git_buf_free(git_buf *buf)
 {
-	free(buf->ptr);
+	git__free(buf->ptr);
 }
 
 void git_buf_clear(git_buf *buf)

src/cache.c

@@ -53,7 +53,7 @@ void git_cache_free(git_cache *cache)
 		git_mutex_free(&cache->nodes[i].lock);
 	}
 
-	free(cache->nodes);
+	git__free(cache->nodes);
 }
 
 void *git_cache_get(git_cache *cache, const git_oid *oid)

src/commit.c

@@ -32,7 +32,7 @@ static void clear_parents(git_commit *commit)
 
 	for (i = 0; i < commit->parent_oids.length; ++i) {
 		git_oid *parent = git_vector_get(&commit->parent_oids, i);
-		free(parent);
+		git__free(parent);
 	}
 
 	git_vector_clear(&commit->parent_oids);
@@ -46,9 +46,9 @@ void git_commit__free(git_commit *commit)
 	git_signature_free(commit->author);
 	git_signature_free(commit->committer);
 
-	free(commit->message);
-	free(commit->message_encoding);
-	free(commit);
+	git__free(commit->message);
+	git__free(commit->message_encoding);
+	git__free(commit);
 }
 
 const git_oid *git_commit_id(git_commit *c)
@@ -84,7 +84,7 @@ int git_commit_create_v(
 		message_encoding, message,
 		tree, parent_count, parents);
 
-	free((void *)parents);
+	git__free((void *)parents);
 
 	return error;
 }

src/config.c

@@ -35,11 +35,11 @@ void git_config_free(git_config *cfg)
 		internal = git_vector_get(&cfg->files, i);
 		file = internal->file;
 		file->free(file);
-		free(internal);
+		git__free(internal);
 	}
 
 	git_vector_free(&cfg->files);
-	free(cfg);
+	git__free(cfg);
 }
 
 static int config_backend_cmp(const void *a, const void *b)
@@ -61,7 +61,7 @@ int git_config_new(git_config **out)
 	memset(cfg, 0x0, sizeof(git_config));
 
 	if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) {
-		free(cfg);
+		git__free(cfg);
 		return GIT_ENOMEM;
 	}
 
@@ -125,7 +125,7 @@ int git_config_add_file(git_config *cfg, git_config_file *file, int priority)
 	internal->priority = priority;
 
 	if (git_vector_insert(&cfg->files, internal) < 0) {
-		free(internal);
+		git__free(internal);
 		return GIT_ENOMEM;
 	}
 
@@ -366,20 +366,20 @@ static int win32_find_system(char *system_config_path)
 		return git__throw(GIT_ERROR, "Failed to expand environment strings");
 
 	if (_waccess(apphome_utf16, F_OK) < 0) {
-		free(apphome_utf16);
+		git__free(apphome_utf16);
 		return GIT_ENOTFOUND;
 	}
 
 	apphome_utf8 = gitwin_from_utf16(apphome_utf16);
-	free(apphome_utf16);
+	git__free(apphome_utf16);
 
 	if (strlen(apphome_utf8) >= GIT_PATH_MAX) {
-		free(apphome_utf8);
+		git__free(apphome_utf8);
 		return git__throw(GIT_ESHORTBUFFER, "Path is too long");
 	}
 
 	strcpy(system_config_path, apphome_utf8);
-	free(apphome_utf8);
+	git__free(apphome_utf8);
 	return GIT_SUCCESS;
 }
 #endif

src/config_file.c

@@ -90,10 +90,10 @@ static void cvar_free(cvar_t *var)
 	if (var == NULL)
 		return;
 
-	free(var->section);
-	free(var->name);
-	free(var->value);
-	free(var);
+	git__free(var->section);
+	git__free(var->name);
+	git__free(var->value);
+	git__free(var);
 }
 
 static void cvar_list_free(cvar_t_list *list)
@@ -188,7 +188,7 @@ static int cvar_normalize_name(cvar_t *var, char **output)
 	if (section_sp == NULL) {
 		ret = p_snprintf(name, len + 1, "%s.%s", var->section, var->name);
 		if (ret < 0) {
-			free(name);
+			git__free(name);
 			return git__throw(GIT_EOSERR, "Failed to normalize name. OS err: %s", strerror(errno));
 		}
 
@@ -281,10 +281,10 @@ static void backend_free(git_config_file *_backend)
 	if (backend == NULL)
 		return;
 
-	free(backend->file_path);
+	git__free(backend->file_path);
 	cvar_list_free(&backend->var_list);
 
-	free(backend);
+	git__free(backend);
 }
 
 static int file_foreach(git_config_file *backend, int (*fn)(const char *, const char *, void *), void *data)
@@ -301,7 +301,7 @@ static int file_foreach(git_config_file *backend, int (*fn)(const char *, const
 			return ret;
 
 		ret = fn(normalized, var->value, data);
-		free(normalized);
+		git__free(normalized);
 		if (ret)
 			break;
 	}
@@ -326,7 +326,7 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
 		if (tmp == NULL && value != NULL)
 			return GIT_ENOMEM;
 
-		free(existing->value);
+		git__free(existing->value);
 		existing->value = tmp;
 
 		return config_write(b, existing);
@@ -411,7 +411,7 @@ int git_config_file__ondisk(git_config_file **out, const char *path)
 
 	backend->file_path = git__strdup(path);
 	if (backend->file_path == NULL) {
-		free(backend);
+		git__free(backend);
 		return GIT_ENOMEM;
 	}
 
@@ -653,13 +653,13 @@ static int parse_section_header(diskfile_backend *cfg, char **section_out)
 	/* find the end of the variable's name */
 	name_end = strchr(line, ']');
 	if (name_end == NULL) {
-		free(line);
+		git__free(line);
 		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse header. Can't find header name end");
 	}
 
 	name = (char *)git__malloc((size_t)(name_end - line) + 1);
 	if (name == NULL) {
-		free(line);
+		git__free(line);
 		return GIT_ENOMEM;
 	}
 
@@ -679,8 +679,8 @@ static int parse_section_header(diskfile_backend *cfg, char **section_out)
 		if (isspace(c)){
 			name[name_length] = '\0';
 			error = parse_section_header_ext(line, name, section_out);
-			free(line);
-			free(name);
+			git__free(line);
+			git__free(name);
 			return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse header");
 		}
 
@@ -699,14 +699,14 @@ static int parse_section_header(diskfile_backend *cfg, char **section_out)
 	}
 
 	name[name_length] = 0;
-	free(line);
+	git__free(line);
 	git__strtolower(name);
 	*section_out = name;
 	return GIT_SUCCESS;
 
 error:
-	free(line);
-	free(name);
+	git__free(line);
+	git__free(name);
 	return error;
 }
 
@@ -810,7 +810,7 @@ static int config_parse(diskfile_backend *cfg_file)
 			break;
 
 		case '[': /* section header, new section begins */
-			free(current_section);
+			git__free(current_section);
 			current_section = NULL;
 			error = parse_section_header(cfg_file, &current_section);
 			break;
@@ -826,7 +826,7 @@ static int config_parse(diskfile_backend *cfg_file)
 			if (error < GIT_SUCCESS)
 				break;
 
-			var = malloc(sizeof(cvar_t));
+			var = git__malloc(sizeof(cvar_t));
 			if (var == NULL) {
 				error = GIT_ENOMEM;
 				break;
@@ -837,7 +837,7 @@ static int config_parse(diskfile_backend *cfg_file)
 			var->section = git__strdup(current_section);
 			if (var->section == NULL) {
 				error = GIT_ENOMEM;
-				free(var);
+				git__free(var);
 				break;
 			}
 
@@ -851,7 +851,7 @@ static int config_parse(diskfile_backend *cfg_file)
 		}
 	}
 
-	free(current_section);
+	git__free(current_section);
 
 	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse config");
 }
@@ -915,7 +915,7 @@ static int config_write(diskfile_backend *cfg, cvar_t *var)
 			 */
 			pre_end = post_start = cfg->reader.read_ptr;
 			if (current_section)
-				free(current_section);
+				git__free(current_section);
 			error = parse_section_header(cfg, &current_section);
 			if (error < GIT_SUCCESS)
 				break;
@@ -953,8 +953,8 @@ static int config_write(diskfile_backend *cfg, cvar_t *var)
 				if ((error = parse_variable(cfg, &var_name, &var_value)) == GIT_SUCCESS)
 					cmp = strcasecmp(var->name, var_name);
 
-				free(var_name);
-				free(var_value);
+				git__free(var_name);
+				git__free(var_value);
 
 				if (cmp != 0)
 					break;
@@ -1029,7 +1029,7 @@ static int config_write(diskfile_backend *cfg, cvar_t *var)
 		git__rethrow(error, "Failed to write new section");
 
  cleanup:
-	free(current_section);
+	git__free(current_section);
 
 	if (error < GIT_SUCCESS)
 		git_filebuf_cleanup(&file);
@@ -1093,7 +1093,7 @@ static int parse_multiline_variable(diskfile_backend *cfg, const char *first, ch
 	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));
-		free(buf);
+		git__free(buf);
 		goto out;
 	}
 
@@ -1105,14 +1105,14 @@ static int parse_multiline_variable(diskfile_backend *cfg, const char *first, ch
 	if (is_multiline_var(buf)) {
 		char *final_val;
 		error = parse_multiline_variable(cfg, buf, &final_val);
-		free(buf);
+		git__free(buf);
 		buf = final_val;
 	}
 
 	*out = buf;
 
  out:
-	free(line);
+	git__free(line);
 	return error;
 }
 
@@ -1168,14 +1168,14 @@ static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_val
 			if (error != GIT_SUCCESS)
 			{
 				*var_value = NULL;
-				free(*var_name);
+				git__free(*var_name);
 			}
 			goto out;
 		}
 
-		tmp = strdup(value_start);
+		tmp = git__strdup(value_start);
 		if (tmp == NULL) {
-			free(*var_name);
+			git__free(*var_name);
 			*var_value = NULL;
 			error = GIT_ENOMEM;
 			goto out;
@@ -1188,6 +1188,6 @@ static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_val
 	}
 
  out:
-	free(line);
+	git__free(line);
 	return error;
 }

src/delta-apply.c

@@ -109,7 +109,7 @@ int git__delta_apply(
 	return GIT_SUCCESS;
 
 fail:
-	free(out->data);
+	git__free(out->data);
 	out->data = NULL;
 	return git__throw(GIT_ERROR, "Failed to apply delta");
 }

src/errors.c

@@ -70,9 +70,9 @@ void git___rethrow(const char *msg, ...)
 	vsnprintf(new_error, sizeof(new_error), msg, va);
 	va_end(va);
 
-	old_error = strdup(g_last_error);
+	old_error = git__strdup(g_last_error);
 	snprintf(g_last_error, sizeof(g_last_error), "%s \n	- %s", new_error, old_error);
-	free(old_error);
+	git__free(old_error);
 }
 
 void git___throw(const char *msg, ...)

src/filebuf.c

@@ -63,13 +63,13 @@ void git_filebuf_cleanup(git_filebuf *file)
 	if (file->digest)
 		git_hash_free_ctx(file->digest);
 
-	free(file->buffer);
-	free(file->z_buf);
+	git__free(file->buffer);
+	git__free(file->z_buf);
 
 	deflateEnd(&file->zs);
 
-	free(file->path_original);
-	free(file->path_lock);
+	git__free(file->path_original);
+	git__free(file->path_lock);
 }
 
 GIT_INLINE(int) flush_buffer(git_filebuf *file)
@@ -248,7 +248,7 @@ int git_filebuf_hash(git_oid *oid, git_filebuf *file)
 
 int git_filebuf_commit_at(git_filebuf *file, const char *path)
 {
-	free(file->path_original);
+	git__free(file->path_original);
 	file->path_original = git__strdup(path);
 	if (file->path_original == NULL)
 		return GIT_ENOMEM;
@@ -368,12 +368,12 @@ int git_filebuf_printf(git_filebuf *file, const char *format, ...)
 	va_end(arglist);
 
 	if (len < 0) {
-		free(tmp_buffer);
+		git__free(tmp_buffer);
 		return git__throw(GIT_EOSERR, "Failed to format string");
 	}
 
 	error = git_filebuf_write(file, tmp_buffer, len);
-	free(tmp_buffer);
+	git__free(tmp_buffer);
 
 	return error;
 }

src/fileops.c

@@ -181,7 +181,7 @@ int git_futils_readbuffer_updated(git_fbuffer *obj, const char *path, time_t *mt
 
 	if (p_read(fd, buff, len) < 0) {
 		p_close(fd);
-		free(buff);
+		git__free(buff);
 		return git__throw(GIT_ERROR, "Failed to read file `%s`", path);
 	}
 	buff[len] = '\0';
@@ -207,7 +207,7 @@ int git_futils_readbuffer(git_fbuffer *obj, const char *path)
 void git_futils_freebuffer(git_fbuffer *obj)
 {
 	assert(obj);
-	free(obj->data);
+	git__free(obj->data);
 	obj->data = NULL;
 }
 
@@ -326,7 +326,7 @@ int git_futils_mkdir_r(const char *path, int mode)
 			error = GIT_SUCCESS;
 	}
 
-	free(path_copy);
+	git__free(path_copy);
 
 	if (error < GIT_SUCCESS)
 		return git__throw(error, "Failed to recursively create `%s` tree structure", path);

src/hash.c

@@ -32,7 +32,7 @@ git_hash_ctx *git_hash_new_ctx(void)
 
 void git_hash_free_ctx(git_hash_ctx *ctx)
 {
-	free(ctx);
+	git__free(ctx);
 }
 
 void git_hash_init(git_hash_ctx *ctx)

src/hashtable.c

@@ -39,17 +39,17 @@ static int resize_to(git_hashtable *self, size_t new_size)
 			self->is_resizing = 0;
 		else {
 			new_size *= 2;
-			free(self->nodes);
+			git__free(self->nodes);
 		}
 	} while(self->is_resizing);
 
-	free(old_nodes);
+	git__free(old_nodes);
 	return GIT_SUCCESS;
 }
 
 static int set_size(git_hashtable *self, size_t new_size)
 {
-	self->nodes = realloc(self->nodes, new_size * sizeof(git_hashtable_node));
+	self->nodes = git__realloc(self->nodes, new_size * sizeof(git_hashtable_node));
 	if (self->nodes == NULL)
 		return GIT_ENOMEM;
 
@@ -156,8 +156,8 @@ void git_hashtable_free(git_hashtable *self)
 {
 	assert(self);
 
-	free(self->nodes);
-	free(self);
+	git__free(self->nodes);
+	git__free(self);
 }
 
 

src/index.c

@@ -138,7 +138,7 @@ static int index_initialize(git_index **index_out, git_repository *owner, const
 
 	index->index_file_path = git__strdup(index_path);
 	if (index->index_file_path == NULL) {
-		free(index);
+		git__free(index);
 		return GIT_ENOMEM;
 	}
 
@@ -179,8 +179,8 @@ void git_index_free(git_index *index)
 	git_vector_free(&index->entries);
 	git_vector_free(&index->unmerged);
 
-	free(index->index_file_path);
-	free(index);
+	git__free(index->index_file_path);
+	git__free(index);
 }
 
 void git_index_clear(git_index *index)
@@ -192,15 +192,15 @@ void git_index_clear(git_index *index)
 	for (i = 0; i < index->entries.length; ++i) {
 		git_index_entry *e;
 		e = git_vector_get(&index->entries, i);
-		free(e->path);
-		free(e);
+		git__free(e->path);
+		git__free(e);
 	}
 
 	for (i = 0; i < index->unmerged.length; ++i) {
 		git_index_entry_unmerged *e;
 		e = git_vector_get(&index->unmerged, i);
-		free(e->path);
-		free(e);
+		git__free(e->path);
+		git__free(e);
 	}
 
 	git_vector_clear(&index->entries);
@@ -334,7 +334,7 @@ static int index_entry_init(git_index_entry **entry_out, git_index *index, const
 	entry->flags |= (stage << GIT_IDXENTRY_STAGESHIFT);
 	entry->path = git__strdup(rel_path);
 	if (entry->path == NULL) {
-		free(entry);
+		git__free(entry);
 		return GIT_ENOMEM;
 	}
 
@@ -364,8 +364,8 @@ static void index_entry_free(git_index_entry *entry)
 {
 	if (!entry)
 		return;
-	free(entry->path);
-	free(entry);
+	git__free(entry->path);
+	git__free(entry);
 }
 
 static int index_insert(git_index *index, git_index_entry *entry, int replace)
@@ -416,8 +416,8 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace)
 
 	/* exists, replace it */
 	entry_array = (git_index_entry **) index->entries.contents;
-	free(entry_array[position]->path);
-	free(entry_array[position]);
+	git__free(entry_array[position]->path);
+	git__free(entry_array[position]);
 	entry_array[position] = entry;
 
 	return GIT_SUCCESS;

src/indexer.c

@@ -367,7 +367,7 @@ int git_indexer_run(git_indexer *idx, git_indexer_stats *stats)
 			idx->fanout[i]++;
 		}
 
-		free(obj.data);
+		git__free(obj.data);
 
 		stats->processed = ++processed;
 	}
@@ -390,12 +390,12 @@ void git_indexer_free(git_indexer *idx)
 
 	p_close(idx->pack->mwf.fd);
 	git_vector_foreach(&idx->objects, i, e)
-		free(e);
+		git__free(e);
 	git_vector_free(&idx->objects);
 	git_vector_foreach(&idx->pack->cache, i, pe)
-		free(pe);
+		git__free(pe);
 	git_vector_free(&idx->pack->cache);
-	free(idx->pack);
-	free(idx);
+	git__free(idx->pack);
+	git__free(idx);
 }
 

src/mwindow.c

@@ -69,7 +69,7 @@ void git_mwindow_free_all(git_mwindow_file *mwf)
 		git_futils_mmap_free(&w->window_map);
 
 		mwf->windows = w->next;
-		free(w);
+		git__free(w);
 	}
 }
 
@@ -139,7 +139,7 @@ static int git_mwindow_close_lru(git_mwindow_file *mwf)
 		else
 			*list = lru_w->next;
 
-		free(lru_w);
+		git__free(lru_w);
 		ctl.open_windows--;
 
 		return GIT_SUCCESS;
@@ -191,7 +191,7 @@ static git_mwindow *new_window(git_mwindow_file *mwf, git_file fd, git_off_t siz
 	return w;
 
 cleanup:
-	free(w);
+	git__free(w);
 	return NULL;
 }
 

src/netops.c

@@ -190,7 +190,7 @@ int gitno_extract_host_and_port(char **host, char **port, const char *url, const
 	delim = colon == NULL ? slash : colon;
 	*host = git__strndup(url, delim - url);
 	if (*host == NULL) {
-		free(*port);
+		git__free(*port);
 		error = GIT_ENOMEM;
 	}
 

src/object.c

@@ -213,7 +213,7 @@ void git_object__free(void *_obj)
 		break;
 
 	default:
-		free(object);
+		git__free(object);
 		break;
 	}
 }

src/odb.c

@@ -83,8 +83,8 @@ static void free_odb_object(void *o)
 	git_odb_object *object = (git_odb_object *)o;
 
 	if (object != NULL) {
-		free(object->raw.data);
-		free(object);
+		git__free(object->raw.data);
+		git__free(object);
 	}
 }
 
@@ -205,8 +205,8 @@ static void fake_wstream__free(git_odb_stream *_stream)
 {
 	fake_wstream *stream = (fake_wstream *)_stream;
 
-	free(stream->buffer);
-	free(stream);
+	git__free(stream->buffer);
+	git__free(stream);
 }
 
 static int init_fake_wstream(git_odb_stream **stream_p, git_odb_backend *backend, size_t size, git_otype type)
@@ -221,7 +221,7 @@ static int init_fake_wstream(git_odb_stream **stream_p, git_odb_backend *backend
 	stream->type = type;
 	stream->buffer = git__malloc(size);
 	if (stream->buffer == NULL) {
-		free(stream);
+		git__free(stream);
 		return GIT_ENOMEM;
 	}
 
@@ -265,12 +265,12 @@ int git_odb_new(git_odb **out)
 
 	error = git_cache_init(&db->cache, GIT_DEFAULT_CACHE_SIZE, &free_odb_object);
 	if (error < GIT_SUCCESS) {
-		free(db);
+		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) {
-		free(db);
+		git__free(db);
 		return git__rethrow(error, "Failed to create object database");
 	}
 
@@ -296,7 +296,7 @@ static int add_backend_internal(git_odb *odb, git_odb_backend *backend, int prio
 	internal->is_alternate = is_alternate;
 
 	if (git_vector_insert(&odb->backends, internal) < 0) {
-		free(internal);
+		git__free(internal);
 		return GIT_ENOMEM;
 	}
 
@@ -421,14 +421,14 @@ void git_odb_close(git_odb *db)
 		git_odb_backend *backend = internal->backend;
 
 		if (backend->free) backend->free(backend);
-		else free(backend);
+		else git__free(backend);
 
-		free(internal);
+		git__free(internal);
 	}
 
 	git_vector_free(&db->backends);
 	git_cache_free(&db->cache);
-	free(db);
+	git__free(db);
 }
 
 int git_odb_exists(git_odb *db, const git_oid *id)

src/odb_loose.c

@@ -277,7 +277,7 @@ static void *inflate_tail(z_stream *s, void *hb, size_t used, obj_hdr *hdr)
 	else {
 		set_stream_output(s, buf + used, hdr->size - used);
 		if (finish_inflate(s)) {
-			free(buf);
+			git__free(buf);
 			return NULL;
 		}
 	}
@@ -317,7 +317,7 @@ static int inflate_packlike_loose_disk_obj(git_rawobj *out, git_fbuffer *obj)
 	in = ((unsigned char *)obj->data) + used;
 	len = obj->len - used;
 	if (inflate_buffer(in, len, buf, hdr.size)) {
-		free(buf);
+		git__free(buf);
 		return git__throw(GIT_ERROR, "Failed to inflate loose object. Could not inflate buffer");
 	}
 	buf[hdr.size] = '\0';
@@ -686,7 +686,7 @@ static void loose_backend__stream_free(git_odb_stream *_stream)
 	if (!stream->finished)
 		git_filebuf_cleanup(&stream->fbuf);
 
-	free(stream);
+	git__free(stream);
 }
 
 static int format_object_header(char *hdr, size_t n, size_t obj_len, git_otype obj_type)
@@ -739,14 +739,14 @@ static int loose_backend__stream(git_odb_stream **stream_out, git_odb_backend *_
 		(backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT));
 
 	if (error < GIT_SUCCESS) {
-		free(stream);
+		git__free(stream);
 		return git__rethrow(error, "Failed to create loose backend stream");
 	}
 
 	error = stream->stream.write((git_odb_stream *)stream, hdr, hdrlen);
 	if (error < GIT_SUCCESS) {
 		git_filebuf_cleanup(&stream->fbuf);
-		free(stream);
+		git__free(stream);
 		return git__rethrow(error, "Failed to create loose backend stream");
 	}
 
@@ -803,8 +803,8 @@ static void loose_backend__free(git_odb_backend *_backend)
 	assert(_backend);
 	backend = (loose_backend *)_backend;
 
-	free(backend->objects_dir);
-	free(backend);
+	git__free(backend->objects_dir);
+	git__free(backend);
 }
 
 int git_odb_backend_loose(
@@ -821,7 +821,7 @@ int git_odb_backend_loose(
 
 	backend->objects_dir = git__strdup(objects_dir);
 	if (backend->objects_dir == NULL) {
-		free(backend);
+		git__free(backend);
 		return GIT_ENOMEM;
 	}
 

src/odb_pack.c

@@ -231,7 +231,7 @@ static int packfile_load__cb(void *_data, char *path)
 		return git__rethrow(error, "Failed to load packfile");
 
 	if (git_vector_insert(&backend->packs, pack) < GIT_SUCCESS) {
-		free(pack);
+		git__free(pack);
 		return GIT_ENOMEM;
 	}
 
@@ -445,8 +445,8 @@ static void pack_backend__free(git_odb_backend *_backend)
 	}
 
 	git_vector_free(&backend->packs);
-	free(backend->pack_folder);
-	free(backend);
+	git__free(backend->pack_folder);
+	git__free(backend);
 }
 
 int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
@@ -459,7 +459,7 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
 		return GIT_ENOMEM;
 
 	if (git_vector_init(&backend->packs, 8, packfile_sort__cb) < GIT_SUCCESS) {
-		free(backend);
+		git__free(backend);
 		return GIT_ENOMEM;
 	}
 
@@ -469,7 +469,7 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
 		backend->pack_folder_mtime = 0;
 
 		if (backend->pack_folder == NULL) {
-			free(backend);
+			git__free(backend);
 			return GIT_ENOMEM;
 		}
 	}

src/oid.c

@@ -223,7 +223,7 @@ struct git_oid_shorten {
 
 static int resize_trie(git_oid_shorten *self, size_t new_size)
 {
-	self->nodes = realloc(self->nodes, new_size * sizeof(trie_node));
+	self->nodes = git__realloc(self->nodes, new_size * sizeof(trie_node));
 	if (self->nodes == NULL)
 		return GIT_ENOMEM;
 
@@ -270,7 +270,7 @@ git_oid_shorten *git_oid_shorten_new(size_t min_length)
 	memset(os, 0x0, sizeof(git_oid_shorten));
 
 	if (resize_trie(os, 16) < GIT_SUCCESS) {
-		free(os);
+		git__free(os);
 		return NULL;
 	}
 
@@ -282,8 +282,8 @@ git_oid_shorten *git_oid_shorten_new(size_t min_length)
 
 void git_oid_shorten_free(git_oid_shorten *os)
 {
-	free(os->nodes);
-	free(os);
+	git__free(os->nodes);
+	git__free(os);
 }
 
 

src/pack.c

@@ -181,7 +181,7 @@ static int pack_index_open(struct git_pack_file *p)
 	strcpy(idx_name + strlen(idx_name) - strlen(".pack"), ".idx");
 
 	error = pack_index_check(idx_name, p);
-	free(idx_name);
+	git__free(idx_name);
 
 	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to open index");
 }
@@ -297,7 +297,7 @@ static int packfile_unpack_delta(
 
 	error = packfile_unpack_compressed(&delta, p, w_curs, curpos, delta_size, delta_type);
 	if (error < GIT_SUCCESS) {
-		free(base.data);
+		git__free(base.data);
 		return git__rethrow(error, "Corrupted delta");
 	}
 
@@ -306,8 +306,8 @@ static int packfile_unpack_delta(
 			base.data, base.len,
 			delta.data, delta.len);
 
-	free(base.data);
-	free(delta.data);
+	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);
@@ -390,7 +390,7 @@ int packfile_unpack_compressed(
 
 	st = inflateInit(&stream);
 	if (st != Z_OK) {
-		free(buffer);
+		git__free(buffer);
 		return git__throw(GIT_EZLIB, "Error in zlib");
 	}
 
@@ -408,7 +408,7 @@ int packfile_unpack_compressed(
 	inflateEnd(&stream);
 
 	if ((st != Z_STREAM_END) || stream.total_out != size) {
-		free(buffer);
+		git__free(buffer);
 		return git__throw(GIT_EZLIB, "Error in zlib");
 	}
 
@@ -504,8 +504,8 @@ void packfile_free(struct git_pack_file *p)
 
 	pack_index_free(p);
 
-	free(p->bad_object_sha1);
-	free(p);
+	git__free(p->bad_object_sha1);
+	git__free(p);
 }
 
 static int packfile_open(struct git_pack_file *p)
@@ -598,7 +598,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
 	 */
 	path_len -= strlen(".idx");
 	if (path_len < 1) {
-		free(p);
+		git__free(p);
 		return git__throw(GIT_ENOTFOUND, "Failed to check packfile. Wrong path name");
 	}
 
@@ -610,7 +610,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
 
 	strcpy(p->pack_name + path_len, ".pack");
 	if (p_stat(p->pack_name, &st) < GIT_SUCCESS || !S_ISREG(st.st_mode)) {
-		free(p);
+		git__free(p);
 		return git__throw(GIT_ENOTFOUND, "Failed to check packfile. File not found");
 	}
 

src/path.c

@@ -144,7 +144,7 @@ char *git_path_dirname(const char *path)
 		return NULL;
 
 	if (git_path_dirname_r(dname, len, path) < GIT_SUCCESS) {
-		free(dname);
+		git__free(dname);
 		return NULL;
 	}
 
@@ -162,7 +162,7 @@ char *git_path_basename(const char *path)
 		return NULL;
 
 	if (git_path_basename_r(bname, len, path) < GIT_SUCCESS) {
-		free(bname);
+		git__free(bname);
 		return NULL;
 	}
 

src/pkt.c

@@ -149,7 +149,7 @@ static int ref_pkt(git_pkt **out, const char *line, size_t len)
 
 out:
 	if (error < GIT_SUCCESS)
-		free(pkt);
+		git__free(pkt);
 	else
 		*out = (git_pkt *)pkt;
 
@@ -260,10 +260,10 @@ void git_pkt_free(git_pkt *pkt)
 {
 	if(pkt->type == GIT_PKT_REF) {
 		git_pkt_ref *p = (git_pkt_ref *) pkt;
-		free(p->head.name);
+		git__free(p->head.name);
 	}
 
-	free(pkt);
+	git__free(pkt);
 }
 
 int git_pkt_buffer_flush(git_buf *buf)

src/pqueue.c

@@ -17,7 +17,7 @@ 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 = malloc((n + 1) * sizeof(void *))) == NULL)
+	if ((q->d = git__malloc((n + 1) * sizeof(void *))) == NULL)
 		return GIT_ENOMEM;
 
 	q->size = 1;
@@ -30,7 +30,7 @@ int git_pqueue_init(git_pqueue *q, size_t n, git_pqueue_cmp cmppri)
 
 void git_pqueue_free(git_pqueue *q)
 {
-	free(q->d);
+	git__free(q->d);
 	q->d = NULL;
 }
 
@@ -102,7 +102,7 @@ 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 = realloc(q->d, sizeof(void *) * newsize)) == NULL)
+		if ((tmp = git__realloc(q->d, sizeof(void *) * newsize)) == NULL)
 			return GIT_ENOMEM;
 
 		q->d = tmp;

src/reflog.c

@@ -25,8 +25,8 @@ static int reflog_init(git_reflog **reflog, git_reference *ref)
 	log->ref_name = git__strdup(ref->name);
 
 	if (git_vector_init(&log->entries, 0, NULL) < 0) {
-		free(log->ref_name);
-		free(log);
+		git__free(log->ref_name);
+		git__free(log);
 		return GIT_ENOMEM;
 	}
 
@@ -86,8 +86,8 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size)
 #define seek_forward(_increase) { \
 	if (_increase >= buf_size) { \
 		if (entry->committer) \
-			free(entry->committer); \
-		free(entry); \
+			git__free(entry->committer); \
+		git__free(entry); \
 		return git__throw(GIT_ERROR, "Failed to seek forward. Buffer size exceeded"); \
 	} \
 	buf += _increase; \
@@ -101,13 +101,13 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size)
 		entry->committer = NULL;
 
 		if (git_oid_fromstrn(&entry->oid_old, buf, GIT_OID_HEXSZ) < GIT_SUCCESS) {
-			free(entry);
+			git__free(entry);
 			return GIT_ERROR;
 		}
 		seek_forward(GIT_OID_HEXSZ + 1);
 
 		if (git_oid_fromstrn(&entry->oid_cur, buf, GIT_OID_HEXSZ) < GIT_SUCCESS) {
-			free(entry);
+			git__free(entry);
 			return GIT_ERROR;
 		}
 		seek_forward(GIT_OID_HEXSZ + 1);
@@ -120,13 +120,13 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size)
 
 		entry->committer = git__malloc(sizeof(git_signature));
 		if (entry->committer == NULL) {
-			free(entry);
+			git__free(entry);
 			return GIT_ENOMEM;
 		}
 
 		if ((error = git_signature__parse(entry->committer, &ptr, buf + 1, NULL, *buf)) < GIT_SUCCESS) {
-			free(entry->committer);
-			free(entry);
+			git__free(entry->committer);
+			git__free(entry);
 			return git__rethrow(error, "Failed to parse reflog. Could not parse signature");
 		}
 
@@ -164,13 +164,13 @@ void git_reflog_free(git_reflog *reflog)
 
 		git_signature_free(entry->committer);
 
-		free(entry->msg);
-		free(entry);
+		git__free(entry->msg);
+		git__free(entry);
 	}
 
 	git_vector_free(&reflog->entries);
-	free(reflog->ref_name);
-	free(reflog);
+	git__free(reflog->ref_name);
+	git__free(reflog);
 }
 
 int git_reflog_read(git_reflog **reflog, git_reference *ref)

src/refs.c

@@ -77,12 +77,12 @@ static void reference_free(git_reference *reference)
 		return;
 
 	if (reference->name)
-		free(reference->name);
+		git__free(reference->name);
 
 	if (reference->type == GIT_REF_SYMBOLIC)
-		free(((reference_symbolic *)reference)->target);
+		git__free(((reference_symbolic *)reference)->target);
 
-	free(reference);
+	git__free(reference);
 }
 
 static int reference_create(
@@ -212,7 +212,7 @@ static int loose_parse_symbolic(git_reference *ref, git_fbuffer *file_content)
 
 	refname_start += header_len;
 
-	free(ref_sym->target);
+	git__free(ref_sym->target);
 	ref_sym->target = git__strdup(refname_start);
 	if (ref_sym->target == NULL)
 		return GIT_ENOMEM;
@@ -1203,7 +1203,7 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id)
 
 		ref_old->ref.name = git__strdup(ref->name);
 		if (ref_old->ref.name == NULL) {
-			free(ref_old);
+			git__free(ref_old);
 			return GIT_ENOMEM;
 		}
 	}
@@ -1252,7 +1252,7 @@ int git_reference_set_target(git_reference *ref, const char *target)
 
 	ref_sym = (reference_symbolic *)ref;
 
-	free(ref_sym->target);
+	git__free(ref_sym->target);
 	ref_sym->target = git__strdup(target);
 	if (ref_sym->target == NULL)
 		return GIT_ENOMEM;
@@ -1381,7 +1381,7 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force)
 			goto rollback;
 	}
 
-	free(ref->name);
+	git__free(ref->name);
 	ref->name = new_ref->name;
 
 	/*
@@ -1408,7 +1408,7 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force)
 			goto rollback;
 
 cleanup:
-	free(old_name);
+	git__free(old_name);
 	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to rename reference");
 
 rollback:

src/refspec.c

@@ -32,7 +32,7 @@ int git_refspec_parse(git_refspec *refspec, const char *str)
 
 	refspec->dst = git__strdup(delim + 1);
 	if (refspec->dst == NULL) {
-		free(refspec->src);
+		git__free(refspec->src);
 		refspec->src = NULL;
 		return GIT_ENOMEM;
 	}

src/remote.c

@@ -36,7 +36,7 @@ static int refspec_parse(git_refspec *refspec, const char *str)
 
 	refspec->dst = git__strdup(delim + 1);
 	if (refspec->dst == NULL) {
-		free(refspec->src);
+		git__free(refspec->src);
 		refspec->src = NULL;
 		return GIT_ENOMEM;
 	}
@@ -68,7 +68,7 @@ int git_remote_new(git_remote **out, git_repository *repo, const char *url)
 	remote->repo = repo;
 	remote->url = git__strdup(url);
 	if (remote->url == NULL) {
-		free(remote);
+		git__free(remote);
 		return GIT_ENOMEM;
 	}
 
@@ -150,7 +150,7 @@ int git_remote_get(git_remote **out, git_config *cfg, const char *name)
 	*out = remote;
 
 cleanup:
-	free(buf);
+	git__free(buf);
 	if (error < GIT_SUCCESS)
 		git_remote_free(remote);
 
@@ -260,17 +260,17 @@ void git_remote_free(git_remote *remote)
 	if (remote == NULL)
 		return;
 
-	free(remote->fetch.src);
-	free(remote->fetch.dst);
-	free(remote->push.src);
-	free(remote->push.dst);
-	free(remote->url);
-	free(remote->name);
+	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);
 	if (remote->transport != NULL) {
 		if (remote->transport->connected)
 			remote->transport->close(remote->transport);
 
 		remote->transport->free(remote->transport);
 	}
-	free(remote);
+	git__free(remote);
 }

src/repository.c

@@ -168,12 +168,12 @@ static git_repository *repository_alloc(void)
 
 	error = git_cache_init(&repo->objects, GIT_DEFAULT_CACHE_SIZE, &git_object__free);
 	if (error < GIT_SUCCESS) {
-		free(repo);
+		git__free(repo);
 		return NULL;
 	}
 
 	if (git_repository__refcache_init(&repo->references) < GIT_SUCCESS) {
-		free(repo);
+		git__free(repo);
 		return NULL;
 	}
 
@@ -467,13 +467,13 @@ static int read_gitfile(char *path_out, const char *file_path, const char *base_
 
 static void git_repository__free_dirs(git_repository *repo)
 {
-	free(repo->path_workdir);
+	git__free(repo->path_workdir);
 	repo->path_workdir = NULL;
-	free(repo->path_index);
+	git__free(repo->path_index);
 	repo->path_index = NULL;
-	free(repo->path_repository);
+	git__free(repo->path_repository);
 	repo->path_repository = NULL;
-	free(repo->path_odb);
+	git__free(repo->path_odb);
 	repo->path_odb = NULL;
 }
 
@@ -489,7 +489,7 @@ void git_repository_free(git_repository *repo)
 	if (repo->db != NULL)
 		git_odb_close(repo->db);
 
-	free(repo);
+	git__free(repo);
 }
 
 int git_repository_discover(char *repository_path, size_t size, const char *start_path, int across_fs, const char *ceiling_dirs)

src/revwalk.c

@@ -68,7 +68,7 @@ static void commit_list_free(commit_list **list_p)
 	while (list) {
 		commit_list *temp = list;
 		list = temp->next;
-		free(temp);
+		git__free(temp);
 	}
 
 	*list_p = NULL;
@@ -81,7 +81,7 @@ static commit_object *commit_list_pop(commit_list **stack)
 
 	if (top) {
 		*stack = top->next;
-		free(top);
+		git__free(top);
 	}
 	return item;
 }
@@ -156,7 +156,7 @@ 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) {
-		free(commit);
+		git__free(commit);
 		return NULL;
 	}
 
@@ -442,7 +442,7 @@ int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
 			(git_hash_keyeq_ptr)git_oid_cmp);
 
 	if (walk->commits == NULL) {
-		free(walk);
+		git__free(walk);
 		return GIT_ENOMEM;
 	}
 
@@ -475,17 +475,17 @@ void git_revwalk_free(git_revwalk *walk)
 	 * make sure it's being free'd */
 	GIT_HASHTABLE_FOREACH(walk->commits, _unused, commit, {
 		if (commit->out_degree > PARENTS_PER_COMMIT)
-			free(commit->parents);
+			git__free(commit->parents);
 	});
 
 	git_hashtable_free(walk->commits);
 	git_pqueue_free(&walk->iterator_time);
 
 	for (i = 0; i < walk->memory_alloc.length; ++i)
-		free(git_vector_get(&walk->memory_alloc, i));
+		git__free(git_vector_get(&walk->memory_alloc, i));
 
 	git_vector_free(&walk->memory_alloc);
-	free(walk);
+	git__free(walk);
 }
 
 git_repository *git_revwalk_repository(git_revwalk *walk)

src/signature.c

@@ -15,9 +15,9 @@ void git_signature_free(git_signature *sig)
 	if (sig == NULL)
 		return;
 
-	free(sig->name);
-	free(sig->email);
-	free(sig);
+	git__free(sig->name);
+	git__free(sig->email);
+	git__free(sig);
 }
 
 static const char *skip_leading_spaces(const char *buffer, const char *buffer_end)

src/status.c

@@ -229,7 +229,7 @@ static int store_if_changed(struct status_st *st, struct status_entry *e)
 			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 (e->status_flags == GIT_STATUS_CURRENT) {
-		free(e);
+		git__free(e);
 		return GIT_SUCCESS;
 	}
 
@@ -446,7 +446,7 @@ int git_status_foreach(git_repository *repo, int (*callback)(const char *, unsig
 				error = git__rethrow(error, "Failed to determine statuses. User callback failed");
 		}
 
-		free(e);
+		git__free(e);
 	}
 
 exit:
@@ -550,7 +550,7 @@ int git_status_file(unsigned int *status_flags, git_repository *repo, const char
 
 exit:
 	git_tree_close(tree);
-	free(e);
+	git__free(e);
 	return error;
 }
 
@@ -606,7 +606,7 @@ static int alphasorted_dirent_cb(void *state, char *full_path)
 		return GIT_ENOMEM;
 
 	if (git_vector_insert(entry_names, entry) < GIT_SUCCESS) {
-		free(entry);
+		git__free(entry);
 		return GIT_ENOMEM;
 	}
 
@@ -639,7 +639,7 @@ static int alphasorted_futils_direach(
 			error = fn(arg, entry->path);
 		}
 
-		free(entry);
+		git__free(entry);
 	}
 
 	git_vector_free(&entry_names);

src/tag.c

@@ -16,9 +16,9 @@
 void git_tag__free(git_tag *tag)
 {
 	git_signature_free(tag->tagger);
-	free(tag->message);
-	free(tag->tag_name);
-	free(tag);
+	git__free(tag->message);
+	git__free(tag->tag_name);
+	git__free(tag);
 }
 
 const git_oid *git_tag_id(git_tag *c)
@@ -341,8 +341,8 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 		error = git_reference_set_oid(new_ref, oid);
 
 	git_signature_free(tag.tagger);
-	free(tag.tag_name);
-	free(tag.message);
+	git__free(tag.tag_name);
+	git__free(tag.message);
 
 	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create tag");
 }

src/transports/git.c

@@ -109,8 +109,8 @@ static int do_connect(transport_git *t, const char *url)
 	error = send_request(s, NULL, url);
 	t->socket = s;
 
-	free(host);
-	free(port);
+	git__free(host);
+	git__free(port);
 
 	if (error < GIT_SUCCESS && s > 0)
 		close(s);
@@ -357,11 +357,11 @@ static int git_negotiate_fetch(git_transport *transport, git_repository *repo, g
 				gitno_consume(buf, line_end);
 
 				if (pkt->type == GIT_PKT_ACK) {
-					free(pkt);
+					git__free(pkt);
 					error = GIT_SUCCESS;
 					goto done;
 				} else if (pkt->type == GIT_PKT_NAK) {
-					free(pkt);
+					git__free(pkt);
 					break;
 				} else {
 					error = git__throw(GIT_ERROR, "Got unexpected pkt type");
@@ -424,12 +424,12 @@ static int git_download_pack(char **out, git_transport *transport, git_repositor
 				return error;
 
 			if (pkt->type == GIT_PKT_PACK) {
-				free(pkt);
+				git__free(pkt);
 				return git_fetch__download_pack(out, buf->data, buf->offset, t->socket, repo);
 			}
 
 			/* For now we don't care about anything */
-			free(pkt);
+			git__free(pkt);
 			gitno_consume(buf, line_end);
 		}
 
@@ -475,9 +475,9 @@ static void git_free(git_transport *transport)
 	}
 
 	git_vector_free(refs);
-	free(t->heads);
-	free(t->parent.url);
-	free(t);
+	git__free(t->heads);
+	git__free(t->parent.url);
+	git__free(t);
 }
 
 int git_transport_git(git_transport **out)

src/transports/http.c

@@ -389,18 +389,18 @@ static int on_body_parse_response(http_parser *parser, const char *str, size_t l
 		git_buf_consume(buf, line_end);
 
 		if (pkt->type == GIT_PKT_PACK) {
-			free(pkt);
+			git__free(pkt);
 			t->pack_ready = 1;
 			return 0;
 		}
 
 		if (pkt->type == GIT_PKT_NAK) {
-			free(pkt);
+			git__free(pkt);
 			return 0;
 		}
 
 		if (pkt->type != GIT_PKT_ACK) {
-			free(pkt);
+			git__free(pkt);
 			continue;
 		}
 
@@ -749,13 +749,13 @@ static void http_free(git_transport *transport)
 	}
 	git_vector_free(common);
 	git_buf_free(&t->buf);
-	free(t->heads);
-	free(t->content_type);
-	free(t->host);
-	free(t->port);
-	free(t->service);
-	free(t->parent.url);
-	free(t);
+	git__free(t->heads);
+	git__free(t->content_type);
+	git__free(t->host);
+	git__free(t->port);
+	git__free(t->service);
+	git__free(t->parent.url);
+	git__free(t);
 }
 
 int git_transport_http(git_transport **out)

src/transports/local.c

@@ -113,8 +113,8 @@ static int add_ref(const char *name, git_repository *repo, git_vector *vec)
  out:
 	git_object_close(obj);
 	if (error < GIT_SUCCESS) {
-		free(head->name);
-		free(head);
+		git__free(head->name);
+		git__free(head);
 	}
 	return error;
 }
@@ -190,16 +190,16 @@ static void local_free(git_transport *transport)
 
 	if (t->refs != NULL) {
 		git_vector_foreach (vec, i, h) {
-			free(h->name);
-			free(h);
+			git__free(h->name);
+			git__free(h);
 		}
 		git_vector_free(vec);
-		free(vec);
+		git__free(vec);
 	}
 
 	git_repository_free(t->repo);
-	free(t->parent.url);
-	free(t);
+	git__free(t->parent.url);
+	git__free(t);
 }
 
 /**************

src/tree-cache.c

@@ -196,6 +196,6 @@ void git_tree_cache_free(git_tree_cache *tree)
 	for (i = 0; i < tree->children_count; ++i)
 		git_tree_cache_free(tree->children[i]);
 
-	free(tree->children);
-	free(tree);
+	git__free(tree->children);
+	git__free(tree);
 }

src/tree.c

@@ -130,12 +130,12 @@ void git_tree__free(git_tree *tree)
 		git_tree_entry *e;
 		e = git_vector_get(&tree->entries, i);
 
-		free(e->filename);
-		free(e);
+		git__free(e->filename);
+		git__free(e);
 	}
 
 	git_vector_free(&tree->entries);
-	free(tree);
+	git__free(tree);
 }
 
 const git_oid *git_tree_id(git_tree *c)
@@ -378,7 +378,7 @@ static int write_tree(git_oid *oid, git_index *index, const char *dirname, unsig
 				last_comp = subdir;
 			}
 			error = append_entry(bld, last_comp, &sub_oid, S_IFDIR);
-			free(subdir);
+			git__free(subdir);
 			if (error < GIT_SUCCESS) {
 				error = git__rethrow(error, "Failed to insert dir");
 				goto cleanup;
@@ -441,7 +441,7 @@ int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source)
 		source_entries = source->entries.length;
 
 	if (git_vector_init(&bld->entries, source_entries, entry_sort_cmp) < GIT_SUCCESS) {
-		free(bld);
+		git__free(bld);
 		return GIT_ENOMEM;
 	}
 
@@ -596,8 +596,8 @@ void git_treebuilder_clear(git_treebuilder *bld)
 
 	for (i = 0; i < bld->entries.length; ++i) {
 		git_tree_entry *e = bld->entries.contents[i];
-		free(e->filename);
-		free(e);
+		git__free(e->filename);
+		git__free(e);
 	}
 
 	git_vector_clear(&bld->entries);
@@ -607,7 +607,7 @@ void git_treebuilder_free(git_treebuilder *bld)
 {
 	git_treebuilder_clear(bld);
 	git_vector_free(&bld->entries);
-	free(bld);
+	git__free(bld);
 }
 
 static int tree_frompath(git_tree **parent_out, git_tree *root, const char *treeentry_path, int offset)

src/tsort.c

@@ -178,7 +178,7 @@ static int check_invariant(struct tsort_run *stack, int stack_curr)
 static int resize(struct tsort_store *store, size_t new_size)
 {
 	if (store->alloc < new_size) {
-		void **tempstore = realloc(store->storage, new_size * sizeof(void *));
+		void **tempstore = git__realloc(store->storage, new_size * sizeof(void *));
 
 		/**
 		 * Do not propagate on OOM; this will abort the sort and
@@ -319,7 +319,7 @@ static ssize_t collapse(void **dst, struct tsort_run *stack, ssize_t stack_curr,
 			stack_curr--; \
 		} \
 		if (store->storage != NULL) {\
-			free(store->storage);\
+			git__free(store->storage);\
 			store->storage = NULL;\
 		}\
 		return;\

src/util.c

@@ -26,9 +26,9 @@ void git_strarray_free(git_strarray *array)
 {
 	size_t i;
 	for (i = 0; i < array->count; ++i)
-		free(array->strings[i]);
+		git__free(array->strings[i]);
 
-	free(array->strings);
+	git__free(array->strings);
 }
 
 int git__fnmatch(const char *pattern, const char *name, int flags)

src/util.h

@@ -72,6 +72,8 @@ GIT_INLINE(void *) git__realloc(void *ptr, size_t size)
 	return new_ptr;
 }
 
+#define git__free(ptr) free(ptr)
+
 extern int git__prefixcmp(const char *str, const char *prefix);
 extern int git__suffixcmp(const char *str, const char *suffix);
 

src/vector.c

@@ -18,7 +18,7 @@ static int resize_vector(git_vector *v)
 	if (v->_alloc_size < minimum_size)
 		v->_alloc_size = minimum_size;
 
-	v->contents = realloc(v->contents, v->_alloc_size * sizeof(void *));
+	v->contents = git__realloc(v->contents, v->_alloc_size * sizeof(void *));
 	if (v->contents == NULL)
 		return GIT_ENOMEM;
 
@@ -29,7 +29,7 @@ static int resize_vector(git_vector *v)
 void git_vector_free(git_vector *v)
 {
 	assert(v);
-	free(v->contents);
+	git__free(v->contents);
 }
 
 int git_vector_init(git_vector *v, unsigned int initial_size, git_vector_cmp cmp)

src/win32/dir.c

@@ -39,18 +39,18 @@ git__DIR *git__opendir(const char *dir)
 
 	new->dir = git__malloc(strlen(dir)+1);
 	if (!new->dir) {
-		free(new);
+		git__free(new);
 		return NULL;
 	}
 	strcpy(new->dir, dir);
 
 	filter_w = gitwin_to_utf16(filter);
 	new->h = FindFirstFileW(filter_w, &new->f);
-	free(filter_w);
+	git__free(filter_w);
 
 	if (new->h == INVALID_HANDLE_VALUE) {
-		free(new->dir);
-		free(new);
+		git__free(new->dir);
+		git__free(new);
 		return NULL;
 	}
 	new->first = 1;
@@ -93,7 +93,7 @@ void git__rewinddir(git__DIR *d)
 		if (init_filter(filter, sizeof(filter), d->dir)) {
 			filter_w = gitwin_to_utf16(filter);
 			d->h = FindFirstFileW(filter_w, &d->f);
-			free(filter_w);
+			git__free(filter_w);
 
 			if (d->h != INVALID_HANDLE_VALUE)
 				d->first = 1;
@@ -107,8 +107,8 @@ int git__closedir(git__DIR *d)
 		if (d->h != INVALID_HANDLE_VALUE)
 			FindClose(d->h);
 		if (d->dir)
-			free(d->dir);
-		free(d);
+			git__free(d->dir);
+		git__free(d);
 	}
 	return 0;
 }

src/win32/posix.h

@@ -26,7 +26,7 @@ GIT_INLINE(int) p_mkdir(const char *path, int GIT_UNUSED(mode))
 
 	GIT_UNUSED_ARG(mode)
 
-	free(buf);
+	git__free(buf);
 	return ret;
 }
 

src/win32/posix_w32.c

@@ -20,7 +20,7 @@ int p_unlink(const char *path)
 	buf = gitwin_to_utf16(path);
 	_wchmod(buf, 0666);
 	ret = _wunlink(buf);
-	free(buf);
+	git__free(buf);
 
 	return ret;
 }
@@ -86,11 +86,11 @@ static int do_lstat(const char *file_name, struct stat *buf)
 		buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
 		buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
 
-		free(fbuf);
+		git__free(fbuf);
 		return GIT_SUCCESS;
 	}
 
-	free(fbuf);
+	git__free(fbuf);
 
 	switch (GetLastError()) {
 		case ERROR_ACCESS_DENIED:
@@ -171,7 +171,7 @@ int p_readlink(const char *link, char *target, size_t target_len)
 			FILE_FLAG_BACKUP_SEMANTICS, // normal file
 			NULL);					// no attr. template
 
-	free(link_w);
+	git__free(link_w);
 
 	if (hFile == INVALID_HANDLE_VALUE)
 		return GIT_EOSERR;
@@ -184,17 +184,17 @@ int p_readlink(const char *link, char *target, size_t target_len)
 
 	dwRet = pGetFinalPath(hFile, target_w, target_len, 0x0);
 	if (dwRet >= target_len) {
-		free(target_w);
+		git__free(target_w);
 		CloseHandle(hFile);
 		return GIT_ENOMEM;
 	}
 
 	if (!WideCharToMultiByte(CP_UTF8, 0, target_w, -1, target, target_len * sizeof(char), NULL, NULL)) {
-		free(target_w);
+		git__free(target_w);
 		return GIT_EOSERR;
 	}
 
-	free(target_w);
+	git__free(target_w);
 	CloseHandle(hFile);
 
 	if (dwRet > 4) {
@@ -226,7 +226,7 @@ int p_open(const char *path, int flags)
 	wchar_t* buf = gitwin_to_utf16(path);
 	fd = _wopen(buf, flags | _O_BINARY);
 
-	free(buf);
+	git__free(buf);
 	return fd;
 }
 
@@ -236,7 +236,7 @@ int p_creat(const char *path, int mode)
 	wchar_t* buf = gitwin_to_utf16(path);
 	fd = _wopen(buf, _O_WRONLY | _O_CREAT | _O_TRUNC | _O_BINARY, mode);
 
-	free(buf);
+	git__free(buf);
 	return fd;
 }
 
@@ -246,11 +246,11 @@ int p_getcwd(char *buffer_out, size_t size)
 	_wgetcwd(buf, (int)size);
 
 	if (!WideCharToMultiByte(CP_UTF8, 0, buf, -1, buffer_out, size, NULL, NULL)) {
-		free(buf);
+		git__free(buf);
 		return GIT_EOSERR;
 	}
 
-	free(buf);
+	git__free(buf);
 	return GIT_SUCCESS;
 }
 
@@ -264,7 +264,7 @@ int p_chdir(const char* path)
 	wchar_t* buf = gitwin_to_utf16(path);
 	int ret = _wchdir(buf);
 
-	free(buf);
+	git__free(buf);
 	return ret;
 }
 
@@ -273,7 +273,7 @@ int p_chmod(const char* path, int mode)
 	wchar_t* buf = gitwin_to_utf16(path);
 	int ret = _wchmod(buf, mode);
 
-	free(buf);
+	git__free(buf);
 	return ret;
 }
 
@@ -282,7 +282,7 @@ int p_rmdir(const char* path)
 	wchar_t* buf = gitwin_to_utf16(path);
 	int ret = _wrmdir(buf);
 
-	free(buf);
+	git__free(buf);
 	return ret;
 }
 
@@ -294,7 +294,7 @@ int p_hide_directory__w32(const char *path)
 	error = SetFileAttributesW(buf, FILE_ATTRIBUTE_HIDDEN) != 0 ?
 		GIT_SUCCESS : GIT_ERROR; /* MSDN states a "non zero" value indicates a success */
 
-	free(buf);
+	git__free(buf);
 
 	if (error < GIT_SUCCESS)
 		error = git__throw(GIT_EOSERR, "Failed to hide directory '%s'", path);
@@ -314,21 +314,21 @@ char *p_realpath(const char *orig_path, char *buffer)
 	}
 
 	ret = GetFullPathNameW(orig_path_w, GIT_PATH_MAX, buffer_w, NULL);
-	free(orig_path_w);
+	git__free(orig_path_w);
 
 	if (!ret || ret > GIT_PATH_MAX) {
-		free(buffer_w);
-		if (alloc) free(buffer);
+		git__free(buffer_w);
+		if (alloc) git__free(buffer);
 
 		return NULL;
 	}
 
 	if (!WideCharToMultiByte(CP_UTF8, 0, buffer_w, -1, buffer, GIT_PATH_MAX, NULL, NULL)) {
-		free(buffer_w);
-		if (alloc) free(buffer);
+		git__free(buffer_w);
+		if (alloc) git__free(buffer);
 	}
 	
-	free(buffer_w);
+	git__free(buffer_w);
 	git_path_mkposix(buffer);
 	return buffer;
 }
@@ -384,7 +384,7 @@ int p_access(const char* path, int mode)
 	int ret;
 
 	ret = _waccess(buf, mode);
-	free(buf);
+	git__free(buf);
 
 	return ret;
 }

src/win32/utf-conv.c

@@ -50,7 +50,7 @@ wchar_t* gitwin_to_utf16(const char* str)
 	ret = (wchar_t*)git__malloc(cb);
 
 	if (MultiByteToWideChar(_active_codepage, 0, str, -1, ret, cb) == 0) {
-		free(ret);
+		git__free(ret);
 		ret = NULL;
 	}
 
@@ -79,7 +79,7 @@ char* gitwin_from_utf16(const wchar_t* str)
 	ret = (char*)git__malloc(cb);
 
 	if (WideCharToMultiByte(_active_codepage, 0, str, -1, ret, cb, NULL, NULL) == 0) {
-		free(ret);
+		git__free(ret);
 		ret = NULL;
 	}
 

tests-clay/core/path.c

@@ -11,7 +11,7 @@ check_dirname(const char *A, const char *B)
 	cl_assert((dir2 = git_path_dirname(A)) != NULL);
 	cl_assert(strcmp(dir2, B) == 0);
 
-	free(dir2);
+	git__free(dir2);
 }
 
 static void
@@ -24,7 +24,7 @@ check_basename(const char *A, const char *B)
 	cl_assert((base2 = git_path_basename(A)) != NULL);
 	cl_assert(strcmp(base2, B) == 0);
 
-	free(base2);
+	git__free(base2);
 }
 
 static void

tests-clay/core/vector.c

@@ -59,8 +59,8 @@ void test_core_vector__2(void)
 
 	git_vector_free(&x);
 
-	free(ptrs[0]);
-	free(ptrs[1]);
+	git__free(ptrs[0]);
+	git__free(ptrs[1]);
 }
 
 

tests-clay/object/raw/compare.c

@@ -101,7 +101,7 @@ void test_object_raw_compare__compare_allocfmt_oids(void)
 	out = git_oid_allocfmt(&in);
 	cl_assert(out);
 	cl_assert(strcmp(exp, out) == 0);
-	free(out);
+	git__free(out);
 }
 
 void test_object_raw_compare__compare_pathfmt_oids(void)

tests-clay/object/raw/short.c

@@ -86,7 +86,7 @@ void test_object_raw_short__oid_shortener_stresstest_git_oid_shorten(void)
 
 	/* cleanup */
 	for (i = 0; i < MAX_OIDS; ++i)
-		free(oids[i]);
+		git__free(oids[i]);
 
 	git_oid_shorten_free(os);
 

tests/t00-core.c

@@ -99,8 +99,8 @@ BEGIN_TEST(vector2, "remove duplicates")
 	must_be_true(x.length == 2);
 	git_vector_free(&x);
 
-	free(ptrs[0]);
-	free(ptrs[1]);
+	git__free(ptrs[0]);
+	git__free(ptrs[1]);
 END_TEST
 
 
@@ -112,7 +112,7 @@ BEGIN_TEST(path0, "get the dirname of a path")
 	must_be_true(strcmp(dir, B) == 0);				\
 	must_be_true((dir2 = git_path_dirname(A)) != NULL);	\
 	must_be_true(strcmp(dir2, B) == 0);				\
-	free(dir2);										\
+	git__free(dir2);										\
 }
 
 	DIRNAME_TEST(NULL, ".");
@@ -141,7 +141,7 @@ BEGIN_TEST(path1, "get the base name of a path")
 	must_be_true(strcmp(base, B) == 0);					\
 	must_be_true((base2 = git_path_basename(A)) != NULL);	\
 	must_be_true(strcmp(base2, B) == 0);				\
-	free(base2);										\
+	git__free(base2);										\
 }
 
 	BASENAME_TEST(NULL, ".");

tests/t01-rawobj.c

@@ -217,7 +217,7 @@ BEGIN_TEST(oid12, "compare oids (allocate + format)")
 	out = git_oid_allocfmt(&in);
 	must_be_true(out);
 	must_be_true(strcmp(exp, out) == 0);
-	free(out);
+	git__free(out);
 END_TEST
 
 BEGIN_TEST(oid13, "compare oids (path format)")
@@ -390,7 +390,7 @@ BEGIN_TEST(oid17, "stress test for the git_oid_shorten object")
 
 	/* cleanup */
 	for (i = 0; i < MAX_OIDS; ++i)
-		free(oids[i]);
+		git__free(oids[i]);
 
 	git_oid_shorten_free(os);
 

tests/t04-commit.c

@@ -162,7 +162,7 @@ BEGIN_TEST(parse1, "parse the signature line in a commit")
 	must_be_true(strcmp(_email, person.email) == 0);\
 	must_be_true(_time == person.when.time);\
 	must_be_true(_offset == person.when.offset);\
-	free(person.name); free(person.email);\
+	git__free(person.name); git__free(person.email);\
 }
 
 #define TEST_SIGNATURE_FAIL(_string, _header) { \
@@ -170,7 +170,7 @@ BEGIN_TEST(parse1, "parse the signature line in a commit")
 	size_t len = strlen(_string);\
 	git_signature person = {NULL, NULL, {0, 0}}; \
 	must_fail(git_signature__parse(&person, &ptr, ptr + len, _header, '\n'));\
-	free(person.name); free(person.email);\
+	git__free(person.name); git__free(person.email);\
 }
 
 	TEST_SIGNATURE_PASS(
@@ -759,7 +759,7 @@ BEGIN_TEST(root0, "create a root commit")
 	must_pass(git_reference_set_target(head, head_old));
 	must_pass(git_reference_delete(branch));
 	must_pass(remove_loose_object(REPOSITORY_FOLDER, (git_object *)commit));
-	free(head_old);
+	git__free(head_old);
 	git_commit_close(commit);
 	git_repository_free(repo);
 END_TEST

tests/t07-hashtable.c

@@ -103,7 +103,7 @@ BEGIN_TEST(table1, "fill the hashtable with random entries")
 	}
 
 	git_hashtable_free(table);
-	free(objects);
+	git__free(objects);
 
 END_TEST
 
@@ -145,7 +145,7 @@ BEGIN_TEST(table2, "make sure the table resizes automatically")
 	}
 
 	git_hashtable_free(table);
-	free(objects);
+	git__free(objects);
 
 END_TEST
 
@@ -179,7 +179,7 @@ BEGIN_TEST(tableit0, "iterate through all the contents of the table")
 		must_be_true(objects[i].visited);
 
 	git_hashtable_free(table);
-	free(objects);
+	git__free(objects);
 END_TEST
 
 

tests/test_helpers.c

@@ -116,7 +116,7 @@ int remove_loose_object(const char *repository_folder, git_object *object)
 		return -1;
 	}
 
-	free(full_path);
+	git__free(full_path);
 
 	return GIT_SUCCESS;
 }