3 files changed, 6 insertions, 1 deletions

diff --git a/cgit.c b/cgit.c
index a92383d..36777b5 100644
--- a/cgit.c
+++ b/cgit.c
@@ -192,128 +192,129 @@ static void querystring_cb(const char *name, const char *value)
         } else if (!strcmp(name, "h")) {
                 ctx.qry.head = xstrdup(value);
                 ctx.qry.has_symref = 1;
         } else if (!strcmp(name, "id")) {
                 ctx.qry.sha1 = xstrdup(value);
                 ctx.qry.has_sha1 = 1;
         } else if (!strcmp(name, "id2")) {
                 ctx.qry.sha2 = xstrdup(value);
                 ctx.qry.has_sha1 = 1;
         } else if (!strcmp(name, "ofs")) {
                 ctx.qry.ofs = atoi(value);
         } else if (!strcmp(name, "path")) {
                 ctx.qry.path = trim_end(value, '/');
         } else if (!strcmp(name, "name")) {
                 ctx.qry.name = xstrdup(value);
         } else if (!strcmp(name, "mimetype")) {
                 ctx.qry.mimetype = xstrdup(value);
         } else if (!strcmp(name, "s")){
                 ctx.qry.sort = xstrdup(value);
         } else if (!strcmp(name, "showmsg")) {
                 ctx.qry.showmsg = atoi(value);
         } else if (!strcmp(name, "period")) {
                 ctx.qry.period = xstrdup(value);
         }
 }
 
 char *xstrdupn(const char *str)
 {
         return (str ? xstrdup(str) : NULL);
 }
 
 static void prepare_context(struct cgit_context *ctx)
 {
         memset(ctx, 0, sizeof(ctx));
         ctx->cfg.agefile = "info/web/last-modified";
         ctx->cfg.nocache = 0;
         ctx->cfg.cache_size = 0;
         ctx->cfg.cache_dynamic_ttl = 5;
         ctx->cfg.cache_max_create_time = 5;
         ctx->cfg.cache_repo_ttl = 5;
         ctx->cfg.cache_root = CGIT_CACHE_ROOT;
         ctx->cfg.cache_root_ttl = 5;
         ctx->cfg.cache_static_ttl = -1;
         ctx->cfg.css = "/cgit.css";
         ctx->cfg.logo = "/git-logo.png";
         ctx->cfg.local_time = 0;
         ctx->cfg.max_repo_count = 50;
         ctx->cfg.max_commit_count = 50;
         ctx->cfg.max_lock_attempts = 5;
         ctx->cfg.max_msg_len = 80;
         ctx->cfg.max_repodesc_len = 80;
         ctx->cfg.max_stats = 0;
         ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s";
         ctx->cfg.renamelimit = -1;
         ctx->cfg.robots = "index, nofollow";
         ctx->cfg.root_title = "Git repository browser";
         ctx->cfg.root_desc = "a fast webinterface for the git dscm";
         ctx->cfg.script_name = CGIT_SCRIPT_NAME;
         ctx->cfg.summary_branches = 10;
         ctx->cfg.summary_log = 10;
         ctx->cfg.summary_tags = 10;
         ctx->env.cgit_config = xstrdupn(getenv("CGIT_CONFIG"));
         ctx->env.http_host = xstrdupn(getenv("HTTP_HOST"));
         ctx->env.https = xstrdupn(getenv("HTTPS"));
+        ctx->env.no_http = xstrdupn(getenv("NO_HTTP"));
         ctx->env.path_info = xstrdupn(getenv("PATH_INFO"));
         ctx->env.query_string = xstrdupn(getenv("QUERY_STRING"));
         ctx->env.request_method = xstrdupn(getenv("REQUEST_METHOD"));
         ctx->env.script_name = xstrdupn(getenv("SCRIPT_NAME"));
         ctx->env.server_name = xstrdupn(getenv("SERVER_NAME"));
         ctx->env.server_port = xstrdupn(getenv("SERVER_PORT"));
         ctx->page.mimetype = "text/html";
         ctx->page.charset = PAGE_ENCODING;
         ctx->page.filename = NULL;
         ctx->page.size = 0;
         ctx->page.modified = time(NULL);
         ctx->page.expires = ctx->page.modified;
         ctx->page.etag = NULL;
         memset(&ctx->cfg.mimetypes, 0, sizeof(struct string_list));
         if (ctx->env.script_name)
                 ctx->cfg.script_name = ctx->env.script_name;
         if (ctx->env.query_string)
                 ctx->qry.raw = ctx->env.query_string;
         if (!ctx->env.cgit_config)
                 ctx->env.cgit_config = CGIT_CONFIG;
 }
 
 struct refmatch {
         char *req_ref;
         char *first_ref;
         int match;
 };
 
 int find_current_ref(const char *refname, const unsigned char *sha1,
                      int flags, void *cb_data)
 {
         struct refmatch *info;
 
         info = (struct refmatch *)cb_data;
         if (!strcmp(refname, info->req_ref))
                 info->match = 1;
         if (!info->first_ref)
                 info->first_ref = xstrdup(refname);
         return info->match;
 }
 
 char *find_default_branch(struct cgit_repo *repo)
 {
         struct refmatch info;
         char *ref;
 
         info.req_ref = repo->defbranch;
         info.first_ref = NULL;
         info.match = 0;
         for_each_branch_ref(find_current_ref, &info);
         if (info.match)
                 ref = info.req_ref;
         else
                 ref = info.first_ref;
         if (ref)
                 ref = xstrdup(ref);
         return ref;
 }
 
 static int prepare_repo_cmd(struct cgit_context *ctx)
 {
         char *tmp;
         unsigned char sha1[20];
         int nongit = 0;
@@ -384,128 +385,131 @@ static void process_request(void *cbdata)
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
                 cgit_print_error(fmt("No repository selected"));
                 cgit_print_docend();
                 return;
         }
 
         if (ctx->repo && prepare_repo_cmd(ctx))
                 return;
 
         if (cmd->want_layout) {
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
         }
 
         cmd->fn(ctx);
 
         if (cmd->want_layout)
                 cgit_print_docend();
 }
 
 int cmp_repos(const void *a, const void *b)
 {
         const struct cgit_repo *ra = a, *rb = b;
         return strcmp(ra->url, rb->url);
 }
 
 void print_repo(struct cgit_repo *repo)
 {
         printf("repo.url=%s\n", repo->url);
         printf("repo.name=%s\n", repo->name);
         printf("repo.path=%s\n", repo->path);
         if (repo->owner)
                 printf("repo.owner=%s\n", repo->owner);
         if (repo->desc)
                 printf("repo.desc=%s\n", repo->desc);
         if (repo->readme)
                 printf("repo.readme=%s\n", repo->readme);
         printf("\n");
 }
 
 void print_repolist(struct cgit_repolist *list)
 {
         int i;
 
         for(i = 0; i < list->count; i++)
                 print_repo(&list->repos[i]);
 }
 
 
 static void cgit_parse_args(int argc, const char **argv)
 {
         int i;
         int scan = 0;
 
         for (i = 1; i < argc; i++) {
                 if (!strncmp(argv[i], "--cache=", 8)) {
                         ctx.cfg.cache_root = xstrdup(argv[i]+8);
                 }
                 if (!strcmp(argv[i], "--nocache")) {
                         ctx.cfg.nocache = 1;
                 }
+                if (!strcmp(argv[i], "--nohttp")) {
+                        ctx.env.no_http = "1";
+                }
                 if (!strncmp(argv[i], "--query=", 8)) {
                         ctx.qry.raw = xstrdup(argv[i]+8);
                 }
                 if (!strncmp(argv[i], "--repo=", 7)) {
                         ctx.qry.repo = xstrdup(argv[i]+7);
                 }
                 if (!strncmp(argv[i], "--page=", 7)) {
                         ctx.qry.page = xstrdup(argv[i]+7);
                 }
                 if (!strncmp(argv[i], "--head=", 7)) {
                         ctx.qry.head = xstrdup(argv[i]+7);
                         ctx.qry.has_symref = 1;
                 }
                 if (!strncmp(argv[i], "--sha1=", 7)) {
                         ctx.qry.sha1 = xstrdup(argv[i]+7);
                         ctx.qry.has_sha1 = 1;
                 }
                 if (!strncmp(argv[i], "--ofs=", 6)) {
                         ctx.qry.ofs = atoi(argv[i]+6);
                 }
                 if (!strncmp(argv[i], "--scan-tree=", 12)) {
                         scan++;
                         scan_tree(argv[i] + 12);
                 }
         }
         if (scan) {
                 qsort(cgit_repolist.repos, cgit_repolist.count,
                         sizeof(struct cgit_repo), cmp_repos);
                 print_repolist(&cgit_repolist);
                 exit(0);
         }
 }
 
 static int calc_ttl()
 {
         if (!ctx.repo)
                 return ctx.cfg.cache_root_ttl;
 
         if (!ctx.qry.page)
                 return ctx.cfg.cache_repo_ttl;
 
         if (ctx.qry.has_symref)
                 return ctx.cfg.cache_dynamic_ttl;
 
         if (ctx.qry.has_sha1)
                 return ctx.cfg.cache_static_ttl;
 
         return ctx.cfg.cache_repo_ttl;
 }
 
 int main(int argc, const char **argv)
 {
         const char *path;
         char *qry;
         int err, ttl;
 
         prepare_context(&ctx);
         cgit_repolist.length = 0;
         cgit_repolist.count = 0;
         cgit_repolist.repos = NULL;
 
         cgit_parse_args(argc, argv);
         parse_configfile(ctx.env.cgit_config, config_cb);
         ctx.repo = NULL;
diff --git a/cgit.h b/cgit.h
index 893231d..d90ccdc 100644
--- a/cgit.h
+++ b/cgit.h
@@ -150,128 +150,129 @@ struct cgit_config {
         char *favicon;
         char *footer;
         char *head_include;
         char *header;
         char *index_header;
         char *index_info;
         char *logo;
         char *logo_link;
         char *module_link;
         char *repo_group;
         char *robots;
         char *root_title;
         char *root_desc;
         char *root_readme;
         char *script_name;
         char *virtual_root;
         int cache_size;
         int cache_dynamic_ttl;
         int cache_max_create_time;
         int cache_repo_ttl;
         int cache_root_ttl;
         int cache_static_ttl;
         int embedded;
         int enable_index_links;
         int enable_log_filecount;
         int enable_log_linecount;
         int local_time;
         int max_repo_count;
         int max_commit_count;
         int max_lock_attempts;
         int max_msg_len;
         int max_repodesc_len;
         int max_stats;
         int nocache;
         int noplainemail;
         int noheader;
         int renamelimit;
         int snapshots;
         int summary_branches;
         int summary_log;
         int summary_tags;
         struct string_list mimetypes;
         struct cgit_filter *about_filter;
         struct cgit_filter *commit_filter;
         struct cgit_filter *source_filter;
 };
 
 struct cgit_page {
         time_t modified;
         time_t expires;
         size_t size;
         char *mimetype;
         char *charset;
         char *filename;
         char *etag;
         char *title;
         int status;
         char *statusmsg;
 };
 
 struct cgit_environment {
         char *cgit_config;
         char *http_host;
         char *https;
+        char *no_http;
         char *path_info;
         char *query_string;
         char *request_method;
         char *script_name;
         char *server_name;
         char *server_port;
 };
 
 struct cgit_context {
         struct cgit_environment env;
         struct cgit_query qry;
         struct cgit_config cfg;
         struct cgit_repo *repo;
         struct cgit_page page;
 };
 
 struct cgit_snapshot_format {
         const char *suffix;
         const char *mimetype;
         write_archive_fn_t write_func;
         int bit;
 };
 
 extern const char *cgit_version;
 
 extern struct cgit_repolist cgit_repolist;
 extern struct cgit_context ctx;
 extern const struct cgit_snapshot_format cgit_snapshot_formats[];
 
 extern struct cgit_repo *cgit_add_repo(const char *url);
 extern struct cgit_repo *cgit_get_repoinfo(const char *url);
 extern void cgit_repo_config_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 chk_non_negative(int result, char *msg);
 
 extern char *trim_end(const char *str, char c);
 extern char *strlpart(char *txt, int maxlen);
 extern char *strrpart(char *txt, int maxlen);
 
 extern void cgit_add_ref(struct reflist *list, struct refinfo *ref);
 extern int cgit_refs_cb(const char *refname, const unsigned char *sha1,
                         int flags, void *cb_data);
 
 extern void *cgit_free_commitinfo(struct commitinfo *info);
 
 extern int cgit_diff_files(const unsigned char *old_sha1,
                            const unsigned char *new_sha1,
                            unsigned long *old_size, unsigned long *new_size,
                            int *binary, linediff_fn fn);
 
 extern void cgit_diff_tree(const unsigned char *old_sha1,
                            const unsigned char *new_sha1,
                            filepair_fn fn, const char *prefix);
 
 extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
 
 extern char *fmt(const char *format,...);
 
 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);
 
