index : cgit

/*
 * The tree page, which renders one level of a repository at a revision as a
 * table of the folders and files in it, or the contents of the file when the
 * path names one. A file is shown as numbered source, passed through the
 * repository's source filter when it has one, or as a hex dump when its bytes
 * look binary. A folder whose only entry is another folder is followed, and
 * both are named in the same row, so a long chain of single folders does not
 * cost a page each.
 */

#define USE_THE_REPOSITORY_VARIABLE

#include "cgit.h"
#include "filter.h"
#include "html.h"
#include "shared.h"
#include "ui-shared.h"
#include "ui-tree.h"

#include <odb/streaming.h>

#define HEXDUMP_ROW_BYTES 32
#define HEXDUMP_ROW_HALF (HEXDUMP_ROW_BYTES / 2)
#define HEXDUMP_GAP_WIDTH 4

// Every byte dumped costs about seven bytes of markup, so a blob near
// max-blob-size would make a page several times its own size.
#define HEXDUMP_MAX_BYTES (64 * 1024)

// How far into a buffer buffer_is_binary looks, the window git judges a file
// binary by.
#define BINARY_SNIFF_BYTES 8000

// How many single-child directories a listing row follows into one path.
#define MAX_DIR_CHAIN_LEVELS 15

enum walk_state {
	WALK_LOOKING,
	WALK_LISTING,
	WALK_BLOB_SHOWN,
	WALK_ERROR_SHOWN,
};

struct ls_entry {
	struct object_id oid;
	char *name;
	unsigned mode;
};

struct walk_tree_context {
	const char *rev;
	char *match_path;
	enum walk_state state;
	struct ls_entry *entries;
	size_t entries_nr, entries_alloc;
};

// The count runs past one as soon as a second entry or a file turns up, which
// ends the descent.
struct only_child {
	struct strbuf *path;
	struct object_id oid;
	char *name;
	size_t count;
};

static void print_linenumbers(const char *buf, size_t size)
{
	size_t lines = 0, idx;

	if (size) {
		lines = 1;
		// The newline that ends the last line must not open a line of
		// its own, so the final byte is left out of the count.
		for (idx = 0; idx < size - 1; idx++)
			if (buf[idx] == '\n')
				lines++;
	}
	cgit_print_line_anchors(1, lines);
}

static void print_text_buffer(const char *filename, char *buf, size_t size)
{
	html("<table class='blob' role='presentation'>\n");

	if (ctx.cfg.enable_tree_linenumbers) {
		html("<tr><td class='linenumbers'><pre>");
		print_linenumbers(buf, size);
		html("</pre></td>\n");
	} else {
		html("<tr>\n");
	}

	html("<td class='lines'><pre><code>");
	if (ctx.repo->source_filter) {
		cgit_open_filter(ctx.repo->source_filter, filename);
		html_raw(buf, size);
		cgit_close_filter(ctx.repo->source_filter);
	} else {
		html_blob_txt(buf, size);
	}
	html("</code></pre></td></tr></table>\n");
}

/*
 * git's ctype macros are locale free, but there is no isgraph among them, so
 * the dump works one out for itself.
 */
static int is_graphic(unsigned char ch)
{
	return isprint(ch) && !isspace(ch);
}

static void print_binary_buffer(char *buf, size_t size, const char *path, const char *rev)
{
	size_t offset, idx, shown = size < HEXDUMP_MAX_BYTES ? size : HEXDUMP_MAX_BYTES;
	char ascii[HEXDUMP_ROW_BYTES + 1];
	struct strbuf row = STRBUF_INIT;

	html("<table class='bin-blob'>\n");
	html("<tr><th>ofs</th><th>hex dump</th><th>ascii</th></tr>\n");

	// A row goes out in one write rather than a write per byte.
	for (offset = 0; offset < shown; offset += HEXDUMP_ROW_BYTES, buf += HEXDUMP_ROW_BYTES) {
		strbuf_reset(&row);
		strbuf_addf(&row, "<tr><td class='right'>%04zx</td><td class='hex'>", offset);
		for (idx = 0; idx < HEXDUMP_ROW_BYTES && offset + idx < shown; idx++) {
			int gap = idx == HEXDUMP_ROW_HALF ? HEXDUMP_GAP_WIDTH : 1;

			strbuf_addf(&row, "%*s%02x", gap, "", (unsigned char)buf[idx]);
		}
		strbuf_addstr(&row, " </td><td class='hex'>");
		html_raw(row.buf, row.len);

		for (idx = 0; idx < HEXDUMP_ROW_BYTES && offset + idx < shown; idx++)
			ascii[idx] = is_graphic(buf[idx]) ? buf[idx] : '.';
		ascii[idx] = '\0';
		html_txt(ascii);
		html("</td></tr>\n");
	}
	strbuf_release(&row);
	html("</table>\n");
	if (shown < size) {
		htmlf("<div class='truncated'>Only the first %d KB of this file are shown. ",
			HEXDUMP_MAX_BYTES / 1024);
		cgit_plain_link("View the whole file", NULL, NULL, ctx.qry.head, rev, path);
		html(".</div>\n");
	}
}

