← Back to branch summary

~db-keen/tanzanite/rat

« back to all changes in this revision

Viewing changes to sources/libarchive-1.2.53/libarchive/archive_write_set_format_shar.c

  • Committer: austin
  • Date: 2007-02-05 03:24:13 UTC
  • Revision ID: svn-v4:8b90d6ed-dc11-0410-98dd-e2d1db709ad4:rat/spikes/2006-05-13:45
Reorganizing the RAT project.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sources/libarchive-1.2.53/libarchive/archive_write_set_format_shar.c
 
1
/*-
 
2
 * Copyright (c) 2003-2004 Tim Kientzle
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer
 
10
 *    in this position and unchanged.
 
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: src/lib/libarchive/archive_write_set_format_shar.c,v 1.11 2004/11/05 05:26:30 kientzle Exp $");
 
29
 
 
30
#include <sys/stat.h>
 
31
#include <errno.h>
 
32
#include <stdarg.h>
 
33
#include <stdio.h>
 
34
#include <stdlib.h>
 
35
#include <string.h>
 
36
 
 
37
#include "archive.h"
 
38
#include "archive_entry.h"
 
39
#include "archive_private.h"
 
40
 
 
41
struct shar {
 
42
        int                      dump;
 
43
        int                      end_of_line;
 
44
        struct archive_entry    *entry;
 
45
        int                      has_data;
 
46
        char                    *last_dir;
 
47
        char                     outbuff[1024];
 
48
        size_t                   outbytes;
 
49
        size_t                   outpos;
 
50
        int                      uuavail;
 
51
        char                     uubuffer[3];
 
52
        int                      wrote_header;
 
53
        struct archive_string    work;
 
54
};
 
55
 
 
56
static int      archive_write_shar_finish(struct archive *);
 
57
static int      archive_write_shar_header(struct archive *,
 
58
                    struct archive_entry *);
 
59
static int      archive_write_shar_data_sed(struct archive *,
 
60
                    const void * buff, size_t);
 
61
static int      archive_write_shar_data_uuencode(struct archive *,
 
62
                    const void * buff, size_t);
 
63
static int      archive_write_shar_finish_entry(struct archive *);
 
64
static int      shar_printf(struct archive *, const char *fmt, ...);
 
65
static void     uuencode_group(struct shar *);
 
66
 
 
67
static int
 
68
shar_printf(struct archive *a, const char *fmt, ...)
 
69
{
 
70
        struct shar *shar;
 
71
        va_list ap;
 
72
        int ret;
 
73
 
 
74
        shar = a->format_data;
 
75
        va_start(ap, fmt);
 
76
        archive_string_empty(&(shar->work));
 
77
        archive_string_vsprintf(&(shar->work), fmt, ap);
 
78
        ret = ((a->compression_write)(a, shar->work.s, strlen(shar->work.s)));
 
79
        va_end(ap);
 
80
        return (ret);
 
81
}
 
82
 
 
83
/*
 
84
 * Set output format to 'shar' format.
 
85
 */
 
86
int
 
87
archive_write_set_format_shar(struct archive *a)
 
88
{
 
89
        struct shar *shar;
 
90
 
 
91
        /* If someone else was already registered, unregister them. */
 
92
        if (a->format_finish != NULL)
 
93
                (a->format_finish)(a);
 
94
 
 
95
        shar = malloc(sizeof(*shar));
 
96
        if (shar == NULL) {
 
97
                archive_set_error(a, ENOMEM, "Can't allocate shar data");
 
98
                return (ARCHIVE_FATAL);
 
99
        }
 
100
        memset(shar, 0, sizeof(*shar));
 
101
        a->format_data = shar;
 
102
 
 
103
        a->pad_uncompressed = 0;
 
104
        a->format_write_header = archive_write_shar_header;
 
105
        a->format_finish = archive_write_shar_finish;
 
106
        a->format_write_data = archive_write_shar_data_sed;
 
107
        a->format_finish_entry = archive_write_shar_finish_entry;
 
108
        a->archive_format = ARCHIVE_FORMAT_SHAR_BASE;
 
109
        a->archive_format_name = "shar";
 
110
        return (ARCHIVE_OK);
 
111
}
 
112
 
 
113
/*
 
114
 * An alternate 'shar' that uses uudecode instead of 'sed' to encode
 
115
 * file contents and can therefore be used to archive binary files.
 
116
 * In addition, this variant also attempts to restore ownership, file modes,
 
117
 * and other extended file information.
 
118
 */
 
119
int
 
