|
diff --git a/cgitrc b/cgitrc index 019781e..e7e731c 100644 --- a/ cgitrc+++ b/ cgitrc |
|
@@ -1,93 +1,96 @@ |
1 | ## |
1 | ## |
2 | ## cgitrc: template for /etc/cgitrc |
2 | ## cgitrc: template for /etc/cgitrc |
3 | ## |
3 | ## |
4 | |
4 | |
5 | |
5 | |
6 | ## Uncomment and set to 1 to deactivate caching of generated pages. Mostly |
6 | ## Uncomment and set to 1 to deactivate caching of generated pages. Mostly |
7 | ## usefull for testing. |
7 | ## usefull for testing. |
8 | #nocache=0 |
8 | #nocache=0 |
9 | |
9 | |
10 | |
10 | |
11 | ## Enable/disable snapshots by default. This can be overridden per repo |
11 | ## Enable/disable snapshots by default. This can be overridden per repo |
12 | #snapshots=0 |
12 | #snapshots=0 |
13 | |
13 | |
14 | |
14 | |
15 | ## Specify a root for virtual urls. This makes cgit generate urls like |
15 | ## Specify a root for virtual urls. This makes cgit generate urls like |
16 | ## |
16 | ## |
17 | ## http://localhost/git/repo/log/?id=master |
17 | ## http://localhost/git/repo/log/?id=master |
18 | ## |
18 | ## |
19 | ## instead of |
19 | ## instead of |
20 | ## |
20 | ## |
21 | ## http://localhost/cgit/cgit.cgi?r=repo&p=log&id=master |
21 | ## http://localhost/cgit/cgit.cgi?r=repo&p=log&id=master |
22 | ## |
22 | ## |
23 | ## For this to work with apache, rewrite rules must be added to httpd.conf, |
23 | ## For this to work with apache, rewrite rules must be added to httpd.conf, |
24 | ## possibly looking something like this: |
24 | ## possibly looking something like this: |
25 | ## |
25 | ## |
26 | ## RewriteRule ^/git/$ /cgit/cgit.cgi [L,QSA] |
26 | ## RewriteRule ^/git/$ /cgit/cgit.cgi [L,QSA] |
27 | ## RewriteRule ^/git/([^/]+)/$ /cgit/cgit.cgi?r=$1 [L,QSA] |
27 | ## RewriteRule ^/git/([^/]+)/$ /cgit/cgit.cgi?r=$1 [L,QSA] |
28 | ## RewriteRule ^/git/([^/]+)/([^/]+)/$ /cgit/cgit.cgi?r=$1&p=$2 [L,QSA] |
28 | ## RewriteRule ^/git/([^/]+)/([^/]+)/$ /cgit/cgit.cgi?r=$1&p=$2 [L,QSA] |
29 | ## |
29 | ## |
30 | ## This setting is disabled by default. |
30 | ## This setting is disabled by default. |
31 | #virtual-root=/git |
31 | #virtual-root=/git |
32 | |
32 | |
33 | |
33 | |
34 | ## Set the title printed on the root page |
34 | ## Set the title printed on the root page |
35 | #root-title=Git repository browser |
35 | #root-title=Git repository browser |
36 | |
36 | |
37 | |
37 | |
38 | ## Link to css file |
38 | ## Link to css file |
39 | #css=/cgit/cgit.css |
39 | #css=/cgit/cgit.css |
40 | |
40 | |
41 | |
41 | |
42 | ## Link to logo file |
42 | ## Link to logo file |
43 | #logo=/cgit/git-logo.png |
43 | #logo=/cgit/git-logo.png |
44 | |
44 | |
45 | |
45 | |
46 | ## Url loaded when clicking the logo |
46 | ## Url loaded when clicking the logo |
47 | #logo-link=http://www.kernel.org/pub/software/scm/git/docs/ |
47 | #logo-link=http://www.kernel.org/pub/software/scm/git/docs/ |
48 | |
48 | |
49 | |
49 | |
50 | ## Url loaded when clicking a submodule link |
50 | ## Url loaded when clicking a submodule link |
51 | #module-link=./?repo=%s&page=commit&id=%s |
51 | #module-link=./?repo=%s&page=commit&id=%s |
52 | |
52 | |
53 | |
53 | |
54 | ## Number of chars shown of commit subject message (in log view) |
54 | ## Number of chars shown of commit subject message (in log view) |
55 | #max-message-length=60 |
55 | #max-message-length=60 |
56 | |
56 | |
57 | |
57 | |
58 | ## Number of commits per page in log view |
58 | ## Number of commits per page in log view |
59 | #max-commit-count=50 |
59 | #max-commit-count=50 |
60 | |
60 | |
61 | |
61 | |
62 | ## Root of cached output |
62 | ## Root of cached output |
63 | #cache-root=/var/cache/cgit |
63 | #cache-root=/var/cache/cgit |
64 | |
64 | |
65 | |
65 | |
| |
66 | ## Include another config-file |
| |
67 | #include=/var/cgit/repolist |
| |
68 | |
66 | ## |
69 | ## |
67 | ## Time-To-Live settings: specifies how long (in minutes) different pages |
70 | ## Time-To-Live settings: specifies how long (in minutes) different pages |
68 | ## should be cached (0 for instant expiration, -1 for immortal pages) |
71 | ## should be cached (0 for instant expiration, -1 for immortal pages) |
69 | ## |
72 | ## |
70 | |
73 | |
71 | ## ttl for root page |
74 | ## ttl for root page |
72 | #cache-root-ttl=5 |
75 | #cache-root-ttl=5 |
73 | |
76 | |
74 | ## ttl for repo summary page |
77 | ## ttl for repo summary page |
75 | #cache-repo-ttl=5 |
78 | #cache-repo-ttl=5 |
76 | |
79 | |
77 | ## ttl for other dynamic pages |
80 | ## ttl for other dynamic pages |
78 | #cache-dynamic-ttl=5 |
81 | #cache-dynamic-ttl=5 |
79 | |
82 | |
80 | ## ttl for static pages (addressed by SHA-1) |
83 | ## ttl for static pages (addressed by SHA-1) |
81 | #cache-static-ttl=-1 |
84 | #cache-static-ttl=-1 |
82 | |
85 | |
83 | |
86 | |
84 | |
87 | |
85 | ## Example repository entry. Required values are repo.url and repo.path (each |
88 | ## Example repository entry. Required values are repo.url and repo.path (each |
86 | ## repository section must start with repo.url). |
89 | ## repository section must start with repo.url). |
87 | #repo.url=cgit |
90 | #repo.url=cgit |
88 | #repo.name=cgit |
91 | #repo.name=cgit |
89 | #repo.desc=the caching cgi for git |
92 | #repo.desc=the caching cgi for git |
90 | #repo.path=/pub/git/cgit |
93 | #repo.path=/pub/git/cgit |
91 | #repo.owner=Lars Hjemli |
94 | #repo.owner=Lars Hjemli |
92 | #repo.snapshots=1 # override a sitewide snapshot-setting |
95 | #repo.snapshots=1 # override a sitewide snapshot-setting |
93 | #repo.module-link=/git/%s/commit/?id=%s # override the standard module-link |
96 | #repo.module-link=/git/%s/commit/?id=%s # override the standard module-link |
|
|
diff --git a/parsing.c b/parsing.c index 332d61c..8e15e5a 100644 --- a/ parsing.c+++ b/ parsing.c |
|
@@ -1,245 +1,247 @@ |
1 | /* config.c: parsing of config files |
1 | /* config.c: parsing of config files |
2 | * |
2 | * |
3 | * Copyright (C) 2006 Lars Hjemli |
3 | * Copyright (C) 2006 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 | |
10 | |
11 | int next_char(FILE *f) |
11 | int next_char(FILE *f) |
12 | { |
12 | { |
13 | int c = fgetc(f); |
13 | int c = fgetc(f); |
14 | if (c=='\r') { |
14 | if (c=='\r') { |
15 | c = fgetc(f); |
15 | c = fgetc(f); |
16 | if (c!='\n') { |
16 | if (c!='\n') { |
17 | ungetc(c, f); |
17 | ungetc(c, f); |
18 | c = '\r'; |
18 | c = '\r'; |
19 | } |
19 | } |
20 | } |
20 | } |
21 | return c; |
21 | return c; |
22 | } |
22 | } |
23 | |
23 | |
24 | void skip_line(FILE *f) |
24 | void skip_line(FILE *f) |
25 | { |
25 | { |
26 | int c; |
26 | int c; |
27 | |
27 | |
28 | while((c=next_char(f)) && c!='\n' && c!=EOF) |
28 | while((c=next_char(f)) && c!='\n' && c!=EOF) |
29 | ; |
29 | ; |
30 | } |
30 | } |
31 | |
31 | |
32 | int read_config_line(FILE *f, char *line, const char **value, int bufsize) |
32 | int read_config_line(FILE *f, char *line, const char **value, int bufsize) |
33 | { |
33 | { |
34 | int i = 0, isname = 0; |
34 | int i = 0, isname = 0; |
35 | |
35 | |
36 | *value = NULL; |
36 | *value = NULL; |
37 | while(i<bufsize-1) { |
37 | while(i<bufsize-1) { |
38 | int c = next_char(f); |
38 | int c = next_char(f); |
39 | if (!isname && (c=='#' || c==';')) { |
39 | if (!isname && (c=='#' || c==';')) { |
40 | skip_line(f); |
40 | skip_line(f); |
41 | continue; |
41 | continue; |
42 | } |
42 | } |
43 | if (!isname && isspace(c)) |
43 | if (!isname && isspace(c)) |
44 | continue; |
44 | continue; |
45 | |
45 | |
46 | if (c=='=' && !*value) { |
46 | if (c=='=' && !*value) { |
47 | line[i] = 0; |
47 | line[i] = 0; |
48 | *value = &line[i+1]; |
48 | *value = &line[i+1]; |
49 | } else if (c=='\n' && !isname) { |
49 | } else if (c=='\n' && !isname) { |
50 | i = 0; |
50 | i = 0; |
51 | continue; |
51 | continue; |
52 | } else if (c=='\n' || c==EOF) { |
52 | } else if (c=='\n' || c==EOF) { |
53 | line[i] = 0; |
53 | line[i] = 0; |
54 | break; |
54 | break; |
55 | } else { |
55 | } else { |
56 | line[i]=c; |
56 | line[i]=c; |
57 | } |
57 | } |
58 | isname = 1; |
58 | isname = 1; |
59 | i++; |
59 | i++; |
60 | } |
60 | } |
61 | line[i+1] = 0; |
61 | line[i+1] = 0; |
62 | return i; |
62 | return i; |
63 | } |
63 | } |
64 | |
64 | |
65 | int cgit_read_config(const char *filename, configfn fn) |
65 | int cgit_read_config(const char *filename, configfn fn) |
66 | { |
66 | { |
67 | int ret = 0, len; |
67 | static int nesting; |
| |
68 | int len; |
68 | char line[256]; |
69 | char line[256]; |
69 | const char *value; |
70 | const char *value; |
70 | FILE *f = fopen(filename, "r"); |
71 | FILE *f; |
71 | |
72 | |
72 | if (!f) |
73 | /* cancel the reading of yet another configfile after 16 invocations */ |
| |
74 | if (nesting++ > 16) |
| |
75 | return -1; |
| |
76 | if (!(f = fopen(filename, "r"))) |
73 | return -1; |
77 | return -1; |
74 | |
| |
75 | while((len = read_config_line(f, line, &value, sizeof(line))) > 0) |
78 | while((len = read_config_line(f, line, &value, sizeof(line))) > 0) |
76 | (*fn)(line, value); |
79 | (*fn)(line, value); |
77 | |
| |
78 | fclose(f); |
80 | fclose(f); |
79 | return ret; |
81 | return 0; |
80 | } |
82 | } |
81 | |
83 | |
82 | char *convert_query_hexchar(char *txt) |
84 | char *convert_query_hexchar(char *txt) |
83 | { |
85 | { |
84 | int d1, d2; |
86 | int d1, d2; |
85 | if (strlen(txt) < 3) { |
87 | if (strlen(txt) < 3) { |
86 | *txt = '\0'; |
88 | *txt = '\0'; |
87 | return txt-1; |
89 | return txt-1; |
88 | } |
90 | } |
89 | d1 = hextoint(*(txt+1)); |
91 | d1 = hextoint(*(txt+1)); |
90 | d2 = hextoint(*(txt+2)); |
92 | d2 = hextoint(*(txt+2)); |
91 | if (d1<0 || d2<0) { |
93 | if (d1<0 || d2<0) { |
92 | strcpy(txt, txt+3); |
94 | strcpy(txt, txt+3); |
93 | return txt-1; |
95 | return txt-1; |
94 | } else { |
96 | } else { |
95 | *txt = d1 * 16 + d2; |
97 | *txt = d1 * 16 + d2; |
96 | strcpy(txt+1, txt+3); |
98 | strcpy(txt+1, txt+3); |
97 | return txt; |
99 | return txt; |
98 | } |
100 | } |
99 | } |
101 | } |
100 | |
102 | |
101 | int cgit_parse_query(char *txt, configfn fn) |
103 | int cgit_parse_query(char *txt, configfn fn) |
102 | { |
104 | { |
103 | char *t, *value = NULL, c; |
105 | char *t, *value = NULL, c; |
104 | |
106 | |
105 | if (!txt) |
107 | if (!txt) |
106 | return 0; |
108 | return 0; |
107 | |
109 | |
108 | t = txt = xstrdup(txt); |
110 | t = txt = xstrdup(txt); |
109 | |
111 | |
110 | while((c=*t) != '\0') { |
112 | while((c=*t) != '\0') { |
111 | if (c=='=') { |
113 | if (c=='=') { |
112 | *t = '\0'; |
114 | *t = '\0'; |
113 | value = t+1; |
115 | value = t+1; |
114 | } else if (c=='+') { |
116 | } else if (c=='+') { |
115 | *t = ' '; |
117 | *t = ' '; |
116 | } else if (c=='%') { |
118 | } else if (c=='%') { |
117 | t = convert_query_hexchar(t); |
119 | t = convert_query_hexchar(t); |
118 | } else if (c=='&') { |
120 | } else if (c=='&') { |
119 | *t = '\0'; |
121 | *t = '\0'; |
120 | (*fn)(txt, value); |
122 | (*fn)(txt, value); |
121 | txt = t+1; |
123 | txt = t+1; |
122 | value = NULL; |
124 | value = NULL; |
123 | } |
125 | } |
124 | t++; |
126 | t++; |
125 | } |
127 | } |
126 | if (t!=txt) |
128 | if (t!=txt) |
127 | (*fn)(txt, value); |
129 | (*fn)(txt, value); |
128 | return 0; |
130 | return 0; |
129 | } |
131 | } |
130 | |
132 | |
131 | char *substr(const char *head, const char *tail) |
133 | char *substr(const char *head, const char *tail) |
132 | { |
134 | { |
133 | char *buf; |
135 | char *buf; |
134 | |
136 | |
135 | buf = xmalloc(tail - head + 1); |
137 | buf = xmalloc(tail - head + 1); |
136 | strncpy(buf, head, tail - head); |
138 | strncpy(buf, head, tail - head); |
137 | buf[tail - head] = '\0'; |
139 | buf[tail - head] = '\0'; |
138 | return buf; |
140 | return buf; |
139 | } |
141 | } |
140 | |
142 | |
141 | struct commitinfo *cgit_parse_commit(struct commit *commit) |
143 | struct commitinfo *cgit_parse_commit(struct commit *commit) |
142 | { |
144 | { |
143 | struct commitinfo *ret; |
145 | struct commitinfo *ret; |
144 | char *p = commit->buffer, *t = commit->buffer; |
146 | char *p = commit->buffer, *t = commit->buffer; |
145 | |
147 | |
146 | ret = xmalloc(sizeof(*ret)); |
148 | ret = xmalloc(sizeof(*ret)); |
147 | ret->commit = commit; |
149 | ret->commit = commit; |
148 | ret->author = NULL; |
150 | ret->author = NULL; |
149 | ret->author_email = NULL; |
151 | ret->author_email = NULL; |
150 | ret->committer = NULL; |
152 | ret->committer = NULL; |
151 | ret->committer_email = NULL; |
153 | ret->committer_email = NULL; |
152 | ret->subject = NULL; |
154 | ret->subject = NULL; |
153 | ret->msg = NULL; |
155 | ret->msg = NULL; |
154 | |
156 | |
155 | if (strncmp(p, "tree ", 5)) |
157 | if (strncmp(p, "tree ", 5)) |
156 | die("Bad commit: %s", sha1_to_hex(commit->object.sha1)); |
158 | die("Bad commit: %s", sha1_to_hex(commit->object.sha1)); |
157 | else |
159 | else |
158 | p += 46; // "tree " + hex[40] + "\n" |
160 | p += 46; // "tree " + hex[40] + "\n" |
159 | |
161 | |
160 | while (!strncmp(p, "parent ", 7)) |
162 | while (!strncmp(p, "parent ", 7)) |
161 | p += 48; // "parent " + hex[40] + "\n" |
163 | p += 48; // "parent " + hex[40] + "\n" |
162 | |
164 | |
163 | if (!strncmp(p, "author ", 7)) { |
165 | if (!strncmp(p, "author ", 7)) { |
164 | p += 7; |
166 | p += 7; |
165 | t = strchr(p, '<') - 1; |
167 | t = strchr(p, '<') - 1; |
166 | ret->author = substr(p, t); |
168 | ret->author = substr(p, t); |
167 | p = t; |
169 | p = t; |
168 | t = strchr(t, '>') + 1; |
170 | t = strchr(t, '>') + 1; |
169 | ret->author_email = substr(p, t); |
171 | ret->author_email = substr(p, t); |
170 | ret->author_date = atol(++t); |
172 | ret->author_date = atol(++t); |
171 | p = strchr(t, '\n') + 1; |
173 | p = strchr(t, '\n') + 1; |
172 | } |
174 | } |
173 | |
175 | |
174 | if (!strncmp(p, "committer ", 9)) { |
176 | if (!strncmp(p, "committer ", 9)) { |
175 | p += 9; |
177 | p += 9; |
176 | t = strchr(p, '<') - 1; |
178 | t = strchr(p, '<') - 1; |
177 | ret->committer = substr(p, t); |
179 | ret->committer = substr(p, t); |
178 | p = t; |
180 | p = t; |
179 | t = strchr(t, '>') + 1; |
181 | t = strchr(t, '>') + 1; |
180 | ret->committer_email = substr(p, t); |
182 | ret->committer_email = substr(p, t); |
181 | ret->committer_date = atol(++t); |
183 | ret->committer_date = atol(++t); |
182 | p = strchr(t, '\n') + 1; |
184 | p = strchr(t, '\n') + 1; |
183 | } |
185 | } |
184 | |
186 | |
185 | while (*p == '\n') |
187 | while (*p == '\n') |
186 | p = strchr(p, '\n') + 1; |
188 | p = strchr(p, '\n') + 1; |
187 | |
189 | |
188 | t = strchr(p, '\n'); |
190 | t = strchr(p, '\n'); |
189 | if (t && *t) { |
191 | if (t && *t) { |
190 | ret->subject = substr(p, t); |
192 | ret->subject = substr(p, t); |
191 | p = t + 1; |
193 | p = t + 1; |
192 | |
194 | |
193 | while (*p == '\n') |
195 | while (*p == '\n') |
194 | p = strchr(p, '\n') + 1; |
196 | p = strchr(p, '\n') + 1; |
195 | ret->msg = p; |
197 | ret->msg = p; |
196 | } |
198 | } |
197 | return ret; |
199 | return ret; |
198 | } |
200 | } |
199 | |
201 | |
200 | |
202 | |
201 | struct taginfo *cgit_parse_tag(struct tag *tag) |
203 | struct taginfo *cgit_parse_tag(struct tag *tag) |
202 | { |
204 | { |
203 | void *data; |
205 | void *data; |
204 | enum object_type type; |
206 | enum object_type type; |
205 | unsigned long size; |
207 | unsigned long size; |
206 | char *p, *t; |
208 | char *p, *t; |
207 | struct taginfo *ret; |
209 | struct taginfo *ret; |
208 | |
210 | |
209 | data = read_sha1_file(tag->object.sha1, &type, &size); |
211 | data = read_sha1_file(tag->object.sha1, &type, &size); |
210 | if (!data || type != OBJ_TAG) { |
212 | if (!data || type != OBJ_TAG) { |
211 | free(data); |
213 | free(data); |
212 | return 0; |
214 | return 0; |
213 | } |
215 | } |
214 | |
216 | |
215 | ret = xmalloc(sizeof(*ret)); |
217 | ret = xmalloc(sizeof(*ret)); |
216 | ret->tagger = NULL; |
218 | ret->tagger = NULL; |
217 | ret->tagger_email = NULL; |
219 | ret->tagger_email = NULL; |
218 | ret->tagger_date = 0; |
220 | ret->tagger_date = 0; |
219 | ret->msg = NULL; |
221 | ret->msg = NULL; |
220 | |
222 | |
221 | p = data; |
223 | p = data; |
222 | |
224 | |
223 | while (p && *p) { |
225 | while (p && *p) { |
224 | if (*p == '\n') |
226 | if (*p == '\n') |
225 | break; |
227 | break; |
226 | |
228 | |
227 | if (!strncmp(p, "tagger ", 7)) { |
229 | if (!strncmp(p, "tagger ", 7)) { |
228 | p += 7; |
230 | p += 7; |
229 | t = strchr(p, '<') - 1; |
231 | t = strchr(p, '<') - 1; |
230 | ret->tagger = substr(p, t); |
232 | ret->tagger = substr(p, t); |
231 | p = t; |
233 | p = t; |
232 | t = strchr(t, '>') + 1; |
234 | t = strchr(t, '>') + 1; |
233 | ret->tagger_email = substr(p, t); |
235 | ret->tagger_email = substr(p, t); |
234 | ret->tagger_date = atol(++t); |
236 | ret->tagger_date = atol(++t); |
235 | } |
237 | } |
236 | p = strchr(p, '\n') + 1; |
238 | p = strchr(p, '\n') + 1; |
237 | } |
239 | } |
238 | |
240 | |
239 | while (p && (*p == '\n')) |
241 | while (p && (*p == '\n')) |
240 | p = strchr(p, '\n') + 1; |
242 | p = strchr(p, '\n') + 1; |
241 | if (p && *p) |
243 | if (p && *p) |
242 | ret->msg = xstrdup(p); |
244 | ret->msg = xstrdup(p); |
243 | free(data); |
245 | free(data); |
244 | return ret; |
246 | return ret; |
245 | } |
247 | } |
|
|
diff --git a/shared.c b/shared.c index ffecac8..072bb6d 100644 --- a/ shared.c+++ b/ shared.c |
|
@@ -1,322 +1,324 @@ |
1 | /* shared.c: global vars + some callback functions |
1 | /* shared.c: global vars + some callback functions |
2 | * |
2 | * |
3 | * Copyright (C) 2006 Lars Hjemli |
3 | * Copyright (C) 2006 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 | |
10 | |
11 | struct repolist cgit_repolist; |
11 | struct repolist cgit_repolist; |
12 | struct repoinfo *cgit_repo; |
12 | struct repoinfo *cgit_repo; |
13 | |
13 | |
14 | char *cgit_root_title = "Git repository browser"; |
14 | char *cgit_root_title = "Git repository browser"; |
15 | char *cgit_css = "/cgit.css"; |
15 | char *cgit_css = "/cgit.css"; |
16 | char *cgit_logo = "/git-logo.png"; |
16 | char *cgit_logo = "/git-logo.png"; |
17 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; |
17 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; |
18 | char *cgit_module_link = "./?repo=%s&page=commit&id=%s"; |
18 | char *cgit_module_link = "./?repo=%s&page=commit&id=%s"; |
19 | char *cgit_virtual_root = NULL; |
19 | char *cgit_virtual_root = NULL; |
20 | |
20 | |
21 | char *cgit_cache_root = "/var/cache/cgit"; |
21 | char *cgit_cache_root = "/var/cache/cgit"; |
22 | |
22 | |
23 | int cgit_nocache = 0; |
23 | int cgit_nocache = 0; |
24 | int cgit_snapshots = 0; |
24 | int cgit_snapshots = 0; |
25 | int cgit_max_lock_attempts = 5; |
25 | int cgit_max_lock_attempts = 5; |
26 | int cgit_cache_root_ttl = 5; |
26 | int cgit_cache_root_ttl = 5; |
27 | int cgit_cache_repo_ttl = 5; |
27 | int cgit_cache_repo_ttl = 5; |
28 | int cgit_cache_dynamic_ttl = 5; |
28 | int cgit_cache_dynamic_ttl = 5; |
29 | int cgit_cache_static_ttl = -1; |
29 | int cgit_cache_static_ttl = -1; |
30 | int cgit_cache_max_create_time = 5; |
30 | int cgit_cache_max_create_time = 5; |
31 | |
31 | |
32 | int cgit_max_msg_len = 60; |
32 | int cgit_max_msg_len = 60; |
33 | int cgit_max_commit_count = 50; |
33 | int cgit_max_commit_count = 50; |
34 | |
34 | |
35 | char *cgit_repo_name = NULL; |
35 | char *cgit_repo_name = NULL; |
36 | char *cgit_repo_desc = NULL; |
36 | char *cgit_repo_desc = NULL; |
37 | char *cgit_repo_owner = NULL; |
37 | char *cgit_repo_owner = NULL; |
38 | |
38 | |
39 | int cgit_query_has_symref = 0; |
39 | int cgit_query_has_symref = 0; |
40 | int cgit_query_has_sha1 = 0; |
40 | int cgit_query_has_sha1 = 0; |
41 | |
41 | |
42 | char *cgit_querystring = NULL; |
42 | char *cgit_querystring = NULL; |
43 | char *cgit_query_repo = NULL; |
43 | char *cgit_query_repo = NULL; |
44 | char *cgit_query_page = NULL; |
44 | char *cgit_query_page = NULL; |
45 | char *cgit_query_head = NULL; |
45 | char *cgit_query_head = NULL; |
46 | char *cgit_query_search = NULL; |
46 | char *cgit_query_search = NULL; |
47 | char *cgit_query_sha1 = NULL; |
47 | char *cgit_query_sha1 = NULL; |
48 | char *cgit_query_sha2 = NULL; |
48 | char *cgit_query_sha2 = NULL; |
49 | char *cgit_query_path = NULL; |
49 | char *cgit_query_path = NULL; |
50 | char *cgit_query_name = NULL; |
50 | char *cgit_query_name = NULL; |
51 | int cgit_query_ofs = 0; |
51 | int cgit_query_ofs = 0; |
52 | |
52 | |
53 | int htmlfd = 0; |
53 | int htmlfd = 0; |
54 | |
54 | |
55 | int chk_zero(int result, char *msg) |
55 | int chk_zero(int result, char *msg) |
56 | { |
56 | { |
57 | if (result != 0) |
57 | if (result != 0) |
58 | die("%s: %s", msg, strerror(errno)); |
58 | die("%s: %s", msg, strerror(errno)); |
59 | return result; |
59 | return result; |
60 | } |
60 | } |
61 | |
61 | |
62 | int chk_positive(int result, char *msg) |
62 | int chk_positive(int result, char *msg) |
63 | { |
63 | { |
64 | if (result <= 0) |
64 | if (result <= 0) |
65 | die("%s: %s", msg, strerror(errno)); |
65 | die("%s: %s", msg, strerror(errno)); |
66 | return result; |
66 | return result; |
67 | } |
67 | } |
68 | |
68 | |
69 | struct repoinfo *add_repo(const char *url) |
69 | struct repoinfo *add_repo(const char *url) |
70 | { |
70 | { |
71 | struct repoinfo *ret; |
71 | struct repoinfo *ret; |
72 | |
72 | |
73 | if (++cgit_repolist.count > cgit_repolist.length) { |
73 | if (++cgit_repolist.count > cgit_repolist.length) { |
74 | if (cgit_repolist.length == 0) |
74 | if (cgit_repolist.length == 0) |
75 | cgit_repolist.length = 8; |
75 | cgit_repolist.length = 8; |
76 | else |
76 | else |
77 | cgit_repolist.length *= 2; |
77 | cgit_repolist.length *= 2; |
78 | cgit_repolist.repos = xrealloc(cgit_repolist.repos, |
78 | cgit_repolist.repos = xrealloc(cgit_repolist.repos, |
79 | cgit_repolist.length * |
79 | cgit_repolist.length * |
80 | sizeof(struct repoinfo)); |
80 | sizeof(struct repoinfo)); |
81 | } |
81 | } |
82 | |
82 | |
83 | ret = &cgit_repolist.repos[cgit_repolist.count-1]; |
83 | ret = &cgit_repolist.repos[cgit_repolist.count-1]; |
84 | ret->url = xstrdup(url); |
84 | ret->url = xstrdup(url); |
85 | ret->name = ret->url; |
85 | ret->name = ret->url; |
86 | ret->path = NULL; |
86 | ret->path = NULL; |
87 | ret->desc = NULL; |
87 | ret->desc = NULL; |
88 | ret->owner = NULL; |
88 | ret->owner = NULL; |
89 | ret->snapshots = cgit_snapshots; |
89 | ret->snapshots = cgit_snapshots; |
90 | ret->module_link = cgit_module_link; |
90 | ret->module_link = cgit_module_link; |
91 | return ret; |
91 | return ret; |
92 | } |
92 | } |
93 | |
93 | |
94 | void cgit_global_config_cb(const char *name, const char *value) |
94 | void cgit_global_config_cb(const char *name, const char *value) |
95 | { |
95 | { |
96 | if (!strcmp(name, "root-title")) |
96 | if (!strcmp(name, "root-title")) |
97 | cgit_root_title = xstrdup(value); |
97 | cgit_root_title = xstrdup(value); |
98 | else if (!strcmp(name, "css")) |
98 | else if (!strcmp(name, "css")) |
99 | cgit_css = xstrdup(value); |
99 | cgit_css = xstrdup(value); |
100 | else if (!strcmp(name, "logo")) |
100 | else if (!strcmp(name, "logo")) |
101 | cgit_logo = xstrdup(value); |
101 | cgit_logo = xstrdup(value); |
102 | else if (!strcmp(name, "logo-link")) |
102 | else if (!strcmp(name, "logo-link")) |
103 | cgit_logo_link = xstrdup(value); |
103 | cgit_logo_link = xstrdup(value); |
104 | else if (!strcmp(name, "module-link")) |
104 | else if (!strcmp(name, "module-link")) |
105 | cgit_module_link = xstrdup(value); |
105 | cgit_module_link = xstrdup(value); |
106 | else if (!strcmp(name, "virtual-root")) |
106 | else if (!strcmp(name, "virtual-root")) |
107 | cgit_virtual_root = xstrdup(value); |
107 | cgit_virtual_root = xstrdup(value); |
108 | else if (!strcmp(name, "nocache")) |
108 | else if (!strcmp(name, "nocache")) |
109 | cgit_nocache = atoi(value); |
109 | cgit_nocache = atoi(value); |
110 | else if (!strcmp(name, "snapshots")) |
110 | else if (!strcmp(name, "snapshots")) |
111 | cgit_snapshots = atoi(value); |
111 | cgit_snapshots = atoi(value); |
112 | else if (!strcmp(name, "cache-root")) |
112 | else if (!strcmp(name, "cache-root")) |
113 | cgit_cache_root = xstrdup(value); |
113 | cgit_cache_root = xstrdup(value); |
114 | else if (!strcmp(name, "cache-root-ttl")) |
114 | else if (!strcmp(name, "cache-root-ttl")) |
115 | cgit_cache_root_ttl = atoi(value); |
115 | cgit_cache_root_ttl = atoi(value); |
116 | else if (!strcmp(name, "cache-repo-ttl")) |
116 | else if (!strcmp(name, "cache-repo-ttl")) |
117 | cgit_cache_repo_ttl = atoi(value); |
117 | cgit_cache_repo_ttl = atoi(value); |
118 | else if (!strcmp(name, "cache-static-ttl")) |
118 | else if (!strcmp(name, "cache-static-ttl")) |
119 | cgit_cache_static_ttl = atoi(value); |
119 | cgit_cache_static_ttl = atoi(value); |
120 | else if (!strcmp(name, "cache-dynamic-ttl")) |
120 | else if (!strcmp(name, "cache-dynamic-ttl")) |
121 | cgit_cache_dynamic_ttl = atoi(value); |
121 | cgit_cache_dynamic_ttl = atoi(value); |
122 | else if (!strcmp(name, "max-message-length")) |
122 | else if (!strcmp(name, "max-message-length")) |
123 | cgit_max_msg_len = atoi(value); |
123 | cgit_max_msg_len = atoi(value); |
124 | else if (!strcmp(name, "max-commit-count")) |
124 | else if (!strcmp(name, "max-commit-count")) |
125 | cgit_max_commit_count = atoi(value); |
125 | cgit_max_commit_count = atoi(value); |
126 | else if (!strcmp(name, "repo.url")) |
126 | else if (!strcmp(name, "repo.url")) |
127 | cgit_repo = add_repo(value); |
127 | cgit_repo = add_repo(value); |
128 | else if (!strcmp(name, "repo.name")) |
128 | else if (!strcmp(name, "repo.name")) |
129 | cgit_repo->name = xstrdup(value); |
129 | cgit_repo->name = xstrdup(value); |
130 | else if (cgit_repo && !strcmp(name, "repo.path")) |
130 | else if (cgit_repo && !strcmp(name, "repo.path")) |
131 | cgit_repo->path = xstrdup(value); |
131 | cgit_repo->path = xstrdup(value); |
132 | else if (cgit_repo && !strcmp(name, "repo.desc")) |
132 | else if (cgit_repo && !strcmp(name, "repo.desc")) |
133 | cgit_repo->desc = xstrdup(value); |
133 | cgit_repo->desc = xstrdup(value); |
134 | else if (cgit_repo && !strcmp(name, "repo.owner")) |
134 | else if (cgit_repo && !strcmp(name, "repo.owner")) |
135 | cgit_repo->owner = xstrdup(value); |
135 | cgit_repo->owner = xstrdup(value); |
136 | else if (cgit_repo && !strcmp(name, "repo.snapshots")) |
136 | else if (cgit_repo && !strcmp(name, "repo.snapshots")) |
137 | cgit_repo->snapshots = atoi(value); |
137 | cgit_repo->snapshots = atoi(value); |
138 | else if (cgit_repo && !strcmp(name, "repo.module-link")) |
138 | else if (cgit_repo && !strcmp(name, "repo.module-link")) |
139 | cgit_repo->module_link= xstrdup(value); |
139 | cgit_repo->module_link= xstrdup(value); |
| |
140 | else if (!strcmp(name, "include")) |
| |
141 | cgit_read_config(value, cgit_global_config_cb); |
140 | } |
142 | } |
141 | |
143 | |
142 | void cgit_repo_config_cb(const char *name, const char *value) |
144 | void cgit_repo_config_cb(const char *name, const char *value) |
143 | { |
145 | { |
144 | if (!strcmp(name, "name")) |
146 | if (!strcmp(name, "name")) |
145 | cgit_repo_name = xstrdup(value); |
147 | cgit_repo_name = xstrdup(value); |
146 | else if (!strcmp(name, "desc")) |
148 | else if (!strcmp(name, "desc")) |
147 | cgit_repo_desc = xstrdup(value); |
149 | cgit_repo_desc = xstrdup(value); |
148 | else if (!strcmp(name, "owner")) |
150 | else if (!strcmp(name, "owner")) |
149 | cgit_repo_owner = xstrdup(value); |
151 | cgit_repo_owner = xstrdup(value); |
150 | } |
152 | } |
151 | |
153 | |
152 | void cgit_querystring_cb(const char *name, const char *value) |
154 | void cgit_querystring_cb(const char *name, const char *value) |
153 | { |
155 | { |
154 | if (!strcmp(name,"r")) { |
156 | if (!strcmp(name,"r")) { |
155 | cgit_query_repo = xstrdup(value); |
157 | cgit_query_repo = xstrdup(value); |
156 | } else if (!strcmp(name, "p")) { |
158 | } else if (!strcmp(name, "p")) { |
157 | cgit_query_page = xstrdup(value); |
159 | cgit_query_page = xstrdup(value); |
158 | } else if (!strcmp(name, "q")) { |
160 | } else if (!strcmp(name, "q")) { |
159 | cgit_query_search = xstrdup(value); |
161 | cgit_query_search = xstrdup(value); |
160 | } else if (!strcmp(name, "h")) { |
162 | } else if (!strcmp(name, "h")) { |
161 | cgit_query_head = xstrdup(value); |
163 | cgit_query_head = xstrdup(value); |
162 | cgit_query_has_symref = 1; |
164 | cgit_query_has_symref = 1; |
163 | } else if (!strcmp(name, "id")) { |
165 | } else if (!strcmp(name, "id")) { |
164 | cgit_query_sha1 = xstrdup(value); |
166 | cgit_query_sha1 = xstrdup(value); |
165 | cgit_query_has_sha1 = 1; |
167 | cgit_query_has_sha1 = 1; |
166 | } else if (!strcmp(name, "id2")) { |
168 | } else if (!strcmp(name, "id2")) { |
167 | cgit_query_sha2 = xstrdup(value); |
169 | cgit_query_sha2 = xstrdup(value); |
168 | cgit_query_has_sha1 = 1; |
170 | cgit_query_has_sha1 = 1; |
169 | } else if (!strcmp(name, "ofs")) { |
171 | } else if (!strcmp(name, "ofs")) { |
170 | cgit_query_ofs = atoi(value); |
172 | cgit_query_ofs = atoi(value); |
171 | } else if (!strcmp(name, "path")) { |
173 | } else if (!strcmp(name, "path")) { |
172 | cgit_query_path = xstrdup(value); |
174 | cgit_query_path = xstrdup(value); |
173 | } else if (!strcmp(name, "name")) { |
175 | } else if (!strcmp(name, "name")) { |
174 | cgit_query_name = xstrdup(value); |
176 | cgit_query_name = xstrdup(value); |
175 | } |
177 | } |
176 | } |
178 | } |
177 | |
179 | |
178 | void *cgit_free_commitinfo(struct commitinfo *info) |
180 | void *cgit_free_commitinfo(struct commitinfo *info) |
179 | { |
181 | { |
180 | free(info->author); |
182 | free(info->author); |
181 | free(info->author_email); |
183 | free(info->author_email); |
182 | free(info->committer); |
184 | free(info->committer); |
183 | free(info->committer_email); |
185 | free(info->committer_email); |
184 | free(info->subject); |
186 | free(info->subject); |
185 | free(info); |
187 | free(info); |
186 | return NULL; |
188 | return NULL; |
187 | } |
189 | } |
188 | |
190 | |
189 | int hextoint(char c) |
191 | int hextoint(char c) |
190 | { |
192 | { |
191 | if (c >= 'a' && c <= 'f') |
193 | if (c >= 'a' && c <= 'f') |
192 | return 10 + c - 'a'; |
194 | return 10 + c - 'a'; |
193 | else if (c >= 'A' && c <= 'F') |
195 | else if (c >= 'A' && c <= 'F') |
194 | return 10 + c - 'A'; |
196 | return 10 + c - 'A'; |
195 | else if (c >= '0' && c <= '9') |
197 | else if (c >= '0' && c <= '9') |
196 | return c - '0'; |
198 | return c - '0'; |
197 | else |
199 | else |
198 | return -1; |
200 | return -1; |
199 | } |
201 | } |
200 | |
202 | |
201 | void cgit_diff_tree_cb(struct diff_queue_struct *q, |
203 | void cgit_diff_tree_cb(struct diff_queue_struct *q, |
202 | struct diff_options *options, void *data) |
204 | struct diff_options *options, void *data) |
203 | { |
205 | { |
204 | int i; |
206 | int i; |
205 | |
207 | |
206 | for (i = 0; i < q->nr; i++) { |
208 | for (i = 0; i < q->nr; i++) { |
207 | if (q->queue[i]->status == 'U') |
209 | if (q->queue[i]->status == 'U') |
208 | continue; |
210 | continue; |
209 | ((filepair_fn)data)(q->queue[i]); |
211 | ((filepair_fn)data)(q->queue[i]); |
210 | } |
212 | } |
211 | } |
213 | } |
212 | |
214 | |
213 | static int load_mmfile(mmfile_t *file, const unsigned char *sha1) |
215 | static int load_mmfile(mmfile_t *file, const unsigned char *sha1) |
214 | { |
216 | { |
215 | enum object_type type; |
217 | enum object_type type; |
216 | |
218 | |
217 | if (is_null_sha1(sha1)) { |
219 | if (is_null_sha1(sha1)) { |
218 | file->ptr = (char *)""; |
220 | file->ptr = (char *)""; |
219 | file->size = 0; |
221 | file->size = 0; |
220 | } else { |
222 | } else { |
221 | file->ptr = read_sha1_file(sha1, &type, &file->size); |
223 | file->ptr = read_sha1_file(sha1, &type, &file->size); |
222 | } |
224 | } |
223 | return 1; |
225 | return 1; |
224 | } |
226 | } |
225 | |
227 | |
226 | /* |
228 | /* |
227 | * Receive diff-buffers from xdiff and concatenate them as |
229 | * Receive diff-buffers from xdiff and concatenate them as |
228 | * needed across multiple callbacks. |
230 | * needed across multiple callbacks. |
229 | * |
231 | * |
230 | * This is basically a copy of xdiff-interface.c/xdiff_outf(), |
232 | * This is basically a copy of xdiff-interface.c/xdiff_outf(), |
231 | * ripped from git and modified to use globals instead of |
233 | * ripped from git and modified to use globals instead of |
232 | * a special callback-struct. |
234 | * a special callback-struct. |
233 | */ |
235 | */ |
234 | char *diffbuf = NULL; |
236 | char *diffbuf = NULL; |
235 | int buflen = 0; |
237 | int buflen = 0; |
236 | |
238 | |
237 | int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) |
239 | int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) |
238 | { |
240 | { |
239 | int i; |
241 | int i; |
240 | |
242 | |
241 | for (i = 0; i < nbuf; i++) { |
243 | for (i = 0; i < nbuf; i++) { |
242 | if (mb[i].ptr[mb[i].size-1] != '\n') { |
244 | if (mb[i].ptr[mb[i].size-1] != '\n') { |
243 | /* Incomplete line */ |
245 | /* Incomplete line */ |
244 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); |
246 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); |
245 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); |
247 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); |
246 | buflen += mb[i].size; |
248 | buflen += mb[i].size; |
247 | continue; |
249 | continue; |
248 | } |
250 | } |
249 | |
251 | |
250 | /* we have a complete line */ |
252 | /* we have a complete line */ |
251 | if (!diffbuf) { |
253 | if (!diffbuf) { |
252 | ((linediff_fn)priv)(mb[i].ptr, mb[i].size); |
254 | ((linediff_fn)priv)(mb[i].ptr, mb[i].size); |
253 | continue; |
255 | continue; |
254 | } |
256 | } |
255 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); |
257 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); |
256 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); |
258 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); |
257 | ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); |
259 | ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); |
258 | free(diffbuf); |
260 | free(diffbuf); |
259 | diffbuf = NULL; |
261 | diffbuf = NULL; |
260 | buflen = 0; |
262 | buflen = 0; |
261 | } |
263 | } |
262 | if (diffbuf) { |
264 | if (diffbuf) { |
263 | ((linediff_fn)priv)(diffbuf, buflen); |
265 | ((linediff_fn)priv)(diffbuf, buflen); |
264 | free(diffbuf); |
266 | free(diffbuf); |
265 | diffbuf = NULL; |
267 | diffbuf = NULL; |
266 | buflen = 0; |
268 | buflen = 0; |
267 | } |
269 | } |
268 | return 0; |
270 | return 0; |
269 | } |
271 | } |
270 | |
272 | |
271 | int cgit_diff_files(const unsigned char *old_sha1, |
273 | int cgit_diff_files(const unsigned char *old_sha1, |
272 | const unsigned char *new_sha1, |
274 | const unsigned char *new_sha1, |
273 | linediff_fn fn) |
275 | linediff_fn fn) |
274 | { |
276 | { |
275 | mmfile_t file1, file2; |
277 | mmfile_t file1, file2; |
276 | xpparam_t diff_params; |
278 | xpparam_t diff_params; |
277 | xdemitconf_t emit_params; |
279 | xdemitconf_t emit_params; |
278 | xdemitcb_t emit_cb; |
280 | xdemitcb_t emit_cb; |
279 | |
281 | |
280 | if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) |
282 | if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) |
281 | return 1; |
283 | return 1; |
282 | |
284 | |
283 | diff_params.flags = XDF_NEED_MINIMAL; |
285 | diff_params.flags = XDF_NEED_MINIMAL; |
284 | emit_params.ctxlen = 3; |
286 | emit_params.ctxlen = 3; |
285 | emit_params.flags = XDL_EMIT_FUNCNAMES; |
287 | emit_params.flags = XDL_EMIT_FUNCNAMES; |
286 | emit_cb.outf = filediff_cb; |
288 | emit_cb.outf = filediff_cb; |
287 | emit_cb.priv = fn; |
289 | emit_cb.priv = fn; |
288 | xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); |
290 | xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); |
289 | return 0; |
291 | return 0; |
290 | } |
292 | } |
291 | |
293 | |
292 | void cgit_diff_tree(const unsigned char *old_sha1, |
294 | void cgit_diff_tree(const unsigned char *old_sha1, |
293 | const unsigned char *new_sha1, |
295 | const unsigned char *new_sha1, |
294 | filepair_fn fn) |
296 | filepair_fn fn) |
295 | { |
297 | { |
296 | struct diff_options opt; |
298 | struct diff_options opt; |
297 | int ret; |
299 | int ret; |
298 | |
300 | |
299 | diff_setup(&opt); |
301 | diff_setup(&opt); |
300 | opt.output_format = DIFF_FORMAT_CALLBACK; |
302 | opt.output_format = DIFF_FORMAT_CALLBACK; |
301 | opt.detect_rename = 1; |
303 | opt.detect_rename = 1; |
302 | opt.recursive = 1; |
304 | opt.recursive = 1; |
303 | opt.format_callback = cgit_diff_tree_cb; |
305 | opt.format_callback = cgit_diff_tree_cb; |
304 | opt.format_callback_data = fn; |
306 | opt.format_callback_data = fn; |
305 | diff_setup_done(&opt); |
307 | diff_setup_done(&opt); |
306 | |
308 | |
307 | if (old_sha1) |
309 | if (old_sha1) |
308 | ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); |
310 | ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); |
309 | else |
311 | else |
310 | ret = diff_root_tree_sha1(new_sha1, "", &opt); |
312 | ret = diff_root_tree_sha1(new_sha1, "", &opt); |
311 | diffcore_std(&opt); |
313 | diffcore_std(&opt); |
312 | diff_flush(&opt); |
314 | diff_flush(&opt); |
313 | } |
315 | } |
314 | |
316 | |
315 | void cgit_diff_commit(struct commit *commit, filepair_fn fn) |
317 | void cgit_diff_commit(struct commit *commit, filepair_fn fn) |
316 | { |
318 | { |
317 | unsigned char *old_sha1 = NULL; |
319 | unsigned char *old_sha1 = NULL; |
318 | |
320 | |
319 | if (commit->parents) |
321 | if (commit->parents) |
320 | old_sha1 = commit->parents->item->object.sha1; |
322 | old_sha1 = commit->parents->item->object.sha1; |
321 | cgit_diff_tree(old_sha1, commit->object.sha1, fn); |
323 | cgit_diff_tree(old_sha1, commit->object.sha1, fn); |
322 | } |
324 | } |
|