1 files changed, 1 insertions, 1 deletions
diff --git a/ui-plain.c b/ui-plain.c
index da76406..1b2b672 100644
--- a/ui-plain.c
+++ b/ui-plain.c
@@ -1,133 +1,133 @@
 /* ui-plain.c: functions for output of plain blobs by path
 *
 * Copyright (C) 2008 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 int match_baselen;
 int match;
 static void print_object(const unsigned char *sha1, const char *path)
 {
        enum object_type type;
        char *buf, *ext;
        unsigned long size;
        struct string_list_item *mime;
        type = sha1_object_info(sha1, &size);
        if (type == OBJ_BAD) {
                html_status(404, "Not found", 0);
                return;
        }
        buf = read_sha1_file(sha1, &type, &size);
        if (!buf) {
                html_status(404, "Not found", 0);
                return;
        }
        ctx.page.mimetype = NULL;
        ext = strrchr(path, '.');
        if (ext && *(++ext)) {
-                mime = string_list_lookup(ext, &ctx.cfg.mimetypes);
+                mime = string_list_lookup(&ctx.cfg.mimetypes, ext);
                if (mime)
                        ctx.page.mimetype = (char *)mime->util;
        }
        if (!ctx.page.mimetype) {
                if (buffer_is_binary(buf, size))
                        ctx.page.mimetype = "application/octet-stream";
                else
                        ctx.page.mimetype = "text/plain";
        }
        ctx.page.filename = fmt("%s", path);
        ctx.page.size = size;
        ctx.page.etag = sha1_to_hex(sha1);
        cgit_print_http_headers(&ctx);
        html_raw(buf, size);
        match = 1;
 }
 static void print_dir(const unsigned char *sha1, const char *path,
                      const char *base)
 {
        char *fullpath;
        if (path[0] || base[0])
                fullpath = fmt("/%s%s/", base, path);
        else
                fullpath = "/";
        ctx.page.etag = sha1_to_hex(sha1);
        cgit_print_http_headers(&ctx);
        htmlf("<html><head><title>%s</title></head>\n<body>\n"
              " <h2>%s</h2>\n <ul>\n", fullpath, fullpath);
        if (path[0] || base[0])
              html("  <li><a href=\"../\">../</a></li>\n");
        match = 2;
 }
 static void print_dir_entry(const unsigned char *sha1, const char *path,
                            unsigned mode)
 {
        const char *sep = "";
        if (S_ISDIR(mode))
                sep = "/";
        htmlf("  <li><a href=\"%s%s\">%s%s</a></li>\n", path, sep, path, sep);
        match = 2;
 }
 static void print_dir_tail(void)
 {
        html(" </ul>\n</body></html>\n");
 }
 static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
                     const char *pathname, unsigned mode, int stage,
                     void *cbdata)
 {
        if (baselen == match_baselen) {
                if (S_ISREG(mode))
                        print_object(sha1, pathname);
                else if (S_ISDIR(mode)) {
                        print_dir(sha1, pathname, base);
                        return READ_TREE_RECURSIVE;
                }
        }
        else if (baselen > match_baselen)
                print_dir_entry(sha1, pathname, mode);
        else if (S_ISDIR(mode))
                return READ_TREE_RECURSIVE;
        return 0;
 }
 static int basedir_len(const char *path)
 {
        char *p = strrchr(path, '/');
        if (p)
                return p - path + 1;
        return 0;
 }
 void cgit_print_plain(struct cgit_context *ctx)
 {
        const char *rev = ctx->qry.sha1;
        unsigned char sha1[20];
        struct commit *commit;
        const char *paths[] = {ctx->qry.path, NULL};
        if (!rev)
                rev = ctx->qry.head;
        if (get_sha1(rev, sha1)) {
                html_status(404, "Not found", 0);
                return;
        }
        commit = lookup_commit_reference(sha1);
        if (!commit || parse_commit(commit)) {
                html_status(404, "Not found", 0);
                return;
        }

diff --git a/ui-plain.c b/ui-plain.c index da76406..1b2b672 100644 --- a/ui-plain.c +++ b/ui-plain.c
@@ -1,133 +1,133 @@
1	/* ui-plain.c: functions for output of plain blobs by path	1	/* ui-plain.c: functions for output of plain blobs by path
2	*	2	*
3	* Copyright (C) 2008 Lars Hjemli	3	* Copyright (C) 2008 Lars Hjemli
4	*	4	*
5	* Licensed under GNU General Public License v2	5	* Licensed under GNU General Public License v2
6	* (see COPYING for full license text)	6	* (see COPYING for full license text)
7	*/	7	*/
8		8
9	#include "cgit.h"	9	#include "cgit.h"
10	#include "html.h"	10	#include "html.h"
11	#include "ui-shared.h"	11	#include "ui-shared.h"
12		12
13	int match_baselen;	13	int match_baselen;
14	int match;	14	int match;
15		15
16	static void print_object(const unsigned char sha1, const char path)	16	static void print_object(const unsigned char sha1, const char path)
17	{	17	{
18	enum object_type type;	18	enum object_type type;
19	char buf, ext;	19	char buf, ext;
20	unsigned long size;	20	unsigned long size;
21	struct string_list_item *mime;	21	struct string_list_item *mime;
22		22
23	type = sha1_object_info(sha1, &size);	23	type = sha1_object_info(sha1, &size);
24	if (type == OBJ_BAD) {	24	if (type == OBJ_BAD) {
25	html_status(404, "Not found", 0);	25	html_status(404, "Not found", 0);
26	return;	26	return;
27	}	27	}
28		28
29	buf = read_sha1_file(sha1, &type, &size);	29	buf = read_sha1_file(sha1, &type, &size);
30	if (!buf) {	30	if (!buf) {
31	html_status(404, "Not found", 0);	31	html_status(404, "Not found", 0);
32	return;	32	return;
33	}	33	}
34	ctx.page.mimetype = NULL;	34	ctx.page.mimetype = NULL;
35	ext = strrchr(path, '.');	35	ext = strrchr(path, '.');
36	if (ext && *(++ext)) {	36	if (ext && *(++ext)) {
37	mime = string_list_lookup(ext, &ctx.cfg.mimetypes);	37	mime = string_list_lookup(&ctx.cfg.mimetypes, ext);
38	if (mime)	38	if (mime)
39	ctx.page.mimetype = (char *)mime->util;	39	ctx.page.mimetype = (char *)mime->util;
40	}	40	}
41	if (!ctx.page.mimetype) {	41	if (!ctx.page.mimetype) {
42	if (buffer_is_binary(buf, size))	42	if (buffer_is_binary(buf, size))
43	ctx.page.mimetype = "application/octet-stream";	43	ctx.page.mimetype = "application/octet-stream";
44	else	44	else
45	ctx.page.mimetype = "text/plain";	45	ctx.page.mimetype = "text/plain";
46	}	46	}
47	ctx.page.filename = fmt("%s", path);	47	ctx.page.filename = fmt("%s", path);
48	ctx.page.size = size;	48	ctx.page.size = size;
49	ctx.page.etag = sha1_to_hex(sha1);	49	ctx.page.etag = sha1_to_hex(sha1);
50	cgit_print_http_headers(&ctx);	50	cgit_print_http_headers(&ctx);
51	html_raw(buf, size);	51	html_raw(buf, size);
52	match = 1;	52	match = 1;
53	}	53	}
54		54
55	static void print_dir(const unsigned char sha1, const char path,	55	static void print_dir(const unsigned char sha1, const char path,
56	const char *base)	56	const char *base)
57	{	57	{
58	char *fullpath;	58	char *fullpath;
59	if (path[0] \|\| base[0])	59	if (path[0] \|\| base[0])
60	fullpath = fmt("/%s%s/", base, path);	60	fullpath = fmt("/%s%s/", base, path);
61	else	61	else
62	fullpath = "/";	62	fullpath = "/";
63	ctx.page.etag = sha1_to_hex(sha1);	63	ctx.page.etag = sha1_to_hex(sha1);
64	cgit_print_http_headers(&ctx);	64	cgit_print_http_headers(&ctx);
65	htmlf("<html><head><title>%s</title></head>\n<body>\n"	65	htmlf("<html><head><title>%s</title></head>\n<body>\n"
66	" <h2>%s</h2>\n <ul>\n", fullpath, fullpath);	66	" <h2>%s</h2>\n <ul>\n", fullpath, fullpath);
67	if (path[0] \|\| base[0])	67	if (path[0] \|\| base[0])
68	html(" <li><a href=\"../\">../</a></li>\n");	68	html(" <li><a href=\"../\">../</a></li>\n");
69	match = 2;	69	match = 2;
70	}	70	}
71		71
72	static void print_dir_entry(const unsigned char sha1, const char path,	72	static void print_dir_entry(const unsigned char sha1, const char path,
73	unsigned mode)	73	unsigned mode)
74	{	74	{
75	const char *sep = "";	75	const char *sep = "";
76	if (S_ISDIR(mode))	76	if (S_ISDIR(mode))
77	sep = "/";	77	sep = "/";
78	htmlf(" <li><a href=\"%s%s\">%s%s</a></li>\n", path, sep, path, sep);	78	htmlf(" <li><a href=\"%s%s\">%s%s</a></li>\n", path, sep, path, sep);
79	match = 2;	79	match = 2;
80	}	80	}
81		81
82	static void print_dir_tail(void)	82	static void print_dir_tail(void)
83	{	83	{
84	html(" </ul>\n</body></html>\n");	84	html(" </ul>\n</body></html>\n");
85	}	85	}
86		86
87	static int walk_tree(const unsigned char sha1, const char base, int baselen,	87	static int walk_tree(const unsigned char sha1, const char base, int baselen,
88	const char *pathname, unsigned mode, int stage,	88	const char *pathname, unsigned mode, int stage,
89	void *cbdata)	89	void *cbdata)
90	{	90	{
91	if (baselen == match_baselen) {	91	if (baselen == match_baselen) {
92	if (S_ISREG(mode))	92	if (S_ISREG(mode))
93	print_object(sha1, pathname);	93	print_object(sha1, pathname);
94	else if (S_ISDIR(mode)) {	94	else if (S_ISDIR(mode)) {
95	print_dir(sha1, pathname, base);	95	print_dir(sha1, pathname, base);
96	return READ_TREE_RECURSIVE;	96	return READ_TREE_RECURSIVE;
97	}	97	}
98	}	98	}
99	else if (baselen > match_baselen)	99	else if (baselen > match_baselen)
100	print_dir_entry(sha1, pathname, mode);	100	print_dir_entry(sha1, pathname, mode);
101	else if (S_ISDIR(mode))	101	else if (S_ISDIR(mode))
102	return READ_TREE_RECURSIVE;	102	return READ_TREE_RECURSIVE;
103		103
104	return 0;	104	return 0;
105	}	105	}
106		106
107	static int basedir_len(const char *path)	107	static int basedir_len(const char *path)
108	{	108	{
109	char *p = strrchr(path, '/');	109	char *p = strrchr(path, '/');
110	if (p)	110	if (p)
111	return p - path + 1;	111	return p - path + 1;
112	return 0;	112	return 0;
113	}	113	}
114		114
115	void cgit_print_plain(struct cgit_context *ctx)	115	void cgit_print_plain(struct cgit_context *ctx)
116	{	116	{
117	const char *rev = ctx->qry.sha1;	117	const char *rev = ctx->qry.sha1;
118	unsigned char sha1[20];	118	unsigned char sha1[20];
119	struct commit *commit;	119	struct commit *commit;
120	const char *paths[] = {ctx->qry.path, NULL};	120	const char *paths[] = {ctx->qry.path, NULL};
121		121
122	if (!rev)	122	if (!rev)
123	rev = ctx->qry.head;	123	rev = ctx->qry.head;
124		124
125	if (get_sha1(rev, sha1)) {	125	if (get_sha1(rev, sha1)) {
126	html_status(404, "Not found", 0);	126	html_status(404, "Not found", 0);
127	return;	127	return;
128	}	128	}
129	commit = lookup_commit_reference(sha1);	129	commit = lookup_commit_reference(sha1);
130	if (!commit \|\| parse_commit(commit)) {	130	if (!commit \|\| parse_commit(commit)) {
131	html_status(404, "Not found", 0);	131	html_status(404, "Not found", 0);
132	return;	132	return;
133	}	133	}