| Current Path : /usr/src/contrib/libarchive/libarchive/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //usr/src/contrib/libarchive/libarchive/archive_write_set_format_shar.c |
/*-
* 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: release/9.1.0/contrib/libarchive/libarchive/archive_write_set_format_shar.c 229592 2012-01-05 12:06:54Z mm $");
#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_finish(struct archive_write *);
static int archive_write_shar_destroy(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;
/* If someone else was already registered, unregister them. */
if (a->format_destroy != NULL)
(a->format_destroy)(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->pad_uncompressed = 0;
a->format_name = "shar";
a->format_write_header = archive_write_shar_header;
a->format_finish = archive_write_shar_finish;
a->format_destroy = archive_write_shar_destroy;
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) {
archive_string_sprintf(&shar->work,
"uudecode -p > %s << 'SHAR_END'\n",
shar->quoted_name.s);
archive_string_sprintf(&shar->work,
"begin %o ",
archive_entry_mode(entry) & 0777);
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 %d %d\n", shar->quoted_name.s,
archive_entry_rdevmajor(entry),
archive_entry_rdevminor(entry));
break;
case AE_IFBLK:
archive_string_sprintf(&shar->work,
"mknod %s b %d %d\n", shar->quoted_name.s,
archive_entry_rdevmajor(entry),
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_errx(1, "Out of memory");
if (shar->work.length > ensured) {
ret = (*a->compressor.write)(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 = (*a->compressor.write)(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 void
uuencode_line(struct shar *shar, const char *inbuf, size_t len)
{
char tmp_buf[3], *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_errx(1, "Out of memory");
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) {
tmp_buf[0] = inbuf[0];
if (len == 1)
tmp_buf[1] = '\0';
else
tmp_buf[1] = inbuf[1];
tmp_buf[2] = '\0';
uuencode_group(inbuf, buf);
buf += 4;
}
*buf++ = '\n';
if ((buf - shar->work.s) > (ptrdiff_t)(shar->work.length + 62))
__archive_errx(1, "Buffer overflow");
shar->work.length = buf - shar->work.s;
}
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(shar, shar->outbuff, 45);
src += n;
n = length - n;
} else {
n = length;
}
while (n >= 45) {
uuencode_line(shar, src, 45);
src += 45;
n -= 45;
if (shar->work.length < 65536)
continue;
ret = (*a->compressor.write)(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(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 ",
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 = (*a->compressor.write)(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_finish(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 = (*a->compressor.write)(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_destroy(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);
}