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