/*
 * Answer whether the page layout was left open for the caller to close. A
 * false means a complete error page went out in place of the blob, so nothing
 * may be added to it.
 */
static bool print_object(const struct object_id *oid, unsigned mode, const char *path,
	const char *filename, const char *rev)
{
	enum object_type type;
	char *buf;
	size_t size;
	bool is_binary;

	type = odb_read_object_info(the_repository->objects, oid, &size);
	if (type == OBJ_BAD) {
		cgit_print_error_page(404, "Not Found", "Bad object id: %s", oid_to_hex(oid));
		return false;
	}

	if (cgit_blob_too_large(size)) {
		cgit_print_blob_too_large(size);
		return false;
	}

	buf = odb_read_object(the_repository->objects, oid, &type, &size);
	if (!buf) {
		cgit_print_error_page(500, "Internal Server Error", "Unable to read object %s",
			oid_to_hex(oid));
		return false;
	}
	// buffer_is_binary only sniffs the front of the blob, and a NUL past
	// that window would end a Lua filter's output early while the line
	// number column still counts the whole file, so check the rest too.
	is_binary = buffer_is_binary(buf, size) || memchr(buf, 0, size);

	cgit_set_title_from_path(path);

	cgit_print_layout_start();
	htmlf("<div class='blob-header'>blob: %s (", oid_to_hex(oid));
	cgit_plain_link("plain", NULL, NULL, ctx.qry.head, rev, path);
	if (ctx.repo->enable_blame && S_ISREG(mode) && !is_binary) {
		html(") (");
		cgit_blame_link("blame", NULL, NULL, ctx.qry.head, rev, path);
	}
	html(")</div>\n");

	if (is_binary)
		print_binary_buffer(buf, size, path, rev);
	else
		print_text_buffer(filename, buf, size);

	free(buf);
	return true;
}

static int only_child_cb(const struct object_id *oid, struct strbuf *base UNUSED,
	const char *pathname, unsigned mode, void *data)
{
	struct only_child *child = data;

	if (++child->count > 1)
		return -1;

	if (!S_ISDIR(mode)) {
		child->count = 2;
		return -1;
	}

	child->name = xstrdup(pathname);
	oidcpy(&child->oid, oid);
	strbuf_addf(child->path, "/%s", pathname);
	return 0;
}

static void print_dir_chain(const struct object_id *oid, const char *name,
	const char *rev, struct strbuf *fullpath)
{
	size_t initial_length = fullpath->len;
	struct tree *tree;
	struct only_child child = {
		.path = fullpath,
		.count = 1,
	};
	struct pathspec paths = {
		.nr = 0
	};
	int levels = 0;

	oidcpy(&child.oid, oid);

	// Each level links the whole path so far, so a chain of thousands of
	// single directories would make one row quadratic in size.
	while (child.count == 1 && levels++ < MAX_DIR_CHAIN_LEVELS) {
		cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head, rev, fullpath->buf);

		tree = lookup_tree(the_repository, &child.oid);
		if (!tree)
			break;

		free(child.name);
		child.name = NULL;
		child.count = 0;

		read_tree(the_repository, tree, &paths, only_child_cb, &child);

		// The separator only goes out ahead of a level that will follow.
		if (child.count != 1 || levels == MAX_DIR_CHAIN_LEVELS)
			break;

		html(" / ");
		name = child.name;
	}

	free(child.name);
	strbuf_setlen(fullpath, initial_length);
}

/*
 * Whether git counts the blob as binary, read through a stream so that only
 * the bytes buffer_is_binary looks at are inflated, however large the blob.
 */
static bool blob_starts_binary(const struct object_id *oid)
{
	char buf[BINARY_SNIFF_BYTES];
	struct odb_stream *stream;
	size_t got = 0;
	ssize_t n;

	stream = odb_stream_from_object(the_repository->objects, oid, NULL);
	if (!stream)
		return false;
	while (got < sizeof(buf) && (n = odb_stream_read(stream, buf + got, sizeof(buf) - got)) > 0)
		got += n;
	odb_stream_close(stream);
	return buffer_is_binary(buf, got);
}