120
archive_write_set_format_shar_dump(struct archive *a)
 
121
{
 
122
        struct shar *shar;
 
123
 
 
124
        archive_write_set_format_shar(a);
 
125
        shar = a->format_data;
 
126
        shar->dump = 1;
 
127
        a->format_write_data = archive_write_shar_data_uuencode;
 
128
        a->archive_format = ARCHIVE_FORMAT_SHAR_DUMP;
 
129
        a->archive_format_name = "shar dump";
 
130
        return (ARCHIVE_OK);
 
131
}
 
132
 
 
133
static int
 
134
archive_write_shar_header(struct archive *a, struct archive_entry *entry)
 
135
{
 
136
        const char *linkname;
 
137
        const char *name;
 
138
        char *p, *pp;
 
139
        struct shar *shar;
 
140
        const struct stat *st;
 
141
        int ret;
 
142
 
 
143
        shar = a->format_data;
 
144
        if (!shar->wrote_header) {
 
145
                ret = shar_printf(a, "#!/bin/sh\n");
 
146
                if (ret != ARCHIVE_OK)
 
147
                        return (ret);
 
148
                ret = shar_printf(a, "# This is a shell archive\n");
 
149
                if (ret != ARCHIVE_OK)
 
150
                        return (ret);
 
151
                shar->wrote_header = 1;
 
152
        }
 
153
 
 
154
        /* Save the entry for the closing. */
 
155
        if (shar->entry)
 
156
                archive_entry_free(shar->entry);
 
157
        shar->entry = archive_entry_clone(entry);
 
158
        name = archive_entry_pathname(entry);
 
159
        st = archive_entry_stat(entry);
 
160
 
 
161
        /* Handle some preparatory issues. */
 
162
        switch(st->st_mode & S_IFMT) {
 
163
        case S_IFREG:
 
164
                /* Only regular files have non-zero size. */
 
165
                break;
 
166
        case S_IFDIR:
 
167
                archive_entry_set_size(entry, 0);
 
168
                /* Don't bother trying to recreate '.' */
 
169
                if (strcmp(name, ".") == 0  ||  strcmp(name, "./") == 0)
 
170
                        return (ARCHIVE_OK);
 
171
                break;
 
172
        case S_IFIFO:
 
173
        case S_IFCHR:
 
174
        case S_IFBLK:
 
175
                /* All other file types have zero size in the archive. */
 
176
                archive_entry_set_size(entry, 0);
 
177
                break;
 
178
        default:
 
179
                archive_entry_set_size(entry, 0);
 
180
                if (archive_entry_hardlink(entry) == NULL &&
 
181
                    archive_entry_symlink(entry) == NULL) {
 
182
                        archive_set_error(a, ARCHIVE_ERRNO_MISC,
 
183
                            "shar format cannot archive this");
 
184
                        return (ARCHIVE_WARN);
 
185
                }
 
186
        }
 
187
 
 
188
        /* Stock preparation for all file types. */
 
189
        ret = shar_printf(a, "echo x %s\n", name);
 
190
        if (ret != ARCHIVE_OK)
 
191
                return (ret);
 
192
 
 
193
        if (!S_ISDIR(st->st_mode)) {
 
194
                /* Try to create the dir. */
 
195
                p = strdup(name);
 
196
                pp = strrchr(p, '/');
 
197
                /* If there is a / character, try to create the dir. */
 
198
                if (pp != NULL) {
 
199
                        *pp = '\0';
 
200
 
 
201
                        /* Try to avoid a lot of redundant mkdir commands. */
 
202
                        if (strcmp(p, ".") == 0) {
 
203
                                /* Don't try to "mkdir ." */
 
204
                        } else if (shar->last_dir == NULL) {
 
205
                                ret = shar_printf(a,
 
206
                                    "mkdir -p %s > /dev/null 2>&1\n", p);
 
207
                                if (ret != ARCHIVE_OK)
 
208
                                        return (ret);
 
209
                                shar->last_dir = p;
 
210
                        } else if (strcmp(p, shar->last_dir) == 0) {
 
211
                                /* We've already created this exact dir. */
 
212
                                free(p);
 
213
                        } else if (strlen(p) < strlen(shar->last_dir) &&
 
214
                            strncmp(p, shar->last_dir, strlen(p)) == 0) {
 
215
                                /* We've already created a subdir. */
 
216
                                free(p);
 
217
                        } else {
 
218
                                ret = shar_printf(a,
 
219
                                    "mkdir -p %s > /dev/null 2>&1\n", p);
 
220
                                if (ret != ARCHIVE_OK)
 
221
                                        return (ret);
 
222
                                free(shar->last_dir);
 
223
                                shar->last_dir = p;
 
224
                        }
 
225
                }
 
226
        }
 
227
 
 
228
        /* Handle file-type specific issues. */
 
229
        shar->has_data = 0;
 
230
        if ((linkname = archive_entry_hardlink(entry)) != NULL) {
 
231
                ret = shar_printf(a, "ln -f %s %s\n", linkname, name);
 
232
                if (ret != ARCHIVE_OK)
 
233
                        return (ret);
 
234
        } else if ((linkname = archive_entry_symlink(entry)) != NULL) {
 
235
                ret = shar_printf(a, "ln -fs %s %s\n", linkname, name);
 
236
                if (ret != ARCHIVE_OK)
 
237
                        return (ret);
 
238
        } else {
 
239
                switch(st->st_mode & S_IFMT) {
 
240
                case S_IFREG:
 
241
                        if (archive_entry_size(entry) == 0) {
 
242
                                /* More portable than "touch." */
 
243
                                ret = shar_printf(a, "test -e \"%s\" || :> \"%s\"\n", name, name);
 
244
                                if (ret != ARCHIVE_OK)
 
245
                                        return (ret);
 
246
                        } else {
 
247
                                if (shar->dump) {
 
248
                                        ret = shar_printf(a,
 
249
                                            "uudecode -o %s << 'SHAR_END'\n",
 
250
                                            name);
 
251
                                        if (ret != ARCHIVE_OK)
 
252
                                                return (ret);
 
253
                                        ret = shar_printf(a, "begin %o %s\n",
 
254
                                            archive_entry_mode(entry) & 0777,
 
255
                                            name);
 
256
                                        if (ret != ARCHIVE_OK)
 
257
                                                return (ret);
 
258
                                } else {
 
259
                                        ret = shar_printf(a,
 
260
                                            "sed 's/^X//' > %s << 'SHAR_END'\n",
 
261
                                            name);
 
262
                                        if (ret != ARCHIVE_OK)
 
263
                                                return (ret);
 
264
                                }
 
265
                                shar->has_data = 1;
 
266
                                shar->end_of_line = 1;
 
267
                                shar->outpos = 0;
 
268
                                shar->outbytes = 0;
 
269
                        }
 
270
                        break;
 
271
                case S_IFDIR:
 
272
                        ret = shar_printf(a, "mkdir -p %s > /dev/null 2>&1\n",
 
273
                            name);
 
274
                        if (ret != ARCHIVE_OK)
 
275
                                return (ret);
 
276
                        /* Record that we just created this directory. */
 
277
                        if (shar->last_dir != NULL)
 
278
                                free(shar->last_dir);
 
279
 
 
280
                        shar->last_dir = strdup(name);
 
281
                        /* Trim a trailing '/'. */
 
282
                        pp = strrchr(shar->last_dir, '/');
 
283
                        if (pp != NULL && pp[1] == '\0')
 
284
                                *pp = '\0';
 
285
                        /*
 
286
                         * TODO: Put dir name/mode on a list to be fixed
 
287
                         * up at end of archive.
 
288
                         */
 
289
                        break;
 
290
                case S_IFIFO:
 
291
                        ret = shar_printf(a, "mkfifo %s\n", name);
 
292
                        if (ret != ARCHIVE_OK)
 
293
                                return (ret);
 
294
                        break;
 
295
                case S_IFCHR:
 
296
                        ret = shar_printf(a, "mknod %s c %d %d\n", name,
 
297
                            archive_entry_rdevmajor(entry),
 
298
                            archive_entry_rdevminor(entry));
 
299
                        if (ret != ARCHIVE_OK)
 
300
                                return (ret);
 
301
                        break;
 
302
                case S_IFBLK:
 
303
                        ret = shar_printf(a, "mknod %s b %d %d\n", name,
 
304
                            archive_entry_rdevmajor(entry),
 
305
                            archive_entry_rdevminor(entry));
 
306
                        if (ret != ARCHIVE_OK)
 
307
                                return (ret);
 
308
                        break;
 
309
                default:
 
310
                        return (ARCHIVE_WARN);
 
311
                }
 
312
        }
 
313
 
 
314
        return (ARCHIVE_OK);
 
315
}
 
