author | Michael Krelin <hacker@klever.net> | 2007-07-21 13:29:55 (UTC) |
---|---|---|
committer | Michael Krelin <hacker@klever.net> | 2007-07-21 13:29:55 (UTC) |
commit | 97c025ae8ecf9764fd6996c81c51c3de4adb837c (patch) (unidiff) | |
tree | 83395f8230a8589b5d167ab796055133f739090d /cgit.c | |
parent | 1cb8bedf1e0a4aa73bb8ad3f96bfa7eda50919b3 (diff) | |
download | cgit-97c025ae8ecf9764fd6996c81c51c3de4adb837c.zip cgit-97c025ae8ecf9764fd6996c81c51c3de4adb837c.tar.gz cgit-97c025ae8ecf9764fd6996c81c51c3de4adb837c.tar.bz2 |
shorten snapshot names to repo basename
Signed-off-by: Michael Krelin <hacker@klever.net>
-rw-r--r-- | cgit.c | 3 |
1 files changed, 2 insertions, 1 deletions
@@ -1,251 +1,252 @@ | |||
1 | /* cgit.c: cgi for the git scm | 1 | /* cgit.c: cgi for the git scm |
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 | static int cgit_prepare_cache(struct cacheitem *item) | 11 | static int cgit_prepare_cache(struct cacheitem *item) |
12 | { | 12 | { |
13 | if (!cgit_repo && cgit_query_repo) { | 13 | if (!cgit_repo && cgit_query_repo) { |
14 | char *title = fmt("%s - %s", cgit_root_title, "Bad request"); | 14 | char *title = fmt("%s - %s", cgit_root_title, "Bad request"); |
15 | cgit_print_docstart(title, item); | 15 | cgit_print_docstart(title, item); |
16 | cgit_print_pageheader(title, 0); | 16 | cgit_print_pageheader(title, 0); |
17 | cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo)); | 17 | cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo)); |
18 | cgit_print_docend(); | 18 | cgit_print_docend(); |
19 | return 0; | 19 | return 0; |
20 | } | 20 | } |
21 | 21 | ||
22 | if (!cgit_repo) { | 22 | if (!cgit_repo) { |
23 | item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); | 23 | item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); |
24 | item->ttl = cgit_cache_root_ttl; | 24 | item->ttl = cgit_cache_root_ttl; |
25 | return 1; | 25 | return 1; |
26 | } | 26 | } |
27 | 27 | ||
28 | if (!cgit_cmd) { | 28 | if (!cgit_cmd) { |
29 | item->name = xstrdup(fmt("%s/%s/index.%s.html", cgit_cache_root, | 29 | item->name = xstrdup(fmt("%s/%s/index.%s.html", cgit_cache_root, |
30 | cache_safe_filename(cgit_repo->url), | 30 | cache_safe_filename(cgit_repo->url), |
31 | cache_safe_filename(cgit_querystring))); | 31 | cache_safe_filename(cgit_querystring))); |
32 | item->ttl = cgit_cache_repo_ttl; | 32 | item->ttl = cgit_cache_repo_ttl; |
33 | } else { | 33 | } else { |
34 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, | 34 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, |
35 | cache_safe_filename(cgit_repo->url), | 35 | cache_safe_filename(cgit_repo->url), |
36 | cgit_query_page, | 36 | cgit_query_page, |
37 | cache_safe_filename(cgit_querystring))); | 37 | cache_safe_filename(cgit_querystring))); |
38 | if (cgit_query_has_symref) | 38 | if (cgit_query_has_symref) |
39 | item->ttl = cgit_cache_dynamic_ttl; | 39 | item->ttl = cgit_cache_dynamic_ttl; |
40 | else if (cgit_query_has_sha1) | 40 | else if (cgit_query_has_sha1) |
41 | item->ttl = cgit_cache_static_ttl; | 41 | item->ttl = cgit_cache_static_ttl; |
42 | else | 42 | else |
43 | item->ttl = cgit_cache_repo_ttl; | 43 | item->ttl = cgit_cache_repo_ttl; |
44 | } | 44 | } |
45 | return 1; | 45 | return 1; |
46 | } | 46 | } |
47 | 47 | ||
48 | static void cgit_print_repo_page(struct cacheitem *item) | 48 | static void cgit_print_repo_page(struct cacheitem *item) |
49 | { | 49 | { |
50 | char *title; | 50 | char *title; |
51 | int show_search; | 51 | int show_search; |
52 | 52 | ||
53 | if (!cgit_query_head) | 53 | if (!cgit_query_head) |
54 | cgit_query_head = cgit_repo->defbranch; | 54 | cgit_query_head = cgit_repo->defbranch; |
55 | 55 | ||
56 | if (chdir(cgit_repo->path)) { | 56 | if (chdir(cgit_repo->path)) { |
57 | title = fmt("%s - %s", cgit_root_title, "Bad request"); | 57 | title = fmt("%s - %s", cgit_root_title, "Bad request"); |
58 | cgit_print_docstart(title, item); | 58 | cgit_print_docstart(title, item); |
59 | cgit_print_pageheader(title, 0); | 59 | cgit_print_pageheader(title, 0); |
60 | cgit_print_error(fmt("Unable to scan repository: %s", | 60 | cgit_print_error(fmt("Unable to scan repository: %s", |
61 | strerror(errno))); | 61 | strerror(errno))); |
62 | cgit_print_docend(); | 62 | cgit_print_docend(); |
63 | return; | 63 | return; |
64 | } | 64 | } |
65 | 65 | ||
66 | title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc); | 66 | title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc); |
67 | show_search = 0; | 67 | show_search = 0; |
68 | setenv("GIT_DIR", cgit_repo->path, 1); | 68 | setenv("GIT_DIR", cgit_repo->path, 1); |
69 | 69 | ||
70 | if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) { | 70 | if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) { |
71 | cgit_print_snapshot(item, cgit_query_sha1, | 71 | cgit_print_snapshot(item, cgit_query_sha1, |
72 | cgit_repo->url, cgit_query_name); | 72 | cgit_repobasename(cgit_repo->url), |
73 | cgit_query_name); | ||
73 | return; | 74 | return; |
74 | } | 75 | } |
75 | 76 | ||
76 | if (cgit_cmd == CMD_BLOB) { | 77 | if (cgit_cmd == CMD_BLOB) { |
77 | cgit_print_blob(item, cgit_query_sha1, cgit_query_path); | 78 | cgit_print_blob(item, cgit_query_sha1, cgit_query_path); |
78 | return; | 79 | return; |
79 | } | 80 | } |
80 | 81 | ||
81 | show_search = (cgit_cmd == CMD_LOG); | 82 | show_search = (cgit_cmd == CMD_LOG); |
82 | cgit_print_docstart(title, item); | 83 | cgit_print_docstart(title, item); |
83 | if (!cgit_cmd) { | 84 | if (!cgit_cmd) { |
84 | cgit_print_pageheader("summary", show_search); | 85 | cgit_print_pageheader("summary", show_search); |
85 | cgit_print_summary(); | 86 | cgit_print_summary(); |
86 | cgit_print_docend(); | 87 | cgit_print_docend(); |
87 | return; | 88 | return; |
88 | } | 89 | } |
89 | 90 | ||
90 | cgit_print_pageheader(cgit_query_page, show_search); | 91 | cgit_print_pageheader(cgit_query_page, show_search); |
91 | 92 | ||
92 | switch(cgit_cmd) { | 93 | switch(cgit_cmd) { |
93 | case CMD_LOG: | 94 | case CMD_LOG: |
94 | cgit_print_log(cgit_query_sha1, cgit_query_ofs, | 95 | cgit_print_log(cgit_query_sha1, cgit_query_ofs, |
95 | cgit_max_commit_count, cgit_query_search, | 96 | cgit_max_commit_count, cgit_query_search, |
96 | cgit_query_path, 1); | 97 | cgit_query_path, 1); |
97 | break; | 98 | break; |
98 | case CMD_TREE: | 99 | case CMD_TREE: |
99 | cgit_print_tree(cgit_query_sha1, cgit_query_path); | 100 | cgit_print_tree(cgit_query_sha1, cgit_query_path); |
100 | break; | 101 | break; |
101 | case CMD_COMMIT: | 102 | case CMD_COMMIT: |
102 | cgit_print_commit(cgit_query_sha1); | 103 | cgit_print_commit(cgit_query_sha1); |
103 | break; | 104 | break; |
104 | case CMD_DIFF: | 105 | case CMD_DIFF: |
105 | cgit_print_diff(cgit_query_sha1, cgit_query_sha2); | 106 | cgit_print_diff(cgit_query_sha1, cgit_query_sha2); |
106 | break; | 107 | break; |
107 | default: | 108 | default: |
108 | cgit_print_error("Invalid request"); | 109 | cgit_print_error("Invalid request"); |
109 | } | 110 | } |
110 | cgit_print_docend(); | 111 | cgit_print_docend(); |
111 | } | 112 | } |
112 | 113 | ||
113 | static void cgit_fill_cache(struct cacheitem *item, int use_cache) | 114 | static void cgit_fill_cache(struct cacheitem *item, int use_cache) |
114 | { | 115 | { |
115 | static char buf[PATH_MAX]; | 116 | static char buf[PATH_MAX]; |
116 | int stdout2; | 117 | int stdout2; |
117 | 118 | ||
118 | getcwd(buf, sizeof(buf)); | 119 | getcwd(buf, sizeof(buf)); |
119 | item->st.st_mtime = time(NULL); | 120 | item->st.st_mtime = time(NULL); |
120 | 121 | ||
121 | if (use_cache) { | 122 | if (use_cache) { |
122 | stdout2 = chk_positive(dup(STDOUT_FILENO), | 123 | stdout2 = chk_positive(dup(STDOUT_FILENO), |
123 | "Preserving STDOUT"); | 124 | "Preserving STDOUT"); |
124 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT"); | 125 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT"); |
125 | chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)"); | 126 | chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)"); |
126 | } | 127 | } |
127 | 128 | ||
128 | if (cgit_repo) | 129 | if (cgit_repo) |
129 | cgit_print_repo_page(item); | 130 | cgit_print_repo_page(item); |
130 | else | 131 | else |
131 | cgit_print_repolist(item); | 132 | cgit_print_repolist(item); |
132 | 133 | ||
133 | if (use_cache) { | 134 | if (use_cache) { |
134 | chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); | 135 | chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); |
135 | chk_positive(dup2(stdout2, STDOUT_FILENO), | 136 | chk_positive(dup2(stdout2, STDOUT_FILENO), |
136 | "Restoring original STDOUT"); | 137 | "Restoring original STDOUT"); |
137 | chk_zero(close(stdout2), "Closing temporary STDOUT"); | 138 | chk_zero(close(stdout2), "Closing temporary STDOUT"); |
138 | } | 139 | } |
139 | 140 | ||
140 | chdir(buf); | 141 | chdir(buf); |
141 | } | 142 | } |
142 | 143 | ||
143 | static void cgit_check_cache(struct cacheitem *item) | 144 | static void cgit_check_cache(struct cacheitem *item) |
144 | { | 145 | { |
145 | int i = 0; | 146 | int i = 0; |
146 | 147 | ||
147 | top: | 148 | top: |
148 | if (++i > cgit_max_lock_attempts) { | 149 | if (++i > cgit_max_lock_attempts) { |
149 | die("cgit_refresh_cache: unable to lock %s: %s", | 150 | die("cgit_refresh_cache: unable to lock %s: %s", |
150 | item->name, strerror(errno)); | 151 | item->name, strerror(errno)); |
151 | } | 152 | } |
152 | if (!cache_exist(item)) { | 153 | if (!cache_exist(item)) { |
153 | if (!cache_lock(item)) { | 154 | if (!cache_lock(item)) { |
154 | sleep(1); | 155 | sleep(1); |
155 | goto top; | 156 | goto top; |
156 | } | 157 | } |
157 | if (!cache_exist(item)) { | 158 | if (!cache_exist(item)) { |
158 | cgit_fill_cache(item, 1); | 159 | cgit_fill_cache(item, 1); |
159 | cache_unlock(item); | 160 | cache_unlock(item); |
160 | } else { | 161 | } else { |
161 | cache_cancel_lock(item); | 162 | cache_cancel_lock(item); |
162 | } | 163 | } |
163 | } else if (cache_expired(item) && cache_lock(item)) { | 164 | } else if (cache_expired(item) && cache_lock(item)) { |
164 | if (cache_expired(item)) { | 165 | if (cache_expired(item)) { |
165 | cgit_fill_cache(item, 1); | 166 | cgit_fill_cache(item, 1); |
166 | cache_unlock(item); | 167 | cache_unlock(item); |
167 | } else { | 168 | } else { |
168 | cache_cancel_lock(item); | 169 | cache_cancel_lock(item); |
169 | } | 170 | } |
170 | } | 171 | } |
171 | } | 172 | } |
172 | 173 | ||
173 | static void cgit_print_cache(struct cacheitem *item) | 174 | static void cgit_print_cache(struct cacheitem *item) |
174 | { | 175 | { |
175 | static char buf[4096]; | 176 | static char buf[4096]; |
176 | ssize_t i; | 177 | ssize_t i; |
177 | 178 | ||
178 | int fd = open(item->name, O_RDONLY); | 179 | int fd = open(item->name, O_RDONLY); |
179 | if (fd<0) | 180 | if (fd<0) |
180 | die("Unable to open cached file %s", item->name); | 181 | die("Unable to open cached file %s", item->name); |
181 | 182 | ||
182 | while((i=read(fd, buf, sizeof(buf))) > 0) | 183 | while((i=read(fd, buf, sizeof(buf))) > 0) |
183 | write(STDOUT_FILENO, buf, i); | 184 | write(STDOUT_FILENO, buf, i); |
184 | 185 | ||
185 | close(fd); | 186 | close(fd); |
186 | } | 187 | } |
187 | 188 | ||
188 | static void cgit_parse_args(int argc, const char **argv) | 189 | static void cgit_parse_args(int argc, const char **argv) |
189 | { | 190 | { |
190 | int i; | 191 | int i; |
191 | 192 | ||
192 | for (i = 1; i < argc; i++) { | 193 | for (i = 1; i < argc; i++) { |
193 | if (!strncmp(argv[i], "--cache=", 8)) { | 194 | if (!strncmp(argv[i], "--cache=", 8)) { |
194 | cgit_cache_root = xstrdup(argv[i]+8); | 195 | cgit_cache_root = xstrdup(argv[i]+8); |
195 | } | 196 | } |
196 | if (!strcmp(argv[i], "--nocache")) { | 197 | if (!strcmp(argv[i], "--nocache")) { |
197 | cgit_nocache = 1; | 198 | cgit_nocache = 1; |
198 | } | 199 | } |
199 | if (!strncmp(argv[i], "--query=", 8)) { | 200 | if (!strncmp(argv[i], "--query=", 8)) { |
200 | cgit_querystring = xstrdup(argv[i]+8); | 201 | cgit_querystring = xstrdup(argv[i]+8); |
201 | } | 202 | } |
202 | if (!strncmp(argv[i], "--repo=", 7)) { | 203 | if (!strncmp(argv[i], "--repo=", 7)) { |
203 | cgit_query_repo = xstrdup(argv[i]+7); | 204 | cgit_query_repo = xstrdup(argv[i]+7); |
204 | } | 205 | } |
205 | if (!strncmp(argv[i], "--page=", 7)) { | 206 | if (!strncmp(argv[i], "--page=", 7)) { |
206 | cgit_query_page = xstrdup(argv[i]+7); | 207 | cgit_query_page = xstrdup(argv[i]+7); |
207 | } | 208 | } |
208 | if (!strncmp(argv[i], "--head=", 7)) { | 209 | if (!strncmp(argv[i], "--head=", 7)) { |
209 | cgit_query_head = xstrdup(argv[i]+7); | 210 | cgit_query_head = xstrdup(argv[i]+7); |
210 | cgit_query_has_symref = 1; | 211 | cgit_query_has_symref = 1; |
211 | } | 212 | } |
212 | if (!strncmp(argv[i], "--sha1=", 7)) { | 213 | if (!strncmp(argv[i], "--sha1=", 7)) { |
213 | cgit_query_sha1 = xstrdup(argv[i]+7); | 214 | cgit_query_sha1 = xstrdup(argv[i]+7); |
214 | cgit_query_has_sha1 = 1; | 215 | cgit_query_has_sha1 = 1; |
215 | } | 216 | } |
216 | if (!strncmp(argv[i], "--ofs=", 6)) { | 217 | if (!strncmp(argv[i], "--ofs=", 6)) { |
217 | cgit_query_ofs = atoi(argv[i]+6); | 218 | cgit_query_ofs = atoi(argv[i]+6); |
218 | } | 219 | } |
219 | } | 220 | } |
220 | } | 221 | } |
221 | 222 | ||
222 | int main(int argc, const char **argv) | 223 | int main(int argc, const char **argv) |
223 | { | 224 | { |
224 | struct cacheitem item; | 225 | struct cacheitem item; |
225 | const char *cgit_config_env = getenv("CGIT_CONFIG"); | 226 | const char *cgit_config_env = getenv("CGIT_CONFIG"); |
226 | 227 | ||
227 | htmlfd = STDOUT_FILENO; | 228 | htmlfd = STDOUT_FILENO; |
228 | item.st.st_mtime = time(NULL); | 229 | item.st.st_mtime = time(NULL); |
229 | cgit_repolist.length = 0; | 230 | cgit_repolist.length = 0; |
230 | cgit_repolist.count = 0; | 231 | cgit_repolist.count = 0; |
231 | cgit_repolist.repos = NULL; | 232 | cgit_repolist.repos = NULL; |
232 | 233 | ||
233 | cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG, | 234 | cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG, |
234 | cgit_global_config_cb); | 235 | cgit_global_config_cb); |
235 | cgit_repo = NULL; | 236 | cgit_repo = NULL; |
236 | if (getenv("SCRIPT_NAME")) | 237 | if (getenv("SCRIPT_NAME")) |
237 | cgit_script_name = xstrdup(getenv("SCRIPT_NAME")); | 238 | cgit_script_name = xstrdup(getenv("SCRIPT_NAME")); |
238 | if (getenv("QUERY_STRING")) | 239 | if (getenv("QUERY_STRING")) |
239 | cgit_querystring = xstrdup(getenv("QUERY_STRING")); | 240 | cgit_querystring = xstrdup(getenv("QUERY_STRING")); |
240 | cgit_parse_args(argc, argv); | 241 | cgit_parse_args(argc, argv); |
241 | cgit_parse_query(cgit_querystring, cgit_querystring_cb); | 242 | cgit_parse_query(cgit_querystring, cgit_querystring_cb); |
242 | if (!cgit_prepare_cache(&item)) | 243 | if (!cgit_prepare_cache(&item)) |
243 | return 0; | 244 | return 0; |
244 | if (cgit_nocache) { | 245 | if (cgit_nocache) { |
245 | cgit_fill_cache(&item, 0); | 246 | cgit_fill_cache(&item, 0); |
246 | } else { | 247 | } else { |
247 | cgit_check_cache(&item); | 248 | cgit_check_cache(&item); |
248 | cgit_print_cache(&item); | 249 | cgit_print_cache(&item); |
249 | } | 250 | } |
250 | return 0; | 251 | return 0; |
251 | } | 252 | } |