static void print_ls_row(const struct object_id *oid, const char *name,
	unsigned mode, struct walk_tree_context *walk)
{
	struct strbuf fullpath = STRBUF_INIT;
	struct strbuf linkpath = STRBUF_INIT;
	struct strbuf class = STRBUF_INIT;
	enum object_type type;
	size_t size = 0;
	char *buf;

	strbuf_addf(&fullpath, "%s%s%s", ctx.qry.path ? ctx.qry.path : "", ctx.qry.path ? "/" : "", name);

	if (!S_ISGITLINK(mode)) {
		type = odb_read_object_info(the_repository->objects, oid, &size);
		if (type == OBJ_BAD) {
			// The name comes from the tree, so it can hold
			// anything a commit was allowed to record.
			html("<tr><td colspan='4'>Bad object: ");
			html_txt(name);
			htmlf(" %s</td></tr>\n", oid_to_hex(oid));
			goto cleanup;
		}
	}

	if (S_ISGITLINK(mode))
		html("<tr class='mod'><td class='ls-mode'>");
	else if (S_ISDIR(mode))
		html("<tr class='dir'><td class='ls-mode'>");
	else if (S_ISLNK(mode))
		html("<tr class='link'><td class='ls-mode'>");
	else
		html("<tr class='blob'><td class='ls-mode'>");
	cgit_print_filemode(mode);
	html("</td><td>");
	if (S_ISGITLINK(mode)) {
		cgit_submodule_link("ls-mod", fullpath.buf, oid_to_hex(oid));
	} else if (S_ISDIR(mode)) {
		print_dir_chain(oid, name, walk->rev, &fullpath);
	} else {
		const char *ext = strrchr(name, '.');

		strbuf_addstr(&class, "ls-blob");
		// The extension becomes a class a stylesheet can pick files out
		// by, prefixed so that a name such as x.button cannot land on a
		// class of the theme's own.
		if (ext && ext[1] && strspn(ext + 1, "abcdefghijklmnopqrstuvwxyz"
				"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-") == strlen(ext + 1))
			strbuf_addf(&class, " ext-%s", ext + 1);
		cgit_tree_link(name, NULL, class.buf, ctx.qry.head, walk->rev, fullpath.buf);
	}
	// A target longer than any path is no link, and reading it would pull
	// a blob of any size into memory.
	if (S_ISLNK(mode) && size <= PATH_MAX) {
		html(" -> ");
		buf = odb_read_object(the_repository->objects, oid, &type, &size);
		// An unreadable target stands in for the link, and the rest of
		// the row still goes out so the table stays whole.
		if (!buf) {
			htmlf("Unable to read object %s", oid_to_hex(oid));
		} else {
			strbuf_addbuf(&linkpath, &fullpath);
			strbuf_addf(&linkpath, "/../%s", buf);
			// A target climbing above the tree root, or one given
			// from the root of the filesystem, has nothing in the
			// tree to link to.
			if (buf[0] == '/' || strbuf_normalize_path(&linkpath))
				html_txt(buf);
			else
				cgit_tree_link(buf, NULL, class.buf, ctx.qry.head, walk->rev,
					linkpath.buf);
			free(buf);
			strbuf_release(&linkpath);
		}
	}
	if (S_ISGITLINK(mode))
		html("</td><td class='ls-size'>-</td>");
	else
		htmlf("</td><td class='ls-size'>%zu</td>", size);

	html("<td class='ls-links'>");
	cgit_log_link("log", NULL, "button", ctx.qry.head, walk->rev, fullpath.buf,
		0, NULL, NULL, ctx.qry.showmsg, 0);
	if (ctx.repo->max_stats)
		cgit_stats_link("stats", NULL, "button", ctx.qry.head, fullpath.buf);
	if (!S_ISGITLINK(mode))
		cgit_plain_link("plain", NULL, "button", ctx.qry.head, walk->rev, fullpath.buf);
	// The blame page refuses a binary file and one past max-blob-size, so
	// neither is offered it.
	if (
		S_ISREG(mode)              &&
		ctx.repo->enable_blame     &&
		!cgit_blob_too_large(size) &&
		!blob_starts_binary(oid)
	)
		cgit_blame_link("blame", NULL, "button", ctx.qry.head, walk->rev, fullpath.buf);
	html("</td></tr>\n");

cleanup:
	strbuf_release(&fullpath);
	strbuf_release(&class);
}