316
 
 
317
/* XXX TODO: This could be more efficient XXX */
 
318
static int
 
319
archive_write_shar_data_sed(struct archive *a, const void *buff, size_t n)
 
320
{
 
321
        struct shar *shar;
 
322
        const char *src;
 
323
        int ret;
 
324
 
 
325
        shar = a->format_data;
 
326
        if (!shar->has_data)
 
327
                return (0);
 
328
 
 
329
        src = buff;
 
330
        ret = ARCHIVE_OK;
 
331
        shar->outpos = 0;
 
332
        while (n-- > 0) {
 
333
                if (shar->end_of_line) {
 
334
                        shar->outbuff[shar->outpos++] = 'X';
 
335
                        shar->end_of_line = 0;
 
336
                }
 
337
                if (*src == '\n')
 
338
                        shar->end_of_line = 1;
 
339
                shar->outbuff[shar->outpos++] = *src++;
 
340
 
 
341
                if (shar->outpos > sizeof(shar->outbuff) - 2) {
 
342
                        ret = (a->compression_write)(a, shar->outbuff,
 
343
                            shar->outpos);
 
344
                        if (ret != ARCHIVE_OK)
 
345
                                return (ret);
 
346
                        shar->outpos = 0;
 
347
                }
 
348
        }
 
349
 
 
350
        if (shar->outpos > 0)
 
351
                ret = (a->compression_write)(a, shar->outbuff, shar->outpos);
 
352
        return (ret);
 
353
}
 
