2 * Copyright (c) 2003-2007 Tim Kientzle
3 * Copyright (c) 2008 Joerg Sonnenberger
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include "archive_platform.h"
28 __FBSDID("$FreeBSD$");
42 #include "archive_entry.h"
43 #include "archive_private.h"
44 #include "archive_write_private.h"
49 struct archive_entry *entry;
53 /* Line buffer for uuencoded dump format */
58 struct archive_string work;
59 struct archive_string quoted_name;
62 static int archive_write_shar_finish(struct archive_write *);
63 static int archive_write_shar_destroy(struct archive_write *);
64 static int archive_write_shar_header(struct archive_write *,
65 struct archive_entry *);
66 static ssize_t archive_write_shar_data_sed(struct archive_write *,
67 const void * buff, size_t);
68 static ssize_t archive_write_shar_data_uuencode(struct archive_write *,
69 const void * buff, size_t);
70 static int archive_write_shar_finish_entry(struct archive_write *);
73 * Copy the given string to the buffer, quoting all shell meta characters
77 shar_quote(struct archive_string *buf, const char *str, int in_shell)
79 static const char meta[] = "\n \t'`\";&<>()|*?{}[]\\$!#^~";
82 while (*str != '\0') {
83 if ((len = strcspn(str, meta)) != 0) {
84 archive_strncat(buf, str, len);
86 } else if (*str == '\n') {
88 archive_strcat(buf, "\"\n\"");
90 archive_strcat(buf, "\\n");
93 archive_strappend_char(buf, '\\');
94 archive_strappend_char(buf, *str);
101 * Set output format to 'shar' format.
104 archive_write_set_format_shar(struct archive *_a)
106 struct archive_write *a = (struct archive_write *)_a;
109 /* If someone else was already registered, unregister them. */
110 if (a->format_destroy != NULL)
111 (a->format_destroy)(a);
113 shar = (struct shar *)malloc(sizeof(*shar));
115 archive_set_error(&a->archive, ENOMEM, "Can't allocate shar data");
116 return (ARCHIVE_FATAL);
118 memset(shar, 0, sizeof(*shar));
119 archive_string_init(&shar->work);
120 archive_string_init(&shar->quoted_name);
121 a->format_data = shar;
123 a->pad_uncompressed = 0;
124 a->format_write_header = archive_write_shar_header;
125 a->format_finish = archive_write_shar_finish;
126 a->format_destroy = archive_write_shar_destroy;
127 a->format_write_data = archive_write_shar_data_sed;
128 a->format_finish_entry = archive_write_shar_finish_entry;
129 a->archive.archive_format = ARCHIVE_FORMAT_SHAR_BASE;
130 a->archive.archive_format_name = "shar";
135 * An alternate 'shar' that uses uudecode instead of 'sed' to encode
136 * file contents and can therefore be used to archive binary files.
137 * In addition, this variant also attempts to restore ownership, file modes,
138 * and other extended file information.
141 archive_write_set_format_shar_dump(struct archive *_a)
143 struct archive_write *a = (struct archive_write *)_a;
146 archive_write_set_format_shar(&a->archive);
147 shar = (struct shar *)a->format_data;
149 a->format_write_data = archive_write_shar_data_uuencode;
150 a->archive.archive_format = ARCHIVE_FORMAT_SHAR_DUMP;
151 a->archive.archive_format_name = "shar dump";
156 archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
158 const char *linkname;
163 shar = (struct shar *)a->format_data;
164 if (!shar->wrote_header) {
165 archive_strcat(&shar->work, "#!/bin/sh\n");
166 archive_strcat(&shar->work, "# This is a shell archive\n");
167 shar->wrote_header = 1;
170 /* Save the entry for the closing. */
172 archive_entry_free(shar->entry);
173 shar->entry = archive_entry_clone(entry);
174 name = archive_entry_pathname(entry);
176 /* Handle some preparatory issues. */
177 switch(archive_entry_filetype(entry)) {
179 /* Only regular files have non-zero size. */
182 archive_entry_set_size(entry, 0);
183 /* Don't bother trying to recreate '.' */
184 if (strcmp(name, ".") == 0 || strcmp(name, "./") == 0)
190 /* All other file types have zero size in the archive. */
191 archive_entry_set_size(entry, 0);
194 archive_entry_set_size(entry, 0);
195 if (archive_entry_hardlink(entry) == NULL &&
196 archive_entry_symlink(entry) == NULL) {
197 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
198 "shar format cannot archive this");
199 return (ARCHIVE_WARN);
203 archive_string_empty(&shar->quoted_name);
204 shar_quote(&shar->quoted_name, name, 1);
206 /* Stock preparation for all file types. */
207 archive_string_sprintf(&shar->work, "echo x %s\n", shar->quoted_name.s);
209 if (archive_entry_filetype(entry) != AE_IFDIR) {
210 /* Try to create the dir. */
212 pp = strrchr(p, '/');
213 /* If there is a / character, try to create the dir. */
217 /* Try to avoid a lot of redundant mkdir commands. */
218 if (strcmp(p, ".") == 0) {
219 /* Don't try to "mkdir ." */
221 } else if (shar->last_dir == NULL) {
222 archive_strcat(&shar->work, "mkdir -p ");
223 shar_quote(&shar->work, p, 1);
224 archive_strcat(&shar->work,
225 " > /dev/null 2>&1\n");
227 } else if (strcmp(p, shar->last_dir) == 0) {
228 /* We've already created this exact dir. */
230 } else if (strlen(p) < strlen(shar->last_dir) &&
231 strncmp(p, shar->last_dir, strlen(p)) == 0) {
232 /* We've already created a subdir. */
235 archive_strcat(&shar->work, "mkdir -p ");
236 shar_quote(&shar->work, p, 1);
237 archive_strcat(&shar->work,
238 " > /dev/null 2>&1\n");
246 /* Handle file-type specific issues. */
248 if ((linkname = archive_entry_hardlink(entry)) != NULL) {
249 archive_strcat(&shar->work, "ln -f ");
250 shar_quote(&shar->work, linkname, 1);
251 archive_string_sprintf(&shar->work, " %s\n",
252 shar->quoted_name.s);
253 } else if ((linkname = archive_entry_symlink(entry)) != NULL) {
254 archive_strcat(&shar->work, "ln -fs ");
255 shar_quote(&shar->work, linkname, 1);
256 archive_string_sprintf(&shar->work, " %s\n",
257 shar->quoted_name.s);
259 switch(archive_entry_filetype(entry)) {
261 if (archive_entry_size(entry) == 0) {
262 /* More portable than "touch." */
263 archive_string_sprintf(&shar->work,
264 "test -e \"%s\" || :> \"%s\"\n",
265 shar->quoted_name.s, shar->quoted_name.s);
268 archive_string_sprintf(&shar->work,
269 "uudecode -p > %s << 'SHAR_END'\n",
270 shar->quoted_name.s);
271 archive_string_sprintf(&shar->work,
273 archive_entry_mode(entry) & 0777);
274 shar_quote(&shar->work, name, 0);
275 archive_strcat(&shar->work, "\n");
277 archive_string_sprintf(&shar->work,
278 "sed 's/^X//' > %s << 'SHAR_END'\n",
279 shar->quoted_name.s);
282 shar->end_of_line = 1;
287 archive_string_sprintf(&shar->work,
288 "mkdir -p %s > /dev/null 2>&1\n",
289 shar->quoted_name.s);
290 /* Record that we just created this directory. */
291 if (shar->last_dir != NULL)
292 free(shar->last_dir);
294 shar->last_dir = strdup(name);
295 /* Trim a trailing '/'. */
296 pp = strrchr(shar->last_dir, '/');
297 if (pp != NULL && pp[1] == '\0')
300 * TODO: Put dir name/mode on a list to be fixed
301 * up at end of archive.
305 archive_string_sprintf(&shar->work,
306 "mkfifo %s\n", shar->quoted_name.s);
309 archive_string_sprintf(&shar->work,
310 "mknod %s c %d %d\n", shar->quoted_name.s,
311 archive_entry_rdevmajor(entry),
312 archive_entry_rdevminor(entry));
315 archive_string_sprintf(&shar->work,
316 "mknod %s b %d %d\n", shar->quoted_name.s,
317 archive_entry_rdevmajor(entry),
318 archive_entry_rdevminor(entry));
321 return (ARCHIVE_WARN);
329 archive_write_shar_data_sed(struct archive_write *a, const void *buff, size_t n)
331 static const size_t ensured = 65533;
338 shar = (struct shar *)a->format_data;
339 if (!shar->has_data || n == 0)
342 src = (const char *)buff;
345 * ensure is the number of bytes in buffer before expanding the
346 * current character. Each operation writes the current character
347 * and optionally the start-of-new-line marker. This can happen
348 * twice before entering the loop, so make sure three additional
349 * bytes can be written.
351 if (archive_string_ensure(&shar->work, ensured + 3) == NULL)
352 __archive_errx(1, "Out of memory");
354 if (shar->work.length > ensured) {
355 ret = (*a->compressor.write)(a, shar->work.s,
357 if (ret != ARCHIVE_OK)
358 return (ARCHIVE_FATAL);
359 archive_string_empty(&shar->work);
361 buf = shar->work.s + shar->work.length;
362 buf_end = shar->work.s + ensured;
364 if (shar->end_of_line) {
366 shar->end_of_line = 0;
370 if ((*buf++ = *src++) == '\n') {
372 shar->end_of_line = 1;
377 if (buf >= buf_end) {
378 shar->work.length = buf - shar->work.s;
379 ret = (*a->compressor.write)(a, shar->work.s,
381 if (ret != ARCHIVE_OK)
382 return (ARCHIVE_FATAL);
383 archive_string_empty(&shar->work);
388 shar->work.length = buf - shar->work.s;
393 #define UUENC(c) (((c)!=0) ? ((c) & 077) + ' ': '`')
396 uuencode_group(const char _in[3], char out[4])
398 const unsigned char *in = (const unsigned char *)_in;
401 t = (in[0] << 16) | (in[1] << 8) | in[2];
402 out[0] = UUENC( 0x3f & (t >> 18) );
403 out[1] = UUENC( 0x3f & (t >> 12) );
404 out[2] = UUENC( 0x3f & (t >> 6) );
405 out[3] = UUENC( 0x3f & t );
409 uuencode_line(struct shar *shar, const char *inbuf, size_t len)
411 char tmp_buf[3], *buf;
414 /* len <= 45 -> expanded to 60 + len byte + new line */
415 alloc_len = shar->work.length + 62;
416 if (archive_string_ensure(&shar->work, alloc_len) == NULL)
417 __archive_errx(1, "Out of memory");
419 buf = shar->work.s + shar->work.length;
422 uuencode_group(inbuf, buf);
428 tmp_buf[0] = inbuf[0];
432 tmp_buf[1] = inbuf[1];
434 uuencode_group(inbuf, buf);
438 if ((buf - shar->work.s) > (ptrdiff_t)(shar->work.length + 62))
439 __archive_errx(1, "Buffer overflow");
440 shar->work.length = buf - shar->work.s;
444 archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
452 shar = (struct shar *)a->format_data;
455 src = (const char *)buff;
457 if (shar->outpos != 0) {
458 n = 45 - shar->outpos;
461 memcpy(shar->outbuff + shar->outpos, src, n);
462 if (shar->outpos + n < 45) {
466 uuencode_line(shar, shar->outbuff, 45);
474 uuencode_line(shar, src, 45);
478 if (shar->work.length < 65536)
480 ret = (*a->compressor.write)(a, shar->work.s,
482 if (ret != ARCHIVE_OK)
483 return (ARCHIVE_FATAL);
484 archive_string_empty(&shar->work);
487 memcpy(shar->outbuff, src, n);
494 archive_write_shar_finish_entry(struct archive_write *a)
496 const char *g, *p, *u;
500 shar = (struct shar *)a->format_data;
501 if (shar->entry == NULL)
505 /* Finish uuencoded data. */
506 if (shar->has_data) {
507 if (shar->outpos > 0)
508 uuencode_line(shar, shar->outbuff,
510 archive_strcat(&shar->work, "`\nend\n");
511 archive_strcat(&shar->work, "SHAR_END\n");
513 /* Restore file mode, owner, flags. */
515 * TODO: Don't immediately restore mode for
516 * directories; defer that to end of script.
518 archive_string_sprintf(&shar->work, "chmod %o ",
519 archive_entry_mode(shar->entry) & 07777);
520 shar_quote(&shar->work, archive_entry_pathname(shar->entry), 1);
521 archive_strcat(&shar->work, "\n");
523 u = archive_entry_uname(shar->entry);
524 g = archive_entry_gname(shar->entry);
525 if (u != NULL || g != NULL) {
526 archive_strcat(&shar->work, "chown ");
528 shar_quote(&shar->work, u, 1);
530 archive_strcat(&shar->work, ":");
531 shar_quote(&shar->work, g, 1);
533 shar_quote(&shar->work,
534 archive_entry_pathname(shar->entry), 1);
535 archive_strcat(&shar->work, "\n");
538 if ((p = archive_entry_fflags_text(shar->entry)) != NULL) {
539 archive_string_sprintf(&shar->work, "chflags %s ",
540 p, archive_entry_pathname(shar->entry));
541 shar_quote(&shar->work,
542 archive_entry_pathname(shar->entry), 1);
543 archive_strcat(&shar->work, "\n");
546 /* TODO: restore ACLs */
549 if (shar->has_data) {
550 /* Finish sed-encoded data: ensure last line ends. */
551 if (!shar->end_of_line)
552 archive_strappend_char(&shar->work, '\n');
553 archive_strcat(&shar->work, "SHAR_END\n");
557 archive_entry_free(shar->entry);
560 if (shar->work.length < 65536)
563 ret = (*a->compressor.write)(a, shar->work.s, shar->work.length);
564 if (ret != ARCHIVE_OK)
565 return (ARCHIVE_FATAL);
566 archive_string_empty(&shar->work);
572 archive_write_shar_finish(struct archive_write *a)
578 * TODO: Accumulate list of directory names/modes and
579 * fix them all up at end-of-archive.
582 shar = (struct shar *)a->format_data;
585 * Only write the end-of-archive markers if the archive was
586 * actually started. This avoids problems if someone sets
587 * shar format, then sets another format (which would invoke
588 * shar_finish to free the format-specific data).
590 if (shar->wrote_header == 0)
593 archive_strcat(&shar->work, "exit\n");
595 ret = (*a->compressor.write)(a, shar->work.s, shar->work.length);
596 if (ret != ARCHIVE_OK)
597 return (ARCHIVE_FATAL);
599 /* Shar output is never padded. */
600 archive_write_set_bytes_in_last_block(&a->archive, 1);
602 * TODO: shar should also suppress padding of
603 * uncompressed data within gzip/bzip2 streams.
610 archive_write_shar_destroy(struct archive_write *a)
614 shar = (struct shar *)a->format_data;
618 archive_entry_free(shar->entry);
619 free(shar->last_dir);
620 archive_string_free(&(shar->work));
621 archive_string_free(&(shar->quoted_name));
623 a->format_data = NULL;