index : cgit

/*
 * The two kinds of raw text cgit reads before it can render a page, the path
 * of the incoming request and the body of a commit or a tag object. Reading
 * the request path settles which repository and which page the request works
 * on. Commit and tag objects arrive as header lines, a blank line, and then
 * the message, so the readers here walk the headers, copy out the fields the
 * pages need, and re-encode the message into the page encoding. The records
 * they return are freed here too.
 */

#define USE_THE_REPOSITORY_VARIABLE

#include "cgit.h"
#include "parsing.h"
#include "shared.h"

#include <mailmap.h>

// The repository's mailmap, read once per request and applied to every ident a
// page shows. Only the blob at HEAD is read, the way git reads a bare
// repository, so a repository cannot point the reader at a file on the server.
static struct string_list mailmap = STRING_LIST_INIT_DUP;
static int mailmap_read;

struct string_list *cgit_mailmap(void)
{
	if (!ctx.repo || !ctx.repo->enable_mailmap)
		return NULL;
	if (!mailmap_read) {
		mailmap_read = 1;
		read_mailmap_blob(the_repository, &mailmap, "HEAD:.mailmap");
	}
	return mailmap.nr ? &mailmap : NULL;
}

static void parse_user(const char *line, char **name, char **email, timestamp_t *date, int *tz)
{
	struct ident_split ident;
	struct strbuf address = STRBUF_INIT;
	struct string_list *map;
	const char *name_start, *mail_start;
	size_t name_len, mail_len;

	if (!split_ident_line(&ident, line, strchrnul(line, '\n') - line)) {
		name_start = ident.name_begin;
		name_len = ident.name_end - ident.name_begin;
		mail_start = ident.mail_begin;
		mail_len = ident.mail_end - ident.mail_begin;
		map = cgit_mailmap();
		if (map)
			map_user(map, &mail_start, &mail_len, &name_start, &name_len);
		*name = xmemdupz(name_start, name_len);

		strbuf_addch(&address, '<');
		strbuf_add(&address, mail_start, mail_len);
		strbuf_addch(&address, '>');
		*email = strbuf_detach(&address, NULL);

		// Clamped as git's own show_ident_date clamps them: a date past
		// what the system can hold becomes the epoch, and a zone that is
		// no hhmm offset becomes UTC, where git's date code would die on
		// either and take the whole page with it.
		if (ident.date_begin)
			*date = parse_timestamp(ident.date_begin, NULL, 10);
		if (date_overflows(*date))
			*date = 0;
		if (ident.tz_begin) {
			long zone = strtol(ident.tz_begin, NULL, 10);
			long west = zone < 0 ? -zone : 0;

			*tz = zone > -10000 && zone < 10000 ? zone : 0;
			// A date earlier than its own westward offset has no
			// local time before the epoch to show.
			if (*date < (timestamp_t)((west / 100) * 60 + west % 100) * 60)
				*tz = 0;
		}
	}
}

static const char *next_header_line(const char *p)
{
	p = strchr(p, '\n');
	if (!p)
		return NULL;
	return p + 1;
}

static int end_of_header(const char *p)
{
	return !p || (*p == '\n');
}

/*
 * Converts a field into the page encoding, which is UTF-8. A git built
 * without iconv still offers reencode_string, where it always fails, and a
 * field can be labelled UTF-8 without being it, so whatever is left that is
 * not UTF-8 has its stray bytes replaced, and a page declared UTF-8 never
 * carries any.
 */
static void reencode(char **text, const char *encoding)
{
	char *converted;

	if (!*text)
		return;

	if (strcasecmp(encoding, PAGE_ENCODING)) {
		converted = reencode_string(*text, PAGE_ENCODING, encoding);
		if (converted) {
			free(*text);
			*text = converted;
		}
	}
	cgit_utf8_sanitize(*text);
}

/*
 * A repository url may itself contain slashes, so every slash-separated
 * prefix is looked up and the longest one that names a repository wins.
 */