354
 
 
355
#define UUENC(c)        (((c)!=0) ? ((c) & 077) + ' ': '`')
 
356
 
 
357
/* XXX This could be a lot more efficient. XXX */
 
358
static void
 
359
uuencode_group(struct shar *shar)
 
360
{
 
361
        int     t;
 
362
 
 
363
        t = 0;
 
364
        if (shar->uuavail > 0)
 
365
                t = 0xff0000 & (shar->uubuffer[0] << 16);
 
366
        if (shar->uuavail > 1)
 
367
                t |= 0x00ff00 & (shar->uubuffer[1] << 8);
 
368
        if (shar->uuavail > 2)
 
369
                t |= 0x0000ff & (shar->uubuffer[2]);
 
370
        shar->outbuff[shar->outpos++] = UUENC( 0x3f & (t>>18) );
 
371
        shar->outbuff[shar->outpos++] = UUENC( 0x3f & (t>>12) );
 
372
        shar->outbuff[shar->outpos++] = UUENC( 0x3f & (t>>6) );
 
373
        shar->outbuff[shar->outpos++] = UUENC( 0x3f & (t) );
 
374
        shar->uuavail = 0;
 
375
        shar->outbytes += shar->uuavail;
 
376
        shar->outbuff[shar->outpos] = 0;
 
377
}
 
378
 
 
379
static int
 
380
archive_write_shar_data_uuencode(struct archive *a, const void *buff,
 
381
    size_t length)
 
382
{
 
383
        struct shar *shar;
 
384
        const char *src;
 
385
        size_t n;
 
386
        int ret;
 
387
 
 
388
        shar = a->format_data;
 
389
        if (!shar->has_data)
 
390
                return (ARCHIVE_OK);
 
391
        src = buff;
 
392
        n = length;
 
393
        while (n-- > 0) {
 
394
                if (shar->uuavail == 3)
 
395
                        uuencode_group(shar);
 
396
                if (shar->outpos >= 60) {
 
397
                        ret = shar_printf(a, "%c%s\n", UUENC(shar->outbytes),
 
398
                            shar->outbuff);
 
399
                        if (ret != ARCHIVE_OK)
 
400
                                return (ret);
 
401
                        shar->outpos = 0;
 
402
                        shar->outbytes = 0;
 
403
                }
 
404
 
 
405
                shar->uubuffer[shar->uuavail++] = *src++;
 
406
                shar->outbytes++;
 
407
        }
 
408
        return (ARCHIVE_OK);
 
409
}
 
410
 
 
411
static int
 
412
archive_write_shar_finish_entry(struct archive *a)
 