static int ls_item(const struct object_id *oid, struct strbuf *base UNUSED,
	const char *pathname, unsigned mode, void *data)
{
	struct walk_tree_context *walk = data;

	// With folders grouped first, a row cannot go out as it arrives,
	// because git hands the level over in name order.
	if (ctx.cfg.enable_tree_group_dirs) {
		struct ls_entry *entry;

		ALLOC_GROW(walk->entries, walk->entries_nr + 1, walk->entries_alloc);
		entry = &walk->entries[walk->entries_nr++];
		oidcpy(&entry->oid, oid);
		entry->name = xstrdup(pathname);
		entry->mode = mode;
		return 0;
	}

	print_ls_row(oid, pathname, mode, walk);
	return 0;
}

static void ls_flush(struct walk_tree_context *walk)
{
	size_t i;

	for (i = 0; i < walk->entries_nr; i++) {
		struct ls_entry *entry = &walk->entries[i];

		if (S_ISDIR(entry->mode))
			print_ls_row(&entry->oid, entry->name, entry->mode, walk);
	}
	for (i = 0; i < walk->entries_nr; i++) {
		struct ls_entry *entry = &walk->entries[i];

		if (!S_ISDIR(entry->mode))
			print_ls_row(&entry->oid, entry->name, entry->mode, walk);
	}

	for (i = 0; i < walk->entries_nr; i++)
		free(walk->entries[i].name);
	free(walk->entries);
	walk->entries = NULL;
	walk->entries_nr = walk->entries_alloc = 0;
}

static void ls_head(void)
{
	cgit_print_layout_start();
	html("<table class='list tree' aria-label='Files'>\n<tbody class='tree'>\n");
	html("<tr class='nohover'>");
	html("<th class='left ls-mode' scope='col'>Mode</th>");
	html("<th class='left' scope='col'>Name</th>");
	html("<th class='right' scope='col'>Size</th>");
	html("<th class='ls-links' scope='col' aria-label='Links'></th>");
	html("</tr>\n");
}

static void ls_tail(void)
{
	html("</tbody>\n</table>\n");
	cgit_print_layout_end();
}

static int walk_tree(const struct object_id *oid, struct strbuf *base,
	const char *pathname, unsigned mode, void *data)
{
	struct walk_tree_context *walk = data;

	if (walk->state == WALK_LOOKING) {
		struct strbuf fullpath = STRBUF_INIT;

		strbuf_addbuf(&fullpath, base);
		strbuf_addstr(&fullpath, pathname);
		if (strcmp(walk->match_path, fullpath.buf))
			return READ_TREE_RECURSIVE;

		if (S_ISDIR(mode)) {
			walk->state = WALK_LISTING;
			cgit_set_title_from_path(fullpath.buf);
			strbuf_release(&fullpath);
			ls_head();
			return READ_TREE_RECURSIVE;
		} else if (S_ISGITLINK(mode)) {
			cgit_print_submodule_page(fullpath.buf, oid_to_hex(oid));
			walk->state = WALK_ERROR_SHOWN;
			strbuf_release(&fullpath);
			return 0;
		} else {
			bool shown = print_object(oid, mode, fullpath.buf, pathname, walk->rev);

			walk->state = shown ? WALK_BLOB_SHOWN : WALK_ERROR_SHOWN;
			strbuf_release(&fullpath);
			return 0;
		}
	}
	ls_item(oid, base, pathname, mode, walk);
	return 0;
}

/*
 * Either argument may be null, in which case the head of the current query
 * stands in for the revision and the listing starts at the root of the tree.
 */
void cgit_print_tree(const char *rev, char *path)
{
	struct object_id oid;
	struct commit *commit;
	struct pathspec_item path_item;
	struct pathspec paths = { 0 };
	struct walk_tree_context walk = {
		.match_path = path,
		.state = WALK_LOOKING
	};

	if (!rev)
		rev = ctx.qry.head;

	commit = cgit_get_commit(rev, &oid);
	if (!commit)
		return;

	walk.rev = rev;
	cgit_literal_pathspec(&paths, &path_item, path);

	if (!path) {
		// The walk is never handed an entry for the top of the tree
		// itself, so the listing it would have opened is opened here.
		cgit_prefix_title("tree");
		walk.state = WALK_LISTING;
		ls_head();
	}

	read_tree(the_repository, repo_get_commit_tree(the_repository, commit), &paths, walk_tree, &walk);
	if (walk.state == WALK_LISTING) {
		ls_flush(&walk);
		ls_tail();
	} else if (walk.state == WALK_BLOB_SHOWN) {
		cgit_print_layout_end();
	} else if (walk.state == WALK_LOOKING) {
		cgit_print_error_page(404, "Not Found", "Path not found");
	}
	// WALK_ERROR_SHOWN is left alone, since the error page the walk put
	// out is already complete.
}