sgw

main.c

---

#include <sys/stat.h>
#include <sys/types.h>

#include <err.h>
#include <errno.h>
#include <libgen.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <limits.h>

#include <git2.h>

#include "compat.h"
#include "opt.h"
#include "files.h"

#define CPUT(f, c)  putc((c), (f))
#define put_xml(fp, s)  put_xml_len((fp), (s), strlen(s))
#define SPUTF(f, s)  fputs((s), (f))
#define LENGTH(s)  (sizeof(s)/sizeof(*s))

#include "config.h"

struct DeltaInfo {
	git_patch *patch;

	size_t add_count;
	size_t del_count;
};

struct CommitInfo {
	const git_oid *id;

	char oid[GIT_OID_HEXSZ + 1];
	char parentoid[GIT_OID_HEXSZ + 1];

	const git_signature *author;
	const git_signature *committer;
	const char *summary;
	const char *msg;

	git_diff *diff;
	git_commit *commit;
	git_commit *parent;
	git_tree *commit_tree;
	git_tree *parent_tree;

	size_t add_count;
	size_t del_count;
	size_t file_count;

	struct DeltaInfo **deltas;
	size_t ndeltas;
};

/* reference and associated data for sorting */
struct ReferenceInfo {
	struct git_reference *ref;
	struct CommitInfo *ci;
};

struct Weight {
	size_t bytes;
	size_t lines;
};

static const char orders[] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
static const char tab[] = "0123456789ABCDEF";

/* GLOBALS */
// TODO untangle these, pass them around instead...

static git_repository *repo;

/* flags + arguments */
static Opt opt;
static const char *repo_dir;

static const char *license_files[] = { LICENSE_FILES };
static const char *readme_files[] = { README_FILES };

// TODO extract these into a struct. LMFAO
static char *name = "";
static char *repo_name = "";
static char description[255];
static char clone_url[1024];
static char *submodules;
static const char *license;
static const char *readme;

/* bad globals for index.... */
// TODO move this stuff to index.h?
static FILE *index_fp;
static char index_fname[255] = "index.html";

void find_owner();
int put_index_log(FILE *fp, git_repository *repo, const char *description, const char *repo_name, const char *readme);
void put_index_header(FILE *fp);
void put_index_footer(FILE *fp);

void
get_page_path(char *buf, size_t buf_size, const char *dir, char *name)
{
	int index = 0, chars = 0;

	// TODO tweak this so that it correctly places slashes between names
	chars = snprintf(buf + index, buf_size - index, "%s", dir);
	if (chars < 0 || (size_t) (index += chars) >= buf_size)
		goto page_path_err;

	if (chars != 0) buf[index++] = '/';

	chars = snprintf(buf + index, buf_size - index, PAGE_DEST);
	if (chars < 0 || (size_t) (index += chars) >= buf_size)
		goto page_path_err;

	if (chars != 0) buf[index++] = '/';

	chars = snprintf(buf + index, buf_size - index, "%s", name);
	if (chars < 0 || (size_t) (index += chars) >= buf_size)
		goto page_path_err;

	return;

page_path_err:
	errx(1, "page path truncated! '%s' / '%s'" "\n", dir, name);
}

void
get_index_page_path(char *buf, size_t buf_size, const char *dir, char *name)
{
	int index = 0, chars = 0;

	// TODO tweak this so that it correctly places slashes between names
	chars = snprintf(buf + index, buf_size - index, "%s", dir);
	if (chars < 0 || (size_t) (index += chars) >= buf_size)
		goto page_path_err;

	const char *format = dir[0] == '\0' ? "%s" : "/%s";
	chars = snprintf(buf + index, buf_size - index, format, name);
	if (chars < 0 || (size_t) (index += chars) >= buf_size)
		goto page_path_err;

	printf("Index page path: %s" "\n", buf);

	return;

page_path_err:
	errx(1, "page path truncated! '%s' / '%s'" "\n", dir, name);
}

FILE *
git_fopen(char *path, int path_size, const char *file)
{
	FILE *ret;

	/* try dir/(whatever), */
	/* (+5 removes the leading '.git/'.) */
	join_path(path, path_size, repo_dir, file + 5); 
	if ((ret = fopen(path, "r"))) return ret;

	/* then try dir/.git/(whatever). */
	join_path(path, path_size, repo_dir, file);
	return fopen(path, "r");
}

void
find_license()
{
	git_object *obj = NULL;
	int i;
	for (i = 0; i < LENGTH(license_files) && !license; i++) {
		if (
			!git_revparse_single(&obj, repo, license_files[i]) &&
			git_object_type(obj) == GIT_OBJ_BLOB
		)
			license = license_files[i] + strlen("HEAD:");
		git_object_free(obj);
	}
}

void
find_readme()
{
	git_object *obj = NULL;
	int i;
	readme = NULL;
	for (i = 0; i < LENGTH(readme_files) && !readme; i++) {
		if (
			!git_revparse_single(&obj, repo, readme_files[i]) &&
			git_object_type(obj) == GIT_OBJ_BLOB
		)
			readme = readme_files[i] + strlen("HEAD:");
		git_object_free(obj);
	}
}

void
delta_info_free(struct DeltaInfo *di)
{
	if (!di) return;

	git_patch_free(di->patch);
	memset(di, 0, sizeof(*di));
	free(di);
}