void cgit_parse_url(const char *url)
{
	char *buf, *slash, *repo_end, *page_end;
	struct cgit_repo *repo;

	if (!url || url[0] == '\0')
		return;

	ctx.qry.page = NULL;
	ctx.repo = cgit_get_repoinfo(url);
	if (ctx.repo) {
		ctx.qry.repo = ctx.repo->url;
		return;
	}

	buf = xstrdup(url);
	repo_end = NULL;
	slash = strchr(buf, '/');
	while (slash) {
		slash[0] = '\0';
		repo = cgit_get_repoinfo(buf);
		if (repo) {
			ctx.repo = repo;
			repo_end = slash;
		}
		slash[0] = '/';
		slash = strchr(slash + 1, '/');
	}

	if (repo_end) {
		ctx.qry.repo = ctx.repo->url;
		page_end = strchr(repo_end + 1, '/');
		if (page_end) {
			page_end[0] = '\0';
			if (page_end[1])
				ctx.qry.path = cgit_trim_end(page_end + 1, '/');
		}
		if (repo_end[1])
			ctx.qry.page = xstrdup(repo_end + 1);
	}
	free(buf);
}

struct commitinfo *cgit_parse_commit(struct commit *commit)
{
	struct commitinfo *info;
	const char *p = repo_get_commit_buffer(the_repository, commit, NULL);
	const char *eol;
	char *encoding = NULL;

	info = xcalloc(1, sizeof(struct commitinfo));
	info->commit = commit;

	if (!p)
		return info;

	if (!skip_prefix(p, "tree ", &p))
		die("Unable to parse commit %s", oid_to_hex(&commit->object.oid));
	p += the_hash_algo->hexsz + 1;

	while (skip_prefix(p, "parent ", &p))
		p += the_hash_algo->hexsz + 1;

	if (skip_prefix(p, "author ", &p)) {
		parse_user(p, &info->author, &info->author_email, &info->author_date, &info->author_tz);
		p = next_header_line(p);
	}

	if (p && skip_prefix(p, "committer ", &p)) {
		parse_user(p, &info->committer, &info->committer_email, &info->committer_date,
			&info->committer_tz);
		p = next_header_line(p);
	}

	if (p && skip_prefix(p, "encoding ", &p)) {
		eol = strchr(p, '\n');
		if (eol) {
			encoding = xmemdupz(p, eol - p);
			p = eol + 1;
		}
	}

	// Git only writes the header when the message is in something other
	// than UTF-8, so its absence means UTF-8.
	if (!encoding)
		encoding = xstrdup("UTF-8");

	while (!end_of_header(p))
		p = next_header_line(p);
	while (p && *p == '\n')
		p++;

	if (p) {
		eol = strchrnul(p, '\n');
		info->subject = xmemdupz(p, eol - p);
		while (*eol == '\n')
			eol++;
		info->msg = xstrdup(eol);
	} else {
		// An object truncated mid header leaves nothing after it,
		// and callers render subject and msg without NULL checks.
		info->subject = xstrdup("");
		info->msg = xstrdup("");
	}

	reencode(&info->author, encoding);
	reencode(&info->author_email, encoding);
	reencode(&info->committer, encoding);
	reencode(&info->committer_email, encoding);
	reencode(&info->subject, encoding);
	reencode(&info->msg, encoding);
	free(encoding);

	return info;
}

void cgit_free_commitinfo(struct commitinfo *info)
{
	free(info->author);
	free(info->author_email);
	free(info->committer);
	free(info->committer_email);
	free(info->subject);
	free(info->msg);
	free(info);
}

struct taginfo *cgit_parse_tag(struct tag *tag)
{
	void *data;
	enum object_type type;
	size_t size;
	const char *p;
	struct taginfo *info = NULL;

	data = odb_read_object(the_repository->objects, &tag->object.oid, &type, &size);
	if (!data || type != OBJ_TAG)
		goto cleanup;

	info = xcalloc(1, sizeof(struct taginfo));

	for (p = data; !end_of_header(p); p = next_header_line(p)) {
		if (skip_prefix(p, "tagger ", &p))
			parse_user(p, &info->tagger, &info->tagger_email, &info->tagger_date, &info->tagger_tz);
	}

	while (p && *p == '\n')
		p++;

	if (p && *p)
		info->msg = xstrdup(p);

	// A tag carries no encoding header, so its text is taken as UTF-8 and
	// cleaned the way a commit's is.
	cgit_utf8_sanitize(info->tagger);
	cgit_utf8_sanitize(info->tagger_email);
	cgit_utf8_sanitize(info->msg);

cleanup:
	free(data);
	return info;
}

void cgit_free_taginfo(struct taginfo *info)
{
	// NULL is accepted because cgit_parse_tag returns it for a tag object
	// that cannot be read, and a ref left holding that still gets freed
	// along with the rest of its list.
	if (!info)
		return;
	free(info->tagger);
	free(info->tagger_email);
	free(info->msg);
	free(info);
}