1 /*-
2 * Copyright (c) 2003-2007 Tim Kientzle
3 * Copyright (c) 2008 Joerg Sonnenberger
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
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.
14 *
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.
25 */
26
27 #include "archive_platform.h"
28 __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_shar.c 189438 2009-03-06 05:58:56Z kientzle $");
29
30 #ifdef HAVE_ERRNO_H
31 #include <errno.h>
32 #endif
33 #include <stdio.h>
34 #ifdef HAVE_STDLIB_H
35 #include <stdlib.h>
36 #endif
37 #ifdef HAVE_STRING_H
38 #include <string.h>
39 #endif
40
41 #include "archive.h"
42 #include "archive_entry.h"
43 #include "archive_private.h"
44 #include "archive_write_private.h"
45 #include "archive_write_set_format_private.h"
46
47 struct shar {
48 int dump;
49 int end_of_line;
50 struct archive_entry *entry;
51 int has_data;
52 char *last_dir;
53
54 /* Line buffer for uuencoded dump format */
55 char outbuff[45];
56 size_t outpos;
57
58 int wrote_header;
59 struct archive_string work;
60 struct archive_string quoted_name;
61 };
62
63 static int archive_write_shar_close(struct archive_write *);
64 static int archive_write_shar_free(struct archive_write *);
65 static int archive_write_shar_header(struct archive_write *,
66 struct archive_entry *);
67 static ssize_t archive_write_shar_data_sed(struct archive_write *,
68 const void * buff, size_t);
69 static ssize_t archive_write_shar_data_uuencode(struct archive_write *,
70 const void * buff, size_t);
71 static int archive_write_shar_finish_entry(struct archive_write *);
72
73 /*
74 * Copy the given string to the buffer, quoting all shell meta characters
75 * found.
76 */
77 static void
shar_quote(struct archive_string * buf,const char * str,int in_shell)78 shar_quote(struct archive_string *buf, const char *str, int in_shell)
79 {
80 static const char meta[] = "\n \t'`\";&<>()|*?{}[]\\$!#^~";
81 size_t len;
82
83 while (*str != '\0') {
84 if ((len = strcspn(str, meta)) != 0) {
85 archive_strncat(buf, str, len);
86 str += len;
87 } else if (*str == '\n') {
88 if (in_shell)
89 archive_strcat(buf, "\"\n\"");
90 else
91 archive_strcat(buf, "\\n");
92 ++str;
93 } else {
94 archive_strappend_char(buf, '\\');
95 archive_strappend_char(buf, *str);
96 ++str;
97 }
98 }
99 }
100
101 /*
102 * Set output format to 'shar' format.
103 */
104 int
archive_write_set_format_shar(struct archive * _a)105 archive_write_set_format_shar(struct archive *_a)
106 {
107 struct archive_write *a = (struct archive_write *)_a;
108 struct shar *shar;
109
110 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
111 ARCHIVE_STATE_NEW, "archive_write_set_format_shar");
112
113 /* If someone else was already registered, unregister them. */
114 if (a->format_free != NULL)
115 (a->format_free)(a);
116
117 shar = (struct shar *)calloc(1, sizeof(*shar));
118 if (shar == NULL) {
119 archive_set_error(&a->archive, ENOMEM, "Can't allocate shar data");
120 return (ARCHIVE_FATAL);
121 }
122 archive_string_init(&shar->work);
123 archive_string_init(&shar->quoted_name);
124 a->format_data = shar;
125 a->format_name = "shar";
126 a->format_write_header = archive_write_shar_header;
127 a->format_close = archive_write_shar_close;
128 a->format_free = archive_write_shar_free;
129 a->format_write_data = archive_write_shar_data_sed;
130 a->format_finish_entry = archive_write_shar_finish_entry;
131 a->archive.archive_format = ARCHIVE_FORMAT_SHAR_BASE;
132 a->archive.archive_format_name = "shar";
133 return (ARCHIVE_OK);
134 }
135
136 /*
137 * An alternate 'shar' that uses uudecode instead of 'sed' to encode
138 * file contents and can therefore be used to archive binary files.
139 * In addition, this variant also attempts to restore ownership, file modes,
140 * and other extended file information.
141 */
142 int
archive_write_set_format_shar_dump(struct archive * _a)143 archive_write_set_format_shar_dump(struct archive *_a)
144 {
145 struct archive_write *a = (struct archive_write *)_a;
146 struct shar *shar;
147
148 archive_write_set_format_shar(&a->archive);
149 shar = (struct shar *)a->format_data;
150 shar->dump = 1;
151 a->format_write_data = archive_write_shar_data_uuencode;
152 a->archive.archive_format = ARCHIVE_FORMAT_SHAR_DUMP;
153 a->archive.archive_format_name = "shar dump";
154 return (ARCHIVE_OK);
155 }
156
157 static int
archive_write_shar_header(struct archive_write * a,struct archive_entry * entry)158 archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
159 {
160 const char *linkname;
161 const char *name;
162 char *p, *pp;
163 struct shar *shar;
164
165 shar = (struct shar *)a->format_data;
166 if (!shar->wrote_header) {
167 archive_strcat(&shar->work, "#!/bin/sh\n");
168 archive_strcat(&shar->work, "# This is a shell archive\n");
169 shar->wrote_header = 1;
170 }
171
172 /* Save the entry for the closing. */
173 archive_entry_free(shar->entry);
174 shar->entry = archive_entry_clone(entry);
175 name = archive_entry_pathname(entry);
176
177 /* Handle some preparatory issues. */
178 switch(archive_entry_filetype(entry)) {
179 case AE_IFREG:
180 /* Only regular files have non-zero size. */
181 break;
182 case AE_IFDIR:
183 archive_entry_set_size(entry, 0);
184 /* Don't bother trying to recreate '.' */
185 if (strcmp(name, ".") == 0 || strcmp(name, "./") == 0)
186 return (ARCHIVE_OK);
187 break;
188 case AE_IFIFO:
189 case AE_IFCHR:
190 case AE_IFBLK:
191 /* All other file types have zero size in the archive. */
192 archive_entry_set_size(entry, 0);
193 break;
194 default:
195 archive_entry_set_size(entry, 0);
196 if (archive_entry_hardlink(entry) == NULL &&
197 archive_entry_symlink(entry) == NULL) {
198 __archive_write_entry_filetype_unsupported(
199 &a->archive, entry, "shar");
200 return (ARCHIVE_WARN);
201 }
202 }
203
204 archive_string_empty(&shar->quoted_name);
205 shar_quote(&shar->quoted_name, name, 1);
206
207 /* Stock preparation for all file types. */
208 archive_string_sprintf(&shar->work, "echo x %s\n", shar->quoted_name.s);
209
210 if (archive_entry_filetype(entry) != AE_IFDIR) {
211 /* Try to create the dir. */
212 p = strdup(name);
213 pp = strrchr(p, '/');
214 /* If there is a / character, try to create the dir. */
215 if (pp != NULL) {
216 *pp = '\0';
217
218 /* Try to avoid a lot of redundant mkdir commands. */
219 if (strcmp(p, ".") == 0) {
220 /* Don't try to "mkdir ." */
221 free(p);
222 } else if (shar->last_dir == NULL) {
223 archive_strcat(&shar->work, "mkdir -p ");
224 shar_quote(&shar->work, p, 1);
225 archive_strcat(&shar->work,
226 " > /dev/null 2>&1\n");
227 shar->last_dir = p;
228 } else if (strcmp(p, shar->last_dir) == 0) {
229 /* We've already created this exact dir. */
230 free(p);
231 } else if (strlen(p) < strlen(shar->last_dir) &&
232 strncmp(p, shar->last_dir, strlen(p)) == 0) {
233 /* We've already created a subdir. */
234 free(p);
235 } else {
236 archive_strcat(&shar->work, "mkdir -p ");
237 shar_quote(&shar->work, p, 1);
238 archive_strcat(&shar->work,
239 " > /dev/null 2>&1\n");
240 shar->last_dir = p;
241 }
242 } else {
243 free(p);
244 }
245 }
246
247 /* Handle file-type specific issues. */
248 shar->has_data = 0;
249 if ((linkname = archive_entry_hardlink(entry)) != NULL) {
250 archive_strcat(&shar->work, "ln -f ");
251 shar_quote(&shar->work, linkname, 1);
252 archive_string_sprintf(&shar->work, " %s\n",
253 shar->quoted_name.s);
254 } else if ((linkname = archive_entry_symlink(entry)) != NULL) {
255 archive_strcat(&shar->work, "ln -fs ");
256 shar_quote(&shar->work, linkname, 1);
257 archive_string_sprintf(&shar->work, " %s\n",
258 shar->quoted_name.s);
259 } else {
260 switch(archive_entry_filetype(entry)) {
261 case AE_IFREG:
262 if (archive_entry_size(entry) == 0) {
263 /* More portable than "touch." */
264 archive_string_sprintf(&shar->work,
265 "test -e \"%s\" || :> \"%s\"\n",
266 shar->quoted_name.s, shar->quoted_name.s);
267 } else {
268 if (shar->dump) {
269 unsigned int mode = archive_entry_mode(entry) & 0777;
270 archive_string_sprintf(&shar->work,
271 "uudecode -p > %s << 'SHAR_END'\n",
272 shar->quoted_name.s);
273 archive_string_sprintf(&shar->work,
274 "begin %o ", mode);
275 shar_quote(&shar->work, name, 0);
276 archive_strcat(&shar->work, "\n");
277 } else {
278 archive_string_sprintf(&shar->work,
279 "sed 's/^X//' > %s << 'SHAR_END'\n",
280 shar->quoted_name.s);
281 }
282 shar->has_data = 1;
283 shar->end_of_line = 1;
284 shar->outpos = 0;
285 }
286 break;
287 case AE_IFDIR:
288 archive_string_sprintf(&shar->work,
289 "mkdir -p %s > /dev/null 2>&1\n",
290 shar->quoted_name.s);
291 /* Record that we just created this directory. */
292 free(shar->last_dir);
293
294 shar->last_dir = strdup(name);
295 /* Trim a trailing '/'. */
296 pp = strrchr(shar->last_dir, '/');
297 if (pp != NULL && pp[1] == '\0')
298 *pp = '\0';
299 /*
300 * TODO: Put dir name/mode on a list to be fixed
301 * up at end of archive.
302 */
303 break;
304 case AE_IFIFO:
305 archive_string_sprintf(&shar->work,
306 "mkfifo %s\n", shar->quoted_name.s);
307 break;
308 case AE_IFCHR:
309 archive_string_sprintf(&shar->work,
310 "mknod %s c %ju %ju\n", shar->quoted_name.s,
311 (uintmax_t)archive_entry_rdevmajor(entry),
312 (uintmax_t)archive_entry_rdevminor(entry));
313 break;
314 case AE_IFBLK:
315 archive_string_sprintf(&shar->work,
316 "mknod %s b %ju %ju\n", shar->quoted_name.s,
317 (uintmax_t)archive_entry_rdevmajor(entry),
318 (uintmax_t)archive_entry_rdevminor(entry));
319 break;
320 default:
321 return (ARCHIVE_WARN);
322 }
323 }
324
325 return (ARCHIVE_OK);
326 }
327
328 static ssize_t
archive_write_shar_data_sed(struct archive_write * a,const void * buff,size_t n)329 archive_write_shar_data_sed(struct archive_write *a, const void *buff, size_t n)
330 {
331 static const size_t ensured = 65533;
332 struct shar *shar;
333 const char *src;
334 char *buf, *buf_end;
335 int ret;
336 size_t written = n;
337
338 shar = (struct shar *)a->format_data;
339 if (!shar->has_data || n == 0)
340 return (0);
341
342 src = (const char *)buff;
343
344 /*
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.
350 */
351 if (archive_string_ensure(&shar->work, ensured + 3) == NULL) {
352 archive_set_error(&a->archive, ENOMEM, "Out of memory");
353 return (ARCHIVE_FATAL);
354 }
355
356 if (shar->work.length > ensured) {
357 ret = __archive_write_output(a, shar->work.s,
358 shar->work.length);
359 if (ret != ARCHIVE_OK)
360 return (ARCHIVE_FATAL);
361 archive_string_empty(&shar->work);
362 }
363 buf = shar->work.s + shar->work.length;
364 buf_end = shar->work.s + ensured;
365
366 if (shar->end_of_line) {
367 *buf++ = 'X';
368 shar->end_of_line = 0;
369 }
370
371 while (n-- != 0) {
372 if ((*buf++ = *src++) == '\n') {
373 if (n == 0)
374 shar->end_of_line = 1;
375 else
376 *buf++ = 'X';
377 }
378
379 if (buf >= buf_end) {
380 shar->work.length = buf - shar->work.s;
381 ret = __archive_write_output(a, shar->work.s,
382 shar->work.length);
383 if (ret != ARCHIVE_OK)
384 return (ARCHIVE_FATAL);
385 archive_string_empty(&shar->work);
386 buf = shar->work.s;
387 }
388 }
389
390 shar->work.length = buf - shar->work.s;
391
392 return (written);
393 }
394
395 #define UUENC(c) (((c)!=0) ? ((c) & 077) + ' ': '`')
396
397 static void
uuencode_group(const char _in[3],char out[4])398 uuencode_group(const char _in[3], char out[4])
399 {
400 const unsigned char *in = (const unsigned char *)_in;
401 int t;
402
403 t = (in[0] << 16) | (in[1] << 8) | in[2];
404 out[0] = UUENC( 0x3f & (t >> 18) );
405 out[1] = UUENC( 0x3f & (t >> 12) );
406 out[2] = UUENC( 0x3f & (t >> 6) );
407 out[3] = UUENC( 0x3f & t );
408 }
409
410 static int
_uuencode_line(struct archive_write * a,struct shar * shar,const char * inbuf,size_t len)411 _uuencode_line(struct archive_write *a, struct shar *shar, const char *inbuf, size_t len)
412 {
413 char *buf;
414 size_t alloc_len;
415
416 /* len <= 45 -> expanded to 60 + len byte + new line */
417 alloc_len = shar->work.length + 62;
418 if (archive_string_ensure(&shar->work, alloc_len) == NULL) {
419 archive_set_error(&a->archive, ENOMEM, "Out of memory");
420 return (ARCHIVE_FATAL);
421 }
422
423 buf = shar->work.s + shar->work.length;
424 *buf++ = UUENC(len);
425 while (len >= 3) {
426 uuencode_group(inbuf, buf);
427 len -= 3;
428 inbuf += 3;
429 buf += 4;
430 }
431 if (len != 0) {
432 char tmp_buf[3];
433 tmp_buf[0] = inbuf[0];
434 if (len == 1)
435 tmp_buf[1] = '\0';
436 else
437 tmp_buf[1] = inbuf[1];
438 tmp_buf[2] = '\0';
439 uuencode_group(tmp_buf, buf);
440 buf += 4;
441 }
442 *buf++ = '\n';
443 if ((buf - shar->work.s) > (ptrdiff_t)(shar->work.length + 62)) {
444 archive_set_error(&a->archive,
445 ARCHIVE_ERRNO_MISC, "Buffer overflow");
446 return (ARCHIVE_FATAL);
447 }
448 shar->work.length = buf - shar->work.s;
449 return (ARCHIVE_OK);
450 }
451
452 #define uuencode_line(__a, __shar, __inbuf, __len) \
453 do { \
454 int r = _uuencode_line(__a, __shar, __inbuf, __len); \
455 if (r != ARCHIVE_OK) \
456 return (ARCHIVE_FATAL); \
457 } while (0)
458
459 static ssize_t
archive_write_shar_data_uuencode(struct archive_write * a,const void * buff,size_t length)460 archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
461 size_t length)
462 {
463 struct shar *shar;
464 const char *src;
465 size_t n;
466 int ret;
467
468 shar = (struct shar *)a->format_data;
469 if (!shar->has_data)
470 return (ARCHIVE_OK);
471 src = (const char *)buff;
472
473 if (shar->outpos != 0) {
474 n = 45 - shar->outpos;
475 if (n > length)
476 n = length;
477 memcpy(shar->outbuff + shar->outpos, src, n);
478 if (shar->outpos + n < 45) {
479 shar->outpos += n;
480 return length;
481 }
482 uuencode_line(a, shar, shar->outbuff, 45);
483 src += n;
484 n = length - n;
485 } else {
486 n = length;
487 }
488
489 while (n >= 45) {
490 uuencode_line(a, shar, src, 45);
491 src += 45;
492 n -= 45;
493
494 if (shar->work.length < 65536)
495 continue;
496 ret = __archive_write_output(a, shar->work.s,
497 shar->work.length);
498 if (ret != ARCHIVE_OK)
499 return (ARCHIVE_FATAL);
500 archive_string_empty(&shar->work);
501 }
502 if (n != 0) {
503 memcpy(shar->outbuff, src, n);
504 shar->outpos = n;
505 }
506 return (length);
507 }
508
509 static int
archive_write_shar_finish_entry(struct archive_write * a)510 archive_write_shar_finish_entry(struct archive_write *a)
511 {
512 const char *g, *p, *u;
513 struct shar *shar;
514 int ret;
515
516 shar = (struct shar *)a->format_data;
517 if (shar->entry == NULL)
518 return (0);
519
520 if (shar->dump) {
521 /* Finish uuencoded data. */
522 if (shar->has_data) {
523 if (shar->outpos > 0)
524 uuencode_line(a, shar, shar->outbuff,
525 shar->outpos);
526 archive_strcat(&shar->work, "`\nend\n");
527 archive_strcat(&shar->work, "SHAR_END\n");
528 }
529 /* Restore file mode, owner, flags. */
530 /*
531 * TODO: Don't immediately restore mode for
532 * directories; defer that to end of script.
533 */
534 archive_string_sprintf(&shar->work, "chmod %o ",
535 (unsigned int)(archive_entry_mode(shar->entry) & 07777));
536 shar_quote(&shar->work, archive_entry_pathname(shar->entry), 1);
537 archive_strcat(&shar->work, "\n");
538
539 u = archive_entry_uname(shar->entry);
540 g = archive_entry_gname(shar->entry);
541 if (u != NULL || g != NULL) {
542 archive_strcat(&shar->work, "chown ");
543 if (u != NULL)
544 shar_quote(&shar->work, u, 1);
545 if (g != NULL) {
546 archive_strcat(&shar->work, ":");
547 shar_quote(&shar->work, g, 1);
548 }
549 archive_strcat(&shar->work, " ");
550 shar_quote(&shar->work,
551 archive_entry_pathname(shar->entry), 1);
552 archive_strcat(&shar->work, "\n");
553 }
554
555 if ((p = archive_entry_fflags_text(shar->entry)) != NULL) {
556 archive_string_sprintf(&shar->work, "chflags %s ", p);
557 shar_quote(&shar->work,
558 archive_entry_pathname(shar->entry), 1);
559 archive_strcat(&shar->work, "\n");
560 }
561
562 /* TODO: restore ACLs */
563
564 } else {
565 if (shar->has_data) {
566 /* Finish sed-encoded data: ensure last line ends. */
567 if (!shar->end_of_line)
568 archive_strappend_char(&shar->work, '\n');
569 archive_strcat(&shar->work, "SHAR_END\n");
570 }
571 }
572
573 archive_entry_free(shar->entry);
574 shar->entry = NULL;
575
576 if (shar->work.length < 65536)
577 return (ARCHIVE_OK);
578
579 ret = __archive_write_output(a, shar->work.s, shar->work.length);
580 if (ret != ARCHIVE_OK)
581 return (ARCHIVE_FATAL);
582 archive_string_empty(&shar->work);
583
584 return (ARCHIVE_OK);
585 }
586
587 static int
archive_write_shar_close(struct archive_write * a)588 archive_write_shar_close(struct archive_write *a)
589 {
590 struct shar *shar;
591 int ret;
592
593 /*
594 * TODO: Accumulate list of directory names/modes and
595 * fix them all up at end-of-archive.
596 */
597
598 shar = (struct shar *)a->format_data;
599
600 /*
601 * Only write the end-of-archive markers if the archive was
602 * actually started. This avoids problems if someone sets
603 * shar format, then sets another format (which would invoke
604 * shar_finish to free the format-specific data).
605 */
606 if (shar->wrote_header == 0)
607 return (ARCHIVE_OK);
608
609 archive_strcat(&shar->work, "exit\n");
610
611 ret = __archive_write_output(a, shar->work.s, shar->work.length);
612 if (ret != ARCHIVE_OK)
613 return (ARCHIVE_FATAL);
614
615 /* Shar output is never padded. */
616 archive_write_set_bytes_in_last_block(&a->archive, 1);
617 /*
618 * TODO: shar should also suppress padding of
619 * uncompressed data within gzip/bzip2 streams.
620 */
621
622 return (ARCHIVE_OK);
623 }
624
625 static int
archive_write_shar_free(struct archive_write * a)626 archive_write_shar_free(struct archive_write *a)
627 {
628 struct shar *shar;
629
630 shar = (struct shar *)a->format_data;
631 if (shar == NULL)
632 return (ARCHIVE_OK);
633
634 archive_entry_free(shar->entry);
635 free(shar->last_dir);
636 archive_string_free(&(shar->work));
637 archive_string_free(&(shar->quoted_name));
638 free(shar);
639 a->format_data = NULL;
640 return (ARCHIVE_OK);
641 }
642