int
commit_info_get_stats(struct CommitInfo *ci)
{
	struct DeltaInfo *di;
	git_diff_options opts;
	git_diff_find_options fopts;
	const git_diff_delta *delta;
	const git_diff_hunk *hunk;
	const git_diff_line *line;
	git_patch *patch = NULL;
	size_t ndeltas, nhunks, nhunklines;
	size_t i, j, k;

	if (git_tree_lookup(&(ci->commit_tree), repo, git_commit_tree_id(ci->commit)))
		goto err;
	if (!git_commit_parent(&(ci->parent), ci->commit, 0)) {
		if (git_tree_lookup(&(ci->parent_tree), repo, git_commit_tree_id(ci->parent))) {
			ci->parent = NULL;
			ci->parent_tree = NULL;
		}
	}

	git_diff_init_options(&opts, GIT_DIFF_OPTIONS_VERSION);
	opts.flags |= GIT_DIFF_DISABLE_PATHSPEC_MATCH |
		GIT_DIFF_IGNORE_SUBMODULES |
		GIT_DIFF_INCLUDE_TYPECHANGE;
	if (git_diff_tree_to_tree(&(ci->diff), repo, ci->parent_tree, ci->commit_tree, &opts))
		goto err;

	if (git_diff_find_init_options(&fopts, GIT_DIFF_FIND_OPTIONS_VERSION))
		goto err;
	/* find renames and copies, exact matches (no heuristic) for renames. */
	fopts.flags |= GIT_DIFF_FIND_RENAMES |
		GIT_DIFF_FIND_COPIES |
		GIT_DIFF_FIND_EXACT_MATCH_ONLY;
	if (git_diff_find_similar(ci->diff, &fopts))
		goto err;

	ndeltas = git_diff_num_deltas(ci->diff);
	if (ndeltas && !(ci->deltas = calloc(ndeltas, sizeof(struct DeltaInfo *))))
		err(1, "calloc");

	for (i = 0; i < ndeltas; i++) {
		if (git_patch_from_diff(&patch, ci->diff, i))
			goto err;

		if (!(di = calloc(1, sizeof(struct DeltaInfo))))
			err(1, "calloc");
		di->patch = patch;
		ci->deltas[i] = di;

		delta = git_patch_get_delta(patch);

		/* skip stats for binary data */
		if (delta->flags & GIT_DIFF_FLAG_BINARY)
			continue;

		nhunks = git_patch_num_hunks(patch);
		for (j = 0; j < nhunks; j++) {
			if (git_patch_get_hunk(&hunk, &nhunklines, patch, j))
				break;
			for (k = 0; ; k++) {
				if (git_patch_get_line_in_hunk(&line, patch, j, k))
					break;
				if (line->old_lineno == -1) {
					di->add_count++;
					ci->add_count++;
				} else if (line->new_lineno == -1) {
					di->del_count++;
					ci->del_count++;
				}
			}
		}
	}
	ci->ndeltas = i;
	ci->file_count = i;

	return 0;

err:
	git_diff_free(ci->diff);
	ci->diff = NULL;
	git_tree_free(ci->commit_tree);
	ci->commit_tree = NULL;
	git_tree_free(ci->parent_tree);
	ci->parent_tree = NULL;
	git_commit_free(ci->parent);
	ci->parent = NULL;

	if (ci->deltas)
		for (i = 0; i < ci->ndeltas; i++)
			delta_info_free(ci->deltas[i]);
	free(ci->deltas);
	ci->deltas = NULL;
	ci->ndeltas = 0;
	ci->add_count = 0;
	ci->del_count = 0;
	ci->file_count = 0;

	return -1;
}

void
commit_info_free(struct CommitInfo *ci)
{
	size_t i;

	if (!ci)
		return;
	if (ci->deltas)
		for (i = 0; i < ci->ndeltas; i++)
			delta_info_free(ci->deltas[i]);

	free(ci->deltas);
	git_diff_free(ci->diff);
	git_tree_free(ci->commit_tree);
	git_tree_free(ci->parent_tree);
	git_commit_free(ci->commit);
	git_commit_free(ci->parent);
	memset(ci, 0, sizeof(*ci));
	free(ci);
}

struct CommitInfo *
commit_info_get_by_oid(const git_oid *id)
{
	struct CommitInfo *ci;

	if (!(ci = calloc(1, sizeof(struct CommitInfo))))
		err(1, "calloc");

	if (git_commit_lookup(&(ci->commit), repo, id))
		goto err;
	ci->id = id;

	git_oid_tostr(ci->oid, sizeof(ci->oid), git_commit_id(ci->commit));
	git_oid_tostr(ci->parentoid, sizeof(ci->parentoid), git_commit_parent_id(ci->commit, 0));

	ci->author = git_commit_author(ci->commit);
	ci->committer = git_commit_committer(ci->commit);
	ci->summary = git_commit_summary(ci->commit);
	ci->msg = git_commit_message(ci->commit);

	return ci;

err:
	commit_info_free(ci);

	return NULL;
}

int
refs_cmp(const void *v1, const void *v2)
{
	const struct ReferenceInfo *r1 = v1, *r2 = v2;
	time_t t1, t2;
	int r;

	if ((r = git_reference_is_tag(r1->ref) - git_reference_is_tag(r2->ref)))
		return r;

	t1 = r1->ci->author ? r1->ci->author->when.time : 0;
	t2 = r2->ci->author ? r2->ci->author->when.time : 0;
	if ((r = t1 > t2 ? -1 : (t1 == t2 ? 0 : 1)))
		return r;

	return strcmp(
		git_reference_shorthand(r1->ref),
		git_reference_shorthand(r2->ref)
	);
}

int
get_refs(struct ReferenceInfo **pris, size_t *prefcount)
{
	struct ReferenceInfo *ris = NULL;
	struct CommitInfo *ci = NULL;
	git_reference_iterator *it = NULL;
	const git_oid *id = NULL;
	git_object *obj = NULL;
	git_reference *dref = NULL, *r, *ref = NULL;
	size_t i, refcount;

	*pris = NULL;
	*prefcount = 0;

	if (git_reference_iterator_new(&it, repo))
		return -1;

	for (refcount = 0; !git_reference_next(&ref, it); ) {
		if (!git_reference_is_branch(ref) && !git_reference_is_tag(ref)) {
			git_reference_free(ref);
			ref = NULL;
			continue;
		}

		switch (git_reference_type(ref)) {
		case GIT_REF_SYMBOLIC:
			if (git_reference_resolve(&dref, ref))
				goto err;
			r = dref;
			break;
		case GIT_REF_OID:
			r = ref;
			break;
		default:
			continue;
		}
		if (
			!git_reference_target(r) ||
			git_reference_peel(&obj, r, GIT_OBJ_ANY)
		)
			goto err;
		if (!(id = git_object_id(obj)))
			goto err;
		if (!(ci = commit_info_get_by_oid(id)))
			break;

		if (!(ris = reallocarray(ris, refcount + 1, sizeof(*ris))))
			err(1, "realloc");
		ris[refcount].ci = ci;
		ris[refcount].ref = r;
		refcount++;

		git_object_free(obj);
		obj = NULL;
		git_reference_free(dref);
		dref = NULL;
	}
	git_reference_iterator_free(it);

	/* sort by type, date then shorthand name */
	qsort(ris, refcount, sizeof(*ris), refs_cmp);

	*pris = ris;
	*prefcount = refcount;

	return 0;

err:
	git_object_free(obj);
	git_reference_free(dref);
	commit_info_free(ci);
	for (i = 0; i < refcount; i++) {
		commit_info_free(ris[i].ci);
		git_reference_free(ris[i].ref);
	}
	free(ris);

	return -1;
}

/* Percent-encode, see RFC3986 section 2.1. */
void
put_percent_char(FILE *fp, unsigned char uc)
{
	/* NOTE: do not encode '/' for paths or ",-." */
	if (
		uc < ',' ||
		uc >= 127 ||
		(uc >= ':' && uc <= '@') ||
		uc == '[' ||
		uc == ']'
	) {
		CPUT(fp, '%');
		CPUT(fp, tab[(uc >> 4) & 0x0f]);
		CPUT(fp, tab[uc & 0x0f]);
		return;
	}

	CPUT(fp, uc);
}

void
put_percent_encoded(FILE *fp, const char *s, size_t len)
{
	size_t i;

	for (i = 0; *s && i < len; s++, i++)
		put_percent_char(fp, *s);
}

/* Escape characters below as HTML 2.0 / XML 1.0. */
void
put_xml_char(FILE *fp, const char *s)
{
	switch(*s) {
		case '<': fputs("&lt;", fp); break;
		case '>': fputs("&gt;", fp); break;
		case '\'': fputs("&#39;", fp); break;
		case '&': fputs("&amp;", fp); break;
		case '"': fputs("&quot;", fp); break;
		default: putc(*s, fp);
	}
}

