-rw-r--r-- | cgit.c | 1 | ||||
-rw-r--r-- | cgit.h | 15 | ||||
-rw-r--r-- | html.c | 31 | ||||
-rw-r--r-- | html.h | 18 | ||||
-rw-r--r-- | shared.c | 2 | ||||
-rw-r--r-- | ui-blob.c | 9 | ||||
-rw-r--r-- | ui-commit.c | 7 | ||||
-rw-r--r-- | ui-diff.c | 2 | ||||
-rw-r--r-- | ui-log.c | 1 | ||||
-rw-r--r-- | ui-patch.c | 1 | ||||
-rw-r--r-- | ui-refs.c | 4 | ||||
-rw-r--r-- | ui-repolist.c | 3 | ||||
-rw-r--r-- | ui-shared.c | 16 | ||||
-rw-r--r-- | ui-snapshot.c | 1 | ||||
-rw-r--r-- | ui-summary.c | 1 | ||||
-rw-r--r-- | ui-tag.c | 2 | ||||
-rw-r--r-- | ui-tree.c | 3 |
17 files changed, 71 insertions, 46 deletions
@@ -198,120 +198,119 @@ static void cgit_fill_cache(struct cacheitem *item, int use_cache) | |||
198 | else | 198 | else |
199 | cgit_print_repolist(item); | 199 | cgit_print_repolist(item); |
200 | 200 | ||
201 | if (use_cache) { | 201 | if (use_cache) { |
202 | chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); | 202 | chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); |
203 | chk_positive(dup2(stdout2, STDOUT_FILENO), | 203 | chk_positive(dup2(stdout2, STDOUT_FILENO), |
204 | "Restoring original STDOUT"); | 204 | "Restoring original STDOUT"); |
205 | chk_zero(close(stdout2), "Closing temporary STDOUT"); | 205 | chk_zero(close(stdout2), "Closing temporary STDOUT"); |
206 | } | 206 | } |
207 | } | 207 | } |
208 | 208 | ||
209 | static void cgit_check_cache(struct cacheitem *item) | 209 | static void cgit_check_cache(struct cacheitem *item) |
210 | { | 210 | { |
211 | int i = 0; | 211 | int i = 0; |
212 | 212 | ||
213 | top: | 213 | top: |
214 | if (++i > ctx.cfg.max_lock_attempts) { | 214 | if (++i > ctx.cfg.max_lock_attempts) { |
215 | die("cgit_refresh_cache: unable to lock %s: %s", | 215 | die("cgit_refresh_cache: unable to lock %s: %s", |
216 | item->name, strerror(errno)); | 216 | item->name, strerror(errno)); |
217 | } | 217 | } |
218 | if (!cache_exist(item)) { | 218 | if (!cache_exist(item)) { |
219 | if (!cache_lock(item)) { | 219 | if (!cache_lock(item)) { |
220 | sleep(1); | 220 | sleep(1); |
221 | goto top; | 221 | goto top; |
222 | } | 222 | } |
223 | if (!cache_exist(item)) { | 223 | if (!cache_exist(item)) { |
224 | cgit_fill_cache(item, 1); | 224 | cgit_fill_cache(item, 1); |
225 | cache_unlock(item); | 225 | cache_unlock(item); |
226 | } else { | 226 | } else { |
227 | cache_cancel_lock(item); | 227 | cache_cancel_lock(item); |
228 | } | 228 | } |
229 | } else if (cache_expired(item) && cache_lock(item)) { | 229 | } else if (cache_expired(item) && cache_lock(item)) { |
230 | if (cache_expired(item)) { | 230 | if (cache_expired(item)) { |
231 | cgit_fill_cache(item, 1); | 231 | cgit_fill_cache(item, 1); |
232 | cache_unlock(item); | 232 | cache_unlock(item); |
233 | } else { | 233 | } else { |
234 | cache_cancel_lock(item); | 234 | cache_cancel_lock(item); |
235 | } | 235 | } |
236 | } | 236 | } |
237 | } | 237 | } |
238 | 238 | ||
239 | static void cgit_print_cache(struct cacheitem *item) | 239 | static void cgit_print_cache(struct cacheitem *item) |
240 | { | 240 | { |
241 | static char buf[4096]; | 241 | static char buf[4096]; |
242 | ssize_t i; | 242 | ssize_t i; |
243 | 243 | ||
244 | int fd = open(item->name, O_RDONLY); | 244 | int fd = open(item->name, O_RDONLY); |
245 | if (fd<0) | 245 | if (fd<0) |
246 | die("Unable to open cached file %s", item->name); | 246 | die("Unable to open cached file %s", item->name); |
247 | 247 | ||
248 | while((i=read(fd, buf, sizeof(buf))) > 0) | 248 | while((i=read(fd, buf, sizeof(buf))) > 0) |
249 | write(STDOUT_FILENO, buf, i); | 249 | write(STDOUT_FILENO, buf, i); |
250 | 250 | ||
251 | close(fd); | 251 | close(fd); |
252 | } | 252 | } |
253 | 253 | ||
254 | static void cgit_parse_args(int argc, const char **argv) | 254 | static void cgit_parse_args(int argc, const char **argv) |
255 | { | 255 | { |
256 | int i; | 256 | int i; |
257 | 257 | ||
258 | for (i = 1; i < argc; i++) { | 258 | for (i = 1; i < argc; i++) { |
259 | if (!strncmp(argv[i], "--cache=", 8)) { | 259 | if (!strncmp(argv[i], "--cache=", 8)) { |
260 | ctx.cfg.cache_root = xstrdup(argv[i]+8); | 260 | ctx.cfg.cache_root = xstrdup(argv[i]+8); |
261 | } | 261 | } |
262 | if (!strcmp(argv[i], "--nocache")) { | 262 | if (!strcmp(argv[i], "--nocache")) { |
263 | ctx.cfg.nocache = 1; | 263 | ctx.cfg.nocache = 1; |
264 | } | 264 | } |
265 | if (!strncmp(argv[i], "--query=", 8)) { | 265 | if (!strncmp(argv[i], "--query=", 8)) { |
266 | ctx.qry.raw = xstrdup(argv[i]+8); | 266 | ctx.qry.raw = xstrdup(argv[i]+8); |
267 | } | 267 | } |
268 | if (!strncmp(argv[i], "--repo=", 7)) { | 268 | if (!strncmp(argv[i], "--repo=", 7)) { |
269 | ctx.qry.repo = xstrdup(argv[i]+7); | 269 | ctx.qry.repo = xstrdup(argv[i]+7); |
270 | } | 270 | } |
271 | if (!strncmp(argv[i], "--page=", 7)) { | 271 | if (!strncmp(argv[i], "--page=", 7)) { |
272 | ctx.qry.page = xstrdup(argv[i]+7); | 272 | ctx.qry.page = xstrdup(argv[i]+7); |
273 | } | 273 | } |
274 | if (!strncmp(argv[i], "--head=", 7)) { | 274 | if (!strncmp(argv[i], "--head=", 7)) { |
275 | ctx.qry.head = xstrdup(argv[i]+7); | 275 | ctx.qry.head = xstrdup(argv[i]+7); |
276 | ctx.qry.has_symref = 1; | 276 | ctx.qry.has_symref = 1; |
277 | } | 277 | } |
278 | if (!strncmp(argv[i], "--sha1=", 7)) { | 278 | if (!strncmp(argv[i], "--sha1=", 7)) { |
279 | ctx.qry.sha1 = xstrdup(argv[i]+7); | 279 | ctx.qry.sha1 = xstrdup(argv[i]+7); |
280 | ctx.qry.has_sha1 = 1; | 280 | ctx.qry.has_sha1 = 1; |
281 | } | 281 | } |
282 | if (!strncmp(argv[i], "--ofs=", 6)) { | 282 | if (!strncmp(argv[i], "--ofs=", 6)) { |
283 | ctx.qry.ofs = atoi(argv[i]+6); | 283 | ctx.qry.ofs = atoi(argv[i]+6); |
284 | } | 284 | } |
285 | } | 285 | } |
286 | } | 286 | } |
287 | 287 | ||
288 | int main(int argc, const char **argv) | 288 | int main(int argc, const char **argv) |
289 | { | 289 | { |
290 | struct cacheitem item; | 290 | struct cacheitem item; |
291 | const char *cgit_config_env = getenv("CGIT_CONFIG"); | 291 | const char *cgit_config_env = getenv("CGIT_CONFIG"); |
292 | 292 | ||
293 | cgit_prepare_context(&ctx); | 293 | cgit_prepare_context(&ctx); |
294 | htmlfd = STDOUT_FILENO; | ||
295 | item.st.st_mtime = time(NULL); | 294 | item.st.st_mtime = time(NULL); |
296 | cgit_repolist.length = 0; | 295 | cgit_repolist.length = 0; |
297 | cgit_repolist.count = 0; | 296 | cgit_repolist.count = 0; |
298 | cgit_repolist.repos = NULL; | 297 | cgit_repolist.repos = NULL; |
299 | 298 | ||
300 | cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG, | 299 | cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG, |
301 | cgit_global_config_cb); | 300 | cgit_global_config_cb); |
302 | if (getenv("SCRIPT_NAME")) | 301 | if (getenv("SCRIPT_NAME")) |
303 | ctx.cfg.script_name = xstrdup(getenv("SCRIPT_NAME")); | 302 | ctx.cfg.script_name = xstrdup(getenv("SCRIPT_NAME")); |
304 | if (getenv("QUERY_STRING")) | 303 | if (getenv("QUERY_STRING")) |
305 | ctx.qry.raw = xstrdup(getenv("QUERY_STRING")); | 304 | ctx.qry.raw = xstrdup(getenv("QUERY_STRING")); |
306 | cgit_parse_args(argc, argv); | 305 | cgit_parse_args(argc, argv); |
307 | cgit_parse_query(ctx.qry.raw, cgit_querystring_cb); | 306 | cgit_parse_query(ctx.qry.raw, cgit_querystring_cb); |
308 | if (!cgit_prepare_cache(&item)) | 307 | if (!cgit_prepare_cache(&item)) |
309 | return 0; | 308 | return 0; |
310 | if (ctx.cfg.nocache) { | 309 | if (ctx.cfg.nocache) { |
311 | cgit_fill_cache(&item, 0); | 310 | cgit_fill_cache(&item, 0); |
312 | } else { | 311 | } else { |
313 | cgit_check_cache(&item); | 312 | cgit_check_cache(&item); |
314 | cgit_print_cache(&item); | 313 | cgit_print_cache(&item); |
315 | } | 314 | } |
316 | return 0; | 315 | return 0; |
317 | } | 316 | } |
@@ -93,212 +93,199 @@ struct commitinfo { | |||
93 | char *author; | 93 | char *author; |
94 | char *author_email; | 94 | char *author_email; |
95 | unsigned long author_date; | 95 | unsigned long author_date; |
96 | char *committer; | 96 | char *committer; |
97 | char *committer_email; | 97 | char *committer_email; |
98 | unsigned long committer_date; | 98 | unsigned long committer_date; |
99 | char *subject; | 99 | char *subject; |
100 | char *msg; | 100 | char *msg; |
101 | char *msg_encoding; | 101 | char *msg_encoding; |
102 | }; | 102 | }; |
103 | 103 | ||
104 | struct taginfo { | 104 | struct taginfo { |
105 | char *tagger; | 105 | char *tagger; |
106 | char *tagger_email; | 106 | char *tagger_email; |
107 | int tagger_date; | 107 | int tagger_date; |
108 | char *msg; | 108 | char *msg; |
109 | }; | 109 | }; |
110 | 110 | ||
111 | struct refinfo { | 111 | struct refinfo { |
112 | const char *refname; | 112 | const char *refname; |
113 | struct object *object; | 113 | struct object *object; |
114 | union { | 114 | union { |
115 | struct taginfo *tag; | 115 | struct taginfo *tag; |
116 | struct commitinfo *commit; | 116 | struct commitinfo *commit; |
117 | }; | 117 | }; |
118 | }; | 118 | }; |
119 | 119 | ||
120 | struct reflist { | 120 | struct reflist { |
121 | struct refinfo **refs; | 121 | struct refinfo **refs; |
122 | int alloc; | 122 | int alloc; |
123 | int count; | 123 | int count; |
124 | }; | 124 | }; |
125 | 125 | ||
126 | struct cgit_query { | 126 | struct cgit_query { |
127 | int has_symref; | 127 | int has_symref; |
128 | int has_sha1; | 128 | int has_sha1; |
129 | char *raw; | 129 | char *raw; |
130 | char *repo; | 130 | char *repo; |
131 | char *page; | 131 | char *page; |
132 | char *search; | 132 | char *search; |
133 | char *grep; | 133 | char *grep; |
134 | char *head; | 134 | char *head; |
135 | char *sha1; | 135 | char *sha1; |
136 | char *sha2; | 136 | char *sha2; |
137 | char *path; | 137 | char *path; |
138 | char *name; | 138 | char *name; |
139 | int ofs; | 139 | int ofs; |
140 | }; | 140 | }; |
141 | 141 | ||
142 | struct cgit_config { | 142 | struct cgit_config { |
143 | char *agefile; | 143 | char *agefile; |
144 | char *cache_root; | 144 | char *cache_root; |
145 | char *clone_prefix; | 145 | char *clone_prefix; |
146 | char *css; | 146 | char *css; |
147 | char *index_header; | 147 | char *index_header; |
148 | char *index_info; | 148 | char *index_info; |
149 | char *logo; | 149 | char *logo; |
150 | char *logo_link; | 150 | char *logo_link; |
151 | char *module_link; | 151 | char *module_link; |
152 | char *repo_group; | 152 | char *repo_group; |
153 | char *robots; | 153 | char *robots; |
154 | char *root_title; | 154 | char *root_title; |
155 | char *script_name; | 155 | char *script_name; |
156 | char *virtual_root; | 156 | char *virtual_root; |
157 | int cache_dynamic_ttl; | 157 | int cache_dynamic_ttl; |
158 | int cache_max_create_time; | 158 | int cache_max_create_time; |
159 | int cache_repo_ttl; | 159 | int cache_repo_ttl; |
160 | int cache_root_ttl; | 160 | int cache_root_ttl; |
161 | int cache_static_ttl; | 161 | int cache_static_ttl; |
162 | int enable_index_links; | 162 | int enable_index_links; |
163 | int enable_log_filecount; | 163 | int enable_log_filecount; |
164 | int enable_log_linecount; | 164 | int enable_log_linecount; |
165 | int max_commit_count; | 165 | int max_commit_count; |
166 | int max_lock_attempts; | 166 | int max_lock_attempts; |
167 | int max_msg_len; | 167 | int max_msg_len; |
168 | int max_repodesc_len; | 168 | int max_repodesc_len; |
169 | int nocache; | 169 | int nocache; |
170 | int renamelimit; | 170 | int renamelimit; |
171 | int snapshots; | 171 | int snapshots; |
172 | int summary_branches; | 172 | int summary_branches; |
173 | int summary_log; | 173 | int summary_log; |
174 | int summary_tags; | 174 | int summary_tags; |
175 | }; | 175 | }; |
176 | 176 | ||
177 | struct cgit_context { | 177 | struct cgit_context { |
178 | struct cgit_query qry; | 178 | struct cgit_query qry; |
179 | struct cgit_config cfg; | 179 | struct cgit_config cfg; |
180 | struct cgit_repo *repo; | 180 | struct cgit_repo *repo; |
181 | }; | 181 | }; |
182 | 182 | ||
183 | extern const char *cgit_version; | 183 | extern const char *cgit_version; |
184 | 184 | ||
185 | extern struct cgit_repolist cgit_repolist; | 185 | extern struct cgit_repolist cgit_repolist; |
186 | extern struct cgit_context ctx; | 186 | extern struct cgit_context ctx; |
187 | extern int cgit_cmd; | 187 | extern int cgit_cmd; |
188 | 188 | ||
189 | extern int htmlfd; | ||
190 | |||
191 | extern void cgit_prepare_context(struct cgit_context *ctx); | 189 | extern void cgit_prepare_context(struct cgit_context *ctx); |
192 | extern int cgit_get_cmd_index(const char *cmd); | 190 | extern int cgit_get_cmd_index(const char *cmd); |
193 | extern struct cgit_repo *cgit_get_repoinfo(const char *url); | 191 | extern struct cgit_repo *cgit_get_repoinfo(const char *url); |
194 | extern void cgit_global_config_cb(const char *name, const char *value); | 192 | extern void cgit_global_config_cb(const char *name, const char *value); |
195 | extern void cgit_repo_config_cb(const char *name, const char *value); | 193 | extern void cgit_repo_config_cb(const char *name, const char *value); |
196 | extern void cgit_querystring_cb(const char *name, const char *value); | 194 | extern void cgit_querystring_cb(const char *name, const char *value); |
197 | 195 | ||
198 | extern int chk_zero(int result, char *msg); | 196 | extern int chk_zero(int result, char *msg); |
199 | extern int chk_positive(int result, char *msg); | 197 | extern int chk_positive(int result, char *msg); |
200 | extern int chk_non_negative(int result, char *msg); | 198 | extern int chk_non_negative(int result, char *msg); |
201 | 199 | ||
202 | extern int hextoint(char c); | 200 | extern int hextoint(char c); |
203 | extern char *trim_end(const char *str, char c); | 201 | extern char *trim_end(const char *str, char c); |
204 | extern char *strlpart(char *txt, int maxlen); | 202 | extern char *strlpart(char *txt, int maxlen); |
205 | extern char *strrpart(char *txt, int maxlen); | 203 | extern char *strrpart(char *txt, int maxlen); |
206 | 204 | ||
207 | extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); | 205 | extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); |
208 | extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, | 206 | extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, |
209 | int flags, void *cb_data); | 207 | int flags, void *cb_data); |
210 | 208 | ||
211 | extern void *cgit_free_commitinfo(struct commitinfo *info); | 209 | extern void *cgit_free_commitinfo(struct commitinfo *info); |
212 | 210 | ||
213 | extern int cgit_diff_files(const unsigned char *old_sha1, | 211 | extern int cgit_diff_files(const unsigned char *old_sha1, |
214 | const unsigned char *new_sha1, | 212 | const unsigned char *new_sha1, |
215 | linediff_fn fn); | 213 | linediff_fn fn); |
216 | 214 | ||
217 | extern void cgit_diff_tree(const unsigned char *old_sha1, | 215 | extern void cgit_diff_tree(const unsigned char *old_sha1, |
218 | const unsigned char *new_sha1, | 216 | const unsigned char *new_sha1, |
219 | filepair_fn fn, const char *prefix); | 217 | filepair_fn fn, const char *prefix); |
220 | 218 | ||
221 | extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); | 219 | extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); |
222 | 220 | ||
223 | extern char *fmt(const char *format,...); | 221 | extern char *fmt(const char *format,...); |
224 | 222 | ||
225 | extern void html(const char *txt); | ||
226 | extern void htmlf(const char *format,...); | ||
227 | extern void html_txt(char *txt); | ||
228 | extern void html_ntxt(int len, char *txt); | ||
229 | extern void html_attr(char *txt); | ||
230 | extern void html_hidden(char *name, char *value); | ||
231 | extern void html_option(char *value, char *text, char *selected_value); | ||
232 | extern void html_link_open(char *url, char *title, char *class); | ||
233 | extern void html_link_close(void); | ||
234 | extern void html_filemode(unsigned short mode); | ||
235 | extern int html_include(const char *filename); | ||
236 | |||
237 | extern int cgit_read_config(const char *filename, configfn fn); | 223 | extern int cgit_read_config(const char *filename, configfn fn); |
238 | extern int cgit_parse_query(char *txt, configfn fn); | 224 | extern int cgit_parse_query(char *txt, configfn fn); |
239 | extern struct commitinfo *cgit_parse_commit(struct commit *commit); | 225 | extern struct commitinfo *cgit_parse_commit(struct commit *commit); |
240 | extern struct taginfo *cgit_parse_tag(struct tag *tag); | 226 | extern struct taginfo *cgit_parse_tag(struct tag *tag); |
241 | extern void cgit_parse_url(const char *url); | 227 | extern void cgit_parse_url(const char *url); |
242 | 228 | ||
243 | extern char *cache_safe_filename(const char *unsafe); | 229 | extern char *cache_safe_filename(const char *unsafe); |
244 | extern int cache_lock(struct cacheitem *item); | 230 | extern int cache_lock(struct cacheitem *item); |
245 | extern int cache_unlock(struct cacheitem *item); | 231 | extern int cache_unlock(struct cacheitem *item); |
246 | extern int cache_cancel_lock(struct cacheitem *item); | 232 | extern int cache_cancel_lock(struct cacheitem *item); |
247 | extern int cache_exist(struct cacheitem *item); | 233 | extern int cache_exist(struct cacheitem *item); |
248 | extern int cache_expired(struct cacheitem *item); | 234 | extern int cache_expired(struct cacheitem *item); |
249 | 235 | ||
250 | extern char *cgit_repourl(const char *reponame); | 236 | extern char *cgit_repourl(const char *reponame); |
251 | extern char *cgit_fileurl(const char *reponame, const char *pagename, | 237 | extern char *cgit_fileurl(const char *reponame, const char *pagename, |
252 | const char *filename, const char *query); | 238 | const char *filename, const char *query); |
253 | extern char *cgit_pageurl(const char *reponame, const char *pagename, | 239 | extern char *cgit_pageurl(const char *reponame, const char *pagename, |
254 | const char *query); | 240 | const char *query); |
255 | 241 | ||
256 | extern const char *cgit_repobasename(const char *reponame); | 242 | extern const char *cgit_repobasename(const char *reponame); |
257 | 243 | ||
258 | extern void cgit_tree_link(char *name, char *title, char *class, char *head, | 244 | extern void cgit_tree_link(char *name, char *title, char *class, char *head, |
259 | char *rev, char *path); | 245 | char *rev, char *path); |
260 | extern void cgit_log_link(char *name, char *title, char *class, char *head, | 246 | extern void cgit_log_link(char *name, char *title, char *class, char *head, |
261 | char *rev, char *path, int ofs, char *grep, | 247 | char *rev, char *path, int ofs, char *grep, |
262 | char *pattern); | 248 | char *pattern); |
263 | extern void cgit_commit_link(char *name, char *title, char *class, char *head, | 249 | extern void cgit_commit_link(char *name, char *title, char *class, char *head, |
264 | char *rev); | 250 | char *rev); |
265 | extern void cgit_refs_link(char *name, char *title, char *class, char *head, | 251 | extern void cgit_refs_link(char *name, char *title, char *class, char *head, |
266 | char *rev, char *path); | 252 | char *rev, char *path); |
267 | extern void cgit_snapshot_link(char *name, char *title, char *class, | 253 | extern void cgit_snapshot_link(char *name, char *title, char *class, |
268 | char *head, char *rev, char *archivename); | 254 | char *head, char *rev, char *archivename); |
269 | extern void cgit_diff_link(char *name, char *title, char *class, char *head, | 255 | extern void cgit_diff_link(char *name, char *title, char *class, char *head, |
270 | char *new_rev, char *old_rev, char *path); | 256 | char *new_rev, char *old_rev, char *path); |
271 | 257 | ||
272 | extern void cgit_object_link(struct object *obj); | 258 | extern void cgit_object_link(struct object *obj); |
273 | 259 | ||
274 | extern void cgit_print_error(char *msg); | 260 | extern void cgit_print_error(char *msg); |
275 | extern void cgit_print_date(time_t secs, char *format); | 261 | extern void cgit_print_date(time_t secs, char *format); |
276 | extern void cgit_print_age(time_t t, time_t max_relative, char *format); | 262 | extern void cgit_print_age(time_t t, time_t max_relative, char *format); |
277 | extern void cgit_print_docstart(char *title, struct cacheitem *item); | 263 | extern void cgit_print_docstart(char *title, struct cacheitem *item); |
278 | extern void cgit_print_docend(); | 264 | extern void cgit_print_docend(); |
279 | extern void cgit_print_pageheader(char *title, int show_search); | 265 | extern void cgit_print_pageheader(char *title, int show_search); |
280 | extern void cgit_print_snapshot_start(const char *mimetype, | 266 | extern void cgit_print_snapshot_start(const char *mimetype, |
281 | const char *filename, | 267 | const char *filename, |
282 | struct cacheitem *item); | 268 | struct cacheitem *item); |
269 | extern void cgit_print_filemode(unsigned short mode); | ||
283 | extern void cgit_print_branches(int maxcount); | 270 | extern void cgit_print_branches(int maxcount); |
284 | extern void cgit_print_tags(int maxcount); | 271 | extern void cgit_print_tags(int maxcount); |
285 | 272 | ||
286 | extern void cgit_print_repolist(struct cacheitem *item); | 273 | extern void cgit_print_repolist(struct cacheitem *item); |
287 | extern void cgit_print_summary(); | 274 | extern void cgit_print_summary(); |
288 | extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, | 275 | extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, |
289 | char *pattern, char *path, int pager); | 276 | char *pattern, char *path, int pager); |
290 | extern void cgit_print_blob(struct cacheitem *item, const char *hex, char *path); | 277 | extern void cgit_print_blob(struct cacheitem *item, const char *hex, char *path); |
291 | extern void cgit_print_tree(const char *rev, char *path); | 278 | extern void cgit_print_tree(const char *rev, char *path); |
292 | extern void cgit_print_commit(char *hex); | 279 | extern void cgit_print_commit(char *hex); |
293 | extern void cgit_print_refs(); | 280 | extern void cgit_print_refs(); |
294 | extern void cgit_print_tag(char *revname); | 281 | extern void cgit_print_tag(char *revname); |
295 | extern void cgit_print_diff(const char *new_hex, const char *old_hex, const char *prefix); | 282 | extern void cgit_print_diff(const char *new_hex, const char *old_hex, const char *prefix); |
296 | extern void cgit_print_patch(char *hex, struct cacheitem *item); | 283 | extern void cgit_print_patch(char *hex, struct cacheitem *item); |
297 | extern void cgit_print_snapshot(struct cacheitem *item, const char *head, | 284 | extern void cgit_print_snapshot(struct cacheitem *item, const char *head, |
298 | const char *hex, const char *prefix, | 285 | const char *hex, const char *prefix, |
299 | const char *filename, int snapshot); | 286 | const char *filename, int snapshot); |
300 | extern void cgit_print_snapshot_links(const char *repo, const char *head, | 287 | extern void cgit_print_snapshot_links(const char *repo, const char *head, |
301 | const char *hex, int snapshots); | 288 | const char *hex, int snapshots); |
302 | extern int cgit_parse_snapshots_mask(const char *str); | 289 | extern int cgit_parse_snapshots_mask(const char *str); |
303 | 290 | ||
304 | #endif /* CGIT_H */ | 291 | #endif /* CGIT_H */ |
@@ -1,194 +1,187 @@ | |||
1 | /* html.c: helper functions for html output | 1 | /* html.c: helper functions for html output |
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 <unistd.h> |
10 | #include <stdio.h> | ||
11 | #include <stdlib.h> | ||
12 | #include <stdarg.h> | ||
13 | #include <string.h> | ||
14 | |||
15 | int htmlfd = STDOUT_FILENO; | ||
10 | 16 | ||
11 | char *fmt(const char *format, ...) | 17 | char *fmt(const char *format, ...) |
12 | { | 18 | { |
13 | static char buf[8][1024]; | 19 | static char buf[8][1024]; |
14 | static int bufidx; | 20 | static int bufidx; |
15 | int len; | 21 | int len; |
16 | va_list args; | 22 | va_list args; |
17 | 23 | ||
18 | bufidx++; | 24 | bufidx++; |
19 | bufidx &= 7; | 25 | bufidx &= 7; |
20 | 26 | ||
21 | va_start(args, format); | 27 | va_start(args, format); |
22 | len = vsnprintf(buf[bufidx], sizeof(buf[bufidx]), format, args); | 28 | len = vsnprintf(buf[bufidx], sizeof(buf[bufidx]), format, args); |
23 | va_end(args); | 29 | va_end(args); |
24 | if (len>sizeof(buf[bufidx])) | 30 | if (len>sizeof(buf[bufidx])) { |
25 | die("[html.c] string truncated: %s", format); | 31 | fprintf(stderr, "[html.c] string truncated: %s\n", format); |
32 | exit(1); | ||
33 | } | ||
26 | return buf[bufidx]; | 34 | return buf[bufidx]; |
27 | } | 35 | } |
28 | 36 | ||
29 | void html(const char *txt) | 37 | void html(const char *txt) |
30 | { | 38 | { |
31 | write(htmlfd, txt, strlen(txt)); | 39 | write(htmlfd, txt, strlen(txt)); |
32 | } | 40 | } |
33 | 41 | ||
34 | void htmlf(const char *format, ...) | 42 | void htmlf(const char *format, ...) |
35 | { | 43 | { |
36 | static char buf[65536]; | 44 | static char buf[65536]; |
37 | va_list args; | 45 | va_list args; |
38 | 46 | ||
39 | va_start(args, format); | 47 | va_start(args, format); |
40 | vsnprintf(buf, sizeof(buf), format, args); | 48 | vsnprintf(buf, sizeof(buf), format, args); |
41 | va_end(args); | 49 | va_end(args); |
42 | html(buf); | 50 | html(buf); |
43 | } | 51 | } |
44 | 52 | ||
45 | void html_txt(char *txt) | 53 | void html_txt(char *txt) |
46 | { | 54 | { |
47 | char *t = txt; | 55 | char *t = txt; |
48 | while(t && *t){ | 56 | while(t && *t){ |
49 | int c = *t; | 57 | int c = *t; |
50 | if (c=='<' || c=='>' || c=='&') { | 58 | if (c=='<' || c=='>' || c=='&') { |
51 | *t = '\0'; | 59 | *t = '\0'; |
52 | html(txt); | 60 | html(txt); |
53 | *t = c; | 61 | *t = c; |
54 | if (c=='>') | 62 | if (c=='>') |
55 | html(">"); | 63 | html(">"); |
56 | else if (c=='<') | 64 | else if (c=='<') |
57 | html("<"); | 65 | html("<"); |
58 | else if (c=='&') | 66 | else if (c=='&') |
59 | html("&"); | 67 | html("&"); |
60 | txt = t+1; | 68 | txt = t+1; |
61 | } | 69 | } |
62 | t++; | 70 | t++; |
63 | } | 71 | } |
64 | if (t!=txt) | 72 | if (t!=txt) |
65 | html(txt); | 73 | html(txt); |
66 | } | 74 | } |
67 | 75 | ||
68 | void html_ntxt(int len, char *txt) | 76 | void html_ntxt(int len, char *txt) |
69 | { | 77 | { |
70 | char *t = txt; | 78 | char *t = txt; |
71 | while(t && *t && len--){ | 79 | while(t && *t && len--){ |
72 | int c = *t; | 80 | int c = *t; |
73 | if (c=='<' || c=='>' || c=='&') { | 81 | if (c=='<' || c=='>' || c=='&') { |
74 | *t = '\0'; | 82 | *t = '\0'; |
75 | html(txt); | 83 | html(txt); |
76 | *t = c; | 84 | *t = c; |
77 | if (c=='>') | 85 | if (c=='>') |
78 | html(">"); | 86 | html(">"); |
79 | else if (c=='<') | 87 | else if (c=='<') |
80 | html("<"); | 88 | html("<"); |
81 | else if (c=='&') | 89 | else if (c=='&') |
82 | html("&"); | 90 | html("&"); |
83 | txt = t+1; | 91 | txt = t+1; |
84 | } | 92 | } |
85 | t++; | 93 | t++; |
86 | } | 94 | } |
87 | if (t!=txt) { | 95 | if (t!=txt) { |
88 | char c = *t; | 96 | char c = *t; |
89 | *t = '\0'; | 97 | *t = '\0'; |
90 | html(txt); | 98 | html(txt); |
91 | *t = c; | 99 | *t = c; |
92 | } | 100 | } |
93 | if (len<0) | 101 | if (len<0) |
94 | html("..."); | 102 | html("..."); |
95 | } | 103 | } |
96 | 104 | ||
97 | void html_attr(char *txt) | 105 | void html_attr(char *txt) |
98 | { | 106 | { |
99 | char *t = txt; | 107 | char *t = txt; |
100 | while(t && *t){ | 108 | while(t && *t){ |
101 | int c = *t; | 109 | int c = *t; |
102 | if (c=='<' || c=='>' || c=='\'') { | 110 | if (c=='<' || c=='>' || c=='\'') { |
103 | *t = '\0'; | 111 | *t = '\0'; |
104 | html(txt); | 112 | html(txt); |
105 | *t = c; | 113 | *t = c; |
106 | if (c=='>') | 114 | if (c=='>') |
107 | html(">"); | 115 | html(">"); |
108 | else if (c=='<') | 116 | else if (c=='<') |
109 | html("<"); | 117 | html("<"); |
110 | else if (c=='\'') | 118 | else if (c=='\'') |
111 | html(""e;"); | 119 | html(""e;"); |
112 | txt = t+1; | 120 | txt = t+1; |
113 | } | 121 | } |
114 | t++; | 122 | t++; |
115 | } | 123 | } |
116 | if (t!=txt) | 124 | if (t!=txt) |
117 | html(txt); | 125 | html(txt); |
118 | } | 126 | } |
119 | 127 | ||
120 | void html_hidden(char *name, char *value) | 128 | void html_hidden(char *name, char *value) |
121 | { | 129 | { |
122 | html("<input type='hidden' name='"); | 130 | html("<input type='hidden' name='"); |
123 | html_attr(name); | 131 | html_attr(name); |
124 | html("' value='"); | 132 | html("' value='"); |
125 | html_attr(value); | 133 | html_attr(value); |
126 | html("'/>"); | 134 | html("'/>"); |
127 | } | 135 | } |
128 | 136 | ||
129 | void html_option(char *value, char *text, char *selected_value) | 137 | void html_option(char *value, char *text, char *selected_value) |
130 | { | 138 | { |
131 | html("<option value='"); | 139 | html("<option value='"); |
132 | html_attr(value); | 140 | html_attr(value); |
133 | html("'"); | 141 | html("'"); |
134 | if (selected_value && !strcmp(selected_value, value)) | 142 | if (selected_value && !strcmp(selected_value, value)) |
135 | html(" selected='selected'"); | 143 | html(" selected='selected'"); |
136 | html(">"); | 144 | html(">"); |
137 | html_txt(text); | 145 | html_txt(text); |
138 | html("</option>\n"); | 146 | html("</option>\n"); |
139 | } | 147 | } |
140 | 148 | ||
141 | void html_link_open(char *url, char *title, char *class) | 149 | void html_link_open(char *url, char *title, char *class) |
142 | { | 150 | { |
143 | html("<a href='"); | 151 | html("<a href='"); |
144 | html_attr(url); | 152 | html_attr(url); |
145 | if (title) { | 153 | if (title) { |
146 | html("' title='"); | 154 | html("' title='"); |
147 | html_attr(title); | 155 | html_attr(title); |
148 | } | 156 | } |
149 | if (class) { | 157 | if (class) { |
150 | html("' class='"); | 158 | html("' class='"); |
151 | html_attr(class); | 159 | html_attr(class); |
152 | } | 160 | } |
153 | html("'>"); | 161 | html("'>"); |
154 | } | 162 | } |
155 | 163 | ||
156 | void html_link_close(void) | 164 | void html_link_close(void) |
157 | { | 165 | { |
158 | html("</a>"); | 166 | html("</a>"); |
159 | } | 167 | } |
160 | 168 | ||
161 | void html_fileperm(unsigned short mode) | 169 | void html_fileperm(unsigned short mode) |
162 | { | 170 | { |
163 | htmlf("%c%c%c", (mode & 4 ? 'r' : '-'), | 171 | htmlf("%c%c%c", (mode & 4 ? 'r' : '-'), |
164 | (mode & 2 ? 'w' : '-'), (mode & 1 ? 'x' : '-')); | 172 | (mode & 2 ? 'w' : '-'), (mode & 1 ? 'x' : '-')); |
165 | } | 173 | } |
166 | 174 | ||
167 | void html_filemode(unsigned short mode) | ||
168 | { | ||
169 | if (S_ISDIR(mode)) | ||
170 | html("d"); | ||
171 | else if (S_ISLNK(mode)) | ||
172 | html("l"); | ||
173 | else if (S_ISGITLINK(mode)) | ||
174 | html("m"); | ||
175 | else | ||
176 | html("-"); | ||
177 | html_fileperm(mode >> 6); | ||
178 | html_fileperm(mode >> 3); | ||
179 | html_fileperm(mode); | ||
180 | } | ||
181 | |||
182 | int html_include(const char *filename) | 175 | int html_include(const char *filename) |
183 | { | 176 | { |
184 | FILE *f; | 177 | FILE *f; |
185 | char buf[4096]; | 178 | char buf[4096]; |
186 | size_t len; | 179 | size_t len; |
187 | 180 | ||
188 | if (!(f = fopen(filename, "r"))) | 181 | if (!(f = fopen(filename, "r"))) |
189 | return -1; | 182 | return -1; |
190 | while((len = fread(buf, 1, 4096, f)) > 0) | 183 | while((len = fread(buf, 1, 4096, f)) > 0) |
191 | write(htmlfd, buf, len); | 184 | write(htmlfd, buf, len); |
192 | fclose(f); | 185 | fclose(f); |
193 | return 0; | 186 | return 0; |
194 | } | 187 | } |
@@ -0,0 +1,18 @@ | |||
1 | #ifndef HTML_H | ||
2 | #define HTML_H | ||
3 | |||
4 | extern int htmlfd; | ||
5 | |||
6 | extern void html(const char *txt); | ||
7 | extern void htmlf(const char *format,...); | ||
8 | extern void html_txt(char *txt); | ||
9 | extern void html_ntxt(int len, char *txt); | ||
10 | extern void html_attr(char *txt); | ||
11 | extern void html_hidden(char *name, char *value); | ||
12 | extern void html_option(char *value, char *text, char *selected_value); | ||
13 | extern void html_link_open(char *url, char *title, char *class); | ||
14 | extern void html_link_close(void); | ||
15 | extern void html_fileperm(unsigned short mode); | ||
16 | extern int html_include(const char *filename); | ||
17 | |||
18 | #endif /* HTML_H */ | ||
@@ -1,114 +1,112 @@ | |||
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 cgit_repolist cgit_repolist; | 11 | struct cgit_repolist cgit_repolist; |
12 | struct cgit_context ctx; | 12 | struct cgit_context ctx; |
13 | int cgit_cmd; | 13 | int cgit_cmd; |
14 | 14 | ||
15 | const char *cgit_version = CGIT_VERSION; | 15 | const char *cgit_version = CGIT_VERSION; |
16 | 16 | ||
17 | int htmlfd = 0; | ||
18 | |||
19 | void cgit_prepare_context(struct cgit_context *ctx) | 17 | void cgit_prepare_context(struct cgit_context *ctx) |
20 | { | 18 | { |
21 | memset(ctx, 0, sizeof(ctx)); | 19 | memset(ctx, 0, sizeof(ctx)); |
22 | ctx->cfg.agefile = "info/web/last-modified"; | 20 | ctx->cfg.agefile = "info/web/last-modified"; |
23 | ctx->cfg.cache_dynamic_ttl = 5; | 21 | ctx->cfg.cache_dynamic_ttl = 5; |
24 | ctx->cfg.cache_max_create_time = 5; | 22 | ctx->cfg.cache_max_create_time = 5; |
25 | ctx->cfg.cache_repo_ttl = 5; | 23 | ctx->cfg.cache_repo_ttl = 5; |
26 | ctx->cfg.cache_root = CGIT_CACHE_ROOT; | 24 | ctx->cfg.cache_root = CGIT_CACHE_ROOT; |
27 | ctx->cfg.cache_root_ttl = 5; | 25 | ctx->cfg.cache_root_ttl = 5; |
28 | ctx->cfg.cache_static_ttl = -1; | 26 | ctx->cfg.cache_static_ttl = -1; |
29 | ctx->cfg.css = "/cgit.css"; | 27 | ctx->cfg.css = "/cgit.css"; |
30 | ctx->cfg.logo = "/git-logo.png"; | 28 | ctx->cfg.logo = "/git-logo.png"; |
31 | ctx->cfg.max_commit_count = 50; | 29 | ctx->cfg.max_commit_count = 50; |
32 | ctx->cfg.max_lock_attempts = 5; | 30 | ctx->cfg.max_lock_attempts = 5; |
33 | ctx->cfg.max_msg_len = 60; | 31 | ctx->cfg.max_msg_len = 60; |
34 | ctx->cfg.max_repodesc_len = 60; | 32 | ctx->cfg.max_repodesc_len = 60; |
35 | ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s"; | 33 | ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s"; |
36 | ctx->cfg.renamelimit = -1; | 34 | ctx->cfg.renamelimit = -1; |
37 | ctx->cfg.robots = "index, nofollow"; | 35 | ctx->cfg.robots = "index, nofollow"; |
38 | ctx->cfg.root_title = "Git repository browser"; | 36 | ctx->cfg.root_title = "Git repository browser"; |
39 | ctx->cfg.script_name = CGIT_SCRIPT_NAME; | 37 | ctx->cfg.script_name = CGIT_SCRIPT_NAME; |
40 | } | 38 | } |
41 | 39 | ||
42 | int cgit_get_cmd_index(const char *cmd) | 40 | int cgit_get_cmd_index(const char *cmd) |
43 | { | 41 | { |
44 | static char *cmds[] = {"log", "commit", "diff", "tree", "blob", | 42 | static char *cmds[] = {"log", "commit", "diff", "tree", "blob", |
45 | "snapshot", "tag", "refs", "patch", NULL}; | 43 | "snapshot", "tag", "refs", "patch", NULL}; |
46 | int i; | 44 | int i; |
47 | 45 | ||
48 | for(i = 0; cmds[i]; i++) | 46 | for(i = 0; cmds[i]; i++) |
49 | if (!strcmp(cmd, cmds[i])) | 47 | if (!strcmp(cmd, cmds[i])) |
50 | return i + 1; | 48 | return i + 1; |
51 | return 0; | 49 | return 0; |
52 | } | 50 | } |
53 | 51 | ||
54 | int chk_zero(int result, char *msg) | 52 | int chk_zero(int result, char *msg) |
55 | { | 53 | { |
56 | if (result != 0) | 54 | if (result != 0) |
57 | die("%s: %s", msg, strerror(errno)); | 55 | die("%s: %s", msg, strerror(errno)); |
58 | return result; | 56 | return result; |
59 | } | 57 | } |
60 | 58 | ||
61 | int chk_positive(int result, char *msg) | 59 | int chk_positive(int result, char *msg) |
62 | { | 60 | { |
63 | if (result <= 0) | 61 | if (result <= 0) |
64 | die("%s: %s", msg, strerror(errno)); | 62 | die("%s: %s", msg, strerror(errno)); |
65 | return result; | 63 | return result; |
66 | } | 64 | } |
67 | 65 | ||
68 | int chk_non_negative(int result, char *msg) | 66 | int chk_non_negative(int result, char *msg) |
69 | { | 67 | { |
70 | if (result < 0) | 68 | if (result < 0) |
71 | die("%s: %s",msg, strerror(errno)); | 69 | die("%s: %s",msg, strerror(errno)); |
72 | return result; | 70 | return result; |
73 | } | 71 | } |
74 | 72 | ||
75 | struct cgit_repo *add_repo(const char *url) | 73 | struct cgit_repo *add_repo(const char *url) |
76 | { | 74 | { |
77 | struct cgit_repo *ret; | 75 | struct cgit_repo *ret; |
78 | 76 | ||
79 | if (++cgit_repolist.count > cgit_repolist.length) { | 77 | if (++cgit_repolist.count > cgit_repolist.length) { |
80 | if (cgit_repolist.length == 0) | 78 | if (cgit_repolist.length == 0) |
81 | cgit_repolist.length = 8; | 79 | cgit_repolist.length = 8; |
82 | else | 80 | else |
83 | cgit_repolist.length *= 2; | 81 | cgit_repolist.length *= 2; |
84 | cgit_repolist.repos = xrealloc(cgit_repolist.repos, | 82 | cgit_repolist.repos = xrealloc(cgit_repolist.repos, |
85 | cgit_repolist.length * | 83 | cgit_repolist.length * |
86 | sizeof(struct cgit_repo)); | 84 | sizeof(struct cgit_repo)); |
87 | } | 85 | } |
88 | 86 | ||
89 | ret = &cgit_repolist.repos[cgit_repolist.count-1]; | 87 | ret = &cgit_repolist.repos[cgit_repolist.count-1]; |
90 | ret->url = trim_end(url, '/'); | 88 | ret->url = trim_end(url, '/'); |
91 | ret->name = ret->url; | 89 | ret->name = ret->url; |
92 | ret->path = NULL; | 90 | ret->path = NULL; |
93 | ret->desc = "[no description]"; | 91 | ret->desc = "[no description]"; |
94 | ret->owner = NULL; | 92 | ret->owner = NULL; |
95 | ret->group = ctx.cfg.repo_group; | 93 | ret->group = ctx.cfg.repo_group; |
96 | ret->defbranch = "master"; | 94 | ret->defbranch = "master"; |
97 | ret->snapshots = ctx.cfg.snapshots; | 95 | ret->snapshots = ctx.cfg.snapshots; |
98 | ret->enable_log_filecount = ctx.cfg.enable_log_filecount; | 96 | ret->enable_log_filecount = ctx.cfg.enable_log_filecount; |
99 | ret->enable_log_linecount = ctx.cfg.enable_log_linecount; | 97 | ret->enable_log_linecount = ctx.cfg.enable_log_linecount; |
100 | ret->module_link = ctx.cfg.module_link; | 98 | ret->module_link = ctx.cfg.module_link; |
101 | ret->readme = NULL; | 99 | ret->readme = NULL; |
102 | return ret; | 100 | return ret; |
103 | } | 101 | } |
104 | 102 | ||
105 | struct cgit_repo *cgit_get_repoinfo(const char *url) | 103 | struct cgit_repo *cgit_get_repoinfo(const char *url) |
106 | { | 104 | { |
107 | int i; | 105 | int i; |
108 | struct cgit_repo *repo; | 106 | struct cgit_repo *repo; |
109 | 107 | ||
110 | for (i=0; i<cgit_repolist.count; i++) { | 108 | for (i=0; i<cgit_repolist.count; i++) { |
111 | repo = &cgit_repolist.repos[i]; | 109 | repo = &cgit_repolist.repos[i]; |
112 | if (!strcmp(repo->url, url)) | 110 | if (!strcmp(repo->url, url)) |
113 | return repo; | 111 | return repo; |
114 | } | 112 | } |
@@ -1,31 +1,40 @@ | |||
1 | /* ui-blob.c: show blob content | ||
2 | * | ||
3 | * Copyright (C) 2008 Lars Hjemli | ||
4 | * | ||
5 | * Licensed under GNU General Public License v2 | ||
6 | * (see COPYING for full license text) | ||
7 | */ | ||
8 | |||
1 | #include "cgit.h" | 9 | #include "cgit.h" |
10 | #include "html.h" | ||
2 | 11 | ||
3 | void cgit_print_blob(struct cacheitem *item, const char *hex, char *path) | 12 | void cgit_print_blob(struct cacheitem *item, const char *hex, char *path) |
4 | { | 13 | { |
5 | 14 | ||
6 | unsigned char sha1[20]; | 15 | unsigned char sha1[20]; |
7 | enum object_type type; | 16 | enum object_type type; |
8 | unsigned char *buf; | 17 | unsigned char *buf; |
9 | unsigned long size; | 18 | unsigned long size; |
10 | 19 | ||
11 | if (get_sha1_hex(hex, sha1)){ | 20 | if (get_sha1_hex(hex, sha1)){ |
12 | cgit_print_error(fmt("Bad hex value: %s", hex)); | 21 | cgit_print_error(fmt("Bad hex value: %s", hex)); |
13 | return; | 22 | return; |
14 | } | 23 | } |
15 | 24 | ||
16 | type = sha1_object_info(sha1, &size); | 25 | type = sha1_object_info(sha1, &size); |
17 | if (type == OBJ_BAD) { | 26 | if (type == OBJ_BAD) { |
18 | cgit_print_error(fmt("Bad object name: %s", hex)); | 27 | cgit_print_error(fmt("Bad object name: %s", hex)); |
19 | return; | 28 | return; |
20 | } | 29 | } |
21 | 30 | ||
22 | buf = read_sha1_file(sha1, &type, &size); | 31 | buf = read_sha1_file(sha1, &type, &size); |
23 | if (!buf) { | 32 | if (!buf) { |
24 | cgit_print_error(fmt("Error reading object %s", hex)); | 33 | cgit_print_error(fmt("Error reading object %s", hex)); |
25 | return; | 34 | return; |
26 | } | 35 | } |
27 | 36 | ||
28 | buf[size] = '\0'; | 37 | buf[size] = '\0'; |
29 | cgit_print_snapshot_start("text/plain", path, item); | 38 | cgit_print_snapshot_start("text/plain", path, item); |
30 | write(htmlfd, buf, size); | 39 | write(htmlfd, buf, size); |
31 | } | 40 | } |
diff --git a/ui-commit.c b/ui-commit.c index 25721ca..ed25824 100644 --- a/ui-commit.c +++ b/ui-commit.c | |||
@@ -1,170 +1,171 @@ | |||
1 | /* ui-commit.c: generate commit view | 1 | /* ui-commit.c: generate commit view |
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 | #include "html.h" | ||
10 | 11 | ||
11 | static int files, slots; | 12 | static int files, slots; |
12 | static int total_adds, total_rems, max_changes; | 13 | static int total_adds, total_rems, max_changes; |
13 | static int lines_added, lines_removed; | 14 | static int lines_added, lines_removed; |
14 | static char *curr_rev; | 15 | static char *curr_rev; |
15 | 16 | ||
16 | static struct fileinfo { | 17 | static struct fileinfo { |
17 | char status; | 18 | char status; |
18 | unsigned char old_sha1[20]; | 19 | unsigned char old_sha1[20]; |
19 | unsigned char new_sha1[20]; | 20 | unsigned char new_sha1[20]; |
20 | unsigned short old_mode; | 21 | unsigned short old_mode; |
21 | unsigned short new_mode; | 22 | unsigned short new_mode; |
22 | char *old_path; | 23 | char *old_path; |
23 | char *new_path; | 24 | char *new_path; |
24 | unsigned int added; | 25 | unsigned int added; |
25 | unsigned int removed; | 26 | unsigned int removed; |
26 | } *items; | 27 | } *items; |
27 | 28 | ||
28 | 29 | ||
29 | void print_fileinfo(struct fileinfo *info) | 30 | void print_fileinfo(struct fileinfo *info) |
30 | { | 31 | { |
31 | char *class; | 32 | char *class; |
32 | 33 | ||
33 | switch (info->status) { | 34 | switch (info->status) { |
34 | case DIFF_STATUS_ADDED: | 35 | case DIFF_STATUS_ADDED: |
35 | class = "add"; | 36 | class = "add"; |
36 | break; | 37 | break; |
37 | case DIFF_STATUS_COPIED: | 38 | case DIFF_STATUS_COPIED: |
38 | class = "cpy"; | 39 | class = "cpy"; |
39 | break; | 40 | break; |
40 | case DIFF_STATUS_DELETED: | 41 | case DIFF_STATUS_DELETED: |
41 | class = "del"; | 42 | class = "del"; |
42 | break; | 43 | break; |
43 | case DIFF_STATUS_MODIFIED: | 44 | case DIFF_STATUS_MODIFIED: |
44 | class = "upd"; | 45 | class = "upd"; |
45 | break; | 46 | break; |
46 | case DIFF_STATUS_RENAMED: | 47 | case DIFF_STATUS_RENAMED: |
47 | class = "mov"; | 48 | class = "mov"; |
48 | break; | 49 | break; |
49 | case DIFF_STATUS_TYPE_CHANGED: | 50 | case DIFF_STATUS_TYPE_CHANGED: |
50 | class = "typ"; | 51 | class = "typ"; |
51 | break; | 52 | break; |
52 | case DIFF_STATUS_UNKNOWN: | 53 | case DIFF_STATUS_UNKNOWN: |
53 | class = "unk"; | 54 | class = "unk"; |
54 | break; | 55 | break; |
55 | case DIFF_STATUS_UNMERGED: | 56 | case DIFF_STATUS_UNMERGED: |
56 | class = "stg"; | 57 | class = "stg"; |
57 | break; | 58 | break; |
58 | default: | 59 | default: |
59 | die("bug: unhandled diff status %c", info->status); | 60 | die("bug: unhandled diff status %c", info->status); |
60 | } | 61 | } |
61 | 62 | ||
62 | html("<tr>"); | 63 | html("<tr>"); |
63 | htmlf("<td class='mode'>"); | 64 | htmlf("<td class='mode'>"); |
64 | if (is_null_sha1(info->new_sha1)) { | 65 | if (is_null_sha1(info->new_sha1)) { |
65 | html_filemode(info->old_mode); | 66 | cgit_print_filemode(info->old_mode); |
66 | } else { | 67 | } else { |
67 | html_filemode(info->new_mode); | 68 | cgit_print_filemode(info->new_mode); |
68 | } | 69 | } |
69 | 70 | ||
70 | if (info->old_mode != info->new_mode && | 71 | if (info->old_mode != info->new_mode && |
71 | !is_null_sha1(info->old_sha1) && | 72 | !is_null_sha1(info->old_sha1) && |
72 | !is_null_sha1(info->new_sha1)) { | 73 | !is_null_sha1(info->new_sha1)) { |
73 | html("<span class='modechange'>["); | 74 | html("<span class='modechange'>["); |
74 | html_filemode(info->old_mode); | 75 | cgit_print_filemode(info->old_mode); |
75 | html("]</span>"); | 76 | html("]</span>"); |
76 | } | 77 | } |
77 | htmlf("</td><td class='%s'>", class); | 78 | htmlf("</td><td class='%s'>", class); |
78 | cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, curr_rev, | 79 | cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, curr_rev, |
79 | NULL, info->new_path); | 80 | NULL, info->new_path); |
80 | if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED) | 81 | if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED) |
81 | htmlf(" (%s from %s)", | 82 | htmlf(" (%s from %s)", |
82 | info->status == DIFF_STATUS_COPIED ? "copied" : "renamed", | 83 | info->status == DIFF_STATUS_COPIED ? "copied" : "renamed", |
83 | info->old_path); | 84 | info->old_path); |
84 | html("</td><td class='right'>"); | 85 | html("</td><td class='right'>"); |
85 | htmlf("%d", info->added + info->removed); | 86 | htmlf("%d", info->added + info->removed); |
86 | html("</td><td class='graph'>"); | 87 | html("</td><td class='graph'>"); |
87 | htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes)); | 88 | htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes)); |
88 | htmlf("<td class='add' style='width: %.1f%%;'/>", | 89 | htmlf("<td class='add' style='width: %.1f%%;'/>", |
89 | info->added * 100.0 / max_changes); | 90 | info->added * 100.0 / max_changes); |
90 | htmlf("<td class='rem' style='width: %.1f%%;'/>", | 91 | htmlf("<td class='rem' style='width: %.1f%%;'/>", |
91 | info->removed * 100.0 / max_changes); | 92 | info->removed * 100.0 / max_changes); |
92 | htmlf("<td class='none' style='width: %.1f%%;'/>", | 93 | htmlf("<td class='none' style='width: %.1f%%;'/>", |
93 | (max_changes - info->removed - info->added) * 100.0 / max_changes); | 94 | (max_changes - info->removed - info->added) * 100.0 / max_changes); |
94 | html("</tr></table></td></tr>\n"); | 95 | html("</tr></table></td></tr>\n"); |
95 | } | 96 | } |
96 | 97 | ||
97 | void cgit_count_diff_lines(char *line, int len) | 98 | void cgit_count_diff_lines(char *line, int len) |
98 | { | 99 | { |
99 | if (line && (len > 0)) { | 100 | if (line && (len > 0)) { |
100 | if (line[0] == '+') | 101 | if (line[0] == '+') |
101 | lines_added++; | 102 | lines_added++; |
102 | else if (line[0] == '-') | 103 | else if (line[0] == '-') |
103 | lines_removed++; | 104 | lines_removed++; |
104 | } | 105 | } |
105 | } | 106 | } |
106 | 107 | ||
107 | void inspect_filepair(struct diff_filepair *pair) | 108 | void inspect_filepair(struct diff_filepair *pair) |
108 | { | 109 | { |
109 | files++; | 110 | files++; |
110 | lines_added = 0; | 111 | lines_added = 0; |
111 | lines_removed = 0; | 112 | lines_removed = 0; |
112 | cgit_diff_files(pair->one->sha1, pair->two->sha1, cgit_count_diff_lines); | 113 | cgit_diff_files(pair->one->sha1, pair->two->sha1, cgit_count_diff_lines); |
113 | if (files >= slots) { | 114 | if (files >= slots) { |
114 | if (slots == 0) | 115 | if (slots == 0) |
115 | slots = 4; | 116 | slots = 4; |
116 | else | 117 | else |
117 | slots = slots * 2; | 118 | slots = slots * 2; |
118 | items = xrealloc(items, slots * sizeof(struct fileinfo)); | 119 | items = xrealloc(items, slots * sizeof(struct fileinfo)); |
119 | } | 120 | } |
120 | items[files-1].status = pair->status; | 121 | items[files-1].status = pair->status; |
121 | hashcpy(items[files-1].old_sha1, pair->one->sha1); | 122 | hashcpy(items[files-1].old_sha1, pair->one->sha1); |
122 | hashcpy(items[files-1].new_sha1, pair->two->sha1); | 123 | hashcpy(items[files-1].new_sha1, pair->two->sha1); |
123 | items[files-1].old_mode = pair->one->mode; | 124 | items[files-1].old_mode = pair->one->mode; |
124 | items[files-1].new_mode = pair->two->mode; | 125 | items[files-1].new_mode = pair->two->mode; |
125 | items[files-1].old_path = xstrdup(pair->one->path); | 126 | items[files-1].old_path = xstrdup(pair->one->path); |
126 | items[files-1].new_path = xstrdup(pair->two->path); | 127 | items[files-1].new_path = xstrdup(pair->two->path); |
127 | items[files-1].added = lines_added; | 128 | items[files-1].added = lines_added; |
128 | items[files-1].removed = lines_removed; | 129 | items[files-1].removed = lines_removed; |
129 | if (lines_added + lines_removed > max_changes) | 130 | if (lines_added + lines_removed > max_changes) |
130 | max_changes = lines_added + lines_removed; | 131 | max_changes = lines_added + lines_removed; |
131 | total_adds += lines_added; | 132 | total_adds += lines_added; |
132 | total_rems += lines_removed; | 133 | total_rems += lines_removed; |
133 | } | 134 | } |
134 | 135 | ||
135 | 136 | ||
136 | void cgit_print_commit(char *hex) | 137 | void cgit_print_commit(char *hex) |
137 | { | 138 | { |
138 | struct commit *commit, *parent; | 139 | struct commit *commit, *parent; |
139 | struct commitinfo *info; | 140 | struct commitinfo *info; |
140 | struct commit_list *p; | 141 | struct commit_list *p; |
141 | unsigned char sha1[20]; | 142 | unsigned char sha1[20]; |
142 | char *tmp; | 143 | char *tmp; |
143 | int i; | 144 | int i; |
144 | 145 | ||
145 | if (!hex) | 146 | if (!hex) |
146 | hex = ctx.qry.head; | 147 | hex = ctx.qry.head; |
147 | curr_rev = hex; | 148 | curr_rev = hex; |
148 | 149 | ||
149 | if (get_sha1(hex, sha1)) { | 150 | if (get_sha1(hex, sha1)) { |
150 | cgit_print_error(fmt("Bad object id: %s", hex)); | 151 | cgit_print_error(fmt("Bad object id: %s", hex)); |
151 | return; | 152 | return; |
152 | } | 153 | } |
153 | commit = lookup_commit_reference(sha1); | 154 | commit = lookup_commit_reference(sha1); |
154 | if (!commit) { | 155 | if (!commit) { |
155 | cgit_print_error(fmt("Bad commit reference: %s", hex)); | 156 | cgit_print_error(fmt("Bad commit reference: %s", hex)); |
156 | return; | 157 | return; |
157 | } | 158 | } |
158 | info = cgit_parse_commit(commit); | 159 | info = cgit_parse_commit(commit); |
159 | 160 | ||
160 | html("<table summary='commit info' class='commit-info'>\n"); | 161 | html("<table summary='commit info' class='commit-info'>\n"); |
161 | html("<tr><th>author</th><td>"); | 162 | html("<tr><th>author</th><td>"); |
162 | html_txt(info->author); | 163 | html_txt(info->author); |
163 | html(" "); | 164 | html(" "); |
164 | html_txt(info->author_email); | 165 | html_txt(info->author_email); |
165 | html("</td><td class='right'>"); | 166 | html("</td><td class='right'>"); |
166 | cgit_print_date(info->author_date, FMT_LONGDATE); | 167 | cgit_print_date(info->author_date, FMT_LONGDATE); |
167 | html("</td></tr>\n"); | 168 | html("</td></tr>\n"); |
168 | html("<tr><th>committer</th><td>"); | 169 | html("<tr><th>committer</th><td>"); |
169 | html_txt(info->committer); | 170 | html_txt(info->committer); |
170 | html(" "); | 171 | html(" "); |
@@ -1,106 +1,106 @@ | |||
1 | /* ui-diff.c: show diff between two blobs | 1 | /* ui-diff.c: show diff between two blobs |
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 | #include "html.h" | |
11 | 11 | ||
12 | unsigned char old_rev_sha1[20]; | 12 | unsigned char old_rev_sha1[20]; |
13 | unsigned char new_rev_sha1[20]; | 13 | unsigned char new_rev_sha1[20]; |
14 | 14 | ||
15 | /* | 15 | /* |
16 | * print a single line returned from xdiff | 16 | * print a single line returned from xdiff |
17 | */ | 17 | */ |
18 | static void print_line(char *line, int len) | 18 | static void print_line(char *line, int len) |
19 | { | 19 | { |
20 | char *class = "ctx"; | 20 | char *class = "ctx"; |
21 | char c = line[len-1]; | 21 | char c = line[len-1]; |
22 | 22 | ||
23 | if (line[0] == '+') | 23 | if (line[0] == '+') |
24 | class = "add"; | 24 | class = "add"; |
25 | else if (line[0] == '-') | 25 | else if (line[0] == '-') |
26 | class = "del"; | 26 | class = "del"; |
27 | else if (line[0] == '@') | 27 | else if (line[0] == '@') |
28 | class = "hunk"; | 28 | class = "hunk"; |
29 | 29 | ||
30 | htmlf("<div class='%s'>", class); | 30 | htmlf("<div class='%s'>", class); |
31 | line[len-1] = '\0'; | 31 | line[len-1] = '\0'; |
32 | html_txt(line); | 32 | html_txt(line); |
33 | html("</div>"); | 33 | html("</div>"); |
34 | line[len-1] = c; | 34 | line[len-1] = c; |
35 | } | 35 | } |
36 | 36 | ||
37 | static void header(unsigned char *sha1, char *path1, int mode1, | 37 | static void header(unsigned char *sha1, char *path1, int mode1, |
38 | unsigned char *sha2, char *path2, int mode2) | 38 | unsigned char *sha2, char *path2, int mode2) |
39 | { | 39 | { |
40 | char *abbrev1, *abbrev2; | 40 | char *abbrev1, *abbrev2; |
41 | int subproject; | 41 | int subproject; |
42 | 42 | ||
43 | subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); | 43 | subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); |
44 | html("<div class='head'>"); | 44 | html("<div class='head'>"); |
45 | html("diff --git a/"); | 45 | html("diff --git a/"); |
46 | html_txt(path1); | 46 | html_txt(path1); |
47 | html(" b/"); | 47 | html(" b/"); |
48 | html_txt(path2); | 48 | html_txt(path2); |
49 | 49 | ||
50 | if (is_null_sha1(sha1)) | 50 | if (is_null_sha1(sha1)) |
51 | path1 = "dev/null"; | 51 | path1 = "dev/null"; |
52 | if (is_null_sha1(sha2)) | 52 | if (is_null_sha1(sha2)) |
53 | path2 = "dev/null"; | 53 | path2 = "dev/null"; |
54 | 54 | ||
55 | if (mode1 == 0) | 55 | if (mode1 == 0) |
56 | htmlf("<br/>new file mode %.6o", mode2); | 56 | htmlf("<br/>new file mode %.6o", mode2); |
57 | 57 | ||
58 | if (mode2 == 0) | 58 | if (mode2 == 0) |
59 | htmlf("<br/>deleted file mode %.6o", mode1); | 59 | htmlf("<br/>deleted file mode %.6o", mode1); |
60 | 60 | ||
61 | if (!subproject) { | 61 | if (!subproject) { |
62 | abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); | 62 | abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); |
63 | abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); | 63 | abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); |
64 | htmlf("<br/>index %s..%s", abbrev1, abbrev2); | 64 | htmlf("<br/>index %s..%s", abbrev1, abbrev2); |
65 | free(abbrev1); | 65 | free(abbrev1); |
66 | free(abbrev2); | 66 | free(abbrev2); |
67 | if (mode1 != 0 && mode2 != 0) { | 67 | if (mode1 != 0 && mode2 != 0) { |
68 | htmlf(" %.6o", mode1); | 68 | htmlf(" %.6o", mode1); |
69 | if (mode2 != mode1) | 69 | if (mode2 != mode1) |
70 | htmlf("..%.6o", mode2); | 70 | htmlf("..%.6o", mode2); |
71 | } | 71 | } |
72 | html("<br/>--- a/"); | 72 | html("<br/>--- a/"); |
73 | if (mode1 != 0) | 73 | if (mode1 != 0) |
74 | cgit_tree_link(path1, NULL, NULL, ctx.qry.head, | 74 | cgit_tree_link(path1, NULL, NULL, ctx.qry.head, |
75 | sha1_to_hex(old_rev_sha1), path1); | 75 | sha1_to_hex(old_rev_sha1), path1); |
76 | else | 76 | else |
77 | html_txt(path1); | 77 | html_txt(path1); |
78 | html("<br/>+++ b/"); | 78 | html("<br/>+++ b/"); |
79 | if (mode2 != 0) | 79 | if (mode2 != 0) |
80 | cgit_tree_link(path2, NULL, NULL, ctx.qry.head, | 80 | cgit_tree_link(path2, NULL, NULL, ctx.qry.head, |
81 | sha1_to_hex(new_rev_sha1), path2); | 81 | sha1_to_hex(new_rev_sha1), path2); |
82 | else | 82 | else |
83 | html_txt(path2); | 83 | html_txt(path2); |
84 | } | 84 | } |
85 | html("</div>"); | 85 | html("</div>"); |
86 | } | 86 | } |
87 | 87 | ||
88 | static void filepair_cb(struct diff_filepair *pair) | 88 | static void filepair_cb(struct diff_filepair *pair) |
89 | { | 89 | { |
90 | header(pair->one->sha1, pair->one->path, pair->one->mode, | 90 | header(pair->one->sha1, pair->one->path, pair->one->mode, |
91 | pair->two->sha1, pair->two->path, pair->two->mode); | 91 | pair->two->sha1, pair->two->path, pair->two->mode); |
92 | if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { | 92 | if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { |
93 | if (S_ISGITLINK(pair->one->mode)) | 93 | if (S_ISGITLINK(pair->one->mode)) |
94 | print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); | 94 | print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); |
95 | if (S_ISGITLINK(pair->two->mode)) | 95 | if (S_ISGITLINK(pair->two->mode)) |
96 | print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); | 96 | print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); |
97 | return; | 97 | return; |
98 | } | 98 | } |
99 | if (cgit_diff_files(pair->one->sha1, pair->two->sha1, print_line)) | 99 | if (cgit_diff_files(pair->one->sha1, pair->two->sha1, print_line)) |
100 | cgit_print_error("Error running diff"); | 100 | cgit_print_error("Error running diff"); |
101 | } | 101 | } |
102 | 102 | ||
103 | void cgit_print_diff(const char *new_rev, const char *old_rev, const char *prefix) | 103 | void cgit_print_diff(const char *new_rev, const char *old_rev, const char *prefix) |
104 | { | 104 | { |
105 | enum object_type type; | 105 | enum object_type type; |
106 | unsigned long size; | 106 | unsigned long size; |
@@ -1,105 +1,106 @@ | |||
1 | /* ui-log.c: functions for log output | 1 | /* ui-log.c: functions for log output |
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 | #include "html.h" | ||
10 | 11 | ||
11 | int files, add_lines, rem_lines; | 12 | int files, add_lines, rem_lines; |
12 | 13 | ||
13 | void count_lines(char *line, int size) | 14 | void count_lines(char *line, int size) |
14 | { | 15 | { |
15 | if (size <= 0) | 16 | if (size <= 0) |
16 | return; | 17 | return; |
17 | 18 | ||
18 | if (line[0] == '+') | 19 | if (line[0] == '+') |
19 | add_lines++; | 20 | add_lines++; |
20 | 21 | ||
21 | else if (line[0] == '-') | 22 | else if (line[0] == '-') |
22 | rem_lines++; | 23 | rem_lines++; |
23 | } | 24 | } |
24 | 25 | ||
25 | void inspect_files(struct diff_filepair *pair) | 26 | void inspect_files(struct diff_filepair *pair) |
26 | { | 27 | { |
27 | files++; | 28 | files++; |
28 | if (ctx.repo->enable_log_linecount) | 29 | if (ctx.repo->enable_log_linecount) |
29 | cgit_diff_files(pair->one->sha1, pair->two->sha1, count_lines); | 30 | cgit_diff_files(pair->one->sha1, pair->two->sha1, count_lines); |
30 | } | 31 | } |
31 | 32 | ||
32 | void print_commit(struct commit *commit) | 33 | void print_commit(struct commit *commit) |
33 | { | 34 | { |
34 | struct commitinfo *info; | 35 | struct commitinfo *info; |
35 | 36 | ||
36 | info = cgit_parse_commit(commit); | 37 | info = cgit_parse_commit(commit); |
37 | html("<tr><td>"); | 38 | html("<tr><td>"); |
38 | cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE); | 39 | cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE); |
39 | html("</td><td>"); | 40 | html("</td><td>"); |
40 | cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head, | 41 | cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head, |
41 | sha1_to_hex(commit->object.sha1)); | 42 | sha1_to_hex(commit->object.sha1)); |
42 | if (ctx.repo->enable_log_filecount) { | 43 | if (ctx.repo->enable_log_filecount) { |
43 | files = 0; | 44 | files = 0; |
44 | add_lines = 0; | 45 | add_lines = 0; |
45 | rem_lines = 0; | 46 | rem_lines = 0; |
46 | cgit_diff_commit(commit, inspect_files); | 47 | cgit_diff_commit(commit, inspect_files); |
47 | html("</td><td class='right'>"); | 48 | html("</td><td class='right'>"); |
48 | htmlf("%d", files); | 49 | htmlf("%d", files); |
49 | if (ctx.repo->enable_log_linecount) { | 50 | if (ctx.repo->enable_log_linecount) { |
50 | html("</td><td class='right'>"); | 51 | html("</td><td class='right'>"); |
51 | htmlf("-%d/+%d", rem_lines, add_lines); | 52 | htmlf("-%d/+%d", rem_lines, add_lines); |
52 | } | 53 | } |
53 | } | 54 | } |
54 | html("</td><td>"); | 55 | html("</td><td>"); |
55 | html_txt(info->author); | 56 | html_txt(info->author); |
56 | html("</td></tr>\n"); | 57 | html("</td></tr>\n"); |
57 | cgit_free_commitinfo(info); | 58 | cgit_free_commitinfo(info); |
58 | } | 59 | } |
59 | 60 | ||
60 | 61 | ||
61 | void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern, char *path, int pager) | 62 | void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern, char *path, int pager) |
62 | { | 63 | { |
63 | struct rev_info rev; | 64 | struct rev_info rev; |
64 | struct commit *commit; | 65 | struct commit *commit; |
65 | const char *argv[] = {NULL, tip, NULL, NULL, NULL}; | 66 | const char *argv[] = {NULL, tip, NULL, NULL, NULL}; |
66 | int argc = 2; | 67 | int argc = 2; |
67 | int i; | 68 | int i; |
68 | 69 | ||
69 | if (!tip) | 70 | if (!tip) |
70 | argv[1] = ctx.qry.head; | 71 | argv[1] = ctx.qry.head; |
71 | 72 | ||
72 | if (grep && pattern && (!strcmp(grep, "grep") || | 73 | if (grep && pattern && (!strcmp(grep, "grep") || |
73 | !strcmp(grep, "author") || | 74 | !strcmp(grep, "author") || |
74 | !strcmp(grep, "committer"))) | 75 | !strcmp(grep, "committer"))) |
75 | argv[argc++] = fmt("--%s=%s", grep, pattern); | 76 | argv[argc++] = fmt("--%s=%s", grep, pattern); |
76 | 77 | ||
77 | if (path) { | 78 | if (path) { |
78 | argv[argc++] = "--"; | 79 | argv[argc++] = "--"; |
79 | argv[argc++] = path; | 80 | argv[argc++] = path; |
80 | } | 81 | } |
81 | init_revisions(&rev, NULL); | 82 | init_revisions(&rev, NULL); |
82 | rev.abbrev = DEFAULT_ABBREV; | 83 | rev.abbrev = DEFAULT_ABBREV; |
83 | rev.commit_format = CMIT_FMT_DEFAULT; | 84 | rev.commit_format = CMIT_FMT_DEFAULT; |
84 | rev.verbose_header = 1; | 85 | rev.verbose_header = 1; |
85 | rev.show_root_diff = 0; | 86 | rev.show_root_diff = 0; |
86 | setup_revisions(argc, argv, &rev, NULL); | 87 | setup_revisions(argc, argv, &rev, NULL); |
87 | if (rev.grep_filter) { | 88 | if (rev.grep_filter) { |
88 | rev.grep_filter->regflags |= REG_ICASE; | 89 | rev.grep_filter->regflags |= REG_ICASE; |
89 | compile_grep_patterns(rev.grep_filter); | 90 | compile_grep_patterns(rev.grep_filter); |
90 | } | 91 | } |
91 | prepare_revision_walk(&rev); | 92 | prepare_revision_walk(&rev); |
92 | 93 | ||
93 | html("<table summary='log' class='list nowrap'>"); | 94 | html("<table summary='log' class='list nowrap'>"); |
94 | html("<tr class='nohover'><th class='left'>Age</th>" | 95 | html("<tr class='nohover'><th class='left'>Age</th>" |
95 | "<th class='left'>Message</th>"); | 96 | "<th class='left'>Message</th>"); |
96 | 97 | ||
97 | if (ctx.repo->enable_log_filecount) { | 98 | if (ctx.repo->enable_log_filecount) { |
98 | html("<th class='right'>Files</th>"); | 99 | html("<th class='right'>Files</th>"); |
99 | if (ctx.repo->enable_log_linecount) | 100 | if (ctx.repo->enable_log_linecount) |
100 | html("<th class='right'>Lines</th>"); | 101 | html("<th class='right'>Lines</th>"); |
101 | } | 102 | } |
102 | html("<th class='left'>Author</th></tr>\n"); | 103 | html("<th class='left'>Author</th></tr>\n"); |
103 | 104 | ||
104 | if (ofs<0) | 105 | if (ofs<0) |
105 | ofs = 0; | 106 | ofs = 0; |
@@ -1,105 +1,106 @@ | |||
1 | /* ui-patch.c: generate patch view | 1 | /* ui-patch.c: generate patch view |
2 | * | 2 | * |
3 | * Copyright (C) 2007 Lars Hjemli | 3 | * Copyright (C) 2007 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 | 11 | ||
11 | static void print_line(char *line, int len) | 12 | static void print_line(char *line, int len) |
12 | { | 13 | { |
13 | char c = line[len-1]; | 14 | char c = line[len-1]; |
14 | 15 | ||
15 | line[len-1] = '\0'; | 16 | line[len-1] = '\0'; |
16 | htmlf("%s\n", line); | 17 | htmlf("%s\n", line); |
17 | line[len-1] = c; | 18 | line[len-1] = c; |
18 | } | 19 | } |
19 | 20 | ||
20 | static void header(unsigned char *sha1, char *path1, int mode1, | 21 | static void header(unsigned char *sha1, char *path1, int mode1, |
21 | unsigned char *sha2, char *path2, int mode2) | 22 | unsigned char *sha2, char *path2, int mode2) |
22 | { | 23 | { |
23 | char *abbrev1, *abbrev2; | 24 | char *abbrev1, *abbrev2; |
24 | int subproject; | 25 | int subproject; |
25 | 26 | ||
26 | subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); | 27 | subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); |
27 | htmlf("diff --git a/%s b/%s\n", path1, path2); | 28 | htmlf("diff --git a/%s b/%s\n", path1, path2); |
28 | 29 | ||
29 | if (is_null_sha1(sha1)) | 30 | if (is_null_sha1(sha1)) |
30 | path1 = "dev/null"; | 31 | path1 = "dev/null"; |
31 | if (is_null_sha1(sha2)) | 32 | if (is_null_sha1(sha2)) |
32 | path2 = "dev/null"; | 33 | path2 = "dev/null"; |
33 | 34 | ||
34 | if (mode1 == 0) | 35 | if (mode1 == 0) |
35 | htmlf("new file mode %.6o\n", mode2); | 36 | htmlf("new file mode %.6o\n", mode2); |
36 | 37 | ||
37 | if (mode2 == 0) | 38 | if (mode2 == 0) |
38 | htmlf("deleted file mode %.6o\n", mode1); | 39 | htmlf("deleted file mode %.6o\n", mode1); |
39 | 40 | ||
40 | if (!subproject) { | 41 | if (!subproject) { |
41 | abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); | 42 | abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); |
42 | abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); | 43 | abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); |
43 | htmlf("index %s..%s", abbrev1, abbrev2); | 44 | htmlf("index %s..%s", abbrev1, abbrev2); |
44 | free(abbrev1); | 45 | free(abbrev1); |
45 | free(abbrev2); | 46 | free(abbrev2); |
46 | if (mode1 != 0 && mode2 != 0) { | 47 | if (mode1 != 0 && mode2 != 0) { |
47 | htmlf(" %.6o", mode1); | 48 | htmlf(" %.6o", mode1); |
48 | if (mode2 != mode1) | 49 | if (mode2 != mode1) |
49 | htmlf("..%.6o", mode2); | 50 | htmlf("..%.6o", mode2); |
50 | } | 51 | } |
51 | htmlf("\n--- a/%s\n", path1); | 52 | htmlf("\n--- a/%s\n", path1); |
52 | htmlf("+++ b/%s\n", path2); | 53 | htmlf("+++ b/%s\n", path2); |
53 | } | 54 | } |
54 | } | 55 | } |
55 | 56 | ||
56 | static void filepair_cb(struct diff_filepair *pair) | 57 | static void filepair_cb(struct diff_filepair *pair) |
57 | { | 58 | { |
58 | header(pair->one->sha1, pair->one->path, pair->one->mode, | 59 | header(pair->one->sha1, pair->one->path, pair->one->mode, |
59 | pair->two->sha1, pair->two->path, pair->two->mode); | 60 | pair->two->sha1, pair->two->path, pair->two->mode); |
60 | if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { | 61 | if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { |
61 | if (S_ISGITLINK(pair->one->mode)) | 62 | if (S_ISGITLINK(pair->one->mode)) |
62 | print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); | 63 | print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); |
63 | if (S_ISGITLINK(pair->two->mode)) | 64 | if (S_ISGITLINK(pair->two->mode)) |
64 | print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); | 65 | print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); |
65 | return; | 66 | return; |
66 | } | 67 | } |
67 | if (cgit_diff_files(pair->one->sha1, pair->two->sha1, print_line)) | 68 | if (cgit_diff_files(pair->one->sha1, pair->two->sha1, print_line)) |
68 | html("Error running diff"); | 69 | html("Error running diff"); |
69 | } | 70 | } |
70 | 71 | ||
71 | void cgit_print_patch(char *hex, struct cacheitem *item) | 72 | void cgit_print_patch(char *hex, struct cacheitem *item) |
72 | { | 73 | { |
73 | struct commit *commit; | 74 | struct commit *commit; |
74 | struct commitinfo *info; | 75 | struct commitinfo *info; |
75 | unsigned char sha1[20], old_sha1[20]; | 76 | unsigned char sha1[20], old_sha1[20]; |
76 | char *patchname; | 77 | char *patchname; |
77 | 78 | ||
78 | if (!hex) | 79 | if (!hex) |
79 | hex = ctx.qry.head; | 80 | hex = ctx.qry.head; |
80 | 81 | ||
81 | if (get_sha1(hex, sha1)) { | 82 | if (get_sha1(hex, sha1)) { |
82 | cgit_print_error(fmt("Bad object id: %s", hex)); | 83 | cgit_print_error(fmt("Bad object id: %s", hex)); |
83 | return; | 84 | return; |
84 | } | 85 | } |
85 | commit = lookup_commit_reference(sha1); | 86 | commit = lookup_commit_reference(sha1); |
86 | if (!commit) { | 87 | if (!commit) { |
87 | cgit_print_error(fmt("Bad commit reference: %s", hex)); | 88 | cgit_print_error(fmt("Bad commit reference: %s", hex)); |
88 | return; | 89 | return; |
89 | } | 90 | } |
90 | info = cgit_parse_commit(commit); | 91 | info = cgit_parse_commit(commit); |
91 | hashcpy(old_sha1, commit->parents->item->object.sha1); | 92 | hashcpy(old_sha1, commit->parents->item->object.sha1); |
92 | 93 | ||
93 | patchname = fmt("%s.patch", sha1_to_hex(sha1)); | 94 | patchname = fmt("%s.patch", sha1_to_hex(sha1)); |
94 | cgit_print_snapshot_start("text/plain", patchname, item); | 95 | cgit_print_snapshot_start("text/plain", patchname, item); |
95 | htmlf("From %s Mon Sep 17 00:00:00 2001\n", sha1_to_hex(sha1)); | 96 | htmlf("From %s Mon Sep 17 00:00:00 2001\n", sha1_to_hex(sha1)); |
96 | htmlf("From: %s%s\n", info->author, info->author_email); | 97 | htmlf("From: %s%s\n", info->author, info->author_email); |
97 | html("Date: "); | 98 | html("Date: "); |
98 | cgit_print_date(info->author_date, "%a, %d %b %Y %H:%M:%S %z%n"); | 99 | cgit_print_date(info->author_date, "%a, %d %b %Y %H:%M:%S %z%n"); |
99 | htmlf("Subject: %s\n\n", info->subject); | 100 | htmlf("Subject: %s\n\n", info->subject); |
100 | if (info->msg && *info->msg) { | 101 | if (info->msg && *info->msg) { |
101 | htmlf("%s", info->msg); | 102 | htmlf("%s", info->msg); |
102 | if (info->msg[strlen(info->msg) - 1] != '\n') | 103 | if (info->msg[strlen(info->msg) - 1] != '\n') |
103 | html("\n"); | 104 | html("\n"); |
104 | } | 105 | } |
105 | html("---\n"); | 106 | html("---\n"); |
@@ -1,30 +1,28 @@ | |||
1 | /* ui-refs.c: browse symbolic refs | 1 | /* ui-refs.c: browse symbolic refs |
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 | #include "html.h" | |
11 | |||
12 | |||
13 | 11 | ||
14 | void cgit_print_refs() | 12 | void cgit_print_refs() |
15 | { | 13 | { |
16 | 14 | ||
17 | html("<table class='list nowrap'>"); | 15 | html("<table class='list nowrap'>"); |
18 | 16 | ||
19 | if (ctx.qry.path && !strncmp(ctx.qry.path, "heads", 5)) | 17 | if (ctx.qry.path && !strncmp(ctx.qry.path, "heads", 5)) |
20 | cgit_print_branches(0); | 18 | cgit_print_branches(0); |
21 | else if (ctx.qry.path && !strncmp(ctx.qry.path, "tags", 4)) | 19 | else if (ctx.qry.path && !strncmp(ctx.qry.path, "tags", 4)) |
22 | cgit_print_tags(0); | 20 | cgit_print_tags(0); |
23 | else { | 21 | else { |
24 | cgit_print_branches(0); | 22 | cgit_print_branches(0); |
25 | html("<tr class='nohover'><td colspan='4'> </td></tr>"); | 23 | html("<tr class='nohover'><td colspan='4'> </td></tr>"); |
26 | cgit_print_tags(0); | 24 | cgit_print_tags(0); |
27 | } | 25 | } |
28 | 26 | ||
29 | html("</table>"); | 27 | html("</table>"); |
30 | } | 28 | } |
diff --git a/ui-repolist.c b/ui-repolist.c index 5fde174..cd4e41d 100644 --- a/ui-repolist.c +++ b/ui-repolist.c | |||
@@ -1,107 +1,108 @@ | |||
1 | /* ui-repolist.c: functions for generating the repolist page | 1 | /* ui-repolist.c: functions for generating the repolist page |
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" | ||
10 | #include <time.h> | 9 | #include <time.h> |
11 | 10 | ||
11 | #include "cgit.h" | ||
12 | #include "html.h" | ||
12 | 13 | ||
13 | time_t read_agefile(char *path) | 14 | time_t read_agefile(char *path) |
14 | { | 15 | { |
15 | FILE *f; | 16 | FILE *f; |
16 | static char buf[64], buf2[64]; | 17 | static char buf[64], buf2[64]; |
17 | 18 | ||
18 | if (!(f = fopen(path, "r"))) | 19 | if (!(f = fopen(path, "r"))) |
19 | return -1; | 20 | return -1; |
20 | fgets(buf, sizeof(buf), f); | 21 | fgets(buf, sizeof(buf), f); |
21 | fclose(f); | 22 | fclose(f); |
22 | if (parse_date(buf, buf2, sizeof(buf2))) | 23 | if (parse_date(buf, buf2, sizeof(buf2))) |
23 | return strtoul(buf2, NULL, 10); | 24 | return strtoul(buf2, NULL, 10); |
24 | else | 25 | else |
25 | return 0; | 26 | return 0; |
26 | } | 27 | } |
27 | 28 | ||
28 | static void print_modtime(struct cgit_repo *repo) | 29 | static void print_modtime(struct cgit_repo *repo) |
29 | { | 30 | { |
30 | char *path; | 31 | char *path; |
31 | struct stat s; | 32 | struct stat s; |
32 | 33 | ||
33 | path = fmt("%s/%s", repo->path, ctx.cfg.agefile); | 34 | path = fmt("%s/%s", repo->path, ctx.cfg.agefile); |
34 | if (stat(path, &s) == 0) { | 35 | if (stat(path, &s) == 0) { |
35 | cgit_print_age(read_agefile(path), -1, NULL); | 36 | cgit_print_age(read_agefile(path), -1, NULL); |
36 | return; | 37 | return; |
37 | } | 38 | } |
38 | 39 | ||
39 | path = fmt("%s/refs/heads/%s", repo->path, repo->defbranch); | 40 | path = fmt("%s/refs/heads/%s", repo->path, repo->defbranch); |
40 | if (stat(path, &s) != 0) | 41 | if (stat(path, &s) != 0) |
41 | return; | 42 | return; |
42 | cgit_print_age(s.st_mtime, -1, NULL); | 43 | cgit_print_age(s.st_mtime, -1, NULL); |
43 | } | 44 | } |
44 | 45 | ||
45 | void cgit_print_repolist(struct cacheitem *item) | 46 | void cgit_print_repolist(struct cacheitem *item) |
46 | { | 47 | { |
47 | int i, columns = 4; | 48 | int i, columns = 4; |
48 | char *last_group = NULL; | 49 | char *last_group = NULL; |
49 | 50 | ||
50 | if (ctx.cfg.enable_index_links) | 51 | if (ctx.cfg.enable_index_links) |
51 | columns++; | 52 | columns++; |
52 | 53 | ||
53 | cgit_print_docstart(ctx.cfg.root_title, item); | 54 | cgit_print_docstart(ctx.cfg.root_title, item); |
54 | cgit_print_pageheader(ctx.cfg.root_title, 0); | 55 | cgit_print_pageheader(ctx.cfg.root_title, 0); |
55 | 56 | ||
56 | html("<table summary='repository list' class='list nowrap'>"); | 57 | html("<table summary='repository list' class='list nowrap'>"); |
57 | if (ctx.cfg.index_header) { | 58 | if (ctx.cfg.index_header) { |
58 | htmlf("<tr class='nohover'><td colspan='%d' class='include-block'>", | 59 | htmlf("<tr class='nohover'><td colspan='%d' class='include-block'>", |
59 | columns); | 60 | columns); |
60 | html_include(ctx.cfg.index_header); | 61 | html_include(ctx.cfg.index_header); |
61 | html("</td></tr>"); | 62 | html("</td></tr>"); |
62 | } | 63 | } |
63 | html("<tr class='nohover'>" | 64 | html("<tr class='nohover'>" |
64 | "<th class='left'>Name</th>" | 65 | "<th class='left'>Name</th>" |
65 | "<th class='left'>Description</th>" | 66 | "<th class='left'>Description</th>" |
66 | "<th class='left'>Owner</th>" | 67 | "<th class='left'>Owner</th>" |
67 | "<th class='left'>Idle</th>"); | 68 | "<th class='left'>Idle</th>"); |
68 | if (ctx.cfg.enable_index_links) | 69 | if (ctx.cfg.enable_index_links) |
69 | html("<th>Links</th>"); | 70 | html("<th>Links</th>"); |
70 | html("</tr>\n"); | 71 | html("</tr>\n"); |
71 | 72 | ||
72 | for (i=0; i<cgit_repolist.count; i++) { | 73 | for (i=0; i<cgit_repolist.count; i++) { |
73 | ctx.repo = &cgit_repolist.repos[i]; | 74 | ctx.repo = &cgit_repolist.repos[i]; |
74 | if ((last_group == NULL && ctx.repo->group != NULL) || | 75 | if ((last_group == NULL && ctx.repo->group != NULL) || |
75 | (last_group != NULL && ctx.repo->group == NULL) || | 76 | (last_group != NULL && ctx.repo->group == NULL) || |
76 | (last_group != NULL && ctx.repo->group != NULL && | 77 | (last_group != NULL && ctx.repo->group != NULL && |
77 | strcmp(ctx.repo->group, last_group))) { | 78 | strcmp(ctx.repo->group, last_group))) { |
78 | htmlf("<tr class='nohover'><td colspan='%d' class='repogroup'>", | 79 | htmlf("<tr class='nohover'><td colspan='%d' class='repogroup'>", |
79 | columns); | 80 | columns); |
80 | html_txt(ctx.repo->group); | 81 | html_txt(ctx.repo->group); |
81 | html("</td></tr>"); | 82 | html("</td></tr>"); |
82 | last_group = ctx.repo->group; | 83 | last_group = ctx.repo->group; |
83 | } | 84 | } |
84 | htmlf("<tr><td class='%s'>", | 85 | htmlf("<tr><td class='%s'>", |
85 | ctx.repo->group ? "sublevel-repo" : "toplevel-repo"); | 86 | ctx.repo->group ? "sublevel-repo" : "toplevel-repo"); |
86 | html_link_open(cgit_repourl(ctx.repo->url), NULL, NULL); | 87 | html_link_open(cgit_repourl(ctx.repo->url), NULL, NULL); |
87 | html_txt(ctx.repo->name); | 88 | html_txt(ctx.repo->name); |
88 | html_link_close(); | 89 | html_link_close(); |
89 | html("</td><td>"); | 90 | html("</td><td>"); |
90 | html_ntxt(ctx.cfg.max_repodesc_len, ctx.repo->desc); | 91 | html_ntxt(ctx.cfg.max_repodesc_len, ctx.repo->desc); |
91 | html("</td><td>"); | 92 | html("</td><td>"); |
92 | html_txt(ctx.repo->owner); | 93 | html_txt(ctx.repo->owner); |
93 | html("</td><td>"); | 94 | html("</td><td>"); |
94 | print_modtime(ctx.repo); | 95 | print_modtime(ctx.repo); |
95 | html("</td>"); | 96 | html("</td>"); |
96 | if (ctx.cfg.enable_index_links) { | 97 | if (ctx.cfg.enable_index_links) { |
97 | html("<td>"); | 98 | html("<td>"); |
98 | html_link_open(cgit_repourl(ctx.repo->url), | 99 | html_link_open(cgit_repourl(ctx.repo->url), |
99 | NULL, "button"); | 100 | NULL, "button"); |
100 | html("summary</a>"); | 101 | html("summary</a>"); |
101 | cgit_log_link("log", NULL, "button", NULL, NULL, NULL, | 102 | cgit_log_link("log", NULL, "button", NULL, NULL, NULL, |
102 | 0, NULL, NULL); | 103 | 0, NULL, NULL); |
103 | cgit_tree_link("tree", NULL, "button", NULL, NULL, NULL); | 104 | cgit_tree_link("tree", NULL, "button", NULL, NULL, NULL); |
104 | html("</td>"); | 105 | html("</td>"); |
105 | } | 106 | } |
106 | html("</tr>\n"); | 107 | html("</tr>\n"); |
107 | } | 108 | } |
diff --git a/ui-shared.c b/ui-shared.c index cc1ab8b..2eff79d 100644 --- a/ui-shared.c +++ b/ui-shared.c | |||
@@ -1,105 +1,106 @@ | |||
1 | /* ui-shared.c: common web output functions | 1 | /* ui-shared.c: common web output 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 | #include "html.h" | ||
10 | 11 | ||
11 | const char cgit_doctype[] = | 12 | const char cgit_doctype[] = |
12 | "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" | 13 | "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" |
13 | " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; | 14 | " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; |
14 | 15 | ||
15 | static char *http_date(time_t t) | 16 | static char *http_date(time_t t) |
16 | { | 17 | { |
17 | static char day[][4] = | 18 | static char day[][4] = |
18 | {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; | 19 | {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; |
19 | static char month[][4] = | 20 | static char month[][4] = |
20 | {"Jan", "Feb", "Mar", "Apr", "May", "Jun", | 21 | {"Jan", "Feb", "Mar", "Apr", "May", "Jun", |
21 | "Jul", "Aug", "Sep", "Oct", "Now", "Dec"}; | 22 | "Jul", "Aug", "Sep", "Oct", "Now", "Dec"}; |
22 | struct tm *tm = gmtime(&t); | 23 | struct tm *tm = gmtime(&t); |
23 | return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday], | 24 | return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday], |
24 | tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year, | 25 | tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year, |
25 | tm->tm_hour, tm->tm_min, tm->tm_sec); | 26 | tm->tm_hour, tm->tm_min, tm->tm_sec); |
26 | } | 27 | } |
27 | 28 | ||
28 | static long ttl_seconds(long ttl) | 29 | static long ttl_seconds(long ttl) |
29 | { | 30 | { |
30 | if (ttl<0) | 31 | if (ttl<0) |
31 | return 60 * 60 * 24 * 365; | 32 | return 60 * 60 * 24 * 365; |
32 | else | 33 | else |
33 | return ttl * 60; | 34 | return ttl * 60; |
34 | } | 35 | } |
35 | 36 | ||
36 | void cgit_print_error(char *msg) | 37 | void cgit_print_error(char *msg) |
37 | { | 38 | { |
38 | html("<div class='error'>"); | 39 | html("<div class='error'>"); |
39 | html_txt(msg); | 40 | html_txt(msg); |
40 | html("</div>\n"); | 41 | html("</div>\n"); |
41 | } | 42 | } |
42 | 43 | ||
43 | char *cgit_rooturl() | 44 | char *cgit_rooturl() |
44 | { | 45 | { |
45 | if (ctx.cfg.virtual_root) | 46 | if (ctx.cfg.virtual_root) |
46 | return fmt("%s/", ctx.cfg.virtual_root); | 47 | return fmt("%s/", ctx.cfg.virtual_root); |
47 | else | 48 | else |
48 | return ctx.cfg.script_name; | 49 | return ctx.cfg.script_name; |
49 | } | 50 | } |
50 | 51 | ||
51 | char *cgit_repourl(const char *reponame) | 52 | char *cgit_repourl(const char *reponame) |
52 | { | 53 | { |
53 | if (ctx.cfg.virtual_root) { | 54 | if (ctx.cfg.virtual_root) { |
54 | return fmt("%s/%s/", ctx.cfg.virtual_root, reponame); | 55 | return fmt("%s/%s/", ctx.cfg.virtual_root, reponame); |
55 | } else { | 56 | } else { |
56 | return fmt("?r=%s", reponame); | 57 | return fmt("?r=%s", reponame); |
57 | } | 58 | } |
58 | } | 59 | } |
59 | 60 | ||
60 | char *cgit_fileurl(const char *reponame, const char *pagename, | 61 | char *cgit_fileurl(const char *reponame, const char *pagename, |
61 | const char *filename, const char *query) | 62 | const char *filename, const char *query) |
62 | { | 63 | { |
63 | char *tmp; | 64 | char *tmp; |
64 | char *delim; | 65 | char *delim; |
65 | 66 | ||
66 | if (ctx.cfg.virtual_root) { | 67 | if (ctx.cfg.virtual_root) { |
67 | tmp = fmt("%s/%s/%s/%s", ctx.cfg.virtual_root, reponame, | 68 | tmp = fmt("%s/%s/%s/%s", ctx.cfg.virtual_root, reponame, |
68 | pagename, (filename ? filename:"")); | 69 | pagename, (filename ? filename:"")); |
69 | delim = "?"; | 70 | delim = "?"; |
70 | } else { | 71 | } else { |
71 | tmp = fmt("?url=%s/%s/%s", reponame, pagename, | 72 | tmp = fmt("?url=%s/%s/%s", reponame, pagename, |
72 | (filename ? filename : "")); | 73 | (filename ? filename : "")); |
73 | delim = "&"; | 74 | delim = "&"; |
74 | } | 75 | } |
75 | if (query) | 76 | if (query) |
76 | tmp = fmt("%s%s%s", tmp, delim, query); | 77 | tmp = fmt("%s%s%s", tmp, delim, query); |
77 | return tmp; | 78 | return tmp; |
78 | } | 79 | } |
79 | 80 | ||
80 | char *cgit_pageurl(const char *reponame, const char *pagename, | 81 | char *cgit_pageurl(const char *reponame, const char *pagename, |
81 | const char *query) | 82 | const char *query) |
82 | { | 83 | { |
83 | return cgit_fileurl(reponame,pagename,0,query); | 84 | return cgit_fileurl(reponame,pagename,0,query); |
84 | } | 85 | } |
85 | 86 | ||
86 | const char *cgit_repobasename(const char *reponame) | 87 | const char *cgit_repobasename(const char *reponame) |
87 | { | 88 | { |
88 | /* I assume we don't need to store more than one repo basename */ | 89 | /* I assume we don't need to store more than one repo basename */ |
89 | static char rvbuf[1024]; | 90 | static char rvbuf[1024]; |
90 | int p; | 91 | int p; |
91 | const char *rv; | 92 | const char *rv; |
92 | strncpy(rvbuf,reponame,sizeof(rvbuf)); | 93 | strncpy(rvbuf,reponame,sizeof(rvbuf)); |
93 | if(rvbuf[sizeof(rvbuf)-1]) | 94 | if(rvbuf[sizeof(rvbuf)-1]) |
94 | die("cgit_repobasename: truncated repository name '%s'", reponame); | 95 | die("cgit_repobasename: truncated repository name '%s'", reponame); |
95 | p = strlen(rvbuf)-1; | 96 | p = strlen(rvbuf)-1; |
96 | /* strip trailing slashes */ | 97 | /* strip trailing slashes */ |
97 | while(p && rvbuf[p]=='/') rvbuf[p--]=0; | 98 | while(p && rvbuf[p]=='/') rvbuf[p--]=0; |
98 | /* strip trailing .git */ | 99 | /* strip trailing .git */ |
99 | if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) { | 100 | if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) { |
100 | p -= 3; rvbuf[p--] = 0; | 101 | p -= 3; rvbuf[p--] = 0; |
101 | } | 102 | } |
102 | /* strip more trailing slashes if any */ | 103 | /* strip more trailing slashes if any */ |
103 | while( p && rvbuf[p]=='/') rvbuf[p--]=0; | 104 | while( p && rvbuf[p]=='/') rvbuf[p--]=0; |
104 | /* find last slash in the remaining string */ | 105 | /* find last slash in the remaining string */ |
105 | rv = strrchr(rvbuf,'/'); | 106 | rv = strrchr(rvbuf,'/'); |
@@ -474,97 +475,112 @@ void cgit_print_pageheader(char *title, int show_search) | |||
474 | html("<tr><td class='sidebar'>\n<a href='"); | 475 | html("<tr><td class='sidebar'>\n<a href='"); |
475 | html_attr(cgit_rooturl()); | 476 | html_attr(cgit_rooturl()); |
476 | htmlf("'><img src='%s' alt='cgit'/></a>\n", | 477 | htmlf("'><img src='%s' alt='cgit'/></a>\n", |
477 | ctx.cfg.logo); | 478 | ctx.cfg.logo); |
478 | html("</td></tr>\n<tr><td class='sidebar'>\n"); | 479 | html("</td></tr>\n<tr><td class='sidebar'>\n"); |
479 | if (ctx.repo) { | 480 | if (ctx.repo) { |
480 | html("<h1 class='first'>"); | 481 | html("<h1 class='first'>"); |
481 | html_txt(strrpart(ctx.repo->name, 20)); | 482 | html_txt(strrpart(ctx.repo->name, 20)); |
482 | html("</h1>\n"); | 483 | html("</h1>\n"); |
483 | html_txt(ctx.repo->desc); | 484 | html_txt(ctx.repo->desc); |
484 | if (ctx.repo->owner) { | 485 | if (ctx.repo->owner) { |
485 | html("<h1>owner</h1>\n"); | 486 | html("<h1>owner</h1>\n"); |
486 | html_txt(ctx.repo->owner); | 487 | html_txt(ctx.repo->owner); |
487 | } | 488 | } |
488 | html("<h1>navigate</h1>\n"); | 489 | html("<h1>navigate</h1>\n"); |
489 | reporevlink(NULL, "summary", NULL, "menu", ctx.qry.head, | 490 | reporevlink(NULL, "summary", NULL, "menu", ctx.qry.head, |
490 | NULL, NULL); | 491 | NULL, NULL); |
491 | cgit_log_link("log", NULL, "menu", ctx.qry.head, NULL, NULL, | 492 | cgit_log_link("log", NULL, "menu", ctx.qry.head, NULL, NULL, |
492 | 0, NULL, NULL); | 493 | 0, NULL, NULL); |
493 | cgit_tree_link("tree", NULL, "menu", ctx.qry.head, | 494 | cgit_tree_link("tree", NULL, "menu", ctx.qry.head, |
494 | ctx.qry.sha1, NULL); | 495 | ctx.qry.sha1, NULL); |
495 | cgit_commit_link("commit", NULL, "menu", ctx.qry.head, | 496 | cgit_commit_link("commit", NULL, "menu", ctx.qry.head, |
496 | ctx.qry.sha1); | 497 | ctx.qry.sha1); |
497 | cgit_diff_link("diff", NULL, "menu", ctx.qry.head, | 498 | cgit_diff_link("diff", NULL, "menu", ctx.qry.head, |
498 | ctx.qry.sha1, ctx.qry.sha2, NULL); | 499 | ctx.qry.sha1, ctx.qry.sha2, NULL); |
499 | cgit_patch_link("patch", NULL, "menu", ctx.qry.head, | 500 | cgit_patch_link("patch", NULL, "menu", ctx.qry.head, |
500 | ctx.qry.sha1); | 501 | ctx.qry.sha1); |
501 | 502 | ||
502 | for_each_ref(print_archive_ref, &header); | 503 | for_each_ref(print_archive_ref, &header); |
503 | 504 | ||
504 | if (ctx.repo->clone_url || ctx.cfg.clone_prefix) { | 505 | if (ctx.repo->clone_url || ctx.cfg.clone_prefix) { |
505 | html("<h1>clone</h1>\n"); | 506 | html("<h1>clone</h1>\n"); |
506 | if (ctx.repo->clone_url) | 507 | if (ctx.repo->clone_url) |
507 | url = ctx.repo->clone_url; | 508 | url = ctx.repo->clone_url; |
508 | else | 509 | else |
509 | url = fmt("%s%s", ctx.cfg.clone_prefix, | 510 | url = fmt("%s%s", ctx.cfg.clone_prefix, |
510 | ctx.repo->url); | 511 | ctx.repo->url); |
511 | html("<a class='menu' href='"); | 512 | html("<a class='menu' href='"); |
512 | html_attr(url); | 513 | html_attr(url); |
513 | html("' title='"); | 514 | html("' title='"); |
514 | html_attr(url); | 515 | html_attr(url); |
515 | html("'>\n"); | 516 | html("'>\n"); |
516 | html_txt(strrpart(url, 20)); | 517 | html_txt(strrpart(url, 20)); |
517 | html("</a>\n"); | 518 | html("</a>\n"); |
518 | } | 519 | } |
519 | 520 | ||
520 | html("<h1>branch</h1>\n"); | 521 | html("<h1>branch</h1>\n"); |
521 | html("<form method='get' action=''>\n"); | 522 | html("<form method='get' action=''>\n"); |
522 | add_hidden_formfields(0, 1, ctx.qry.page); | 523 | add_hidden_formfields(0, 1, ctx.qry.page); |
523 | // html("<table summary='branch selector' class='grid'><tr><td id='branch-dropdown-cell'>"); | 524 | // html("<table summary='branch selector' class='grid'><tr><td id='branch-dropdown-cell'>"); |
524 | html("<select name='h' onchange='this.form.submit();'>\n"); | 525 | html("<select name='h' onchange='this.form.submit();'>\n"); |
525 | for_each_branch_ref(print_branch_option, ctx.qry.head); | 526 | for_each_branch_ref(print_branch_option, ctx.qry.head); |
526 | html("</select>\n"); | 527 | html("</select>\n"); |
527 | // html("</td><td>"); | 528 | // html("</td><td>"); |
528 | html("<noscript><input type='submit' id='switch-btn' value='switch'/></noscript>\n"); | 529 | html("<noscript><input type='submit' id='switch-btn' value='switch'/></noscript>\n"); |
529 | // html("</td></tr></table>"); | 530 | // html("</td></tr></table>"); |
530 | html("</form>\n"); | 531 | html("</form>\n"); |
531 | 532 | ||
532 | html("<h1>search</h1>\n"); | 533 | html("<h1>search</h1>\n"); |
533 | html("<form method='get' action='"); | 534 | html("<form method='get' action='"); |
534 | if (ctx.cfg.virtual_root) | 535 | if (ctx.cfg.virtual_root) |
535 | html_attr(cgit_fileurl(ctx.qry.repo, "log", | 536 | html_attr(cgit_fileurl(ctx.qry.repo, "log", |
536 | ctx.qry.path, NULL)); | 537 | ctx.qry.path, NULL)); |
537 | html("'>\n"); | 538 | html("'>\n"); |
538 | add_hidden_formfields(1, 0, "log"); | 539 | add_hidden_formfields(1, 0, "log"); |
539 | html("<select name='qt'>\n"); | 540 | html("<select name='qt'>\n"); |
540 | html_option("grep", "log msg", ctx.qry.grep); | 541 | html_option("grep", "log msg", ctx.qry.grep); |
541 | html_option("author", "author", ctx.qry.grep); | 542 | html_option("author", "author", ctx.qry.grep); |
542 | html_option("committer", "committer", ctx.qry.grep); | 543 | html_option("committer", "committer", ctx.qry.grep); |
543 | html("</select>\n"); | 544 | html("</select>\n"); |
544 | html("<input class='txt' type='text' name='q' value='"); | 545 | html("<input class='txt' type='text' name='q' value='"); |
545 | html_attr(ctx.qry.search); | 546 | html_attr(ctx.qry.search); |
546 | html("'/>\n"); | 547 | html("'/>\n"); |
547 | html("</form>\n"); | 548 | html("</form>\n"); |
548 | } else { | 549 | } else { |
549 | if (!ctx.cfg.index_info || html_include(ctx.cfg.index_info)) | 550 | if (!ctx.cfg.index_info || html_include(ctx.cfg.index_info)) |
550 | html(default_info); | 551 | html(default_info); |
551 | } | 552 | } |
552 | 553 | ||
553 | html("</td></tr></table></td>\n"); | 554 | html("</td></tr></table></td>\n"); |
554 | 555 | ||
555 | html("<td id='content'>\n"); | 556 | html("<td id='content'>\n"); |
556 | } | 557 | } |
557 | 558 | ||
558 | 559 | ||
559 | void cgit_print_snapshot_start(const char *mimetype, const char *filename, | 560 | void cgit_print_snapshot_start(const char *mimetype, const char *filename, |
560 | struct cacheitem *item) | 561 | struct cacheitem *item) |
561 | { | 562 | { |
562 | htmlf("Content-Type: %s\n", mimetype); | 563 | htmlf("Content-Type: %s\n", mimetype); |
563 | htmlf("Content-Disposition: inline; filename=\"%s\"\n", filename); | 564 | htmlf("Content-Disposition: inline; filename=\"%s\"\n", filename); |
564 | htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime)); | 565 | htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime)); |
565 | htmlf("Expires: %s\n", http_date(item->st.st_mtime + | 566 | htmlf("Expires: %s\n", http_date(item->st.st_mtime + |
566 | ttl_seconds(item->ttl))); | 567 | ttl_seconds(item->ttl))); |
567 | html("\n"); | 568 | html("\n"); |
568 | } | 569 | } |
569 | 570 | ||
571 | void cgit_print_filemode(unsigned short mode) | ||
572 | { | ||
573 | if (S_ISDIR(mode)) | ||
574 | html("d"); | ||
575 | else if (S_ISLNK(mode)) | ||
576 | html("l"); | ||
577 | else if (S_ISGITLINK(mode)) | ||
578 | html("m"); | ||
579 | else | ||
580 | html("-"); | ||
581 | html_fileperm(mode >> 6); | ||
582 | html_fileperm(mode >> 3); | ||
583 | html_fileperm(mode); | ||
584 | } | ||
585 | |||
570 | /* vim:set sw=8: */ | 586 | /* vim:set sw=8: */ |
diff --git a/ui-snapshot.c b/ui-snapshot.c index dfedd8f..67dbbdd 100644 --- a/ui-snapshot.c +++ b/ui-snapshot.c | |||
@@ -1,105 +1,106 @@ | |||
1 | /* ui-snapshot.c: generate snapshot of a commit | 1 | /* ui-snapshot.c: generate snapshot of a commit |
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 | #include "html.h" | ||
10 | 11 | ||
11 | static int write_compressed_tar_archive(struct archiver_args *args,const char *filter) | 12 | static int write_compressed_tar_archive(struct archiver_args *args,const char *filter) |
12 | { | 13 | { |
13 | int rw[2]; | 14 | int rw[2]; |
14 | pid_t gzpid; | 15 | pid_t gzpid; |
15 | int stdout2; | 16 | int stdout2; |
16 | int status; | 17 | int status; |
17 | int rv; | 18 | int rv; |
18 | 19 | ||
19 | stdout2 = chk_non_negative(dup(STDIN_FILENO), "Preserving STDOUT before compressing"); | 20 | stdout2 = chk_non_negative(dup(STDIN_FILENO), "Preserving STDOUT before compressing"); |
20 | chk_zero(pipe(rw), "Opening pipe from compressor subprocess"); | 21 | chk_zero(pipe(rw), "Opening pipe from compressor subprocess"); |
21 | gzpid = chk_non_negative(fork(), "Forking compressor subprocess"); | 22 | gzpid = chk_non_negative(fork(), "Forking compressor subprocess"); |
22 | if(gzpid==0) { | 23 | if(gzpid==0) { |
23 | /* child */ | 24 | /* child */ |
24 | chk_zero(close(rw[1]), "Closing write end of pipe in child"); | 25 | chk_zero(close(rw[1]), "Closing write end of pipe in child"); |
25 | chk_zero(close(STDIN_FILENO), "Closing STDIN"); | 26 | chk_zero(close(STDIN_FILENO), "Closing STDIN"); |
26 | chk_non_negative(dup2(rw[0],STDIN_FILENO), "Redirecting compressor input to stdin"); | 27 | chk_non_negative(dup2(rw[0],STDIN_FILENO), "Redirecting compressor input to stdin"); |
27 | execlp(filter,filter,NULL); | 28 | execlp(filter,filter,NULL); |
28 | _exit(-1); | 29 | _exit(-1); |
29 | } | 30 | } |
30 | /* parent */ | 31 | /* parent */ |
31 | chk_zero(close(rw[0]), "Closing read end of pipe"); | 32 | chk_zero(close(rw[0]), "Closing read end of pipe"); |
32 | chk_non_negative(dup2(rw[1],STDOUT_FILENO), "Redirecting output to compressor"); | 33 | chk_non_negative(dup2(rw[1],STDOUT_FILENO), "Redirecting output to compressor"); |
33 | 34 | ||
34 | rv = write_tar_archive(args); | 35 | rv = write_tar_archive(args); |
35 | 36 | ||
36 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT redirected to compressor"); | 37 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT redirected to compressor"); |
37 | chk_non_negative(dup2(stdout2,STDOUT_FILENO), "Restoring uncompressed STDOUT"); | 38 | chk_non_negative(dup2(stdout2,STDOUT_FILENO), "Restoring uncompressed STDOUT"); |
38 | chk_zero(close(stdout2), "Closing uncompressed STDOUT"); | 39 | chk_zero(close(stdout2), "Closing uncompressed STDOUT"); |
39 | chk_zero(close(rw[1]), "Closing write end of pipe in parent"); | 40 | chk_zero(close(rw[1]), "Closing write end of pipe in parent"); |
40 | chk_positive(waitpid(gzpid,&status,0), "Waiting on compressor process"); | 41 | chk_positive(waitpid(gzpid,&status,0), "Waiting on compressor process"); |
41 | if(! ( WIFEXITED(status) && WEXITSTATUS(status)==0 ) ) | 42 | if(! ( WIFEXITED(status) && WEXITSTATUS(status)==0 ) ) |
42 | cgit_print_error("Failed to compress archive"); | 43 | cgit_print_error("Failed to compress archive"); |
43 | 44 | ||
44 | return rv; | 45 | return rv; |
45 | } | 46 | } |
46 | 47 | ||
47 | static int write_tar_gzip_archive(struct archiver_args *args) | 48 | static int write_tar_gzip_archive(struct archiver_args *args) |
48 | { | 49 | { |
49 | return write_compressed_tar_archive(args,"gzip"); | 50 | return write_compressed_tar_archive(args,"gzip"); |
50 | } | 51 | } |
51 | 52 | ||
52 | static int write_tar_bzip2_archive(struct archiver_args *args) | 53 | static int write_tar_bzip2_archive(struct archiver_args *args) |
53 | { | 54 | { |
54 | return write_compressed_tar_archive(args,"bzip2"); | 55 | return write_compressed_tar_archive(args,"bzip2"); |
55 | } | 56 | } |
56 | 57 | ||
57 | static const struct snapshot_archive_t { | 58 | static const struct snapshot_archive_t { |
58 | const char *suffix; | 59 | const char *suffix; |
59 | const char *mimetype; | 60 | const char *mimetype; |
60 | write_archive_fn_t write_func; | 61 | write_archive_fn_t write_func; |
61 | int bit; | 62 | int bit; |
62 | }snapshot_archives[] = { | 63 | }snapshot_archives[] = { |
63 | { ".zip", "application/x-zip", write_zip_archive, 0x1 }, | 64 | { ".zip", "application/x-zip", write_zip_archive, 0x1 }, |
64 | { ".tar.gz", "application/x-tar", write_tar_gzip_archive, 0x2 }, | 65 | { ".tar.gz", "application/x-tar", write_tar_gzip_archive, 0x2 }, |
65 | { ".tar.bz2", "application/x-tar", write_tar_bzip2_archive, 0x4 }, | 66 | { ".tar.bz2", "application/x-tar", write_tar_bzip2_archive, 0x4 }, |
66 | { ".tar", "application/x-tar", write_tar_archive, 0x8 } | 67 | { ".tar", "application/x-tar", write_tar_archive, 0x8 } |
67 | }; | 68 | }; |
68 | 69 | ||
69 | #define snapshot_archives_len (sizeof(snapshot_archives) / sizeof(*snapshot_archives)) | 70 | #define snapshot_archives_len (sizeof(snapshot_archives) / sizeof(*snapshot_archives)) |
70 | 71 | ||
71 | void cgit_print_snapshot(struct cacheitem *item, const char *head, | 72 | void cgit_print_snapshot(struct cacheitem *item, const char *head, |
72 | const char *hex, const char *prefix, | 73 | const char *hex, const char *prefix, |
73 | const char *filename, int snapshots) | 74 | const char *filename, int snapshots) |
74 | { | 75 | { |
75 | const struct snapshot_archive_t* sat; | 76 | const struct snapshot_archive_t* sat; |
76 | struct archiver_args args; | 77 | struct archiver_args args; |
77 | struct commit *commit; | 78 | struct commit *commit; |
78 | unsigned char sha1[20]; | 79 | unsigned char sha1[20]; |
79 | int f, sl, fnl = strlen(filename); | 80 | int f, sl, fnl = strlen(filename); |
80 | 81 | ||
81 | for(f=0; f<snapshot_archives_len; f++) { | 82 | for(f=0; f<snapshot_archives_len; f++) { |
82 | sat = &snapshot_archives[f]; | 83 | sat = &snapshot_archives[f]; |
83 | if(!(snapshots & sat->bit)) | 84 | if(!(snapshots & sat->bit)) |
84 | continue; | 85 | continue; |
85 | sl = strlen(sat->suffix); | 86 | sl = strlen(sat->suffix); |
86 | if(fnl<sl || strcmp(&filename[fnl-sl],sat->suffix)) | 87 | if(fnl<sl || strcmp(&filename[fnl-sl],sat->suffix)) |
87 | continue; | 88 | continue; |
88 | if (!hex) | 89 | if (!hex) |
89 | hex = head; | 90 | hex = head; |
90 | if(get_sha1(hex, sha1)) { | 91 | if(get_sha1(hex, sha1)) { |
91 | cgit_print_error(fmt("Bad object id: %s", hex)); | 92 | cgit_print_error(fmt("Bad object id: %s", hex)); |
92 | return; | 93 | return; |
93 | } | 94 | } |
94 | commit = lookup_commit_reference(sha1); | 95 | commit = lookup_commit_reference(sha1); |
95 | if(!commit) { | 96 | if(!commit) { |
96 | cgit_print_error(fmt("Not a commit reference: %s", hex)); | 97 | cgit_print_error(fmt("Not a commit reference: %s", hex)); |
97 | return;; | 98 | return;; |
98 | } | 99 | } |
99 | memset(&args,0,sizeof(args)); | 100 | memset(&args,0,sizeof(args)); |
100 | args.base = fmt("%s/", prefix); | 101 | args.base = fmt("%s/", prefix); |
101 | args.tree = commit->tree; | 102 | args.tree = commit->tree; |
102 | args.time = commit->date; | 103 | args.time = commit->date; |
103 | cgit_print_snapshot_start(sat->mimetype, filename, item); | 104 | cgit_print_snapshot_start(sat->mimetype, filename, item); |
104 | (*sat->write_func)(&args); | 105 | (*sat->write_func)(&args); |
105 | return; | 106 | return; |
diff --git a/ui-summary.c b/ui-summary.c index 3baac08..0afa0a3 100644 --- a/ui-summary.c +++ b/ui-summary.c | |||
@@ -1,105 +1,106 @@ | |||
1 | /* ui-summary.c: functions for generating repo summary page | 1 | /* ui-summary.c: functions for generating repo summary page |
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 | #include "html.h" | ||
10 | 11 | ||
11 | static int header; | 12 | static int header; |
12 | 13 | ||
13 | static int cmp_age(int age1, int age2) | 14 | static int cmp_age(int age1, int age2) |
14 | { | 15 | { |
15 | if (age1 != 0 && age2 != 0) | 16 | if (age1 != 0 && age2 != 0) |
16 | return age2 - age1; | 17 | return age2 - age1; |
17 | 18 | ||
18 | if (age1 == 0 && age2 == 0) | 19 | if (age1 == 0 && age2 == 0) |
19 | return 0; | 20 | return 0; |
20 | 21 | ||
21 | if (age1 == 0) | 22 | if (age1 == 0) |
22 | return +1; | 23 | return +1; |
23 | 24 | ||
24 | return -1; | 25 | return -1; |
25 | } | 26 | } |
26 | 27 | ||
27 | static int cmp_ref_name(const void *a, const void *b) | 28 | static int cmp_ref_name(const void *a, const void *b) |
28 | { | 29 | { |
29 | struct refinfo *r1 = *(struct refinfo **)a; | 30 | struct refinfo *r1 = *(struct refinfo **)a; |
30 | struct refinfo *r2 = *(struct refinfo **)b; | 31 | struct refinfo *r2 = *(struct refinfo **)b; |
31 | 32 | ||
32 | return strcmp(r1->refname, r2->refname); | 33 | return strcmp(r1->refname, r2->refname); |
33 | } | 34 | } |
34 | 35 | ||
35 | static int cmp_branch_age(const void *a, const void *b) | 36 | static int cmp_branch_age(const void *a, const void *b) |
36 | { | 37 | { |
37 | struct refinfo *r1 = *(struct refinfo **)a; | 38 | struct refinfo *r1 = *(struct refinfo **)a; |
38 | struct refinfo *r2 = *(struct refinfo **)b; | 39 | struct refinfo *r2 = *(struct refinfo **)b; |
39 | 40 | ||
40 | return cmp_age(r1->commit->committer_date, r2->commit->committer_date); | 41 | return cmp_age(r1->commit->committer_date, r2->commit->committer_date); |
41 | } | 42 | } |
42 | 43 | ||
43 | static int cmp_tag_age(const void *a, const void *b) | 44 | static int cmp_tag_age(const void *a, const void *b) |
44 | { | 45 | { |
45 | struct refinfo *r1 = *(struct refinfo **)a; | 46 | struct refinfo *r1 = *(struct refinfo **)a; |
46 | struct refinfo *r2 = *(struct refinfo **)b; | 47 | struct refinfo *r2 = *(struct refinfo **)b; |
47 | 48 | ||
48 | return cmp_age(r1->tag->tagger_date, r2->tag->tagger_date); | 49 | return cmp_age(r1->tag->tagger_date, r2->tag->tagger_date); |
49 | } | 50 | } |
50 | 51 | ||
51 | static int print_branch(struct refinfo *ref) | 52 | static int print_branch(struct refinfo *ref) |
52 | { | 53 | { |
53 | struct commitinfo *info = ref->commit; | 54 | struct commitinfo *info = ref->commit; |
54 | char *name = (char *)ref->refname; | 55 | char *name = (char *)ref->refname; |
55 | 56 | ||
56 | if (!info) | 57 | if (!info) |
57 | return 1; | 58 | return 1; |
58 | html("<tr><td>"); | 59 | html("<tr><td>"); |
59 | cgit_log_link(name, NULL, NULL, name, NULL, NULL, 0, NULL, NULL); | 60 | cgit_log_link(name, NULL, NULL, name, NULL, NULL, 0, NULL, NULL); |
60 | html("</td><td>"); | 61 | html("</td><td>"); |
61 | 62 | ||
62 | if (ref->object->type == OBJ_COMMIT) { | 63 | if (ref->object->type == OBJ_COMMIT) { |
63 | cgit_print_age(info->commit->date, -1, NULL); | 64 | cgit_print_age(info->commit->date, -1, NULL); |
64 | html("</td><td>"); | 65 | html("</td><td>"); |
65 | html_txt(info->author); | 66 | html_txt(info->author); |
66 | html("</td><td>"); | 67 | html("</td><td>"); |
67 | cgit_commit_link(info->subject, NULL, NULL, name, NULL); | 68 | cgit_commit_link(info->subject, NULL, NULL, name, NULL); |
68 | } else { | 69 | } else { |
69 | html("</td><td></td><td>"); | 70 | html("</td><td></td><td>"); |
70 | cgit_object_link(ref->object); | 71 | cgit_object_link(ref->object); |
71 | } | 72 | } |
72 | html("</td></tr>\n"); | 73 | html("</td></tr>\n"); |
73 | return 0; | 74 | return 0; |
74 | } | 75 | } |
75 | 76 | ||
76 | static void print_tag_header() | 77 | static void print_tag_header() |
77 | { | 78 | { |
78 | html("<tr class='nohover'><th class='left'>Tag</th>" | 79 | html("<tr class='nohover'><th class='left'>Tag</th>" |
79 | "<th class='left'>Age</th>" | 80 | "<th class='left'>Age</th>" |
80 | "<th class='left'>Author</th>" | 81 | "<th class='left'>Author</th>" |
81 | "<th class='left'>Reference</th></tr>\n"); | 82 | "<th class='left'>Reference</th></tr>\n"); |
82 | header = 1; | 83 | header = 1; |
83 | } | 84 | } |
84 | 85 | ||
85 | static int print_tag(struct refinfo *ref) | 86 | static int print_tag(struct refinfo *ref) |
86 | { | 87 | { |
87 | struct tag *tag; | 88 | struct tag *tag; |
88 | struct taginfo *info; | 89 | struct taginfo *info; |
89 | char *url, *name = (char *)ref->refname; | 90 | char *url, *name = (char *)ref->refname; |
90 | 91 | ||
91 | if (ref->object->type == OBJ_TAG) { | 92 | if (ref->object->type == OBJ_TAG) { |
92 | tag = (struct tag *)ref->object; | 93 | tag = (struct tag *)ref->object; |
93 | info = ref->tag; | 94 | info = ref->tag; |
94 | if (!tag || !info) | 95 | if (!tag || !info) |
95 | return 1; | 96 | return 1; |
96 | html("<tr><td>"); | 97 | html("<tr><td>"); |
97 | url = cgit_pageurl(ctx.qry.repo, "tag", | 98 | url = cgit_pageurl(ctx.qry.repo, "tag", |
98 | fmt("id=%s", name)); | 99 | fmt("id=%s", name)); |
99 | html_link_open(url, NULL, NULL); | 100 | html_link_open(url, NULL, NULL); |
100 | html_txt(name); | 101 | html_txt(name); |
101 | html_link_close(); | 102 | html_link_close(); |
102 | html("</td><td>"); | 103 | html("</td><td>"); |
103 | if (info->tagger_date > 0) | 104 | if (info->tagger_date > 0) |
104 | cgit_print_age(info->tagger_date, -1, NULL); | 105 | cgit_print_age(info->tagger_date, -1, NULL); |
105 | html("</td><td>"); | 106 | html("</td><td>"); |
@@ -1,74 +1,74 @@ | |||
1 | /* ui-tag.c: display a tag | 1 | /* ui-tag.c: display a tag |
2 | * | 2 | * |
3 | * Copyright (C) 2007 Lars Hjemli | 3 | * Copyright (C) 2007 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 | #include "html.h" | |
11 | 11 | ||
12 | static void print_tag_content(char *buf) | 12 | static void print_tag_content(char *buf) |
13 | { | 13 | { |
14 | char *p; | 14 | char *p; |
15 | 15 | ||
16 | if (!buf) | 16 | if (!buf) |
17 | return; | 17 | return; |
18 | 18 | ||
19 | html("<div class='commit-subject'>"); | 19 | html("<div class='commit-subject'>"); |
20 | p = strchr(buf, '\n'); | 20 | p = strchr(buf, '\n'); |
21 | if (p) | 21 | if (p) |
22 | *p = '\0'; | 22 | *p = '\0'; |
23 | html_txt(buf); | 23 | html_txt(buf); |
24 | html("</div>"); | 24 | html("</div>"); |
25 | if (p) { | 25 | if (p) { |
26 | html("<div class='commit-msg'>"); | 26 | html("<div class='commit-msg'>"); |
27 | html_txt(++p); | 27 | html_txt(++p); |
28 | html("</div>"); | 28 | html("</div>"); |
29 | } | 29 | } |
30 | } | 30 | } |
31 | 31 | ||
32 | void cgit_print_tag(char *revname) | 32 | void cgit_print_tag(char *revname) |
33 | { | 33 | { |
34 | unsigned char sha1[20]; | 34 | unsigned char sha1[20]; |
35 | struct object *obj; | 35 | struct object *obj; |
36 | struct tag *tag; | 36 | struct tag *tag; |
37 | struct taginfo *info; | 37 | struct taginfo *info; |
38 | 38 | ||
39 | if (get_sha1(revname, sha1)) { | 39 | if (get_sha1(revname, sha1)) { |
40 | cgit_print_error(fmt("Bad tag reference: %s", revname)); | 40 | cgit_print_error(fmt("Bad tag reference: %s", revname)); |
41 | return; | 41 | return; |
42 | } | 42 | } |
43 | obj = parse_object(sha1); | 43 | obj = parse_object(sha1); |
44 | if (!obj) { | 44 | if (!obj) { |
45 | cgit_print_error(fmt("Bad object id: %s", sha1_to_hex(sha1))); | 45 | cgit_print_error(fmt("Bad object id: %s", sha1_to_hex(sha1))); |
46 | return; | 46 | return; |
47 | } | 47 | } |
48 | if (obj->type == OBJ_TAG) { | 48 | if (obj->type == OBJ_TAG) { |
49 | tag = lookup_tag(sha1); | 49 | tag = lookup_tag(sha1); |
50 | if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) { | 50 | if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) { |
51 | cgit_print_error(fmt("Bad tag object: %s", revname)); | 51 | cgit_print_error(fmt("Bad tag object: %s", revname)); |
52 | return; | 52 | return; |
53 | } | 53 | } |
54 | html("<table class='commit-info'>\n"); | 54 | html("<table class='commit-info'>\n"); |
55 | htmlf("<tr><td>Tag name</td><td>%s (%s)</td></tr>\n", | 55 | htmlf("<tr><td>Tag name</td><td>%s (%s)</td></tr>\n", |
56 | revname, sha1_to_hex(sha1)); | 56 | revname, sha1_to_hex(sha1)); |
57 | if (info->tagger_date > 0) { | 57 | if (info->tagger_date > 0) { |
58 | html("<tr><td>Tag date</td><td>"); | 58 | html("<tr><td>Tag date</td><td>"); |
59 | cgit_print_date(info->tagger_date, FMT_LONGDATE); | 59 | cgit_print_date(info->tagger_date, FMT_LONGDATE); |
60 | html("</td></tr>\n"); | 60 | html("</td></tr>\n"); |
61 | } | 61 | } |
62 | if (info->tagger) { | 62 | if (info->tagger) { |
63 | html("<tr><td>Tagged by</td><td>"); | 63 | html("<tr><td>Tagged by</td><td>"); |
64 | html_txt(info->tagger); | 64 | html_txt(info->tagger); |
65 | html("</td></tr>\n"); | 65 | html("</td></tr>\n"); |
66 | } | 66 | } |
67 | html("<tr><td>Tagged object</td><td>"); | 67 | html("<tr><td>Tagged object</td><td>"); |
68 | cgit_object_link(tag->tagged); | 68 | cgit_object_link(tag->tagged); |
69 | html("</td></tr>\n"); | 69 | html("</td></tr>\n"); |
70 | html("</table>\n"); | 70 | html("</table>\n"); |
71 | print_tag_content(info->msg); | 71 | print_tag_content(info->msg); |
72 | } | 72 | } |
73 | return; | 73 | return; |
74 | } | 74 | } |
@@ -1,178 +1,179 @@ | |||
1 | /* ui-tree.c: functions for tree output | 1 | /* ui-tree.c: functions for tree output |
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 | #include "html.h" | ||
10 | 11 | ||
11 | char *curr_rev; | 12 | char *curr_rev; |
12 | char *match_path; | 13 | char *match_path; |
13 | int header = 0; | 14 | int header = 0; |
14 | 15 | ||
15 | static void print_object(const unsigned char *sha1, char *path) | 16 | static void print_object(const unsigned char *sha1, char *path) |
16 | { | 17 | { |
17 | enum object_type type; | 18 | enum object_type type; |
18 | char *buf; | 19 | char *buf; |
19 | unsigned long size, lineno, start, idx; | 20 | unsigned long size, lineno, start, idx; |
20 | const char *linefmt = "<tr><td class='no'><a id='n%1$d' name='n%1$d' href='#n%1$d'>%1$d</a></td><td class='txt'>"; | 21 | const char *linefmt = "<tr><td class='no'><a id='n%1$d' name='n%1$d' href='#n%1$d'>%1$d</a></td><td class='txt'>"; |
21 | 22 | ||
22 | type = sha1_object_info(sha1, &size); | 23 | type = sha1_object_info(sha1, &size); |
23 | if (type == OBJ_BAD) { | 24 | if (type == OBJ_BAD) { |
24 | cgit_print_error(fmt("Bad object name: %s", | 25 | cgit_print_error(fmt("Bad object name: %s", |
25 | sha1_to_hex(sha1))); | 26 | sha1_to_hex(sha1))); |
26 | return; | 27 | return; |
27 | } | 28 | } |
28 | 29 | ||
29 | buf = read_sha1_file(sha1, &type, &size); | 30 | buf = read_sha1_file(sha1, &type, &size); |
30 | if (!buf) { | 31 | if (!buf) { |
31 | cgit_print_error(fmt("Error reading object %s", | 32 | cgit_print_error(fmt("Error reading object %s", |
32 | sha1_to_hex(sha1))); | 33 | sha1_to_hex(sha1))); |
33 | return; | 34 | return; |
34 | } | 35 | } |
35 | 36 | ||
36 | html(" blob: <a href='"); | 37 | html(" blob: <a href='"); |
37 | html_attr(cgit_pageurl(ctx.qry.repo, "blob", fmt("id=%s", sha1_to_hex(sha1)))); | 38 | html_attr(cgit_pageurl(ctx.qry.repo, "blob", fmt("id=%s", sha1_to_hex(sha1)))); |
38 | htmlf("'>%s</a>",sha1_to_hex(sha1)); | 39 | htmlf("'>%s</a>",sha1_to_hex(sha1)); |
39 | 40 | ||
40 | html("<table summary='blob content' class='blob'>\n"); | 41 | html("<table summary='blob content' class='blob'>\n"); |
41 | idx = 0; | 42 | idx = 0; |
42 | start = 0; | 43 | start = 0; |
43 | lineno = 0; | 44 | lineno = 0; |
44 | while(idx < size) { | 45 | while(idx < size) { |
45 | if (buf[idx] == '\n') { | 46 | if (buf[idx] == '\n') { |
46 | buf[idx] = '\0'; | 47 | buf[idx] = '\0'; |
47 | htmlf(linefmt, ++lineno); | 48 | htmlf(linefmt, ++lineno); |
48 | html_txt(buf + start); | 49 | html_txt(buf + start); |
49 | html("</td></tr>\n"); | 50 | html("</td></tr>\n"); |
50 | start = idx + 1; | 51 | start = idx + 1; |
51 | } | 52 | } |
52 | idx++; | 53 | idx++; |
53 | } | 54 | } |
54 | htmlf(linefmt, ++lineno); | 55 | htmlf(linefmt, ++lineno); |
55 | html_txt(buf + start); | 56 | html_txt(buf + start); |
56 | html("</td></tr>\n"); | 57 | html("</td></tr>\n"); |
57 | html("</table>\n"); | 58 | html("</table>\n"); |
58 | } | 59 | } |
59 | 60 | ||
60 | 61 | ||
61 | static int ls_item(const unsigned char *sha1, const char *base, int baselen, | 62 | static int ls_item(const unsigned char *sha1, const char *base, int baselen, |
62 | const char *pathname, unsigned int mode, int stage) | 63 | const char *pathname, unsigned int mode, int stage) |
63 | { | 64 | { |
64 | char *name; | 65 | char *name; |
65 | char *fullpath; | 66 | char *fullpath; |
66 | enum object_type type; | 67 | enum object_type type; |
67 | unsigned long size = 0; | 68 | unsigned long size = 0; |
68 | 69 | ||
69 | name = xstrdup(pathname); | 70 | name = xstrdup(pathname); |
70 | fullpath = fmt("%s%s%s", ctx.qry.path ? ctx.qry.path : "", | 71 | fullpath = fmt("%s%s%s", ctx.qry.path ? ctx.qry.path : "", |
71 | ctx.qry.path ? "/" : "", name); | 72 | ctx.qry.path ? "/" : "", name); |
72 | 73 | ||
73 | type = sha1_object_info(sha1, &size); | 74 | type = sha1_object_info(sha1, &size); |
74 | if (type == OBJ_BAD && !S_ISGITLINK(mode)) { | 75 | if (type == OBJ_BAD && !S_ISGITLINK(mode)) { |
75 | htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>", | 76 | htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>", |
76 | name, | 77 | name, |
77 | sha1_to_hex(sha1)); | 78 | sha1_to_hex(sha1)); |
78 | return 0; | 79 | return 0; |
79 | } | 80 | } |
80 | 81 | ||
81 | html("<tr><td class='ls-mode'>"); | 82 | html("<tr><td class='ls-mode'>"); |
82 | html_filemode(mode); | 83 | cgit_print_filemode(mode); |
83 | html("</td><td>"); | 84 | html("</td><td>"); |
84 | if (S_ISGITLINK(mode)) { | 85 | if (S_ISGITLINK(mode)) { |
85 | htmlf("<a class='ls-mod' href='"); | 86 | htmlf("<a class='ls-mod' href='"); |
86 | html_attr(fmt(ctx.repo->module_link, | 87 | html_attr(fmt(ctx.repo->module_link, |
87 | name, | 88 | name, |
88 | sha1_to_hex(sha1))); | 89 | sha1_to_hex(sha1))); |
89 | html("'>"); | 90 | html("'>"); |
90 | html_txt(name); | 91 | html_txt(name); |
91 | html("</a>"); | 92 | html("</a>"); |
92 | } else if (S_ISDIR(mode)) { | 93 | } else if (S_ISDIR(mode)) { |
93 | cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head, | 94 | cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head, |
94 | curr_rev, fullpath); | 95 | curr_rev, fullpath); |
95 | } else { | 96 | } else { |
96 | cgit_tree_link(name, NULL, "ls-blob", ctx.qry.head, | 97 | cgit_tree_link(name, NULL, "ls-blob", ctx.qry.head, |
97 | curr_rev, fullpath); | 98 | curr_rev, fullpath); |
98 | } | 99 | } |
99 | htmlf("</td><td class='ls-size'>%li</td>", size); | 100 | htmlf("</td><td class='ls-size'>%li</td>", size); |
100 | 101 | ||
101 | html("<td>"); | 102 | html("<td>"); |
102 | cgit_log_link("log", NULL, "button", ctx.qry.head, curr_rev, | 103 | cgit_log_link("log", NULL, "button", ctx.qry.head, curr_rev, |
103 | fullpath, 0, NULL, NULL); | 104 | fullpath, 0, NULL, NULL); |
104 | html("</td></tr>\n"); | 105 | html("</td></tr>\n"); |
105 | free(name); | 106 | free(name); |
106 | return 0; | 107 | return 0; |
107 | } | 108 | } |
108 | 109 | ||
109 | static void ls_head() | 110 | static void ls_head() |
110 | { | 111 | { |
111 | html("<table summary='tree listing' class='list'>\n"); | 112 | html("<table summary='tree listing' class='list'>\n"); |
112 | html("<tr class='nohover'>"); | 113 | html("<tr class='nohover'>"); |
113 | html("<th class='left'>Mode</th>"); | 114 | html("<th class='left'>Mode</th>"); |
114 | html("<th class='left'>Name</th>"); | 115 | html("<th class='left'>Name</th>"); |
115 | html("<th class='right'>Size</th>"); | 116 | html("<th class='right'>Size</th>"); |
116 | html("<th/>"); | 117 | html("<th/>"); |
117 | html("</tr>\n"); | 118 | html("</tr>\n"); |
118 | header = 1; | 119 | header = 1; |
119 | } | 120 | } |
120 | 121 | ||
121 | static void ls_tail() | 122 | static void ls_tail() |
122 | { | 123 | { |
123 | if (!header) | 124 | if (!header) |
124 | return; | 125 | return; |
125 | html("</table>\n"); | 126 | html("</table>\n"); |
126 | header = 0; | 127 | header = 0; |
127 | } | 128 | } |
128 | 129 | ||
129 | static void ls_tree(const unsigned char *sha1, char *path) | 130 | static void ls_tree(const unsigned char *sha1, char *path) |
130 | { | 131 | { |
131 | struct tree *tree; | 132 | struct tree *tree; |
132 | 133 | ||
133 | tree = parse_tree_indirect(sha1); | 134 | tree = parse_tree_indirect(sha1); |
134 | if (!tree) { | 135 | if (!tree) { |
135 | cgit_print_error(fmt("Not a tree object: %s", | 136 | cgit_print_error(fmt("Not a tree object: %s", |
136 | sha1_to_hex(sha1))); | 137 | sha1_to_hex(sha1))); |
137 | return; | 138 | return; |
138 | } | 139 | } |
139 | 140 | ||
140 | ls_head(); | 141 | ls_head(); |
141 | read_tree_recursive(tree, "", 0, 1, NULL, ls_item); | 142 | read_tree_recursive(tree, "", 0, 1, NULL, ls_item); |
142 | ls_tail(); | 143 | ls_tail(); |
143 | } | 144 | } |
144 | 145 | ||
145 | 146 | ||
146 | static int walk_tree(const unsigned char *sha1, const char *base, int baselen, | 147 | static int walk_tree(const unsigned char *sha1, const char *base, int baselen, |
147 | const char *pathname, unsigned mode, int stage) | 148 | const char *pathname, unsigned mode, int stage) |
148 | { | 149 | { |
149 | static int state; | 150 | static int state; |
150 | static char buffer[PATH_MAX]; | 151 | static char buffer[PATH_MAX]; |
151 | char *url; | 152 | char *url; |
152 | 153 | ||
153 | if (state == 0) { | 154 | if (state == 0) { |
154 | memcpy(buffer, base, baselen); | 155 | memcpy(buffer, base, baselen); |
155 | strcpy(buffer+baselen, pathname); | 156 | strcpy(buffer+baselen, pathname); |
156 | url = cgit_pageurl(ctx.qry.repo, "tree", | 157 | url = cgit_pageurl(ctx.qry.repo, "tree", |
157 | fmt("h=%s&path=%s", curr_rev, buffer)); | 158 | fmt("h=%s&path=%s", curr_rev, buffer)); |
158 | html("/"); | 159 | html("/"); |
159 | cgit_tree_link(xstrdup(pathname), NULL, NULL, ctx.qry.head, | 160 | cgit_tree_link(xstrdup(pathname), NULL, NULL, ctx.qry.head, |
160 | curr_rev, buffer); | 161 | curr_rev, buffer); |
161 | 162 | ||
162 | if (strcmp(match_path, buffer)) | 163 | if (strcmp(match_path, buffer)) |
163 | return READ_TREE_RECURSIVE; | 164 | return READ_TREE_RECURSIVE; |
164 | 165 | ||
165 | if (S_ISDIR(mode)) { | 166 | if (S_ISDIR(mode)) { |
166 | state = 1; | 167 | state = 1; |
167 | ls_head(); | 168 | ls_head(); |
168 | return READ_TREE_RECURSIVE; | 169 | return READ_TREE_RECURSIVE; |
169 | } else { | 170 | } else { |
170 | print_object(sha1, buffer); | 171 | print_object(sha1, buffer); |
171 | return 0; | 172 | return 0; |
172 | } | 173 | } |
173 | } | 174 | } |
174 | ls_item(sha1, base, baselen, pathname, mode, stage); | 175 | ls_item(sha1, base, baselen, pathname, mode, stage); |
175 | return 0; | 176 | return 0; |
176 | } | 177 | } |
177 | 178 | ||
178 | 179 | ||