Add support for downloading single blobs

Signed-off-by: Lars Hjemli <hjemli@gmail.com>

5 files changed, 47 insertions, 3 deletions

diff --git a/Makefile b/Makefile
index 24c3963..7c0527b 100644
--- a/Makefile
+++ b/Makefile
@@ -1,44 +1,44 @@
 CGIT_VERSION = 0.2
 
 prefix = /var/www/htdocs/cgit
 gitsrc = ../git
 
 SHA1_HEADER = <openssl/sha.h>
 
 CACHE_ROOT = /var/cache/cgit
 EXTLIBS = $(gitsrc)/libgit.a $(gitsrc)/xdiff/lib.a -lz -lcrypto
 OBJECTS = shared.o cache.o parsing.o html.o ui-shared.o ui-repolist.o \
 	ui-summary.o ui-log.o ui-view.o ui-tree.o ui-commit.o ui-diff.o \
-	ui-snapshot.o
+	ui-snapshot.o ui-blob.o
 
 CFLAGS += -Wall
 
 ifdef DEBUG
 	CFLAGS += -g
 endif
 
 CFLAGS += -I$(gitsrc) -DSHA1_HEADER='$(SHA1_HEADER)'
 
 all: cgit
 
 install: all clean-cache
 	mkdir -p $(prefix)
 	install cgit $(prefix)/cgit.cgi
 	install cgit.css $(prefix)/cgit.css
 
 cgit: cgit.c cgit.h $(OBJECTS) $(gitsrc)/libgit.a
 	$(CC) $(CFLAGS) -DCGIT_VERSION='"$(CGIT_VERSION)"' cgit.c -o cgit \
 		$(OBJECTS) $(EXTLIBS)
 
 $(OBJECTS): cgit.h
 
 $(gitsrc)/libgit.a:
 	$(MAKE) -C $(gitsrc)
 
 
 .PHONY: clean
 clean:
 	rm -f cgit *.o
 
 clean-cache:
 	rm -rf $(CACHE_ROOT)/*
diff --git a/cgit.c b/cgit.c
index 6dddcbb..28bab8d 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,254 +1,259 @@
 /* cgit.c: cgi for the git scm
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 
 const char cgit_version[] = CGIT_VERSION;
 
 
 static struct repoinfo *cgit_get_repoinfo(char *url)
 {
 	int i;
 	struct repoinfo *repo;
 	
 	for (i=0; i<cgit_repolist.count; i++) {
 		repo = &cgit_repolist.repos[i];
 		if (!strcmp(repo->url, url))
 			return repo;
 	}
 	return NULL;
 }
 
 
 static int cgit_prepare_cache(struct cacheitem *item)
 {
 	if (!cgit_query_repo) {
 		item->name = xstrdup(fmt("%s/index.html", cgit_cache_root));
 		item->ttl = cgit_cache_root_ttl;
 		return 1;
 	}
 	cgit_repo = cgit_get_repoinfo(cgit_query_repo);
 	if (!cgit_repo) {
 		char *title = fmt("%s - %s", cgit_root_title, "Bad request");
 		cgit_print_docstart(title, item);
 		cgit_print_pageheader(title, 0);
 		cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo));
 		cgit_print_docend();
 		return 0;
 	}
 
 	if (!cgit_query_page) {
 		item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root, 
 			   cgit_repo->url));
 		item->ttl = cgit_cache_repo_ttl;
 	} else {
 		item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, 
 			   cgit_repo->url, cgit_query_page, 
 			   cache_safe_filename(cgit_querystring)));
 		if (cgit_query_has_symref)
 			item->ttl = cgit_cache_dynamic_ttl;
 		else if (cgit_query_has_sha1)
 			item->ttl = cgit_cache_static_ttl;
 		else
 			item->ttl = cgit_cache_repo_ttl;
 	}
 	return 1;
 }
 
 static void cgit_print_repo_page(struct cacheitem *item)
 {
 	char *title;
 	int show_search;
 
 	if (chdir(cgit_repo->path)) {
 		title = fmt("%s - %s", cgit_root_title, "Bad request");
 		cgit_print_docstart(title, item);
 		cgit_print_pageheader(title, 0);
 		cgit_print_error(fmt("Unable to scan repository: %s",
 				     strerror(errno)));
 		cgit_print_docend();
 		return;
 	}
 
 	title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc);
 	show_search = 0;
 	setenv("GIT_DIR", cgit_repo->path, 1);
 
-	if (cgit_repo->snapshots && cgit_query_page && 
-	    !strcmp(cgit_query_page, "snapshot")) {
+	if (cgit_query_page) {
+	    if (cgit_repo->snapshots && !strcmp(cgit_query_page, "snapshot")) {
 		cgit_print_snapshot(item, cgit_query_sha1, "zip", 
 				    cgit_repo->url, cgit_query_name);
 		return;
+	    }
+	    if (!strcmp(cgit_query_page, "blob")) {
+		    cgit_print_blob(item, cgit_query_sha1, cgit_query_path);
+		    return;
+	    }
 	}
 
 	if (cgit_query_page && !strcmp(cgit_query_page, "log"))
 		show_search = 1;
 
 	cgit_print_docstart(title, item);
 
 
 	if (!cgit_query_page) {
 		cgit_print_pageheader("summary", show_search);
 		cgit_print_summary();
 		cgit_print_docend();
 		return;
 	}
 
 	cgit_print_pageheader(cgit_query_page, show_search);
 
 	if (!strcmp(cgit_query_page, "log")) {
 		cgit_print_log(cgit_query_head, cgit_query_ofs, 100, 
 			       cgit_query_search);
 	} else if (!strcmp(cgit_query_page, "tree")) {
 		cgit_print_tree(cgit_query_sha1, cgit_query_path);
 	} else if (!strcmp(cgit_query_page, "commit")) {
 		cgit_print_commit(cgit_query_sha1);
 	} else if (!strcmp(cgit_query_page, "view")) {
 		cgit_print_view(cgit_query_sha1, cgit_query_path);
 	} else if (!strcmp(cgit_query_page, "diff")) {
 		cgit_print_diff(cgit_query_sha1, cgit_query_sha2);
 	} else {
 		cgit_print_error("Invalid request");
 	}
 	cgit_print_docend();
 }
 
 static void cgit_fill_cache(struct cacheitem *item, int use_cache)
 {
 	static char buf[PATH_MAX];
 	int stdout2;
 
 	getcwd(buf, sizeof(buf));
 	item->st.st_mtime = time(NULL);
 
 	if (use_cache) {
 		stdout2 = chk_positive(dup(STDOUT_FILENO), 
 				       "Preserving STDOUT");
 		chk_zero(close(STDOUT_FILENO), "Closing STDOUT");
 		chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)");
 	}
 
 	if (cgit_query_repo)
 		cgit_print_repo_page(item);
 	else
 		cgit_print_repolist(item);
 
 	if (use_cache) {
 		chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT");
 		chk_positive(dup2(stdout2, STDOUT_FILENO), 
 			     "Restoring original STDOUT");
 		chk_zero(close(stdout2), "Closing temporary STDOUT");
 	}
 
 	chdir(buf);
 }
 
 static void cgit_check_cache(struct cacheitem *item)
 {
 	int i = 0;
 
  top:
 	if (++i > cgit_max_lock_attempts) {
 		die("cgit_refresh_cache: unable to lock %s: %s",
 		    item->name, strerror(errno));
 	}
 	if (!cache_exist(item)) {
 		if (!cache_lock(item)) {
 			sleep(1);
 			goto top;
 		}
 		if (!cache_exist(item)) {
 			cgit_fill_cache(item, 1);
 			cache_unlock(item);
 		} else {
 			cache_cancel_lock(item);
 		}
 	} else if (cache_expired(item) && cache_lock(item)) {
 		if (cache_expired(item)) {
 			cgit_fill_cache(item, 1);
 			cache_unlock(item);
 		} else {
 			cache_cancel_lock(item);
 		}
 	}
 }
 
 static void cgit_print_cache(struct cacheitem *item)
 {
 	static char buf[4096];
 	ssize_t i;
 
 	int fd = open(item->name, O_RDONLY);
 	if (fd<0)
 		die("Unable to open cached file %s", item->name);
 
 	while((i=read(fd, buf, sizeof(buf))) > 0)
 		write(STDOUT_FILENO, buf, i);
 
 	close(fd);
 }
 
 static void cgit_parse_args(int argc, const char **argv)
 {
 	int i;
 
 	for (i = 1; i < argc; i++) {
 		if (!strncmp(argv[i], "--cache=", 8)) {
 			cgit_cache_root = xstrdup(argv[i]+8);
 		}
 		if (!strcmp(argv[i], "--nocache")) {
 			cgit_nocache = 1;
 		}
 		if (!strncmp(argv[i], "--query=", 8)) {
 			cgit_querystring = xstrdup(argv[i]+8);
 		}
 		if (!strncmp(argv[i], "--repo=", 7)) {
 			cgit_query_repo = xstrdup(argv[i]+7);
 		}
 		if (!strncmp(argv[i], "--page=", 7)) {
 			cgit_query_page = xstrdup(argv[i]+7);
 		}
 		if (!strncmp(argv[i], "--head=", 7)) {
 			cgit_query_head = xstrdup(argv[i]+7);
 			cgit_query_has_symref = 1;
 		}
 		if (!strncmp(argv[i], "--sha1=", 7)) {
 			cgit_query_sha1 = xstrdup(argv[i]+7);
 			cgit_query_has_sha1 = 1;
 		}
 		if (!strncmp(argv[i], "--ofs=", 6)) {
 			cgit_query_ofs = atoi(argv[i]+6);
 		}
 	}
 }
 
 int main(int argc, const char **argv)
 {
 	struct cacheitem item;
 
 	htmlfd = STDOUT_FILENO;
 	item.st.st_mtime = time(NULL);
 	cgit_repolist.length = 0;
 	cgit_repolist.count = 0;
 	cgit_repolist.repos = NULL;
 
 	cgit_read_config("/etc/cgitrc", cgit_global_config_cb);
 	if (getenv("QUERY_STRING"))
 		cgit_querystring = xstrdup(getenv("QUERY_STRING"));
 	cgit_parse_args(argc, argv);
 	cgit_parse_query(cgit_querystring, cgit_querystring_cb);
 	if (!cgit_prepare_cache(&item))
 		return 0;
 	if (cgit_nocache) {
 		cgit_fill_cache(&item, 0);
 	} else {
 		cgit_check_cache(&item);
 		cgit_print_cache(&item);
 	}
 	return 0;
 }
diff --git a/cgit.h b/cgit.h
index 2615231..292e488 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,166 +1,167 @@
 #ifndef CGIT_H
 #define CGIT_H
 
 
 #include <git-compat-util.h>
 #include <cache.h>
 #include <grep.h>
 #include <object.h>
 #include <tree.h>
 #include <commit.h>
 #include <tag.h>
 #include <diff.h>
 #include <diffcore.h>
 #include <refs.h>
 #include <revision.h>
 #include <log-tree.h>
 #include <archive.h>
 #include <xdiff/xdiff.h>
 
 
 typedef void (*configfn)(const char *name, const char *value);
 
 struct cacheitem {
 	char *name;
 	struct stat st;
 	int ttl;
 	int fd;
 };
 
 struct repoinfo {
 	char *url;
 	char *name;
 	char *path;
 	char *desc;
 	char *owner;
 	int snapshots;
 };
 
 struct repolist {
 	int length;
 	int count;
 	struct repoinfo *repos;
 };
 
 struct commitinfo {
 	struct commit *commit;
 	char *author;
 	char *author_email;
 	unsigned long author_date;
 	char *committer;
 	char *committer_email;
 	unsigned long committer_date;
 	char *subject;
 	char *msg;
 };
 
 struct taginfo {
 	char *tagger;
 	char *tagger_email;
 	int tagger_date;
 	char *msg;
 };
 
 extern const char cgit_version[];
 
 extern struct repolist cgit_repolist;
 extern struct repoinfo *cgit_repo;
 
 extern char *cgit_root_title;
 extern char *cgit_css;
 extern char *cgit_logo;
 extern char *cgit_logo_link;
 extern char *cgit_virtual_root;
 extern char *cgit_cache_root;
 
 extern int cgit_nocache;
 extern int cgit_snapshots;
 extern int cgit_max_lock_attempts;
 extern int cgit_cache_root_ttl;
 extern int cgit_cache_repo_ttl;
 extern int cgit_cache_dynamic_ttl;
 extern int cgit_cache_static_ttl;
 extern int cgit_cache_max_create_time;
 
 extern int cgit_max_msg_len;
 
 extern char *cgit_repo_name;
 extern char *cgit_repo_desc;
 extern char *cgit_repo_owner;
 
 extern int cgit_query_has_symref;
 extern int cgit_query_has_sha1;
 
 extern char *cgit_querystring;
 extern char *cgit_query_repo;
 extern char *cgit_query_page;
 extern char *cgit_query_search;
 extern char *cgit_query_head;
 extern char *cgit_query_sha1;
 extern char *cgit_query_sha2;
 extern char *cgit_query_path;
 extern char *cgit_query_name;
 extern int   cgit_query_ofs;
 
 extern int htmlfd;
 
 extern void cgit_global_config_cb(const char *name, const char *value);
 extern void cgit_repo_config_cb(const char *name, const char *value);
 extern void cgit_querystring_cb(const char *name, const char *value);
 
 extern int chk_zero(int result, char *msg);
 extern int chk_positive(int result, char *msg);
 
 extern int hextoint(char c);
 
 extern void *cgit_free_commitinfo(struct commitinfo *info);
 
 extern char *fmt(const char *format,...);
 
 extern void html(const char *txt);
 extern void htmlf(const char *format,...);
 extern void html_txt(char *txt);
 extern void html_ntxt(int len, char *txt);
 extern void html_attr(char *txt);
 extern void html_hidden(char *name, char *value);
 extern void html_link_open(char *url, char *title, char *class);
 extern void html_link_close(void);
 extern void html_filemode(unsigned short mode);
 
 extern int cgit_read_config(const char *filename, configfn fn);
 extern int cgit_parse_query(char *txt, configfn fn);
 extern struct commitinfo *cgit_parse_commit(struct commit *commit);
 extern struct taginfo *cgit_parse_tag(struct tag *tag);
 
 extern char *cache_safe_filename(const char *unsafe);
 extern int cache_lock(struct cacheitem *item);
 extern int cache_unlock(struct cacheitem *item);
 extern int cache_cancel_lock(struct cacheitem *item);
 extern int cache_exist(struct cacheitem *item);
 extern int cache_expired(struct cacheitem *item);
 
 extern char *cgit_repourl(const char *reponame);
 extern char *cgit_pageurl(const char *reponame, const char *pagename, 
 			  const char *query);
 
 extern void cgit_print_error(char *msg);
 extern void cgit_print_date(unsigned long secs);
 extern void cgit_print_docstart(char *title, struct cacheitem *item);
 extern void cgit_print_docend();
 extern void cgit_print_pageheader(char *title, int show_search);
 extern void cgit_print_snapshot_start(const char *mimetype, 
 				      const char *filename, 
 				      struct cacheitem *item);
 
 extern void cgit_print_repolist(struct cacheitem *item);
 extern void cgit_print_summary();
 extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep);
 extern void cgit_print_view(const char *hex, char *path);
+extern void cgit_print_blob(struct cacheitem *item, const char *hex, char *path);
 extern void cgit_print_tree(const char *hex, char *path);
 extern void cgit_print_commit(const char *hex);
 extern void cgit_print_diff(const char *old_hex, const char *new_hex);
 extern void cgit_print_snapshot(struct cacheitem *item, const char *hex, 
 				const char *format, const char *prefix,
 				const char *filename);
 
 #endif /* CGIT_H */