void
put_xml_len(FILE *fp, const char *s, size_t len)
{
	size_t i = 0;
	for (; *s && i < len; s++, i++)
		put_xml_char(fp, s);
}

/* terminate on, but don't print '\r' or '\n' */
void
put_xml_line(FILE *fp, const char *s, size_t len)
{
	size_t i = 0;
	for (; *s && i < len; s++, i++) {
		if (*s == '\r' || *s == '\n')
			break;
		put_xml_char(fp, s);
	}
}

void
printtimez(FILE *fp, const git_time *intime)
{
	struct tm *intm;
	time_t t;
	char out[32];

	t = (time_t)intime->time;
	if (!(intm = gmtime(&t)))
		return;
	strftime(out, sizeof(out), "%Y-%m-%dT%H:%M:%SZ", intm);
	fputs(out, fp);
}

void
printtime(FILE *fp, const git_time *intime)
{
	struct tm *intm;
	time_t t;
	char out[32];

	t = (time_t)intime->time + (intime->offset * 60);
	if (!(intm = gmtime(&t)))
		return;
	strftime(out, sizeof(out), "%a, %e %b %Y %H:%M:%S", intm);
	if (intime->offset < 0) {
		fprintf(
			fp,
			"%s -%02d%02d",
			out,
			-(intime->offset) / 60,
			-(intime->offset) % 60
		);
	} else {
		fprintf(
			fp,
			"%s +%02d%02d", out,
			intime->offset / 60,
			intime->offset % 60
		);
	}
}

void
printtimeshort(FILE *fp, const git_time *intime)
{
	struct tm *intm;
	time_t t;
	char out[32];

	t = (time_t)intime->time;
	if (!(intm = gmtime(&t)))
		return;
	strftime(out, sizeof(out), "%Y-%m-%d %H:%M", intm);
	fputs(out, fp);
}

void
put_absolute_path(FILE *fp, const char * path)
{
	if (opt.base_url[0] != '\0')
		fprintf(fp, "/%s", opt.base_url);
	CPUT(fp, '/');
	fprintf(fp, PAGE_DEST); /* should have no leading/trailing slashes */
	fprintf(fp, "/%s", path);
}

void
put_header(FILE *fp, const char *title)
{
	fputs(
		"<!DOCTYPE html>\n"
		"<html>" "\n"
		"<head>" "\n"
		"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n"
		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n"
		"<title>",
		fp
	);
	put_xml(fp, title);
	if (title[0] && repo_name[0])
		fputs(" - ", fp);
	put_xml(fp, repo_name);
	if (description[0])
		fputs(" - ", fp);
	put_xml(fp, description);
	SPUTF(fp, "</title>" "\n");

	SPUTF(fp, "<link rel=\"icon\" type=\"image/png\" href=\"");
	put_absolute_path(fp, "favicon.png");
	SPUTF(fp, "\" />" "\n");

	SPUTF(fp, "<link rel=\"alternate\" type=\"application/atom+xml\" title=\"");
	put_xml(fp, name);
	SPUTF(fp, " Atom Feed\" href=\"");
	put_absolute_path(fp, "atom.xml");
	SPUTF(fp, "\" />" "\n");

	SPUTF(fp, "<link rel=\"alternate\" type=\"application/atom+xml\" title=\"");
	put_xml(fp, name);
	SPUTF(fp, " Atom Feed (tags)\" href=\"");
	put_absolute_path(fp, "tags.xml");
	SPUTF(fp, "\" />" "\n");

	SPUTF(fp, "<link rel=\"stylesheet\" type=\"text/css\" href=\"");
	fprintf(fp, PAGE_STYLE_HREF);
	SPUTF(fp, "\" />" "\n");
	SPUTF(fp, "</head>" "\n" "<body>" "\n");
	
	fprintf(fp, PAGE_HEADER);

	SPUTF(fp, "<table>" "<tr><td>");

	SPUTF(fp, "<a href=\"");
	fprintf(fp, PAGE_LOGO_HREF);
	SPUTF(fp, "\"><img alt=\"logo\" width=\"32\" height=\"32\" src=\"");
	fprintf(fp, PAGE_LOGO_SRC);
	SPUTF(fp, "\"></a>");

	SPUTF(fp, "</td><td>" "<h1>");
	put_xml(fp, repo_name);
	SPUTF(fp, "</h1>" "<span class=\"desc\">");
	put_xml(fp, description);
	SPUTF(fp, "</span>" "</td></tr>");
	if (clone_url[0]) {
		SPUTF(fp, "<tr class=\"url\"><td></td><td>git clone <a href=\"");
		put_xml(fp, clone_url); /* not percent encoded */
		SPUTF(fp, "\">");
		put_xml(fp, clone_url);
		SPUTF(fp, "</a></td></tr>");
	}
	SPUTF(fp, "<tr><td></td><td>" "\n");

	if (readme) {
		SPUTF(fp, "<a href=\"");
		put_absolute_path(fp, "files/");
		fprintf(fp, "%s.html", readme);
		SPUTF(fp, "\">README</a> | ");
	}
	
	SPUTF(fp, "<a href=\"");
	put_absolute_path(fp, "files.html");
	SPUTF(fp, "\">Files</a> | ");

	SPUTF(fp, "<a href=\"");
	put_absolute_path(fp, "log.html");
	SPUTF(fp, "\">Log</a> | ");

	SPUTF(fp, "<a href=\"");
	put_absolute_path(fp, "refs.html");
	SPUTF(fp, "\">Refs</a>");

	if (submodules) {
		SPUTF(fp, " | <a href=\"");
		put_absolute_path(fp, "files/");
		fprintf(fp, "%s.html", submodules);
		SPUTF(fp, "\">Submodules</a>");
	}

	if (license) {
		SPUTF(fp, " | <a href=\"");
		put_absolute_path(fp, "files/");
		fprintf(fp, "%s.html", license);
		SPUTF(fp, "\">LICENSE</a>");
	}

	SPUTF(fp, "</td></tr></table>" "\n");
	SPUTF(fp, "<hr/>" "\n");

	SPUTF(fp, "<div id=\"content\">" "\n");
}

void
put_footer(FILE *fp)
{
	SPUTF(fp, "</div>" "\n");
	fprintf(fp, PAGE_FOOTER);
	SPUTF(fp, "</body>" "\n" "</html>" "\n");
}

size_t
put_file_html(FILE *fp, const git_blob *blob)
{
	size_t n = 0, i, len, prev;
	const char *number_format =
		"<a href=\"#l%zu\" class=\"line\" id=\"l%zu\">%7zu </a>";
	const char *s = git_blob_rawcontent(blob);

	len = git_blob_rawsize(blob);
	SPUTF(fp, "<pre id=\"blob\">" "\n");

	if (len > 0) {
		for (i = 0, prev = 0; i < len; i++) {
			if (s[i] != '\n')
				continue;
			n++;
			fprintf(fp, number_format, n, n, n);
			put_xml_line(fp, &s[prev], i - prev + 1);
			SPUTF(fp, "\n");
			prev = i + 1;
		}
		/* trailing data */
		if ((len - prev) > 0) {
			n++;
			fprintf(fp, number_format, n, n, n);
			put_xml_line(fp, &s[prev], len - prev);
		}
	}

	SPUTF(fp, "</pre>" "\n");

	return n;
}

