int send_file(struct asfd *asfd, FF_PKT *ff, bool top_level, struct conf *conf) { static struct sbuf *sb=NULL; if(!sb && !(sb=sbuf_alloc(conf))) return -1; if(!file_is_included(conf, ff->fname, top_level)) return 0; #ifdef HAVE_WIN32 if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED) { if(ff->type==FT_REG || ff->type==FT_DIR) return to_server(asfd, conf, ff, sb, CMD_EFS_FILE); return logw(asfd, conf, "EFS type %d not yet supported: %s", ff->type, ff->fname); } #endif switch(ff->type) { case FT_REG: case FT_RAW: case FT_FIFO: return do_to_server(asfd, conf, ff, sb, filesymbol, in_exclude_comp(conf->excom, ff->fname, conf->compression)); case FT_DIR: case FT_REPARSE: case FT_JUNCTION: return to_server(asfd, conf, ff, sb, dirsymbol); case FT_LNK_S: return to_server(asfd, conf, ff, sb, CMD_SOFT_LINK); case FT_LNK_H: return to_server(asfd, conf, ff, sb, CMD_HARD_LINK); case FT_SPEC: return to_server(asfd, conf, ff, sb, CMD_SPECIAL); case FT_NOFSCHG: return logw(asfd, conf, "Dir: %s [will not descend: " "file system change not allowed]\n", ff->fname); case FT_NOFOLLOW: return ft_err(asfd, conf, ff, "Could not follow link"); case FT_NOSTAT: return ft_err(asfd, conf, ff, "Could not stat"); case FT_NOOPEN: return ft_err(asfd, conf, ff, "Could not open directory"); default: return logw(asfd, conf, _("Err: Unknown file type %d: %s"), ff->type, ff->fname); } }
/* * 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; }
/* * 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; }
// Last checks before actually processing the file system entry. int send_file_w(struct asfd *asfd, FF_PKT *ff, bool top_level, struct conf **confs) { if(!file_is_included(confs, ff->fname, top_level)) return 0; // Doing the file size match here also catches hard links. if(S_ISREG(ff->statp.st_mode) && !file_size_match(ff, confs)) return 0; /* * Handle hard linked files * Maintain a list of hard linked files already backed up. This * allows us to ensure that the data of each file gets backed * up only once. */ if(ff->statp.st_nlink > 1 && (S_ISREG(ff->statp.st_mode) || S_ISCHR(ff->statp.st_mode) || S_ISBLK(ff->statp.st_mode) || S_ISFIFO(ff->statp.st_mode) || S_ISSOCK(ff->statp.st_mode))) { struct f_link *lp; struct f_link **bucket=NULL; if((lp=linkhash_search(&ff->statp, &bucket))) { if(!strcmp(lp->name, ff->fname)) return 0; ff->link=lp->name; /* Handle link, file already saved */ ff->type=FT_LNK_H; } else { if(linkhash_add(ff->fname, &ff->statp, bucket)) return -1; } } return send_file(asfd, ff, confs); }
/* * 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; }
int send_file(FF_PKT *ff, bool top_level, struct config *conf, struct cntr *p1cntr) { char msg[128]=""; char attribs[MAXSTRING]; if(!file_is_included(conf->incexcdir, conf->iecount, conf->incext, conf->incount, conf->excext, conf->excount, conf->increg, conf->ircount, conf->excreg, conf->ercount, ff->fname, top_level)) return 0; #ifdef HAVE_WIN32 // Useful Windows attributes debug /* printf("\n%llu", ff->winattr); printf("\n%s\n", ff->fname); if(ff->winattr & FILE_ATTRIBUTE_READONLY) printf("readonly\n"); if(ff->winattr & FILE_ATTRIBUTE_HIDDEN) printf("hidden\n"); if(ff->winattr & FILE_ATTRIBUTE_SYSTEM) printf("system\n"); if(ff->winattr & FILE_ATTRIBUTE_DIRECTORY) printf("directory\n"); if(ff->winattr & FILE_ATTRIBUTE_ARCHIVE) printf("archive\n"); if(ff->winattr & FILE_ATTRIBUTE_DEVICE) printf("device\n"); if(ff->winattr & FILE_ATTRIBUTE_NORMAL) printf("normal\n"); if(ff->winattr & FILE_ATTRIBUTE_TEMPORARY) printf("temporary\n"); if(ff->winattr & FILE_ATTRIBUTE_SPARSE_FILE) printf("sparse\n"); if(ff->winattr & FILE_ATTRIBUTE_REPARSE_POINT) printf("reparse\n"); if(ff->winattr & FILE_ATTRIBUTE_COMPRESSED) printf("compressed\n"); if(ff->winattr & FILE_ATTRIBUTE_OFFLINE) printf("offline\n"); if(ff->winattr & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) printf("notcont\n"); if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED) printf("encrypted\n"); if(ff->winattr & FILE_ATTRIBUTE_VIRTUAL) printf("virtual\n"); */ if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED) { // if(ff->type!=FT_DIREND) // logw(p1cntr, "EFS not yet supported: %s", ff->fname); // return 0; if(ff->type==FT_REGE || ff->type==FT_REG || ff->type==FT_DIRBEGIN) { encode_stat(attribs, &ff->statp, ff->winattr, conf->compression); if(async_write_str(CMD_STAT, attribs) || async_write_str(CMD_EFS_FILE, ff->fname)) return -1; do_filecounter(p1cntr, CMD_EFS_FILE, 1); if(ff->type==FT_REG) do_filecounter_bytes(p1cntr, (unsigned long long)ff->statp.st_size); return 0; } else if(ff->type==FT_DIREND) return 0; else { // Hopefully, here is never reached. logw(p1cntr, "EFS type %d not yet supported: %s", ff->type, ff->fname); return 0; } } #endif //logp("%d: %s\n", ff->type, ff->fname); switch (ff->type) { case FT_LNKSAVED: //printf("Lnka: %s -> %s\n", ff->fname, ff->link); encode_stat(attribs, &ff->statp, ff->winattr, conf->compression); if(async_write_str(CMD_STAT, attribs) || async_write_str(CMD_HARD_LINK, ff->fname) || async_write_str(CMD_HARD_LINK, ff->link)) return -1; do_filecounter(p1cntr, CMD_HARD_LINK, 1); // At least FreeBSD 8.2 can have different xattrs on hard links. if(maybe_send_extrameta(ff->fname, CMD_HARD_LINK, attribs, p1cntr)) return -1; break; case FT_FIFO: case FT_REGE: case FT_REG: encode_stat(attribs, &ff->statp, ff->winattr, in_exclude_comp(conf->excom, conf->excmcount, ff->fname, conf->compression)); if(async_write_str(CMD_STAT, attribs) || async_write_str(filesymbol, ff->fname)) return -1; do_filecounter(p1cntr, filesymbol, 1); if(ff->type==FT_REG) do_filecounter_bytes(p1cntr, (unsigned long long)ff->statp.st_size); if(maybe_send_extrameta(ff->fname, filesymbol, attribs, p1cntr)) return -1; break; case FT_LNK: //printf("link: %s -> %s\n", ff->fname, ff->link); encode_stat(attribs, &ff->statp, ff->winattr, conf->compression); if(async_write_str(CMD_STAT, attribs) || async_write_str(CMD_SOFT_LINK, ff->fname) || async_write_str(CMD_SOFT_LINK, ff->link)) return -1; do_filecounter(p1cntr, CMD_SOFT_LINK, 1); if(maybe_send_extrameta(ff->fname, CMD_SOFT_LINK, attribs, p1cntr)) return -1; break; case FT_DIREND: return 0; case FT_NOFSCHG: case FT_DIRBEGIN: case FT_REPARSE: case FT_JUNCTION: { char errmsg[100] = ""; if (ff->type == FT_NOFSCHG) snprintf(errmsg, sizeof(errmsg), _("\t[will not descend: file system change not allowed]")); if(*errmsg) { snprintf(msg, sizeof(msg), "%s%s%s\n", "Dir: ", ff->fname, errmsg); logw(p1cntr, "%s", msg); } else { encode_stat(attribs, &ff->statp, ff->winattr, conf->compression); if(async_write_str(CMD_STAT, attribs)) return -1; #if defined(WIN32_VSS) if(async_write_str(filesymbol, ff->fname)) return -1; do_filecounter(p1cntr, filesymbol, 1); #else if(async_write_str(CMD_DIRECTORY, ff->fname)) return -1; do_filecounter(p1cntr, CMD_DIRECTORY, 1); if(maybe_send_extrameta(ff->fname, CMD_DIRECTORY, attribs, p1cntr)) return -1; #endif } } break; case FT_SPEC: // special file - fifo, socket, device node... encode_stat(attribs, &ff->statp, ff->winattr, conf->compression); if(async_write_str(CMD_STAT, attribs) || async_write_str(CMD_SPECIAL, ff->fname)) return -1; do_filecounter(p1cntr, CMD_SPECIAL, 1); if(maybe_send_extrameta(ff->fname, CMD_SPECIAL, attribs, p1cntr)) return -1; break; case FT_NOACCESS: logw(p1cntr, _("Err: Could not access %s: %s"), ff->fname, strerror(errno)); break; case FT_NOFOLLOW: logw(p1cntr, _("Err: Could not follow ff->link %s: %s"), ff->fname, strerror(errno)); break; case FT_NOSTAT: logw(p1cntr, _("Err: Could not stat %s: %s"), ff->fname, strerror(errno)); break; case FT_NOCHG: logw(p1cntr, _("Skip: File not saved. No change. %s"), ff->fname); break; case FT_ISARCH: logw(p1cntr, _("Err: Attempt to backup archive. Not saved. %s"), ff->fname); break; case FT_NOOPEN: logw(p1cntr, _("Err: Could not open directory %s: %s"), ff->fname, strerror(errno)); break; case FT_RAW: logw(p1cntr, _("Err: Raw partition: %s"), ff->fname); break; default: logw(p1cntr, _("Err: Unknown file ff->type %d: %s"), ff->type, ff->fname); break; } return 0; }