|
diff --git a/cgit.c b/cgit.c index f0907a1..b270fdc 100644 --- a/ cgit.c+++ b/ cgit.c |
|
@@ -1,243 +1,243 @@ |
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 && ctx.qry.repo) { |
13 | if (!ctx.repo && ctx.qry.repo) { |
14 | char *title = fmt("%s - %s", ctx.cfg.root_title, "Bad request"); |
14 | char *title = fmt("%s - %s", ctx.cfg.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", ctx.qry.repo)); |
17 | cgit_print_error(fmt("Unknown repo: %s", ctx.qry.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 (!ctx.repo) { |
23 | item->name = xstrdup(fmt("%s/index.html", ctx.cfg.cache_root)); |
23 | item->name = xstrdup(fmt("%s/index.html", ctx.cfg.cache_root)); |
24 | item->ttl = ctx.cfg.cache_root_ttl; |
24 | item->ttl = ctx.cfg.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", ctx.cfg.cache_root, |
29 | item->name = xstrdup(fmt("%s/%s/index.%s.html", ctx.cfg.cache_root, |
30 | cache_safe_filename(cgit_repo->url), |
30 | cache_safe_filename(ctx.repo->url), |
31 | cache_safe_filename(ctx.qry.raw))); |
31 | cache_safe_filename(ctx.qry.raw))); |
32 | item->ttl = ctx.cfg.cache_repo_ttl; |
32 | item->ttl = ctx.cfg.cache_repo_ttl; |
33 | } else { |
33 | } else { |
34 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", ctx.cfg.cache_root, |
34 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", ctx.cfg.cache_root, |
35 | cache_safe_filename(cgit_repo->url), |
35 | cache_safe_filename(ctx.repo->url), |
36 | ctx.qry.page, |
36 | ctx.qry.page, |
37 | cache_safe_filename(ctx.qry.raw))); |
37 | cache_safe_filename(ctx.qry.raw))); |
38 | if (ctx.qry.has_symref) |
38 | if (ctx.qry.has_symref) |
39 | item->ttl = ctx.cfg.cache_dynamic_ttl; |
39 | item->ttl = ctx.cfg.cache_dynamic_ttl; |
40 | else if (ctx.qry.has_sha1) |
40 | else if (ctx.qry.has_sha1) |
41 | item->ttl = ctx.cfg.cache_static_ttl; |
41 | item->ttl = ctx.cfg.cache_static_ttl; |
42 | else |
42 | else |
43 | item->ttl = ctx.cfg.cache_repo_ttl; |
43 | item->ttl = ctx.cfg.cache_repo_ttl; |
44 | } |
44 | } |
45 | return 1; |
45 | return 1; |
46 | } |
46 | } |
47 | |
47 | |
48 | struct refmatch { |
48 | struct refmatch { |
49 | char *req_ref; |
49 | char *req_ref; |
50 | char *first_ref; |
50 | char *first_ref; |
51 | int match; |
51 | int match; |
52 | }; |
52 | }; |
53 | |
53 | |
54 | int find_current_ref(const char *refname, const unsigned char *sha1, |
54 | int find_current_ref(const char *refname, const unsigned char *sha1, |
55 | int flags, void *cb_data) |
55 | int flags, void *cb_data) |
56 | { |
56 | { |
57 | struct refmatch *info; |
57 | struct refmatch *info; |
58 | |
58 | |
59 | info = (struct refmatch *)cb_data; |
59 | info = (struct refmatch *)cb_data; |
60 | if (!strcmp(refname, info->req_ref)) |
60 | if (!strcmp(refname, info->req_ref)) |
61 | info->match = 1; |
61 | info->match = 1; |
62 | if (!info->first_ref) |
62 | if (!info->first_ref) |
63 | info->first_ref = xstrdup(refname); |
63 | info->first_ref = xstrdup(refname); |
64 | return info->match; |
64 | return info->match; |
65 | } |
65 | } |
66 | |
66 | |
67 | char *find_default_branch(struct repoinfo *repo) |
67 | char *find_default_branch(struct cgit_repo *repo) |
68 | { |
68 | { |
69 | struct refmatch info; |
69 | struct refmatch info; |
70 | |
70 | |
71 | info.req_ref = repo->defbranch; |
71 | info.req_ref = repo->defbranch; |
72 | info.first_ref = NULL; |
72 | info.first_ref = NULL; |
73 | info.match = 0; |
73 | info.match = 0; |
74 | for_each_branch_ref(find_current_ref, &info); |
74 | for_each_branch_ref(find_current_ref, &info); |
75 | if (info.match) |
75 | if (info.match) |
76 | return info.req_ref; |
76 | return info.req_ref; |
77 | else |
77 | else |
78 | return info.first_ref; |
78 | return info.first_ref; |
79 | } |
79 | } |
80 | |
80 | |
81 | static void cgit_print_repo_page(struct cacheitem *item) |
81 | static void cgit_print_repo_page(struct cacheitem *item) |
82 | { |
82 | { |
83 | char *title, *tmp; |
83 | char *title, *tmp; |
84 | int show_search; |
84 | int show_search; |
85 | unsigned char sha1[20]; |
85 | unsigned char sha1[20]; |
86 | |
86 | |
87 | if (chdir(cgit_repo->path)) { |
87 | if (chdir(ctx.repo->path)) { |
88 | title = fmt("%s - %s", ctx.cfg.root_title, "Bad request"); |
88 | title = fmt("%s - %s", ctx.cfg.root_title, "Bad request"); |
89 | cgit_print_docstart(title, item); |
89 | cgit_print_docstart(title, item); |
90 | cgit_print_pageheader(title, 0); |
90 | cgit_print_pageheader(title, 0); |
91 | cgit_print_error(fmt("Unable to scan repository: %s", |
91 | cgit_print_error(fmt("Unable to scan repository: %s", |
92 | strerror(errno))); |
92 | strerror(errno))); |
93 | cgit_print_docend(); |
93 | cgit_print_docend(); |
94 | return; |
94 | return; |
95 | } |
95 | } |
96 | |
96 | |
97 | title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc); |
97 | title = fmt("%s - %s", ctx.repo->name, ctx.repo->desc); |
98 | show_search = 0; |
98 | show_search = 0; |
99 | setenv("GIT_DIR", cgit_repo->path, 1); |
99 | setenv("GIT_DIR", ctx.repo->path, 1); |
100 | |
100 | |
101 | if (!ctx.qry.head) { |
101 | if (!ctx.qry.head) { |
102 | ctx.qry.head = xstrdup(find_default_branch(cgit_repo)); |
102 | ctx.qry.head = xstrdup(find_default_branch(ctx.repo)); |
103 | cgit_repo->defbranch = ctx.qry.head; |
103 | ctx.repo->defbranch = ctx.qry.head; |
104 | } |
104 | } |
105 | |
105 | |
106 | if (!ctx.qry.head) { |
106 | if (!ctx.qry.head) { |
107 | cgit_print_docstart(title, item); |
107 | cgit_print_docstart(title, item); |
108 | cgit_print_pageheader(title, 0); |
108 | cgit_print_pageheader(title, 0); |
109 | cgit_print_error("Repository seems to be empty"); |
109 | cgit_print_error("Repository seems to be empty"); |
110 | cgit_print_docend(); |
110 | cgit_print_docend(); |
111 | return; |
111 | return; |
112 | } |
112 | } |
113 | |
113 | |
114 | if (get_sha1(ctx.qry.head, sha1)) { |
114 | if (get_sha1(ctx.qry.head, sha1)) { |
115 | tmp = xstrdup(ctx.qry.head); |
115 | tmp = xstrdup(ctx.qry.head); |
116 | ctx.qry.head = cgit_repo->defbranch; |
116 | ctx.qry.head = ctx.repo->defbranch; |
117 | cgit_print_docstart(title, item); |
117 | cgit_print_docstart(title, item); |
118 | cgit_print_pageheader(title, 0); |
118 | cgit_print_pageheader(title, 0); |
119 | cgit_print_error(fmt("Invalid branch: %s", tmp)); |
119 | cgit_print_error(fmt("Invalid branch: %s", tmp)); |
120 | cgit_print_docend(); |
120 | cgit_print_docend(); |
121 | return; |
121 | return; |
122 | } |
122 | } |
123 | |
123 | |
124 | if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) { |
124 | if ((cgit_cmd == CMD_SNAPSHOT) && ctx.repo->snapshots) { |
125 | cgit_print_snapshot(item, ctx.qry.head, ctx.qry.sha1, |
125 | cgit_print_snapshot(item, ctx.qry.head, ctx.qry.sha1, |
126 | cgit_repobasename(cgit_repo->url), |
126 | cgit_repobasename(ctx.repo->url), |
127 | ctx.qry.path, |
127 | ctx.qry.path, |
128 | cgit_repo->snapshots ); |
128 | ctx.repo->snapshots ); |
129 | return; |
129 | return; |
130 | } |
130 | } |
131 | |
131 | |
132 | if (cgit_cmd == CMD_PATCH) { |
132 | if (cgit_cmd == CMD_PATCH) { |
133 | cgit_print_patch(ctx.qry.sha1, item); |
133 | cgit_print_patch(ctx.qry.sha1, item); |
134 | return; |
134 | return; |
135 | } |
135 | } |
136 | |
136 | |
137 | if (cgit_cmd == CMD_BLOB) { |
137 | if (cgit_cmd == CMD_BLOB) { |
138 | cgit_print_blob(item, ctx.qry.sha1, ctx.qry.path); |
138 | cgit_print_blob(item, ctx.qry.sha1, ctx.qry.path); |
139 | return; |
139 | return; |
140 | } |
140 | } |
141 | |
141 | |
142 | show_search = (cgit_cmd == CMD_LOG); |
142 | show_search = (cgit_cmd == CMD_LOG); |
143 | cgit_print_docstart(title, item); |
143 | cgit_print_docstart(title, item); |
144 | if (!cgit_cmd) { |
144 | if (!cgit_cmd) { |
145 | cgit_print_pageheader("summary", show_search); |
145 | cgit_print_pageheader("summary", show_search); |
146 | cgit_print_summary(); |
146 | cgit_print_summary(); |
147 | cgit_print_docend(); |
147 | cgit_print_docend(); |
148 | return; |
148 | return; |
149 | } |
149 | } |
150 | |
150 | |
151 | cgit_print_pageheader(ctx.qry.page, show_search); |
151 | cgit_print_pageheader(ctx.qry.page, show_search); |
152 | |
152 | |
153 | switch(cgit_cmd) { |
153 | switch(cgit_cmd) { |
154 | case CMD_LOG: |
154 | case CMD_LOG: |
155 | cgit_print_log(ctx.qry.sha1, ctx.qry.ofs, |
155 | cgit_print_log(ctx.qry.sha1, ctx.qry.ofs, |
156 | ctx.cfg.max_commit_count, ctx.qry.grep, ctx.qry.search, |
156 | ctx.cfg.max_commit_count, ctx.qry.grep, ctx.qry.search, |
157 | ctx.qry.path, 1); |
157 | ctx.qry.path, 1); |
158 | break; |
158 | break; |
159 | case CMD_TREE: |
159 | case CMD_TREE: |
160 | cgit_print_tree(ctx.qry.sha1, ctx.qry.path); |
160 | cgit_print_tree(ctx.qry.sha1, ctx.qry.path); |
161 | break; |
161 | break; |
162 | case CMD_COMMIT: |
162 | case CMD_COMMIT: |
163 | cgit_print_commit(ctx.qry.sha1); |
163 | cgit_print_commit(ctx.qry.sha1); |
164 | break; |
164 | break; |
165 | case CMD_REFS: |
165 | case CMD_REFS: |
166 | cgit_print_refs(); |
166 | cgit_print_refs(); |
167 | break; |
167 | break; |
168 | case CMD_TAG: |
168 | case CMD_TAG: |
169 | cgit_print_tag(ctx.qry.sha1); |
169 | cgit_print_tag(ctx.qry.sha1); |
170 | break; |
170 | break; |
171 | case CMD_DIFF: |
171 | case CMD_DIFF: |
172 | cgit_print_diff(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path); |
172 | cgit_print_diff(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path); |
173 | break; |
173 | break; |
174 | default: |
174 | default: |
175 | cgit_print_error("Invalid request"); |
175 | cgit_print_error("Invalid request"); |
176 | } |
176 | } |
177 | cgit_print_docend(); |
177 | cgit_print_docend(); |
178 | } |
178 | } |
179 | |
179 | |
180 | static void cgit_fill_cache(struct cacheitem *item, int use_cache) |
180 | static void cgit_fill_cache(struct cacheitem *item, int use_cache) |
181 | { |
181 | { |
182 | static char buf[PATH_MAX]; |
182 | static char buf[PATH_MAX]; |
183 | int stdout2; |
183 | int stdout2; |
184 | |
184 | |
185 | getcwd(buf, sizeof(buf)); |
185 | getcwd(buf, sizeof(buf)); |
186 | item->st.st_mtime = time(NULL); |
186 | item->st.st_mtime = time(NULL); |
187 | |
187 | |
188 | if (use_cache) { |
188 | if (use_cache) { |
189 | stdout2 = chk_positive(dup(STDOUT_FILENO), |
189 | stdout2 = chk_positive(dup(STDOUT_FILENO), |
190 | "Preserving STDOUT"); |
190 | "Preserving STDOUT"); |
191 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT"); |
191 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT"); |
192 | chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)"); |
192 | chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)"); |
193 | } |
193 | } |
194 | |
194 | |
195 | if (cgit_repo) |
195 | if (ctx.repo) |
196 | cgit_print_repo_page(item); |
196 | cgit_print_repo_page(item); |
197 | else |
197 | else |
198 | cgit_print_repolist(item); |
198 | cgit_print_repolist(item); |
199 | |
199 | |
200 | if (use_cache) { |
200 | if (use_cache) { |
201 | chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); |
201 | chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); |
202 | chk_positive(dup2(stdout2, STDOUT_FILENO), |
202 | chk_positive(dup2(stdout2, STDOUT_FILENO), |
203 | "Restoring original STDOUT"); |
203 | "Restoring original STDOUT"); |
204 | chk_zero(close(stdout2), "Closing temporary STDOUT"); |
204 | chk_zero(close(stdout2), "Closing temporary STDOUT"); |
205 | } |
205 | } |
206 | |
206 | |
207 | chdir(buf); |
207 | chdir(buf); |
208 | } |
208 | } |
209 | |
209 | |
210 | static void cgit_check_cache(struct cacheitem *item) |
210 | static void cgit_check_cache(struct cacheitem *item) |
211 | { |
211 | { |
212 | int i = 0; |
212 | int i = 0; |
213 | |
213 | |
214 | top: |
214 | top: |
215 | if (++i > ctx.cfg.max_lock_attempts) { |
215 | if (++i > ctx.cfg.max_lock_attempts) { |
216 | die("cgit_refresh_cache: unable to lock %s: %s", |
216 | die("cgit_refresh_cache: unable to lock %s: %s", |
217 | item->name, strerror(errno)); |
217 | item->name, strerror(errno)); |
218 | } |
218 | } |
219 | if (!cache_exist(item)) { |
219 | if (!cache_exist(item)) { |
220 | if (!cache_lock(item)) { |
220 | if (!cache_lock(item)) { |
221 | sleep(1); |
221 | sleep(1); |
222 | goto top; |
222 | goto top; |
223 | } |
223 | } |
224 | if (!cache_exist(item)) { |
224 | if (!cache_exist(item)) { |
225 | cgit_fill_cache(item, 1); |
225 | cgit_fill_cache(item, 1); |
226 | cache_unlock(item); |
226 | cache_unlock(item); |
227 | } else { |
227 | } else { |
228 | cache_cancel_lock(item); |
228 | cache_cancel_lock(item); |
229 | } |
229 | } |
230 | } else if (cache_expired(item) && cache_lock(item)) { |
230 | } else if (cache_expired(item) && cache_lock(item)) { |
231 | if (cache_expired(item)) { |
231 | if (cache_expired(item)) { |
232 | cgit_fill_cache(item, 1); |
232 | cgit_fill_cache(item, 1); |
233 | cache_unlock(item); |
233 | cache_unlock(item); |
234 | } else { |
234 | } else { |
235 | cache_cancel_lock(item); |
235 | cache_cancel_lock(item); |
236 | } |
236 | } |
237 | } |
237 | } |
238 | } |
238 | } |
239 | |
239 | |
240 | static void cgit_print_cache(struct cacheitem *item) |
240 | static void cgit_print_cache(struct cacheitem *item) |
241 | { |
241 | { |
242 | static char buf[4096]; |
242 | static char buf[4096]; |
243 | ssize_t i; |
243 | ssize_t i; |
@@ -255,65 +255,64 @@ static void cgit_print_cache(struct cacheitem *item) |
255 | static void cgit_parse_args(int argc, const char **argv) |
255 | static void cgit_parse_args(int argc, const char **argv) |
256 | { |
256 | { |
257 | int i; |
257 | int i; |
258 | |
258 | |
259 | for (i = 1; i < argc; i++) { |
259 | for (i = 1; i < argc; i++) { |
260 | if (!strncmp(argv[i], "--cache=", 8)) { |
260 | if (!strncmp(argv[i], "--cache=", 8)) { |
261 | ctx.cfg.cache_root = xstrdup(argv[i]+8); |
261 | ctx.cfg.cache_root = xstrdup(argv[i]+8); |
262 | } |
262 | } |
263 | if (!strcmp(argv[i], "--nocache")) { |
263 | if (!strcmp(argv[i], "--nocache")) { |
264 | ctx.cfg.nocache = 1; |
264 | ctx.cfg.nocache = 1; |
265 | } |
265 | } |
266 | if (!strncmp(argv[i], "--query=", 8)) { |
266 | if (!strncmp(argv[i], "--query=", 8)) { |
267 | ctx.qry.raw = xstrdup(argv[i]+8); |
267 | ctx.qry.raw = xstrdup(argv[i]+8); |
268 | } |
268 | } |
269 | if (!strncmp(argv[i], "--repo=", 7)) { |
269 | if (!strncmp(argv[i], "--repo=", 7)) { |
270 | ctx.qry.repo = xstrdup(argv[i]+7); |
270 | ctx.qry.repo = xstrdup(argv[i]+7); |
271 | } |
271 | } |
272 | if (!strncmp(argv[i], "--page=", 7)) { |
272 | if (!strncmp(argv[i], "--page=", 7)) { |
273 | ctx.qry.page = xstrdup(argv[i]+7); |
273 | ctx.qry.page = xstrdup(argv[i]+7); |
274 | } |
274 | } |
275 | if (!strncmp(argv[i], "--head=", 7)) { |
275 | if (!strncmp(argv[i], "--head=", 7)) { |
276 | ctx.qry.head = xstrdup(argv[i]+7); |
276 | ctx.qry.head = xstrdup(argv[i]+7); |
277 | ctx.qry.has_symref = 1; |
277 | ctx.qry.has_symref = 1; |
278 | } |
278 | } |
279 | if (!strncmp(argv[i], "--sha1=", 7)) { |
279 | if (!strncmp(argv[i], "--sha1=", 7)) { |
280 | ctx.qry.sha1 = xstrdup(argv[i]+7); |
280 | ctx.qry.sha1 = xstrdup(argv[i]+7); |
281 | ctx.qry.has_sha1 = 1; |
281 | ctx.qry.has_sha1 = 1; |
282 | } |
282 | } |
283 | if (!strncmp(argv[i], "--ofs=", 6)) { |
283 | if (!strncmp(argv[i], "--ofs=", 6)) { |
284 | ctx.qry.ofs = atoi(argv[i]+6); |
284 | ctx.qry.ofs = atoi(argv[i]+6); |
285 | } |
285 | } |
286 | } |
286 | } |
287 | } |
287 | } |
288 | |
288 | |
289 | int main(int argc, const char **argv) |
289 | int main(int argc, const char **argv) |
290 | { |
290 | { |
291 | struct cacheitem item; |
291 | struct cacheitem item; |
292 | const char *cgit_config_env = getenv("CGIT_CONFIG"); |
292 | const char *cgit_config_env = getenv("CGIT_CONFIG"); |
293 | |
293 | |
294 | cgit_prepare_context(&ctx); |
294 | cgit_prepare_context(&ctx); |
295 | htmlfd = STDOUT_FILENO; |
295 | htmlfd = STDOUT_FILENO; |
296 | item.st.st_mtime = time(NULL); |
296 | item.st.st_mtime = time(NULL); |
297 | cgit_repolist.length = 0; |
297 | cgit_repolist.length = 0; |
298 | cgit_repolist.count = 0; |
298 | cgit_repolist.count = 0; |
299 | cgit_repolist.repos = NULL; |
299 | cgit_repolist.repos = NULL; |
300 | |
300 | |
301 | cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG, |
301 | cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG, |
302 | cgit_global_config_cb); |
302 | cgit_global_config_cb); |
303 | cgit_repo = NULL; |
| |
304 | if (getenv("SCRIPT_NAME")) |
303 | if (getenv("SCRIPT_NAME")) |
305 | ctx.cfg.script_name = xstrdup(getenv("SCRIPT_NAME")); |
304 | ctx.cfg.script_name = xstrdup(getenv("SCRIPT_NAME")); |
306 | if (getenv("QUERY_STRING")) |
305 | if (getenv("QUERY_STRING")) |
307 | ctx.qry.raw = xstrdup(getenv("QUERY_STRING")); |
306 | ctx.qry.raw = xstrdup(getenv("QUERY_STRING")); |
308 | cgit_parse_args(argc, argv); |
307 | cgit_parse_args(argc, argv); |
309 | cgit_parse_query(ctx.qry.raw, cgit_querystring_cb); |
308 | cgit_parse_query(ctx.qry.raw, cgit_querystring_cb); |
310 | if (!cgit_prepare_cache(&item)) |
309 | if (!cgit_prepare_cache(&item)) |
311 | return 0; |
310 | return 0; |
312 | if (ctx.cfg.nocache) { |
311 | if (ctx.cfg.nocache) { |
313 | cgit_fill_cache(&item, 0); |
312 | cgit_fill_cache(&item, 0); |
314 | } else { |
313 | } else { |
315 | cgit_check_cache(&item); |
314 | cgit_check_cache(&item); |
316 | cgit_print_cache(&item); |
315 | cgit_print_cache(&item); |
317 | } |
316 | } |
318 | return 0; |
317 | return 0; |
319 | } |
318 | } |
|