Support for writing the 'newc' cpio format, plus a minimal test harness
for the cpio formats. Thanks to: Rudolf Marek Approved by: re@
This commit is contained in:
Tim Kientzle
parent
dffc4a655f
commit
17e60e6230
@ -87,6 +87,7 @@ SRCS= archive.h \
|
||||
archive_write_set_format_ar.c \
|
||||
archive_write_set_format_by_name.c \
|
||||
archive_write_set_format_cpio.c \
|
||||
archive_write_set_format_cpio_newc.c \
|
||||
archive_write_set_format_pax.c \
|
||||
archive_write_set_format_shar.c \
|
||||
archive_write_set_format_ustar.c \
|
||||
|
||||
@ -390,6 +390,7 @@ int archive_write_set_format_by_name(struct archive *,
|
||||
int archive_write_set_format_ar_bsd(struct archive *);
|
||||
int archive_write_set_format_ar_svr4(struct archive *);
|
||||
int archive_write_set_format_cpio(struct archive *);
|
||||
int archive_write_set_format_cpio_newc(struct archive *);
|
||||
/* TODO: int archive_write_set_format_old_tar(struct archive *); */
|
||||
int archive_write_set_format_pax(struct archive *);
|
||||
int archive_write_set_format_pax_restricted(struct archive *);
|
||||
|
||||
@ -42,6 +42,7 @@ static
|
||||
struct { int code; int (*setter)(struct archive *); } codes[] =
|
||||
{
|
||||
{ ARCHIVE_FORMAT_CPIO, archive_write_set_format_cpio },
|
||||
{ ARCHIVE_FORMAT_CPIO_SVR4_NOCRC, archive_write_set_format_cpio_newc },
|
||||
{ ARCHIVE_FORMAT_CPIO_POSIX, archive_write_set_format_cpio },
|
||||
{ ARCHIVE_FORMAT_SHAR, archive_write_set_format_shar },
|
||||
{ ARCHIVE_FORMAT_SHAR_BASE, archive_write_set_format_shar },
|
||||
|
||||
@ -49,6 +49,8 @@ struct { const char *name; int (*setter)(struct archive *); } names[] =
|
||||
{ "argnu", archive_write_set_format_ar_svr4 },
|
||||
{ "arsvr4", archive_write_set_format_ar_svr4 },
|
||||
{ "cpio", archive_write_set_format_cpio },
|
||||
{ "newc", archive_write_set_format_cpio_newc },
|
||||
{ "odc", archive_write_set_format_cpio },
|
||||
{ "pax", archive_write_set_format_pax },
|
||||
{ "posix", archive_write_set_format_pax },
|
||||
{ "shar", archive_write_set_format_shar },
|
||||
|
||||
274
lib/libarchive/archive_write_set_format_cpio_newc.c
Normal file
274
lib/libarchive/archive_write_set_format_cpio_newc.c
Normal file
@ -0,0 +1,274 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* Copyright (c) 2006 Rudolf Marek SYSGO s.r.o.
|
||||
* 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$");
|
||||
|
||||
#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"
|
||||
|
||||
static ssize_t archive_write_newc_data(struct archive_write *,
|
||||
const void *buff, size_t s);
|
||||
static int archive_write_newc_finish(struct archive_write *);
|
||||
static int archive_write_newc_destroy(struct archive_write *);
|
||||
static int archive_write_newc_finish_entry(struct archive_write *);
|
||||
static int archive_write_newc_header(struct archive_write *,
|
||||
struct archive_entry *);
|
||||
static int format_hex(int64_t, void *, int);
|
||||
static int64_t format_hex_recursive(int64_t, char *, int);
|
||||
|
||||
struct cpio {
|
||||
uint64_t entry_bytes_remaining;
|
||||
int padding;
|
||||
};
|
||||
|
||||
struct cpio_header_newc {
|
||||
char c_magic[6];
|
||||
char c_ino[8];
|
||||
char c_mode[8];
|
||||
char c_uid[8];
|
||||
char c_gid[8];
|
||||
char c_nlink[8];
|
||||
char c_mtime[8];
|
||||
char c_filesize[8];
|
||||
char c_devmajor[8];
|
||||
char c_devminor[8];
|
||||
char c_rdevmajor[8];
|
||||
char c_rdevminor[8];
|
||||
char c_namesize[8];
|
||||
char c_checksum[8];
|
||||
};
|
||||
|
||||
/*
|
||||
* Set output format to 'cpio' format.
|
||||
*/
|
||||
int
|
||||
archive_write_set_format_cpio_newc(struct archive *_a)
|
||||
{
|
||||
struct archive_write *a = (struct archive_write *)_a;
|
||||
struct cpio *cpio;
|
||||
|
||||
/* If someone else was already registered, unregister them. */
|
||||
if (a->format_destroy != NULL)
|
||||
(a->format_destroy)(a);
|
||||
|
||||
cpio = (struct cpio *)malloc(sizeof(*cpio));
|
||||
if (cpio == NULL) {
|
||||
archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
|
||||
return (ARCHIVE_FATAL);
|
||||
}
|
||||
memset(cpio, 0, sizeof(*cpio));
|
||||
a->format_data = cpio;
|
||||
|
||||
a->pad_uncompressed = 1;
|
||||
a->format_write_header = archive_write_newc_header;
|
||||
a->format_write_data = archive_write_newc_data;
|
||||
a->format_finish_entry = archive_write_newc_finish_entry;
|
||||
a->format_finish = archive_write_newc_finish;
|
||||
a->format_destroy = archive_write_newc_destroy;
|
||||
a->archive_format = ARCHIVE_FORMAT_CPIO_SVR4_NOCRC;
|
||||
a->archive_format_name = "SVR4 cpio nocrc";
|
||||
return (ARCHIVE_OK);
|
||||
}
|
||||
|
||||
static int
|
||||
archive_write_newc_header(struct archive_write *a, struct archive_entry *entry)
|
||||
{
|
||||
struct cpio *cpio;
|
||||
const char *p, *path;
|
||||
int pathlength, ret;
|
||||
struct cpio_header_newc h;
|
||||
int pad;
|
||||
|
||||
cpio = (struct cpio *)a->format_data;
|
||||
ret = 0;
|
||||
|
||||
path = archive_entry_pathname(entry);
|
||||
pathlength = strlen(path) + 1; /* Include trailing null. */
|
||||
|
||||
memset(&h, 0, sizeof(h));
|
||||
format_hex(0x070701, &h.c_magic, sizeof(h.c_magic));
|
||||
format_hex(archive_entry_devmajor(entry), &h.c_devmajor, sizeof(h.c_devmajor));
|
||||
format_hex(archive_entry_devminor(entry), &h.c_devminor, sizeof(h.c_devminor));
|
||||
if (archive_entry_ino(entry) > 0xffffffff) {
|
||||
archive_set_error(&a->archive, ERANGE, "large inode number truncated");
|
||||
ret = ARCHIVE_WARN;
|
||||
}
|
||||
|
||||
format_hex(archive_entry_ino(entry) & 0xffffffff, &h.c_ino, sizeof(h.c_ino));
|
||||
format_hex(archive_entry_mode(entry), &h.c_mode, sizeof(h.c_mode));
|
||||
format_hex(archive_entry_uid(entry), &h.c_uid, sizeof(h.c_uid));
|
||||
format_hex(archive_entry_gid(entry), &h.c_gid, sizeof(h.c_gid));
|
||||
format_hex(archive_entry_nlink(entry), &h.c_nlink, sizeof(h.c_nlink));
|
||||
if (archive_entry_filetype(entry) == AE_IFBLK
|
||||
|| archive_entry_filetype(entry) == AE_IFCHR) {
|
||||
format_hex(archive_entry_rdevmajor(entry), &h.c_rdevmajor, sizeof(h.c_rdevmajor));
|
||||
format_hex(archive_entry_rdevminor(entry), &h.c_rdevminor, sizeof(h.c_rdevminor));
|
||||
} else {
|
||||
format_hex(0, &h.c_rdevmajor, sizeof(h.c_rdevmajor));
|
||||
format_hex(0, &h.c_rdevminor, sizeof(h.c_rdevminor));
|
||||
}
|
||||
format_hex(archive_entry_mtime(entry), &h.c_mtime, sizeof(h.c_mtime));
|
||||
format_hex(pathlength, &h.c_namesize, sizeof(h.c_namesize));
|
||||
format_hex(0, &h.c_checksum, sizeof(h.c_checksum));
|
||||
|
||||
/* Symlinks get the link written as the body of the entry. */
|
||||
p = archive_entry_symlink(entry);
|
||||
if (p != NULL && *p != '\0')
|
||||
format_hex(strlen(p), &h.c_filesize, sizeof(h.c_filesize));
|
||||
else
|
||||
format_hex(archive_entry_size(entry), &h.c_filesize, sizeof(h.c_filesize));
|
||||
|
||||
ret = (a->compressor.write)(a, &h, sizeof(h));
|
||||
if (ret != ARCHIVE_OK)
|
||||
return (ARCHIVE_FATAL);
|
||||
|
||||
/* Pad pathname to even length. */
|
||||
ret = (a->compressor.write)(a, path, pathlength);
|
||||
if (ret != ARCHIVE_OK)
|
||||
return (ARCHIVE_FATAL);
|
||||
pad = 0x3 & - (pathlength + sizeof(struct cpio_header_newc));
|
||||
if (pad)
|
||||
ret = (a->compressor.write)(a, "\0\0\0", pad);
|
||||
if (ret != ARCHIVE_OK)
|
||||
return (ARCHIVE_FATAL);
|
||||
|
||||
cpio->entry_bytes_remaining = archive_entry_size(entry);
|
||||
cpio->padding = 3 & (-cpio->entry_bytes_remaining);
|
||||
/* Write the symlink now. */
|
||||
if (p != NULL && *p != '\0')
|
||||
ret = (a->compressor.write)(a, p, strlen(p));
|
||||
|
||||
return (ret);
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
archive_write_newc_data(struct archive_write *a, const void *buff, size_t s)
|
||||
{
|
||||
struct cpio *cpio;
|
||||
int ret;
|
||||
|
||||
cpio = (struct cpio *)a->format_data;
|
||||
if (s > cpio->entry_bytes_remaining)
|
||||
s = cpio->entry_bytes_remaining;
|
||||
|
||||
ret = (a->compressor.write)(a, buff, s);
|
||||
cpio->entry_bytes_remaining -= s;
|
||||
if (ret >= 0)
|
||||
return (s);
|
||||
else
|
||||
return (ret);
|
||||
}
|
||||
|
||||
/*
|
||||
* Format a number into the specified field.
|
||||
*/
|
||||
static int
|
||||
format_hex(int64_t v, void *p, int digits)
|
||||
{
|
||||
int64_t max;
|
||||
int ret;
|
||||
|
||||
max = (((int64_t)1) << (digits * 4)) - 1;
|
||||
if (v >= 0 && v <= max) {
|
||||
format_hex_recursive(v, (char *)p, digits);
|
||||
ret = 0;
|
||||
} else {
|
||||
format_hex_recursive(max, (char *)p, digits);
|
||||
ret = -1;
|
||||
}
|
||||
return (ret);
|
||||
}
|
||||
|
||||
static int64_t
|
||||
format_hex_recursive(int64_t v, char *p, int s)
|
||||
{
|
||||
if (s == 0)
|
||||
return (v);
|
||||
v = format_hex_recursive(v, p+1, s-1);
|
||||
*p = "0123456789abcdef"[v & 0xf];
|
||||
return (v >>= 4);
|
||||
}
|
||||
|
||||
static int
|
||||
archive_write_newc_finish(struct archive_write *a)
|
||||
{
|
||||
struct cpio *cpio;
|
||||
int er;
|
||||
struct archive_entry *trailer;
|
||||
|
||||
cpio = (struct cpio *)a->format_data;
|
||||
trailer = archive_entry_new();
|
||||
archive_entry_set_nlink(trailer, 1);
|
||||
archive_entry_set_pathname(trailer, "TRAILER!!!");
|
||||
er = archive_write_newc_header(a, trailer);
|
||||
archive_entry_free(trailer);
|
||||
return (er);
|
||||
}
|
||||
|
||||
static int
|
||||
archive_write_newc_destroy(struct archive_write *a)
|
||||
{
|
||||
struct cpio *cpio;
|
||||
|
||||
cpio = (struct cpio *)a->format_data;
|
||||
free(cpio);
|
||||
a->format_data = NULL;
|
||||
return (ARCHIVE_OK);
|
||||
}
|
||||
|
||||
static int
|
||||
archive_write_newc_finish_entry(struct archive_write *a)
|
||||
{
|
||||
struct cpio *cpio;
|
||||
int to_write, ret;
|
||||
|
||||
cpio = (struct cpio *)a->format_data;
|
||||
ret = ARCHIVE_OK;
|
||||
while (cpio->entry_bytes_remaining > 0) {
|
||||
to_write = cpio->entry_bytes_remaining < a->null_length ?
|
||||
cpio->entry_bytes_remaining : a->null_length;
|
||||
ret = (a->compressor.write)(a, a->nulls, to_write);
|
||||
if (ret != ARCHIVE_OK)
|
||||
return (ret);
|
||||
cpio->entry_bytes_remaining -= to_write;
|
||||
}
|
||||
ret = (a->compressor.write)(a, a->nulls, cpio->padding);
|
||||
return (ret);
|
||||
}
|
||||
@ -30,6 +30,7 @@ TESTS= \
|
||||
test_read_format_zip.c \
|
||||
test_read_large.c \
|
||||
test_read_position.c \
|
||||
test_read_pax_truncated.c \
|
||||
test_read_truncated.c \
|
||||
test_tar_filenames.c \
|
||||
test_write_compress_program.c \
|
||||
@ -37,6 +38,7 @@ TESTS= \
|
||||
test_write_disk_perms.c \
|
||||
test_write_disk_secure.c \
|
||||
test_write_format_ar.c \
|
||||
test_write_format_cpio.c \
|
||||
test_write_format_cpio_empty.c \
|
||||
test_write_format_shar_empty.c \
|
||||
test_write_format_tar.c \
|
||||
|
||||
112
lib/libarchive/test/test_write_format_cpio.c
Normal file
112
lib/libarchive/test/test_write_format_cpio.c
Normal file
@ -0,0 +1,112 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* 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 "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
static void
|
||||
test_format(int (*set_format)(struct archive *))
|
||||
{
|
||||
char filedata[64];
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
char *p;
|
||||
size_t used;
|
||||
size_t buffsize = 1000000;
|
||||
char *buff;
|
||||
|
||||
buff = malloc(buffsize);
|
||||
|
||||
/* Create a new archive in memory. */
|
||||
assert((a = archive_write_new()) != NULL);
|
||||
assertA(0 == (*set_format)(a));
|
||||
assertA(0 == archive_write_set_compression_none(a));
|
||||
assertA(0 == archive_write_open_memory(a, buff, buffsize, &used));
|
||||
|
||||
/*
|
||||
* Write a file to it.
|
||||
*/
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_set_mtime(ae, 1, 10);
|
||||
assert(1 == archive_entry_mtime(ae));
|
||||
assert(10 == archive_entry_mtime_nsec(ae));
|
||||
p = strdup("file");
|
||||
archive_entry_copy_pathname(ae, p);
|
||||
strcpy(p, "XXXX");
|
||||
free(p);
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
archive_entry_set_mode(ae, S_IFREG | 0755);
|
||||
assert((S_IFREG | 0755) == archive_entry_mode(ae));
|
||||
archive_entry_set_size(ae, 8);
|
||||
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
assertA(8 == archive_write_data(a, "12345678", 9));
|
||||
|
||||
/* Close out the archive. */
|
||||
assertA(0 == archive_write_close(a));
|
||||
#if ARCHIVE_API_VERSION > 1
|
||||
assertA(0 == archive_write_finish(a));
|
||||
#else
|
||||
archive_write_finish(a);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Now, read the data back.
|
||||
*/
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertA(0 == archive_read_support_format_all(a));
|
||||
assertA(0 == archive_read_support_compression_all(a));
|
||||
assertA(0 == archive_read_open_memory(a, buff, used));
|
||||
|
||||
assertA(0 == archive_read_next_header(a, &ae));
|
||||
|
||||
assert(1 == archive_entry_mtime(ae));
|
||||
/* Not the same as above: cpio doesn't store hi-res times. */
|
||||
assert(0 == archive_entry_mtime_nsec(ae));
|
||||
assert(0 == archive_entry_atime(ae));
|
||||
assert(0 == archive_entry_ctime(ae));
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
assert((S_IFREG | 0755) == archive_entry_mode(ae));
|
||||
assert(8 == archive_entry_size(ae));
|
||||
assertA(8 == archive_read_data(a, filedata, 10));
|
||||
assert(0 == memcmp(filedata, "12345678", 8));
|
||||
|
||||
/* Verify the end of the archive. */
|
||||
assert(1 == archive_read_next_header(a, &ae));
|
||||
assert(0 == archive_read_close(a));
|
||||
#if ARCHIVE_API_VERSION > 1
|
||||
assert(0 == archive_read_finish(a));
|
||||
#else
|
||||
archive_read_finish(a);
|
||||
#endif
|
||||
|
||||
free(buff);
|
||||
}
|
||||
|
||||
DEFINE_TEST(test_write_format_cpio)
|
||||
{
|
||||
test_format(archive_write_set_format_cpio);
|
||||
test_format(archive_write_set_format_cpio_newc);
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user