2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of John Walker.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
29 * Bacula File Daemon backup.c send file attributes and data
30 * to the Storage daemon.
32 * Kern Sibbald, March MM
40 #include "lib/htable.h"
42 /* Forward referenced functions */
43 int save_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level);
44 static void strip_path(FF_PKT *ff_pkt);
45 static void unstrip_path(FF_PKT *ff_pkt);
46 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest, DIGEST *signature_digest);
47 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream);
48 static bool read_and_send_acl(JCR *jcr, int acltype, int stream);
49 static bool crypto_session_start(JCR *jcr);
50 static void crypto_session_end(JCR *jcr);
51 static bool crypto_session_send(JCR *jcr, BSOCK *sd);
53 typedef struct CurFile {
60 #define accurate_mark_file_as_seen(elt) ((elt)->seen = 1)
61 #define accurate_file_has_been_seen(elt) ((elt)->seen)
64 * This function is called for each file seen in fileset.
65 * We check in file_list hash if fname have been backuped
66 * the last time. After we can compare Lstat field.
69 /* TODO: tweak verify code to use the same function ?? */
70 bool accurate_check_file(JCR *jcr, FF_PKT *ff_pkt)
74 struct stat statc; /* catalog stat */
81 if (*ff_pkt->VerifyOpts) { /* use mtime + ctime checks by default */
82 Opts_Digest = ff_pkt->VerifyOpts;
87 if (!jcr->accurate || jcr->JobLevel == L_FULL) {
93 if (S_ISDIR(ff_pkt->statp.st_mode)) {
96 fname = ff_pkt->fname;
99 elt = (CurFile *)jcr->file_list->lookup(fname);
102 Dmsg1(500, "accurate %s = yes (not found)\n", fname);
107 if (accurate_file_has_been_seen(elt)) {
108 Dmsg1(500, "accurate %s = no (already seen)\n", fname);
112 decode_stat(elt->lstat, &statc, &LinkFIc); /* decode catalog stat */
113 // *do_Digest = CRYPTO_DIGEST_NONE;
115 for (p=Opts_Digest; *p; p++) {
116 char ed1[30], ed2[30];
118 case 'i': /* compare INODEs */
119 if (statc.st_ino != ff_pkt->statp.st_ino) {
120 Jmsg(jcr, M_SAVED, 0, _("%s st_ino differ. Cat: %s File: %s\n"), fname,
121 edit_uint64((uint64_t)statc.st_ino, ed1),
122 edit_uint64((uint64_t)ff_pkt->statp.st_ino, ed2));
126 case 'p': /* permissions bits */
127 if (statc.st_mode != ff_pkt->statp.st_mode) {
128 Jmsg(jcr, M_SAVED, 0, _("%s st_mode differ. Cat: %x File: %x\n"), fname,
129 (uint32_t)statc.st_mode, (uint32_t)ff_pkt->statp.st_mode);
133 // case 'n': /* number of links */
134 // if (statc.st_nlink != ff_pkt->statp.st_nlink) {
135 // Jmsg(jcr, M_SAVED, 0, _("%s st_nlink differ. Cat: %d File: %d\n"), fname,
136 // (uint32_t)statc.st_nlink, (uint32_t)ff_pkt->statp.st_nlink);
140 case 'u': /* user id */
141 if (statc.st_uid != ff_pkt->statp.st_uid) {
142 Jmsg(jcr, M_SAVED, 0, _("%s st_uid differ. Cat: %u File: %u\n"), fname,
143 (uint32_t)statc.st_uid, (uint32_t)ff_pkt->statp.st_uid);
147 case 'g': /* group id */
148 if (statc.st_gid != ff_pkt->statp.st_gid) {
149 Jmsg(jcr, M_SAVED, 0, _("%s st_gid differ. Cat: %u File: %u\n"), fname,
150 (uint32_t)statc.st_gid, (uint32_t)ff_pkt->statp.st_gid);
155 if (statc.st_size != ff_pkt->statp.st_size) {
156 Jmsg(jcr, M_SAVED, 0, _("%s st_size differ. Cat: %s File: %s\n"), fname,
157 edit_uint64((uint64_t)statc.st_size, ed1),
158 edit_uint64((uint64_t)ff_pkt->statp.st_size, ed2));
162 // case 'a': /* access time */
163 // if (statc.st_atime != ff_pkt->statp.st_atime) {
164 // Jmsg(jcr, M_SAVED, 0, _("%s st_atime differs\n"), fname);
169 if (statc.st_mtime != ff_pkt->statp.st_mtime) {
170 Jmsg(jcr, M_SAVED, 0, _("%s st_mtime differs\n"), fname);
174 case 'c': /* ctime */
175 if (statc.st_ctime != ff_pkt->statp.st_ctime) {
176 Jmsg(jcr, M_SAVED, 0, _("%s st_ctime differs\n"), fname);
180 case 'd': /* file size decrease */
181 if (statc.st_size > ff_pkt->statp.st_size) {
182 Jmsg(jcr, M_SAVED, 0, _("%s st_size decrease. Cat: %s File: %s\n"), fname,
183 edit_uint64((uint64_t)statc.st_size, ed1),
184 edit_uint64((uint64_t)ff_pkt->statp.st_size, ed2));
188 case '5': /* compare MD5 */
189 Dmsg1(500, "set Do_MD5 for %s\n", ff_pkt->fname);
190 // *do_Digest = CRYPTO_DIGEST_MD5;
192 case '1': /* compare SHA1 */
193 // *do_Digest = CRYPTO_DIGEST_SHA1;
201 accurate_mark_file_as_seen(elt);
202 Dmsg2(500, "accurate %s = %i\n", fname, stat);
205 unstrip_path(ff_pkt);
210 * This function doesn't work very well with smartalloc
211 * TODO: use bigbuffer from htable
213 int accurate_cmd(JCR *jcr)
215 BSOCK *dir = jcr->dir_bsock;
220 if (jcr->accurate==false || job_canceled(jcr) || jcr->JobLevel==L_FULL) {
224 if (sscanf(dir->msg, "accurate files=%ld", &nb) != 1) {
225 dir->fsend(_("2991 Bad accurate command\n"));
229 jcr->file_list = (htable *)malloc(sizeof(htable));
230 jcr->file_list->init(elt, &elt->link, nb);
233 * buffer = sizeof(CurFile) + dirmsg
234 * dirmsg = fname + lstat
236 /* get current files */
237 while (dir->recv() >= 0) {
238 len = strlen(dir->msg);
239 if ((len+1) < dir->msglen) {
240 // elt = (CurFile *)malloc(sizeof(CurFile));
241 // elt->fname = (char *) malloc(dir->msglen+1);
243 /* we store CurFile, fname and lstat in the same chunk */
244 elt = (CurFile *)malloc(sizeof(CurFile)+dir->msglen+1);
245 elt->fname = (char *) elt+sizeof(CurFile);
246 memcpy(elt->fname, dir->msg, dir->msglen);
247 elt->fname[dir->msglen]='\0';
248 elt->lstat = elt->fname + len + 1;
250 jcr->file_list->insert(elt->fname, elt);
251 Dmsg2(500, "add fname=%s lstat=%s\n", elt->fname, elt->lstat);
255 // jcr->file_list->stats();
256 /* TODO: send a EOM ?
257 * dir->fsend("2000 OK accurate\n");
262 bool accurate_send_deleted_list(JCR *jcr)
267 int stream = STREAM_UNIX_ATTRIBUTES;
269 if (jcr->accurate == false || jcr->JobLevel == L_FULL) {
273 if (jcr->file_list == NULL) {
277 ff_pkt = init_find_files();
278 ff_pkt->type = FT_DELETED;
280 foreach_htable (elt, jcr->file_list) {
281 if (!accurate_file_has_been_seen(elt)) { /* already seen */
282 Dmsg3(500, "deleted fname=%s lstat=%s seen=%i\n", elt->fname, elt->lstat, elt->seen);
283 ff_pkt->fname = elt->fname;
284 decode_stat(elt->lstat, &ff_pkt->statp, &ff_pkt->LinkFI); /* decode catalog stat */
285 encode_and_send_attributes(jcr, ff_pkt, stream);
289 term_find_files(ff_pkt);
291 /* TODO: clean htable when this function is not reached ? */
292 if (jcr->file_list) {
293 jcr->file_list->destroy();
294 free(jcr->file_list);
295 jcr->file_list = NULL;
301 * check for BSD nodump flag
303 static bool no_dump(JCR *jcr, FF_PKT *ff_pkt)
305 #if defined(HAVE_CHFLAGS) && defined(UF_NODUMP)
306 if ( (ff_pkt->flags & FO_HONOR_NODUMP) &&
307 (ff_pkt->statp.st_flags & UF_NODUMP) ) {
308 Jmsg(jcr, M_INFO, 1, _(" NODUMP flag set - will not process %s\n"),
310 return true; /* do not backup this file */
313 return false; /* do backup */
317 * Find all the requested files and send them
318 * to the Storage daemon.
320 * Note, we normally carry on a one-way
321 * conversation from this point on with the SD, simply blasting
322 * data to him. To properly know what is going on, we
323 * also run a "heartbeat" monitor which reads the socket and
324 * reacts accordingly (at the moment it has nothing to do
325 * except echo the heartbeat to the Director).
328 bool blast_data_to_storage_daemon(JCR *jcr, char *addr)
332 // TODO landonf: Allow user to specify encryption algorithm
334 sd = jcr->store_bsock;
336 set_jcr_job_status(jcr, JS_Running);
338 Dmsg1(300, "bfiled: opened data connection %d to stored\n", sd->m_fd);
341 CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
345 buf_size = client->max_network_buffer_size;
347 buf_size = 0; /* use default */
349 if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
350 set_jcr_job_status(jcr, JS_ErrorTerminated);
351 Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size FD->SD.\n"));
355 jcr->buf_size = sd->msglen;
356 /* Adjust for compression so that output buffer is
357 * 12 bytes + 0.1% larger than input buffer plus 18 bytes.
358 * This gives a bit extra plus room for the sparse addr if any.
359 * Note, we adjust the read size to be smaller so that the
360 * same output buffer can be used without growing it.
362 * The zlib compression workset is initialized here to minimise
363 * the "per file" load. The jcr member is only set, if the init was successful.
365 jcr->compress_buf_size = jcr->buf_size + ((jcr->buf_size+999) / 1000) + 30;
366 jcr->compress_buf = get_memory(jcr->compress_buf_size);
369 z_stream *pZlibStream = (z_stream*)malloc(sizeof(z_stream));
371 pZlibStream->zalloc = Z_NULL;
372 pZlibStream->zfree = Z_NULL;
373 pZlibStream->opaque = Z_NULL;
374 pZlibStream->state = Z_NULL;
376 if (deflateInit(pZlibStream, Z_DEFAULT_COMPRESSION) == Z_OK) {
377 jcr->pZLIB_compress_workset = pZlibStream;
384 if (!crypto_session_start(jcr)) {
388 set_find_options((FF_PKT *)jcr->ff, jcr->incremental, jcr->mtime);
390 /* in accurate mode, we overwrite the find_one check function */
392 set_find_changed_function((FF_PKT *)jcr->ff, accurate_check_file);
395 start_heartbeat_monitor(jcr);
397 jcr->acl_text = get_pool_memory(PM_MESSAGE);
399 /* Subroutine save_file() is called for each file */
400 if (!find_files(jcr, (FF_PKT *)jcr->ff, save_file, plugin_save)) {
401 ok = false; /* error */
402 set_jcr_job_status(jcr, JS_ErrorTerminated);
405 accurate_send_deleted_list(jcr); /* send deleted list to SD */
407 free_pool_memory(jcr->acl_text);
409 stop_heartbeat_monitor(jcr);
411 sd->signal(BNET_EOD); /* end of sending data */
417 if (jcr->compress_buf) {
418 free_pool_memory(jcr->compress_buf);
419 jcr->compress_buf = NULL;
421 if (jcr->pZLIB_compress_workset) {
422 /* Free the zlib stream */
424 deflateEnd((z_stream *)jcr->pZLIB_compress_workset);
426 free (jcr->pZLIB_compress_workset);
427 jcr->pZLIB_compress_workset = NULL;
429 crypto_session_end(jcr);
432 Dmsg1(100, "end blast_data ok=%d\n", ok);
436 static bool crypto_session_start(JCR *jcr)
438 crypto_cipher_t cipher = CRYPTO_CIPHER_AES_128_CBC;
441 * Create encryption session data and a cached, DER-encoded session data
442 * structure. We use a single session key for each backup, so we'll encode
443 * the session data only once.
445 if (jcr->crypto.pki_encrypt) {
448 /* Create per-job session encryption context */
449 jcr->crypto.pki_session = crypto_session_new(cipher, jcr->crypto.pki_recipients);
451 /* Get the session data size */
452 if (!crypto_session_encode(jcr->crypto.pki_session, (uint8_t *)0, &size)) {
453 Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
457 /* Allocate buffer */
458 jcr->crypto.pki_session_encoded = get_memory(size);
460 /* Encode session data */
461 if (!crypto_session_encode(jcr->crypto.pki_session, (uint8_t *)jcr->crypto.pki_session_encoded, &size)) {
462 Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
466 /* ... and store the encoded size */
467 jcr->crypto.pki_session_encoded_size = size;
469 /* Allocate the encryption/decryption buffer */
470 jcr->crypto.crypto_buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
475 static void crypto_session_end(JCR *jcr)
477 if (jcr->crypto.crypto_buf) {
478 free_pool_memory(jcr->crypto.crypto_buf);
479 jcr->crypto.crypto_buf = NULL;
481 if (jcr->crypto.pki_session) {
482 crypto_session_free(jcr->crypto.pki_session);
484 if (jcr->crypto.pki_session_encoded) {
485 free_pool_memory(jcr->crypto.pki_session_encoded);
486 jcr->crypto.pki_session_encoded = NULL;
490 static bool crypto_session_send(JCR *jcr, BSOCK *sd)
494 /* Send our header */
495 Dmsg2(100, "Send hdr fi=%ld stream=%d\n", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
496 sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
499 sd->msg = jcr->crypto.pki_session_encoded;
500 sd->msglen = jcr->crypto.pki_session_encoded_size;
501 jcr->JobBytes += sd->msglen;
503 Dmsg1(100, "Send data len=%d\n", sd->msglen);
506 sd->signal(BNET_EOD);
512 * Called here by find() for each file included.
513 * This is a callback. The original is find_files() above.
515 * Send the file and its data to the Storage daemon.
519 * -1 to ignore file/directory (not used here)
521 int save_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
523 bool do_read = false;
524 int stat, data_stream;
526 DIGEST *digest = NULL;
527 DIGEST *signing_digest = NULL;
528 int digest_stream = STREAM_NONE;
529 SIGNATURE *sig = NULL;
530 bool has_file_data = false;
531 // TODO landonf: Allow the user to specify the digest algorithm
533 crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA256;
535 crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA1;
537 BSOCK *sd = jcr->store_bsock;
539 if (job_canceled(jcr)) {
543 jcr->num_files_examined++; /* bump total file count */
545 switch (ff_pkt->type) {
546 case FT_LNKSAVED: /* Hard linked, file already saved */
547 Dmsg2(130, "FT_LNKSAVED hard link: %s => %s\n", ff_pkt->fname, ff_pkt->link);
550 Dmsg1(130, "FT_REGE saving: %s\n", ff_pkt->fname);
551 if (no_dump(jcr, ff_pkt))
553 has_file_data = true;
556 Dmsg1(130, "FT_REG saving: %s\n", ff_pkt->fname);
557 if (no_dump(jcr, ff_pkt))
559 has_file_data = true;
562 Dmsg2(130, "FT_LNK saving: %s -> %s\n", ff_pkt->fname, ff_pkt->link);
565 jcr->num_files_examined--; /* correct file count */
566 if (no_dump(jcr, ff_pkt)) /* disable recursion on nodump directories */
567 ff_pkt->flags |= FO_NO_RECURSION;
568 return 1; /* not used */
570 Jmsg(jcr, M_INFO, 1, _(" Recursion turned off. Will not descend from %s into %s\n"),
571 ff_pkt->top_fname, ff_pkt->fname);
572 ff_pkt->type = FT_DIREND; /* Backup only the directory entry */
575 /* Suppress message for /dev filesystems */
576 if (!is_in_fileset(ff_pkt)) {
577 Jmsg(jcr, M_INFO, 1, _(" %s is a different filesystem. Will not descend from %s into %s\n"),
578 ff_pkt->fname, ff_pkt->top_fname, ff_pkt->fname);
580 ff_pkt->type = FT_DIREND; /* Backup only the directory entry */
583 Jmsg(jcr, M_INFO, 1, _(" Disallowed filesystem. Will not descend from %s into %s\n"),
584 ff_pkt->top_fname, ff_pkt->fname);
585 ff_pkt->type = FT_DIREND; /* Backup only the directory entry */
588 Jmsg(jcr, M_INFO, 1, _(" Disallowed drive type. Will not descend into %s\n"),
593 Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
596 Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
597 if (S_ISSOCK(ff_pkt->statp.st_mode)) {
598 Jmsg(jcr, M_SKIPPED, 1, _(" Socket file skipped: %s\n"), ff_pkt->fname);
603 Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
604 has_file_data = true;
607 Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
611 Jmsg(jcr, M_NOTSAVED, 0, _(" Could not access %s: ERR=%s\n"), ff_pkt->fname,
612 be.bstrerror(ff_pkt->ff_errno));
618 Jmsg(jcr, M_NOTSAVED, 0, _(" Could not follow link %s: ERR=%s\n"),
619 ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
625 Jmsg(jcr, M_NOTSAVED, 0, _(" Could not stat %s: ERR=%s\n"), ff_pkt->fname,
626 be.bstrerror(ff_pkt->ff_errno));
632 Jmsg(jcr, M_SKIPPED, 1, _(" Unchanged file skipped: %s\n"), ff_pkt->fname);
635 Jmsg(jcr, M_NOTSAVED, 0, _(" Archive file not saved: %s\n"), ff_pkt->fname);
639 Jmsg(jcr, M_NOTSAVED, 0, _(" Could not open directory %s: ERR=%s\n"),
640 ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
645 Jmsg(jcr, M_NOTSAVED, 0, _(" Unknown file type %d; not saved: %s\n"),
646 ff_pkt->type, ff_pkt->fname);
651 Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
653 /* Digests and encryption are only useful if there's file data */
656 * Setup for digest handling. If this fails, the digest will be set to NULL
657 * and not used. Note, the digest (file hash) can be any one of the four
660 * The signing digest is a single algorithm depending on
661 * whether or not we have SHA2.
662 * ****FIXME**** the signing algoritm should really be
663 * determined a different way!!!!!! What happens if
664 * sha2 was available during backup but not restore?
666 if (ff_pkt->flags & FO_MD5) {
667 digest = crypto_digest_new(jcr, CRYPTO_DIGEST_MD5);
668 digest_stream = STREAM_MD5_DIGEST;
670 } else if (ff_pkt->flags & FO_SHA1) {
671 digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA1);
672 digest_stream = STREAM_SHA1_DIGEST;
674 } else if (ff_pkt->flags & FO_SHA256) {
675 digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA256);
676 digest_stream = STREAM_SHA256_DIGEST;
678 } else if (ff_pkt->flags & FO_SHA512) {
679 digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA512);
680 digest_stream = STREAM_SHA512_DIGEST;
683 /* Did digest initialization fail? */
684 if (digest_stream != STREAM_NONE && digest == NULL) {
685 Jmsg(jcr, M_WARNING, 0, _("%s digest initialization failed\n"),
686 stream_to_ascii(digest_stream));
690 * Set up signature digest handling. If this fails, the signature digest will be set to
693 // TODO landonf: We should really only calculate the digest once, for both verification and signing.
694 if (jcr->crypto.pki_sign) {
695 signing_digest = crypto_digest_new(jcr, signing_algorithm);
697 /* Full-stop if a failure occurred initializing the signature digest */
698 if (signing_digest == NULL) {
699 Jmsg(jcr, M_NOTSAVED, 0, _("%s signature digest initialization failed\n"),
700 stream_to_ascii(signing_algorithm));
706 /* Enable encryption */
707 if (jcr->crypto.pki_encrypt) {
708 ff_pkt->flags |= FO_ENCRYPT;
712 /* Initialize the file descriptor we use for data and other streams. */
714 if (ff_pkt->flags & FO_PORTABLE) {
715 set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
717 if (ff_pkt->cmd_plugin) {
718 if (!set_cmd_plugin(&ff_pkt->bfd, jcr)) {
721 send_plugin_name(jcr, sd, true); /* signal start of plugin data */
724 /* Send attributes -- must be done after binit() */
725 if (!encode_and_send_attributes(jcr, ff_pkt, data_stream)) {
729 /* Set up the encryption context and send the session data to the SD */
730 if (has_file_data && jcr->crypto.pki_encrypt) {
731 if (!crypto_session_send(jcr, sd)) {
737 * Open any file with data that we intend to save, then save it.
739 * Note, if is_win32_backup, we must open the Directory so that
740 * the BackupRead will save its permissions and ownership streams.
742 if (ff_pkt->type != FT_LNKSAVED && S_ISREG(ff_pkt->statp.st_mode)) {
744 do_read = !is_portable_backup(&ff_pkt->bfd) || ff_pkt->statp.st_size > 0;
746 do_read = ff_pkt->statp.st_size > 0;
748 } else if (ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
749 ff_pkt->type == FT_REPARSE ||
750 (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
753 if (ff_pkt->cmd_plugin) {
757 Dmsg1(100, "do_read=%d\n", do_read);
761 if (ff_pkt->type == FT_FIFO) {
762 tid = start_thread_timer(jcr, pthread_self(), 60);
766 int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
767 ff_pkt->bfd.reparse_point = ff_pkt->type == FT_REPARSE;
768 if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
769 ff_pkt->ff_errno = errno;
771 Jmsg(jcr, M_NOTSAVED, 0, _(" Cannot open %s: ERR=%s.\n"), ff_pkt->fname,
775 stop_thread_timer(tid);
781 stop_thread_timer(tid);
785 stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
787 if (ff_pkt->flags & FO_CHKCHANGES) {
788 has_file_changed(jcr, ff_pkt);
791 bclose(&ff_pkt->bfd);
798 #ifdef HAVE_DARWIN_OS
799 /* Regular files can have resource forks and Finder Info */
800 if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
801 ff_pkt->flags & FO_HFSPLUS)) {
802 if (ff_pkt->hfsinfo.rsrclength > 0) {
805 if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
806 ff_pkt->ff_errno = errno;
808 Jmsg(jcr, M_NOTSAVED, -1, _(" Cannot open resource fork for %s: ERR=%s.\n"),
809 ff_pkt->fname, be.bstrerror());
811 if (is_bopen(&ff_pkt->bfd)) {
812 bclose(&ff_pkt->bfd);
816 flags = ff_pkt->flags;
817 ff_pkt->flags &= ~(FO_GZIP|FO_SPARSE);
818 if (flags & FO_ENCRYPT) {
819 rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
821 rsrc_stream = STREAM_MACOS_FORK_DATA;
823 stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
824 ff_pkt->flags = flags;
825 bclose(&ff_pkt->bfd);
831 Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
832 sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
833 Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
834 memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
837 crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
839 if (signing_digest) {
840 crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
843 sd->signal(BNET_EOD);
847 if (ff_pkt->flags & FO_ACL) {
848 /* Read access ACLs for files, dirs and links */
849 if (!read_and_send_acl(jcr, BACL_TYPE_ACCESS, STREAM_UNIX_ACCESS_ACL)) {
852 /* Directories can have default ACLs too */
853 if (ff_pkt->type == FT_DIREND && (BACL_CAP & BACL_CAP_DEFAULTS_DIR)) {
854 if (!read_and_send_acl(jcr, BACL_TYPE_DEFAULT, STREAM_UNIX_DEFAULT_ACL)) {
860 /* Terminate the signing digest and send it to the Storage daemon */
861 if (signing_digest) {
864 if ((sig = crypto_sign_new(jcr)) == NULL) {
865 Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for crypto signature.\n"));
869 if (!crypto_sign_add_signer(sig, signing_digest, jcr->crypto.pki_keypair)) {
870 Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
874 /* Get signature size */
875 if (!crypto_sign_encode(sig, NULL, &size)) {
876 Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
880 /* Grow the bsock buffer to fit our message if necessary */
881 if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
882 sd->msg = realloc_pool_memory(sd->msg, size);
885 /* Send our header */
886 sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
887 Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
889 /* Encode signature data */
890 if (!crypto_sign_encode(sig, (uint8_t *)sd->msg, &size)) {
891 Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
897 sd->signal(BNET_EOD); /* end of checksum */
900 /* Terminate any digest and send it to Storage daemon */
904 sd->fsend("%ld %d 0", jcr->JobFiles, digest_stream);
905 Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
907 size = CRYPTO_DIGEST_MAX_SIZE;
909 /* Grow the bsock buffer to fit our message if necessary */
910 if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
911 sd->msg = realloc_pool_memory(sd->msg, size);
914 if (!crypto_digest_finalize(digest, (uint8_t *)sd->msg, &size)) {
915 Jmsg(jcr, M_FATAL, 0, _("An error occurred finalizing signing the stream.\n"));
921 sd->signal(BNET_EOD); /* end of checksum */
923 if (ff_pkt->cmd_plugin) {
924 send_plugin_name(jcr, sd, false); /* signal end of plugin data */
928 rtnstat = 1; /* good return */
932 crypto_digest_free(digest);
934 if (signing_digest) {
935 crypto_digest_free(signing_digest);
938 crypto_sign_free(sig);
944 * Send data read from an already open file descriptor.
946 * We return 1 on sucess and 0 on errors.
949 * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
951 * Currently this is not a problem as the only other stream, resource forks,
952 * are not handled as sparse files.
954 int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
955 DIGEST *signing_digest)
957 BSOCK *sd = jcr->store_bsock;
958 uint64_t fileAddr = 0; /* file address */
960 int32_t rsize = jcr->buf_size; /* read buffer size */
962 CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
963 const uint8_t *cipher_input;
964 uint32_t cipher_input_len;
965 uint32_t cipher_block_size;
966 uint32_t encrypted_len;
967 #ifdef FD_NO_SEND_TEST
972 rbuf = sd->msg; /* read buffer */
973 wbuf = sd->msg; /* write buffer */
974 cipher_input = (uint8_t *)rbuf; /* encrypt uncompressed data */
976 Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
979 uLong compress_len = 0;
980 uLong max_compress_len = 0;
981 const Bytef *cbuf = NULL;
984 if (ff_pkt->flags & FO_GZIP) {
985 if (ff_pkt->flags & FO_SPARSE) {
986 cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
987 max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
989 cbuf = (Bytef *)jcr->compress_buf;
990 max_compress_len = jcr->compress_buf_size; /* set max length */
992 wbuf = jcr->compress_buf; /* compressed output here */
993 cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
996 * Only change zlib parameters if there is no pending operation.
997 * This should never happen as deflatereset is called after each
1001 if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
1002 /* set gzip compression level - must be done per file */
1003 if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
1004 ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
1005 Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
1006 set_jcr_job_status(jcr, JS_ErrorTerminated);
1012 const uint32_t max_compress_len = 0;
1015 if (ff_pkt->flags & FO_ENCRYPT) {
1016 if (ff_pkt->flags & FO_SPARSE) {
1017 Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse data not supported.\n"));
1020 /* Allocate the cipher context */
1021 if ((cipher_ctx = crypto_cipher_new(jcr->crypto.pki_session, true,
1022 &cipher_block_size)) == NULL) {
1023 /* Shouldn't happen! */
1024 Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
1029 * Grow the crypto buffer, if necessary.
1030 * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
1031 * We grow crypto_buf to the maximum number of blocks that
1032 * could be returned for the given read buffer size.
1033 * (Using the larger of either rsize or max_compress_len)
1035 jcr->crypto.crypto_buf = check_pool_memory_size(jcr->crypto.crypto_buf,
1036 (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
1037 cipher_block_size - 1) / cipher_block_size * cipher_block_size);
1039 wbuf = jcr->crypto.crypto_buf; /* Encrypted, possibly compressed output here. */
1043 * Send Data header to Storage daemon
1044 * <file-index> <stream> <info>
1046 if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
1047 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1051 Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
1054 * Make space at beginning of buffer for fileAddr because this
1055 * same buffer will be used for writing if compression is off.
1057 if (ff_pkt->flags & FO_SPARSE) {
1058 rbuf += SPARSE_FADDR_SIZE;
1059 rsize -= SPARSE_FADDR_SIZE;
1060 #ifdef HAVE_FREEBSD_OS
1062 * To read FreeBSD partitions, the read size must be
1063 * a multiple of 512.
1065 rsize = (rsize/512) * 512;
1069 /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
1071 if (S_ISBLK(ff_pkt->statp.st_mode))
1072 rsize = (rsize/512) * 512;
1076 * Read the file data
1078 while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
1080 /* Check for sparse blocks */
1081 if (ff_pkt->flags & FO_SPARSE) {
1083 bool haveBlock = true;
1084 if (sd->msglen == rsize &&
1085 fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
1086 ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
1087 (uint64_t)ff_pkt->statp.st_size == 0)) {
1088 haveBlock = !is_buf_zero(rbuf, rsize);
1091 ser_begin(wbuf, SPARSE_FADDR_SIZE);
1092 ser_uint64(fileAddr); /* store fileAddr in begin of buffer */
1094 fileAddr += sd->msglen; /* update file address */
1096 continue; /* skip block of zeros */
1100 jcr->ReadBytes += sd->msglen; /* count bytes read */
1102 /* Uncompressed cipher input length */
1103 cipher_input_len = sd->msglen;
1105 /* Update checksum if requested */
1107 crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
1110 /* Update signing digest if requested */
1111 if (signing_digest) {
1112 crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
1116 /* Do compression if turned on */
1117 if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
1118 Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
1120 ((z_stream*)jcr->pZLIB_compress_workset)->next_in = (Bytef *)rbuf;
1121 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in = sd->msglen;
1122 ((z_stream*)jcr->pZLIB_compress_workset)->next_out = (Bytef *)cbuf;
1123 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
1125 if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
1126 Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
1127 set_jcr_job_status(jcr, JS_ErrorTerminated);
1130 compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
1131 /* reset zlib stream to be able to begin from scratch again */
1132 if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
1133 Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
1134 set_jcr_job_status(jcr, JS_ErrorTerminated);
1138 Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
1141 sd->msglen = compress_len; /* set compressed length */
1142 cipher_input_len = compress_len;
1146 * Note, here we prepend the current record length to the beginning
1147 * of the encrypted data. This is because both sparse and compression
1148 * restore handling want records returned to them with exactly the
1149 * same number of bytes that were processed in the backup handling.
1150 * That is, both are block filters rather than a stream. When doing
1151 * compression, the compression routines may buffer data, so that for
1152 * any one record compressed, when it is decompressed the same size
1153 * will not be obtained. Of course, the buffered data eventually comes
1154 * out in subsequent crypto_cipher_update() calls or at least
1155 * when crypto_cipher_finalize() is called. Unfortunately, this
1156 * "feature" of encryption enormously complicates the restore code.
1158 if (ff_pkt->flags & FO_ENCRYPT) {
1159 uint32_t initial_len = 0;
1162 if (ff_pkt->flags & FO_SPARSE) {
1163 cipher_input_len += SPARSE_FADDR_SIZE;
1166 /* Encrypt the length of the input block */
1167 uint8_t packet_len[sizeof(uint32_t)];
1169 ser_begin(packet_len, sizeof(uint32_t));
1170 ser_uint32(cipher_input_len); /* store data len in begin of buffer */
1171 Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
1173 if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
1174 (uint8_t *)jcr->crypto.crypto_buf, &initial_len)) {
1175 /* Encryption failed. Shouldn't happen. */
1176 Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
1180 /* Encrypt the input block */
1181 if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
1182 (uint8_t *)&jcr->crypto.crypto_buf[initial_len], &encrypted_len)) {
1183 if ((initial_len + encrypted_len) == 0) {
1184 /* No full block of data available, read more data */
1187 Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
1189 sd->msglen = initial_len + encrypted_len; /* set encrypted length */
1191 /* Encryption failed. Shouldn't happen. */
1192 Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
1197 /* Send the buffer to the Storage daemon */
1198 if (ff_pkt->flags & FO_SPARSE) {
1199 sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
1201 sd->msg = wbuf; /* set correct write buffer */
1203 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1207 Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1209 jcr->JobBytes += sd->msglen; /* count bytes saved possibly compressed/encrypted */
1210 sd->msg = msgsave; /* restore read buffer */
1212 } /* end while read file data */
1214 if (sd->msglen < 0) { /* error */
1216 Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
1217 ff_pkt->fname, be.bstrerror(ff_pkt->bfd.berrno));
1218 if (jcr->Errors++ > 1000) { /* insanity check */
1219 Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
1221 } else if (ff_pkt->flags & FO_ENCRYPT) {
1223 * For encryption, we must call finalize to push out any
1226 if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto.crypto_buf,
1228 /* Padding failed. Shouldn't happen. */
1229 Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
1233 /* Note, on SSL pre-0.9.7, there is always some output */
1234 if (encrypted_len > 0) {
1235 sd->msglen = encrypted_len; /* set encrypted length */
1236 sd->msg = jcr->crypto.crypto_buf; /* set correct write buffer */
1238 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1242 Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1243 jcr->JobBytes += sd->msglen; /* count bytes saved possibly compressed/encrypted */
1244 sd->msg = msgsave; /* restore bnet buffer */
1248 if (!sd->signal(BNET_EOD)) { /* indicate end of file data */
1249 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1254 /* Free the cipher context */
1256 crypto_cipher_free(cipher_ctx);
1261 /* Free the cipher context */
1263 crypto_cipher_free(cipher_ctx);
1266 sd->msg = msgsave; /* restore bnet buffer */
1272 * Read and send an ACL for the last encountered file.
1274 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
1277 BSOCK *sd = jcr->store_bsock;
1280 #ifdef FD_NO_SEND_TEST
1284 len = bacl_get(jcr, acltype);
1286 Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
1290 return true; /* no ACL */
1294 if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
1295 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1300 /* Send the buffer to the storage deamon */
1301 Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
1303 sd->msg = jcr->acl_text;
1304 sd->msglen = len + 1;
1308 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1313 jcr->JobBytes += sd->msglen;
1315 if (!sd->signal(BNET_EOD)) {
1316 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1321 Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
1326 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1328 BSOCK *sd = jcr->store_bsock;
1329 char attribs[MAXSTRING];
1330 char attribsEx[MAXSTRING];
1333 #ifdef FD_NO_SEND_TEST
1337 Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1338 /* Find what data stream we will use, then encode the attributes */
1339 if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1340 /* This should not happen */
1341 Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1344 encode_stat(attribs, ff_pkt, data_stream);
1346 /* Now possibly extend the attributes */
1347 attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1349 Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1352 jcr->JobFiles++; /* increment number of files sent */
1353 ff_pkt->FileIndex = jcr->JobFiles; /* return FileIndex */
1354 pm_strcpy(jcr->last_fname, ff_pkt->fname);
1358 * Send Attributes header to Storage daemon
1359 * <file-index> <stream> <info>
1361 if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1362 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1366 Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1369 * Send file attributes to Storage daemon
1372 * Filename (full path)
1373 * Encoded attributes
1374 * Link name (if type==FT_LNK or FT_LNKSAVED)
1375 * Encoded extended-attributes (for Win32)
1377 * For a directory, link is the same as fname, but with trailing
1378 * slash. For a linked file, link is the link.
1380 if (ff_pkt->type != FT_DELETED) { /* already stripped */
1383 if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
1384 Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1385 stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
1386 ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
1388 } else if (ff_pkt->type == FT_DIREND || ff_pkt->type == FT_REPARSE) {
1389 /* Here link is the canonical filename (i.e. with trailing slash) */
1390 stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1391 ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
1393 stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1394 ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
1396 if (ff_pkt->type != FT_DELETED) {
1397 unstrip_path(ff_pkt);
1400 Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1402 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1406 sd->signal(BNET_EOD); /* indicate end of attributes data */
1411 * Do in place strip of path
1413 static bool do_strip(int count, char *in)
1419 /* Copy to first path separator -- Win32 might have c: ... */
1420 while (*in && !IsPathSeparator(*in)) {
1424 numsep++; /* one separator seen */
1425 for (stripped=0; stripped<count && *in; stripped++) {
1426 while (*in && !IsPathSeparator(*in)) {
1427 in++; /* skip chars */
1430 numsep++; /* count separators seen */
1431 in++; /* skip separator */
1435 while (*in) { /* copy to end */
1436 if (IsPathSeparator(*in)) {
1442 Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1443 stripped, count, numsep, numsep>count);
1444 return stripped==count && numsep>count;
1448 * If requested strip leading components of the path so that we can
1449 * save file as if it came from a subdirectory. This is most useful
1450 * for dealing with snapshots, by removing the snapshot directory, or
1451 * in handling vendor migrations where files have been restored with
1452 * a vendor product into a subdirectory.
1454 static void strip_path(FF_PKT *ff_pkt)
1456 if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1457 Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1460 if (!ff_pkt->fname_save) {
1461 ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1462 ff_pkt->link_save = get_pool_memory(PM_FNAME);
1464 pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1467 * Strip path. If it doesn't succeed put it back. If
1468 * it does, and there is a different link string,
1469 * attempt to strip the link. If it fails, back them
1471 * Do not strip symlinks.
1472 * I.e. if either stripping fails don't strip anything.
1474 if (do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1475 /* Strip links but not symlinks */
1476 if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1477 pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1478 if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1479 strcpy(ff_pkt->link, ff_pkt->link_save);
1480 strcpy(ff_pkt->fname, ff_pkt->fname_save);
1484 strcpy(ff_pkt->fname, ff_pkt->fname_save);
1486 Dmsg2(200, "fname=%s stripped=%s\n", ff_pkt->fname_save, ff_pkt->fname);
1489 static void unstrip_path(FF_PKT *ff_pkt)
1491 if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1494 strcpy(ff_pkt->fname, ff_pkt->fname_save);
1495 if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1496 strcpy(ff_pkt->link, ff_pkt->link_save);