submodule: Use cat instead of echo to avoid DOS line-endings
[git/dscho.git] / archive-tar.c
blob20af0051a334a1357b055ea10d74f5380117ab68
1 /*
2 * Copyright (c) 2005, 2006 Rene Scharfe
3 */
4 #include "cache.h"
5 #include "tar.h"
6 #include "archive.h"
7 #include "run-command.h"
9 #define RECORDSIZE (512)
10 #define BLOCKSIZE (RECORDSIZE * 20)
12 static char block[BLOCKSIZE];
13 static unsigned long offset;
15 static int tar_umask = 002;
17 static int write_tar_filter_archive(const struct archiver *ar,
18 struct archiver_args *args);
20 /* writes out the whole block, but only if it is full */
21 static void write_if_needed(void)
23 if (offset == BLOCKSIZE) {
24 write_or_die(1, block, BLOCKSIZE);
25 offset = 0;
30 * queues up writes, so that all our write(2) calls write exactly one
31 * full block; pads writes to RECORDSIZE
33 static void write_blocked(const void *data, unsigned long size)
35 const char *buf = data;
36 unsigned long tail;
38 if (offset) {
39 unsigned long chunk = BLOCKSIZE - offset;
40 if (size < chunk)
41 chunk = size;
42 memcpy(block + offset, buf, chunk);
43 size -= chunk;
44 offset += chunk;
45 buf += chunk;
46 write_if_needed();
48 while (size >= BLOCKSIZE) {
49 write_or_die(1, buf, BLOCKSIZE);
50 size -= BLOCKSIZE;
51 buf += BLOCKSIZE;
53 if (size) {
54 memcpy(block + offset, buf, size);
55 offset += size;
57 tail = offset % RECORDSIZE;
58 if (tail) {
59 memset(block + offset, 0, RECORDSIZE - tail);
60 offset += RECORDSIZE - tail;
62 write_if_needed();
66 * The end of tar archives is marked by 2*512 nul bytes and after that
67 * follows the rest of the block (if any).
69 static void write_trailer(void)
71 int tail = BLOCKSIZE - offset;
72 memset(block + offset, 0, tail);
73 write_or_die(1, block, BLOCKSIZE);
74 if (tail < 2 * RECORDSIZE) {
75 memset(block, 0, offset);
76 write_or_die(1, block, BLOCKSIZE);
81 * pax extended header records have the format "%u %s=%s\n". %u contains
82 * the size of the whole string (including the %u), the first %s is the
83 * keyword, the second one is the value. This function constructs such a
84 * string and appends it to a struct strbuf.
86 static void strbuf_append_ext_header(struct strbuf *sb, const char *keyword,
87 const char *value, unsigned int valuelen)
89 int len, tmp;
91 /* "%u %s=%s\n" */
92 len = 1 + 1 + strlen(keyword) + 1 + valuelen + 1;
93 for (tmp = len; tmp > 9; tmp /= 10)
94 len++;
96 strbuf_grow(sb, len);
97 strbuf_addf(sb, "%u %s=", len, keyword);
98 strbuf_add(sb, value, valuelen);
99 strbuf_addch(sb, '\n');
102 static unsigned int ustar_header_chksum(const struct ustar_header *header)
104 char *p = (char *)header;
105 unsigned int chksum = 0;
106 while (p < header->chksum)
107 chksum += *p++;
108 chksum += sizeof(header->chksum) * ' ';
109 p += sizeof(header->chksum);
110 while (p < (char *)header + sizeof(struct ustar_header))
111 chksum += *p++;
112 return chksum;
115 static size_t get_path_prefix(const char *path, size_t pathlen, size_t maxlen)
117 size_t i = pathlen;
118 if (i > maxlen)
119 i = maxlen;
120 do {
121 i--;
122 } while (i > 0 && path[i] != '/');
123 return i;
126 static int write_tar_entry(struct archiver_args *args,
127 const unsigned char *sha1, const char *path, size_t pathlen,
128 unsigned int mode, void *buffer, unsigned long size)
130 struct ustar_header header;
131 struct strbuf ext_header = STRBUF_INIT;
132 int err = 0;
134 memset(&header, 0, sizeof(header));
136 if (!sha1) {
137 *header.typeflag = TYPEFLAG_GLOBAL_HEADER;
138 mode = 0100666;
139 strcpy(header.name, "pax_global_header");
140 } else if (!path) {
141 *header.typeflag = TYPEFLAG_EXT_HEADER;
142 mode = 0100666;
143 sprintf(header.name, "%s.paxheader", sha1_to_hex(sha1));
144 } else {
145 if (S_ISDIR(mode) || S_ISGITLINK(mode)) {
146 *header.typeflag = TYPEFLAG_DIR;
147 mode = (mode | 0777) & ~tar_umask;
148 } else if (S_ISLNK(mode)) {
149 *header.typeflag = TYPEFLAG_LNK;
150 mode |= 0777;
151 } else if (S_ISREG(mode)) {
152 *header.typeflag = TYPEFLAG_REG;
153 mode = (mode | ((mode & 0100) ? 0777 : 0666)) & ~tar_umask;
154 } else {
155 return error("unsupported file mode: 0%o (SHA1: %s)",
156 mode, sha1_to_hex(sha1));
158 if (pathlen > sizeof(header.name)) {
159 size_t plen = get_path_prefix(path, pathlen,
160 sizeof(header.prefix));
161 size_t rest = pathlen - plen - 1;
162 if (plen > 0 && rest <= sizeof(header.name)) {
163 memcpy(header.prefix, path, plen);
164 memcpy(header.name, path + plen + 1, rest);
165 } else {
166 sprintf(header.name, "%s.data",
167 sha1_to_hex(sha1));
168 strbuf_append_ext_header(&ext_header, "path",
169 path, pathlen);
171 } else
172 memcpy(header.name, path, pathlen);
175 if (S_ISLNK(mode) && buffer) {
176 if (size > sizeof(header.linkname)) {
177 sprintf(header.linkname, "see %s.paxheader",
178 sha1_to_hex(sha1));
179 strbuf_append_ext_header(&ext_header, "linkpath",
180 buffer, size);
181 } else
182 memcpy(header.linkname, buffer, size);
185 sprintf(header.mode, "%07o", mode & 07777);
186 sprintf(header.size, "%011lo", S_ISREG(mode) ? size : 0);
187 sprintf(header.mtime, "%011lo", (unsigned long) args->time);
189 sprintf(header.uid, "%07o", 0);
190 sprintf(header.gid, "%07o", 0);
191 strlcpy(header.uname, "root", sizeof(header.uname));
192 strlcpy(header.gname, "root", sizeof(header.gname));
193 sprintf(header.devmajor, "%07o", 0);
194 sprintf(header.devminor, "%07o", 0);
196 memcpy(header.magic, "ustar", 6);
197 memcpy(header.version, "00", 2);
199 sprintf(header.chksum, "%07o", ustar_header_chksum(&header));
201 if (ext_header.len > 0) {
202 err = write_tar_entry(args, sha1, NULL, 0, 0, ext_header.buf,
203 ext_header.len);
204 if (err)
205 return err;
207 strbuf_release(&ext_header);
208 write_blocked(&header, sizeof(header));
209 if (S_ISREG(mode) && buffer && size > 0)
210 write_blocked(buffer, size);
211 return err;
214 static int write_global_extended_header(struct archiver_args *args)
216 const unsigned char *sha1 = args->commit_sha1;
217 struct strbuf ext_header = STRBUF_INIT;
218 int err;
220 strbuf_append_ext_header(&ext_header, "comment", sha1_to_hex(sha1), 40);
221 err = write_tar_entry(args, NULL, NULL, 0, 0, ext_header.buf,
222 ext_header.len);
223 strbuf_release(&ext_header);
224 return err;
227 static struct archiver **tar_filters;
228 static int nr_tar_filters;
229 static int alloc_tar_filters;
231 static struct archiver *find_tar_filter(const char *name, int len)
233 int i;
234 for (i = 0; i < nr_tar_filters; i++) {
235 struct archiver *ar = tar_filters[i];
236 if (!strncmp(ar->name, name, len) && !ar->name[len])
237 return ar;
239 return NULL;
242 static int tar_filter_config(const char *var, const char *value, void *data)
244 struct archiver *ar;
245 const char *dot;
246 const char *name;
247 const char *type;
248 int namelen;
250 if (prefixcmp(var, "tar."))
251 return 0;
252 dot = strrchr(var, '.');
253 if (dot == var + 9)
254 return 0;
256 name = var + 4;
257 namelen = dot - name;
258 type = dot + 1;
260 ar = find_tar_filter(name, namelen);
261 if (!ar) {
262 ar = xcalloc(1, sizeof(*ar));
263 ar->name = xmemdupz(name, namelen);
264 ar->write_archive = write_tar_filter_archive;
265 ar->flags = ARCHIVER_WANT_COMPRESSION_LEVELS;
266 ALLOC_GROW(tar_filters, nr_tar_filters + 1, alloc_tar_filters);
267 tar_filters[nr_tar_filters++] = ar;
270 if (!strcmp(type, "command")) {
271 if (!value)
272 return config_error_nonbool(var);
273 free(ar->data);
274 ar->data = xstrdup(value);
275 return 0;
277 if (!strcmp(type, "remote")) {
278 if (git_config_bool(var, value))
279 ar->flags |= ARCHIVER_REMOTE;
280 else
281 ar->flags &= ~ARCHIVER_REMOTE;
282 return 0;
285 return 0;
288 static int git_tar_config(const char *var, const char *value, void *cb)
290 if (!strcmp(var, "tar.umask")) {
291 if (value && !strcmp(value, "user")) {
292 tar_umask = umask(0);
293 umask(tar_umask);
294 } else {
295 tar_umask = git_config_int(var, value);
297 return 0;
300 return tar_filter_config(var, value, cb);
303 static int write_tar_archive(const struct archiver *ar,
304 struct archiver_args *args)
306 int err = 0;
308 if (args->commit_sha1)
309 err = write_global_extended_header(args);
310 if (!err)
311 err = write_archive_entries(args, write_tar_entry);
312 if (!err)
313 write_trailer();
314 return err;
317 static int write_tar_filter_archive(const struct archiver *ar,
318 struct archiver_args *args)
320 struct strbuf cmd = STRBUF_INIT;
321 struct child_process filter;
322 const char *argv[2];
323 int r;
325 if (!ar->data)
326 die("BUG: tar-filter archiver called with no filter defined");
328 strbuf_addstr(&cmd, ar->data);
329 if (args->compression_level >= 0)
330 strbuf_addf(&cmd, " -%d", args->compression_level);
332 memset(&filter, 0, sizeof(filter));
333 argv[0] = cmd.buf;
334 argv[1] = NULL;
335 filter.argv = argv;
336 filter.use_shell = 1;
337 filter.in = -1;
339 if (start_command(&filter) < 0)
340 die_errno("unable to start '%s' filter", argv[0]);
341 close(1);
342 if (dup2(filter.in, 1) < 0)
343 die_errno("unable to redirect descriptor");
344 close(filter.in);
346 r = write_tar_archive(ar, args);
348 close(1);
349 if (finish_command(&filter) != 0)
350 die("'%s' filter reported error", argv[0]);
352 strbuf_release(&cmd);
353 return r;
356 static struct archiver tar_archiver = {
357 "tar",
358 write_tar_archive,
359 ARCHIVER_REMOTE
362 void init_tar_archiver(void)
364 int i;
365 register_archiver(&tar_archiver);
367 tar_filter_config("tar.tgz.command", "gzip -cn", NULL);
368 tar_filter_config("tar.tgz.remote", "true", NULL);
369 tar_filter_config("tar.tar.gz.command", "gzip -cn", NULL);
370 tar_filter_config("tar.tar.gz.remote", "true", NULL);
371 git_config(git_tar_config, NULL);
372 for (i = 0; i < nr_tar_filters; i++) {
373 /* omit any filters that never had a command configured */
374 if (tar_filters[i]->data)
375 register_archiver(tar_filters[i]);