void
print_commit(FILE *fp, struct CommitInfo *ci)
{
	SPUTF(fp, "<b>commit</b> <a href=\"");
	put_absolute_path(fp, "commits/");
	fprintf(fp, "%s.html", ci->oid);
	fprintf(fp, "\">%s</a>" "\n", ci->oid);

	if (ci->parentoid[0]) {
		SPUTF(fp, "<b>parent</b> <a href=\"");
		put_absolute_path(fp, "commits/");
		fprintf(fp, "%s.html", ci->parentoid);
		fprintf(fp, "\">%s</a>" "\n", ci->parentoid);
	}

	if (ci->author) {
		SPUTF(fp, "<b>Author:</b> ");
		put_xml(fp, ci->author->name);
		SPUTF(fp, " &lt;<a href=\"mailto:");
		put_xml(fp, ci->author->email); /* not percent encoded */
		SPUTF(fp, "\">");
		put_xml(fp, ci->author->email);
		SPUTF(fp, "</a>&gt;\n<b>Date:</b>   ");
		printtime(fp, &(ci->author->when));
		CPUT(fp, '\n');
	}
	if (ci->msg) {
		CPUT(fp, '\n');
		put_xml(fp, ci->msg);
		CPUT(fp, '\n');
	}
}

void
put_show_file(FILE *fp, struct CommitInfo *ci)
{
	const git_diff_delta *delta;
	const git_diff_hunk *hunk;
	const git_diff_line *line;
	git_patch *patch;
	size_t nhunks, nhunklines, changed, add, del, total, i, j, k;
	char linestr[80];
	int c;

	print_commit(fp, ci);

	if (!ci->deltas)
		return;

	if (
		ci->file_count > 1000 ||
		ci->ndeltas > 1000 ||
		ci->add_count > 100000 ||
		ci->del_count > 100000
	) {
		fputs("Diff is too large, output suppressed.\n", fp);
		return;
	}

	/* diff stat */
	fputs("<b>Diffstat:</b>" "\n", fp);
	fputs("<table id=\"diffstat\">", fp);
	for (i = 0; i < ci->ndeltas; i++) {
		delta = git_patch_get_delta(ci->deltas[i]->patch);

		switch (delta->status) {
		case GIT_DELTA_ADDED: c = 'A'; break;
		case GIT_DELTA_COPIED: c = 'C'; break;
		case GIT_DELTA_DELETED: c = 'D'; break;
		case GIT_DELTA_MODIFIED: c = 'M'; break;
		case GIT_DELTA_RENAMED: c = 'R'; break;
		case GIT_DELTA_TYPECHANGE: c = 'T'; break;
		default: c = ' '; break;
		}
		if (c == ' ')
			fprintf(fp, "<tr><td>%c", c);
		else
			fprintf(fp, "<tr><td class=\"%c\">%c", c, c);

		fprintf(fp, "</td><td><a href=\"#h%zu\">", i);
		put_xml(fp, delta->old_file.path);
		if (strcmp(delta->old_file.path, delta->new_file.path)) {
			fputs(" -&gt; ", fp);
			put_xml(fp, delta->new_file.path);
		}

		add = ci->deltas[i]->add_count;
		del = ci->deltas[i]->del_count;
		changed = add + del;
		total = sizeof(linestr) - 2;
		if (changed > total) {
			if (add)
				add = ((float)total / changed * add) + 1;
			if (del)
				del = ((float)total / changed * del) + 1;
		}
		memset(&linestr, '+', add);
		memset(&linestr[add], '-', del);

		fprintf(
			fp,
			"</a></td>"
			// "<td> | </td>"
			"<td class=\"num\">%zu</td><td><span class=\"i\">",
			ci->deltas[i]->add_count + ci->deltas[i]->del_count
		);
		fwrite(&linestr, 1, add, fp);
		fputs("</span><span class=\"d\">", fp);
		fwrite(&linestr[add], 1, del, fp);
		fputs("</span></td></tr>\n", fp);
	}
	fprintf(
		fp,
		"</table></pre><pre>%zu file%s changed, %zu insertion%s(+), %zu deletion%s(-)\n",
		ci->file_count, ci->file_count == 1 ? "" : "s",
		ci->add_count, ci->add_count == 1 ? "" : "s",
		ci->del_count, ci->del_count == 1 ? "" : "s"
	);

	fputs("<hr/>", fp);

	for (i = 0; i < ci->ndeltas; i++) {
		patch = ci->deltas[i]->patch;
		delta = git_patch_get_delta(patch);

		SPUTF(fp, "<b>diff --git a/");
		put_xml(fp, delta->old_file.path);
		fprintf(fp, " b/<a id=\"h%zu\" href=\"#h%zu\">", i, i);
		put_xml(fp, delta->new_file.path);
		SPUTF(fp, "</a></b>" "\n");

		/* check binary data */
		if (delta->flags & GIT_DIFF_FLAG_BINARY) {
			SPUTF(fp, "Binary files differ." "\n");
			continue;
		}

		nhunks = git_patch_num_hunks(patch);
		for (j = 0; j < nhunks; j++) {
			if (git_patch_get_hunk(&hunk, &nhunklines, patch, j))
				break;

			fprintf(fp, "<a href=\"#h%zu-%zu\" id=\"h%zu-%zu\" class=\"h\">", i, j, i, j);
			put_xml_len(fp, hunk->header, hunk->header_len);
			SPUTF(fp, "</a>");

			for (k = 0; ; k++) {
				if (git_patch_get_line_in_hunk(&line, patch, j, k))
					break;
				if (line->old_lineno == -1)
					fprintf(
						fp,
						"<a href=\"#h%zu-%zu-%zu\" id=\"h%zu-%zu-%zu\" class=\"i\">+",
						i, j, k, i, j, k
					);
				else if (line->new_lineno == -1)
					fprintf(
						fp,
						"<a href=\"#h%zu-%zu-%zu\" id=\"h%zu-%zu-%zu\" class=\"d\">-",
						i, j, k, i, j, k
					);
				else
					CPUT(fp, ' ');
				put_xml_line(fp, line->content, line->content_len);
				CPUT(fp, '\n');
				if (line->old_lineno == -1 || line->new_lineno == -1)
					SPUTF(fp, "</a>");
			}
		}
	}
}

