src/reflog.c - third_party/libgit2 - Git at Google

 /*
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2,
  * as published by the Free Software Foundation.
  *
  * In addition to the permissions in the GNU General Public License,
  * the authors give you unlimited permission to link the compiled
  * version of this file into combinations with other programs,
  * and to distribute those combinations without any restriction
  * coming from the use of this file.  (The General Public License
  * restrictions do apply in other respects; for example, they cover
  * modification of the file, and distribution when not linked into
  * a combined executable.)
  *
  * This file is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; see the file COPYING.  If not, write to
  * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */

 #include "reflog.h"
 #include "repository.h"
 #include "filebuf.h"
 #include "signature.h"

 static int reflog_init(git_reflog **reflog, git_reference *ref)
 {
 	git_reflog *log;

 	*reflog = NULL;

 	log = git__malloc(sizeof(git_reflog));
 	if (log == NULL)
 		return GIT_ENOMEM;

 	memset(log, 0x0, sizeof(git_reflog));

 	log->ref_name = git__strdup(ref->name);

 	if (git_vector_init(&log->entries, 0, NULL) < 0) {
 		free(log->ref_name);
 		free(log);
 		return GIT_ENOMEM;
 	}

 	*reflog = log;

 	return GIT_SUCCESS;
 }

 static int reflog_write(git_repository *repo, const char *ref_name,
 		        const char *oid_old, const char *oid_new,
 		        const git_signature *committer, const char *msg)
 {
 	int error;
 	char log_path[GIT_PATH_MAX];
 	git_buf log = GIT_BUF_INIT;
 	git_filebuf fbuf;

 	assert(repo && ref_name && oid_old && oid_new && committer);

 	git_path_join_n(log_path, 3, repo->path_repository, GIT_REFLOG_DIR, ref_name);

 	if (git_futils_exists(log_path)) {
 		if ((error = git_futils_mkpath2file(log_path)) < GIT_SUCCESS)
 			return git__rethrow(error, "Failed to write reflog. Cannot create reflog directory");

 	} else if (git_futils_isfile(log_path))
 		return git__throw(GIT_ERROR, "Failed to write reflog. `%s` is directory", log_path);

 	git_buf_puts(&log, oid_old);
 	git_buf_putc(&log, ' ');

 	git_buf_puts(&log, oid_new);

 	git_signature__writebuf(&log, " ", committer);
 	log.size--; /* drop LF */

 	if (msg) {
 		if (strchr(msg, '\n')) {
 			git_buf_free(&log);
 			return git__throw(GIT_ERROR, "Reflog message cannot contain newline");
 		}

 		git_buf_putc(&log, '\t');
 		git_buf_puts(&log, msg);
 	}

 	git_buf_putc(&log, '\n');

 	if ((error = git_filebuf_open(&fbuf, log_path, GIT_FILEBUF_APPEND)) < GIT_SUCCESS) {
 		git_buf_free(&log);
 		return git__throw(GIT_ERROR, "Failed to write reflog. Cannot open reflog `%s`", log_path);
 	}

 	git_filebuf_write(&fbuf, log.ptr, log.size);
 	error = git_filebuf_commit(&fbuf);

 	git_buf_free(&log);
 	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write reflog");
 }

 static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size)
 {
 	int error = GIT_SUCCESS;
 	const char *ptr;
 	git_reflog_entry *entry;

 #define seek_forward(_increase) { \
 	if (_increase >= buf_size) \
 		return git__throw(GIT_ERROR, "Failed to seek forward. Buffer size exceeded"); \
 	buf += _increase; \
 	buf_size -= _increase; \
 }

 	while (buf_size > GIT_REFLOG_SIZE_MIN) {
 		entry = git__malloc(sizeof(git_reflog_entry));
 		if (entry == NULL)
 			return GIT_ENOMEM;

 		entry->oid_old = git__strndup(buf, GIT_OID_HEXSZ);
 		seek_forward(GIT_OID_HEXSZ + 1);

 		entry->oid_cur = git__strndup(buf, GIT_OID_HEXSZ);
 		seek_forward(GIT_OID_HEXSZ + 1);

 		ptr = buf;

 		/* Seek forward to the end of the signature. */
 		while (*buf && *buf != '\t' && *buf != '\n')
 			seek_forward(1);

 		entry->committer = git__malloc(sizeof(git_signature));
 		if (entry->committer == NULL)
 			return GIT_ENOMEM;

 		if ((error = git_signature__parse(entry->committer, &ptr, buf + 1, NULL, *buf)) < GIT_SUCCESS)
 			goto cleanup;

 		if (*buf == '\t') {
 			/* We got a message. Read everything till we reach LF. */
 			seek_forward(1);
 			entry->msg = (char *)buf;

 			while (*buf && *buf != '\n')
 				seek_forward(1);

 			entry->msg = git__strndup(entry->msg, buf - entry->msg);
 		} else
 			entry->msg = NULL;

 		while (*buf && *buf == '\n' && buf_size > 1)
 			seek_forward(1);

 		if ((error = git_vector_insert(&log->entries, entry)) < GIT_SUCCESS)
 			goto cleanup;
 	}

 #undef seek_forward

 cleanup:
 	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse reflog");
 }

 void git_reflog_free(git_reflog *reflog)
 {
 	unsigned int i;
 	git_reflog_entry *entry;

 	for (i=0; i < reflog->entries.length; i++) {
 		entry = git_vector_get(&reflog->entries, i);

 		free(entry->oid_old);
 		free(entry->oid_cur);

 		git_signature_free(entry->committer);

 		free(entry->msg);
 		free(entry);
 	}

 	git_vector_free(&reflog->entries);
 	free(reflog->ref_name);
 	free(reflog);
 }

 int git_reflog_read(git_reflog **reflog, git_reference *ref)
 {
 	int error;
 	char log_path[GIT_PATH_MAX];
 	git_fbuffer log_file = GIT_FBUFFER_INIT;
 	git_reflog *log = NULL;

 	*reflog = NULL;

 	if ((error = reflog_init(&log, ref)) < GIT_SUCCESS)
 		return git__rethrow(error, "Failed to read reflog. Cannot init reflog");

 	git_path_join_n(log_path, 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name);

 	if ((error = git_futils_readbuffer(&log_file, log_path)) < GIT_SUCCESS)
 		return git__rethrow(error, "Failed to read reflog. Cannot read file `%s`", log_path);

 	error = reflog_parse(log, log_file.data, log_file.len);

 	git_futils_freebuffer(&log_file);

 	if (error == GIT_SUCCESS)
 		*reflog = log;

 	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to read reflog");
 }

 int git_reflog_write(git_reference *ref, const git_oid *oid_old,
 		     const git_signature *committer, const char *msg)
 {
 	int error;
 	char old[GIT_OID_HEXSZ+1];
 	char new[GIT_OID_HEXSZ+1];
 	git_reference *r;
 	const git_oid *oid;

 	if ((error = git_reference_resolve(&r, ref)) < GIT_SUCCESS)
 		return git__rethrow(error, "Failed to write reflog. Cannot resolve reference `%s`", ref->name);

 	oid = git_reference_oid(r);
 	if (oid == NULL)
 		return git__throw(GIT_ERROR, "Failed to write reflog. Cannot resolve reference `%s`", r->name);

 	git_oid_to_string(new, GIT_OID_HEXSZ+1, oid);

 	if (oid_old)
 		git_oid_to_string(old, GIT_OID_HEXSZ+1, oid_old);
 	else
 		snprintf(old, GIT_OID_HEXSZ+1, "%0*d", GIT_OID_HEXSZ, 0);

 	return reflog_write(ref->owner, ref->name, old, new, committer, msg);
 }

 unsigned int git_reflog_entrycount(git_reflog *reflog)
 {
 	assert(reflog);
 	return reflog->entries.length;
 }

 const git_reflog_entry * git_reflog_entry_byindex(git_reflog *reflog, unsigned int idx)
 {
 	assert(reflog);
 	return git_vector_get(&reflog->entries, idx);
 }

 char * git_reflog_entry_oidold(const git_reflog_entry *entry)
 {
 	assert(entry);
 	return entry->oid_old;
 }

 char * git_reflog_entry_oidnew(const git_reflog_entry *entry)
 {
 	assert(entry);
 	return entry->oid_cur;
 }

 git_signature * git_reflog_entry_committer(const git_reflog_entry *entry)
 {
 	assert(entry);
 	return entry->committer;
 }

 char * git_reflog_entry_msg(const git_reflog_entry *entry)
 {
 	assert(entry);
 	return entry->msg;
 }
	/*
	* This file is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License, version 2,
	* as published by the Free Software Foundation.
	*
	* In addition to the permissions in the GNU General Public License,
	* the authors give you unlimited permission to link the compiled
	* version of this file into combinations with other programs,
	* and to distribute those combinations without any restriction
	* coming from the use of this file. (The General Public License
	* restrictions do apply in other respects; for example, they cover
	* modification of the file, and distribution when not linked into
	* a combined executable.)
	*
	* This file is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; see the file COPYING. If not, write to
	* the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	* Boston, MA 02110-1301, USA.
	*/

	#include "reflog.h"
	#include "repository.h"
	#include "filebuf.h"
	#include "signature.h"

	static int reflog_init(git_reflog *reflog, git_reference ref)
	{
	git_reflog *log;

	*reflog = NULL;

	log = git__malloc(sizeof(git_reflog));
	if (log == NULL)
	return GIT_ENOMEM;

	memset(log, 0x0, sizeof(git_reflog));

	log->ref_name = git__strdup(ref->name);

	if (git_vector_init(&log->entries, 0, NULL) < 0) {
	free(log->ref_name);
	free(log);
	return GIT_ENOMEM;
	}

	*reflog = log;

	return GIT_SUCCESS;
	}

	static int reflog_write(git_repository repo, const char ref_name,
	const char oid_old, const char oid_new,
	const git_signature committer, const char msg)
	{
	int error;
	char log_path[GIT_PATH_MAX];
	git_buf log = GIT_BUF_INIT;
	git_filebuf fbuf;

	assert(repo && ref_name && oid_old && oid_new && committer);

	git_path_join_n(log_path, 3, repo->path_repository, GIT_REFLOG_DIR, ref_name);

	if (git_futils_exists(log_path)) {
	if ((error = git_futils_mkpath2file(log_path)) < GIT_SUCCESS)
	return git__rethrow(error, "Failed to write reflog. Cannot create reflog directory");

	} else if (git_futils_isfile(log_path))
	return git__throw(GIT_ERROR, "Failed to write reflog. `%s` is directory", log_path);

	git_buf_puts(&log, oid_old);
	git_buf_putc(&log, ' ');

	git_buf_puts(&log, oid_new);

	git_signature__writebuf(&log, " ", committer);
	log.size--; /* drop LF */

	if (msg) {
	if (strchr(msg, '\n')) {
	git_buf_free(&log);
	return git__throw(GIT_ERROR, "Reflog message cannot contain newline");
	}

	git_buf_putc(&log, '\t');
	git_buf_puts(&log, msg);
	}

	git_buf_putc(&log, '\n');

	if ((error = git_filebuf_open(&fbuf, log_path, GIT_FILEBUF_APPEND)) < GIT_SUCCESS) {
	git_buf_free(&log);
	return git__throw(GIT_ERROR, "Failed to write reflog. Cannot open reflog `%s`", log_path);
	}

	git_filebuf_write(&fbuf, log.ptr, log.size);
	error = git_filebuf_commit(&fbuf);

	git_buf_free(&log);
	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write reflog");
	}

	static int reflog_parse(git_reflog log, const char buf, size_t buf_size)
	{
	int error = GIT_SUCCESS;
	const char *ptr;
	git_reflog_entry *entry;

	#define seek_forward(_increase) { \
	if (_increase >= buf_size) \
	return git__throw(GIT_ERROR, "Failed to seek forward. Buffer size exceeded"); \
	buf += _increase; \
	buf_size -= _increase; \
	}

	while (buf_size > GIT_REFLOG_SIZE_MIN) {
	entry = git__malloc(sizeof(git_reflog_entry));
	if (entry == NULL)
	return GIT_ENOMEM;

	entry->oid_old = git__strndup(buf, GIT_OID_HEXSZ);
	seek_forward(GIT_OID_HEXSZ + 1);

	entry->oid_cur = git__strndup(buf, GIT_OID_HEXSZ);
	seek_forward(GIT_OID_HEXSZ + 1);

	ptr = buf;

	/* Seek forward to the end of the signature. */
	while (buf && buf != '\t' && *buf != '\n')
	seek_forward(1);

	entry->committer = git__malloc(sizeof(git_signature));
	if (entry->committer == NULL)
	return GIT_ENOMEM;

	if ((error = git_signature__parse(entry->committer, &ptr, buf + 1, NULL, *buf)) < GIT_SUCCESS)
	goto cleanup;

	if (*buf == '\t') {
	/* We got a message. Read everything till we reach LF. */
	seek_forward(1);
	entry->msg = (char *)buf;

	while (buf && buf != '\n')
	seek_forward(1);

	entry->msg = git__strndup(entry->msg, buf - entry->msg);
	} else
	entry->msg = NULL;

	while (buf && buf == '\n' && buf_size > 1)
	seek_forward(1);

	if ((error = git_vector_insert(&log->entries, entry)) < GIT_SUCCESS)
	goto cleanup;
	}

	#undef seek_forward

	cleanup:
	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse reflog");
	}

	void git_reflog_free(git_reflog *reflog)
	{
	unsigned int i;
	git_reflog_entry *entry;

	for (i=0; i < reflog->entries.length; i++) {
	entry = git_vector_get(&reflog->entries, i);

	free(entry->oid_old);
	free(entry->oid_cur);

	git_signature_free(entry->committer);

	free(entry->msg);
	free(entry);
	}

	git_vector_free(&reflog->entries);
	free(reflog->ref_name);
	free(reflog);
	}

	int git_reflog_read(git_reflog *reflog, git_reference ref)
	{
	int error;
	char log_path[GIT_PATH_MAX];
	git_fbuffer log_file = GIT_FBUFFER_INIT;
	git_reflog *log = NULL;

	*reflog = NULL;

	if ((error = reflog_init(&log, ref)) < GIT_SUCCESS)
	return git__rethrow(error, "Failed to read reflog. Cannot init reflog");

	git_path_join_n(log_path, 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name);

	if ((error = git_futils_readbuffer(&log_file, log_path)) < GIT_SUCCESS)
	return git__rethrow(error, "Failed to read reflog. Cannot read file `%s`", log_path);

	error = reflog_parse(log, log_file.data, log_file.len);

	git_futils_freebuffer(&log_file);

	if (error == GIT_SUCCESS)
	*reflog = log;

	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to read reflog");
	}

	int git_reflog_write(git_reference ref, const git_oid oid_old,
	const git_signature committer, const char msg)
	{
	int error;
	char old[GIT_OID_HEXSZ+1];
	char new[GIT_OID_HEXSZ+1];
	git_reference *r;
	const git_oid *oid;

	if ((error = git_reference_resolve(&r, ref)) < GIT_SUCCESS)
	return git__rethrow(error, "Failed to write reflog. Cannot resolve reference `%s`", ref->name);

	oid = git_reference_oid(r);
	if (oid == NULL)
	return git__throw(GIT_ERROR, "Failed to write reflog. Cannot resolve reference `%s`", r->name);

	git_oid_to_string(new, GIT_OID_HEXSZ+1, oid);

	if (oid_old)
	git_oid_to_string(old, GIT_OID_HEXSZ+1, oid_old);
	else
	snprintf(old, GIT_OID_HEXSZ+1, "%0*d", GIT_OID_HEXSZ, 0);

	return reflog_write(ref->owner, ref->name, old, new, committer, msg);
	}

	unsigned int git_reflog_entrycount(git_reflog *reflog)
	{
	assert(reflog);
	return reflog->entries.length;
	}

	const git_reflog_entry * git_reflog_entry_byindex(git_reflog *reflog, unsigned int idx)
	{
	assert(reflog);
	return git_vector_get(&reflog->entries, idx);
	}

	char * git_reflog_entry_oidold(const git_reflog_entry *entry)
	{
	assert(entry);
	return entry->oid_old;
	}

	char * git_reflog_entry_oidnew(const git_reflog_entry *entry)
	{
	assert(entry);
	return entry->oid_cur;
	}

	git_signature * git_reflog_entry_committer(const git_reflog_entry *entry)
	{
	assert(entry);
	return entry->committer;
	}

	char * git_reflog_entry_msg(const git_reflog_entry *entry)
	{
	assert(entry);
	return entry->msg;
	}