You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
643 lines
17 KiB
643 lines
17 KiB
/*-
|
|
* Copyright (c) 2003-2007 Tim Kientzle
|
|
* Copyright (c) 2008 Joerg Sonnenberger
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "archive_platform.h"
|
|
__FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_shar.c 189438 2009-03-06 05:58:56Z kientzle $");
|
|
|
|
#ifdef HAVE_ERRNO_H
|
|
#include <errno.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#ifdef HAVE_STDLIB_H
|
|
#include <stdlib.h>
|
|
#endif
|
|
#ifdef HAVE_STRING_H
|
|
#include <string.h>
|
|
#endif
|
|
|
|
#include "archive.h"
|
|
#include "archive_entry.h"
|
|
#include "archive_private.h"
|
|
#include "archive_write_private.h"
|
|
|
|
struct shar {
|
|
int dump;
|
|
int end_of_line;
|
|
struct archive_entry *entry;
|
|
int has_data;
|
|
char *last_dir;
|
|
|
|
/* Line buffer for uuencoded dump format */
|
|
char outbuff[45];
|
|
size_t outpos;
|
|
|
|
int wrote_header;
|
|
struct archive_string work;
|
|
struct archive_string quoted_name;
|
|
};
|
|
|
|
static int archive_write_shar_close(struct archive_write *);
|
|
static int archive_write_shar_free(struct archive_write *);
|
|
static int archive_write_shar_header(struct archive_write *,
|
|
struct archive_entry *);
|
|
static ssize_t archive_write_shar_data_sed(struct archive_write *,
|
|
const void * buff, size_t);
|
|
static ssize_t archive_write_shar_data_uuencode(struct archive_write *,
|
|
const void * buff, size_t);
|
|
static int archive_write_shar_finish_entry(struct archive_write *);
|
|
|
|
/*
|
|
* Copy the given string to the buffer, quoting all shell meta characters
|
|
* found.
|
|
*/
|
|
static void
|
|
shar_quote(struct archive_string *buf, const char *str, int in_shell)
|
|
{
|
|
static const char meta[] = "\n \t'`\";&<>()|*?{}[]\\$!#^~";
|
|
size_t len;
|
|
|
|
while (*str != '\0') {
|
|
if ((len = strcspn(str, meta)) != 0) {
|
|
archive_strncat(buf, str, len);
|
|
str += len;
|
|
} else if (*str == '\n') {
|
|
if (in_shell)
|
|
archive_strcat(buf, "\"\n\"");
|
|
else
|
|
archive_strcat(buf, "\\n");
|
|
++str;
|
|
} else {
|
|
archive_strappend_char(buf, '\\');
|
|
archive_strappend_char(buf, *str);
|
|
++str;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set output format to 'shar' format.
|
|
*/
|
|
int
|
|
archive_write_set_format_shar(struct archive *_a)
|
|
{
|
|
struct archive_write *a = (struct archive_write *)_a;
|
|
struct shar *shar;
|
|
|
|
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
|
|
ARCHIVE_STATE_NEW, "archive_write_set_format_shar");
|
|
|
|
/* If someone else was already registered, unregister them. */
|
|
if (a->format_free != NULL)
|
|
(a->format_free)(a);
|
|
|
|
shar = (struct shar *)malloc(sizeof(*shar));
|
|
if (shar == NULL) {
|
|
archive_set_error(&a->archive, ENOMEM, "Can't allocate shar data");
|
|
return (ARCHIVE_FATAL);
|
|
}
|
|
memset(shar, 0, sizeof(*shar));
|
|
archive_string_init(&shar->work);
|
|
archive_string_init(&shar->quoted_name);
|
|
a->format_data = shar;
|
|
a->format_name = "shar";
|
|
a->format_write_header = archive_write_shar_header;
|
|
a->format_close = archive_write_shar_close;
|
|
a->format_free = archive_write_shar_free;
|
|
a->format_write_data = archive_write_shar_data_sed;
|
|
a->format_finish_entry = archive_write_shar_finish_entry;
|
|
a->archive.archive_format = ARCHIVE_FORMAT_SHAR_BASE;
|
|
a->archive.archive_format_name = "shar";
|
|
return (ARCHIVE_OK);
|
|
}
|
|
|
|
/*
|
|
* An alternate 'shar' that uses uudecode instead of 'sed' to encode
|
|
* file contents and can therefore be used to archive binary files.
|
|
* In addition, this variant also attempts to restore ownership, file modes,
|
|
* and other extended file information.
|
|
*/
|
|
int
|
|
archive_write_set_format_shar_dump(struct archive *_a)
|
|
{
|
|
struct archive_write *a = (struct archive_write *)_a;
|
|
struct shar *shar;
|
|
|
|
archive_write_set_format_shar(&a->archive);
|
|
shar = (struct shar *)a->format_data;
|
|
shar->dump = 1;
|
|
a->format_write_data = archive_write_shar_data_uuencode;
|
|
a->archive.archive_format = ARCHIVE_FORMAT_SHAR_DUMP;
|
|
a->archive.archive_format_name = "shar dump";
|
|
return (ARCHIVE_OK);
|
|
}
|
|
|
|
static int
|
|
archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
|
|
{
|
|
const char *linkname;
|
|
const char *name;
|
|
char *p, *pp;
|
|
struct shar *shar;
|
|
|
|
shar = (struct shar *)a->format_data;
|
|
if (!shar->wrote_header) {
|
|
archive_strcat(&shar->work, "#!/bin/sh\n");
|
|
archive_strcat(&shar->work, "# This is a shell archive\n");
|
|
shar->wrote_header = 1;
|
|
}
|
|
|
|
/* Save the entry for the closing. */
|
|
if (shar->entry)
|
|
archive_entry_free(shar->entry);
|
|
shar->entry = archive_entry_clone(entry);
|
|
name = archive_entry_pathname(entry);
|
|
|
|
/* Handle some preparatory issues. */
|
|
switch(archive_entry_filetype(entry)) {
|
|
case AE_IFREG:
|
|
/* Only regular files have non-zero size. */
|
|
break;
|
|
case AE_IFDIR:
|
|
archive_entry_set_size(entry, 0);
|
|
/* Don't bother trying to recreate '.' */
|
|
if (strcmp(name, ".") == 0 || strcmp(name, "./") == 0)
|
|
return (ARCHIVE_OK);
|
|
break;
|
|
case AE_IFIFO:
|
|
case AE_IFCHR:
|
|
case AE_IFBLK:
|
|
/* All other file types have zero size in the archive. */
|
|
archive_entry_set_size(entry, 0);
|
|
break;
|
|
default:
|
|
archive_entry_set_size(entry, 0);
|
|
if (archive_entry_hardlink(entry) == NULL &&
|
|
archive_entry_symlink(entry) == NULL) {
|
|
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
|
|
"shar format cannot archive this");
|
|
return (ARCHIVE_WARN);
|
|
}
|
|
}
|
|
|
|
archive_string_empty(&shar->quoted_name);
|
|
shar_quote(&shar->quoted_name, name, 1);
|
|
|
|
/* Stock preparation for all file types. */
|
|
archive_string_sprintf(&shar->work, "echo x %s\n", shar->quoted_name.s);
|
|
|
|
if (archive_entry_filetype(entry) != AE_IFDIR) {
|
|
/* Try to create the dir. */
|
|
p = strdup(name);
|
|
pp = strrchr(p, '/');
|
|
/* If there is a / character, try to create the dir. */
|
|
if (pp != NULL) {
|
|
*pp = '\0';
|
|
|
|
/* Try to avoid a lot of redundant mkdir commands. */
|
|
if (strcmp(p, ".") == 0) {
|
|
/* Don't try to "mkdir ." */
|
|
free(p);
|
|
} else if (shar->last_dir == NULL) {
|
|
archive_strcat(&shar->work, "mkdir -p ");
|
|
shar_quote(&shar->work, p, 1);
|
|
archive_strcat(&shar->work,
|
|
" > /dev/null 2>&1\n");
|
|
shar->last_dir = p;
|
|
} else if (strcmp(p, shar->last_dir) == 0) {
|
|
/* We've already created this exact dir. */
|
|
free(p);
|
|
} else if (strlen(p) < strlen(shar->last_dir) &&
|
|
strncmp(p, shar->last_dir, strlen(p)) == 0) {
|
|
/* We've already created a subdir. */
|
|
free(p);
|
|
} else {
|
|
archive_strcat(&shar->work, "mkdir -p ");
|
|
shar_quote(&shar->work, p, 1);
|
|
archive_strcat(&shar->work,
|
|
" > /dev/null 2>&1\n");
|
|
shar->last_dir = p;
|
|
}
|
|
} else {
|
|
free(p);
|
|
}
|
|
}
|
|
|
|
/* Handle file-type specific issues. */
|
|
shar->has_data = 0;
|
|
if ((linkname = archive_entry_hardlink(entry)) != NULL) {
|
|
archive_strcat(&shar->work, "ln -f ");
|
|
shar_quote(&shar->work, linkname, 1);
|
|
archive_string_sprintf(&shar->work, " %s\n",
|
|
shar->quoted_name.s);
|
|
} else if ((linkname = archive_entry_symlink(entry)) != NULL) {
|
|
archive_strcat(&shar->work, "ln -fs ");
|
|
shar_quote(&shar->work, linkname, 1);
|
|
archive_string_sprintf(&shar->work, " %s\n",
|
|
shar->quoted_name.s);
|
|
} else {
|
|
switch(archive_entry_filetype(entry)) {
|
|
case AE_IFREG:
|
|
if (archive_entry_size(entry) == 0) {
|
|
/* More portable than "touch." */
|
|
archive_string_sprintf(&shar->work,
|
|
"test -e \"%s\" || :> \"%s\"\n",
|
|
shar->quoted_name.s, shar->quoted_name.s);
|
|
} else {
|
|
if (shar->dump) {
|
|
unsigned int mode = archive_entry_mode(entry) & 0777;
|
|
archive_string_sprintf(&shar->work,
|
|
"uudecode -p > %s << 'SHAR_END'\n",
|
|
shar->quoted_name.s);
|
|
archive_string_sprintf(&shar->work,
|
|
"begin %o ", mode);
|
|
shar_quote(&shar->work, name, 0);
|
|
archive_strcat(&shar->work, "\n");
|
|
} else {
|
|
archive_string_sprintf(&shar->work,
|
|
"sed 's/^X//' > %s << 'SHAR_END'\n",
|
|
shar->quoted_name.s);
|
|
}
|
|
shar->has_data = 1;
|
|
shar->end_of_line = 1;
|
|
shar->outpos = 0;
|
|
}
|
|
break;
|
|
case AE_IFDIR:
|
|
archive_string_sprintf(&shar->work,
|
|
"mkdir -p %s > /dev/null 2>&1\n",
|
|
shar->quoted_name.s);
|
|
/* Record that we just created this directory. */
|
|
if (shar->last_dir != NULL)
|
|
free(shar->last_dir);
|
|
|
|
shar->last_dir = strdup(name);
|
|
/* Trim a trailing '/'. */
|
|
pp = strrchr(shar->last_dir, '/');
|
|
if (pp != NULL && pp[1] == '\0')
|
|
*pp = '\0';
|
|
/*
|
|
* TODO: Put dir name/mode on a list to be fixed
|
|
* up at end of archive.
|
|
*/
|
|
break;
|
|
case AE_IFIFO:
|
|
archive_string_sprintf(&shar->work,
|
|
"mkfifo %s\n", shar->quoted_name.s);
|
|
break;
|
|
case AE_IFCHR:
|
|
archive_string_sprintf(&shar->work,
|
|
"mknod %s c %ju %ju\n", shar->quoted_name.s,
|
|
(uintmax_t)archive_entry_rdevmajor(entry),
|
|
(uintmax_t)archive_entry_rdevminor(entry));
|
|
break;
|
|
case AE_IFBLK:
|
|
archive_string_sprintf(&shar->work,
|
|
"mknod %s b %ju %ju\n", shar->quoted_name.s,
|
|
(uintmax_t)archive_entry_rdevmajor(entry),
|
|
(uintmax_t)archive_entry_rdevminor(entry));
|
|
break;
|
|
default:
|
|
return (ARCHIVE_WARN);
|
|
}
|
|
}
|
|
|
|
return (ARCHIVE_OK);
|
|
}
|
|
|
|
static ssize_t
|
|
archive_write_shar_data_sed(struct archive_write *a, const void *buff, size_t n)
|
|
{
|
|
static const size_t ensured = 65533;
|
|
struct shar *shar;
|
|
const char *src;
|
|
char *buf, *buf_end;
|
|
int ret;
|
|
size_t written = n;
|
|
|
|
shar = (struct shar *)a->format_data;
|
|
if (!shar->has_data || n == 0)
|
|
return (0);
|
|
|
|
src = (const char *)buff;
|
|
|
|
/*
|
|
* ensure is the number of bytes in buffer before expanding the
|
|
* current character. Each operation writes the current character
|
|
* and optionally the start-of-new-line marker. This can happen
|
|
* twice before entering the loop, so make sure three additional
|
|
* bytes can be written.
|
|
*/
|
|
if (archive_string_ensure(&shar->work, ensured + 3) == NULL) {
|
|
archive_set_error(&a->archive, ENOMEM, "Out of memory");
|
|
return (ARCHIVE_FATAL);
|
|
}
|
|
|
|
if (shar->work.length > ensured) {
|
|
ret = __archive_write_output(a, shar->work.s,
|
|
shar->work.length);
|
|
if (ret != ARCHIVE_OK)
|
|
return (ARCHIVE_FATAL);
|
|
archive_string_empty(&shar->work);
|
|
}
|
|
buf = shar->work.s + shar->work.length;
|
|
buf_end = shar->work.s + ensured;
|
|
|
|
if (shar->end_of_line) {
|
|
*buf++ = 'X';
|
|
shar->end_of_line = 0;
|
|
}
|
|
|
|
while (n-- != 0) {
|
|
if ((*buf++ = *src++) == '\n') {
|
|
if (n == 0)
|
|
shar->end_of_line = 1;
|
|
else
|
|
*buf++ = 'X';
|
|
}
|
|
|
|
if (buf >= buf_end) {
|
|
shar->work.length = buf - shar->work.s;
|
|
ret = __archive_write_output(a, shar->work.s,
|
|
shar->work.length);
|
|
if (ret != ARCHIVE_OK)
|
|
return (ARCHIVE_FATAL);
|
|
archive_string_empty(&shar->work);
|
|
buf = shar->work.s;
|
|
}
|
|
}
|
|
|
|
shar->work.length = buf - shar->work.s;
|
|
|
|
return (written);
|
|
}
|
|
|
|
#define UUENC(c) (((c)!=0) ? ((c) & 077) + ' ': '`')
|
|
|
|
static void
|
|
uuencode_group(const char _in[3], char out[4])
|
|
{
|
|
const unsigned char *in = (const unsigned char *)_in;
|
|
int t;
|
|
|
|
t = (in[0] << 16) | (in[1] << 8) | in[2];
|
|
out[0] = UUENC( 0x3f & (t >> 18) );
|
|
out[1] = UUENC( 0x3f & (t >> 12) );
|
|
out[2] = UUENC( 0x3f & (t >> 6) );
|
|
out[3] = UUENC( 0x3f & t );
|
|
}
|
|
|
|
static int
|
|
_uuencode_line(struct archive_write *a, struct shar *shar, const char *inbuf, size_t len)
|
|
{
|
|
char *buf;
|
|
size_t alloc_len;
|
|
|
|
/* len <= 45 -> expanded to 60 + len byte + new line */
|
|
alloc_len = shar->work.length + 62;
|
|
if (archive_string_ensure(&shar->work, alloc_len) == NULL) {
|
|
archive_set_error(&a->archive, ENOMEM, "Out of memory");
|
|
return (ARCHIVE_FATAL);
|
|
}
|
|
|
|
buf = shar->work.s + shar->work.length;
|
|
*buf++ = UUENC(len);
|
|
while (len >= 3) {
|
|
uuencode_group(inbuf, buf);
|
|
len -= 3;
|
|
inbuf += 3;
|
|
buf += 4;
|
|
}
|
|
if (len != 0) {
|
|
char tmp_buf[3];
|
|
tmp_buf[0] = inbuf[0];
|
|
if (len == 1)
|
|
tmp_buf[1] = '\0';
|
|
else
|
|
tmp_buf[1] = inbuf[1];
|
|
tmp_buf[2] = '\0';
|
|
uuencode_group(tmp_buf, buf);
|
|
buf += 4;
|
|
}
|
|
*buf++ = '\n';
|
|
if ((buf - shar->work.s) > (ptrdiff_t)(shar->work.length + 62)) {
|
|
archive_set_error(&a->archive,
|
|
ARCHIVE_ERRNO_MISC, "Buffer overflow");
|
|
return (ARCHIVE_FATAL);
|
|
}
|
|
shar->work.length = buf - shar->work.s;
|
|
return (ARCHIVE_OK);
|
|
}
|
|
|
|
#define uuencode_line(__a, __shar, __inbuf, __len) \
|
|
do { \
|
|
int r = _uuencode_line(__a, __shar, __inbuf, __len); \
|
|
if (r != ARCHIVE_OK) \
|
|
return (ARCHIVE_FATAL); \
|
|
} while (0)
|
|
|
|
static ssize_t
|
|
archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
|
|
size_t length)
|
|
{
|
|
struct shar *shar;
|
|
const char *src;
|
|
size_t n;
|
|
int ret;
|
|
|
|
shar = (struct shar *)a->format_data;
|
|
if (!shar->has_data)
|
|
return (ARCHIVE_OK);
|
|
src = (const char *)buff;
|
|
|
|
if (shar->outpos != 0) {
|
|
n = 45 - shar->outpos;
|
|
if (n > length)
|
|
n = length;
|
|
memcpy(shar->outbuff + shar->outpos, src, n);
|
|
if (shar->outpos + n < 45) {
|
|
shar->outpos += n;
|
|
return length;
|
|
}
|
|
uuencode_line(a, shar, shar->outbuff, 45);
|
|
src += n;
|
|
n = length - n;
|
|
} else {
|
|
n = length;
|
|
}
|
|
|
|
while (n >= 45) {
|
|
uuencode_line(a, shar, src, 45);
|
|
src += 45;
|
|
n -= 45;
|
|
|
|
if (shar->work.length < 65536)
|
|
continue;
|
|
ret = __archive_write_output(a, shar->work.s,
|
|
shar->work.length);
|
|
if (ret != ARCHIVE_OK)
|
|
return (ARCHIVE_FATAL);
|
|
archive_string_empty(&shar->work);
|
|
}
|
|
if (n != 0) {
|
|
memcpy(shar->outbuff, src, n);
|
|
shar->outpos = n;
|
|
}
|
|
return (length);
|
|
}
|
|
|
|
static int
|
|
archive_write_shar_finish_entry(struct archive_write *a)
|
|
{
|
|
const char *g, *p, *u;
|
|
struct shar *shar;
|
|
int ret;
|
|
|
|
shar = (struct shar *)a->format_data;
|
|
if (shar->entry == NULL)
|
|
return (0);
|
|
|
|
if (shar->dump) {
|
|
/* Finish uuencoded data. */
|
|
if (shar->has_data) {
|
|
if (shar->outpos > 0)
|
|
uuencode_line(a, shar, shar->outbuff,
|
|
shar->outpos);
|
|
archive_strcat(&shar->work, "`\nend\n");
|
|
archive_strcat(&shar->work, "SHAR_END\n");
|
|
}
|
|
/* Restore file mode, owner, flags. */
|
|
/*
|
|
* TODO: Don't immediately restore mode for
|
|
* directories; defer that to end of script.
|
|
*/
|
|
archive_string_sprintf(&shar->work, "chmod %o ",
|
|
(unsigned int)(archive_entry_mode(shar->entry) & 07777));
|
|
shar_quote(&shar->work, archive_entry_pathname(shar->entry), 1);
|
|
archive_strcat(&shar->work, "\n");
|
|
|
|
u = archive_entry_uname(shar->entry);
|
|
g = archive_entry_gname(shar->entry);
|
|
if (u != NULL || g != NULL) {
|
|
archive_strcat(&shar->work, "chown ");
|
|
if (u != NULL)
|
|
shar_quote(&shar->work, u, 1);
|
|
if (g != NULL) {
|
|
archive_strcat(&shar->work, ":");
|
|
shar_quote(&shar->work, g, 1);
|
|
}
|
|
shar_quote(&shar->work,
|
|
archive_entry_pathname(shar->entry), 1);
|
|
archive_strcat(&shar->work, "\n");
|
|
}
|
|
|
|
if ((p = archive_entry_fflags_text(shar->entry)) != NULL) {
|
|
archive_string_sprintf(&shar->work, "chflags %s ", p);
|
|
shar_quote(&shar->work,
|
|
archive_entry_pathname(shar->entry), 1);
|
|
archive_strcat(&shar->work, "\n");
|
|
}
|
|
|
|
/* TODO: restore ACLs */
|
|
|
|
} else {
|
|
if (shar->has_data) {
|
|
/* Finish sed-encoded data: ensure last line ends. */
|
|
if (!shar->end_of_line)
|
|
archive_strappend_char(&shar->work, '\n');
|
|
archive_strcat(&shar->work, "SHAR_END\n");
|
|
}
|
|
}
|
|
|
|
archive_entry_free(shar->entry);
|
|
shar->entry = NULL;
|
|
|
|
if (shar->work.length < 65536)
|
|
return (ARCHIVE_OK);
|
|
|
|
ret = __archive_write_output(a, shar->work.s, shar->work.length);
|
|
if (ret != ARCHIVE_OK)
|
|
return (ARCHIVE_FATAL);
|
|
archive_string_empty(&shar->work);
|
|
|
|
return (ARCHIVE_OK);
|
|
}
|
|
|
|
static int
|
|
archive_write_shar_close(struct archive_write *a)
|
|
{
|
|
struct shar *shar;
|
|
int ret;
|
|
|
|
/*
|
|
* TODO: Accumulate list of directory names/modes and
|
|
* fix them all up at end-of-archive.
|
|
*/
|
|
|
|
shar = (struct shar *)a->format_data;
|
|
|
|
/*
|
|
* Only write the end-of-archive markers if the archive was
|
|
* actually started. This avoids problems if someone sets
|
|
* shar format, then sets another format (which would invoke
|
|
* shar_finish to free the format-specific data).
|
|
*/
|
|
if (shar->wrote_header == 0)
|
|
return (ARCHIVE_OK);
|
|
|
|
archive_strcat(&shar->work, "exit\n");
|
|
|
|
ret = __archive_write_output(a, shar->work.s, shar->work.length);
|
|
if (ret != ARCHIVE_OK)
|
|
return (ARCHIVE_FATAL);
|
|
|
|
/* Shar output is never padded. */
|
|
archive_write_set_bytes_in_last_block(&a->archive, 1);
|
|
/*
|
|
* TODO: shar should also suppress padding of
|
|
* uncompressed data within gzip/bzip2 streams.
|
|
*/
|
|
|
|
return (ARCHIVE_OK);
|
|
}
|
|
|
|
static int
|
|
archive_write_shar_free(struct archive_write *a)
|
|
{
|
|
struct shar *shar;
|
|
|
|
shar = (struct shar *)a->format_data;
|
|
if (shar == NULL)
|
|
return (ARCHIVE_OK);
|
|
|
|
archive_entry_free(shar->entry);
|
|
free(shar->last_dir);
|
|
archive_string_free(&(shar->work));
|
|
archive_string_free(&(shar->quoted_name));
|
|
free(shar);
|
|
a->format_data = NULL;
|
|
return (ARCHIVE_OK);
|
|
}
|