void
put_log_line(FILE *fp, struct CommitInfo *ci)
{
	fputs("<tr><td>", fp);
	if (ci->author)
		printtimeshort(fp, &(ci->author->when));
	fputs("</td><td>", fp);
	if (ci->summary) {
		SPUTF(fp, "<a href=\"");
		put_absolute_path(fp, "commits/");
		fprintf(fp, "%s.html", ci->oid);
		SPUTF(fp, "\">");
		put_xml(fp, ci->summary);
		SPUTF(fp, "</a>");
	}
	SPUTF(fp, "</td><td>");
	if (ci->author) put_xml(fp, ci->author->name);
	SPUTF(fp, "</td><td class=\"num\" align=\"right\">");
	fprintf(fp, "%zu", ci->file_count);
	SPUTF(fp, "</td><td class=\"num\" align=\"right\">");
	fprintf(fp, "+%zu", ci->add_count);
	SPUTF(fp, "</td><td class=\"num\" align=\"right\">");
	fprintf(fp, "-%zu", ci->del_count);
	SPUTF(fp, "</td></tr>" "\n");
}

void
write_commit_page(char *name, struct CommitInfo *ci)
{
	char fname[PATH_MAX];
	get_page_path(fname, sizeof(fname), opt.out_dir, name);
	FILE *fp = fopen_w(fname);
	// [old] fpfile = efopen(path, "w");

	put_header(fp, ci->summary);

	SPUTF(fp, "<pre>");
	put_show_file(fp, ci);
	SPUTF(fp, "</pre>" "\n");

	put_footer(fp);
	check_file_error(fp, fname, 'w');
	fclose(fp);
}

int
put_log(FILE *fp, const git_oid *oid)
{
	struct CommitInfo *ci;
	git_revwalk *w = NULL;
	git_oid id;
	char path[PATH_MAX], oidstr[GIT_OID_HEXSZ + 1];
	size_t remcommits = 0;
	int r;
	int commits_left = MAX_COMMITS;

	git_revwalk_new(&w, repo);
	git_revwalk_push(w, oid);

	// TODO avoid processing very large commits
	while (!git_revwalk_next(&id, w)) {
		git_oid_tostr(oidstr, sizeof(oidstr), &id);
		r = snprintf(path, sizeof(path), "commits/%s.html", oidstr);
		if (r < 0 || (size_t)r >= sizeof(path))
			errx(1, "path truncated: 'commits/%s.html'", oidstr);
		r = access(path, F_OK);

		/* optimization: if there are no log lines to write and
		   the commit file already exists: skip the diffstat */
		if (!commits_left) {
			remcommits++;
			if (!r)
				continue;
		}

		if (!(ci = commit_info_get_by_oid(&id)))
			break;
		/* diffstat: for stagit HTML required for the log.html line */
		if (commit_info_get_stats(ci) == -1)
			goto err;

		if (commits_left != 0) {
			put_log_line(fp, ci);
			if (commits_left > 0)
				commits_left--;
		}

		/* check if file exists if so skip it */
		if (r) write_commit_page(path, ci);

err:
		commit_info_free(ci);
	}
	git_revwalk_free(w);

	if (commits_left == 0 && remcommits != 0)
		fprintf(
			fp,
			"<tr><td></td><td colspan=\"5\">"
			"%zu more commits remaining, fetch the repository"
			"</td></tr>" "\n",
			remcommits
		);

	return 0;
}

void
put_log_html(FILE *fp, const git_oid *head)
{
	put_header(fp, "Log");
	fputs(
		"<table id=\"log\"><thead>" "\n"
		"<tr>"
		"<td><b>Date</b></td>"
		"<td><b>Commit message</b></td>"
		"<td><b>Author</b></td>"
		"<td class=\"num\" align=\"right\"><b>Files</b></td>"
		"<td class=\"num\" align=\"right\"><b>+</b></td>"
		"<td class=\"num\" align=\"right\"><b>-</b></td>"
		"</tr>" "\n"
		"</thead><tbody>" "\n",
		fp
	);

	if (head) put_log(fp, head);

	fputs("</tbody></table>", fp);
	put_footer(fp);
}

void
print_commit_atom(FILE *fp, struct CommitInfo *ci, const char *tag)
{
	fputs("<entry>\n", fp);

	fprintf(fp, "<id>%s</id>\n", ci->oid);
	if (ci->author) {
		SPUTF(fp, "<published>");
		printtimez(fp, &(ci->author->when));
		SPUTF(fp, "</published>\n");
	}
	if (ci->committer) {
		SPUTF(fp, "<updated>");
		printtimez(fp, &(ci->committer->when));
		SPUTF(fp, "</updated>\n");
	}
	if (ci->summary) {
		SPUTF(fp, "<title>");
		if (tag && tag[0]) {
			SPUTF(fp, "[");
			put_xml(fp, tag);
			SPUTF(fp, "] ");
		}
		put_xml(fp, ci->summary);
		SPUTF(fp, "</title>\n");
	}
	SPUTF(fp, "<link rel=\"alternate\" type=\"text/html\" href=\"");
	put_absolute_path(fp, "commits/");
	fprintf(fp, "%s.html\" />" "\n", ci->oid);

	if (ci->author) {
		SPUTF(fp, "<author>" "\n" "<name>");
		put_xml(fp, ci->author->name);
		SPUTF(fp, "</name>" "\n" "<email>");
		put_xml(fp, ci->author->email);
		SPUTF(fp, "</email>" "\n" "</author>" "\n");
	}

	SPUTF(fp, "<content>");
	fprintf(fp, "commit %s" "\n", ci->oid);
	if (ci->parentoid[0])
		fprintf(fp, "parent %s" "\n", ci->parentoid);
	if (ci->author) {
		SPUTF(fp, "Author: ");
		put_xml(fp, ci->author->name);
		SPUTF(fp, " &lt;");
		put_xml(fp, ci->author->email);
		SPUTF(fp, "&gt;" "\n" "Date:   ");
		printtime(fp, &(ci->author->when));
		CPUT(fp, '\n');
	}
	if (ci->msg) {
		CPUT(fp, '\n');
		put_xml(fp, ci->msg);
	}
	SPUTF(fp, "\n" "</content>" "\n" "</entry>" "\n");
}

int
write_atom(FILE *fp, int all)
{
	struct ReferenceInfo *ris = NULL;
	size_t refcount = 0;
	struct CommitInfo *ci;
	git_revwalk *w = NULL;
	git_oid id;
	size_t i, m = 100; /* last 'm' commits */

	SPUTF(
		fp,
		"<?xml version=\"1.0\" encoding=\"UTF-8\"?>" "\n"
		"<feed xmlns=\"http://www.w3.org/2005/Atom\">" "\n" "<title>"
	);
	put_xml(fp, repo_name);
	SPUTF(fp, ", branch HEAD</title>" "\n" "<subtitle>");
	put_xml(fp, description);
	SPUTF(fp, "</subtitle>" "\n");

	/* all commits or only tags? */
	if (all) {
		git_revwalk_new(&w, repo);
		git_revwalk_push_head(w);
		for (i = 0; i < m && !git_revwalk_next(&id, w); i++) {
			if (!(ci = commit_info_get_by_oid(&id)))
				break;
			print_commit_atom(fp, ci, "");
			commit_info_free(ci);
		}
		git_revwalk_free(w);
	} else if (get_refs(&ris, &refcount) != -1) {
		/* references: tags */
		for (i = 0; i < refcount; i++) {
			if (git_reference_is_tag(ris[i].ref))
				print_commit_atom(
					fp, ris[i].ci,
					git_reference_shorthand(ris[i].ref)
				);

			commit_info_free(ris[i].ci);
			git_reference_free(ris[i].ref);
		}
		free(ris);
	}

	fputs("</feed>\n", fp);

	return 0;
}