diff --git a/ui-blob.c b/ui-blob.c
new file mode 100644
index 0000000..f5b844b
--- a/dev/null
+++ b/ui-blob.c
@@ -0,0 +1,31 @@
+#include "cgit.h"
+
+void cgit_print_blob(struct cacheitem *item, const char *hex, char *path)
+{
+
+	unsigned char sha1[20];
+	enum object_type type;
+	unsigned char *buf;
+	unsigned long size;
+
+	if (get_sha1_hex(hex, sha1)){
+		cgit_print_error(fmt("Bad hex value: %s", hex));
+	        return;
+	}
+
+	type = sha1_object_info(sha1, &size);
+	if (type == OBJ_BAD) {
+		cgit_print_error(fmt("Bad object name: %s", hex));
+		return;
+	}
+
+	buf = read_sha1_file(sha1, &type, &size);
+	if (!buf) {
+		cgit_print_error(fmt("Error reading object %s", hex));
+		return;
+	}
+
+	buf[size] = '\0';
+	cgit_print_snapshot_start("text/plain", path, item);
+	write(htmlfd, buf, size);
+}
diff --git a/ui-view.c b/ui-view.c
index 7d022fd..dbe4b29 100644
--- a/ui-view.c
+++ b/ui-view.c
@@ -1,48 +1,55 @@
 /* ui-view.c: functions to output _any_ object, given it's sha1
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 
 void cgit_print_view(const char *hex, char *path)
 {
 	unsigned char sha1[20];
 	enum object_type type;
 	unsigned char *buf;
 	unsigned long size;
 
 	if (get_sha1_hex(hex, sha1)){
 		cgit_print_error(fmt("Bad hex value: %s", hex));
 	        return;
 	}
 
 	type = sha1_object_info(sha1, &size);
 	if (type == OBJ_BAD) {
 		cgit_print_error(fmt("Bad object name: %s", hex));
 		return;
 	}
 
 	buf = read_sha1_file(sha1, &type, &size);
 	if (!buf) {
 		cgit_print_error(fmt("Error reading object %s", hex));
 		return;
 	}
 
 	buf[size] = '\0';
 	html("<table class='list'>\n");
 	html("<tr class='nohover'><th class='left'>");
 	if (path)
 		htmlf("%s (", path);
 	htmlf("%s %s, %li bytes", typename(type), hex, size);
 	if (path)
 		html(")");
+
+	html(" <a href='");
+	html_attr(cgit_pageurl(cgit_query_repo, "blob", 
+			       fmt("id=%s&path=%s", 
+				   hex,
+				   path)));
+	html("'>download</a>");
 	html("</th></tr>\n");
 	html("<tr><td class='blob'>\n");
 	html_txt(buf);
 	html("\n</td></tr>\n");
 	html("</table>\n");
 }