Add git-for-each-ref: helper for language bindings
[alt-git.git] / builtin-tar-tree.c
blobfa666f78c5b5e44617495abb2716eded8407626c
1 /*
2 * Copyright (c) 2005, 2006 Rene Scharfe
3 */
4 #include <time.h>
5 #include "cache.h"
6 #include "tree-walk.h"
7 #include "commit.h"
8 #include "strbuf.h"
9 #include "tar.h"
10 #include "builtin.h"
11 #include "pkt-line.h"
13 #define RECORDSIZE (512)
14 #define BLOCKSIZE (RECORDSIZE * 20)
16 static const char tar_tree_usage[] =
17 "git-tar-tree [--remote=<repo>] <tree-ish> [basedir]";
19 static char block[BLOCKSIZE];
20 static unsigned long offset;
22 static time_t archive_time;
23 static int tar_umask;
25 /* writes out the whole block, but only if it is full */
26 static void write_if_needed(void)
28 if (offset == BLOCKSIZE) {
29 write_or_die(1, block, BLOCKSIZE);
30 offset = 0;
35 * queues up writes, so that all our write(2) calls write exactly one
36 * full block; pads writes to RECORDSIZE
38 static void write_blocked(const void *data, unsigned long size)
40 const char *buf = data;
41 unsigned long tail;
43 if (offset) {
44 unsigned long chunk = BLOCKSIZE - offset;
45 if (size < chunk)
46 chunk = size;
47 memcpy(block + offset, buf, chunk);
48 size -= chunk;
49 offset += chunk;
50 buf += chunk;
51 write_if_needed();
53 while (size >= BLOCKSIZE) {
54 write_or_die(1, buf, BLOCKSIZE);
55 size -= BLOCKSIZE;
56 buf += BLOCKSIZE;
58 if (size) {
59 memcpy(block + offset, buf, size);
60 offset += size;
62 tail = offset % RECORDSIZE;
63 if (tail) {
64 memset(block + offset, 0, RECORDSIZE - tail);
65 offset += RECORDSIZE - tail;
67 write_if_needed();
71 * The end of tar archives is marked by 2*512 nul bytes and after that
72 * follows the rest of the block (if any).
74 static void write_trailer(void)
76 int tail = BLOCKSIZE - offset;
77 memset(block + offset, 0, tail);
78 write_or_die(1, block, BLOCKSIZE);
79 if (tail < 2 * RECORDSIZE) {
80 memset(block, 0, offset);
81 write_or_die(1, block, BLOCKSIZE);
85 static void strbuf_append_string(struct strbuf *sb, const char *s)
87 int slen = strlen(s);
88 int total = sb->len + slen;
89 if (total > sb->alloc) {
90 sb->buf = xrealloc(sb->buf, total);
91 sb->alloc = total;
93 memcpy(sb->buf + sb->len, s, slen);
94 sb->len = total;
98 * pax extended header records have the format "%u %s=%s\n". %u contains
99 * the size of the whole string (including the %u), the first %s is the
100 * keyword, the second one is the value. This function constructs such a
101 * string and appends it to a struct strbuf.
103 static void strbuf_append_ext_header(struct strbuf *sb, const char *keyword,
104 const char *value, unsigned int valuelen)
106 char *p;
107 int len, total, tmp;
109 /* "%u %s=%s\n" */
110 len = 1 + 1 + strlen(keyword) + 1 + valuelen + 1;
111 for (tmp = len; tmp > 9; tmp /= 10)
112 len++;
114 total = sb->len + len;
115 if (total > sb->alloc) {
116 sb->buf = xrealloc(sb->buf, total);
117 sb->alloc = total;
120 p = sb->buf;
121 p += sprintf(p, "%u %s=", len, keyword);
122 memcpy(p, value, valuelen);
123 p += valuelen;
124 *p = '\n';
125 sb->len = total;
128 static unsigned int ustar_header_chksum(const struct ustar_header *header)
130 char *p = (char *)header;
131 unsigned int chksum = 0;
132 while (p < header->chksum)
133 chksum += *p++;
134 chksum += sizeof(header->chksum) * ' ';
135 p += sizeof(header->chksum);
136 while (p < (char *)header + sizeof(struct ustar_header))
137 chksum += *p++;
138 return chksum;
141 static int get_path_prefix(const struct strbuf *path, int maxlen)
143 int i = path->len;
144 if (i > maxlen)
145 i = maxlen;
146 do {
147 i--;
148 } while (i > 0 && path->buf[i] != '/');
149 return i;
152 static void write_entry(const unsigned char *sha1, struct strbuf *path,
153 unsigned int mode, void *buffer, unsigned long size)
155 struct ustar_header header;
156 struct strbuf ext_header;
158 memset(&header, 0, sizeof(header));
159 ext_header.buf = NULL;
160 ext_header.len = ext_header.alloc = 0;
162 if (!sha1) {
163 *header.typeflag = TYPEFLAG_GLOBAL_HEADER;
164 mode = 0100666;
165 strcpy(header.name, "pax_global_header");
166 } else if (!path) {
167 *header.typeflag = TYPEFLAG_EXT_HEADER;
168 mode = 0100666;
169 sprintf(header.name, "%s.paxheader", sha1_to_hex(sha1));
170 } else {
171 if (S_ISDIR(mode)) {
172 *header.typeflag = TYPEFLAG_DIR;
173 mode = (mode | 0777) & ~tar_umask;
174 } else if (S_ISLNK(mode)) {
175 *header.typeflag = TYPEFLAG_LNK;
176 mode |= 0777;
177 } else if (S_ISREG(mode)) {
178 *header.typeflag = TYPEFLAG_REG;
179 mode = (mode | ((mode & 0100) ? 0777 : 0666)) & ~tar_umask;
180 } else {
181 error("unsupported file mode: 0%o (SHA1: %s)",
182 mode, sha1_to_hex(sha1));
183 return;
185 if (path->len > sizeof(header.name)) {
186 int plen = get_path_prefix(path, sizeof(header.prefix));
187 int rest = path->len - plen - 1;
188 if (plen > 0 && rest <= sizeof(header.name)) {
189 memcpy(header.prefix, path->buf, plen);
190 memcpy(header.name, path->buf + plen + 1, rest);
191 } else {
192 sprintf(header.name, "%s.data",
193 sha1_to_hex(sha1));
194 strbuf_append_ext_header(&ext_header, "path",
195 path->buf, path->len);
197 } else
198 memcpy(header.name, path->buf, path->len);
201 if (S_ISLNK(mode) && buffer) {
202 if (size > sizeof(header.linkname)) {
203 sprintf(header.linkname, "see %s.paxheader",
204 sha1_to_hex(sha1));
205 strbuf_append_ext_header(&ext_header, "linkpath",
206 buffer, size);
207 } else
208 memcpy(header.linkname, buffer, size);
211 sprintf(header.mode, "%07o", mode & 07777);
212 sprintf(header.size, "%011lo", S_ISREG(mode) ? size : 0);
213 sprintf(header.mtime, "%011lo", archive_time);
215 /* XXX: should we provide more meaningful info here? */
216 sprintf(header.uid, "%07o", 0);
217 sprintf(header.gid, "%07o", 0);
218 strlcpy(header.uname, "git", sizeof(header.uname));
219 strlcpy(header.gname, "git", sizeof(header.gname));
220 sprintf(header.devmajor, "%07o", 0);
221 sprintf(header.devminor, "%07o", 0);
223 memcpy(header.magic, "ustar", 6);
224 memcpy(header.version, "00", 2);
226 sprintf(header.chksum, "%07o", ustar_header_chksum(&header));
228 if (ext_header.len > 0) {
229 write_entry(sha1, NULL, 0, ext_header.buf, ext_header.len);
230 free(ext_header.buf);
232 write_blocked(&header, sizeof(header));
233 if (S_ISREG(mode) && buffer && size > 0)
234 write_blocked(buffer, size);
237 static void write_global_extended_header(const unsigned char *sha1)
239 struct strbuf ext_header;
240 ext_header.buf = NULL;
241 ext_header.len = ext_header.alloc = 0;
242 strbuf_append_ext_header(&ext_header, "comment", sha1_to_hex(sha1), 40);
243 write_entry(NULL, NULL, 0, ext_header.buf, ext_header.len);
244 free(ext_header.buf);
247 static void traverse_tree(struct tree_desc *tree, struct strbuf *path)
249 int pathlen = path->len;
250 struct name_entry entry;
252 while (tree_entry(tree, &entry)) {
253 void *eltbuf;
254 char elttype[20];
255 unsigned long eltsize;
257 eltbuf = read_sha1_file(entry.sha1, elttype, &eltsize);
258 if (!eltbuf)
259 die("cannot read %s", sha1_to_hex(entry.sha1));
261 path->len = pathlen;
262 strbuf_append_string(path, entry.path);
263 if (S_ISDIR(entry.mode))
264 strbuf_append_string(path, "/");
266 write_entry(entry.sha1, path, entry.mode, eltbuf, eltsize);
268 if (S_ISDIR(entry.mode)) {
269 struct tree_desc subtree;
270 subtree.buf = eltbuf;
271 subtree.size = eltsize;
272 traverse_tree(&subtree, path);
274 free(eltbuf);
278 static int git_tar_config(const char *var, const char *value)
280 if (!strcmp(var, "tar.umask")) {
281 if (!strcmp(value, "user")) {
282 tar_umask = umask(0);
283 umask(tar_umask);
284 } else {
285 tar_umask = git_config_int(var, value);
287 return 0;
289 return git_default_config(var, value);
292 static int generate_tar(int argc, const char **argv, const char *prefix)
294 unsigned char sha1[20], tree_sha1[20];
295 struct commit *commit;
296 struct tree_desc tree;
297 struct strbuf current_path;
298 void *buffer;
300 current_path.buf = xmalloc(PATH_MAX);
301 current_path.alloc = PATH_MAX;
302 current_path.len = current_path.eof = 0;
304 git_config(git_tar_config);
306 switch (argc) {
307 case 3:
308 strbuf_append_string(&current_path, argv[2]);
309 strbuf_append_string(&current_path, "/");
310 /* FALLTHROUGH */
311 case 2:
312 if (get_sha1(argv[1], sha1))
313 die("Not a valid object name %s", argv[1]);
314 break;
315 default:
316 usage(tar_tree_usage);
319 commit = lookup_commit_reference_gently(sha1, 1);
320 if (commit) {
321 write_global_extended_header(commit->object.sha1);
322 archive_time = commit->date;
323 } else
324 archive_time = time(NULL);
326 tree.buf = buffer = read_object_with_reference(sha1, tree_type,
327 &tree.size, tree_sha1);
328 if (!tree.buf)
329 die("not a reference to a tag, commit or tree object: %s",
330 sha1_to_hex(sha1));
332 if (current_path.len > 0)
333 write_entry(tree_sha1, &current_path, 040777, NULL, 0);
334 traverse_tree(&tree, &current_path);
335 write_trailer();
336 free(buffer);
337 free(current_path.buf);
338 return 0;
341 static const char *exec = "git-upload-tar";
343 static int remote_tar(int argc, const char **argv)
345 int fd[2], ret, len;
346 pid_t pid;
347 char buf[1024];
348 char *url;
350 if (argc < 3 || 4 < argc)
351 usage(tar_tree_usage);
353 /* --remote=<repo> */
354 url = xstrdup(argv[1]+9);
355 pid = git_connect(fd, url, exec);
356 if (pid < 0)
357 return 1;
359 packet_write(fd[1], "want %s\n", argv[2]);
360 if (argv[3])
361 packet_write(fd[1], "base %s\n", argv[3]);
362 packet_flush(fd[1]);
364 len = packet_read_line(fd[0], buf, sizeof(buf));
365 if (!len)
366 die("git-tar-tree: expected ACK/NAK, got EOF");
367 if (buf[len-1] == '\n')
368 buf[--len] = 0;
369 if (strcmp(buf, "ACK")) {
370 if (5 < len && !strncmp(buf, "NACK ", 5))
371 die("git-tar-tree: NACK %s", buf + 5);
372 die("git-tar-tree: protocol error");
374 /* expect a flush */
375 len = packet_read_line(fd[0], buf, sizeof(buf));
376 if (len)
377 die("git-tar-tree: expected a flush");
379 /* Now, start reading from fd[0] and spit it out to stdout */
380 ret = copy_fd(fd[0], 1);
381 close(fd[0]);
383 ret |= finish_connect(pid);
384 return !!ret;
387 int cmd_tar_tree(int argc, const char **argv, const char *prefix)
389 if (argc < 2)
390 usage(tar_tree_usage);
391 if (!strncmp("--remote=", argv[1], 9))
392 return remote_tar(argc, argv);
393 return generate_tar(argc, argv, prefix);
396 /* ustar header + extended global header content */
397 #define HEADERSIZE (2 * RECORDSIZE)
399 int cmd_get_tar_commit_id(int argc, const char **argv, const char *prefix)
401 char buffer[HEADERSIZE];
402 struct ustar_header *header = (struct ustar_header *)buffer;
403 char *content = buffer + RECORDSIZE;
404 ssize_t n;
406 n = xread(0, buffer, HEADERSIZE);
407 if (n < HEADERSIZE)
408 die("git-get-tar-commit-id: read error");
409 if (header->typeflag[0] != 'g')
410 return 1;
411 if (memcmp(content, "52 comment=", 11))
412 return 1;
414 n = xwrite(1, content + 11, 41);
415 if (n < 41)
416 die("git-get-tar-commit-id: write error");
418 return 0;