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 static int cgit_prepare_cache(struct cacheitem *item)
  12 {
  13         if (!ctx.repo && ctx.qry.repo) {
  14                 char *title = fmt("%s - %s", ctx.cfg.root_title, "Bad request");
  15                 cgit_print_docstart(title, item);
  16                 cgit_print_pageheader(title, 0);
  17                 cgit_print_error(fmt("Unknown repo: %s", ctx.qry.repo));
  18                 cgit_print_docend();
  19                 return 0;
  20         }
  21
  22         if (!ctx.repo) {
  23                 item->name = xstrdup(fmt("%s/index.html", ctx.cfg.cache_root));
  24                 item->ttl = ctx.cfg.cache_root_ttl;
  25                 return 1;
  26         }
  27
  28         if (!cgit_cmd) {
  29                 item->name = xstrdup(fmt("%s/%s/index.%s.html", ctx.cfg.cache_root,
  30                                          cache_safe_filename(ctx.repo->url),
  31                                          cache_safe_filename(ctx.qry.raw)));
  32                 item->ttl = ctx.cfg.cache_repo_ttl;
  33         } else {
  34                 item->name = xstrdup(fmt("%s/%s/%s/%s.html", ctx.cfg.cache_root,
  35                                          cache_safe_filename(ctx.repo->url),
  36                                          ctx.qry.page,
  37                                          cache_safe_filename(ctx.qry.raw)));
  38                 if (ctx.qry.has_symref)
  39                         item->ttl = ctx.cfg.cache_dynamic_ttl;
  40                 else if (ctx.qry.has_sha1)
  41                         item->ttl = ctx.cfg.cache_static_ttl;
  42                 else
  43                         item->ttl = ctx.cfg.cache_repo_ttl;
  44         }
  45         return 1;
  46 }
  47
  48 struct refmatch {
  49         char *req_ref;
  50         char *first_ref;
  51         int match;
  52 };
  53
  54 int find_current_ref(const char *refname, const unsigned char *sha1,
  55                      int flags, void *cb_data)
  56 {
  57         struct refmatch *info;
  58
  59         info = (struct refmatch *)cb_data;
  60         if (!strcmp(refname, info->req_ref))
  61                 info->match = 1;
  62         if (!info->first_ref)
  63                 info->first_ref = xstrdup(refname);
  64         return info->match;
  65 }
  66
  67 char *find_default_branch(struct cgit_repo *repo)
  68 {
  69         struct refmatch info;
  70
  71         info.req_ref = repo->defbranch;
  72         info.first_ref = NULL;
  73         info.match = 0;
  74         for_each_branch_ref(find_current_ref, &info);
  75         if (info.match)
  76                 return info.req_ref;
  77         else
  78                 return info.first_ref;
  79 }
  80
  81 static void cgit_print_repo_page(struct cacheitem *item)
  82 {
  83         char *title, *tmp;
  84         int show_search;
  85         unsigned char sha1[20];
  86         int nongit = 0;
  87
  88         setenv("GIT_DIR", ctx.repo->path, 1);
  89         setup_git_directory_gently(&nongit);
  90         if (nongit) {
  91                 title = fmt("%s - %s", ctx.cfg.root_title, "config error");
  92                 tmp = fmt("Not a git repository: '%s'", ctx.repo->path);
  93                 ctx.repo = NULL;
  94                 cgit_print_docstart(title, item);
  95                 cgit_print_pageheader(title, 0);
  96                 cgit_print_error(tmp);
  97                 cgit_print_docend();
  98                 return;
  99         }
 100
 101         title = fmt("%s - %s", ctx.repo->name, ctx.repo->desc);
 102         show_search = 0;
 103
 104         if (!ctx.qry.head) {
 105                 ctx.qry.head = xstrdup(find_default_branch(ctx.repo));
 106                 ctx.repo->defbranch = ctx.qry.head;
 107         }
 108
 109         if (!ctx.qry.head) {
 110                 cgit_print_docstart(title, item);
 111                 cgit_print_pageheader(title, 0);
 112                 cgit_print_error("Repository seems to be empty");
 113                 cgit_print_docend();
 114                 return;
 115         }
 116
 117         if (get_sha1(ctx.qry.head, sha1)) {
 118                 tmp = xstrdup(ctx.qry.head);
 119                 ctx.qry.head = ctx.repo->defbranch;
 120                 cgit_print_docstart(title, item);
 121                 cgit_print_pageheader(title, 0);
 122                 cgit_print_error(fmt("Invalid branch: %s", tmp));
 123                 cgit_print_docend();
 124                 return;
 125         }
 126
 127         if ((cgit_cmd == CMD_SNAPSHOT) && ctx.repo->snapshots) {
 128                 cgit_print_snapshot(item, ctx.qry.head, ctx.qry.sha1,
 129                                     cgit_repobasename(ctx.repo->url),
 130                                     ctx.qry.path,
 131                                     ctx.repo->snapshots );
 132                 return;
 133         }
 134
 135         if (cgit_cmd == CMD_PATCH) {
 136                 cgit_print_patch(ctx.qry.sha1, item);
 137                 return;
 138         }
 139
 140         if (cgit_cmd == CMD_BLOB) {
 141                 cgit_print_blob(item, ctx.qry.sha1, ctx.qry.path);
 142                 return;
 143         }
 144
 145         show_search = (cgit_cmd == CMD_LOG);
 146         cgit_print_docstart(title, item);
 147         if (!cgit_cmd) {
 148                 cgit_print_pageheader("summary", show_search);
 149                 cgit_print_summary();
 150                 cgit_print_docend();
 151                 return;
 152         }
 153
 154         cgit_print_pageheader(ctx.qry.page, show_search);
 155
 156         switch(cgit_cmd) {
 157         case CMD_LOG:
 158                 cgit_print_log(ctx.qry.sha1, ctx.qry.ofs,
 159                                ctx.cfg.max_commit_count, ctx.qry.grep, ctx.qry.search,
 160                                ctx.qry.path, 1);
 161                 break;
 162         case CMD_TREE:
 163                 cgit_print_tree(ctx.qry.sha1, ctx.qry.path);
 164                 break;
 165         case CMD_COMMIT:
 166                 cgit_print_commit(ctx.qry.sha1);
 167                 break;
 168         case CMD_REFS:
 169                 cgit_print_refs();
 170                 break;
 171         case CMD_TAG:
 172                 cgit_print_tag(ctx.qry.sha1);
 173                 break;
 174         case CMD_DIFF:
 175                 cgit_print_diff(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path);
 176                 break;
 177         default:
 178                 cgit_print_error("Invalid request");
 179         }
 180         cgit_print_docend();
 181 }
 182
 183 static void cgit_fill_cache(struct cacheitem *item, int use_cache)
 184 {
 185         int stdout2;
 186
 187         item->st.st_mtime = time(NULL);
 188
 189         if (use_cache) {
 190                 stdout2 = chk_positive(dup(STDOUT_FILENO),
 191                                        "Preserving STDOUT");
 192                 chk_zero(close(STDOUT_FILENO), "Closing STDOUT");
 193                 chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)");
 194         }
 195
 196         if (ctx.repo)
 197                 cgit_print_repo_page(item);
 198         else
 199                 cgit_print_repolist(item);
 200
 201         if (use_cache) {
 202                 chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT");
 203                 chk_positive(dup2(stdout2, STDOUT_FILENO),
 204                              "Restoring original STDOUT");
 205                 chk_zero(close(stdout2), "Closing temporary STDOUT");
 206         }
 207 }
 208
 209 static void cgit_check_cache(struct cacheitem *item)
 210 {
 211         int i = 0;
 212
 213  top:
 214         if (++i > ctx.cfg.max_lock_attempts) {
 215                 die("cgit_refresh_cache: unable to lock %s: %s",
 216                     item->name, strerror(errno));
 217         }
 218         if (!cache_exist(item)) {
 219                 if (!cache_lock(item)) {
 220                         sleep(1);
 221                         goto top;
 222                 }
 223                 if (!cache_exist(item)) {
 224                         cgit_fill_cache(item, 1);
 225                         cache_unlock(item);
 226                 } else {
 227                         cache_cancel_lock(item);
 228                 }
 229         } else if (cache_expired(item) && cache_lock(item)) {
 230                 if (cache_expired(item)) {
 231                         cgit_fill_cache(item, 1);
 232                         cache_unlock(item);
 233                 } else {
 234                         cache_cancel_lock(item);
 235                 }
 236         }
 237 }
 238
 239 static void cgit_print_cache(struct cacheitem *item)
 240 {
 241         static char buf[4096];
 242         ssize_t i;
 243
 244         int fd = open(item->name, O_RDONLY);
 245         if (fd<0)
 246                 die("Unable to open cached file %s", item->name);
 247
 248         while((i=read(fd, buf, sizeof(buf))) > 0)
 249                 write(STDOUT_FILENO, buf, i);
 250
 251         close(fd);
 252 }
 253
 254 static void cgit_parse_args(int argc, const char **argv)
 255 {
 256         int i;
 257
 258         for (i = 1; i < argc; i++) {
 259                 if (!strncmp(argv[i], "--cache=", 8)) {
 260                         ctx.cfg.cache_root = xstrdup(argv[i]+8);
 261                 }
 262                 if (!strcmp(argv[i], "--nocache")) {
 263                         ctx.cfg.nocache = 1;
 264                 }
 265                 if (!strncmp(argv[i], "--query=", 8)) {
 266                         ctx.qry.raw = xstrdup(argv[i]+8);
 267                 }
 268                 if (!strncmp(argv[i], "--repo=", 7)) {
 269                         ctx.qry.repo = xstrdup(argv[i]+7);
 270                 }
 271                 if (!strncmp(argv[i], "--page=", 7)) {
 272                         ctx.qry.page = xstrdup(argv[i]+7);
 273                 }
 274                 if (!strncmp(argv[i], "--head=", 7)) {
 275                         ctx.qry.head = xstrdup(argv[i]+7);
 276                         ctx.qry.has_symref = 1;
 277                 }
 278                 if (!strncmp(argv[i], "--sha1=", 7)) {
 279                         ctx.qry.sha1 = xstrdup(argv[i]+7);
 280                         ctx.qry.has_sha1 = 1;
 281                 }
 282                 if (!strncmp(argv[i], "--ofs=", 6)) {
 283                         ctx.qry.ofs = atoi(argv[i]+6);
 284                 }
 285         }
 286 }
 287
 288 int main(int argc, const char **argv)
 289 {
 290         struct cacheitem item;
 291         const char *cgit_config_env = getenv("CGIT_CONFIG");
 292
 293         cgit_prepare_context(&ctx);
 294         item.st.st_mtime = time(NULL);
 295         cgit_repolist.length = 0;
 296         cgit_repolist.count = 0;
 297         cgit_repolist.repos = NULL;
 298
 299         cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG,
 300                          cgit_global_config_cb);
 301         if (getenv("SCRIPT_NAME"))
 302                 ctx.cfg.script_name = xstrdup(getenv("SCRIPT_NAME"));
 303         if (getenv("QUERY_STRING"))
 304                 ctx.qry.raw = xstrdup(getenv("QUERY_STRING"));
 305         cgit_parse_args(argc, argv);
 306         cgit_parse_query(ctx.qry.raw, cgit_querystring_cb);
 307         if (!cgit_prepare_cache(&item))
 308                 return 0;
 309         if (ctx.cfg.nocache) {
 310                 cgit_fill_cache(&item, 0);
 311         } else {
 312                 cgit_check_cache(&item);
 313                 cgit_print_cache(&item);
 314         }
 315         return 0;
 316 }