5 files changed, 37 insertions, 2 deletions

diff --git a/Makefile b/Makefile
index 8e3da72..36b5ff6 100644
--- a/Makefile
+++ b/Makefile
@@ -1,72 +1,72 @@
 CGIT_VERSION = v0.6.3
 CGIT_SCRIPT_NAME = cgit.cgi
 CGIT_SCRIPT_PATH = /var/www/htdocs/cgit
 CGIT_CONFIG = /etc/cgitrc
 CACHE_ROOT = /var/cache/cgit
 SHA1_HEADER = <openssl/sha.h>
 GIT_VER = 1.5.3.3
 GIT_URL = http://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.bz2
 
 #
 # 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-tree.o ui-commit.o ui-diff.o \
-        ui-snapshot.o ui-blob.o ui-tag.o
+        ui-snapshot.o ui-blob.o ui-tag.o ui-refs.o
 
 
 .PHONY: all git install clean distclean force-version get-git
 
 all: cgit git
 
 VERSION: force-version
         @./gen-version.sh "$(CGIT_VERSION)"
 -include VERSION
 
 
 CFLAGS += -g -Wall -Igit
 CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER)'
 CFLAGS += -DCGIT_VERSION='"$(CGIT_VERSION)"'
 CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"'
 CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"'
 CFLAGS += -DCGIT_CACHE_ROOT='"$(CACHE_ROOT)"'
 
 
 cgit: cgit.c $(OBJECTS)
         $(CC) $(CFLAGS) cgit.c -o cgit $(OBJECTS) $(EXTLIBS)
 
 $(OBJECTS): cgit.h git/xdiff/lib.a git/libgit.a VERSION
 
 git/xdiff/lib.a: | git
 
 git/libgit.a: | git
 
 git:
         cd git && $(MAKE) xdiff/lib.a
         cd git && $(MAKE) libgit.a
 
 install: all
         mkdir -p $(DESTDIR)$(CGIT_SCRIPT_PATH)
         install cgit $(DESTDIR)$(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
         install cgit.css $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.css
         rm -rf $(DESTDIR)$(CACHE_ROOT)/*
 
 uninstall:
         rm -f $(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
         rm -f $(CGIT_SCRIPT_PATH)/cgit.css
         rm -rf $(CACHE_ROOT)
 
 clean:
         rm -f cgit VERSION *.o
         cd git && $(MAKE) clean
 
 distclean: clean
         git clean -d -x
         cd git && git clean -d -x
 
 get-git:
         curl $(GIT_URL) | tar -xj && rm -rf git && mv git-$(GIT_VER) git
diff --git a/cgit.c b/cgit.c
index 1b85b15..cc18ed4 100644
--- a/cgit.c
+++ b/cgit.c
@@ -42,128 +42,131 @@ static int cgit_prepare_cache(struct cacheitem *item)
                 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_head, cgit_query_sha1,
                                     cgit_repobasename(cgit_repo->url),
                                     cgit_query_path,
                                     cgit_repo->snapshots );
                 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_sha1, cgit_query_ofs,
                                cgit_max_commit_count, cgit_query_search,
                                cgit_query_path, 1);
                 break;
         case CMD_TREE:
                 cgit_print_tree(cgit_query_sha1, cgit_query_path);
                 break;
         case CMD_COMMIT:
                 cgit_print_commit(cgit_query_sha1);
                 break;
+        case CMD_REFS:
+                cgit_print_refs();
+                break;
         case CMD_TAG:
                 cgit_print_tag(cgit_query_sha1);
                 break;
         case CMD_DIFF:
                 cgit_print_diff(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)) {
diff --git a/cgit.h b/cgit.h
index a1fe527..d9a15f4 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,94 +1,95 @@
 #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_BLOB     5
 #define CMD_SNAPSHOT 6
 #define CMD_TAG      7
+#define CMD_REFS     8
 
 /*
  * 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 {
@@ -199,74 +200,75 @@ 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_fileurl(const char *reponame, const char *pagename,
                           const char *filename, const char *query);
 extern char *cgit_pageurl(const char *reponame, const char *pagename,
                           const char *query);
 
 extern const char *cgit_repobasename(const char *reponame);
 
 extern void cgit_tree_link(char *name, char *title, char *class, char *head,
                            char *rev, char *path);
 extern void cgit_log_link(char *name, char *title, char *class, char *head,
                           char *rev, char *path, int ofs);
 extern void cgit_commit_link(char *name, char *title, char *class, char *head,
                              char *rev);
 extern void cgit_snapshot_link(char *name, char *title, char *class,
                                char *head, char *rev, char *archivename);
 extern void cgit_diff_link(char *name, char *title, char *class, char *head,
                            char *new_rev, char *old_rev, char *path);
 
 extern void cgit_object_link(struct object *obj);
 
 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_branches(int maxcount);
 extern void cgit_print_tags(int maxcount);
 
 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_blob(struct cacheitem *item, const char *hex, char *path);
 extern void cgit_print_tree(const char *rev, char *path);
 extern void cgit_print_commit(char *hex);
+extern void cgit_print_refs();
 extern void cgit_print_tag(char *revname);
 extern void cgit_print_diff(const char *new_hex, const char *old_hex, const char *prefix);
 extern void cgit_print_snapshot(struct cacheitem *item, const char *head,
                                 const char *hex, const char *prefix,
                                 const char *filename, int snapshot);
 extern void cgit_print_snapshot_links(const char *repo, const char *head,
                                       const char *hex, int snapshots);
 extern int cgit_parse_snapshots_mask(const char *str);
 
 #endif /* CGIT_H */
diff --git a/shared.c b/shared.c
index ff600db..7eb2b0e 100644
--- a/shared.c
+++ b/shared.c
@@ -5,129 +5,129 @@
  * 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;
 
 const char *cgit_version = CGIT_VERSION;
 
 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   = CGIT_CACHE_ROOT;
 char *cgit_repo_group   = NULL;
 
 int cgit_nocache               =  0;
 int cgit_snapshots             =  0;
 int cgit_enable_index_links    =  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_summary_tags          =  0;
 int cgit_summary_branches      =  0;
 int cgit_renamelimit           = -1;
 
 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", "blob",
-                               "snapshot", "tag", NULL};
+                               "snapshot", "tag", "refs", 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;
 }
 
 int chk_non_negative(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 = trim_end(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;
 
diff --git a/ui-refs.c b/ui-refs.c
new file mode 100644
index 0000000..295f5ba
--- a/dev/null
+++ b/ui-refs.c
@@ -0,0 +1,30 @@
+/* ui-refs.c: browse symbolic refs
+ *
+ * Copyright (C) 2006 Lars Hjemli
+ *
+ * Licensed under GNU General Public License v2
+ *   (see COPYING for full license text)
+ */
+
+#include "cgit.h"
+
+
+
+
+void cgit_print_refs()
+{
+
+        html("<table class='list nowrap'>");
+
+        if (cgit_query_path && !strncmp(cgit_query_path, "heads", 5))
+                cgit_print_branches(0);
+        else if (cgit_query_path && !strncmp(cgit_query_path, "tags", 4))
+                cgit_print_tags(0);
+        else {
+                cgit_print_branches(0);
+                html("<tr class='nohover'><td colspan='4'>&nbsp;</td></tr>");
+                cgit_print_tags(0);
+        }
+
+        html("</table>");
+}