diff --git a/ui-shared.c b/ui-shared.c
index 538ddda..4175bd8 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -394,129 +394,129 @@ void cgit_object_link(struct object *obj)
         name = fmt("%s %s...", typename(obj->type), shortrev);
         reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL);
 }
 
 void cgit_print_date(time_t secs, char *format, int local_time)
 {
         char buf[64];
         struct tm *time;
 
         if (!secs)
                 return;
         if(local_time)
                 time = localtime(&secs);
         else
                 time = gmtime(&secs);
         strftime(buf, sizeof(buf)-1, format, time);
         html_txt(buf);
 }
 
 void cgit_print_age(time_t t, time_t max_relative, char *format)
 {
         time_t now, secs;
 
         if (!t)
                 return;
         time(&now);
         secs = now - t;
 
         if (secs > max_relative && max_relative >= 0) {
                 cgit_print_date(t, format, ctx.cfg.local_time);
                 return;
         }
 
         if (secs < TM_HOUR * 2) {
                 htmlf("<span class='age-mins'>%.0f min.</span>",
                       secs * 1.0 / TM_MIN);
                 return;
         }
         if (secs < TM_DAY * 2) {
                 htmlf("<span class='age-hours'>%.0f hours</span>",
                       secs * 1.0 / TM_HOUR);
                 return;
         }
         if (secs < TM_WEEK * 2) {
                 htmlf("<span class='age-days'>%.0f days</span>",
                       secs * 1.0 / TM_DAY);
                 return;
         }
         if (secs < TM_MONTH * 2) {
                 htmlf("<span class='age-weeks'>%.0f weeks</span>",
                       secs * 1.0 / TM_WEEK);
                 return;
         }
         if (secs < TM_YEAR * 2) {
                 htmlf("<span class='age-months'>%.0f months</span>",
                       secs * 1.0 / TM_MONTH);
                 return;
         }
         htmlf("<span class='age-years'>%.0f years</span>",
               secs * 1.0 / TM_YEAR);
 }
 
 void cgit_print_http_headers(struct cgit_context *ctx)
 {
-        if (ctx->cfg.embedded)
+        if (ctx->env.no_http && !strcmp(ctx->env.no_http, "1"))
                 return;
 
         if (ctx->page.status)
                 htmlf("Status: %d %s\n", ctx->page.status, ctx->page.statusmsg);
         if (ctx->page.mimetype && ctx->page.charset)
                 htmlf("Content-Type: %s; charset=%s\n", ctx->page.mimetype,
                       ctx->page.charset);
         else if (ctx->page.mimetype)
                 htmlf("Content-Type: %s\n", ctx->page.mimetype);
         if (ctx->page.size)
                 htmlf("Content-Length: %ld\n", ctx->page.size);
         if (ctx->page.filename)
                 htmlf("Content-Disposition: inline; filename=\"%s\"\n",
                       ctx->page.filename);
         htmlf("Last-Modified: %s\n", http_date(ctx->page.modified));
         htmlf("Expires: %s\n", http_date(ctx->page.expires));
         if (ctx->page.etag)
                 htmlf("ETag: \"%s\"\n", ctx->page.etag);
         html("\n");
         if (ctx->env.request_method && !strcmp(ctx->env.request_method, "HEAD"))
                 exit(0);
 }
 
 void cgit_print_docstart(struct cgit_context *ctx)
 {
         if (ctx->cfg.embedded)
                 return;
 
         char *host = cgit_hosturl();
         html(cgit_doctype);
         html("<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en' lang='en'>\n");
         html("<head>\n");
         html("<title>");
         html_txt(ctx->page.title);
         html("</title>\n");
         htmlf("<meta name='generator' content='cgit %s'/>\n", cgit_version);
         if (ctx->cfg.robots && *ctx->cfg.robots)
                 htmlf("<meta name='robots' content='%s'/>\n", ctx->cfg.robots);
         html("<link rel='stylesheet' type='text/css' href='");
         html_attr(ctx->cfg.css);
         html("'/>\n");
         if (ctx->cfg.favicon) {
                 html("<link rel='shortcut icon' href='");
                 html_attr(ctx->cfg.favicon);
                 html("'/>\n");
         }
         if (host && ctx->repo) {
                 html("<link rel='alternate' title='Atom feed' href='");
                 html(cgit_httpscheme());
                 html_attr(cgit_hosturl());
                 html_attr(cgit_fileurl(ctx->repo->url, "atom", ctx->qry.path,
                                        fmt("h=%s", ctx->qry.head)));
                 html("' type='application/atom+xml'/>\n");
         }
         if (ctx->cfg.head_include)
                 html_include(ctx->cfg.head_include);
         html("</head>\n");
         html("<body>\n");
         if (ctx->cfg.header)
                 html_include(ctx->cfg.header);
 }
 
 void cgit_print_docend()
 {