void
write_binary_file(const char *filename, git_blob *blob) {
	char dest[PATH_MAX];
	const char *raw = git_blob_rawcontent(blob);
	int size = git_blob_rawsize(blob);

	/* set dest */
	join_path(dest, PATH_MAX, "files", filename);

	/* write the file! */
	char fname[PATH_MAX];
	get_page_path(fname, sizeof(fname), opt.out_dir, dest);
	FILE *fp = fopen_w(fname);

	fwrite(raw, size, 1, fp);
	check_file_error(fp, fname, 'w');
	fclose(fp);
}

void
put_size(FILE *fp, size_t size, int fixed)
{
	int order = 0;
	int decimal;

	if (size == 0) {
		fprintf(fp, "  - ");
		return;
	}

	while (size > 1000) {
		order++;
		decimal = (size / 100) % 10;
		size /= 1000;
	}

	if (size < 10 && order > 0) fprintf(fp, "%1zu.%1d", size, decimal);
	else fprintf(fp, fixed ? "%3zu" : "%zu", size);

	if (order != 0 || fixed) fprintf(fp, "%c", orders[order]);
}

void
put_file_title(FILE *fp, const char *name, int is_dir)
{
	int i = 0;
	int len = 0;

	/* project root */
	if (name[0] == '\0')
		return;

	if (!DIR_PAGES) {
		fprintf(fp, "<p>%s</p>", name);
		return;
	}

	if (BACKLINKS && !is_dir) {
		for (i = 0; name[i] != '\0'; i++)
			if (name[i] == '/') len = i;	

		if (len != 0) {
			SPUTF(fp, "<p><a href=\"");
			put_absolute_path(fp, "files/");
			for (i = 0; i < len; i++) put_percent_char(fp, name[i]);
			SPUTF(fp, ".html\">");
			for (i = 0; i < len; i++) put_percent_char(fp, name[i]);
			fprintf(fp, "</a>%s</p>", name + len);
			if (!is_dir) SPUTF(fp, "<hr>");
			return;
		}
	}


	fprintf(fp, "<p>%s</p>", name);
	if (!is_dir) SPUTF(fp, "<hr>");
}

void
put_binary_blob_stub(FILE *fp, const char *file_url)
{
	SPUTF(fp, "<p>Binary file: <a href=\"");
	put_absolute_path(fp, "files/");
	fprintf(fp, "%s\">raw</a></p>" "\n", file_url);
	SPUTF(fp, "<object data=\"");
	put_absolute_path(fp, "files/");
	fprintf(fp, "%s\">", file_url);
	SPUTF(fp, "no preview available.</object></p>" "\n");
}

struct Weight
write_blob(
	git_blob *blob,
	char *filename,
	const char *entrypath,
	const char *name
) {
	char fname[PATH_MAX];
	FILE *fp;
	struct Weight ret;

	ret.lines = 0;
	ret.bytes = 0;

	get_page_path(fname, sizeof(fname), opt.out_dir, filename);
	fp = fopen_w(fname);
	
	put_header(fp, name);
	put_file_title(fp, entrypath, 0);

	if (git_blob_is_binary(blob)) {
		put_binary_blob_stub(fp, entrypath); // name);
		write_binary_file(entrypath, blob);
		ret.bytes = git_blob_rawsize(blob);
	} else {
		ret.lines = put_file_html(fp, blob);
	}

	put_footer(fp);
	check_file_error(fp, fname, 'w');
	fclose(fp);

	return ret;
}

char
get_filemode_type(git_filemode_t m)
{
	if (S_ISREG(m)) return '-';
	if (S_ISBLK(m)) return 'b';
	if (S_ISCHR(m)) return 'c';
	if (S_ISDIR(m)) return 'd';
	if (S_ISFIFO(m)) return 'p';
	if (S_ISLNK(m)) return 'l';
	if (S_ISSOCK(m)) return 's';
	return '?';
}

const char *
get_filemode(const git_tree_entry *entry)
{
	git_filemode_t mode;
	static char ret[11];

	/* used for backlink: .. */
	if (entry == NULL) return "d---------";

	mode = git_tree_entry_filemode(entry);

	memset(ret, '-', sizeof(ret) - 1);
	ret[0] = get_filemode_type(mode);
	if (mode & S_IRUSR) ret[1] = 'r';
	if (mode & S_IWUSR) ret[2] = 'w';
	if (mode & S_IXUSR) ret[3] = 'x';
	if (mode & S_ISUID) ret[3] = (ret[3] == 'x') ? 's' : 'S';
	if (mode & S_IRGRP) ret[4] = 'r';
	if (mode & S_IWGRP) ret[5] = 'w';
	if (mode & S_IXGRP) ret[6] = 'x';
	if (mode & S_ISGID) ret[6] = (ret[6] == 'x') ? 's' : 'S';
	if (mode & S_IROTH) ret[7] = 'r';
	if (mode & S_IWOTH) ret[8] = 'w';
	if (mode & S_IXOTH) ret[9] = 'x';
	if (mode & S_ISVTX) ret[9] = (ret[9] == 'x') ? 't' : 'T';
	ret[10] = '\0';

	return ret;
}

void
put_filetree_file_line(
	FILE *fp,
	git_object *obj,
	const git_tree_entry *entry,
	char *filename,
	char *entrypath,
	const char *name,
	struct Weight weight
) {
	SPUTF(fp, "<tr><td>");
	SPUTF(fp, get_filemode(entry));
	SPUTF(fp, "</td><td><a href=\"");
	put_absolute_path(fp, "");
	put_percent_encoded(fp, filename, strlen(filename));
	SPUTF(fp, "\">");
	if (DIR_PAGES) put_xml(fp, name);
	else put_xml(fp, entrypath);
	SPUTF(fp, "</a></td><td class=\"num\" align=\"right\">");
	put_size(fp, weight.lines, 1);
	SPUTF(fp, "</td><td class=\"num\" align=\"right\">");
	put_size(fp, weight.bytes, 1);
	SPUTF(fp, "</td></tr>\n");
}

void
put_filetree_dir_line(
	FILE *fp,
	const git_tree_entry *entry,
	char *destination,
	const char *title,
	size_t lines,
	size_t bytes
) {
	SPUTF(fp, "<tr><td>");
	SPUTF(fp, get_filemode(entry));
	SPUTF(fp, "</td><td><a href=\"");
	put_absolute_path(fp, "");
	put_percent_encoded(fp, destination, strlen(destination));
	SPUTF(fp, "\">");
	put_xml(fp, title);
	SPUTF(fp, "</a></td><td class=\"num\" align=\"right\">");
	put_size(fp, lines, 1);
	SPUTF(fp, "</td><td class=\"num\" align=\"right\">");
	put_size(fp, bytes, 1);
	SPUTF(fp, "</td></tr>\n");
}

