|
diff --git a/cgit.c b/cgit.c index a83f0be..79e0e43 100644 --- a/ cgit.c+++ b/ cgit.c |
|
@@ -36,228 +36,198 @@ static int cgit_prepare_cache(struct cacheitem *item) |
36 | } else { |
36 | } else { |
37 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", ctx.cfg.cache_root, |
37 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", ctx.cfg.cache_root, |
38 | cache_safe_filename(ctx.repo->url), |
38 | cache_safe_filename(ctx.repo->url), |
39 | ctx.qry.page, |
39 | ctx.qry.page, |
40 | cache_safe_filename(ctx.qry.raw))); |
40 | cache_safe_filename(ctx.qry.raw))); |
41 | if (ctx.qry.has_symref) |
41 | if (ctx.qry.has_symref) |
42 | item->ttl = ctx.cfg.cache_dynamic_ttl; |
42 | item->ttl = ctx.cfg.cache_dynamic_ttl; |
43 | else if (ctx.qry.has_sha1) |
43 | else if (ctx.qry.has_sha1) |
44 | item->ttl = ctx.cfg.cache_static_ttl; |
44 | item->ttl = ctx.cfg.cache_static_ttl; |
45 | else |
45 | else |
46 | item->ttl = ctx.cfg.cache_repo_ttl; |
46 | item->ttl = ctx.cfg.cache_repo_ttl; |
47 | } |
47 | } |
48 | return 1; |
48 | return 1; |
49 | } |
49 | } |
50 | |
50 | |
51 | struct refmatch { |
51 | struct refmatch { |
52 | char *req_ref; |
52 | char *req_ref; |
53 | char *first_ref; |
53 | char *first_ref; |
54 | int match; |
54 | int match; |
55 | }; |
55 | }; |
56 | |
56 | |
57 | int find_current_ref(const char *refname, const unsigned char *sha1, |
57 | int find_current_ref(const char *refname, const unsigned char *sha1, |
58 | int flags, void *cb_data) |
58 | int flags, void *cb_data) |
59 | { |
59 | { |
60 | struct refmatch *info; |
60 | struct refmatch *info; |
61 | |
61 | |
62 | info = (struct refmatch *)cb_data; |
62 | info = (struct refmatch *)cb_data; |
63 | if (!strcmp(refname, info->req_ref)) |
63 | if (!strcmp(refname, info->req_ref)) |
64 | info->match = 1; |
64 | info->match = 1; |
65 | if (!info->first_ref) |
65 | if (!info->first_ref) |
66 | info->first_ref = xstrdup(refname); |
66 | info->first_ref = xstrdup(refname); |
67 | return info->match; |
67 | return info->match; |
68 | } |
68 | } |
69 | |
69 | |
70 | char *find_default_branch(struct cgit_repo *repo) |
70 | char *find_default_branch(struct cgit_repo *repo) |
71 | { |
71 | { |
72 | struct refmatch info; |
72 | struct refmatch info; |
73 | |
73 | |
74 | info.req_ref = repo->defbranch; |
74 | info.req_ref = repo->defbranch; |
75 | info.first_ref = NULL; |
75 | info.first_ref = NULL; |
76 | info.match = 0; |
76 | info.match = 0; |
77 | for_each_branch_ref(find_current_ref, &info); |
77 | for_each_branch_ref(find_current_ref, &info); |
78 | if (info.match) |
78 | if (info.match) |
79 | return info.req_ref; |
79 | return info.req_ref; |
80 | else |
80 | else |
81 | return info.first_ref; |
81 | return info.first_ref; |
82 | } |
82 | } |
83 | |
83 | |
84 | static void cgit_print_repo_page() |
84 | static int prepare_repo_cmd(struct cgit_context *ctx) |
85 | { |
85 | { |
86 | char *tmp; |
86 | char *tmp; |
87 | int show_search; |
| |
88 | unsigned char sha1[20]; |
87 | unsigned char sha1[20]; |
89 | int nongit = 0; |
88 | int nongit = 0; |
90 | |
89 | |
91 | setenv("GIT_DIR", ctx.repo->path, 1); |
90 | setenv("GIT_DIR", ctx->repo->path, 1); |
92 | setup_git_directory_gently(&nongit); |
91 | setup_git_directory_gently(&nongit); |
93 | if (nongit) { |
92 | if (nongit) { |
94 | ctx.page.title = fmt("%s - %s", ctx.cfg.root_title, |
93 | ctx->page.title = fmt("%s - %s", ctx->cfg.root_title, |
95 | "config error"); |
94 | "config error"); |
96 | tmp = fmt("Not a git repository: '%s'", ctx.repo->path); |
95 | tmp = fmt("Not a git repository: '%s'", ctx->repo->path); |
97 | ctx.repo = NULL; |
96 | ctx->repo = NULL; |
98 | cgit_print_http_headers(&ctx); |
97 | cgit_print_http_headers(ctx); |
99 | cgit_print_docstart(&ctx); |
98 | cgit_print_docstart(ctx); |
100 | cgit_print_pageheader(&ctx); |
99 | cgit_print_pageheader(ctx); |
101 | cgit_print_error(tmp); |
100 | cgit_print_error(tmp); |
102 | cgit_print_docend(); |
101 | cgit_print_docend(); |
103 | return; |
102 | return 1; |
104 | } |
103 | } |
| |
104 | ctx->page.title = fmt("%s - %s", ctx->repo->name, ctx->repo->desc); |
105 | |
105 | |
106 | ctx.page.title = fmt("%s - %s", ctx.repo->name, ctx.repo->desc); |
106 | if (!ctx->qry.head) { |
107 | show_search = 0; |
107 | ctx->qry.head = xstrdup(find_default_branch(ctx->repo)); |
108 | |
108 | ctx->repo->defbranch = ctx->qry.head; |
109 | if (!ctx.qry.head) { |
| |
110 | ctx.qry.head = xstrdup(find_default_branch(ctx.repo)); |
| |
111 | ctx.repo->defbranch = ctx.qry.head; |
| |
112 | } |
109 | } |
113 | |
110 | |
114 | if (!ctx.qry.head) { |
111 | if (!ctx->qry.head) { |
115 | cgit_print_http_headers(&ctx); |
112 | cgit_print_http_headers(ctx); |
116 | cgit_print_docstart(&ctx); |
113 | cgit_print_docstart(ctx); |
117 | cgit_print_pageheader(&ctx); |
114 | cgit_print_pageheader(ctx); |
118 | cgit_print_error("Repository seems to be empty"); |
115 | cgit_print_error("Repository seems to be empty"); |
119 | cgit_print_docend(); |
116 | cgit_print_docend(); |
120 | return; |
117 | return 1; |
121 | } |
118 | } |
122 | |
119 | |
123 | if (get_sha1(ctx.qry.head, sha1)) { |
120 | if (get_sha1(ctx->qry.head, sha1)) { |
124 | tmp = xstrdup(ctx.qry.head); |
121 | tmp = xstrdup(ctx->qry.head); |
125 | ctx.qry.head = ctx.repo->defbranch; |
122 | ctx->qry.head = ctx->repo->defbranch; |
126 | cgit_print_http_headers(&ctx); |
123 | cgit_print_http_headers(ctx); |
127 | cgit_print_docstart(&ctx); |
124 | cgit_print_docstart(ctx); |
128 | cgit_print_pageheader(&ctx); |
125 | cgit_print_pageheader(ctx); |
129 | cgit_print_error(fmt("Invalid branch: %s", tmp)); |
126 | cgit_print_error(fmt("Invalid branch: %s", tmp)); |
130 | cgit_print_docend(); |
127 | cgit_print_docend(); |
131 | return; |
128 | return 1; |
132 | } |
129 | } |
133 | |
130 | return 0; |
134 | if ((cgit_cmd == CMD_SNAPSHOT) && ctx.repo->snapshots) { |
| |
135 | cgit_print_snapshot(ctx.qry.head, ctx.qry.sha1, |
| |
136 | cgit_repobasename(ctx.repo->url), |
| |
137 | ctx.qry.path, |
| |
138 | ctx.repo->snapshots ); |
| |
139 | return; |
| |
140 | } |
131 | } |
141 | |
132 | |
142 | if (cgit_cmd == CMD_PATCH) { |
133 | static void process_request(struct cgit_context *ctx) |
143 | cgit_print_patch(ctx.qry.sha1); |
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(); |
144 | return; |
146 | return; |
145 | } |
147 | } |
146 | |
148 | |
147 | if (cgit_cmd == CMD_BLOB) { |
149 | if (cmd->want_repo && prepare_repo_cmd(ctx)) |
148 | cgit_print_blob(ctx.qry.sha1, ctx.qry.path); |
| |
149 | return; |
150 | return; |
150 | } |
| |
151 | |
151 | |
152 | show_search = (cgit_cmd == CMD_LOG); |
152 | if (cmd->want_layout) { |
153 | cgit_print_http_headers(&ctx); |
153 | cgit_print_http_headers(ctx); |
154 | cgit_print_docstart(&ctx); |
154 | cgit_print_docstart(ctx); |
155 | if (!cgit_cmd) { |
155 | cgit_print_pageheader(ctx); |
156 | cgit_print_pageheader(&ctx); |
| |
157 | cgit_print_summary(); |
| |
158 | cgit_print_docend(); |
| |
159 | return; |
| |
160 | } |
156 | } |
161 | |
157 | |
162 | cgit_print_pageheader(&ctx); |
158 | cmd->fn(ctx); |
163 | |
159 | |
164 | switch(cgit_cmd) { |
160 | if (cmd->want_layout) |
165 | case CMD_LOG: |
| |
166 | cgit_print_log(ctx.qry.sha1, ctx.qry.ofs, |
| |
167 | ctx.cfg.max_commit_count, ctx.qry.grep, ctx.qry.search, |
| |
168 | ctx.qry.path, 1); |
| |
169 | break; |
| |
170 | case CMD_TREE: |
| |
171 | cgit_print_tree(ctx.qry.sha1, ctx.qry.path); |
| |
172 | break; |
| |
173 | case CMD_COMMIT: |
| |
174 | cgit_print_commit(ctx.qry.sha1); |
| |
175 | break; |
| |
176 | case CMD_REFS: |
| |
177 | cgit_print_refs(); |
| |
178 | break; |
| |
179 | case CMD_TAG: |
| |
180 | cgit_print_tag(ctx.qry.sha1); |
| |
181 | break; |
| |
182 | case CMD_DIFF: |
| |
183 | cgit_print_diff(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path); |
| |
184 | break; |
| |
185 | default: |
| |
186 | cgit_print_error("Invalid request"); |
| |
187 | } |
| |
188 | cgit_print_docend(); |
161 | cgit_print_docend(); |
189 | } |
162 | } |
190 | |
163 | |
191 | static long ttl_seconds(long ttl) |
164 | static long ttl_seconds(long ttl) |
192 | { |
165 | { |
193 | if (ttl<0) |
166 | if (ttl<0) |
194 | return 60 * 60 * 24 * 365; |
167 | return 60 * 60 * 24 * 365; |
195 | else |
168 | else |
196 | return ttl * 60; |
169 | return ttl * 60; |
197 | } |
170 | } |
198 | |
171 | |
199 | static void cgit_fill_cache(struct cacheitem *item, int use_cache) |
172 | static void cgit_fill_cache(struct cacheitem *item, int use_cache) |
200 | { |
173 | { |
201 | int stdout2; |
174 | int stdout2; |
202 | |
175 | |
203 | if (use_cache) { |
176 | if (use_cache) { |
204 | stdout2 = chk_positive(dup(STDOUT_FILENO), |
177 | stdout2 = chk_positive(dup(STDOUT_FILENO), |
205 | "Preserving STDOUT"); |
178 | "Preserving STDOUT"); |
206 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT"); |
179 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT"); |
207 | chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)"); |
180 | chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)"); |
208 | } |
181 | } |
209 | |
182 | |
210 | ctx.page.modified = time(NULL); |
183 | ctx.page.modified = time(NULL); |
211 | ctx.page.expires = ctx.page.modified + ttl_seconds(item->ttl); |
184 | ctx.page.expires = ctx.page.modified + ttl_seconds(item->ttl); |
212 | if (ctx.repo) |
185 | process_request(&ctx); |
213 | cgit_print_repo_page(); |
| |
214 | else |
| |
215 | cgit_print_repolist(); |
| |
216 | |
186 | |
217 | if (use_cache) { |
187 | if (use_cache) { |
218 | chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); |
188 | chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); |
219 | chk_positive(dup2(stdout2, STDOUT_FILENO), |
189 | chk_positive(dup2(stdout2, STDOUT_FILENO), |
220 | "Restoring original STDOUT"); |
190 | "Restoring original STDOUT"); |
221 | chk_zero(close(stdout2), "Closing temporary STDOUT"); |
191 | chk_zero(close(stdout2), "Closing temporary STDOUT"); |
222 | } |
192 | } |
223 | } |
193 | } |
224 | |
194 | |
225 | static void cgit_check_cache(struct cacheitem *item) |
195 | static void cgit_check_cache(struct cacheitem *item) |
226 | { |
196 | { |
227 | int i = 0; |
197 | int i = 0; |
228 | |
198 | |
229 | top: |
199 | top: |
230 | if (++i > ctx.cfg.max_lock_attempts) { |
200 | if (++i > ctx.cfg.max_lock_attempts) { |
231 | die("cgit_refresh_cache: unable to lock %s: %s", |
201 | die("cgit_refresh_cache: unable to lock %s: %s", |
232 | item->name, strerror(errno)); |
202 | item->name, strerror(errno)); |
233 | } |
203 | } |
234 | if (!cache_exist(item)) { |
204 | if (!cache_exist(item)) { |
235 | if (!cache_lock(item)) { |
205 | if (!cache_lock(item)) { |
236 | sleep(1); |
206 | sleep(1); |
237 | goto top; |
207 | goto top; |
238 | } |
208 | } |
239 | if (!cache_exist(item)) { |
209 | if (!cache_exist(item)) { |
240 | cgit_fill_cache(item, 1); |
210 | cgit_fill_cache(item, 1); |
241 | cache_unlock(item); |
211 | cache_unlock(item); |
242 | } else { |
212 | } else { |
243 | cache_cancel_lock(item); |
213 | cache_cancel_lock(item); |
244 | } |
214 | } |
245 | } else if (cache_expired(item) && cache_lock(item)) { |
215 | } else if (cache_expired(item) && cache_lock(item)) { |
246 | if (cache_expired(item)) { |
216 | if (cache_expired(item)) { |
247 | cgit_fill_cache(item, 1); |
217 | cgit_fill_cache(item, 1); |
248 | cache_unlock(item); |
218 | cache_unlock(item); |
249 | } else { |
219 | } else { |
250 | cache_cancel_lock(item); |
220 | cache_cancel_lock(item); |
251 | } |
221 | } |
252 | } |
222 | } |
253 | } |
223 | } |
254 | |
224 | |
255 | static void cgit_print_cache(struct cacheitem *item) |
225 | static void cgit_print_cache(struct cacheitem *item) |
256 | { |
226 | { |
257 | static char buf[4096]; |
227 | static char buf[4096]; |
258 | ssize_t i; |
228 | ssize_t i; |
259 | |
229 | |
260 | int fd = open(item->name, O_RDONLY); |
230 | int fd = open(item->name, O_RDONLY); |
261 | if (fd<0) |
231 | if (fd<0) |
262 | die("Unable to open cached file %s", item->name); |
232 | die("Unable to open cached file %s", item->name); |
263 | |
233 | |
|