gitweb.ps.run Git - ps-cgit/blob - cgit.c

   1 /* cgit.c: cgi for the git scm
   2  *
   3  * Copyright (C) 2006 Lars Hjemli
   4  *
   5  * Licensed under GNU General Public License v2
   6  *   (see COPYING for full license text)
   7  */
   8
   9 #include "cgit.h"
  10
  11 const char cgit_version[] = CGIT_VERSION;
  12
  13 int htmlfd = 0;
  14
  15 char *cgit_root         = "/usr/src/git";
  16 char *cgit_root_title   = "Git repository browser";
  17 char *cgit_css          = "/cgit.css";
  18 char *cgit_logo         = "/git-logo.png";
  19 char *cgit_logo_link    = "http://www.kernel.org/pub/software/scm/git/docs/";
  20 char *cgit_virtual_root = NULL;
  21
  22 char *cgit_cache_root   = "/var/cache/cgit";
  23
  24 int cgit_max_lock_attempts     =  5;
  25 int cgit_cache_root_ttl        =  5;
  26 int cgit_cache_repo_ttl        =  5;
  27 int cgit_cache_dynamic_ttl     =  5;
  28 int cgit_cache_static_ttl      = -1;
  29 int cgit_cache_max_create_time =  5;
  30
  31 char *cgit_repo_name    = NULL;
  32 char *cgit_repo_desc    = NULL;
  33 char *cgit_repo_owner   = NULL;
  34
  35 int cgit_query_has_symref = 0;
  36 int cgit_query_has_sha1   = 0;
  37
  38 char *cgit_querystring  = NULL;
  39 char *cgit_query_repo   = NULL;
  40 char *cgit_query_page   = NULL;
  41 char *cgit_query_head   = NULL;
  42 char *cgit_query_sha1   = NULL;
  43
  44 struct cacheitem cacheitem;
  45
  46 void cgit_global_config_cb(const char *name, const char *value)
  47 {
  48         if (!strcmp(name, "root"))
  49                 cgit_root = xstrdup(value);
  50         else if (!strcmp(name, "root-title"))
  51                 cgit_root_title = xstrdup(value);
  52         else if (!strcmp(name, "css"))
  53                 cgit_css = xstrdup(value);
  54         else if (!strcmp(name, "logo"))
  55                 cgit_logo = xstrdup(value);
  56         else if (!strcmp(name, "logo-link"))
  57                 cgit_logo_link = xstrdup(value);
  58         else if (!strcmp(name, "virtual-root"))
  59                 cgit_virtual_root = xstrdup(value);
  60 }
  61
  62 void cgit_repo_config_cb(const char *name, const char *value)
  63 {
  64         if (!strcmp(name, "name"))
  65                 cgit_repo_name = xstrdup(value);
  66         else if (!strcmp(name, "desc"))
  67                 cgit_repo_desc = xstrdup(value);
  68         else if (!strcmp(name, "owner"))
  69                 cgit_repo_owner = xstrdup(value);
  70 }
  71
  72 void cgit_querystring_cb(const char *name, const char *value)
  73 {
  74         if (!strcmp(name,"r"))
  75                 cgit_query_repo = xstrdup(value);
  76         else if (!strcmp(name, "p"))
  77                 cgit_query_page = xstrdup(value);
  78         else if (!strcmp(name, "h")) {
  79                 cgit_query_head = xstrdup(value);
  80                 cgit_query_has_symref = 1;
  81         } else if (!strcmp(name, "id")) {
  82                 cgit_query_sha1 = xstrdup(value);
  83                 cgit_query_has_sha1 = 1;
  84         }
  85 }
  86
  87 static int cgit_print_branch_cb(const char *refname, const unsigned char *sha1,
  88                                 int flags, void *cb_data)
  89 {
  90         struct commit *commit;
  91         char buf[256], *url;
  92
  93         commit = lookup_commit(sha1);
  94         if (commit && !parse_commit(commit)){
  95                 html("<tr><td>");
  96                 url = cgit_pageurl(cgit_query_repo, "log",
  97                                    fmt("h=%s", refname));
  98                 html_link_open(url, NULL, NULL);
  99                 strncpy(buf, refname, sizeof(buf));
 100                 html_txt(buf);
 101                 html_link_close();
 102                 html("</td><td>");
 103                 pretty_print_commit(CMIT_FMT_ONELINE, commit, ~0, buf,
 104                                     sizeof(buf), 0, NULL, NULL, 0);
 105                 html_txt(buf);
 106                 html("</td></tr>\n");
 107         } else {
 108                 html("<tr><td>");
 109                 html_txt(buf);
 110                 html("</td><td>");
 111                 htmlf("*** bad ref %s", sha1_to_hex(sha1));
 112                 html("</td></tr>\n");
 113         }
 114         return 0;
 115 }
 116
 117 static void cgit_print_branches()
 118 {
 119         html("<table class='list'>");
 120         html("<tr><th>Branch name</th><th>Head commit</th></tr>\n");
 121         for_each_branch_ref(cgit_print_branch_cb, NULL);
 122         html("</table>");
 123 }
 124
 125 static int get_one_line(char *txt)
 126 {
 127         char *t;
 128
 129         for(t=txt; *t != '\n' && t != '\0'; t++)
 130                 ;
 131         *t = '\0';
 132         return t-txt-1;
 133 }
 134
 135 static void cgit_print_commit_shortlog(struct commit *commit)
 136 {
 137         char *h, *t, *p;
 138         char *tree = NULL, *author = NULL, *subject = NULL;
 139         int len;
 140         time_t sec;
 141         struct tm *time;
 142         char buf[32];
 143
 144         h = t = commit->buffer;
 145
 146         if (strncmp(h, "tree ", 5))
 147                 die("Bad commit format: %s",
 148                     sha1_to_hex(commit->object.sha1));
 149
 150         len = get_one_line(h);
 151         tree = h+5;
 152         h += len + 2;
 153
 154         while (!strncmp(h, "parent ", 7))
 155                 h += get_one_line(h) + 2;
 156
 157         if (!strncmp(h, "author ", 7)) {
 158                 author = h+7;
 159                 h += get_one_line(h) + 2;
 160                 t = author;
 161                 while(t!=h && *t!='<')
 162                         t++;
 163                 *t='\0';
 164                 p = t;
 165                 while(--t!=author && *t==' ')
 166                         *t='\0';
 167                 while(++p!=h && *p!='>')
 168                         ;
 169                 while(++p!=h && !isdigit(*p))
 170                         ;
 171
 172                 t = p;
 173                 while(++p && isdigit(*p))
 174                         ;
 175                 *p = '\0';
 176                 sec = atoi(t);
 177                 time = gmtime(&sec);
 178         }
 179
 180         while((len = get_one_line(h)) > 0)
 181                 h += len+2;
 182
 183         h++;
 184         len = get_one_line(h);
 185
 186         subject = h;
 187
 188         html("<tr><td>");
 189         strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", time);
 190         html_txt(buf);
 191         html("</td><td>");
 192         char *qry = fmt("id=%s", sha1_to_hex(commit->object.sha1));
 193         char *url = cgit_pageurl(cgit_query_repo, "view", qry);
 194         html_link_open(url, NULL, NULL);
 195         html_txt(subject);
 196         html_link_close();
 197         html("</td><td>");
 198         html_txt(author);
 199         html("</td></tr>\n");
 200 }
 201
 202 static void cgit_print_log(const char *tip, int ofs, int cnt)
 203 {
 204         struct rev_info rev;
 205         struct commit *commit;
 206         const char *argv[2] = {NULL, tip};
 207         int n = 0;
 208
 209         init_revisions(&rev, NULL);
 210         rev.abbrev = DEFAULT_ABBREV;
 211         rev.commit_format = CMIT_FMT_DEFAULT;
 212         rev.verbose_header = 1;
 213         rev.show_root_diff = 0;
 214         setup_revisions(2, argv, &rev, NULL);
 215         prepare_revision_walk(&rev);
 216
 217         html("<h2>Log</h2>");
 218         html("<table class='list'>");
 219         html("<tr><th>Date</th><th>Message</th><th>Author</th></tr>\n");
 220         while ((commit = get_revision(&rev)) != NULL && n++ < 100) {
 221                 cgit_print_commit_shortlog(commit);
 222                 free(commit->buffer);
 223                 commit->buffer = NULL;
 224                 free_commit_list(commit->parents);
 225                 commit->parents = NULL;
 226         }
 227         html("</table>\n");
 228 }
 229
 230 static void cgit_print_repo_summary()
 231 {
 232         html("<h2>");
 233         html_txt("Repo summary page");
 234         html("</h2>");
 235         cgit_print_branches();
 236 }
 237
 238 static void cgit_print_object(char *hex)
 239 {
 240         unsigned char sha1[20];
 241         //struct object *object;
 242         char type[20];
 243         unsigned char *buf;
 244         unsigned long size;
 245
 246         if (get_sha1_hex(hex, sha1)){
 247                 cgit_print_error(fmt("Bad hex value: %s", hex));
 248                 return;
 249         }
 250
 251         if (sha1_object_info(sha1, type, NULL)){
 252                 cgit_print_error("Bad object name");
 253                 return;
 254         }
 255
 256         buf = read_sha1_file(sha1, type, &size);
 257         if (!buf) {
 258                 cgit_print_error("Error reading object");
 259                 return;
 260         }
 261
 262         buf[size] = '\0';
 263         html("<h2>Object view</h2>");
 264         htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size);
 265         html("<pre>");
 266         html_txt(buf);
 267         html("</pre>");
 268 }
 269
 270 static void cgit_print_repo_page(struct cacheitem *item)
 271 {
 272         if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) ||
 273             cgit_read_config("info/cgit", cgit_repo_config_cb)) {
 274                 char *title = fmt("%s - %s", cgit_root_title, "Bad request");
 275                 cgit_print_docstart(title, item);
 276                 cgit_print_pageheader(title);
 277                 cgit_print_error(fmt("Unable to scan repository: %s",
 278                                      strerror(errno)));
 279                 cgit_print_docend();
 280                 return;
 281         }
 282         setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1);
 283         char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc);
 284         cgit_print_docstart(title, item);
 285         cgit_print_pageheader(title);
 286         if (!cgit_query_page)
 287                 cgit_print_repo_summary();
 288         else if (!strcmp(cgit_query_page, "log")) {
 289                 cgit_print_log(cgit_query_head, 0, 100);
 290         } else if (!strcmp(cgit_query_page, "view")) {
 291                 cgit_print_object(cgit_query_sha1);
 292         }
 293         cgit_print_docend();
 294 }
 295
 296 static void cgit_fill_cache(struct cacheitem *item)
 297 {
 298         htmlfd = item->fd;
 299         item->st.st_mtime = time(NULL);
 300         if (cgit_query_repo)
 301                 cgit_print_repo_page(item);
 302         else
 303                 cgit_print_repolist(item);
 304 }
 305
 306 static void cgit_refresh_cache(struct cacheitem *item)
 307 {
 308         int i = 0;
 309
 310         cache_prepare(item);
 311  top:
 312         if (++i > cgit_max_lock_attempts) {
 313                 die("cgit_refresh_cache: unable to lock %s: %s",
 314                     item->name, strerror(errno));
 315         }
 316         if (!cache_exist(item)) {
 317                 if (!cache_lock(item)) {
 318                         sleep(1);
 319                         goto top;
 320                 }
 321                 if (!cache_exist(item))
 322                         cgit_fill_cache(item);
 323                 cache_unlock(item);
 324         } else if (cache_expired(item) && cache_lock(item)) {
 325                 if (cache_expired(item))
 326                         cgit_fill_cache(item);
 327                 cache_unlock(item);
 328         }
 329 }
 330
 331 static void cgit_print_cache(struct cacheitem *item)
 332 {
 333         static char buf[4096];
 334         ssize_t i;
 335
 336         int fd = open(item->name, O_RDONLY);
 337         if (fd<0)
 338                 die("Unable to open cached file %s", item->name);
 339
 340         while((i=read(fd, buf, sizeof(buf))) > 0)
 341                 write(STDOUT_FILENO, buf, i);
 342
 343         close(fd);
 344 }
 345
 346 int main(int argc, const char **argv)
 347 {
 348         cgit_read_config("/etc/cgitrc", cgit_global_config_cb);
 349         cgit_querystring = xstrdup(getenv("QUERY_STRING"));
 350         cgit_parse_query(cgit_querystring, cgit_querystring_cb);
 351         cgit_refresh_cache(&cacheitem);
 352         cgit_print_cache(&cacheitem);
 353         return 0;
 354 }