void put_filetree_backlink_line(FILE *fp, const char *path) {
	char previous_path[PATH_MAX];
	char previous_filename[PATH_MAX];
	int i, r, last_slash = 0;
	
	/* figure out previous directory */
	// TODO how to do this more cleanly...
	for (i = 0; path[i] != '\0'; i++) {
		previous_path[i] = path[i];
		if (path[i] == '/') last_slash = i;
	}
	previous_path[last_slash] = '\0';

	if (last_slash == 0) {
		put_filetree_dir_line(fp, NULL, "files.html", "..", 0, 0);
	} else {
		r = snprintf(previous_filename, sizeof(previous_filename), "files/%s.html", previous_path);
		if (r < 0 || (size_t) r >= sizeof(previous_filename))
			errx(1, "path truncated: 'files/%s.html'", previous_path);
		put_filetree_dir_line(fp, NULL, previous_filename, "..", 0, 0);
	}
}

/* need this here to allow recursion */
struct Weight write_filetree(
	const char *path,
	const char *filename,
	git_tree *tree
);
struct Weight put_file_list(FILE *fp, git_tree *tree, const char *path);

struct Weight
put_entry_obj(FILE *fp, git_object *obj, const git_tree_entry *entry, char *entrypath, const char *name)
{
	struct Weight ret;
	git_object_t obj_type = git_object_type(obj);
	char filename[PATH_MAX];
	int r;
	
	/* filename = f("files/%s.html", entrypath) */
	r = snprintf(filename, sizeof(filename), "files/%s.html", entrypath);
	if (r < 0 || (size_t) r >= sizeof(filename))
		errx(1, "path truncated: 'files/%s.html'", entrypath);

	switch (obj_type) {
	case GIT_OBJ_TREE:
		if (DIR_PAGES) {
			/* create dir page */
			ret = write_filetree(entrypath, filename, (git_tree *) obj);
			
			/* add link to that dir page */
			put_filetree_dir_line(fp, entry, filename, name, ret.lines, ret.bytes);
		} else {
			/* list files on this page */
			ret = put_file_list(fp, (git_tree *) obj, entrypath);
		}
		break;
	case GIT_OBJ_BLOB:
		ret = write_blob((git_blob *) obj, filename, entrypath, name);
		put_filetree_file_line(fp, obj, entry, filename, entrypath, name, ret);
		break;
	default: break;
	}

	return ret;
}

void
put_submodule_obj(FILE *fp, const git_tree_entry *entry, const char *name)
{
	char oid[8];

	SPUTF(fp, "<tr>" "<td>m---------</td>" "<td><a href=\"");
	put_absolute_path(fp, "files/.gitmodules.html");
	SPUTF(fp, "\">");
	put_xml(fp, name);
	SPUTF(fp, "</a> @ ");
	git_oid_tostr(oid, sizeof(oid), git_tree_entry_id(entry));
	put_xml(fp, oid);
	SPUTF(fp, "</td>" "<td class=\"num\" align=\"right\"></td>" "\n");
	SPUTF(fp, "<td class=\"num\" align=\"right\"></td>" "</tr>" "\n");
}

struct Weight
put_file_list(FILE *fp, git_tree *tree, const char *path)
{
	struct Weight ret;
	size_t count;
	size_t i;

	ret.lines = ret.bytes = 0;

	count = git_tree_entrycount(tree);
	for (i = 0; i < count; i++) {
		const git_tree_entry *entry = NULL;
		const char *name;
		char entrypath[PATH_MAX];
		git_object *obj = NULL;

		if (
			!(entry = git_tree_entry_byindex(tree, i)) ||
			!(name = git_tree_entry_name(entry))
		)
			return ret;

		combine_paths(entrypath, path, name);

		if (!git_tree_entry_to_object(&obj, repo, entry)) {
			struct Weight weight =
				put_entry_obj(fp, obj, entry, entrypath, name);
			ret.bytes += weight.bytes;
			ret.lines += weight.lines;
			git_object_free(obj);
			continue;
		}

		if (git_tree_entry_type(entry) == GIT_OBJ_COMMIT) {
			put_submodule_obj(fp, entry, name);
			continue;
		}
	}

	return ret;
}

struct Weight
write_filetree(const char *path, const char *filename, git_tree *tree)
{
	struct Weight ret;
	char fname[PATH_MAX] = "";
	FILE *fp;

	get_page_path(fname, sizeof(fname), opt.out_dir, (char *) filename);
	fp = fopen_w(fname);

	put_header(fp, "Files");
	
	put_file_title(fp, path, 1);

	SPUTF(
		fp,
		"<table id=\"files\"><thead>" "\n" "<tr>"
		"<td><b>Mode</b></td><td><b>Name</b></td>"
		"<td class=\"num\" align=\"right\"><b>  L </b></td>"
		"<td class=\"num\" align=\"right\"><b>  B </b></td>"
		"</tr>" "\n" "</thead><tbody>" "\n"
	);

	if (tree != NULL) {
		if (BACKLINKS && path[0] != '\0')
			put_filetree_backlink_line(fp, path);

		ret = put_file_list(fp, tree, path);
	}

	SPUTF(fp, "</tbody></table>");

	// TODO how can this get printed before the contents...
	/*
	SPUTF(fp, "<p>Totals: ");
	put_size(fp, ret.lines, 0);
	SPUTF(fp, "L ");
	put_size(fp, ret.bytes, 0);
	SPUTF(fp, "B</p>");
	*/

	put_footer(fp);
	check_file_error(fp, fname, 'w');
	fclose(fp);

	return ret;
}

void
walk_git_tree(const git_oid *id)
{
	git_tree *tree = NULL;
	git_commit *commit = NULL;
	int has_files;
	
	if (!id) return;

	has_files = !git_commit_lookup(&commit, repo, id) &&
		!git_commit_tree(&tree, commit);

	write_filetree("", "files.html", has_files ? tree : NULL);

	git_commit_free(commit);
	git_tree_free(tree);
}

