/* Parse a dump header, including its tagged attributes, and call the
* dump-header callback, if one is defined.
*/
static afs_uint32
parse_dumphdr(XFILE * X, unsigned char *tag, tagged_field * field,
afs_uint32 value, tag_parse_info * pi, void *g_refcon,
void *l_refcon)
{
dump_parser *p = (dump_parser *) g_refcon;
afs_dump_header hdr;
dt_uint64 where;
afs_uint32 r;
memset(&hdr, 0, sizeof(hdr));
if ((r = xftell(X, &where)))
return r;
sub64_32(hdr.offset, where, 1);
if ((r = ReadInt32(X, &hdr.magic)))
return r;
if ((r = ReadInt32(X, &hdr.version)))
return r;
if (hdr.magic != DUMPBEGINMAGIC) {
if (p->cb_error)
(p->cb_error) (DSERR_MAGIC, 1, p->err_refcon,
"Invalid magic number (0x%08x) in dump header",
hdr.magic);
return DSERR_MAGIC;
}
if (hdr.version != DUMPVERSION) {
if (p->cb_error)
(p->cb_error) (DSERR_MAGIC, 1, p->err_refcon,
"Unknown dump format version (%d) in dump header",
hdr.version);
return DSERR_MAGIC;
}
if (p->print_flags & DSPRINT_DUMPHDR)
printf("%s [%s = 0x%s]\n", field->label,
decimate_int64(&hdr.offset, 0), hexify_int64(&hdr.offset, 0));
if (p->print_flags & DSPRINT_DUMPHDR) {
printf(" Magic number: 0x%08x\n", hdr.magic);
printf(" Version: %d\n", hdr.version);
}
r = ParseTaggedData(X, dumphdr_fields, tag, pi, g_refcon, (void *)&hdr);
if (!r && p->cb_dumphdr) {
r = xftell(X, &where);
if (!r)
r = (p->cb_dumphdr) (&hdr, X, p->refcon);
if (p->flags & DSFLAG_SEEK) {
if (!r)
r = xfseek(X, &where);
else
xfseek(X, &where);
}
}
if (hdr.field_mask & F_DUMPHDR_VOLNAME)
free(hdr.volname);
return r;
}
static unsigned long long lengthOfFile(FILE *file)
{
long int currentPosition = xftell(file);
xfseek(file , 0L , SEEK_END);
long int length = xftell(file);
xfseek(file, currentPosition, SEEK_SET);
return length;
}
/*** THIS FUNCTION INTENDED FOR INTERNAL USE ONLY ***/
int
handle_return(int r, XFILE * X, unsigned char tag, dump_parser * p)
{
u_int64 where, xwhere;
switch (r) {
case 0:
if (p->cb_error) {
xftell(X, &where);
sub64_32(xwhere, where, 1);
(p->cb_error) (DSERR_TAG, 1, p->err_refcon,
(tag > 0x20 && tag < 0x7f)
? "Unexpected tag '%c' at %s = 0x%s" :
"Unexpected tag 0x%02x at %s = 0x%s", tag,
decimate_int64(&xwhere, 0), hexify_int64(&xwhere,
0));
}
return DSERR_TAG;
case ERROR_XFILE_EOF:
if (p->cb_error) {
xftell(X, &where);
(p->cb_error) (ERROR_XFILE_EOF, 1, p->err_refcon,
"Unexpected EOF at %s = 0x%s",
decimate_int64(&where, 0), hexify_int64(&where,
0));
}
return ERROR_XFILE_EOF;
case ENOMEM:
if (p->cb_error) {
xftell(X, &where);
(p->cb_error) (ENOMEM, 1, p->err_refcon,
"Out of memory at %s = 0x%s",
decimate_int64(&where, 0), hexify_int64(&where,
0));
}
return ENOMEM;
case DSERR_DONE:
return 0;
default:
/* For other negative valuees, the callback was already done */
if (r > 0 && p->cb_error)
(p->cb_error) (r, 1, p->err_refcon,
"System error %d reading dump file", r);
return r;
}
}
CSFAPI int CSFile_load(CSFile** outcsf, const char* filename, CSFileMemoryPTR mem)
{
FILE* file;
if (fopen_s(&file,filename,"rb")){
*outcsf = 0;
return CADSCENEFILE_ERROR_NOFILE;
}
CSFile header;
size_t sizeshould = 0;
if (!fread_s(&header,sizeof(header),sizeof(header),1,file) ||
!(sizeshould=CSFile_getRawSize(&header)))
{
fclose(file);
*outcsf = 0;
return CADSCENEFILE_ERROR_VERSION;
}
// load the full file to memory
xfseek(file, 0, SEEK_END);
size_t size = (size_t)xftell(file);
xfseek(file, 0, SEEK_SET);
if (sizeshould != size){
fclose(file);
*outcsf = 0;
return CADSCENEFILE_ERROR_VERSION;
}
char* data = (char*)mem->alloc(size);
fread_s(data,size,size,1,file);
fclose(file);
return CSFile_loadRaw(outcsf,size,data);
}
static afs_uint32
file_cb(afs_vnode * v, XFILE * X, void *refcon)
{
char *vnodepath, vnpx[30];
dt_uint64 where;
XFILE OX;
int r, use = 0;
if (!dirs_done) {
dirs_done = 1;
if (verbose)
printf("* Extracting files...\n");
}
/* Should we even use this? */
if (!use_vnum) {
if ((r = Path_Build(X, &phi, v->vnode, &vnodepath, !use_realpath)))
return r;
if (!(use = usevnode(X, v->vnode, vnodepath))) {
free(vnodepath);
return 0;
}
if (use == 2) {
free(vnodepath);
sprintf(vnpx, "#%d:%d", v->vnode, v->vuniq);
vnodepath = vnpx;
}
} else {
sprintf(vnpx, "#%d:%d", v->vnode, v->vuniq);
vnodepath = vnpx;
}
/* Print it out */
if (verbose) {
printf("-%s %3d %-11d %11d %s %s\n", modestr(v->mode), v->nlinks,
v->owner, v->size, datestr(v->server_date), vnodepath);
} else if (!quiet) {
printf("%s\n", vnodepath);
}
if (!nomode) {
if ((r = xftell(X, &where))
|| (r = xfseek(X, &v->d_offset))
|| (r =
xfopen_path(&OX, O_RDWR | O_CREAT | O_TRUNC, vnodepath + 1,
0644))) {
if (vnodepath != vnpx)
free(vnodepath);
return r;
}
r = copyfile(X, &OX, v->size);
xfclose(&OX);
xfseek(X, &where);
} else
r = 0;
if (vnodepath != vnpx)
free(vnodepath);
return r;
}
/* Parse a volume header, including any tagged attributes, and call the
* volume-header callback, if one is defined.
*/
afs_uint32
parse_volhdr(XFILE * X, unsigned char *tag, tagged_field * field,
afs_uint32 value, tag_parse_info * pi, void *g_refcon,
void *l_refcon)
{
dump_parser *p = (dump_parser *) g_refcon;
afs_vol_header hdr;
u_int64 where;
afs_uint32 r;
memset(&hdr, 0, sizeof(hdr));
if (r = xftell(X, &where))
return r;
sub64_32(hdr.offset, where, 1);
if (p->print_flags & DSPRINT_VOLHDR)
printf("%s [%s = 0x%s]\n", field->label,
decimate_int64(&hdr.offset, 0), hexify_int64(&hdr.offset, 0));
r = ParseTaggedData(X, volhdr_fields, tag, pi, g_refcon, (void *)&hdr);
if (!r && p->cb_volhdr) {
if (r = xftell(X, &where))
return r;
r = (p->cb_volhdr) (&hdr, X, p->refcon);
if (p->flags & DSFLAG_SEEK) {
if (!r)
r = xfseek(X, &where);
else
xfseek(X, &where);
}
}
if (hdr.field_mask & F_VOLHDR_VOLUNIQ)
p->vol_uniquifier = hdr.voluniq;
if (hdr.field_mask & F_VOLHDR_VOLNAME)
free(hdr.volname);
if (hdr.field_mask & F_VOLHDR_OFFLINE_MSG)
free(hdr.offline_msg);
if (hdr.field_mask & F_VOLHDR_MOTD)
free(hdr.motd_msg);
return r;
}
/* do_tell for profiled xfiles */
static afs_uint32
xf_PROFILE_do_tell(XFILE * X, u_int64 * offset)
{
PFILE *PF = X->refcon;
afs_uint32 err;
err = xftell(&PF->content, offset);
if (err)
xfprintf(&PF->profile, "TELL ERR =%ld\n", (long)err);
else
xfprintf(&PF->profile, "TELL %s =0\n", hexify_int64(offset, 0));
return err;
}
static afs_uint32
resync_vnode(XFILE * X, dump_parser * p, afs_vnode * v, int start, int limit)
{
dt_uint64 where, expected_where;
afs_uint32 r;
int i;
if ((r = xftell(X, &expected_where)))
return r;
cp64(where, expected_where);
r = match_next_vnode(X, p, &where, v->vnode);
if (r && r != DSERR_FMT)
return r;
if (r)
for (i = -start; i < limit; i++) {
add64_32(where, expected_where, i);
r = match_next_vnode(X, p, &where, v->vnode);
if (!r)
break;
if (r != DSERR_FMT)
return r;
}
if (r) {
if (p->cb_error)
(p->cb_error) (r, 1, p->err_refcon,
"Unable to resync after vnode %d [%s = 0x%s]",
v->vnode, decimate_int64(&expected_where, 0),
hexify_int64(&expected_where, 0));
return r;
}
if (ne64(where, expected_where) && p->cb_error) {
(p->cb_error) (DSERR_FMT, 0, p->err_refcon,
"Vnode after %d not in expected location", v->vnode);
(p->cb_error) (DSERR_FMT, 0, p->err_refcon,
"Expected location: %s = 0x%s",
decimate_int64(&expected_where, 0),
hexify_int64(&expected_where, 0));
(p->cb_error) (DSERR_FMT, 0, p->err_refcon,
"Actual location: %s = 0x%s", decimate_int64(&where,
0),
hexify_int64(&where, 0));
}
return xfseek(X, &where);
}
struct pic_string *
pic_get_output_string(pic_state *pic, struct pic_port *port)
{
size_t size;
char *buf;
/* get endpos */
xfflush(port->file);
size = (size_t)xftell(port->file);
xrewind(port->file);
/* copy to buf */
buf = (char *)pic_alloc(pic, size + 1);
buf[size] = 0;
xfread(buf, size, 1, port->file);
return pic_make_str(pic, buf, size);
}
afs_uint32
xfskip(XFILE * X, afs_uint32 count)
{
afs_uint32 code;
u_int64 tmp64;
/* Use the skip method, if there is one */
if (X->do_skip && !X->passthru) {
code = (X->do_skip) (X, count);
if (code)
return code;
add64_32(tmp64, X->filepos, count);
cp64(X->filepos, tmp64);
return 0;
}
/* Simulate using absolute seek, if available */
if (X->do_seek && !X->passthru) {
if ((code = xftell(X, &tmp64)))
return code;
add64_32(X->filepos, tmp64, count);
cp64(tmp64, X->filepos);
return xfseek(X, &tmp64);
}
/* Do it the hard/slow way - read all the data to be skipped.
* This is done if no other method is available, or if we are
* supposed to be copying all the data to another XFILE
*/
{
char buf[SKIP_SIZE];
afs_uint32 n;
while (count) {
n = (count > SKIP_SIZE) ? SKIP_SIZE : count;
if ((code = xfread(X, buf, n)))
return code;
count -= n;
}
return 0;
}
}
afs_uint32
try_backuphdr(XFILE * X, char *tag, tagged_field * field, afs_uint32 value,
tag_parse_info * pi, void *g_refcon, void *l_refcon)
{
dump_parser *p = (dump_parser *) g_refcon;
backup_system_header bh;
u_int64 where;
afs_uint32 r;
/* Which header should we try (if any)? */
switch (*tag) {
case STAGE_VERSMIN:
r = ParseStageHdr(X, (unsigned char *)tag, &bh);
break;
default:
return DSERR_MAGIC;
}
if (r)
return r;
/* Do something with it... */
if (p->print_flags & DSPRINT_BCKHDR)
PrintBackupHdr(&bh);
if (p->cb_bckhdr) {
r = xftell(X, &where);
if (!r && p->cb_bckhdr)
r = (p->cb_bckhdr) (&bh, X, p->refcon);
if (p->flags & DSFLAG_SEEK) {
if (!r)
r = xfseek(X, &where);
else
xfseek(X, &where);
}
}
if (bh.server)
free(bh.server);
if (bh.part)
free(bh.part);
if (bh.volname)
free(bh.volname);
return r;
}
static pic_value
pic_port_get_output_bytevector(pic_state *pic)
{
struct pic_port *port = pic_stdout(pic);
pic_blob *blob;
size_t size;
pic_get_args(pic, "|p", &port);
assert_port_profile(port, PIC_PORT_OUT | PIC_PORT_BINARY, PIC_PORT_OPEN, "get-output-bytevector");
/* get endpos */
xfflush(port->file);
size = (size_t)xftell(port->file);
xrewind(port->file);
/* copy to buf */
blob = pic_make_blob(pic, size);
xfread(blob->data, 1, size, port->file);
return pic_obj_value(blob);
}
/* Parse a file containing tagged data and attributes **/
afs_uint32
ParseTaggedData(XFILE * X, tagged_field * fields, unsigned char *tag,
tag_parse_info * pi, void *g_refcon, void *l_refcon)
{
int i = -1;
afs_uint32 r, val;
afs_uint16 val16;
unsigned char val8;
unsigned char *strval;
for (;;) {
if (i < 0 || (fields[i].kind & DKIND_MASK) != DKIND_SPECIAL) {
/* Need to read in a tag */
if ((r = ReadByte(X, tag)))
return r;
}
/* Simple error recovery - if we encounter a 0, it can never be
* a valid tag. If TPFLAG_SKIP is set, we can skip over any
* such null bytes, and process whatever tag we find beyond.
* In addition, if TPFLAG_RSKIP is set, then the next time
* we encounter a 0, try skipping backwards. That seems to
* work much of the time.
*/
if (!*tag && pi->shift_offset && (pi->flags & TPFLAG_RSKIP)) {
u_int64 where, tmp64a, tmp64b;
char buf1[21], buf2[21], buf3[21];
char *p1, *p2, *p3;
if ((r = xftell(X, &tmp64a)))
return r;
sub64_32(where, tmp64a, pi->shift_offset + 1);
if ((r = xfseek(X, &where)))
return r;
if (pi->cb_error) {
(pi->cb_error) (DSERR_FMT, 0, pi->err_refcon,
"Inserted %d bytes before offset %d",
pi->shift_offset, decimate_int64(&where, 0));
add64_32(tmp64a, pi->shift_start, pi->shift_offset);
p1 = decimate_int64(&tmp64a, buf1);
sub64_64(tmp64b, where, tmp64a);
p2 = decimate_int64(&tmp64b, buf2);
p3 = decimate_int64(&pi->shift_start, buf3);
(pi->cb_error) (DSERR_FMT, 0, pi->err_refcon,
">>> SHIFT start=%s length=%s target=%s", p1,
p2, p3);
}
pi->shift_offset = 0;
if ((r = ReadByte(X, tag)))
return r;
}
if (!*tag && (pi->flags & TPFLAG_SKIP)) {
int count = 0;
u_int64 where, tmp64a;
if ((r = xftell(X, &where)))
return r;
while (!*tag) {
if ((r = ReadByte(X, tag)))
return r;
count++;
}
pi->shift_offset += count;
cp64(pi->shift_start, where);
if (pi->cb_error) {
sub64_32(tmp64a, where, 1);
(pi->cb_error) (DSERR_FMT, 0, pi->err_refcon,
"Skipped %d bytes at offset %s", count,
decimate_int64(&tmp64a, 0));
}
}
for (i = 0; fields[i].tag && fields[i].tag != *tag; i++);
if (!fields[i].tag)
return 0;
switch (fields[i].kind & DKIND_MASK) {
case DKIND_NOOP:
if (fields[i].func) {
r = (fields[i].func) (X, 0, fields + i, 0, pi, g_refcon,
l_refcon);
if (r)
return r;
}
break;
case DKIND_BYTE:
if ((r = ReadByte(X, &val8)))
return r;
if (fields[i].func) {
r = (fields[i].func) (X, 0, fields + i, val8, pi, g_refcon,
l_refcon);
if (r)
return r;
}
break;
case DKIND_INT16:
if ((r = ReadInt16(X, &val16)))
return r;
if (fields[i].func) {
r = (fields[i].func) (X, 0, fields + i, val16, pi, g_refcon,
l_refcon);
if (r)
return r;
}
break;
case DKIND_INT32:
if ((r = ReadInt32(X, &val)))
return r;
if (fields[i].func) {
r = (fields[i].func) (X, 0, fields + i, val, pi, g_refcon,
l_refcon);
if (r)
return r;
}
break;
case DKIND_STRING:
if ((r = ReadString(X, &strval)))
return r;
if (fields[i].func) {
r = (fields[i].func) (X, strval, fields + i, 0, pi, g_refcon,
l_refcon);
if (r != DSERR_KEEP)
free(strval);
if (r && r != DSERR_KEEP)
return r;
} else
free(strval);
break;
case DKIND_SPECIAL:
if (fields[i].func) {
r = (fields[i].func) (X, tag, fields + i, 0, pi, g_refcon,
l_refcon);
if (r)
return r;
} else
i = -1;
}
}
}
/* Parse or skip over the vnode data */
static afs_uint32
parse_vdata(XFILE * X, unsigned char *tag, tagged_field * field,
afs_uint32 value, tag_parse_info * pi, void *g_refcon,
void *l_refcon)
{
dump_parser *p = (dump_parser *) g_refcon;
afs_vnode *v = (afs_vnode *) l_refcon;
static char *symlink_buf = 0;
static int symlink_size = 0;
afs_uint32 r;
if ((r = ReadInt32(X, &v->size)))
return r;
v->field_mask |= F_VNODE_SIZE;
if (v->size) {
v->field_mask |= F_VNODE_DATA;
if ((r = xftell(X, &v->d_offset)))
return r;
if (p->print_flags & DSPRINT_VNODE)
printf("%s%d (0x%08x) bytes at %s (0x%s)\n", field->label,
v->size, v->size, decimate_int64(&v->d_offset, 0),
hexify_int64(&v->d_offset, 0));
switch (v->type) {
case vSymlink:
if (v->size > symlink_size) {
if (symlink_buf)
symlink_buf = realloc(symlink_buf, v->size + 1);
else
symlink_buf = (char *)malloc(v->size + 1);
symlink_size = symlink_buf ? v->size : 0;
}
if (symlink_buf) {
if ((r = xfread(X, symlink_buf, v->size)))
return r;
symlink_buf[v->size] = 0;
if (p->print_flags & DSPRINT_VNODE)
printf(" Target: %s\n", symlink_buf);
} else {
/* Call the callback here, because it's non-fatal */
if (p->cb_error)
(p->cb_error) (ENOMEM, 0, p->err_refcon,
"Out of memory reading symlink");
if ((r = xfskip(X, v->size)))
return r;
}
break;
case vDirectory:
if (p->cb_dirent || (p->print_flags & DSPRINT_DIR)) {
if ((r = parse_directory(X, p, v, v->size, 0)))
return r;
break;
}
default:
if ((r = xfskip(X, v->size)))
return r;
}
} else if (p->print_flags & DSPRINT_VNODE) {
printf("%sEmpty\n", field->label);
}
if (p->repair_flags & DSFIX_VDSYNC) {
r = resync_vnode(X, p, v, 10, 15);
if (r)
return r;
}
return ReadByte(X, tag);
}
/* Parse a VNode, including any tagged attributes and data, and call the
* appropriate callback, if one is defined.
*/
afs_uint32
parse_vnode(XFILE * X, unsigned char *tag, tagged_field * field,
afs_uint32 value, tag_parse_info * pi, void *g_refcon,
void *l_refcon)
{
dump_parser *p = (dump_parser *) g_refcon;
afs_uint32(*cb) (afs_vnode *, XFILE *, void *);
dt_uint64 where, offset2k;
afs_vnode v;
afs_uint32 r;
if ((r = xftell(X, &where)))
return r;
memset(&v, 0, sizeof(v));
sub64_32(v.offset, where, 1);
if ((r = ReadInt32(X, &v.vnode)))
return r;
if ((r = ReadInt32(X, &v.vuniq)))
return r;
mk64(offset2k, 0, 2048);
if (!LastGoodVNode
|| ((p->flags & DSFLAG_SEEK) && v.vnode == 1
&& lt64(v.offset, offset2k)))
LastGoodVNode = -1;
if (p->print_flags & DSPRINT_ITEM) {
printf("%s %d/%d [%s = 0x%s]\n", field->label, v.vnode, v.vuniq,
decimate_int64(&where, 0), hexify_int64(&where, 0));
}
r = ParseTaggedData(X, vnode_fields, tag, pi, g_refcon, (void *)&v);
/* Try to resync, if requested */
if (!r && (p->repair_flags & DSFIX_VFSYNC)) {
afs_uint32 drop;
dt_uint64 xwhere;
if ((r = xftell(X, &where)))
return r;
sub64_32(xwhere, where, 1);
/* Are we at the start of a valid vnode (or dump end)? */
r = match_next_vnode(X, p, &xwhere, v.vnode);
if (r && r != DSERR_FMT)
return r;
if (r) { /* Nope. */
/* Was _this_ a valid vnode? If so, we can keep it and search for
* the next one. Otherwise, we throw it out, and start the search
* at the starting point of this vnode.
*/
drop = r = match_next_vnode(X, p, &v.offset, LastGoodVNode);
if (r && r != DSERR_FMT)
return r;
if (!r) {
add64_32(where, v.offset, 1);
if ((r = xfseek(X, &v.offset)))
return r;
} else {
if ((r = xfseek(X, &xwhere)))
return r;
}
if ((r = resync_vnode(X, p, &v, 0, 1024)))
return r;
if ((r = ReadByte(X, tag)))
return r;
if (drop) {
if (p->cb_error)
(p->cb_error) (DSERR_FMT, 0, p->err_refcon,
"Dropping vnode %d", v.vnode);
return 0;
}
} else {
if ((r = xfseek(X, &where)))
return r;
}
}
LastGoodVNode = v.vnode;
if (!r) {
if (v.field_mask & F_VNODE_TYPE)
switch (v.type) {
case vFile:
cb = p->cb_vnode_file;
break;
case vDirectory:
cb = p->cb_vnode_dir;
break;
case vSymlink:
cb = p->cb_vnode_link;
break;
default:
cb = p->cb_vnode_wierd;
break;
} else
cb = p->cb_vnode_empty;
if (cb) {
dt_uint64 where;
if ((r = xftell(X, &where)))
return r;
r = (cb) (&v, X, p->refcon);
if (p->flags & DSFLAG_SEEK) {
if (!r)
r = xfseek(X, &where);
else
xfseek(X, &where);
}
}
}
return r;
}
void read_jpg_info(integer img)
{
int i, units = 0;
unsigned char jpg_id[] = "JFIF";
img_xres(img) = img_yres(img) = 0;
jpg_ptr(img)->file = xfopen(img_name(img), FOPEN_RBIN_MODE);
/* no LFS needed, as JPEG is limited to <4GiB */
xfseek(jpg_ptr(img)->file, 0, SEEK_END, cur_file_name);
jpg_ptr(img)->length = xftell(jpg_ptr(img)->file, cur_file_name);
xfseek(jpg_ptr(img)->file, 0, SEEK_SET, cur_file_name);
if (read2bytes(jpg_ptr(img)->file) != 0xFFD8)
pdftex_fail("reading JPEG image failed (no JPEG header found)");
/* currently only true JFIF files allow extracting img_xres and img_yres */
if (read2bytes(jpg_ptr(img)->file) == 0xFFE0) { /* check for JFIF */
(void) read2bytes(jpg_ptr(img)->file);
for (i = 0; i < 5; i++) {
if (xgetc(jpg_ptr(img)->file) != jpg_id[i])
break;
}
if (i == 5) { /* it's JFIF */
read2bytes(jpg_ptr(img)->file);
units = xgetc(jpg_ptr(img)->file);
img_xres(img) = read2bytes(jpg_ptr(img)->file);
img_yres(img) = read2bytes(jpg_ptr(img)->file);
switch (units) {
case 1:
break; /* pixels per inch */
case 2:
img_xres(img) *= 2.54;
img_yres(img) *= 2.54;
break; /* pixels per cm */
default:
img_xres(img) = img_yres(img) = 0;
break;
}
}
}
xfseek(jpg_ptr(img)->file, 0, SEEK_SET, cur_file_name);
while (1) {
if (feof(jpg_ptr(img)->file))
pdftex_fail("reading JPEG image failed (premature file end)");
if (fgetc(jpg_ptr(img)->file) != 0xFF)
pdftex_fail("reading JPEG image failed (no marker found)");
switch (xgetc(jpg_ptr(img)->file)) {
case M_SOF5:
case M_SOF6:
case M_SOF7:
case M_SOF9:
case M_SOF10:
case M_SOF11:
case M_SOF13:
case M_SOF14:
case M_SOF15:
pdftex_fail("unsupported type of compression");
case M_SOF2:
if (fixedpdfminorversion <= 2)
pdftex_fail("cannot use progressive DCT with PDF-1.2");
case M_SOF0:
case M_SOF1:
case M_SOF3:
(void) read2bytes(jpg_ptr(img)->file); /* read segment length */
jpg_ptr(img)->bits_per_component = xgetc(jpg_ptr(img)->file);
img_height(img) = read2bytes(jpg_ptr(img)->file);
img_width(img) = read2bytes(jpg_ptr(img)->file);
jpg_ptr(img)->color_space = xgetc(jpg_ptr(img)->file);
xfseek(jpg_ptr(img)->file, 0, SEEK_SET, cur_file_name);
switch (jpg_ptr(img)->color_space) {
case JPG_GRAY:
img_color(img) = IMAGE_COLOR_B;
break;
case JPG_RGB:
img_color(img) = IMAGE_COLOR_C;
break;
case JPG_CMYK:
img_color(img) = IMAGE_COLOR_C;
break;
default:
pdftex_fail("Unsupported color space %i",
(int) jpg_ptr(img)->color_space);
}
return;
case M_SOI: /* ignore markers without parameters */
case M_EOI:
case M_TEM:
case M_RST0:
case M_RST1:
case M_RST2:
case M_RST3:
case M_RST4:
case M_RST5:
case M_RST6:
case M_RST7:
break;
default: /* skip variable length markers */
xfseek(jpg_ptr(img)->file, read2bytes(jpg_ptr(img)->file) - 2,
SEEK_CUR, cur_file_name);
break;
}
}
}
/* Main program */
int
main(int argc, char **argv)
{
XFILE input_file;
afs_uint32 r;
parse_options(argc, argv);
initialize_acfg_error_table();
initialize_AVds_error_table();
initialize_rxk_error_table();
initialize_u_error_table();
initialize_vl_error_table();
initialize_vols_error_table();
initialize_xFil_error_table();
r = xfopen(&input_file, O_RDONLY, input_path);
if (r) {
afs_com_err(argv0, r, "opening %s", input_path);
exit(2);
}
memset(&dp, 0, sizeof(dp));
dp.cb_error = my_error_cb;
if (input_file.is_seekable)
dp.flags |= DSFLAG_SEEK;
dirs_done = 0;
if (!use_vnum) {
dt_uint64 where;
memset(&phi, 0, sizeof(phi));
phi.p = &dp;
if (verbose)
printf("* Building pathname info...\n");
if ((r = xftell(&input_file, &where))
|| (r = Path_PreScan(&input_file, &phi, 1))
|| (r = xfseek(&input_file, &where))) {
afs_com_err(argv0, r, "- path initialization failed");
xfclose(&input_file);
exit(1);
}
}
dp.cb_vnode_dir = directory_cb;
dp.cb_vnode_file = file_cb;
dp.cb_vnode_link = symlink_cb;
dp.cb_vnode_empty = lose_cb;
dp.cb_vnode_wierd = lose_cb;
if (do_headers) {
dp.cb_dumphdr = dumphdr_cb;
dp.cb_volhdr = volhdr_cb;
}
if (!nomode) {
mkdir(target, 0755);
if (chdir(target)) {
fprintf(stderr, "chdir %s failed: %s\n", target, strerror(errno));
exit(1);
}
}
r = ParseDumpFile(&input_file, &dp);
if (verbose && error_count)
fprintf(stderr, "*** %d errors\n", error_count);
if (r && !quiet)
fprintf(stderr, "*** FAILED: %s\n", afs_error_message(r));
exit(0);
}
static afs_uint32
symlink_cb(afs_vnode * v, XFILE * X, void *refcon)
{
char *vnodepath, *linktarget, vnpx[30];
dt_uint64 where;
int r, use = 0;
if (!dirs_done) {
dirs_done = 1;
if (verbose)
printf("* Extracting files...\n");
}
/* Should we even use this? */
if (!use_vnum) {
if ((r = Path_Build(X, &phi, v->vnode, &vnodepath, !use_realpath)))
return r;
if (!(use = usevnode(X, v->vnode, vnodepath))) {
free(vnodepath);
return 0;
}
if (use == 2) {
free(vnodepath);
sprintf(vnpx, "#%d:%d", v->vnode, v->vuniq);
vnodepath = vnpx;
}
} else {
sprintf(vnpx, "#%d:%d", v->vnode, v->vuniq);
vnodepath = vnpx;
}
if (!(linktarget = malloc(v->size + 1))) {
if (vnodepath != vnpx)
free(vnodepath);
return DSERR_MEM;
}
if ((r = xftell(X, &where))
|| (r = xfseek(X, &v->d_offset))
|| (r = xfread(X, linktarget, v->size))) {
if (vnodepath != vnpx)
free(vnodepath);
free(linktarget);
return r;
}
xfseek(X, &where);
linktarget[v->size] = 0;
/* Print it out */
if (verbose)
printf("l%s %3d %-11d %11d %s %s -> %s\n", modestr(v->mode),
v->nlinks, v->owner, v->size, datestr(v->server_date),
vnodepath, linktarget);
else if (!quiet)
printf("%s\n", vnodepath);
r = 0;
if (!nomode) {
if (symlink(linktarget, vnodepath + 1))
r = errno;
}
free(linktarget);
if (vnodepath != vnpx)
free(vnodepath);
return r;
}
/* Main program */
void
main(int argc, char **argv)
{
XFILE *X;
afs_uint32 r;
parse_options(argc, argv);
initialize_UB_error_table();
initialize_UBsp_error_table();
initialize_AVds_error_table();
r = xfopen(&X, input_path, O_RDONLY, 0);
if (r) {
afs_com_err(argv0, r, "opening %s", input_path);
exit(2);
}
bzero(&dp, sizeof(dp));
dp.cb_error = my_error_cb;
dp.repair_flags = repairflags;
if (X->is_seekable)
dp.flags |= DSFLAG_SEEK;
else {
if (repairflags)
fprintf(stderr,
"Repair modes available only for seekable dumps\n");
if (printflags & DSPRINT_PATH)
fprintf(stderr,
"Path-printing available only for seekable dumps\n");
if (repairflags || (printflags & DSPRINT_PATH))
exit(1);
}
if (gendump_path && (r = setup_repair())) {
afs_com_err(argv0, r, "setting up repair output");
xfclose(X);
exit(2);
}
if (printflags & DSPRINT_PATH) {
u_int64 where;
dp.print_flags = printflags & DSPRINT_DEBUG;
bzero(&phi, sizeof(phi));
phi.p = &dp;
if ((r = xftell(X, &where))
|| (r = Path_PreScan(X, &phi, 0))
|| (r = xfseek(X, &where))) {
afs_com_err(argv0, r, "- path initialization failed");
xfclose(X);
exit(2);
}
dp.cb_vnode_dir = print_vnode_path;
dp.cb_vnode_file = print_vnode_path;
dp.cb_vnode_link = print_vnode_path;
dp.cb_vnode_empty = print_vnode_path;
dp.cb_vnode_wierd = print_vnode_path;
}
if (add_admin) {
dp.cb_vnode_dir = munge_admin_acl;
}
dp.print_flags = printflags;
r = ParseDumpFile(X, &dp);
if (gendump_path) {
if (!r)
r = DumpDumpEnd(&repair_output);
if (!r)
r = xfclose(&repair_output);
else
xfclose(&repair_output);
}
if (verbose && error_count)
fprintf(stderr, "*** %d errors\n", error_count);
if (r && !quiet)
fprintf(stderr, "*** FAILED: %s\n", afs_error_message(r));
exit(0);
}
/* Parse a stage backup header.
* If tag is non-NULL, *tag should contain the first byte (already read),
* and will be filled in with the first byte after the header, if one exists.
* On success, returns 0 and leaves us positioned after the header
* On failure, returns an error and position is undefined
* Iff there is no header, returns DSERR_MAGIC and leaves us
* positioned where we started.
*/
afs_uint32
ParseStageHdr(XFILE * X, unsigned char *tag, backup_system_header * hdr)
{
char buf[STAGE_HDRLEN];
struct stage_header *bckhdr = (struct stage_header *)buf;
u_int64 where;
afs_int32 r;
if ((r = xftell(X, &where)))
return r;
if (hdr)
memset(hdr, 0, sizeof(*hdr));
if (tag) {
if (*tag != STAGE_VERSMIN)
return DSERR_MAGIC;
buf[0] = *tag;
r = xfread(X, buf + 1, STAGE_HDRLEN - 1);
} else {
r = xfread(X, buf, STAGE_HDRLEN);
}
if (r == ERROR_XFILE_EOF) {
r = xfseek(X, &where);
return r ? r : DSERR_MAGIC;
} else if (r)
return r;
if (bckhdr->c_vers < STAGE_VERSMIN
|| ntohl(bckhdr->c_magic) != STAGE_MAGIC
|| hdr_checksum(buf, STAGE_HDRLEN) != STAGE_CHECKSUM) {
r = xfseek(X, &where);
return r ? r : DSERR_MAGIC;
}
if (hdr) {
hdr->version = bckhdr->c_vers;
hdr->from_date = ntohl(bckhdr->c_fdate);
hdr->to_date = ntohl(bckhdr->c_tdate);
hdr->dump_date = ntohl(bckhdr->c_time);
hdr->filenum = ntohl(bckhdr->c_filenum);
hdr->volid = ntohl(bckhdr->c_id);
#ifdef NATIVE_INT64
hdr->dumplen = ntohl(bckhdr->c_length);
#else
hdr->dumplen.hi = 0;
hdr->dumplen.lo = ntohl(bckhdr->c_length);
#endif
hdr->level = ntohl(bckhdr->c_level);
hdr->magic = ntohl(bckhdr->c_magic);
hdr->cksum = ntohl(bckhdr->c_checksum);
hdr->flags = ntohl(bckhdr->c_flags);
hdr->server = malloc(strlen(bckhdr->c_host) + 1);
hdr->part = malloc(strlen(bckhdr->c_disk) + 1);
hdr->volname = malloc(strlen(bckhdr->c_name) + 1);
if (!hdr->server || !hdr->part || !hdr->volname) {
if (hdr->server)
free(hdr->server);
if (hdr->part)
free(hdr->part);
if (hdr->volname)
free(hdr->volname);
return ENOMEM;
}
strcpy((char *)hdr->server, bckhdr->c_host);
strcpy((char *)hdr->part, bckhdr->c_disk);
strcpy((char *)hdr->volname, bckhdr->c_name);
}
if (tag)
return ReadByte(X, tag);
else
return 0;
}