summaryrefslogtreecommitdiffabout
Side-by-side diff
Diffstat (more/less context) (show whitespace changes)
-rw-r--r--Makefile2
-rw-r--r--cgit.c5
-rw-r--r--cgit.css16
-rw-r--r--cgit.h8
-rw-r--r--shared.c3
-rw-r--r--ui-commit.c3
-rw-r--r--ui-tree.c192
-rw-r--r--ui-view.c55
8 files changed, 173 insertions, 111 deletions
diff --git a/Makefile b/Makefile
index 57f80f8..c2a5736 100644
--- a/Makefile
+++ b/Makefile
@@ -1,87 +1,87 @@
CGIT_VERSION = 0.5
prefix = /var/www/htdocs/cgit
SHA1_HEADER = <openssl/sha.h>
CACHE_ROOT = /var/cache/cgit
CGIT_CONFIG = /etc/cgitrc
CGIT_SCRIPT_NAME = cgit.cgi
#
# Let the user override the above settings.
#
-include cgit.conf
EXTLIBS = git/libgit.a git/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-summary.o ui-log.o ui-tree.o ui-commit.o ui-diff.o \
ui-snapshot.o ui-blob.o
CFLAGS += -Wall
ifdef DEBUG
CFLAGS += -g
endif
CFLAGS += -Igit
CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER)'
CFLAGS += -DCGIT_VERSION='"$(CGIT_VERSION)"'
CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"'
CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"'
#
# If make is run on a nongit platform, get the git sources as a tarball.
#
GITVER = $(shell git version 2>/dev/null || echo nogit)
ifeq ($(GITVER),nogit)
GITURL = http://www.kernel.org/pub/software/scm/git/git-1.5.2.tar.bz2
INITGIT = test -e git/git.c || ((curl "$(GITURL)" | tar -xj) && mv git-1.5.2 git)
else
INITGIT = ./submodules.sh -i
endif
#
# basic build rules
#
all: cgit
cgit: cgit.c cgit.h $(OBJECTS)
$(CC) $(CFLAGS) cgit.c -o cgit $(OBJECTS) $(EXTLIBS)
$(OBJECTS): cgit.h git/libgit.a
git/libgit.a:
$(INITGIT)
$(MAKE) -C git
#
# phony targets
#
install: all clean-cache
mkdir -p $(prefix)
install cgit $(prefix)/$(CGIT_SCRIPT_NAME)
install cgit.css $(prefix)/cgit.css
clean-cgit:
rm -f cgit *.o
distclean-cgit: clean-cgit
git clean -d -x
clean-sub:
$(MAKE) -C git clean
distclean-sub: clean-sub
$(shell cd git && git clean -d -x)
clean-cache:
rm -rf $(CACHE_ROOT)/*
clean: clean-cgit clean-sub
distclean: distclean-cgit distclean-sub
.PHONY: all install clean clean-cgit clean-sub clean-cache \
distclean distclean-cgit distclean-sub
diff --git a/cgit.c b/cgit.c
index 34e590e..1c213c7 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,254 +1,251 @@
/* 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 int cgit_prepare_cache(struct cacheitem *item)
{
if (!cgit_repo && cgit_query_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_repo) {
item->name = xstrdup(fmt("%s/index.html", cgit_cache_root));
item->ttl = cgit_cache_root_ttl;
return 1;
}
if (!cgit_cmd) {
item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root,
cache_safe_filename(cgit_repo->url)));
item->ttl = cgit_cache_repo_ttl;
} else {
item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root,
cache_safe_filename(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 (!cgit_query_head)
cgit_query_head = cgit_repo->defbranch;
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_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) {
cgit_print_snapshot(item, cgit_query_sha1, "zip",
cgit_repo->url, cgit_query_name);
return;
}
if (cgit_cmd == CMD_BLOB) {
cgit_print_blob(item, cgit_query_sha1, cgit_query_path);
return;
}
show_search = (cgit_cmd == CMD_LOG);
cgit_print_docstart(title, item);
if (!cgit_cmd) {
cgit_print_pageheader("summary", show_search);
cgit_print_summary();
cgit_print_docend();
return;
}
cgit_print_pageheader(cgit_query_page, show_search);
switch(cgit_cmd) {
case CMD_LOG:
cgit_print_log(cgit_query_head, cgit_query_ofs,
cgit_max_commit_count, cgit_query_search,
cgit_query_path, 1);
break;
case CMD_TREE:
- cgit_print_tree(cgit_query_head, cgit_query_sha1, cgit_query_path);
+ cgit_print_tree(cgit_query_sha1, cgit_query_path);
break;
case CMD_COMMIT:
cgit_print_commit(cgit_query_head);
break;
- case CMD_VIEW:
- cgit_print_view(cgit_query_sha1, cgit_query_path);
- break;
case CMD_DIFF:
cgit_print_diff(cgit_query_head, cgit_query_sha1, cgit_query_sha2,
cgit_query_path);
break;
default:
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_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(CGIT_CONFIG, cgit_global_config_cb);
cgit_repo = NULL;
if (getenv("SCRIPT_NAME"))
cgit_script_name = xstrdup(getenv("SCRIPT_NAME"));
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.css b/cgit.css
index 8bd6bf4..30fde03 100644
--- a/cgit.css
+++ b/cgit.css
@@ -1,412 +1,424 @@
body {
font-family: arial, sans-serif;
font-size: 11pt;
color: black;
background: white;
}
body, table {
padding: 0em;
margin: 0em;
}
table {
border-collapse: collapse;
}
h2 {
font-size: 120%;
font-weight: bold;
margin-top: 0em;
margin-bottom: 0.25em;
}
h3 {
margin-top: 0em;
font-size: 100%;
font-weight: normal;
}
h4 {
margin-top: 1.5em;
margin-bottom: 0.1em;
font-size: 100%;
font-weight: bold;
}
a {
color: blue;
text-decoration: none;
}
a:hover {
text-decoration: underline;
}
table.list {
border: none;
border-collapse: collapse;
}
table.list tr {
background: white;
}
table.list tr:hover {
background: #eee;
}
table.list tr.nohover:hover {
background: white;
}
table.list th {
font-weight: bold;
border-bottom: solid 1px #777;
padding: 0.1em 0.5em 0.1em 0.5em;
vertical-align: baseline;
}
table.list td {
border: none;
padding: 0.1em 0.5em 0.1em 0.5em;
}
img {
border: none;
}
table#layout {
width: 100%;
border-collapse: collapse;
margin: 0px;
}
td#header, td#logo {
color: #666;
background-color: #ddd;
border-bottom: solid 1px #000;
}
td#header {
font-size: 150%;
font-weight: bold;
padding: 0.2em 0.5em;
vertical-align: text-bottom;
}
td#logo {
text-align: right;
vertical-align: middle;
padding-right: 0.5em;
}
td#crumb, td#search {
color: #ccc;
border-top: solid 3px #555;
background-color: #666;
border-bottom: solid 1px #333;
padding: 2px 1em;
}
td#crumb {
font-weight: bold;
}
td#crumb a {
color: #ccc;
background-color: #666;
}
td#crumb a:hover {
color: #eee;
background-color: #666;
}
td#search {
text-align: right;
vertical-align: middle;
padding-right: 0.5em;
}
td#search form {
margin: 0px;
padding: 0px;
}
td#search input {
font-size: 9pt;
padding: 0px;
width: 10em;
border: solid 1px #333;
color: #333;
background-color: #fff;
}
div#summary {
vertical-align: top;
margin-bottom: 1em;
}
table#downloads {
float: right;
border-collapse: collapse;
border: solid 1px #777;
margin-left: 0.5em;
margin-bottom: 0.5em;
}
table#downloads th {
background-color: #ccc;
}
td#content {
padding: 1em 0.5em;
}
div#blob {
border: solid 1px black;
}
div.error {
color: red;
font-weight: bold;
margin: 1em 2em;
}
td.ls-blob, td.ls-dir, td.ls-mod {
font-family: monospace;
}
div.ls-dir a {
font-weight: bold;
}
th.filesize, td.filesize {
text-align: right;
}
td.filesize {
font-family: monospace;
}
td.links {
font-size: 80%;
padding-left: 2em;
}
td.filemode {
font-family: monospace;
}
-td.blob {
+table.blob {
+ margin-top: 0.5em;
+ border-top: solid 1px black;
+}
+
+table.blob td.no {
+ border-right: solid 1px black;
+ color: black;
+ background-color: #eee;
+ text-align: right;
+}
+
+table.blob td.txt {
white-space: pre;
font-family: monospace;
- background-color: white;
+ padding-left: 0.5em;
}
table.nowrap td {
white-space: nowrap;
}
table.commit-info {
border-collapse: collapse;
margin-top: 1.5em;
}
table.commit-info th {
text-align: left;
font-weight: normal;
padding: 0.1em 1em 0.1em 0.1em;
}
table.commit-info td {
font-weight: normal;
padding: 0.1em 1em 0.1em 0.1em;
}
div.commit-subject {
font-weight: bold;
font-size: 125%;
margin: 1.5em 0em 0.5em 0em;
padding: 0em;
}
div.commit-msg {
white-space: pre;
font-family: monospace;
}
div.diffstat-header {
font-weight: bold;
padding-top: 1.5em;
}
table.diffstat {
border-collapse: collapse;
width: 100%;
border: solid 1px #aaa;
background-color: #eee;
}
table.diffstat tr:hover {
background-color: #ccc;
}
table.diffstat th {
font-weight: normal;
text-align: left;
text-decoration: underline;
padding: 0.1em 1em 0.1em 0.1em;
font-size: 100%;
}
table.diffstat td {
padding: 0.2em 0.2em 0.1em 0.1em;
font-size: 100%;
border: none;
}
table.diffstat td.mode {
white-space: nowrap;
}
table.diffstat td span.modechange {
padding-left: 1em;
color: red;
}
table.diffstat td.add a {
color: green;
}
table.diffstat td.del a {
color: red;
}
table.diffstat td.upd a {
color: blue;
}
table.diffstat td.graph {
width: 75%;
vertical-align: middle;
}
table.diffstat td.graph table {
border: none;
}
table.diffstat td.graph td {
padding: 0px;
border: 0px;
height: 7pt;
}
table.diffstat td.graph td.add {
background-color: #5c5;
}
table.diffstat td.graph td.rem {
background-color: #c55;
}
div.diffstat-summary {
color: #888;
padding-top: 0.5em;
}
table.diff td {
font-family: monospace;
white-space: pre;
}
table.diff td div.head {
font-weight: bold;
padding-top: 1em;
}
table.diff td div.hunk {
color: #009;
}
table.diff td div.add {
color: green;
}
table.diff td div.del {
color: red;
}
.sha1 {
font-family: monospace;
font-size: 90%;
}
.left {
text-align: left;
}
.right {
text-align: right;
}
table.list td.repogroup {
font-style: italic;
color: #888;
}
a.button {
font-size: 80%;
color: #333;
background-color: #ccc;
border: solid 1px #999;
padding: 0em 0.5em;
margin: 0.1em 0.25em;
}
a.button:hover {
text-decoration: none;
background-color: #eee;
}
a.primary {
font-size: 100%;
}
a.secondary {
font-size: 90%;
}
td.toplevel-repo {
}
table.list td.sublevel-repo {
padding-left: 1.5em;
}
span.age-mins {
font-weight: bold;
color: #080;
}
span.age-hours {
color: #080;
}
span.age-days {
color: #040;
}
span.age-weeks {
color: #444;
}
span.age-months {
color: #888;
}
span.age-years {
color: #bbb;
}
diff --git a/cgit.h b/cgit.h
index 2f3fca1..b93e2e8 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,228 +1,226 @@
#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>
/*
* The valid cgit repo-commands
*/
#define CMD_LOG 1
#define CMD_COMMIT 2
#define CMD_DIFF 3
#define CMD_TREE 4
-#define CMD_VIEW 5
-#define CMD_BLOB 6
-#define CMD_SNAPSHOT 7
+#define CMD_BLOB 5
+#define CMD_SNAPSHOT 6
/*
* Dateformats used on misc. pages
*/
#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S"
#define FMT_SHORTDATE "%Y-%m-%d"
/*
* Limits used for relative dates
*/
#define TM_MIN 60
#define TM_HOUR (TM_MIN * 60)
#define TM_DAY (TM_HOUR * 24)
#define TM_WEEK (TM_DAY * 7)
#define TM_YEAR (TM_DAY * 365)
#define TM_MONTH (TM_YEAR / 12.0)
typedef void (*configfn)(const char *name, const char *value);
typedef void (*filepair_fn)(struct diff_filepair *pair);
typedef void (*linediff_fn)(char *line, int len);
struct cacheitem {
char *name;
struct stat st;
int ttl;
int fd;
};
struct repoinfo {
char *url;
char *name;
char *path;
char *desc;
char *owner;
char *defbranch;
char *group;
char *module_link;
char *readme;
int snapshots;
int enable_log_filecount;
int enable_log_linecount;
};
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 int cgit_cmd;
extern char *cgit_root_title;
extern char *cgit_css;
extern char *cgit_logo;
extern char *cgit_index_header;
extern char *cgit_logo_link;
extern char *cgit_module_link;
extern char *cgit_agefile;
extern char *cgit_virtual_root;
extern char *cgit_script_name;
extern char *cgit_cache_root;
extern char *cgit_repo_group;
extern int cgit_nocache;
extern int cgit_snapshots;
extern int cgit_enable_log_filecount;
extern int cgit_enable_log_linecount;
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_summary_log;
extern int cgit_max_msg_len;
extern int cgit_max_repodesc_len;
extern int cgit_max_commit_count;
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 int cgit_get_cmd_index(const char *cmd);
extern struct repoinfo *cgit_get_repoinfo(const char *url);
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 int cgit_diff_files(const unsigned char *old_sha1,
const unsigned char *new_sha1,
linediff_fn fn);
extern void cgit_diff_tree(const unsigned char *old_sha1,
const unsigned char *new_sha1,
filepair_fn fn);
extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
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 html_include(const char *filename);
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 void cgit_parse_url(const char *url);
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(time_t secs, char *format);
extern void cgit_print_age(time_t t, time_t max_relative, char *format);
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, char *path, int pager);
-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 *rev, const char *hex, char *path);
+extern void cgit_print_tree(const char *rev, char *path);
extern void cgit_print_commit(const char *hex);
extern void cgit_print_diff(const char *head, const char *old_hex, const char *new_hex,
char *path);
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/shared.c b/shared.c
index b6d2fa1..c7cd8a5 100644
--- a/shared.c
+++ b/shared.c
@@ -1,377 +1,378 @@
/* shared.c: global vars + some callback functions
*
* Copyright (C) 2006 Lars Hjemli
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
*/
#include "cgit.h"
struct repolist cgit_repolist;
struct repoinfo *cgit_repo;
int cgit_cmd;
char *cgit_root_title = "Git repository browser";
char *cgit_css = "/cgit.css";
char *cgit_logo = "/git-logo.png";
char *cgit_index_header = NULL;
char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/";
char *cgit_module_link = "./?repo=%s&page=commit&id=%s";
char *cgit_agefile = "info/web/last-modified";
char *cgit_virtual_root = NULL;
char *cgit_script_name = CGIT_SCRIPT_NAME;
char *cgit_cache_root = "/var/cache/cgit";
char *cgit_repo_group = NULL;
int cgit_nocache = 0;
int cgit_snapshots = 0;
int cgit_enable_log_filecount = 0;
int cgit_enable_log_linecount = 0;
int cgit_max_lock_attempts = 5;
int cgit_cache_root_ttl = 5;
int cgit_cache_repo_ttl = 5;
int cgit_cache_dynamic_ttl = 5;
int cgit_cache_static_ttl = -1;
int cgit_cache_max_create_time = 5;
int cgit_summary_log = 0;
int cgit_max_msg_len = 60;
int cgit_max_repodesc_len = 60;
int cgit_max_commit_count = 50;
int cgit_query_has_symref = 0;
int cgit_query_has_sha1 = 0;
char *cgit_querystring = NULL;
char *cgit_query_repo = NULL;
char *cgit_query_page = NULL;
char *cgit_query_head = NULL;
char *cgit_query_search = NULL;
char *cgit_query_sha1 = NULL;
char *cgit_query_sha2 = NULL;
char *cgit_query_path = NULL;
char *cgit_query_name = NULL;
int cgit_query_ofs = 0;
int htmlfd = 0;
int cgit_get_cmd_index(const char *cmd)
{
- static char *cmds[] = {"log", "commit", "diff", "tree", "view", "blob", "snapshot", NULL};
+ static char *cmds[] = {"log", "commit", "diff", "tree", "blob",
+ "snapshot", NULL};
int i;
for(i = 0; cmds[i]; i++)
if (!strcmp(cmd, cmds[i]))
return i + 1;
return 0;
}
int chk_zero(int result, char *msg)
{
if (result != 0)
die("%s: %s", msg, strerror(errno));
return result;
}
int chk_positive(int result, char *msg)
{
if (result <= 0)
die("%s: %s", msg, strerror(errno));
return result;
}
struct repoinfo *add_repo(const char *url)
{
struct repoinfo *ret;
if (++cgit_repolist.count > cgit_repolist.length) {
if (cgit_repolist.length == 0)
cgit_repolist.length = 8;
else
cgit_repolist.length *= 2;
cgit_repolist.repos = xrealloc(cgit_repolist.repos,
cgit_repolist.length *
sizeof(struct repoinfo));
}
ret = &cgit_repolist.repos[cgit_repolist.count-1];
ret->url = xstrdup(url);
ret->name = ret->url;
ret->path = NULL;
ret->desc = NULL;
ret->owner = NULL;
ret->group = cgit_repo_group;
ret->defbranch = "master";
ret->snapshots = cgit_snapshots;
ret->enable_log_filecount = cgit_enable_log_filecount;
ret->enable_log_linecount = cgit_enable_log_linecount;
ret->module_link = cgit_module_link;
ret->readme = NULL;
return ret;
}
struct repoinfo *cgit_get_repoinfo(const 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;
}
void cgit_global_config_cb(const char *name, const char *value)
{
if (!strcmp(name, "root-title"))
cgit_root_title = xstrdup(value);
else if (!strcmp(name, "css"))
cgit_css = xstrdup(value);
else if (!strcmp(name, "logo"))
cgit_logo = xstrdup(value);
else if (!strcmp(name, "index-header"))
cgit_index_header = xstrdup(value);
else if (!strcmp(name, "logo-link"))
cgit_logo_link = xstrdup(value);
else if (!strcmp(name, "module-link"))
cgit_module_link = xstrdup(value);
else if (!strcmp(name, "virtual-root"))
cgit_virtual_root = xstrdup(value);
else if (!strcmp(name, "nocache"))
cgit_nocache = atoi(value);
else if (!strcmp(name, "snapshots"))
cgit_snapshots = atoi(value);
else if (!strcmp(name, "enable-log-filecount"))
cgit_enable_log_filecount = atoi(value);
else if (!strcmp(name, "enable-log-linecount"))
cgit_enable_log_linecount = atoi(value);
else if (!strcmp(name, "cache-root"))
cgit_cache_root = xstrdup(value);
else if (!strcmp(name, "cache-root-ttl"))
cgit_cache_root_ttl = atoi(value);
else if (!strcmp(name, "cache-repo-ttl"))
cgit_cache_repo_ttl = atoi(value);
else if (!strcmp(name, "cache-static-ttl"))
cgit_cache_static_ttl = atoi(value);
else if (!strcmp(name, "cache-dynamic-ttl"))
cgit_cache_dynamic_ttl = atoi(value);
else if (!strcmp(name, "max-message-length"))
cgit_max_msg_len = atoi(value);
else if (!strcmp(name, "max-repodesc-length"))
cgit_max_repodesc_len = atoi(value);
else if (!strcmp(name, "max-commit-count"))
cgit_max_commit_count = atoi(value);
else if (!strcmp(name, "summary-log"))
cgit_summary_log = atoi(value);
else if (!strcmp(name, "agefile"))
cgit_agefile = xstrdup(value);
else if (!strcmp(name, "repo.group"))
cgit_repo_group = xstrdup(value);
else if (!strcmp(name, "repo.url"))
cgit_repo = add_repo(value);
else if (!strcmp(name, "repo.name"))
cgit_repo->name = xstrdup(value);
else if (cgit_repo && !strcmp(name, "repo.path"))
cgit_repo->path = xstrdup(value);
else if (cgit_repo && !strcmp(name, "repo.desc"))
cgit_repo->desc = xstrdup(value);
else if (cgit_repo && !strcmp(name, "repo.owner"))
cgit_repo->owner = xstrdup(value);
else if (cgit_repo && !strcmp(name, "repo.defbranch"))
cgit_repo->defbranch = xstrdup(value);
else if (cgit_repo && !strcmp(name, "repo.snapshots"))
cgit_repo->snapshots = cgit_snapshots * atoi(value);
else if (cgit_repo && !strcmp(name, "repo.enable-log-filecount"))
cgit_repo->enable_log_filecount = cgit_enable_log_filecount * atoi(value);
else if (cgit_repo && !strcmp(name, "repo.enable-log-linecount"))
cgit_repo->enable_log_linecount = cgit_enable_log_linecount * atoi(value);
else if (cgit_repo && !strcmp(name, "repo.module-link"))
cgit_repo->module_link= xstrdup(value);
else if (cgit_repo && !strcmp(name, "repo.readme") && value != NULL) {
if (*value == '/')
cgit_repo->readme = xstrdup(value);
else
cgit_repo->readme = xstrdup(fmt("%s/%s", cgit_repo->path, value));
} else if (!strcmp(name, "include"))
cgit_read_config(value, cgit_global_config_cb);
}
void cgit_querystring_cb(const char *name, const char *value)
{
if (!strcmp(name,"r")) {
cgit_query_repo = xstrdup(value);
cgit_repo = cgit_get_repoinfo(value);
} else if (!strcmp(name, "p")) {
cgit_query_page = xstrdup(value);
cgit_cmd = cgit_get_cmd_index(value);
} else if (!strcmp(name, "url")) {
cgit_parse_url(value);
} else if (!strcmp(name, "q")) {
cgit_query_search = xstrdup(value);
} else if (!strcmp(name, "h")) {
cgit_query_head = xstrdup(value);
cgit_query_has_symref = 1;
} else if (!strcmp(name, "id")) {
cgit_query_sha1 = xstrdup(value);
cgit_query_has_sha1 = 1;
} else if (!strcmp(name, "id2")) {
cgit_query_sha2 = xstrdup(value);
cgit_query_has_sha1 = 1;
} else if (!strcmp(name, "ofs")) {
cgit_query_ofs = atoi(value);
} else if (!strcmp(name, "path")) {
cgit_query_path = xstrdup(value);
} else if (!strcmp(name, "name")) {
cgit_query_name = xstrdup(value);
}
}
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);
return NULL;
}
int hextoint(char c)
{
if (c >= 'a' && c <= 'f')
return 10 + c - 'a';
else if (c >= 'A' && c <= 'F')
return 10 + c - 'A';
else if (c >= '0' && c <= '9')
return c - '0';
else
return -1;
}
void cgit_diff_tree_cb(struct diff_queue_struct *q,
struct diff_options *options, void *data)
{
int i;
for (i = 0; i < q->nr; i++) {
if (q->queue[i]->status == 'U')
continue;
((filepair_fn)data)(q->queue[i]);
}
}
static int load_mmfile(mmfile_t *file, const unsigned char *sha1)
{
enum object_type type;
if (is_null_sha1(sha1)) {
file->ptr = (char *)"";
file->size = 0;
} else {
file->ptr = read_sha1_file(sha1, &type, &file->size);
}
return 1;
}
/*
* Receive diff-buffers from xdiff and concatenate them as
* needed across multiple callbacks.
*
* This is basically a copy of xdiff-interface.c/xdiff_outf(),
* ripped from git and modified to use globals instead of
* a special callback-struct.
*/
char *diffbuf = NULL;
int buflen = 0;
int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)
{
int i;
for (i = 0; i < nbuf; i++) {
if (mb[i].ptr[mb[i].size-1] != '\n') {
/* Incomplete line */
diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
buflen += mb[i].size;
continue;
}
/* we have a complete line */
if (!diffbuf) {
((linediff_fn)priv)(mb[i].ptr, mb[i].size);
continue;
}
diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
((linediff_fn)priv)(diffbuf, buflen + mb[i].size);
free(diffbuf);
diffbuf = NULL;
buflen = 0;
}
if (diffbuf) {
((linediff_fn)priv)(diffbuf, buflen);
free(diffbuf);
diffbuf = NULL;
buflen = 0;
}
return 0;
}
int cgit_diff_files(const unsigned char *old_sha1,
const unsigned char *new_sha1,
linediff_fn fn)
{
mmfile_t file1, file2;
xpparam_t diff_params;
xdemitconf_t emit_params;
xdemitcb_t emit_cb;
if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1))
return 1;
diff_params.flags = XDF_NEED_MINIMAL;
emit_params.ctxlen = 3;
emit_params.flags = XDL_EMIT_FUNCNAMES;
emit_cb.outf = filediff_cb;
emit_cb.priv = fn;
xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb);
return 0;
}
void cgit_diff_tree(const unsigned char *old_sha1,
const unsigned char *new_sha1,
filepair_fn fn)
{
struct diff_options opt;
int ret;
diff_setup(&opt);
opt.output_format = DIFF_FORMAT_CALLBACK;
opt.detect_rename = 1;
opt.recursive = 1;
opt.format_callback = cgit_diff_tree_cb;
opt.format_callback_data = fn;
diff_setup_done(&opt);
if (old_sha1)
ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt);
else
ret = diff_root_tree_sha1(new_sha1, "", &opt);
diffcore_std(&opt);
diff_flush(&opt);
}
void cgit_diff_commit(struct commit *commit, filepair_fn fn)
{
unsigned char *old_sha1 = NULL;
if (commit->parents)
old_sha1 = commit->parents->item->object.sha1;
cgit_diff_tree(old_sha1, commit->object.sha1, fn);
}
diff --git a/ui-commit.c b/ui-commit.c
index 1d12bbb..ed5384d 100644
--- a/ui-commit.c
+++ b/ui-commit.c
@@ -1,240 +1,239 @@
/* ui-commit.c: generate commit view
*
* Copyright (C) 2006 Lars Hjemli
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
*/
#include "cgit.h"
static int files, slots;
static int total_adds, total_rems, max_changes;
static int lines_added, lines_removed;
static struct fileinfo {
char status;
unsigned char old_sha1[20];
unsigned char new_sha1[20];
unsigned short old_mode;
unsigned short new_mode;
char *old_path;
char *new_path;
unsigned int added;
unsigned int removed;
} *items;
void print_fileinfo(struct fileinfo *info)
{
char *query, *query2;
char *class;
switch (info->status) {
case DIFF_STATUS_ADDED:
class = "add";
break;
case DIFF_STATUS_COPIED:
class = "cpy";
break;
case DIFF_STATUS_DELETED:
class = "del";
break;
case DIFF_STATUS_MODIFIED:
class = "upd";
break;
case DIFF_STATUS_RENAMED:
class = "mov";
break;
case DIFF_STATUS_TYPE_CHANGED:
class = "typ";
break;
case DIFF_STATUS_UNKNOWN:
class = "unk";
break;
case DIFF_STATUS_UNMERGED:
class = "stg";
break;
default:
die("bug: unhandled diff status %c", info->status);
}
html("<tr>");
htmlf("<td class='mode'>");
if (is_null_sha1(info->new_sha1)) {
html_filemode(info->old_mode);
} else {
html_filemode(info->new_mode);
}
if (info->old_mode != info->new_mode &&
!is_null_sha1(info->old_sha1) &&
!is_null_sha1(info->new_sha1)) {
html("<span class='modechange'>[");
html_filemode(info->old_mode);
html("]</span>");
}
htmlf("</td><td class='%s'>", class);
query = fmt("id=%s&amp;id2=%s&amp;path=%s", sha1_to_hex(info->old_sha1),
sha1_to_hex(info->new_sha1), info->new_path);
html_link_open(cgit_pageurl(cgit_query_repo, "diff", query),
NULL, NULL);
if (info->status == DIFF_STATUS_COPIED ||
info->status == DIFF_STATUS_RENAMED) {
html_txt(info->new_path);
htmlf("</a> (%s from ", info->status == DIFF_STATUS_COPIED ?
"copied" : "renamed");
query2 = fmt("id=%s", sha1_to_hex(info->old_sha1));
html_link_open(cgit_pageurl(cgit_query_repo, "view", query2),
NULL, NULL);
html_txt(info->old_path);
html("</a>)");
} else {
html_txt(info->new_path);
html("</a>");
}
html("</td><td class='right'>");
htmlf("%d", info->added + info->removed);
html("</td><td class='graph'>");
htmlf("<table width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes));
htmlf("<td class='add' style='width: %.1f%%;'/>",
info->added * 100.0 / max_changes);
htmlf("<td class='rem' style='width: %.1f%%;'/>",
info->removed * 100.0 / max_changes);
htmlf("<td class='none' style='width: %.1f%%;'/>",
(max_changes - info->removed - info->added) * 100.0 / max_changes);
html("</tr></table></td></tr>\n");
}
void cgit_count_diff_lines(char *line, int len)
{
if (line && (len > 0)) {
if (line[0] == '+')
lines_added++;
else if (line[0] == '-')
lines_removed++;
}
}
void inspect_filepair(struct diff_filepair *pair)
{
files++;
lines_added = 0;
lines_removed = 0;
cgit_diff_files(pair->one->sha1, pair->two->sha1, cgit_count_diff_lines);
if (files >= slots) {
if (slots == 0)
slots = 4;
else
slots = slots * 2;
items = xrealloc(items, slots * sizeof(struct fileinfo));
}
items[files-1].status = pair->status;
hashcpy(items[files-1].old_sha1, pair->one->sha1);
hashcpy(items[files-1].new_sha1, pair->two->sha1);
items[files-1].old_mode = pair->one->mode;
items[files-1].new_mode = pair->two->mode;
items[files-1].old_path = xstrdup(pair->one->path);
items[files-1].new_path = xstrdup(pair->two->path);
items[files-1].added = lines_added;
items[files-1].removed = lines_removed;
if (lines_added + lines_removed > max_changes)
max_changes = lines_added + lines_removed;
total_adds += lines_added;
total_rems += lines_removed;
}
void cgit_print_commit(const char *hex)
{
struct commit *commit, *parent;
struct commitinfo *info;
struct commit_list *p;
unsigned char sha1[20];
char *query;
char *filename;
int i;
if (get_sha1(hex, sha1)) {
cgit_print_error(fmt("Bad object id: %s", hex));
return;
}
commit = lookup_commit_reference(sha1);
if (!commit) {
cgit_print_error(fmt("Bad commit reference: %s", hex));
return;
}
info = cgit_parse_commit(commit);
html("<table class='commit-info'>\n");
html("<tr><th>author</th><td>");
html_txt(info->author);
html(" ");
html_txt(info->author_email);
html("</td><td class='right'>");
cgit_print_date(info->author_date, FMT_LONGDATE);
html("</td></tr>\n");
html("<tr><th>committer</th><td>");
html_txt(info->committer);
html(" ");
html_txt(info->committer_email);
html("</td><td class='right'>");
cgit_print_date(info->committer_date, FMT_LONGDATE);
html("</td></tr>\n");
html("<tr><th>tree</th><td colspan='2' class='sha1'><a href='");
- query = fmt("h=%s&amp;id=%s", sha1_to_hex(commit->object.sha1),
- sha1_to_hex(commit->tree->object.sha1));
+ query = fmt("h=%s", sha1_to_hex(commit->object.sha1));
html_attr(cgit_pageurl(cgit_query_repo, "tree", query));
htmlf("'>%s</a></td></tr>\n", sha1_to_hex(commit->tree->object.sha1));
for (p = commit->parents; p ; p = p->next) {
parent = lookup_commit_reference(p->item->object.sha1);
if (!parent) {
html("<tr><td colspan='3'>");
cgit_print_error("Error reading parent commit");
html("</td></tr>");
continue;
}
html("<tr><th>parent</th>"
"<td colspan='2' class='sha1'>"
"<a href='");
query = fmt("h=%s", sha1_to_hex(p->item->object.sha1));
html_attr(cgit_pageurl(cgit_query_repo, "commit", query));
htmlf("'>%s</a> (<a href='",
sha1_to_hex(p->item->object.sha1));
query = fmt("id=%s&amp;id2=%s", sha1_to_hex(parent->tree->object.sha1),
sha1_to_hex(commit->tree->object.sha1));
html_attr(cgit_pageurl(cgit_query_repo, "diff", query));
html("'>diff</a>)</td></tr>");
}
if (cgit_repo->snapshots) {
htmlf("<tr><th>download</th><td colspan='2' class='sha1'><a href='");
filename = fmt("%s-%s.zip", cgit_query_repo, hex);
html_attr(cgit_pageurl(cgit_query_repo, "snapshot",
fmt("id=%s&amp;name=%s", hex, filename)));
htmlf("'>%s</a></td></tr>", filename);
}
html("</table>\n");
html("<div class='commit-subject'>");
html_txt(info->subject);
html("</div>");
html("<div class='commit-msg'>");
html_txt(info->msg);
html("</div>");
if (!(commit->parents && commit->parents->next && commit->parents->next->next)) {
html("<div class='diffstat-header'>Diffstat</div>");
html("<table class='diffstat'>");
max_changes = 0;
cgit_diff_commit(commit, inspect_filepair);
for(i = 0; i<files; i++)
print_fileinfo(&items[i]);
html("</table>");
html("<div class='diffstat-summary'>");
htmlf("%d files changed, %d insertions, %d deletions (",
files, total_adds, total_rems);
query = fmt("h=%s", hex);
html_link_open(cgit_pageurl(cgit_query_repo, "diff", query), NULL, NULL);
html("show diff</a>)");
html("</div>");
}
cgit_free_commitinfo(info);
}
diff --git a/ui-tree.c b/ui-tree.c
index cb57d8d..eb3d3ac 100644
--- a/ui-tree.c
+++ b/ui-tree.c
@@ -1,104 +1,214 @@
/* ui-tree.c: functions for tree output
*
* Copyright (C) 2006 Lars Hjemli
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
*/
#include "cgit.h"
char *curr_rev;
+char *match_path;
+int header = 0;
-static int print_entry(const unsigned char *sha1, const char *base,
- int baselen, const char *pathname, unsigned int mode,
- int stage)
+static void print_object(const unsigned char *sha1, char *path)
+{
+ enum object_type type;
+ unsigned char *buf;
+ unsigned long size, lineno, start, idx;
+
+ type = sha1_object_info(sha1, &size);
+ if (type == OBJ_BAD) {
+ cgit_print_error(fmt("Bad object name: %s",
+ sha1_to_hex(sha1)));
+ return;
+ }
+
+ buf = read_sha1_file(sha1, &type, &size);
+ if (!buf) {
+ cgit_print_error(fmt("Error reading object %s",
+ sha1_to_hex(sha1)));
+ return;
+ }
+
+ html("<table class='blob'>\n");
+ idx = 0;
+ start = 0;
+ lineno = 0;
+ while(idx < size) {
+ if (buf[idx] == '\n') {
+ buf[idx] = '\0';
+ htmlf("<tr><td class='no'>%d</td><td class='txt'>",
+ ++lineno);
+ html_txt(buf + start);
+ html("</td></tr>\n");
+ start = idx + 1;
+ }
+ idx++;
+ }
+ html("\n</td></tr>\n");
+ html("</table>\n");
+}
+
+
+static int ls_item(const unsigned char *sha1, const char *base, int baselen,
+ const char *pathname, unsigned int mode, int stage)
{
char *name;
enum object_type type;
unsigned long size = 0;
+ char *url, *qry;
name = xstrdup(pathname);
type = sha1_object_info(sha1, &size);
if (type == OBJ_BAD && !S_ISDIRLNK(mode)) {
htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
name,
sha1_to_hex(sha1));
return 0;
}
+ qry = fmt("h=%s&amp;path=%s%s%s", curr_rev,
+ cgit_query_path ? cgit_query_path : "",
+ cgit_query_path ? "/" : "", pathname);
+ url = cgit_pageurl(cgit_query_repo, "tree", qry);
html("<tr><td class='filemode'>");
html_filemode(mode);
html("</td><td ");
if (S_ISDIRLNK(mode)) {
htmlf("class='ls-mod'><a href='");
html_attr(fmt(cgit_repo->module_link,
name,
sha1_to_hex(sha1)));
} else if (S_ISDIR(mode)) {
html("class='ls-dir'><a href='");
- html_attr(cgit_pageurl(cgit_query_repo, "tree",
- fmt("h=%s&amp;id=%s&amp;path=%s%s/",
- curr_rev,
- sha1_to_hex(sha1),
- cgit_query_path ? cgit_query_path : "",
- pathname)));
+ html_attr(url);
} else {
html("class='ls-blob'><a href='");
- html_attr(cgit_pageurl(cgit_query_repo, "view",
- fmt("h=%s&amp;id=%s&amp;path=%s%s", curr_rev,
- sha1_to_hex(sha1),
- cgit_query_path ? cgit_query_path : "",
- pathname)));
+ html_attr(url);
}
htmlf("'>%s</a></td>", name);
htmlf("<td class='filesize'>%li</td>", size);
html("<td class='links'><a href='");
- html_attr(cgit_pageurl(cgit_query_repo, "log",
- fmt("h=%s&amp;path=%s%s",
- curr_rev,
+ qry = fmt("h=%s&amp;path=%s%s%s", curr_rev,
cgit_query_path ? cgit_query_path : "",
- pathname)));
- html("'>history</a></td>");
+ cgit_query_path ? "/" : "", pathname);
+ url = cgit_pageurl(cgit_query_repo, "log", qry);
+ html_attr(url);
+ html("' class='button'>H</a></td>");
html("</tr>\n");
free(name);
return 0;
}
-void cgit_print_tree(const char *rev, const char *hex, char *path)
+static void ls_head()
+{
+ html("<table class='list'>\n");
+ html("<tr class='nohover'>");
+ html("<th class='left'>Mode</th>");
+ html("<th class='left'>Name</th>");
+ html("<th class='right'>Size</th>");
+ html("<th/>");
+ html("</tr>\n");
+ header = 1;
+}
+
+static void ls_tail()
+{
+ if (!header)
+ return;
+ html("</table>\n");
+ header = 0;
+}
+
+static void ls_tree(const unsigned char *sha1, char *path)
{
struct tree *tree;
+
+ tree = parse_tree_indirect(sha1);
+ if (!tree) {
+ cgit_print_error(fmt("Not a tree object: %s",
+ sha1_to_hex(sha1)));
+ return;
+ }
+
+ ls_head();
+ read_tree_recursive(tree, "", 0, 1, NULL, ls_item);
+ ls_tail();
+}
+
+
+static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
+ const char *pathname, unsigned mode, int stage)
+{
+ static int state;
+ static char buffer[PATH_MAX];
+ char *url;
+
+ if (state == 0) {
+ memcpy(buffer, base, baselen);
+ strcpy(buffer+baselen, pathname);
+ url = cgit_pageurl(cgit_query_repo, "tree",
+ fmt("h=%s&amp;path=%s", curr_rev, buffer));
+ htmlf(" / <a href='");
+ html_attr(url);
+ html("'>");
+ html_txt(xstrdup(pathname));
+ html("</a>");
+
+ if (strcmp(match_path, buffer))
+ return READ_TREE_RECURSIVE;
+
+ if (S_ISDIR(mode)) {
+ state = 1;
+ ls_head();
+ return READ_TREE_RECURSIVE;
+ } else {
+ print_object(sha1, buffer);
+ return 0;
+ }
+ }
+ ls_item(sha1, base, baselen, pathname, mode, stage);
+ return 0;
+}
+
+
+/*
+ * Show a tree or a blob
+ * rev: the commit pointing at the root tree object
+ * path: path to tree or blob
+ */
+void cgit_print_tree(const char *rev, char *path)
+{
unsigned char sha1[20];
struct commit *commit;
+ const char *paths[] = {path, NULL};
+
+ if (!rev)
+ rev = cgit_query_head;
curr_rev = xstrdup(rev);
- get_sha1(rev, sha1);
+ if (get_sha1(rev, sha1)) {
+ cgit_print_error(fmt("Invalid revision name: %s", rev));
+ return;
+ }
commit = lookup_commit_reference(sha1);
if (!commit || parse_commit(commit)) {
- cgit_print_error(fmt("Invalid head: %s", rev));
+ cgit_print_error(fmt("Invalid commit reference: %s", rev));
return;
}
- if (!hex)
- hex = sha1_to_hex(commit->tree->object.sha1);
- if (get_sha1_hex(hex, sha1)) {
- cgit_print_error(fmt("Invalid object id: %s", hex));
- return;
- }
- tree = parse_tree_indirect(sha1);
- if (!tree) {
- cgit_print_error(fmt("Not a tree object: %s", hex));
+ html("path: <a href='");
+ html_attr(cgit_pageurl(cgit_query_repo, "tree", fmt("h=%s", rev)));
+ html("'>root</a>");
+
+ if (path == NULL) {
+ ls_tree(commit->tree->object.sha1, NULL);
return;
}
- html_txt(path);
- html("<table class='list'>\n");
- html("<tr class='nohover'>");
- html("<th class='left'>Mode</th>");
- html("<th class='left'>Name</th>");
- html("<th class='right'>Size</th>");
- html("<th/>");
- html("</tr>\n");
- read_tree_recursive(tree, "", 0, 1, NULL, print_entry);
- html("</table>\n");
+ match_path = path;
+ read_tree_recursive(commit->tree, NULL, 0, 0, paths, walk_tree);
+ ls_tail();
}
diff --git a/ui-view.c b/ui-view.c
deleted file mode 100644
index 8873415..0000000
--- a/ui-view.c
+++ b/dev/null
@@ -1,55 +0,0 @@
-/* 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&amp;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");
-}