413
{
 
414
        const char *g, *p, *u;
 
415
        struct shar *shar;
 
416
        int ret;
 
417
 
 
418
        shar = a->format_data;
 
419
        if (shar->entry == NULL)
 
420
                return (0);
 
421
 
 
422
        if (shar->dump) {
 
423
                /* Finish uuencoded data. */
 
424
                if (shar->has_data) {
 
425
                        if (shar->uuavail > 0)
 
426
                                uuencode_group(shar);
 
427
                        if (shar->outpos > 0) {
 
428
                                ret = shar_printf(a, "%c%s\n",
 
429
                                    UUENC(shar->outbytes), shar->outbuff);
 
430
                                if (ret != ARCHIVE_OK)
 
431
                                        return (ret);
 
432
                                shar->outpos = 0;
 
433
                                shar->uuavail = 0;
 
434
                                shar->outbytes = 0;
 
435
                        }
 
436
                        ret = shar_printf(a, "%c\n", UUENC(0));
 
437
                        if (ret != ARCHIVE_OK)
 
438
                                return (ret);
 
439
                        ret = shar_printf(a, "end\n", UUENC(0));
 
440
                        if (ret != ARCHIVE_OK)
 
441
                                return (ret);
 
442
                        ret = shar_printf(a, "SHAR_END\n");
 
443
                        if (ret != ARCHIVE_OK)
 
444
                                return (ret);
 
445
                }
 
446
                /* Restore file mode, owner, flags. */
 
447
                /*
 
448
                 * TODO: Don't immediately restore mode for
 
449
                 * directories; defer that to end of script.
 
450
                 */
 
451
                ret = shar_printf(a, "chmod %o %s\n",
 
452
                    archive_entry_mode(shar->entry) & 07777,
 
453
                    archive_entry_pathname(shar->entry));
 
454
                if (ret != ARCHIVE_OK)
 
455
                        return (ret);
 
456
 
 
457
                u = archive_entry_uname(shar->entry);
 
458
                g = archive_entry_gname(shar->entry);
 
459
                if (u != NULL || g != NULL) {
 
460
                        ret = shar_printf(a, "chown %s%s%s %s\n",
 
461
                            (u != NULL) ? u : "",
 
462
                            (g != NULL) ? ":" : "", (g != NULL) ? g : "",
 
463
                            archive_entry_pathname(shar->entry));
 
464
                        if (ret != ARCHIVE_OK)
 
465
                                return (ret);
 
466
                }
 
467
 
 
468
                if ((p = archive_entry_fflags_text(shar->entry)) != NULL) {
 
469
                        ret = shar_printf(a, "chflags %s %s\n", p,
 
470
                            archive_entry_pathname(shar->entry));
 
471
                        if (ret != ARCHIVE_OK)
 
472
                                return (ret);
 
473
                }
 
474
 
 
475
                /* TODO: restore ACLs */
 
476
 
 
477
        } else {
 
478
                if (shar->has_data) {
 
479
                        /* Finish sed-encoded data:  ensure last line ends. */
 
480
                        if (!shar->end_of_line) {
 
481
                                ret = shar_printf(a, "\n");
 
482
                                if (ret != ARCHIVE_OK)
 
483
                                        return (ret);
 
484
                        }
 
485
                        ret = shar_printf(a, "SHAR_END\n");
 
486
                        if (ret != ARCHIVE_OK)
 
487
                                return (ret);
 
488
                }
 
489
        }
 
490
 
 
491
        archive_entry_free(shar->entry);
 
492
        shar->entry = NULL;
 
493
        return (0);
 
494
}
 
495
 
 
496
static int
 
497
archive_write_shar_finish(struct archive *a)
 
498
{
 
499
        struct shar *shar;
 
500
        int ret;
 
501
 
 
502
        /*
 
503
         * TODO: Accumulate list of directory names/modes and
 
504
         * fix them all up at end-of-archive.
 
505
         */
 
506
 
 
507
        shar = a->format_data;
 
508
 
 
509
        /*
 
510
         * Only write the end-of-archive markers if the archive was
 
511
         * actually started.  This avoids problems if someone sets
 
512
         * shar format, then sets another format (which would invoke
 
513
         * shar_finish to free the format-specific data).
 
514
         */
 
515
        if (shar->wrote_header) {
 
516
                ret = shar_printf(a, "exit\n");
 
517
                if (ret != ARCHIVE_OK)
 
518
                        return (ret);
 
519
                /* Shar output is never padded. */
 
520
                archive_write_set_bytes_in_last_block(a, 1);
 
521
                /*
 
522
                 * TODO: shar should also suppress padding of
 
523
                 * uncompressed data within gzip/bzip2 streams.
 
524
                 */
 
525
        }
 
526
        if (shar->entry != NULL)
 
527
                archive_entry_free(shar->entry);
 
528
        if (shar->last_dir != NULL)
 
529
                free(shar->last_dir);
 
530
        archive_string_free(&(shar->work));
 
531
        free(shar);
 
532
        a->format_data = NULL;
 
533
        return (ARCHIVE_OK);
 
534
}