ui-tree.c (view raw)
1/* ui-tree.c: functions for tree output
2 *
3 * Copyright (C) 2006 Lars Hjemli
4 *
5 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text)
7 */
8
9#include <ctype.h>
10#include "cgit.h"
11#include "html.h"
12#include "ui-shared.h"
13
14char *curr_rev;
15char *match_path;
16int header = 0;
17
18static void print_text_buffer(const char *name, char *buf, unsigned long size)
19{
20 unsigned long lineno, idx;
21 const char *numberfmt =
22 "<a class='no' id='n%1$d' name='n%1$d' href='#n%1$d'>%1$d</a>\n";
23
24 html("<table summary='blob content' class='blob'>\n");
25 if (ctx.repo->source_filter) {
26 html("<tr><td class='lines'><pre><code>");
27 ctx.repo->source_filter->argv[1] = xstrdup(name);
28 cgit_open_filter(ctx.repo->source_filter);
29 write(STDOUT_FILENO, buf, size);
30 cgit_close_filter(ctx.repo->source_filter);
31 html("</code></pre></td></tr></table>\n");
32 return;
33 }
34
35 html("<tr><td class='linenumbers'><pre>");
36 idx = 0;
37 lineno = 0;
38
39 if (size) {
40 htmlf(numberfmt, ++lineno);
41 while(idx < size - 1) { // skip absolute last newline
42 if (buf[idx] == '\n')
43 htmlf(numberfmt, ++lineno);
44 idx++;
45 }
46 }
47 html("</pre></td>\n");
48 html("<td class='lines'><pre><code>");
49 html_txt(buf);
50 html("</code></pre></td></tr></table>\n");
51}
52
53#define ROWLEN 32
54
55static void print_binary_buffer(char *buf, unsigned long size)
56{
57 unsigned long ofs, idx;
58 static char ascii[ROWLEN + 1];
59
60 html("<table summary='blob content' class='bin-blob'>\n");
61 html("<tr><th>ofs</th><th>hex dump</th><th>ascii</th></tr>");
62 for (ofs = 0; ofs < size; ofs += ROWLEN, buf += ROWLEN) {
63 htmlf("<tr><td class='right'>%04x</td><td class='hex'>", ofs);
64 for (idx = 0; idx < ROWLEN && ofs + idx < size; idx++)
65 htmlf("%*s%02x",
66 idx == 16 ? 4 : 1, "",
67 buf[idx] & 0xff);
68 html(" </td><td class='hex'>");
69 for (idx = 0; idx < ROWLEN && ofs + idx < size; idx++)
70 ascii[idx] = isgraph(buf[idx]) ? buf[idx] : '.';
71 ascii[idx] = '\0';
72 html_txt(ascii);
73 html("</td></tr>\n");
74 }
75 html("</table>\n");
76}
77
78static void print_object(const unsigned char *sha1, char *path, const char *basename)
79{
80 enum object_type type;
81 char *buf;
82 unsigned long size;
83
84 type = sha1_object_info(sha1, &size);
85 if (type == OBJ_BAD) {
86 cgit_print_error(fmt("Bad object name: %s",
87 sha1_to_hex(sha1)));
88 return;
89 }
90
91 buf = read_sha1_file(sha1, &type, &size);
92 if (!buf) {
93 cgit_print_error(fmt("Error reading object %s",
94 sha1_to_hex(sha1)));
95 return;
96 }
97
98 html(" (");
99 cgit_plain_link("plain", NULL, NULL, ctx.qry.head,
100 curr_rev, path);
101 htmlf(")<br/>blob: %s\n", sha1_to_hex(sha1));
102
103 if (buffer_is_binary(buf, size))
104 print_binary_buffer(buf, size);
105 else
106 print_text_buffer(basename, buf, size);
107}
108
109
110static int ls_item(const unsigned char *sha1, const char *base, int baselen,
111 const char *pathname, unsigned int mode, int stage,
112 void *cbdata)
113{
114 char *name;
115 char *fullpath;
116 char *class;
117 enum object_type type;
118 unsigned long size = 0;
119
120 name = xstrdup(pathname);
121 fullpath = fmt("%s%s%s", ctx.qry.path ? ctx.qry.path : "",
122 ctx.qry.path ? "/" : "", name);
123
124 if (!S_ISGITLINK(mode)) {
125 type = sha1_object_info(sha1, &size);
126 if (type == OBJ_BAD) {
127 htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
128 name,
129 sha1_to_hex(sha1));
130 return 0;
131 }
132 }
133
134 html("<tr><td class='ls-mode'>");
135 cgit_print_filemode(mode);
136 html("</td><td>");
137 if (S_ISGITLINK(mode)) {
138 htmlf("<a class='ls-mod' href='");
139 html_attr(fmt(ctx.repo->module_link,
140 name,
141 sha1_to_hex(sha1)));
142 html("'>");
143 html_txt(name);
144 html("</a>");
145 } else if (S_ISDIR(mode)) {
146 cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head,
147 curr_rev, fullpath);
148 } else {
149 class = strrchr(name, '.');
150 if (class != NULL) {
151 class = fmt("ls-blob %s", class + 1);
152 } else
153 class = "ls-blob";
154 cgit_tree_link(name, NULL, class, ctx.qry.head,
155 curr_rev, fullpath);
156 }
157 htmlf("</td><td class='ls-size'>%li</td>", size);
158
159 html("<td>");
160 cgit_log_link("log", NULL, "button", ctx.qry.head, curr_rev,
161 fullpath, 0, NULL, NULL, ctx.qry.showmsg);
162 if (ctx.repo->max_stats)
163 cgit_stats_link("stats", NULL, "button", ctx.qry.head,
164 fullpath);
165 html("</td></tr>\n");
166 free(name);
167 return 0;
168}
169
170static void ls_head()
171{
172 html("<table summary='tree listing' class='list'>\n");
173 html("<tr class='nohover'>");
174 html("<th class='left'>Mode</th>");
175 html("<th class='left'>Name</th>");
176 html("<th class='right'>Size</th>");
177 html("<th/>");
178 html("</tr>\n");
179 header = 1;
180}
181
182static void ls_tail()
183{
184 if (!header)
185 return;
186 html("</table>\n");
187 header = 0;
188}
189
190static void ls_tree(const unsigned char *sha1, char *path)
191{
192 struct tree *tree;
193
194 tree = parse_tree_indirect(sha1);
195 if (!tree) {
196 cgit_print_error(fmt("Not a tree object: %s",
197 sha1_to_hex(sha1)));
198 return;
199 }
200
201 ls_head();
202 read_tree_recursive(tree, "", 0, 1, NULL, ls_item, NULL);
203 ls_tail();
204}
205
206
207static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
208 const char *pathname, unsigned mode, int stage,
209 void *cbdata)
210{
211 static int state;
212 static char buffer[PATH_MAX];
213 char *url;
214
215 if (state == 0) {
216 memcpy(buffer, base, baselen);
217 strcpy(buffer+baselen, pathname);
218 url = cgit_pageurl(ctx.qry.repo, "tree",
219 fmt("h=%s&path=%s", curr_rev, buffer));
220 html("/");
221 cgit_tree_link(xstrdup(pathname), NULL, NULL, ctx.qry.head,
222 curr_rev, buffer);
223
224 if (strcmp(match_path, buffer))
225 return READ_TREE_RECURSIVE;
226
227 if (S_ISDIR(mode)) {
228 state = 1;
229 ls_head();
230 return READ_TREE_RECURSIVE;
231 } else {
232 print_object(sha1, buffer, pathname);
233 return 0;
234 }
235 }
236 ls_item(sha1, base, baselen, pathname, mode, stage, NULL);
237 return 0;
238}
239
240
241/*
242 * Show a tree or a blob
243 * rev: the commit pointing at the root tree object
244 * path: path to tree or blob
245 */
246void cgit_print_tree(const char *rev, char *path)
247{
248 unsigned char sha1[20];
249 struct commit *commit;
250 const char *paths[] = {path, NULL};
251
252 if (!rev)
253 rev = ctx.qry.head;
254
255 curr_rev = xstrdup(rev);
256 if (get_sha1(rev, sha1)) {
257 cgit_print_error(fmt("Invalid revision name: %s", rev));
258 return;
259 }
260 commit = lookup_commit_reference(sha1);
261 if (!commit || parse_commit(commit)) {
262 cgit_print_error(fmt("Invalid commit reference: %s", rev));
263 return;
264 }
265
266 html("path: <a href='");
267 html_attr(cgit_pageurl(ctx.qry.repo, "tree", fmt("h=%s", rev)));
268 html("'>root</a>");
269
270 if (path == NULL) {
271 ls_tree(commit->tree->object.sha1, NULL);
272 return;
273 }
274
275 match_path = path;
276 read_tree_recursive(commit->tree, NULL, 0, 0, paths, walk_tree, NULL);
277 ls_tail();
278}