/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 2018 Olaf Wintermann. 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 "tar.h"
#include <string.h>
#include <cx/string.h>
#include <libidav/utils.h>
const char* tar_error2str(TarError error) {
switch(error) {
default: break;
case TAR_OK: return "ok";
case TAR_PATH_TOO_LONG: return "path too long";
case TAR_FILE_TOO_LARGE: return "file too large";
case TAR_CONTENT_TOO_LARGE: return "tar content too large";
case TAR_UNFINISHED_FILE: return "can''t read a tar header at this position";
case TAR_CONTENT_BROKEN: return "tar content broken";
}
return "error";
}
TarOutputStream* tar_open(FILE *f) {
TarOutputStream *tar = malloc(sizeof(TarOutputStream));
tar->file= f;
tar->cur_filesize = 0;
tar->cur_written = 0;
tar->error = 0;
return tar;
}
static int add_header(TarOutputStream *tar, char *path, uint32_t mode, uint64_t size, time_t mtime, int type) {
// split path in prefix and name and check length
char *p = util_parent_path(path);
const char *n = util_resource_name(path);
if(!p || !n) {
return -1;
}
cxstring prefix = cx_str(p);
cxstring name = cx_str(n);
if(prefix.ptr[prefix.length-1] == '/') {
prefix.length--;
}
if(prefix.length > 154) {
tar->error = TAR_PATH_TOO_LONG;
free(p);
return -1;
}
if(name.length > 99) {
tar->error = TAR_PATH_TOO_LONG;
free(p);
return -1;
}
// check file length
if(size >= 077777777777 ) {
tar->error = TAR_FILE_TOO_LARGE;
free(p);
return -1;
}
// set header fields
TarHeader h;
memset(&h, 0, sizeof(TarHeader));
// name
memcpy(h.name, name.ptr, name.length);
// mode
snprintf(h.mode, 8, "%07o", mode);
h.mode[7] = ' ';
// uid/gid
memset(h.uid, '0', 8);
h.uid[7] = ' ';
memset(h.gid, '0', 8);
h.gid[7] = ' ';
// size
snprintf(h.size, 12, "%011lo", (unsigned long)size);
h.size[11] = ' ';
// mtime
uint64_t t = (uint64_t)mtime;
snprintf(h.mtime, 12, "%011lo", mtime);
h.mtime[11] = ' ';
// chksum
memset(h.chksum, ' ', 8);
// typeflag
h.typeflag = type;
// linkname - zeros
// magic
snprintf(h.magic, 6, "ustar");
// version
h.version[0] = '0';
h.version[1] = '0';
// uname/gname - zero
// devmajor/devminor
char *devbuf = (char*)h.devmajor;
snprintf(devbuf, 16, "%015o", 0);
h.devmajor[7] = ' ';
h.devminor[7] = ' ';
// prefix
memcpy(h.prefix, prefix.ptr, prefix.length);
// compute checksum
uint8_t *header = (uint8_t*)&h;
uint32_t chksum = 0;
for(int i=0;i<512;i++) {
chksum += header[i];
}
snprintf(h.chksum, 8, "%07o", chksum);
fwrite(&h, 1, 512, tar->file);
free(p);
return 0;
}
int tar_add_dir(TarOutputStream *tar, char *path, uint32_t mode, time_t mtime) {
return add_header(tar, path, mode, 0, mtime, TAR_TYPE_DIRECTORY);
}
int tar_begin_file(
TarOutputStream *tar,
char *path,
uint32_t mode,
uint64_t size,
time_t mtime)
{
if(add_header(tar, path, mode, size, mtime, TAR_TYPE_FILE)) {
return -1;
}
tar->cur_filesize = size;
tar->cur_written = 0;
return 0;
}
size_t tar_fwrite(const void *ptr, size_t s, size_t n, TarOutputStream *stream) {
size_t w = fwrite(ptr, s, n, stream->file);
stream->cur_written += w;
if(stream->cur_written > stream->cur_filesize) {
stream->error = TAR_CONTENT_TOO_LARGE;
return 0;
}
return w;
}
int tar_end_file(TarOutputStream *tar) {
size_t pad = 512 - tar->cur_written % 512;
char buf[512];
memset(buf, 0, 512);
fwrite(buf, 1, pad, tar->file);
tar->cur_filesize = 0;
tar->cur_written = 0;
return 0;
}
int tar_close(TarOutputStream *tar) {
char buf[512];
memset(buf, 0, 512);
fwrite(buf, 1, 512, tar->file);
return 0;
}
TarInputStream* tar_inputstream_open(FILE *f) {
TarInputStream *tar = malloc(sizeof(TarInputStream));
memset(tar, 0, sizeof(TarInputStream));
tar->file = f;
return tar;
}
TarEntry* tar_read_entry(TarInputStream *tar) {
if(tar->cur_read < tar->cur_entry.size) {
tar->error = TAR_UNFINISHED_FILE;
return NULL;
}
TarHeader h;
memset(&h, 0, sizeof(TarHeader));
if(fread(&h, 1, 512, tar->file) != 512) {
tar->error = TAR_ERROR;
return NULL;
}
// some checks
tar->error = TAR_CONTENT_BROKEN; // set error for all following returns
char *buf = (char*)&h;
uint64_t chksum = 0;
int chksumfield = 8 * 32;
for(int i=0;i<148;i++) {
chksum += buf[i];
}
chksum += chksumfield;
for(int i=156;i<512;i++) {
chksum += buf[i];
}
if(chksum != chksumfield) {
long long int cks = strtoll(h.chksum, NULL, 8);
if(cks != chksum) {
return NULL;
}
}
if(memcmp(h.magic, "ustar\0", 6)) {
if(!memcmp(h.magic, "\0\0\0\0", 4)) {
tar->error = TAR_OK;
}
return NULL;
}
if(memcmp(h.version, "00", 2)) {
return NULL;
}
// check if name and prefix are null terminated
int nameterm = 0;
int prefixterm = 0;
for(int i=0;i<100;i++) {
if(h.name[i] == 0) {
nameterm = 1;
break;
}
}
for(int i=0;i<155;i++) {
if(h.prefix[i] == 0) {
prefixterm = 1;
break;
}
}
if(!nameterm || !prefixterm) {
return NULL;
}
// get size
if(!(h.size[11] == ' ' || h.size[11] == 0)) {
return NULL;
}
long long int size = strtoll(h.size, NULL, 8);
if(size < 0) {
return NULL;
}
if(h.name[0] == 0) {
return NULL;
}
// get path
char *path = h.prefix[0] != 0 ? util_concat_path(h.prefix, h.name) : strdup(h.name);
if(tar->cur_entry.path) {
free(tar->cur_entry.path);
}
tar->cur_entry.path = path;
tar->cur_entry.size = (uint64_t)size;
tar->cur_entry.type = h.typeflag;
tar->cur_read = 0;
tar->error = TAR_OK;
return &tar->cur_entry;
}
size_t tar_fread(void *ptr, size_t s, size_t n, TarInputStream *stream) {
size_t bufsize = s*n;
size_t available = stream->cur_entry.size - stream->cur_read;
size_t nb = available > bufsize ? bufsize : available;
if(nb == 0) {
return 0;
}
size_t r = fread(ptr, 1, nb, stream->file);
if(r != nb) {
stream->error = TAR_ERROR;
return 0;
}
stream->cur_read += r;
if(stream->cur_read >= stream->cur_entry.size) {
// read padding
size_t pad = 512 - stream->cur_read % 512;
char buf[512];
if(fread(buf, 1, pad, stream->file) != pad) {
stream->error = TAR_ERROR;
return 0;
}
}
return r;
}
int tar_seek(TarInputStream *stream, long offset, int whence) {
return fseek(stream->file, offset, whence);
}
int tar_inputstream_close(TarInputStream *tar) {
if(tar->cur_entry.path) {
free(tar->cur_entry.path);
}
free(tar);
return 0;
}