static int result_handler(void *ctx, int fields, char **row)
{
Bvfs *vfs = (Bvfs *)ctx;
ATTR *attr = vfs->get_attr();
char empty[] = "A A A A A A A A A A A A A A";
memset(&attr->statp, 0, sizeof(struct stat));
decode_stat((row[BVFS_LStat] && row[BVFS_LStat][0])?row[BVFS_LStat]:empty,
&attr->statp, sizeof(attr->statp), &attr->LinkFI);
if (bvfs_is_dir(row) || bvfs_is_file(row)) {
/* display clean stuffs */
if (bvfs_is_dir(row)) {
pm_strcpy(attr->ofname, bvfs_basename_dir(row[BVFS_Name]));
} else {
/* if we see the requested file, note his filenameid */
if (bstrcmp(row[BVFS_Name], file)) {
fnid = str_to_int64(row[BVFS_FilenameId]);
}
pm_strcpy(attr->ofname, row[BVFS_Name]);
}
print_ls_output(vfs->get_jcr(), attr);
} else {
Pmsg5(0, "JobId=%s FileId=%s\tMd5=%s\tVolName=%s\tVolInChanger=%s\n",
row[BVFS_JobId], row[BVFS_FileId], row[BVFS_Md5], row[BVFS_VolName],
row[BVFS_VolInchanger]);
pm_strcpy(attr->ofname, file);
print_ls_output(vfs->get_jcr(), attr);
}
return 0;
}
/*
* Called here by find() for each file included.
*
*/
static int tally_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
{
ATTR attr;
if (job_canceled(jcr)) {
return 0;
}
switch (ff_pkt->type) {
case FT_LNKSAVED: /* Hard linked, file already saved */
case FT_REGE:
case FT_REG:
case FT_LNK:
case FT_NORECURSE:
case FT_NOFSCHG:
case FT_INVALIDFS:
case FT_INVALIDDT:
case FT_REPARSE:
case FT_JUNCTION:
case FT_DIREND:
case FT_SPEC:
case FT_RAW:
case FT_FIFO:
break;
case FT_DIRBEGIN:
case FT_NOACCESS:
case FT_NOFOLLOW:
case FT_NOSTAT:
case FT_DIRNOCHG:
case FT_NOCHG:
case FT_ISARCH:
case FT_NOOPEN:
default:
return 1;
}
if (ff_pkt->type != FT_LNKSAVED && S_ISREG(ff_pkt->statp.st_mode)) {
if (ff_pkt->statp.st_size > 0) {
jcr->JobBytes += ff_pkt->statp.st_size;
}
#ifdef HAVE_DARWIN_OS
if (ff_pkt->flags & FO_HFSPLUS) {
if (ff_pkt->hfsinfo.rsrclength > 0) {
jcr->JobBytes += ff_pkt->hfsinfo.rsrclength;
}
jcr->JobBytes += 32; /* Finder info */
}
#endif
}
jcr->num_files_examined++;
jcr->JobFiles++; /* increment number of files seen */
if (jcr->listing) {
memcpy(&attr.statp, &ff_pkt->statp, sizeof(struct stat));
attr.type = ff_pkt->type;
attr.ofname = (POOLMEM *)ff_pkt->fname;
attr.olname = (POOLMEM *)ff_pkt->link;
print_ls_output(jcr, &attr);
}
return 1;
}
/*
* Called here for each record from read_records()
*/
static bool record_cb(DCR *dcr, DEV_RECORD *rec)
{
if (rec->FileIndex < 0) {
get_session_record(dev, rec, &sessrec);
return true;
}
/*
* File Attributes stream
*/
switch (rec->maskedStream) {
case STREAM_UNIX_ATTRIBUTES:
case STREAM_UNIX_ATTRIBUTES_EX:
if (!unpack_attributes_record(jcr, rec->Stream, rec->data, rec->data_len, attr)) {
if (!forge_on) {
Emsg0(M_ERROR_TERM, 0, _("Cannot continue.\n"));
} else {
Emsg0(M_ERROR, 0, _("Attrib unpack error!\n"));
}
num_files++;
return true;
}
attr->data_stream = decode_stat(attr->attr, &attr->statp, sizeof(attr->statp), &attr->LinkFI);
build_attr_output_fnames(jcr, attr);
if (file_is_included(ff, attr->fname) && !file_is_excluded(ff, attr->fname)) {
if (verbose) {
Pmsg5(-1, _("FileIndex=%d VolSessionId=%d VolSessionTime=%d Stream=%d DataLen=%d\n"),
rec->FileIndex, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
}
print_ls_output(jcr, attr);
num_files++;
}
break;
case STREAM_PLUGIN_NAME: {
char data[100];
int len = MIN(rec->data_len+1, sizeof(data));
bstrncpy(data, rec->data, len);
Pmsg1(000, "Plugin data: %s\n", data);
break;
}
case STREAM_RESTORE_OBJECT:
Pmsg0(000, "Restore Object record\n");
break;
default:
break;
}
return true;
}
/*
* Called here for each record from read_records()
*/
static bool record_cb(DCR *dcr, DEV_RECORD *rec)
{
if (verbose && rec->FileIndex < 0) {
dump_label_record(dcr->dev, rec, verbose);
return true;
}
if (verbose) {
char buf1[100], buf2[100];
Pmsg6(000, "Record: FI=%s SessId=%d Strm=%s len=%u remlen=%d data_len=%d\n",
FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_bytes, rec->remlen,
rec->data_len);
}
/* File Attributes stream */
if (rec->maskedStream == STREAM_UNIX_ATTRIBUTES ||
rec->maskedStream == STREAM_UNIX_ATTRIBUTES_EX) {
if (!unpack_attributes_record(jcr, rec->Stream, rec->data, rec->data_len, attr)) {
if (!forge_on) {
Emsg0(M_ERROR_TERM, 0, _("Cannot continue.\n"));
} else {
Emsg0(M_ERROR, 0, _("Attrib unpack error!\n"));
}
num_files++;
return true;
}
attr->data_stream = decode_stat(attr->attr, &attr->statp, sizeof(attr->statp), &attr->LinkFI);
build_attr_output_fnames(jcr, attr);
if (file_is_included(ff, attr->fname) && !file_is_excluded(ff, attr->fname)) {
if (verbose) {
Pmsg5(000, _("FileIndex=%d VolSessionId=%d VolSessionTime=%d Stream=%d DataLen=%d\n"),
rec->FileIndex, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
}
print_ls_output(jcr, attr);
num_files++;
}
} else if (rec->Stream == STREAM_PLUGIN_NAME) {
char data[100];
int len = MIN(rec->data_len+1, sizeof(data));
bstrncpy(data, rec->data, len);
Dmsg1(100, "Plugin data: %s\n", data);
} else if (rec->Stream == STREAM_RESTORE_OBJECT) {
Dmsg0(100, "Restore Object record\n");
}
return true;
}
static int print_file(JCR *jcr, FF_PKT *ff, bool top_level)
{
switch (ff->type) {
case FT_LNKSAVED:
case FT_REGE:
case FT_REG:
case FT_LNK:
case FT_DIREND:
case FT_SPEC:
print_ls_output(ff->fname, ff->link, ff->type, &ff->statp);
break;
case FT_DIRBEGIN:
break;
case FT_NOACCESS:
printf(_("Err: Could not access %s: %s\n"), ff->fname, strerror(errno));
break;
case FT_NOFOLLOW:
printf(_("Err: Could not follow ff->link %s: %s\n"), ff->fname, strerror(errno));
break;
case FT_NOSTAT:
printf(_("Err: Could not stat %s: %s\n"), ff->fname, strerror(errno));
break;
case FT_NOCHG:
printf(_("Skip: File not saved. No change. %s\n"), ff->fname);
break;
case FT_ISARCH:
printf(_("Err: Attempt to backup archive. Not saved. %s\n"), ff->fname);
break;
case FT_NORECURSE:
printf(_("Recursion turned off. Directory not entered. %s\n"), ff->fname);
break;
case FT_NOFSCHG:
printf(_("Skip: File system change prohibited. Directory not entered. %s\n"), ff->fname);
break;
case FT_NOOPEN:
printf(_("Err: Could not open directory %s: %s\n"), ff->fname, strerror(errno));
break;
default:
printf(_("Err: Unknown file ff->type %d: %s\n"), ff->type, ff->fname);
break;
}
num_files++;
return 1;
}
/*
* Called here for each record from read_records()
*/
static bool record_cb(DCR *dcr, DEV_RECORD *rec)
{
if (rec->FileIndex < 0) {
get_session_record(dev, rec, &sessrec);
return true;
}
/* File Attributes stream */
if (rec->Stream == STREAM_UNIX_ATTRIBUTES ||
rec->Stream == STREAM_UNIX_ATTRIBUTES_EX) {
if (!unpack_attributes_record(jcr, rec->Stream, rec->data, attr)) {
if (!forge_on) {
Emsg0(M_ERROR_TERM, 0, _("Cannot continue.\n"));
}
num_files++;
return true;
}
if (attr->file_index != rec->FileIndex) {
Emsg2(forge_on?M_WARNING:M_ERROR_TERM, 0, _("Record header file index %ld not equal record index %ld\n"),
rec->FileIndex, attr->file_index);
}
attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
build_attr_output_fnames(jcr, attr);
if (file_is_included(ff, attr->fname) && !file_is_excluded(ff, attr->fname)) {
if (verbose) {
Pmsg5(-1, _("FileIndex=%d VolSessionId=%d VolSessionTime=%d Stream=%d DataLen=%d\n"),
rec->FileIndex, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
}
print_ls_output(jcr, attr);
num_files++;
}
} else if (rec->Stream == STREAM_PLUGIN_NAME) {
if (strncmp("0 0", rec->data, 3) != 0) {
Pmsg1(000, "Plugin data: %s\n", rec->data);
}
}
return true;
}
/*
* Called here for each record from read_records()
*/
static bool record_cb(DCR *dcr, DEV_RECORD *rec)
{
int status;
JCR *jcr = dcr->jcr;
if (rec->FileIndex < 0) {
return true; /* we don't want labels */
}
/* File Attributes stream */
switch (rec->maskedStream) {
case STREAM_UNIX_ATTRIBUTES:
case STREAM_UNIX_ATTRIBUTES_EX:
/* If extracting, it was from previous stream, so
* close the output file.
*/
if (extract) {
if (!is_bopen(&bfd)) {
Emsg0(M_ERROR, 0, _("Logic error output file should be open but is not.\n"));
}
set_attributes(jcr, attr, &bfd);
extract = false;
}
if (!unpack_attributes_record(jcr, rec->Stream, rec->data, rec->data_len, attr)) {
Emsg0(M_ERROR_TERM, 0, _("Cannot continue.\n"));
}
if (file_is_included(ff, attr->fname) && !file_is_excluded(ff, attr->fname)) {
attr->data_stream = decode_stat(attr->attr, &attr->statp, sizeof(attr->statp), &attr->LinkFI);
if (!is_restore_stream_supported(attr->data_stream)) {
if (!non_support_data++) {
Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
stream_to_ascii(attr->data_stream));
}
extract = false;
return true;
}
build_attr_output_fnames(jcr, attr);
if (attr->type == FT_DELETED) { /* TODO: choose the right fname/ofname */
Jmsg(jcr, M_INFO, 0, _("%s was deleted.\n"), attr->fname);
extract = false;
return true;
}
extract = false;
status = create_file(jcr, attr, &bfd, REPLACE_ALWAYS);
switch (status) {
case CF_ERROR:
case CF_SKIP:
break;
case CF_EXTRACT:
extract = true;
print_ls_output(jcr, attr);
num_files++;
fileAddr = 0;
break;
case CF_CREATED:
set_attributes(jcr, attr, &bfd);
print_ls_output(jcr, attr);
num_files++;
fileAddr = 0;
break;
}
}
break;
case STREAM_RESTORE_OBJECT:
/* nothing to do */
break;
/* Data stream and extracting */
case STREAM_FILE_DATA:
case STREAM_SPARSE_DATA:
case STREAM_WIN32_DATA:
if (extract) {
if (rec->maskedStream == STREAM_SPARSE_DATA) {
ser_declare;
uint64_t faddr;
wbuf = rec->data + OFFSET_FADDR_SIZE;
wsize = rec->data_len - OFFSET_FADDR_SIZE;
ser_begin(rec->data, OFFSET_FADDR_SIZE);
unser_uint64(faddr);
if (fileAddr != faddr) {
fileAddr = faddr;
if (blseek(&bfd, (boffset_t)fileAddr, SEEK_SET) < 0) {
berrno be;
Emsg2(M_ERROR_TERM, 0, _("Seek error on %s: %s\n"),
attr->ofname, be.bstrerror());
}
}
} else {
wbuf = rec->data;
wsize = rec->data_len;
}
total += wsize;
Dmsg2(8, "Write %u bytes, total=%u\n", wsize, total);
store_data(&bfd, wbuf, wsize);
fileAddr += wsize;
}
break;
/* GZIP data stream */
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
case STREAM_WIN32_GZIP_DATA:
#ifdef HAVE_LIBZ
if (extract) {
uLong compress_len = compress_buf_size;
int status = Z_BUF_ERROR;
if (rec->maskedStream == STREAM_SPARSE_GZIP_DATA) {
ser_declare;
uint64_t faddr;
char ec1[50];
wbuf = rec->data + OFFSET_FADDR_SIZE;
wsize = rec->data_len - OFFSET_FADDR_SIZE;
ser_begin(rec->data, OFFSET_FADDR_SIZE);
unser_uint64(faddr);
if (fileAddr != faddr) {
fileAddr = faddr;
if (blseek(&bfd, (boffset_t)fileAddr, SEEK_SET) < 0) {
berrno be;
Emsg3(M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
edit_uint64(fileAddr, ec1), attr->ofname, be.bstrerror());
extract = false;
return true;
}
}
} else {
wbuf = rec->data;
wsize = rec->data_len;
}
while (compress_len < 10000000 && (status = uncompress((Byte *)compress_buf, &compress_len,
(const Byte *)wbuf, (uLong)wsize)) == Z_BUF_ERROR) {
/* The buffer size is too small, try with a bigger one */
compress_len = 2 * compress_len;
compress_buf = check_pool_memory_size(compress_buf,
compress_len);
}
if (status != Z_OK) {
Emsg1(M_ERROR, 0, _("Uncompression error. ERR=%d\n"), status);
extract = false;
return true;
}
Dmsg2(100, "Write uncompressed %d bytes, total before write=%d\n", compress_len, total);
store_data(&bfd, compress_buf, compress_len);
total += compress_len;
fileAddr += compress_len;
Dmsg2(100, "Compress len=%d uncompressed=%d\n", rec->data_len,
compress_len);
}
#else
if (extract) {
Emsg0(M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
extract = false;
return true;
}
#endif
break;
/* Compressed data stream */
case STREAM_COMPRESSED_DATA:
case STREAM_SPARSE_COMPRESSED_DATA:
case STREAM_WIN32_COMPRESSED_DATA:
if (extract) {
uint32_t comp_magic, comp_len;
uint16_t comp_level, comp_version;
#ifdef HAVE_LZO
lzo_uint compress_len;
const unsigned char *cbuf;
int r, real_compress_len;
#endif
if (rec->maskedStream == STREAM_SPARSE_COMPRESSED_DATA) {
ser_declare;
uint64_t faddr;
char ec1[50];
wbuf = rec->data + OFFSET_FADDR_SIZE;
wsize = rec->data_len - OFFSET_FADDR_SIZE;
ser_begin(rec->data, OFFSET_FADDR_SIZE);
unser_uint64(faddr);
if (fileAddr != faddr) {
fileAddr = faddr;
if (blseek(&bfd, (boffset_t)fileAddr, SEEK_SET) < 0) {
berrno be;
Emsg3(M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
edit_uint64(fileAddr, ec1), attr->ofname, be.bstrerror());
extract = false;
return true;
}
}
} else {
wbuf = rec->data;
wsize = rec->data_len;
}
/* read compress header */
unser_declare;
unser_begin(wbuf, sizeof(comp_stream_header));
unser_uint32(comp_magic);
unser_uint32(comp_len);
unser_uint16(comp_level);
unser_uint16(comp_version);
Dmsg4(200, "Compressed data stream found: magic=0x%x, len=%d, level=%d, ver=0x%x\n", comp_magic, comp_len,
comp_level, comp_version);
/* version check */
if (comp_version != COMP_HEAD_VERSION) {
Emsg1(M_ERROR, 0, _("Compressed header version error. version=0x%x\n"), comp_version);
return false;
}
/* size check */
if (comp_len + sizeof(comp_stream_header) != wsize) {
Emsg2(M_ERROR, 0, _("Compressed header size error. comp_len=%d, msglen=%d\n"),
comp_len, wsize);
return false;
}
switch(comp_magic) {
#ifdef HAVE_LZO
case COMPRESS_LZO1X:
compress_len = compress_buf_size;
cbuf = (const unsigned char*) wbuf + sizeof(comp_stream_header);
real_compress_len = wsize - sizeof(comp_stream_header);
Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, wsize);
while ((r=lzo1x_decompress_safe(cbuf, real_compress_len,
(unsigned char *)compress_buf, &compress_len, NULL)) == LZO_E_OUTPUT_OVERRUN)
{
/* The buffer size is too small, try with a bigger one */
compress_len = 2 * compress_len;
compress_buf = check_pool_memory_size(compress_buf,
compress_len);
}
if (r != LZO_E_OK) {
Emsg1(M_ERROR, 0, _("LZO uncompression error. ERR=%d\n"), r);
extract = false;
return true;
}
Dmsg2(100, "Write uncompressed %d bytes, total before write=%d\n", compress_len, total);
store_data(&bfd, compress_buf, compress_len);
total += compress_len;
fileAddr += compress_len;
Dmsg2(100, "Compress len=%d uncompressed=%d\n", rec->data_len, compress_len);
break;
#endif
default:
Emsg1(M_ERROR, 0, _("Compression algorithm 0x%x found, but not supported!\n"), comp_magic);
extract = false;
return true;
}
}
break;
case STREAM_MD5_DIGEST:
case STREAM_SHA1_DIGEST:
case STREAM_SHA256_DIGEST:
case STREAM_SHA512_DIGEST:
break;
case STREAM_SIGNED_DIGEST:
case STREAM_ENCRYPTED_SESSION_DATA:
// TODO landonf: Investigate crypto support in the storage daemon
break;
case STREAM_PROGRAM_NAMES:
case STREAM_PROGRAM_DATA:
if (!prog_name_msg) {
Pmsg0(000, _("Got Program Name or Data Stream. Ignored.\n"));
prog_name_msg++;
}
break;
case STREAM_UNIX_ACCESS_ACL: /* Deprecated Standard ACL attributes on UNIX */
case STREAM_UNIX_DEFAULT_ACL: /* Deprecated Default ACL attributes on UNIX */
case STREAM_ACL_AIX_TEXT:
case STREAM_ACL_DARWIN_ACCESS_ACL:
case STREAM_ACL_FREEBSD_DEFAULT_ACL:
case STREAM_ACL_FREEBSD_ACCESS_ACL:
case STREAM_ACL_HPUX_ACL_ENTRY:
case STREAM_ACL_IRIX_DEFAULT_ACL:
case STREAM_ACL_IRIX_ACCESS_ACL:
case STREAM_ACL_LINUX_DEFAULT_ACL:
case STREAM_ACL_LINUX_ACCESS_ACL:
case STREAM_ACL_TRU64_DEFAULT_ACL:
case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
case STREAM_ACL_TRU64_ACCESS_ACL:
case STREAM_ACL_SOLARIS_ACLENT:
case STREAM_ACL_SOLARIS_ACE:
case STREAM_ACL_AFS_TEXT:
case STREAM_ACL_AIX_AIXC:
case STREAM_ACL_AIX_NFS4:
case STREAM_ACL_FREEBSD_NFS4_ACL:
case STREAM_ACL_HURD_DEFAULT_ACL:
case STREAM_ACL_HURD_ACCESS_ACL:
if (extract) {
wbuf = rec->data;
wsize = rec->data_len;
pm_strcpy(acl_data.last_fname, attr->fname);
parse_acl_streams(jcr, &acl_data, rec->maskedStream, wbuf, wsize);
}
break;
case STREAM_XATTR_HURD:
case STREAM_XATTR_IRIX:
case STREAM_XATTR_TRU64:
case STREAM_XATTR_AIX:
case STREAM_XATTR_OPENBSD:
case STREAM_XATTR_SOLARIS_SYS:
case STREAM_XATTR_SOLARIS:
case STREAM_XATTR_DARWIN:
case STREAM_XATTR_FREEBSD:
case STREAM_XATTR_LINUX:
case STREAM_XATTR_NETBSD:
if (extract) {
wbuf = rec->data;
wsize = rec->data_len;
pm_strcpy(xattr_data.last_fname, attr->fname);
parse_xattr_streams(jcr, &xattr_data, rec->maskedStream, wbuf, wsize);
}
break;
case STREAM_NDMP_SEPERATOR:
break;
default:
/* If extracting, weird stream (not 1 or 2), close output file anyway */
if (extract) {
if (!is_bopen(&bfd)) {
Emsg0(M_ERROR, 0, _("Logic error output file should be open but is not.\n"));
}
set_attributes(jcr, attr, &bfd);
extract = false;
}
Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"),
rec->Stream);
break;
} /* end switch */
return true;
}
