int32_t xar_hash_fromheap_out(xar_t x, xar_file_t f, xar_prop_t p, void *in, size_t inlen, void **context) {
const char *opt;
xar_prop_t tmpp;
opt = NULL;
tmpp = xar_prop_pget(p, "extracted-checksum");
if( tmpp ) {
opt = xar_attr_pget(f, tmpp, "style");
} else {
// The xar-1.7 release in OS X Yosemite accidentally wrote <unarchived-checksum>
// instead of <extracted-checksum>. Since archives like this are now in the wild,
// we check for both.
tmpp = xar_prop_pget(p, "unarchived-checksum");
if( tmpp ) {
opt = xar_attr_pget(f, tmpp, "style");
}
}
// If there's an <archived-checksum> and no <extracted-checksum> (or
// <unarchived-checksum>), the archive is malformed.
if ( !opt && xar_prop_pget(p, "archived-checksum") ) {
xar_err_new(x);
xar_err_set_string(x, "No extracted-checksum");
xar_err_callback(x, XAR_SEVERITY_FATAL, XAR_ERR_ARCHIVE_EXTRACTION);
return -1;
}
if( !opt )
opt = xar_opt_get(x, XAR_OPT_FILECKSUM);
if( !opt || (0 == strcmp(opt, XAR_OPT_VAL_NONE) ) )
return 0;
if(!CONTEXT(context)) {
*context = calloc(1, sizeof(struct _hash_context));
if( ! *context )
return -1;
}
if( ! CONTEXT(context)->unarchived ) {
CONTEXT(context)->unarchived = xar_hash_new(opt, NULL);
if( ! CONTEXT(context)->unarchived ) {
free(*context);
*context = NULL;
return -1;
}
}
if( inlen == 0 )
return 0;
CONTEXT(context)->count += inlen;
xar_hash_update(CONTEXT(context)->unarchived, in, inlen);
return 0;
}
size_t xar_io_get_rsize(xar_t x) {
ssize_t bsize;
const char *opt = NULL;
opt = xar_opt_get(x, "rsize");
if( !opt ) {
bsize = 4096;
} else {
bsize = strtol(opt, NULL, 0);
if( ((bsize == LONG_MAX) || (bsize == LONG_MIN)) && (errno == ERANGE) ) {
bsize = 4096;
} else if( bsize <= 0 ) {
bsize = 4096;
}
}
return bsize;
}
/* xar_heap_to_archive
* x: archive to operate on
* Returns 0 on success, -1 on error
* Summary: copies the heap into the archive.
*/
int32_t xar_heap_to_archive(xar_t x) {
long bsize;
ssize_t r;
int off;
const char *opt;
char *b;
opt = xar_opt_get(x, "rsize");
if( !opt ) {
bsize = 4096;
} else {
bsize = strtol(opt, NULL, 0);
if( ((bsize == LONG_MAX) || (bsize == LONG_MIN)) && (errno == ERANGE) ) {
bsize = 4096;
}
}
b = malloc(bsize);
if( !b ) return -1;
lseek(XAR(x)->heap_fd, 0, SEEK_SET);
while(1) {
r = read(XAR(x)->heap_fd, b, bsize);
if( r == 0 ) break;
if( (r < 0) && (errno == EINTR) ) continue;
if( r < 0 ) {
free(b);
return -1;
}
off = 0;
do {
r = write(XAR(x)->fd, b+off, bsize-off);
if( (r < 0) && (errno != EINTR) ) {
free(b);
return -1;
}
off += r;
} while( off < bsize );
}
free(b);
return 0;
}
int32_t xar_hash_toheap_out(xar_t x, xar_file_t f, xar_prop_t p, void *in, size_t inlen, void **context) {
const char *opt;
xar_prop_t tmpp;
opt = NULL;
tmpp = xar_prop_pget(p, "archived-checksum");
if( tmpp )
opt = xar_attr_pget(f, tmpp, "style");
if( !opt )
opt = xar_opt_get(x, XAR_OPT_FILECKSUM);
if( !opt || (0 == strcmp(opt, XAR_OPT_VAL_NONE) ) )
return 0;
if( ! CONTEXT(context) ) {
*context = calloc(1, sizeof(struct _hash_context));
if( ! *context )
return -1;
}
if( ! CONTEXT(context)->archived ) {
CONTEXT(context)->archived = xar_hash_new(opt, NULL);
if( ! CONTEXT(context)->archived ) {
free(*context);
*context = NULL;
return -1;
}
}
if( inlen == 0 )
return 0;
CONTEXT(context)->count += inlen;
xar_hash_update(CONTEXT(context)->archived, in, inlen);
return 0;
}
/* xar_attrcopy_from_heap_to_heap
* This does a simple copy of the heap data from one head (read-only) to another heap (write only).
* This does not set any properties or attributes of the file, so this should not be used alone.
*/
int32_t xar_attrcopy_from_heap_to_heap(xar_t xsource, xar_file_t fsource, xar_prop_t p, xar_t xdest, xar_file_t fdest){
int r, off;
size_t bsize;
int64_t fsize, inc = 0, seekoff, writesize=0;
off_t orig_heap_offset = XAR(xdest)->heap_offset;
void *inbuf;
const char *opt;
char *tmpstr = NULL;
xar_prop_t tmpp;
opt = xar_opt_get(xsource, "rsize");
if( !opt ) {
bsize = 4096;
} else {
bsize = strtol(opt, NULL, 0);
if( ((bsize == LONG_MAX) || (bsize == LONG_MIN)) && (errno == ERANGE) ) {
bsize = 4096;
}
}
tmpp = xar_prop_pget(p, "offset");
if( tmpp )
opt = xar_prop_getvalue(tmpp);
seekoff = strtoll(opt, NULL, 0);
if( ((seekoff == LLONG_MAX) || (seekoff == LLONG_MIN)) && (errno == ERANGE) ) {
return -1;
}
seekoff += XAR(xsource)->toc_count + sizeof(xar_header_t);
if( XAR(xsource)->fd > 1 ) {
r = lseek(XAR(xsource)->fd, seekoff, SEEK_SET);
if( r == -1 ) {
if( errno == ESPIPE ) {
ssize_t rr;
char *buf;
unsigned int len;
len = seekoff - XAR(xsource)->toc_count;
len -= sizeof(xar_header_t);
if( XAR(xsource)->heap_offset > len ) {
xar_err_new(xsource);
xar_err_set_file(xsource, fsource);
xar_err_set_string(xsource, "Unable to seek");
xar_err_callback(xsource, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
} else {
len -= XAR(xsource)->heap_offset;
buf = malloc(len);
assert(buf);
rr = read(XAR(xsource)->fd, buf, len);
if( rr < len ) {
xar_err_new(xsource);
xar_err_set_file(xsource, fsource);
xar_err_set_string(xsource, "Unable to seek");
xar_err_callback(xsource, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
}
free(buf);
}
} else {
xar_err_new(xsource);
xar_err_set_file(xsource, fsource);
xar_err_set_string(xsource, "Unable to seek");
xar_err_callback(xsource, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
}
}
}
opt = NULL;
tmpp = xar_prop_pget(p, "length");
if( tmpp )
opt = xar_prop_getvalue(tmpp);
if( !opt ) {
return 0;
} else {
fsize = strtoll(opt, NULL, 10);
if( ((fsize == LLONG_MAX) || (fsize == LLONG_MIN)) && (errno == ERANGE) ) {
return -1;
}
}
inbuf = malloc(bsize);
if( !inbuf ) {
return -1;
}
while(1) {
/* Size has been reached */
if( fsize == inc )
break;
if( (fsize - inc) < bsize )
bsize = fsize - inc;
r = read(XAR(xsource)->fd, inbuf, bsize);
if( r == 0 )
break;
if( (r < 0) && (errno == EINTR) )
continue;
if( r < 0 ) {
free(inbuf);
return -1;
}
XAR(xsource)->heap_offset += r;
inc += r;
bsize = r;
off = 0;
do {
r = write(XAR(xdest)->heap_fd, inbuf+off, r-off );
off += r;
writesize += r;
} while( off < r );
XAR(xdest)->heap_offset += off;
XAR(xdest)->heap_len += off;
}
asprintf(&tmpstr, "%"PRIu64, (uint64_t)orig_heap_offset);
opt = xar_prop_getkey(p);
tmpp = xar_prop_pfirst(fdest);
if( tmpp )
tmpp = xar_prop_find(tmpp, opt);
if( tmpp )
xar_prop_pset(fdest, tmpp, "offset", tmpstr);
free(tmpstr);
free(inbuf);
/* It is the caller's responsibility to copy the attributes of the file, etc, this only copies the data in the heap */
return 0;
}
/* xar_copy_from_heap
* This is the arcmod extraction entry point for extracting the file's
* data from the heap file.
* It is assumed the heap_fd is already positioned appropriately.
*/
int32_t xar_attrcopy_from_heap(xar_t x, xar_file_t f, xar_prop_t p, write_callback wcb, void *context) {
int modulecount = (sizeof(xar_datamods)/sizeof(struct datamod));
void *modulecontext[modulecount];
int r, i;
size_t bsize, def_bsize;
int64_t fsize, inc = 0, seekoff;
void *inbuf;
const char *opt;
xar_prop_t tmpp;
memset(modulecontext, 0, sizeof(void*)*modulecount);
opt = xar_opt_get(x, "rsize");
if( !opt ) {
def_bsize = 4096;
} else {
def_bsize = strtol(opt, NULL, 0);
if( ((def_bsize == LONG_MAX) || (def_bsize == LONG_MIN)) && (errno == ERANGE) ) {
def_bsize = 4096;
}
}
opt = NULL;
tmpp = xar_prop_pget(p, "offset");
if( tmpp )
opt = xar_prop_getvalue(tmpp);
if( !opt ) {
wcb(x, f, NULL, 0, context);
return 0;
} else {
seekoff = strtoll(opt, NULL, 0);
if( ((seekoff == LLONG_MAX) || (seekoff == LLONG_MIN)) && (errno == ERANGE) ) {
return -1;
}
}
seekoff += XAR(x)->toc_count + sizeof(xar_header_t);
if( XAR(x)->fd > 1 ) {
r = lseek(XAR(x)->fd, seekoff, SEEK_SET);
if( r == -1 ) {
if( errno == ESPIPE ) {
ssize_t rr;
char *buf;
unsigned int len;
len = seekoff - XAR(x)->toc_count;
len -= sizeof(xar_header_t);
if( XAR(x)->heap_offset > len ) {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "Unable to seek");
xar_err_callback(x, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
} else {
len -= XAR(x)->heap_offset;
buf = malloc(len);
assert(buf);
rr = read(XAR(x)->fd, buf, len);
if( rr < len ) {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "Unable to seek");
xar_err_callback(x, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
}
free(buf);
}
} else {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "Unable to seek");
xar_err_callback(x, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
}
}
}
opt = NULL;
tmpp = xar_prop_pget(p, "length");
if( tmpp )
opt = xar_prop_getvalue(tmpp);
if( !opt ) {
return 0;
} else {
fsize = strtoll(opt, NULL, 10);
if( ((fsize == LLONG_MAX) || (fsize == LLONG_MIN)) && (errno == ERANGE) ) {
return -1;
}
}
bsize = def_bsize;
inbuf = malloc(bsize);
if( !inbuf ) {
return -1;
}
while(1) {
/* Size has been reached */
if( fsize == inc )
break;
if( (fsize - inc) < bsize )
bsize = fsize - inc;
r = read(XAR(x)->fd, inbuf, bsize);
if( r == 0 )
break;
if( (r < 0) && (errno == EINTR) )
continue;
if( r < 0 ) {
free(inbuf);
return -1;
}
XAR(x)->heap_offset += r;
inc += r;
bsize = r;
/* filter the data through the in modules */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].fh_in ) {
int32_t ret;
ret = xar_datamods[i].fh_in(x, f, p, &inbuf, &bsize, &(modulecontext[i]));
if( ret < 0 )
return -1;
}
}
/* Only due the write phase, if there is a write function to call */
if(wcb){
/* filter the data through the out modules */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].fh_out ) {
int32_t ret;
ret = xar_datamods[i].fh_out(x, f, p, inbuf, bsize, &(modulecontext[i]));
if( ret < 0 )
return -1;
}
}
wcb(x, f, inbuf, bsize, context);
}
free(inbuf);
bsize = def_bsize;
inbuf = malloc(bsize);
}
free(inbuf);
/* finish up anything that still needs doing */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].fh_done ) {
int32_t ret;
ret = xar_datamods[i].fh_done(x, f, p, &(modulecontext[i]));
if( ret < 0 )
return ret;
}
}
return 0;
}
int32_t xar_attrcopy_to_heap(xar_t x, xar_file_t f, xar_prop_t p, read_callback rcb, void *context) {
int modulecount = (sizeof(xar_datamods)/sizeof(struct datamod));
void *modulecontext[modulecount];
int r, off, i;
size_t bsize, rsize;
int64_t readsize=0, writesize=0, inc = 0;
void *inbuf;
char *tmpstr = NULL;
const char *opt, *csum;
off_t orig_heap_offset = XAR(x)->heap_offset;
xar_file_t tmpf = NULL;
xar_prop_t tmpp = NULL;
memset(modulecontext, 0, sizeof(void*)*modulecount);
opt = xar_opt_get(x, XAR_OPT_RSIZE);
if( !opt ) {
bsize = 4096;
} else {
bsize = strtol(opt, NULL, 0);
if( ((bsize == LONG_MAX) || (bsize == LONG_MIN)) && (errno == ERANGE) ) {
bsize = 4096;
}
}
r = 1;
while(r != 0) {
inbuf = malloc(bsize);
if( !inbuf )
return -1;
r = rcb(x, f, inbuf, bsize, context);
if( r < 0 ) {
free(inbuf);
return -1;
}
readsize+=r;
inc += r;
rsize = r;
/* filter the data through the in modules */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].th_in ) {
xar_datamods[i].th_in(x, f, p, &inbuf, &rsize, &(modulecontext[i]));
}
}
/* filter the data through the out modules */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].th_out )
xar_datamods[i].th_out(x, f, p, inbuf, rsize, &(modulecontext[i]));
}
off = 0;
if( rsize != 0 ) {
do {
r = write(XAR(x)->heap_fd, inbuf+off, rsize-off);
if( (r < 0) && (errno != EINTR) )
return -1;
off += r;
writesize += r;
} while( off < rsize );
}
XAR(x)->heap_offset += off;
free(inbuf);
}
/* If size is 0, don't bother having anything in the heap */
if( readsize == 0 ) {
XAR(x)->heap_offset = orig_heap_offset;
lseek(XAR(x)->heap_fd, -writesize, SEEK_CUR);
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].th_done )
xar_datamods[i].th_done(x, f, p, &(modulecontext[i]));
}
return 0;
}
/* finish up anything that still needs doing */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].th_done )
xar_datamods[i].th_done(x, f, p, &(modulecontext[i]));
}
XAR(x)->heap_len += writesize;
tmpp = xar_prop_pget(p, "archived-checksum");
if( tmpp )
csum = xar_prop_getvalue(tmpp);
tmpf = xmlHashLookup(XAR(x)->csum_hash, BAD_CAST(csum));
if( tmpf ) {
const char *attr = xar_prop_getkey(p);
opt = xar_opt_get(x, XAR_OPT_LINKSAME);
if( opt && (strcmp(attr, "data") == 0) ) {
const char *id = xar_attr_pget(tmpf, NULL, "id");
xar_prop_pset(f, NULL, "type", "hardlink");
tmpp = xar_prop_pfirst(f);
if( tmpp )
tmpp = xar_prop_find(tmpp, "type");
if( tmpp )
xar_attr_pset(f, tmpp, "link", id);
xar_prop_pset(tmpf, NULL, "type", "hardlink");
tmpp = xar_prop_pfirst(tmpf);
if( tmpp )
tmpp = xar_prop_find(tmpp, "type");
if( tmpp )
xar_attr_pset(tmpf, tmpp, "link", "original");
tmpp = xar_prop_pfirst(f);
if( tmpp )
tmpp = xar_prop_find(tmpp, "data");
xar_prop_punset(f, tmpp);
XAR(x)->heap_offset = orig_heap_offset;
lseek(XAR(x)->heap_fd, -writesize, SEEK_CUR);
XAR(x)->heap_len -= writesize;
return 0;
}
opt = xar_opt_get(x, XAR_OPT_COALESCE);
if( opt ) {
long long tmpoff;
const char *offstr = NULL;
tmpp = xar_prop_pfirst(tmpf);
if( tmpp ) {
const char *key;
key = xar_prop_getkey(p);
tmpp = xar_prop_find(tmpp, key);
}
if( tmpp )
tmpp = xar_prop_pget(tmpp, "offset");
if( tmpp )
offstr = xar_prop_getvalue(tmpp);
if( offstr ) {
tmpoff = strtoll(offstr, NULL, 10);
XAR(x)->heap_offset = orig_heap_offset;
lseek(XAR(x)->heap_fd, -writesize, SEEK_CUR);
orig_heap_offset = tmpoff;
XAR(x)->heap_len -= writesize;
}
}
} else {
xmlHashAddEntry(XAR(x)->csum_hash, BAD_CAST(csum), XAR_FILE(f));
}
asprintf(&tmpstr, "%"PRIu64, readsize);
xar_prop_pset(f, p, "size", tmpstr);
free(tmpstr);
asprintf(&tmpstr, "%"PRIu64, (uint64_t)orig_heap_offset);
xar_prop_pset(f, p, "offset", tmpstr);
free(tmpstr);
tmpstr = (char *)xar_opt_get(x, XAR_OPT_COMPRESSION);
if( tmpstr && (strcmp(tmpstr, XAR_OPT_VAL_NONE) == 0) ) {
xar_prop_pset(f, p, "encoding", NULL);
tmpp = xar_prop_pget(p, "encoding");
if( tmpp )
xar_attr_pset(f, tmpp, "style", "application/octet-stream");
}
asprintf(&tmpstr, "%"PRIu64, writesize);
xar_prop_pset(f, p, "length", tmpstr);
free(tmpstr);
return 0;
}
int32_t xar_attrcopy_to_heap(xar_t x, xar_file_t f, xar_prop_t p, read_callback rcb, void *context) {
int modulecount = (sizeof(xar_datamods)/sizeof(struct datamod));
void *modulecontext[modulecount];
int r, i;
size_t bsize, rsize;
int64_t readsize=0, writesize=0, inc = 0, this_write=0;
void *inbuf;
char *tmpstr = NULL;
const char *opt = NULL, *csum = NULL;
off_t orig_heap_offset = XAR(x)->heap_offset;
xar_file_t tmpf = NULL;
xar_prop_t tmpp = NULL;
memset(modulecontext, 0, sizeof(void*)*modulecount);
bsize = xar_io_get_rsize(x);
r = 1;
// (Apple) allocate once
inbuf = malloc(bsize);
if( !inbuf )
return -1;
while(r != 0) {
r = rcb(x, f, inbuf, bsize, context);
if( r < 0 ) {
free(inbuf);
return -1;
}
readsize+=r;
inc += r;
rsize = r;
/* filter the data through the in modules */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].th_in ) {
xar_datamods[i].th_in(x, f, p, &inbuf, &rsize, &(modulecontext[i]));
}
}
/* filter the data through the out modules */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].th_out )
xar_datamods[i].th_out(x, f, p, inbuf, rsize, &(modulecontext[i]));
}
size_t written = 0;
if( rsize != 0 ) {
while(written < rsize) {
this_write = xar_write_fd(XAR(x)->heap_fd, inbuf, rsize);
if( this_write < 0 ) {
xar_err_new(x);
xar_err_set_string(x, "write(2) error when writing to heap");
xar_err_set_errno(x, errno);
xar_err_callback(x, XAR_SEVERITY_FATAL, XAR_ERR_ARCHIVE_CREATION);
free(inbuf);
return -1;
}
written += this_write;
}
}
XAR(x)->heap_offset += written;
writesize += written;
}
free(inbuf);
/* If size is 0, don't bother having anything in the heap */
if( readsize == 0 ) {
XAR(x)->heap_offset = orig_heap_offset;
lseek(XAR(x)->heap_fd, -writesize, SEEK_CUR);
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].th_done )
xar_datamods[i].th_done(x, f, p, &(modulecontext[i]));
}
return 0;
}
/* finish up anything that still needs doing */
for( i = 0; i < modulecount; i++) {
if( xar_datamods[i].th_done )
xar_datamods[i].th_done(x, f, p, &(modulecontext[i]));
}
XAR(x)->heap_len += writesize;
tmpp = xar_prop_pget(p, "archived-checksum");
if( tmpp )
csum = xar_prop_getvalue(tmpp);
if( csum )
tmpf = xmlHashLookup(XAR(x)->csum_hash, BAD_CAST(csum));
if( tmpf ) {
const char *attr = xar_prop_getkey(p);
opt = xar_opt_get(x, XAR_OPT_LINKSAME);
if( opt && (strcmp(attr, "data") == 0) ) {
const char *id = xar_attr_pget(tmpf, NULL, "id");
xar_prop_pset(f, NULL, "type", "hardlink");
tmpp = xar_prop_pfirst(f);
if( tmpp )
tmpp = xar_prop_find(tmpp, "type");
if( tmpp )
xar_attr_pset(f, tmpp, "link", id);
xar_prop_pset(tmpf, NULL, "type", "hardlink");
tmpp = xar_prop_pfirst(tmpf);
if( tmpp )
tmpp = xar_prop_find(tmpp, "type");
if( tmpp )
xar_attr_pset(tmpf, tmpp, "link", "original");
tmpp = xar_prop_pfirst(f);
if( tmpp )
tmpp = xar_prop_find(tmpp, "data");
xar_prop_punset(f, tmpp);
XAR(x)->heap_offset = orig_heap_offset;
lseek(XAR(x)->heap_fd, -writesize, SEEK_CUR);
XAR(x)->heap_len -= writesize;
return 0;
}
opt = xar_opt_get(x, XAR_OPT_COALESCE);
if( opt ) {
long long tmpoff;
const char *offstr = NULL;
tmpp = xar_prop_pfirst(tmpf);
if( tmpp ) {
const char *key;
key = xar_prop_getkey(p);
tmpp = xar_prop_find(tmpp, key);
}
if( tmpp )
tmpp = xar_prop_pget(tmpp, "offset");
if( tmpp )
offstr = xar_prop_getvalue(tmpp);
if( offstr ) {
tmpoff = strtoll(offstr, NULL, 10);
XAR(x)->heap_offset = orig_heap_offset;
lseek(XAR(x)->heap_fd, -writesize, SEEK_CUR);
orig_heap_offset = tmpoff;
XAR(x)->heap_len -= writesize;
}
}
} else if( csum ) {
xmlHashAddEntry(XAR(x)->csum_hash, BAD_CAST(csum), XAR_FILE(f));
} else {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "No archived-checksum");
xar_err_callback(x, XAR_SEVERITY_WARNING, XAR_ERR_ARCHIVE_CREATION);
}
asprintf(&tmpstr, "%"PRIu64, readsize);
xar_prop_pset(f, p, "size", tmpstr);
free(tmpstr);
asprintf(&tmpstr, "%"PRIu64, (uint64_t)orig_heap_offset);
xar_prop_pset(f, p, "offset", tmpstr);
free(tmpstr);
tmpstr = (char *)xar_opt_get(x, XAR_OPT_COMPRESSION);
if( tmpstr && (strcmp(tmpstr, XAR_OPT_VAL_NONE) == 0) ) {
xar_prop_pset(f, p, "encoding", NULL);
tmpp = xar_prop_pget(p, "encoding");
if( tmpp )
xar_attr_pset(f, tmpp, "style", "application/octet-stream");
}
asprintf(&tmpstr, "%"PRIu64, writesize);
xar_prop_pset(f, p, "length", tmpstr);
free(tmpstr);
return 0;
}
int32_t xar_gzip_toheap_in(xar_t x, xar_file_t f, xar_prop_t p, void **in, size_t *inlen, void **context) {
void *out = NULL;
size_t outlen, offset = 0;
int r;
const char *opt;
/* on first run, we init the context and check the compression type */
if( !GZIP_CONTEXT(context) ) {
int level = Z_BEST_COMPRESSION;
*context = calloc(1,sizeof(struct _gzip_context));
opt = xar_opt_get(x, XAR_OPT_COMPRESSION);
if( !opt )
return 0;
if( strcmp(opt, XAR_OPT_VAL_GZIP) != 0 )
return 0;
opt = xar_opt_get(x, XAR_OPT_COMPRESSIONARG);
if( opt ) {
int tmp;
errno = 0;
tmp = strtol(opt, NULL, 10);
if( errno == 0 ) {
if( (level >= 0) && (level <= 9) )
level = tmp;
}
}
deflateInit(&GZIP_CONTEXT(context)->z, level);
GZIP_CONTEXT(context)->gzipcompressed = 1;
if( *inlen == 0 )
return 0;
}else if( !GZIP_CONTEXT(context)->gzipcompressed ){
/* once the context has been initialized, then we have already
checked the compression type, so we need only check if we
actually are compressed */
return 0;
}
outlen = *inlen/2;
if(outlen == 0) outlen = 1024;
GZIP_CONTEXT(context)->z.next_in = *in;
GZIP_CONTEXT(context)->z.avail_in = *inlen;
GZIP_CONTEXT(context)->z.next_out = out;
GZIP_CONTEXT(context)->z.avail_out = 0;
if( *inlen != 0 ) {
do {
outlen *= 2;
out = realloc(out, outlen);
if( out == NULL ) abort();
GZIP_CONTEXT(context)->z.next_out = ((unsigned char *)out) + offset;
GZIP_CONTEXT(context)->z.avail_out = outlen - offset;
r = deflate(&GZIP_CONTEXT(context)->z, Z_NO_FLUSH);
offset = outlen - GZIP_CONTEXT(context)->z.avail_out;
} while( r == Z_OK && GZIP_CONTEXT(context)->z.avail_in != 0 );
} else {
do {
outlen *= 2;
out = realloc(out, outlen);
if( out == NULL ) abort();
GZIP_CONTEXT(context)->z.next_out = ((unsigned char *)out) + offset;
GZIP_CONTEXT(context)->z.avail_out = outlen - offset;
r = deflate(&GZIP_CONTEXT(context)->z, Z_FINISH);
offset = outlen - GZIP_CONTEXT(context)->z.avail_out;
} while( r == Z_OK && r != Z_STREAM_END /* no-op */);
}
if( (r != Z_OK && r != Z_STREAM_END) ) {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "Error compressing file");
xar_err_set_errno(x, r);
xar_err_callback(x, XAR_SEVERITY_FATAL, XAR_ERR_ARCHIVE_CREATION);
return -1;
}
free(*in);
*in = out;
GZIP_CONTEXT(context)->count += *inlen;
*inlen = offset;
return 0;
}
static int archive(const char *filename, int arglen, char *args[]) {
xar_t x;
FTS *fts;
FTSENT *ent;
int flags;
struct lnode *i;
const char *default_compression;
x = xar_open(filename, WRITE);
if( !x ) {
fprintf(stderr, "Error creating archive %s\n", filename);
exit(1);
}
if ( SigSize ) {
xar_signature_t sig = xar_signature_new(x, "RSA", SigSize, &signingCallback, NULL);
if ( LeafCertPath )
insert_cert(sig, LeafCertPath);
if ( IntermediateCertPath )
insert_cert(sig, IntermediateCertPath);
}
if( Toccksum )
xar_opt_set(x, XAR_OPT_TOCCKSUM, Toccksum);
if( Compression )
xar_opt_set(x, XAR_OPT_COMPRESSION, Compression);
if( Coalesce )
xar_opt_set(x, XAR_OPT_COALESCE, "true");
if( LinkSame )
xar_opt_set(x, XAR_OPT_LINKSAME, "true");
if ( Rsize != NULL )
xar_opt_set(x, XAR_OPT_RSIZE, Rsize);
xar_register_errhandler(x, err_callback, NULL);
if( Subdoc )
add_subdoc(x);
if( Perms == SYMBOLIC ) {
xar_opt_set(x, XAR_OPT_OWNERSHIP, XAR_OPT_VAL_SYMBOLIC);
}
if( Perms == NUMERIC ) {
xar_opt_set(x, XAR_OPT_OWNERSHIP, XAR_OPT_VAL_NUMERIC);
}
default_compression = strdup(xar_opt_get(x, XAR_OPT_COMPRESSION));
if( !default_compression )
default_compression = strdup(XAR_OPT_VAL_GZIP);
flags = FTS_PHYSICAL|FTS_NOSTAT|FTS_NOCHDIR;
if( Local )
flags |= FTS_XDEV;
fts = fts_open(args, flags, NULL);
if( !fts ) {
fprintf(stderr, "Error traversing file tree\n");
exit(1);
}
while( (ent = fts_read(fts)) ) {
xar_file_t f;
int exclude_match = 1;
int nocompress_match = 1;
if( ent->fts_info == FTS_DP )
continue;
if( strcmp(ent->fts_path, "/") == 0 )
continue;
if( strcmp(ent->fts_path, ".") == 0 )
continue;
for( i = Exclude; i; i=i->next ) {
exclude_match = regexec(&i->reg, ent->fts_path, 0, NULL, 0);
if( !exclude_match )
break;
}
if( !exclude_match ) {
if( Verbose )
printf("Excluding %s\n", ent->fts_path);
continue;
}
for( i = NoCompress; i; i=i->next ) {
nocompress_match = regexec(&i->reg, ent->fts_path, 0, NULL, 0);
if( !nocompress_match ) {
xar_opt_set(x, XAR_OPT_COMPRESSION, XAR_OPT_VAL_NONE);
break;
}
}
f = xar_add(x, ent->fts_path);
if( !f ) {
fprintf(stderr, "Error adding file %s\n", ent->fts_path);
} else {
print_file(f);
}
if( !nocompress_match )
xar_opt_set(x, XAR_OPT_COMPRESSION, default_compression);
}
fts_close(fts);
if( xar_close(x) != 0 ) {
fprintf(stderr, "Error creating the archive\n");
if( !Err )
Err = 42;
}
free((char *)default_compression);
for( i = Exclude; i; ) {
struct lnode *tmp;
regfree(&i->reg);
tmp = i;
i = i->next;
free(tmp);
}
for( i = NoCompress; i; ) {
struct lnode *tmp;
regfree(&i->reg);
tmp = i;
i = i->next;
free(tmp);
}
if ( SigOffsetDumpPath ) {
x = xar_open(filename, READ);
if( !x ) {
fprintf(stderr, "Error re-opening archive %s\n", filename);
exit(1);
}
if (extract_sig_offset(x, SigOffsetDumpPath))
exit(1);
}
return Err;
}
/* replace_sign: rip out all current signatures and certs and insert a new pair
Since libxar is currently not capable of doing this directly, we have to create a new xar archive,
copy all the files and options from the current archive, and sign the new archive
*/
static void replace_sign(const char *filename) {
xar_t old_xar, new_xar;
xar_signature_t sig;
char *new_xar_path = (char *)malloc(15);
strncpy(new_xar_path, "/tmp/xar.XXXXX", 15);
new_xar_path = mktemp(new_xar_path);
char *systemcall;
int err;
// open both archives
old_xar = xar_open(filename, READ);
if ( old_xar == NULL ) {
fprintf(stderr, "Could not open archive %s!\n", filename);
exit(1);
}
new_xar = xar_open(new_xar_path, WRITE);
if( !new_xar ) {
fprintf(stderr, "Error creating new archive %s\n", new_xar_path);
exit(1);
}
// install new signature and new certs in new_xar
sig = xar_signature_new(new_xar, "RSA", SigSize, &signingCallback, NULL);
if ( LeafCertPath )
insert_cert(sig, LeafCertPath);
if ( IntermediateCertPath )
insert_cert(sig, IntermediateCertPath);
// copy options
char *opts[6] = {XAR_OPT_TOCCKSUM, XAR_OPT_COMPRESSION, XAR_OPT_COALESCE, XAR_OPT_LINKSAME, XAR_OPT_RSIZE, XAR_OPT_OWNERSHIP};
int i;
const char *opt;
for (i=0; i<6; i++) {
opt = xar_opt_get(old_xar, opts[i]);
if (opt)
xar_opt_set(new_xar, opts[i], opt);
}
// skip copy subdocs for now since we don't use them yet
// copy files
xar_iter_t iter = xar_iter_new();
xar_file_t f = xar_file_first(old_xar, iter);
// xar_file_next iterates the archive depth-first, i.e. all children are enumerated before the siblings.
const char *name;
char *f_dirname, *stack_top_dirname;
stack s_new = stack_new();
stack s_old = stack_new();
xar_file_t last_copied = NULL, last_added;
xar_iter_t loopIter = xar_iter_new();
xar_file_t current_xar_file;
for (current_xar_file = xar_file_first(old_xar, loopIter); current_xar_file; current_xar_file = xar_file_next(loopIter))
{
printf("old_xar -> %s (parent: %s)\n",xar_get_path(current_xar_file),XAR_FILE(current_xar_file)->parent?xar_get_path(XAR_FILE(current_xar_file)->parent):"(nil)");
}
do {
// parent is the parent in the new archive!
// 3 cases:
// 1. the file has no parent. Happens for every file at the top level of the archive.
// 2. the file's parent is the last file we added. Happens while descending down a path
// 3. the file's parent is one of the ancestors of the last file (and not NULL, that would be case 1)
// that means we either go back up the tree and add a sibling of one of the ancestors, or we add a
// sibling on the same level
xar_prop_get(f, "name", &name); // filename, without any path info
if (!XAR_FILE(f)->parent) { // case 1
printf("root: %s\n",xar_get_path(f));
last_added = xar_add_from_archive(new_xar, NULL, name, old_xar, f);
last_copied = f;
stack_push(s_new, (void *)last_added);
stack_push(s_old, (void *)last_copied);
} else if (f->parent == last_copied) { // case 2
printf("child: %s -> %s\n",xar_get_path(f->parent),xar_get_path(f));
last_added = xar_add_from_archive(new_xar, last_added, name, old_xar, f);
last_copied = f;
stack_push(s_new, (void *)last_added);
stack_push(s_old, (void *)last_copied);
} else { // case 3
printf("searching for parent: %s ?\n",xar_get_path(f));
while (XAR_FILE(f)->parent != XAR_FILE(s_old->top->data)->parent) {
printf("popping: %s\n",xar_get_path(XAR_FILE(s_old->top->data)));
stack_pop(s_new);
stack_pop(s_old);
}
printf("found: %s -> %s\n",xar_get_path(XAR_FILE(s_new->top->data)),xar_get_path(f));
stack_pop(s_new);
stack_pop(s_old);
last_added = xar_add_from_archive(new_xar, (xar_file_t)(s_new->top->data), name, old_xar, f);
last_copied = f;
stack_push(s_new, (void *)last_added);
stack_push(s_old, (void *)last_copied);
}
} while (f = xar_file_next(iter));
loopIter = xar_iter_new();
for (current_xar_file = xar_file_first(new_xar, loopIter); current_xar_file; current_xar_file = xar_file_next(loopIter))
{
char * current_path = xar_get_path(current_xar_file);
printf("new_xar -> %s\n",current_path);
}
xar_iter_free(iter);
stack_free(s_new);
stack_free(s_old);
if( xar_close(new_xar) != 0 ) {
fprintf(stderr, "Error creating the archive\n");
if( !Err )
Err = 42;
}
xar_close(old_xar);
// write signature offset to file (have to re-open so xar_close can figure out the correct offset)
new_xar = xar_open(new_xar_path, READ);
if( !new_xar ) {
fprintf(stderr, "Error re-opening new archive %s\n", new_xar_path);
unlink(new_xar_path);
exit(1);
}
if (extract_sig_offset(new_xar, SigOffsetDumpPath)) {
xar_close(new_xar);
unlink(new_xar_path);
exit(1);
}
xar_close(new_xar);
// delete old archive, move new in its place
unlink(filename);
asprintf(&systemcall, "cp \"%s\" \"%s\"", new_xar_path, filename);
err = system(systemcall);
if (err) {
fprintf(stderr, "Could not copy new archive to final location (system() returned %i)\n", err);
unlink(new_xar_path);
exit(1);
}
// Delete the tmp archive
unlink(new_xar_path);
free(systemcall);
}
int32_t xar_set_perm(xar_t x, xar_file_t f, const char *file, char *buffer, size_t len) {
const char *opt;
int32_t m=0, mset=0;
uid_t u;
gid_t g;
const char *timestr;
struct tm t;
enum {ATIME=0, MTIME};
struct timeval tv[2];
/* when writing to a buffer, there are no permissions to set */
if ( len )
return 0;
/* in case we don't find anything useful in the archive */
u = geteuid();
g = getegid();
opt = xar_opt_get(x, XAR_OPT_OWNERSHIP);
if( opt && (strcmp(opt, XAR_OPT_VAL_SYMBOLIC) == 0) ) {
struct passwd *pw;
struct group *gr;
xar_prop_get(f, "user", &opt);
if( opt ) {
pw = getpwnam(opt);
if( pw ) {
u = pw->pw_uid;
}
}
xar_prop_get(f, "group", &opt);
if( opt ) {
gr = getgrnam(opt);
if( gr ) {
g = gr->gr_gid;
}
}
}
if( opt && (strcmp(opt, XAR_OPT_VAL_NUMERIC) == 0) ) {
xar_prop_get(f, "uid", &opt);
if( opt ) {
long long tmp;
tmp = strtol(opt, NULL, 10);
if( ( (tmp == LLONG_MIN) || (tmp == LLONG_MAX) ) && (errno == ERANGE) ) {
return -1;
}
u = (uid_t)tmp;
}
xar_prop_get(f, "gid", &opt);
if( opt ) {
long long tmp;
tmp = strtol(opt, NULL, 10);
if( ( (tmp == LLONG_MIN) || (tmp == LLONG_MAX) ) && (errno == ERANGE) ) {
return -1;
}
g = (gid_t)tmp;
}
}
xar_prop_get(f, "mode", &opt);
if( opt ) {
long long tmp;
tmp = strtoll(opt, NULL, 8);
if( ( (tmp == LLONG_MIN) || (tmp == LLONG_MAX) ) && (errno == ERANGE) ) {
return -1;
}
m = (mode_t)tmp;
mset = 1;
}
xar_prop_get(f, "type", &opt);
if( opt && !mset ) {
mode_t u = umask(0);
umask(u);
if( strcmp(opt, "directory") == 0 ) {
m = (mode_t)(0777 & ~u);
} else {
m = (mode_t)(0666 & ~u);
}
mset = 1;
}
if( opt && (strcmp(opt, "symlink") == 0) ) {
#ifdef HAVE_LCHOWN
if( lchown(file, u, g) ) {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "perm: could not lchown symlink");
xar_err_callback(x, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
}
#ifdef HAVE_LCHMOD
if( mset )
if( lchmod(file, m) ) {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "perm: could not lchmod symlink");
xar_err_callback(x, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
}
#endif
#endif
} else {
if( chown(file, u, g) ) {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "perm: could not chown file");
xar_err_set_errno(x, errno);
xar_err_callback(x, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
}
if( mset )
if( chmod(file, m) ) {
xar_err_new(x);
xar_err_set_file(x, f);
xar_err_set_string(x, "perm: could not chmod file");
xar_err_callback(x, XAR_SEVERITY_NONFATAL, XAR_ERR_ARCHIVE_EXTRACTION);
}
}
eacls(x, f, file);
memset(tv, 0, sizeof(struct timeval) * 2);
xar_prop_get(f, "atime", ×tr);
if( timestr ) {
memset(&t, 0, sizeof(t));
strptime(timestr, "%FT%T", &t);
tv[ATIME].tv_sec = timegm(&t);
} else {
tv[ATIME].tv_sec = time(NULL);
}
xar_prop_get(f, "mtime", ×tr);
if( timestr ) {
memset(&t, 0, sizeof(t));
strptime(timestr, "%FT%T", &t);
tv[MTIME].tv_sec = timegm(&t);
} else {
tv[MTIME].tv_sec = time(NULL);
}
utimes(file, tv);
return 0;
}