int
put_refs(FILE *fp)
{
	struct ReferenceInfo *ris = NULL;
	struct CommitInfo *ci;
	size_t count, i, j, refcount;
	const char *titles[] = { "Branches", "Tags" };
	const char *ids[] = { "branches", "tags" };
	const char *s;

	if (get_refs(&ris, &refcount) == -1)
		return -1;

	for (i = 0, j = 0, count = 0; i < refcount; i++) {
		if (j == 0 && git_reference_is_tag(ris[i].ref)) {
			if (count)
				fputs("</tbody></table><br/>\n", fp);
			count = 0;
			j = 1;
		}

		/* print header if it has an entry (first). */
		if (++count == 1)
			fprintf(
				fp,
				"<h2>%s</h2><table id=\"%s\">"
				"<thead>\n<tr><td><b>Name</b></td>"
				"<td><b>Last commit date</b></td>"
				"<td><b>Author</b></td>\n</tr>\n"
				"</thead><tbody>\n",
				titles[j],
				ids[j]
			);

		ci = ris[i].ci;
		s = git_reference_shorthand(ris[i].ref);

		fputs("<tr><td>", fp);
		put_xml(fp, s);
		fputs("</td><td>", fp);
		if (ci->author)
			printtimeshort(fp, &(ci->author->when));
		fputs("</td><td>", fp);
		if (ci->author)
			put_xml(fp, ci->author->name);
		fputs("</td></tr>\n", fp);
	}

	if (count)
		fputs("</tbody></table><br/>\n", fp);

	for (i = 0; i < refcount; i++) {
		commit_info_free(ris[i].ci);
		git_reference_free(ris[i].ref);
	}
	free(ris);

	return 0;
}

void
write_log_page(const git_oid *head)
{
	FILE *fp;
	char fname[PATH_MAX];

	get_page_path(fname, sizeof(fname), opt.out_dir, "log.html");
	fp = fopen_w(fname);

	put_log_html(fp, head);

	check_file_error(fp, fname, 'w');
	fclose(fp);
}

void
write_refs_page()
{
	FILE *fp;
	char fname[PATH_MAX];

	get_page_path(fname, sizeof(fname), opt.out_dir, "refs.html");
	fp = fopen_w(fname);

	put_header(fp, "Refs");
	put_refs(fp);
	put_footer(fp);

	check_file_error(fp, fname, 'w');
	fclose(fp);
}

void
write_feed()
{
	FILE *fp;
	char fname[PATH_MAX];

	get_page_path(fname, sizeof(fname), opt.out_dir, "atom.xml");
	fp = fopen_w(fname);

	write_atom(fp, 1);

	check_file_error(fp, fname, 'w');
	fclose(fp);
}

void
write_releases_feed()
{
	FILE *fp;
	char fname[PATH_MAX];

	get_page_path(fname, sizeof(fname), opt.out_dir, "tags.xml");
	fp = fopen_w(fname);

	write_atom(fp, 0);

	check_file_error(fp, fname, 'w');
	fclose(fp);
}

void
find_submodules()
{
	git_object *obj = NULL;
	if (
		!git_revparse_single(&obj, repo, "HEAD:.gitmodules") &&
		git_object_type(obj) == GIT_OBJ_BLOB
	)
		submodules = ".gitmodules";
	git_object_free(obj);
}

void
find_description()
{
	char path[PATH_MAX];
	FILE *fp;
	if ((fp = git_fopen(path, sizeof(path), ".git/description"))) {
		if (!fgets(description, sizeof(description), fp))
			description[0] = '\0';
		check_file_error(fp, path, 'r');
		fclose(fp);
	}
}

void
find_clone_url()
{
	char path[PATH_MAX];
	FILE *fp;
	if ((fp = git_fopen(path, sizeof(path), ".git/url"))) {
		if (!fgets(clone_url, sizeof(clone_url), fp))
			clone_url[0] = '\0';
		check_file_error(fp, path, 'r');
		fclose(fp);

		// TODO ???
		clone_url[strcspn(clone_url, "\n")] = '\0';
	}
}

void
find_repo_name()
{
	char abs_dir[PATH_MAX + 1];
	char *p;

	/* set abs_dir */
	if (!realpath(repo_dir, abs_dir))
		err(1, "realpath");

	if ((name = strrchr(abs_dir, '/'))) name++;
	else name = "";

	if (!(repo_name = strdup(name))) err(1, "strdup");
	if ((p = strrchr(repo_name, '.')))
		if (!strcmp(p, ".git"))
			*p = '\0';

	if (repo_name[0] == '\0')
		repo_name = "untitled";
}

int
write_repo_pages(const char* dir)
{

	// TODO fully stop using globals like this....
	repo_dir = dir;

#ifdef __OpenBSD__
	if (unveil(repo_dir, "r") == -1) err(1, "unveil: %s", repo_dir);
	if (unveil(".", "rwc") == -1) err(1, "unveil: .");

	/*
	if (cachefile) {
		if (unveil(cachefile, "rwc") == -1) err(1, "unveil: %s", cachefile);
		if (pledge("stdio rpath wpath cpath fattr", NULL) == -1) err(1, "pledge");
	} else {
		if (pledge("stdio rpath wpath cpath", NULL) == -1) err(1, "pledge");
	}
	*/
#endif

	/* open the git repo */
	int result = git_repository_open_ext(
		&repo, repo_dir, GIT_REPOSITORY_OPEN_NO_SEARCH, NULL
	);
	if (result < 0) {
		fprintf(stderr, "fatal: cannot open repository '%s'" "\n", dir);
		return 1;
	}

	/* find HEAD */
	const git_oid *head = NULL;
	git_object *obj = NULL;
	if (!git_revparse_single(&obj, repo, "HEAD"))
		head = git_object_id(obj);
	git_object_free(obj);

	/* set global vars... */
	// TODO repo = open_repo();
	find_repo_name();
	find_description();
	find_clone_url();
	find_license();
	find_readme();
	find_submodules();
	if (opt.index) find_owner();

	if (opt.index) {
		put_index_log(index_fp, repo, description, repo_name, readme);
	}

	if (opt.pages) {
		write_log_page(head);
		walk_git_tree(head);
		write_refs_page();
		write_feed();
		write_releases_feed();
	}

	/* clean up */
	// TODO close_repo();
	git_repository_free(repo);

	return 0;
}

void
begin_index()
{
	get_index_page_path(
		index_fname,
		sizeof(index_fname),
		opt.out_dir,
		INDEX_DEST
	);
	index_fp = fopen_w(index_fname);
	put_index_header(index_fp);
}

void
end_index()
{
	put_index_footer(index_fp);	
	check_file_error(index_fp, index_fname, 'w');
	fclose(index_fp);
}

void
init_lib_git()
{
	int i;

	/* do not search outside the git repository:
	   GIT_CONFIG_LEVEL_APP is the highest level currently */
	git_libgit2_init();
	for (i = 1; i <= GIT_CONFIG_LEVEL_APP; i++)
		git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, i, "");

	/* do not require the git repository to be owned by the current user */
	git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 0);
}

int
main(int argc, const char *argv[])
{
	int i, result;

	if (parse_opts(&opt, argc, argv) == OPT_FAIL) {
		PRINT_USAGE(argv[0]);
		return 1;
	}

	if (!opt.pages && !opt.index) {
		printf("Nothing to do, use -i and/or -p." "\n\n");
		PRINT_USAGE(argv[0]);
		return 1;
	}

	init_lib_git();

	if (opt.index) begin_index();
	for (i = 0; i < opt.repo_count; i++) {
		result = write_repo_pages(opt.repo_dirs[i]);
		if(result > 0) return 1;
	}
	if (opt.index) end_index();

	git_libgit2_shutdown();

	return 0;
}