author | Martins Polakovs <martins.polakovs@gmail.com> | 2009-12-10 15:35:42 (UTC) |
---|---|---|
committer | Lars Hjemli <hjemli@gmail.com> | 2009-12-12 10:56:25 (UTC) |
commit | 24538b072718924d3418a258cf0009fb5b5768de (patch) (unidiff) | |
tree | 54a2ea6fb82c5ff99f188624a24b7c5d54657095 | |
parent | f2bf0a05280edddb4961214adfd7b440191737e2 (diff) | |
download | cgit-24538b072718924d3418a258cf0009fb5b5768de.zip cgit-24538b072718924d3418a258cf0009fb5b5768de.tar.gz cgit-24538b072718924d3418a258cf0009fb5b5768de.tar.bz2 |
Fix segfault on ppc when browsing tree
-rw-r--r-- | ui-blob.c | 2 | ||||
-rw-r--r-- | ui-plain.c | 2 | ||||
-rw-r--r-- | ui-tree.c | 2 |
3 files changed, 3 insertions, 3 deletions
@@ -1,79 +1,79 @@ | |||
1 | /* ui-blob.c: show blob content | 1 | /* ui-blob.c: show blob content |
2 | * | 2 | * |
3 | * Copyright (C) 2008 Lars Hjemli | 3 | * Copyright (C) 2008 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 | #include "html.h" |
11 | #include "ui-shared.h" | 11 | #include "ui-shared.h" |
12 | 12 | ||
13 | static char *match_path; | 13 | static char *match_path; |
14 | static unsigned char *matched_sha1; | 14 | static unsigned char *matched_sha1; |
15 | 15 | ||
16 | static int walk_tree(const unsigned char *sha1, const char *base,int baselen, | 16 | static int walk_tree(const unsigned char *sha1, const char *base,int baselen, |
17 | const char *pathname, unsigned mode, int stage, void *cbdata) { | 17 | const char *pathname, unsigned mode, int stage, void *cbdata) { |
18 | if(strncmp(base,match_path,baselen) | 18 | if(strncmp(base,match_path,baselen) |
19 | || strcmp(match_path+baselen,pathname) ) | 19 | || strcmp(match_path+baselen,pathname) ) |
20 | return READ_TREE_RECURSIVE; | 20 | return READ_TREE_RECURSIVE; |
21 | memmove(matched_sha1,sha1,20); | 21 | memmove(matched_sha1,sha1,20); |
22 | return 0; | 22 | return 0; |
23 | } | 23 | } |
24 | 24 | ||
25 | void cgit_print_blob(const char *hex, char *path, const char *head) | 25 | void cgit_print_blob(const char *hex, char *path, const char *head) |
26 | { | 26 | { |
27 | 27 | ||
28 | unsigned char sha1[20]; | 28 | unsigned char sha1[20]; |
29 | enum object_type type; | 29 | enum object_type type; |
30 | char *buf; | 30 | char *buf; |
31 | unsigned long size; | 31 | unsigned long size; |
32 | struct commit *commit; | 32 | struct commit *commit; |
33 | const char *paths[] = {path, NULL}; | 33 | const char *paths[] = {path, NULL}; |
34 | 34 | ||
35 | if (hex) { | 35 | if (hex) { |
36 | if (get_sha1_hex(hex, sha1)){ | 36 | if (get_sha1_hex(hex, sha1)){ |
37 | cgit_print_error(fmt("Bad hex value: %s", hex)); | 37 | cgit_print_error(fmt("Bad hex value: %s", hex)); |
38 | return; | 38 | return; |
39 | } | 39 | } |
40 | } else { | 40 | } else { |
41 | if (get_sha1(head,sha1)) { | 41 | if (get_sha1(head,sha1)) { |
42 | cgit_print_error(fmt("Bad ref: %s", head)); | 42 | cgit_print_error(fmt("Bad ref: %s", head)); |
43 | return; | 43 | return; |
44 | } | 44 | } |
45 | } | 45 | } |
46 | 46 | ||
47 | type = sha1_object_info(sha1, &size); | 47 | type = sha1_object_info(sha1, &size); |
48 | 48 | ||
49 | if((!hex) && type == OBJ_COMMIT && path) { | 49 | if((!hex) && type == OBJ_COMMIT && path) { |
50 | commit = lookup_commit_reference(sha1); | 50 | commit = lookup_commit_reference(sha1); |
51 | match_path = path; | 51 | match_path = path; |
52 | matched_sha1 = sha1; | 52 | matched_sha1 = sha1; |
53 | read_tree_recursive(commit->tree, NULL, 0, 0, paths, walk_tree, NULL); | 53 | read_tree_recursive(commit->tree, "", 0, 0, paths, walk_tree, NULL); |
54 | type = sha1_object_info(sha1,&size); | 54 | type = sha1_object_info(sha1,&size); |
55 | } | 55 | } |
56 | 56 | ||
57 | if (type == OBJ_BAD) { | 57 | if (type == OBJ_BAD) { |
58 | cgit_print_error(fmt("Bad object name: %s", hex)); | 58 | cgit_print_error(fmt("Bad object name: %s", hex)); |
59 | return; | 59 | return; |
60 | } | 60 | } |
61 | 61 | ||
62 | buf = read_sha1_file(sha1, &type, &size); | 62 | buf = read_sha1_file(sha1, &type, &size); |
63 | if (!buf) { | 63 | if (!buf) { |
64 | cgit_print_error(fmt("Error reading object %s", hex)); | 64 | cgit_print_error(fmt("Error reading object %s", hex)); |
65 | return; | 65 | return; |
66 | } | 66 | } |
67 | 67 | ||
68 | buf[size] = '\0'; | 68 | buf[size] = '\0'; |
69 | ctx.page.mimetype = ctx.qry.mimetype; | 69 | ctx.page.mimetype = ctx.qry.mimetype; |
70 | if (!ctx.page.mimetype) { | 70 | if (!ctx.page.mimetype) { |
71 | if (buffer_is_binary(buf, size)) | 71 | if (buffer_is_binary(buf, size)) |
72 | ctx.page.mimetype = "application/octet-stream"; | 72 | ctx.page.mimetype = "application/octet-stream"; |
73 | else | 73 | else |
74 | ctx.page.mimetype = "text/plain"; | 74 | ctx.page.mimetype = "text/plain"; |
75 | } | 75 | } |
76 | ctx.page.filename = path; | 76 | ctx.page.filename = path; |
77 | cgit_print_http_headers(&ctx); | 77 | cgit_print_http_headers(&ctx); |
78 | write(htmlfd, buf, size); | 78 | write(htmlfd, buf, size); |
79 | } | 79 | } |
@@ -1,94 +1,94 @@ | |||
1 | /* ui-plain.c: functions for output of plain blobs by path | 1 | /* ui-plain.c: functions for output of plain blobs by path |
2 | * | 2 | * |
3 | * Copyright (C) 2008 Lars Hjemli | 3 | * Copyright (C) 2008 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 | #include "html.h" |
11 | #include "ui-shared.h" | 11 | #include "ui-shared.h" |
12 | 12 | ||
13 | char *curr_rev; | 13 | char *curr_rev; |
14 | char *match_path; | 14 | char *match_path; |
15 | int match; | 15 | int match; |
16 | 16 | ||
17 | static void print_object(const unsigned char *sha1, const char *path) | 17 | static void print_object(const unsigned char *sha1, const char *path) |
18 | { | 18 | { |
19 | enum object_type type; | 19 | enum object_type type; |
20 | char *buf, *ext; | 20 | char *buf, *ext; |
21 | unsigned long size; | 21 | unsigned long size; |
22 | struct string_list_item *mime; | 22 | struct string_list_item *mime; |
23 | 23 | ||
24 | type = sha1_object_info(sha1, &size); | 24 | type = sha1_object_info(sha1, &size); |
25 | if (type == OBJ_BAD) { | 25 | if (type == OBJ_BAD) { |
26 | html_status(404, "Not found", 0); | 26 | html_status(404, "Not found", 0); |
27 | return; | 27 | return; |
28 | } | 28 | } |
29 | 29 | ||
30 | buf = read_sha1_file(sha1, &type, &size); | 30 | buf = read_sha1_file(sha1, &type, &size); |
31 | if (!buf) { | 31 | if (!buf) { |
32 | html_status(404, "Not found", 0); | 32 | html_status(404, "Not found", 0); |
33 | return; | 33 | return; |
34 | } | 34 | } |
35 | ctx.page.mimetype = NULL; | 35 | ctx.page.mimetype = NULL; |
36 | ext = strrchr(path, '.'); | 36 | ext = strrchr(path, '.'); |
37 | if (ext && *(++ext)) { | 37 | if (ext && *(++ext)) { |
38 | mime = string_list_lookup(ext, &ctx.cfg.mimetypes); | 38 | mime = string_list_lookup(ext, &ctx.cfg.mimetypes); |
39 | if (mime) | 39 | if (mime) |
40 | ctx.page.mimetype = (char *)mime->util; | 40 | ctx.page.mimetype = (char *)mime->util; |
41 | } | 41 | } |
42 | if (!ctx.page.mimetype) { | 42 | if (!ctx.page.mimetype) { |
43 | if (buffer_is_binary(buf, size)) | 43 | if (buffer_is_binary(buf, size)) |
44 | ctx.page.mimetype = "application/octet-stream"; | 44 | ctx.page.mimetype = "application/octet-stream"; |
45 | else | 45 | else |
46 | ctx.page.mimetype = "text/plain"; | 46 | ctx.page.mimetype = "text/plain"; |
47 | } | 47 | } |
48 | ctx.page.filename = fmt("%s", path); | 48 | ctx.page.filename = fmt("%s", path); |
49 | ctx.page.size = size; | 49 | ctx.page.size = size; |
50 | ctx.page.etag = sha1_to_hex(sha1); | 50 | ctx.page.etag = sha1_to_hex(sha1); |
51 | cgit_print_http_headers(&ctx); | 51 | cgit_print_http_headers(&ctx); |
52 | html_raw(buf, size); | 52 | html_raw(buf, size); |
53 | match = 1; | 53 | match = 1; |
54 | } | 54 | } |
55 | 55 | ||
56 | static int walk_tree(const unsigned char *sha1, const char *base, int baselen, | 56 | static int walk_tree(const unsigned char *sha1, const char *base, int baselen, |
57 | const char *pathname, unsigned mode, int stage, | 57 | const char *pathname, unsigned mode, int stage, |
58 | void *cbdata) | 58 | void *cbdata) |
59 | { | 59 | { |
60 | if (S_ISDIR(mode)) | 60 | if (S_ISDIR(mode)) |
61 | return READ_TREE_RECURSIVE; | 61 | return READ_TREE_RECURSIVE; |
62 | 62 | ||
63 | if (S_ISREG(mode) && !strncmp(base, match_path, baselen) && | 63 | if (S_ISREG(mode) && !strncmp(base, match_path, baselen) && |
64 | !strcmp(pathname, match_path + baselen)) | 64 | !strcmp(pathname, match_path + baselen)) |
65 | print_object(sha1, pathname); | 65 | print_object(sha1, pathname); |
66 | 66 | ||
67 | return 0; | 67 | return 0; |
68 | } | 68 | } |
69 | 69 | ||
70 | void cgit_print_plain(struct cgit_context *ctx) | 70 | void cgit_print_plain(struct cgit_context *ctx) |
71 | { | 71 | { |
72 | const char *rev = ctx->qry.sha1; | 72 | const char *rev = ctx->qry.sha1; |
73 | unsigned char sha1[20]; | 73 | unsigned char sha1[20]; |
74 | struct commit *commit; | 74 | struct commit *commit; |
75 | const char *paths[] = {ctx->qry.path, NULL}; | 75 | const char *paths[] = {ctx->qry.path, NULL}; |
76 | 76 | ||
77 | if (!rev) | 77 | if (!rev) |
78 | rev = ctx->qry.head; | 78 | rev = ctx->qry.head; |
79 | 79 | ||
80 | curr_rev = xstrdup(rev); | 80 | curr_rev = xstrdup(rev); |
81 | if (get_sha1(rev, sha1)) { | 81 | if (get_sha1(rev, sha1)) { |
82 | html_status(404, "Not found", 0); | 82 | html_status(404, "Not found", 0); |
83 | return; | 83 | return; |
84 | } | 84 | } |
85 | commit = lookup_commit_reference(sha1); | 85 | commit = lookup_commit_reference(sha1); |
86 | if (!commit || parse_commit(commit)) { | 86 | if (!commit || parse_commit(commit)) { |
87 | html_status(404, "Not found", 0); | 87 | html_status(404, "Not found", 0); |
88 | return; | 88 | return; |
89 | } | 89 | } |
90 | match_path = ctx->qry.path; | 90 | match_path = ctx->qry.path; |
91 | read_tree_recursive(commit->tree, NULL, 0, 0, paths, walk_tree, NULL); | 91 | read_tree_recursive(commit->tree, "", 0, 0, paths, walk_tree, NULL); |
92 | if (!match) | 92 | if (!match) |
93 | html_status(404, "Not found", 0); | 93 | html_status(404, "Not found", 0); |
94 | } | 94 | } |
@@ -91,195 +91,195 @@ static void print_object(const unsigned char *sha1, char *path, const char *base | |||
91 | type = sha1_object_info(sha1, &size); | 91 | type = sha1_object_info(sha1, &size); |
92 | if (type == OBJ_BAD) { | 92 | if (type == OBJ_BAD) { |
93 | cgit_print_error(fmt("Bad object name: %s", | 93 | cgit_print_error(fmt("Bad object name: %s", |
94 | sha1_to_hex(sha1))); | 94 | sha1_to_hex(sha1))); |
95 | return; | 95 | return; |
96 | } | 96 | } |
97 | 97 | ||
98 | buf = read_sha1_file(sha1, &type, &size); | 98 | buf = read_sha1_file(sha1, &type, &size); |
99 | if (!buf) { | 99 | if (!buf) { |
100 | cgit_print_error(fmt("Error reading object %s", | 100 | cgit_print_error(fmt("Error reading object %s", |
101 | sha1_to_hex(sha1))); | 101 | sha1_to_hex(sha1))); |
102 | return; | 102 | return; |
103 | } | 103 | } |
104 | 104 | ||
105 | html(" ("); | 105 | html(" ("); |
106 | cgit_plain_link("plain", NULL, NULL, ctx.qry.head, | 106 | cgit_plain_link("plain", NULL, NULL, ctx.qry.head, |
107 | curr_rev, path); | 107 | curr_rev, path); |
108 | htmlf(")<br/>blob: %s\n", sha1_to_hex(sha1)); | 108 | htmlf(")<br/>blob: %s\n", sha1_to_hex(sha1)); |
109 | 109 | ||
110 | if (buffer_is_binary(buf, size)) | 110 | if (buffer_is_binary(buf, size)) |
111 | print_binary_buffer(buf, size); | 111 | print_binary_buffer(buf, size); |
112 | else | 112 | else |
113 | print_text_buffer(basename, buf, size); | 113 | print_text_buffer(basename, buf, size); |
114 | } | 114 | } |
115 | 115 | ||
116 | 116 | ||
117 | static int ls_item(const unsigned char *sha1, const char *base, int baselen, | 117 | static int ls_item(const unsigned char *sha1, const char *base, int baselen, |
118 | const char *pathname, unsigned int mode, int stage, | 118 | const char *pathname, unsigned int mode, int stage, |
119 | void *cbdata) | 119 | void *cbdata) |
120 | { | 120 | { |
121 | char *name; | 121 | char *name; |
122 | char *fullpath; | 122 | char *fullpath; |
123 | char *class; | 123 | char *class; |
124 | enum object_type type; | 124 | enum object_type type; |
125 | unsigned long size = 0; | 125 | unsigned long size = 0; |
126 | 126 | ||
127 | name = xstrdup(pathname); | 127 | name = xstrdup(pathname); |
128 | fullpath = fmt("%s%s%s", ctx.qry.path ? ctx.qry.path : "", | 128 | fullpath = fmt("%s%s%s", ctx.qry.path ? ctx.qry.path : "", |
129 | ctx.qry.path ? "/" : "", name); | 129 | ctx.qry.path ? "/" : "", name); |
130 | 130 | ||
131 | if (!S_ISGITLINK(mode)) { | 131 | if (!S_ISGITLINK(mode)) { |
132 | type = sha1_object_info(sha1, &size); | 132 | type = sha1_object_info(sha1, &size); |
133 | if (type == OBJ_BAD) { | 133 | if (type == OBJ_BAD) { |
134 | htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>", | 134 | htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>", |
135 | name, | 135 | name, |
136 | sha1_to_hex(sha1)); | 136 | sha1_to_hex(sha1)); |
137 | return 0; | 137 | return 0; |
138 | } | 138 | } |
139 | } | 139 | } |
140 | 140 | ||
141 | html("<tr><td class='ls-mode'>"); | 141 | html("<tr><td class='ls-mode'>"); |
142 | cgit_print_filemode(mode); | 142 | cgit_print_filemode(mode); |
143 | html("</td><td>"); | 143 | html("</td><td>"); |
144 | if (S_ISGITLINK(mode)) { | 144 | if (S_ISGITLINK(mode)) { |
145 | htmlf("<a class='ls-mod' href='"); | 145 | htmlf("<a class='ls-mod' href='"); |
146 | html_attr(fmt(ctx.repo->module_link, | 146 | html_attr(fmt(ctx.repo->module_link, |
147 | name, | 147 | name, |
148 | sha1_to_hex(sha1))); | 148 | sha1_to_hex(sha1))); |
149 | html("'>"); | 149 | html("'>"); |
150 | html_txt(name); | 150 | html_txt(name); |
151 | html("</a>"); | 151 | html("</a>"); |
152 | } else if (S_ISDIR(mode)) { | 152 | } else if (S_ISDIR(mode)) { |
153 | cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head, | 153 | cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head, |
154 | curr_rev, fullpath); | 154 | curr_rev, fullpath); |
155 | } else { | 155 | } else { |
156 | class = strrchr(name, '.'); | 156 | class = strrchr(name, '.'); |
157 | if (class != NULL) { | 157 | if (class != NULL) { |
158 | class = fmt("ls-blob %s", class + 1); | 158 | class = fmt("ls-blob %s", class + 1); |
159 | } else | 159 | } else |
160 | class = "ls-blob"; | 160 | class = "ls-blob"; |
161 | cgit_tree_link(name, NULL, class, ctx.qry.head, | 161 | cgit_tree_link(name, NULL, class, ctx.qry.head, |
162 | curr_rev, fullpath); | 162 | curr_rev, fullpath); |
163 | } | 163 | } |
164 | htmlf("</td><td class='ls-size'>%li</td>", size); | 164 | htmlf("</td><td class='ls-size'>%li</td>", size); |
165 | 165 | ||
166 | html("<td>"); | 166 | html("<td>"); |
167 | cgit_log_link("log", NULL, "button", ctx.qry.head, curr_rev, | 167 | cgit_log_link("log", NULL, "button", ctx.qry.head, curr_rev, |
168 | fullpath, 0, NULL, NULL, ctx.qry.showmsg); | 168 | fullpath, 0, NULL, NULL, ctx.qry.showmsg); |
169 | if (ctx.repo->max_stats) | 169 | if (ctx.repo->max_stats) |
170 | cgit_stats_link("stats", NULL, "button", ctx.qry.head, | 170 | cgit_stats_link("stats", NULL, "button", ctx.qry.head, |
171 | fullpath); | 171 | fullpath); |
172 | html("</td></tr>\n"); | 172 | html("</td></tr>\n"); |
173 | free(name); | 173 | free(name); |
174 | return 0; | 174 | return 0; |
175 | } | 175 | } |
176 | 176 | ||
177 | static void ls_head() | 177 | static void ls_head() |
178 | { | 178 | { |
179 | html("<table summary='tree listing' class='list'>\n"); | 179 | html("<table summary='tree listing' class='list'>\n"); |
180 | html("<tr class='nohover'>"); | 180 | html("<tr class='nohover'>"); |
181 | html("<th class='left'>Mode</th>"); | 181 | html("<th class='left'>Mode</th>"); |
182 | html("<th class='left'>Name</th>"); | 182 | html("<th class='left'>Name</th>"); |
183 | html("<th class='right'>Size</th>"); | 183 | html("<th class='right'>Size</th>"); |
184 | html("<th/>"); | 184 | html("<th/>"); |
185 | html("</tr>\n"); | 185 | html("</tr>\n"); |
186 | header = 1; | 186 | header = 1; |
187 | } | 187 | } |
188 | 188 | ||
189 | static void ls_tail() | 189 | static void ls_tail() |
190 | { | 190 | { |
191 | if (!header) | 191 | if (!header) |
192 | return; | 192 | return; |
193 | html("</table>\n"); | 193 | html("</table>\n"); |
194 | header = 0; | 194 | header = 0; |
195 | } | 195 | } |
196 | 196 | ||
197 | static void ls_tree(const unsigned char *sha1, char *path) | 197 | static void ls_tree(const unsigned char *sha1, char *path) |
198 | { | 198 | { |
199 | struct tree *tree; | 199 | struct tree *tree; |
200 | 200 | ||
201 | tree = parse_tree_indirect(sha1); | 201 | tree = parse_tree_indirect(sha1); |
202 | if (!tree) { | 202 | if (!tree) { |
203 | cgit_print_error(fmt("Not a tree object: %s", | 203 | cgit_print_error(fmt("Not a tree object: %s", |
204 | sha1_to_hex(sha1))); | 204 | sha1_to_hex(sha1))); |
205 | return; | 205 | return; |
206 | } | 206 | } |
207 | 207 | ||
208 | ls_head(); | 208 | ls_head(); |
209 | read_tree_recursive(tree, "", 0, 1, NULL, ls_item, NULL); | 209 | read_tree_recursive(tree, "", 0, 1, NULL, ls_item, NULL); |
210 | ls_tail(); | 210 | ls_tail(); |
211 | } | 211 | } |
212 | 212 | ||
213 | 213 | ||
214 | static int walk_tree(const unsigned char *sha1, const char *base, int baselen, | 214 | static int walk_tree(const unsigned char *sha1, const char *base, int baselen, |
215 | const char *pathname, unsigned mode, int stage, | 215 | const char *pathname, unsigned mode, int stage, |
216 | void *cbdata) | 216 | void *cbdata) |
217 | { | 217 | { |
218 | static int state; | 218 | static int state; |
219 | static char buffer[PATH_MAX]; | 219 | static char buffer[PATH_MAX]; |
220 | char *url; | 220 | char *url; |
221 | 221 | ||
222 | if (state == 0) { | 222 | if (state == 0) { |
223 | memcpy(buffer, base, baselen); | 223 | memcpy(buffer, base, baselen); |
224 | strcpy(buffer+baselen, pathname); | 224 | strcpy(buffer+baselen, pathname); |
225 | url = cgit_pageurl(ctx.qry.repo, "tree", | 225 | url = cgit_pageurl(ctx.qry.repo, "tree", |
226 | fmt("h=%s&path=%s", curr_rev, buffer)); | 226 | fmt("h=%s&path=%s", curr_rev, buffer)); |
227 | html("/"); | 227 | html("/"); |
228 | cgit_tree_link(xstrdup(pathname), NULL, NULL, ctx.qry.head, | 228 | cgit_tree_link(xstrdup(pathname), NULL, NULL, ctx.qry.head, |
229 | curr_rev, buffer); | 229 | curr_rev, buffer); |
230 | 230 | ||
231 | if (strcmp(match_path, buffer)) | 231 | if (strcmp(match_path, buffer)) |
232 | return READ_TREE_RECURSIVE; | 232 | return READ_TREE_RECURSIVE; |
233 | 233 | ||
234 | if (S_ISDIR(mode)) { | 234 | if (S_ISDIR(mode)) { |
235 | state = 1; | 235 | state = 1; |
236 | ls_head(); | 236 | ls_head(); |
237 | return READ_TREE_RECURSIVE; | 237 | return READ_TREE_RECURSIVE; |
238 | } else { | 238 | } else { |
239 | print_object(sha1, buffer, pathname); | 239 | print_object(sha1, buffer, pathname); |
240 | return 0; | 240 | return 0; |
241 | } | 241 | } |
242 | } | 242 | } |
243 | ls_item(sha1, base, baselen, pathname, mode, stage, NULL); | 243 | ls_item(sha1, base, baselen, pathname, mode, stage, NULL); |
244 | return 0; | 244 | return 0; |
245 | } | 245 | } |
246 | 246 | ||
247 | 247 | ||
248 | /* | 248 | /* |
249 | * Show a tree or a blob | 249 | * Show a tree or a blob |
250 | * rev: the commit pointing at the root tree object | 250 | * rev: the commit pointing at the root tree object |
251 | * path: path to tree or blob | 251 | * path: path to tree or blob |
252 | */ | 252 | */ |
253 | void cgit_print_tree(const char *rev, char *path) | 253 | void cgit_print_tree(const char *rev, char *path) |
254 | { | 254 | { |
255 | unsigned char sha1[20]; | 255 | unsigned char sha1[20]; |
256 | struct commit *commit; | 256 | struct commit *commit; |
257 | const char *paths[] = {path, NULL}; | 257 | const char *paths[] = {path, NULL}; |
258 | 258 | ||
259 | if (!rev) | 259 | if (!rev) |
260 | rev = ctx.qry.head; | 260 | rev = ctx.qry.head; |
261 | 261 | ||
262 | curr_rev = xstrdup(rev); | 262 | curr_rev = xstrdup(rev); |
263 | if (get_sha1(rev, sha1)) { | 263 | if (get_sha1(rev, sha1)) { |
264 | cgit_print_error(fmt("Invalid revision name: %s", rev)); | 264 | cgit_print_error(fmt("Invalid revision name: %s", rev)); |
265 | return; | 265 | return; |
266 | } | 266 | } |
267 | commit = lookup_commit_reference(sha1); | 267 | commit = lookup_commit_reference(sha1); |
268 | if (!commit || parse_commit(commit)) { | 268 | if (!commit || parse_commit(commit)) { |
269 | cgit_print_error(fmt("Invalid commit reference: %s", rev)); | 269 | cgit_print_error(fmt("Invalid commit reference: %s", rev)); |
270 | return; | 270 | return; |
271 | } | 271 | } |
272 | 272 | ||
273 | html("path: <a href='"); | 273 | html("path: <a href='"); |
274 | html_attr(cgit_pageurl(ctx.qry.repo, "tree", fmt("h=%s", rev))); | 274 | html_attr(cgit_pageurl(ctx.qry.repo, "tree", fmt("h=%s", rev))); |
275 | html("'>root</a>"); | 275 | html("'>root</a>"); |
276 | 276 | ||
277 | if (path == NULL) { | 277 | if (path == NULL) { |
278 | ls_tree(commit->tree->object.sha1, NULL); | 278 | ls_tree(commit->tree->object.sha1, NULL); |
279 | return; | 279 | return; |
280 | } | 280 | } |
281 | 281 | ||
282 | match_path = path; | 282 | match_path = path; |
283 | read_tree_recursive(commit->tree, NULL, 0, 0, paths, walk_tree, NULL); | 283 | read_tree_recursive(commit->tree, "", 0, 0, paths, walk_tree, NULL); |
284 | ls_tail(); | 284 | ls_tail(); |
285 | } | 285 | } |