#include "archive_platform.h"
__FBSDID("$FreeBSD: src/lib/libarchive/archive_read.c,v 1.39 2008/12/06 06:45:15 kientzle Exp $");
#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
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include "archive.h"
#include "archive_entry.h"
#include "archive_private.h"
#include "archive_read_private.h"
#define minimum(a, b) (a < b ? a : b)
static int build_stream(struct archive_read *);
static int choose_format(struct archive_read *);
struct archive *
archive_read_new(void)
{
struct archive_read *a;
a = (struct archive_read *)malloc(sizeof(*a));
if (a == NULL)
return (NULL);
memset(a, 0, sizeof(*a));
a->archive.magic = ARCHIVE_READ_MAGIC;
a->archive.state = ARCHIVE_STATE_NEW;
a->entry = archive_entry_new();
a->buffer_size = 64 * 1024;
a->buffer = (char *)malloc(a->buffer_size);
a->next = a->buffer;
if (a->buffer == NULL) {
archive_entry_free(a->entry);
free(a);
return (NULL);
}
return (&a->archive);
}
void
archive_read_extract_set_skip_file(struct archive *_a, dev_t d, ino_t i)
{
struct archive_read *a = (struct archive_read *)_a;
__archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_ANY,
"archive_read_extract_set_skip_file");
a->skip_file_dev = d;
a->skip_file_ino = i;
}
int
archive_read_open(struct archive *a, void *client_data,
archive_open_callback *client_opener, archive_read_callback *client_reader,
archive_close_callback *client_closer)
{
return archive_read_open2(a, client_data, client_opener,
client_reader, NULL, client_closer);
}
static ssize_t
client_read_proxy(struct archive_read_source *self, const void **buff)
{
return (self->archive->client.reader)((struct archive *)self->archive,
self->data, buff);
}
static int64_t
client_skip_proxy(struct archive_read_source *self, int64_t request)
{
if (self->archive->client.skipper == NULL)
return (0);
return (self->archive->client.skipper)((struct archive *)self->archive,
self->data, request);
}
static int
client_close_proxy(struct archive_read_source *self)
{
int r = ARCHIVE_OK;
if (self->archive->client.closer != NULL)
r = (self->archive->client.closer)((struct archive *)self->archive,
self->data);
free(self);
return (r);
}
int
archive_read_open2(struct archive *_a, void *client_data,
archive_open_callback *client_opener,
archive_read_callback *client_reader,
archive_skip_callback *client_skipper,
archive_close_callback *client_closer)
{
struct archive_read *a = (struct archive_read *)_a;
int e;
__archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
"archive_read_open");
if (client_reader == NULL)
__archive_errx(1,
"No reader function provided to archive_read_open");
if (client_opener != NULL) {
e =(client_opener)(&a->archive, client_data);
if (e != 0) {
if (client_closer)
(client_closer)(&a->archive, client_data);
return (e);
}
}
a->client.opener = client_opener;
a->client.reader = client_reader;
a->client.skipper = client_skipper;
a->client.closer = client_closer;
a->client.data = client_data;
{
struct archive_read_source *source;
source = calloc(1, sizeof(*source));
if (source == NULL)
return (ARCHIVE_FATAL);
source->reader = NULL;
source->upstream = NULL;
source->archive = a;
source->data = client_data;
source->read = client_read_proxy;
source->skip = client_skip_proxy;
source->close = client_close_proxy;
a->source = source;
}
a->archive.compression_code = ARCHIVE_COMPRESSION_NONE;
a->archive.compression_name = "none";
e = build_stream(a);
if (e == ARCHIVE_OK)
a->archive.state = ARCHIVE_STATE_HEADER;
return (e);
}
static int
build_stream(struct archive_read *a)
{
int number_readers, i, bid, best_bid;
struct archive_reader *reader, *best_reader;
struct archive_read_source *source;
const void *block;
ssize_t bytes_read;
bytes_read = (a->source->read)(a->source, &block);
if (bytes_read < 0) {
if (a->source->close != NULL) {
(a->source->close)(a->source);
a->source = NULL;
}
return (ARCHIVE_FATAL);
}
number_readers = sizeof(a->readers) / sizeof(a->readers[0]);
best_bid = 0;
best_reader = NULL;
reader = a->readers;
for (i = 0, reader = a->readers; i < number_readers; i++, reader++) {
if (reader->bid != NULL) {
bid = (reader->bid)(reader, block, bytes_read);
if (bid > best_bid) {
best_bid = bid;
best_reader = reader;
}
}
}
if (best_reader != NULL) {
source = (best_reader->init)(a, best_reader, a->source,
block, bytes_read);
if (source == NULL)
return (ARCHIVE_FATAL);
a->source = source;
return (build_stream(a));
}
a->client_buff = block;
a->client_total = bytes_read;
a->client_next = a->client_buff;
a->client_avail = a->client_total;
return (ARCHIVE_OK);
}
int
archive_read_next_header(struct archive *_a, struct archive_entry **entryp)
{
struct archive_read *a = (struct archive_read *)_a;
struct archive_entry *entry;
int slot, ret;
__archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_read_next_header");
*entryp = NULL;
entry = a->entry;
archive_entry_clear(entry);
archive_clear_error(&a->archive);
if (a->format == NULL) {
slot = choose_format(a);
if (slot < 0) {
a->archive.state = ARCHIVE_STATE_FATAL;
return (ARCHIVE_FATAL);
}
a->format = &(a->formats[slot]);
}
if (a->archive.state == ARCHIVE_STATE_DATA) {
ret = archive_read_data_skip(&a->archive);
if (ret == ARCHIVE_EOF) {
archive_set_error(&a->archive, EIO, "Premature end-of-file.");
a->archive.state = ARCHIVE_STATE_FATAL;
return (ARCHIVE_FATAL);
}
if (ret != ARCHIVE_OK)
return (ret);
}
a->header_position = a->archive.file_position;
ret = (a->format->read_header)(a, entry);
switch (ret) {
case ARCHIVE_EOF:
a->archive.state = ARCHIVE_STATE_EOF;
break;
case ARCHIVE_OK:
a->archive.state = ARCHIVE_STATE_DATA;
break;
case ARCHIVE_WARN:
a->archive.state = ARCHIVE_STATE_DATA;
break;
case ARCHIVE_RETRY:
break;
case ARCHIVE_FATAL:
a->archive.state = ARCHIVE_STATE_FATAL;
break;
}
*entryp = entry;
a->read_data_output_offset = 0;
a->read_data_remaining = 0;
return (ret);
}
static int
choose_format(struct archive_read *a)
{
int slots;
int i;
int bid, best_bid;
int best_bid_slot;
slots = sizeof(a->formats) / sizeof(a->formats[0]);
best_bid = -1;
best_bid_slot = -1;
a->format = &(a->formats[0]);
for (i = 0; i < slots; i++, a->format++) {
if (a->format->bid) {
bid = (a->format->bid)(a);
if (bid == ARCHIVE_FATAL)
return (ARCHIVE_FATAL);
if ((bid > best_bid) || (best_bid_slot < 0)) {
best_bid = bid;
best_bid_slot = i;
}
}
}
if (best_bid_slot < 0)
__archive_errx(1, "No formats were registered; you must "
"invoke at least one archive_read_support_format_XXX "
"function in order to successfully read an archive.");
if (best_bid < 1) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Unrecognized archive format");
return (ARCHIVE_FATAL);
}
return (best_bid_slot);
}
int64_t
archive_read_header_position(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
__archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_ANY, "archive_read_header_position");
return (a->header_position);
}
ssize_t
archive_read_data(struct archive *_a, void *buff, size_t s)
{
struct archive_read *a = (struct archive_read *)_a;
char *dest;
const void *read_buf;
size_t bytes_read;
size_t len;
int r;
bytes_read = 0;
dest = (char *)buff;
while (s > 0) {
if (a->read_data_remaining == 0) {
read_buf = a->read_data_block;
r = archive_read_data_block(&a->archive, &read_buf,
&a->read_data_remaining, &a->read_data_offset);
a->read_data_block = read_buf;
if (r == ARCHIVE_EOF)
return (bytes_read);
if (r < ARCHIVE_OK)
return (r);
}
if (a->read_data_offset < a->read_data_output_offset) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Encountered out-of-order sparse blocks");
return (ARCHIVE_RETRY);
}
if (a->read_data_output_offset + (off_t)s <
a->read_data_offset) {
len = s;
} else if (a->read_data_output_offset <
a->read_data_offset) {
len = a->read_data_offset -
a->read_data_output_offset;
} else
len = 0;
memset(dest, 0, len);
s -= len;
a->read_data_output_offset += len;
dest += len;
bytes_read += len;
if (s > 0) {
len = a->read_data_remaining;
if (len > s)
len = s;
memcpy(dest, a->read_data_block, len);
s -= len;
a->read_data_block += len;
a->read_data_remaining -= len;
a->read_data_output_offset += len;
a->read_data_offset += len;
dest += len;
bytes_read += len;
}
}
return (bytes_read);
}
#if ARCHIVE_API_VERSION < 3
int
archive_read_data_into_buffer(struct archive *a, void *d, ssize_t len)
{
archive_read_data(a, d, len);
return (ARCHIVE_OK);
}
#endif
int
archive_read_data_skip(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
int r;
const void *buff;
size_t size;
off_t offset;
__archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
"archive_read_data_skip");
if (a->format->read_data_skip != NULL)
r = (a->format->read_data_skip)(a);
else {
while ((r = archive_read_data_block(&a->archive,
&buff, &size, &offset))
== ARCHIVE_OK)
;
}
if (r == ARCHIVE_EOF)
r = ARCHIVE_OK;
a->archive.state = ARCHIVE_STATE_HEADER;
return (r);
}
int
archive_read_data_block(struct archive *_a,
const void **buff, size_t *size, off_t *offset)
{
struct archive_read *a = (struct archive_read *)_a;
__archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
"archive_read_data_block");
if (a->format->read_data == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Internal error: "
"No format_read_data_block function registered");
return (ARCHIVE_FATAL);
}
return (a->format->read_data)(a, buff, size, offset);
}
int
archive_read_close(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
int r = ARCHIVE_OK, r1 = ARCHIVE_OK;
size_t i, n;
__archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_ANY, "archive_read_close");
a->archive.state = ARCHIVE_STATE_CLOSED;
if (a->cleanup_archive_extract != NULL)
r = (a->cleanup_archive_extract)(a);
while (a->source != NULL) {
struct archive_read_source *t = a->source->upstream;
r1 = (a->source->close)(a->source);
if (r1 < r)
r = r1;
a->source = t;
}
n = sizeof(a->readers)/sizeof(a->readers[0]);
for (i = 0; i < n; i++) {
if (a->readers[i].free != NULL) {
r1 = (a->readers[i].free)(&a->readers[i]);
if (r1 < r)
r = r1;
}
}
return (r);
}
#if ARCHIVE_API_VERSION > 1
int
#else
void
#endif
archive_read_finish(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
int i;
int slots;
int r = ARCHIVE_OK;
__archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_ANY,
"archive_read_finish");
if (a->archive.state != ARCHIVE_STATE_CLOSED)
r = archive_read_close(&a->archive);
slots = sizeof(a->formats) / sizeof(a->formats[0]);
for (i = 0; i < slots; i++) {
a->format = &(a->formats[i]);
if (a->formats[i].cleanup)
(a->formats[i].cleanup)(a);
}
archive_string_free(&a->archive.error_string);
if (a->entry)
archive_entry_free(a->entry);
a->archive.magic = 0;
free(a->buffer);
free(a);
#if ARCHIVE_API_VERSION > 1
return (r);
#endif
}
int
__archive_read_register_format(struct archive_read *a,
void *format_data,
int (*bid)(struct archive_read *),
int (*read_header)(struct archive_read *, struct archive_entry *),
int (*read_data)(struct archive_read *, const void **, size_t *, off_t *),
int (*read_data_skip)(struct archive_read *),
int (*cleanup)(struct archive_read *))
{
int i, number_slots;
__archive_check_magic(&a->archive,
ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
"__archive_read_register_format");
number_slots = sizeof(a->formats) / sizeof(a->formats[0]);
for (i = 0; i < number_slots; i++) {
if (a->formats[i].bid == bid)
return (ARCHIVE_WARN);
if (a->formats[i].bid == NULL) {
a->formats[i].bid = bid;
a->formats[i].read_header = read_header;
a->formats[i].read_data = read_data;
a->formats[i].read_data_skip = read_data_skip;
a->formats[i].cleanup = cleanup;
a->formats[i].data = format_data;
return (ARCHIVE_OK);
}
}
__archive_errx(1, "Not enough slots for format registration");
return (ARCHIVE_FATAL);
}
struct archive_reader *
__archive_read_get_reader(struct archive_read *a)
{
int i, number_slots;
__archive_check_magic(&a->archive,
ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
"__archive_read_get_reader");
number_slots = sizeof(a->readers) / sizeof(a->readers[0]);
for (i = 0; i < number_slots; i++) {
if (a->readers[i].bid == NULL)
return (a->readers + i);
}
__archive_errx(1, "Not enough slots for compression registration");
return (NULL);
}
const void *
__archive_read_ahead(struct archive_read *a, size_t min, ssize_t *avail)
{
ssize_t bytes_read;
size_t tocopy;
if (a->fatal) {
if (avail)
*avail = ARCHIVE_FATAL;
return (NULL);
}
for (;;) {
if (a->avail >= min) {
if (avail != NULL)
*avail = a->avail;
return (a->next);
}
if (a->client_total >= a->client_avail + a->avail
&& a->client_avail + a->avail >= min) {
a->client_avail += a->avail;
a->client_next -= a->avail;
a->avail = 0;
a->next = a->buffer;
if (avail != NULL)
*avail = a->client_avail;
return (a->client_next);
}
if (a->next > a->buffer &&
a->next + min > a->buffer + a->buffer_size) {
if (a->avail > 0)
memmove(a->buffer, a->next, a->avail);
a->next = a->buffer;
}
if (a->client_avail <= 0) {
if (a->end_of_file) {
if (avail != NULL)
*avail = 0;
return (NULL);
}
bytes_read = (a->source->read)(a->source,
&a->client_buff);
if (bytes_read < 0) {
a->client_total = a->client_avail = 0;
a->client_next = a->client_buff = NULL;
a->fatal = 1;
if (avail != NULL)
*avail = ARCHIVE_FATAL;
return (NULL);
}
if (bytes_read == 0) {
a->client_total = a->client_avail = 0;
a->client_next = a->client_buff = NULL;
a->end_of_file = 1;
if (avail != NULL)
*avail = a->avail;
return (NULL);
}
a->archive.raw_position += bytes_read;
a->client_total = bytes_read;
a->client_avail = a->client_total;
a->client_next = a->client_buff;
}
else
{
if (min > a->buffer_size) {
size_t s, t;
char *p;
s = t = a->buffer_size;
while (s < min) {
t *= 2;
if (t <= s) {
archive_set_error(&a->archive,
ENOMEM,
"Unable to allocate copy buffer");
a->fatal = 1;
if (avail != NULL)
*avail = ARCHIVE_FATAL;
return (NULL);
}
s = t;
}
p = (char *)malloc(s);
if (p == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Unable to allocate copy buffer");
a->fatal = 1;
if (avail != NULL)
*avail = ARCHIVE_FATAL;
return (NULL);
}
if (a->avail > 0)
memmove(p, a->next, a->avail);
free(a->buffer);
a->next = a->buffer = p;
a->buffer_size = s;
}
tocopy = (a->buffer + a->buffer_size)
- (a->next + a->avail);
if (tocopy + a->avail > min)
tocopy = min - a->avail;
if (tocopy > a->client_avail)
tocopy = a->client_avail;
memcpy(a->next + a->avail, a->client_next,
tocopy);
a->client_next += tocopy;
a->client_avail -= tocopy;
a->avail += tocopy;
}
}
}
ssize_t
__archive_read_consume(struct archive_read *a, size_t request)
{
if (a->avail > 0) {
a->next += request;
a->avail -= request;
} else {
a->client_next += request;
a->client_avail -= request;
}
a->archive.file_position += request;
return (request);
}
int64_t
__archive_read_skip(struct archive_read *a, int64_t request)
{
off_t bytes_skipped, total_bytes_skipped = 0;
size_t min;
if (a->fatal)
return (-1);
if (a->avail > 0) {
min = minimum(request, (off_t)a->avail);
bytes_skipped = __archive_read_consume(a, min);
request -= bytes_skipped;
total_bytes_skipped += bytes_skipped;
}
if (a->client_avail > 0) {
min = minimum(request, (off_t)a->client_avail);
bytes_skipped = __archive_read_consume(a, min);
request -= bytes_skipped;
total_bytes_skipped += bytes_skipped;
}
if (request == 0)
return (total_bytes_skipped);
#if ARCHIVE_API_VERSION < 2
if ((a->source->skip != NULL) && (request < SSIZE_MAX)) {
#else
if (a->source->skip != NULL) {
#endif
bytes_skipped = (a->source->skip)(a->source, request);
if (bytes_skipped < 0) {
a->client_total = a->client_avail = 0;
a->client_next = a->client_buff = NULL;
a->fatal = 1;
return (bytes_skipped);
}
total_bytes_skipped += bytes_skipped;
a->archive.file_position += bytes_skipped;
request -= bytes_skipped;
a->client_next = a->client_buff;
a->archive.raw_position += bytes_skipped;
a->client_avail = a->client_total = 0;
}
while (request > 0) {
const void* dummy_buffer;
ssize_t bytes_read;
dummy_buffer = __archive_read_ahead(a, 1, &bytes_read);
if (bytes_read < 0)
return (bytes_read);
if (bytes_read == 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Truncated input file (need to skip %jd bytes)",
(intmax_t)request);
return (ARCHIVE_FATAL);
}
min = (size_t)(minimum(bytes_read, request));
bytes_read = __archive_read_consume(a, min);
total_bytes_skipped += bytes_read;
request -= bytes_read;
}
return (total_bytes_skipped);
}