git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/backup.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2009 Free Software Foundation Europe e.V.
   5
   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
  11    in the file LICENSE.
  12
  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.
  17
  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
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  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.
  27 */
  28 /*
  29  *  Bacula File Daemon  backup.c  send file attributes and data
  30  *   to the Storage daemon.
  31  *
  32  *    Kern Sibbald, March MM
  33  *
  34  *   Version $Id$
  35  *
  36  */
  37
  38 #include "bacula.h"
  39 #include "filed.h"
  40
  41 #if defined(HAVE_ACL)
  42 const bool have_acl = true;
  43 #else
  44 const bool have_acl = false;
  45 #endif
  46
  47 #if defined(HAVE_XATTR)
  48 const bool have_xattr = true;
  49 #else
  50 const bool have_xattr = false;
  51 #endif
  52
  53 /* Forward referenced functions */
  54 int save_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level);
  55 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest, DIGEST *signature_digest);
  56 bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream);
  57 static bool crypto_session_start(JCR *jcr);
  58 static void crypto_session_end(JCR *jcr);
  59 static bool crypto_session_send(JCR *jcr, BSOCK *sd);
  60
  61 /*
  62  * Find all the requested files and send them
  63  * to the Storage daemon.
  64  *
  65  * Note, we normally carry on a one-way
  66  * conversation from this point on with the SD, simply blasting
  67  * data to him.  To properly know what is going on, we
  68  * also run a "heartbeat" monitor which reads the socket and
  69  * reacts accordingly (at the moment it has nothing to do
  70  * except echo the heartbeat to the Director).
  71  *
  72  */
  73 bool blast_data_to_storage_daemon(JCR *jcr, char *addr)
  74 {
  75    BSOCK *sd;
  76    bool ok = true;
  77    // TODO landonf: Allow user to specify encryption algorithm
  78
  79    sd = jcr->store_bsock;
  80
  81    set_jcr_job_status(jcr, JS_Running);
  82
  83    Dmsg1(300, "bfiled: opened data connection %d to stored\n", sd->m_fd);
  84
  85    LockRes();
  86    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
  87    UnlockRes();
  88    uint32_t buf_size;
  89    if (client) {
  90       buf_size = client->max_network_buffer_size;
  91    } else {
  92       buf_size = 0;                   /* use default */
  93    }
  94    if (!sd->set_buffer_size(buf_size, BNET_SETBUF_WRITE)) {
  95       set_jcr_job_status(jcr, JS_ErrorTerminated);
  96       Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size FD->SD.\n"));
  97       return false;
  98    }
  99
 100    jcr->buf_size = sd->msglen;
 101    /* Adjust for compression so that output buffer is
 102     *  12 bytes + 0.1% larger than input buffer plus 18 bytes.
 103     *  This gives a bit extra plus room for the sparse addr if any.
 104     *  Note, we adjust the read size to be smaller so that the
 105     *  same output buffer can be used without growing it.
 106     *
 107     * The zlib compression workset is initialized here to minimize
 108     *  the "per file" load. The jcr member is only set, if the init
 109     *  was successful.
 110     */
 111    jcr->compress_buf_size = jcr->buf_size + ((jcr->buf_size+999) / 1000) + 30;
 112    jcr->compress_buf = get_memory(jcr->compress_buf_size);
 113
 114 #ifdef HAVE_LIBZ
 115    z_stream *pZlibStream = (z_stream*)malloc(sizeof(z_stream));
 116    if (pZlibStream) {
 117       pZlibStream->zalloc = Z_NULL;
 118       pZlibStream->zfree = Z_NULL;
 119       pZlibStream->opaque = Z_NULL;
 120       pZlibStream->state = Z_NULL;
 121
 122       if (deflateInit(pZlibStream, Z_DEFAULT_COMPRESSION) == Z_OK) {
 123          jcr->pZLIB_compress_workset = pZlibStream;
 124       } else {
 125          free (pZlibStream);
 126       }
 127    }
 128 #endif
 129
 130    if (!crypto_session_start(jcr)) {
 131       return false;
 132    }
 133
 134    set_find_options((FF_PKT *)jcr->ff, jcr->incremental, jcr->mtime);
 135
 136    /* in accurate mode, we overwrite the find_one check function */
 137    if (jcr->accurate) {
 138       set_find_changed_function((FF_PKT *)jcr->ff, accurate_check_file);
 139    }
 140
 141    start_heartbeat_monitor(jcr);
 142
 143    if (have_acl) {
 144       jcr->acl_data = get_pool_memory(PM_MESSAGE);
 145       jcr->total_acl_errors = 0;
 146    }
 147    if (have_xattr) {
 148       jcr->xattr_data = get_pool_memory(PM_MESSAGE);
 149    }
 150
 151    /* Subroutine save_file() is called for each file */
 152    if (!find_files(jcr, (FF_PKT *)jcr->ff, save_file, plugin_save)) {
 153       ok = false;                     /* error */
 154       set_jcr_job_status(jcr, JS_ErrorTerminated);
 155    }
 156
 157    if (jcr->total_acl_errors > 0) {
 158       Jmsg(jcr, M_ERROR, 0, _("Encountered %ld acl errors while doing backup\n"),
 159            jcr->total_acl_errors);
 160    }
 161
 162    accurate_send_deleted_list(jcr);              /* send deleted list to SD  */
 163
 164    stop_heartbeat_monitor(jcr);
 165
 166    sd->signal(BNET_EOD);            /* end of sending data */
 167
 168    if (have_acl && jcr->acl_data) {
 169       free_pool_memory(jcr->acl_data);
 170       jcr->acl_data = NULL;
 171    }
 172    if (have_xattr && jcr->xattr_data) {
 173       free_pool_memory(jcr->xattr_data);
 174       jcr->xattr_data = NULL;
 175    }
 176    if (jcr->big_buf) {
 177       free(jcr->big_buf);
 178       jcr->big_buf = NULL;
 179    }
 180    if (jcr->compress_buf) {
 181       free_pool_memory(jcr->compress_buf);
 182       jcr->compress_buf = NULL;
 183    }
 184    if (jcr->pZLIB_compress_workset) {
 185       /* Free the zlib stream */
 186 #ifdef HAVE_LIBZ
 187       deflateEnd((z_stream *)jcr->pZLIB_compress_workset);
 188 #endif
 189       free (jcr->pZLIB_compress_workset);
 190       jcr->pZLIB_compress_workset = NULL;
 191    }
 192    crypto_session_end(jcr);
 193
 194
 195    Dmsg1(100, "end blast_data ok=%d\n", ok);
 196    return ok;
 197 }
 198
 199 static bool crypto_session_start(JCR *jcr)
 200 {
 201    crypto_cipher_t cipher = CRYPTO_CIPHER_AES_128_CBC;
 202
 203    /*
 204     * Create encryption session data and a cached, DER-encoded session data
 205     * structure. We use a single session key for each backup, so we'll encode
 206     * the session data only once.
 207     */
 208    if (jcr->crypto.pki_encrypt) {
 209       uint32_t size = 0;
 210
 211       /* Create per-job session encryption context */
 212       jcr->crypto.pki_session = crypto_session_new(cipher, jcr->crypto.pki_recipients);
 213
 214       /* Get the session data size */
 215       if (!crypto_session_encode(jcr->crypto.pki_session, (uint8_t *)0, &size)) {
 216          Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
 217          return false;
 218       }
 219
 220       /* Allocate buffer */
 221       jcr->crypto.pki_session_encoded = get_memory(size);
 222
 223       /* Encode session data */
 224       if (!crypto_session_encode(jcr->crypto.pki_session, (uint8_t *)jcr->crypto.pki_session_encoded, &size)) {
 225          Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
 226          return false;
 227       }
 228
 229       /* ... and store the encoded size */
 230       jcr->crypto.pki_session_encoded_size = size;
 231
 232       /* Allocate the encryption/decryption buffer */
 233       jcr->crypto.crypto_buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 234    }
 235    return true;
 236 }
 237
 238 static void crypto_session_end(JCR *jcr)
 239 {
 240    if (jcr->crypto.crypto_buf) {
 241       free_pool_memory(jcr->crypto.crypto_buf);
 242       jcr->crypto.crypto_buf = NULL;
 243    }
 244    if (jcr->crypto.pki_session) {
 245       crypto_session_free(jcr->crypto.pki_session);
 246    }
 247    if (jcr->crypto.pki_session_encoded) {
 248       free_pool_memory(jcr->crypto.pki_session_encoded);
 249       jcr->crypto.pki_session_encoded = NULL;
 250    }
 251 }
 252
 253 static bool crypto_session_send(JCR *jcr, BSOCK *sd)
 254 {
 255    POOLMEM *msgsave;
 256
 257    /* Send our header */
 258    Dmsg2(100, "Send hdr fi=%ld stream=%d\n", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 259    sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 260
 261    msgsave = sd->msg;
 262    sd->msg = jcr->crypto.pki_session_encoded;
 263    sd->msglen = jcr->crypto.pki_session_encoded_size;
 264    jcr->JobBytes += sd->msglen;
 265
 266    Dmsg1(100, "Send data len=%d\n", sd->msglen);
 267    sd->send();
 268    sd->msg = msgsave;
 269    sd->signal(BNET_EOD);
 270    return true;
 271 }
 272
 273
 274 /*
 275  * Called here by find() for each file included.
 276  *   This is a callback. The original is find_files() above.
 277  *
 278  *  Send the file and its data to the Storage daemon.
 279  *
 280  *  Returns: 1 if OK
 281  *           0 if error
 282  *          -1 to ignore file/directory (not used here)
 283  */
 284 int save_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
 285 {
 286    bool do_read = false;
 287    int stat, data_stream;
 288    int rtnstat = 0;
 289    DIGEST *digest = NULL;
 290    DIGEST *signing_digest = NULL;
 291    int digest_stream = STREAM_NONE;
 292    SIGNATURE *sig = NULL;
 293    bool has_file_data = false;
 294    // TODO landonf: Allow the user to specify the digest algorithm
 295 #ifdef HAVE_SHA2
 296    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA256;
 297 #else
 298    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA1;
 299 #endif
 300    BSOCK *sd = jcr->store_bsock;
 301
 302    if (job_canceled(jcr)) {
 303       return 0;
 304    }
 305
 306    jcr->num_files_examined++;         /* bump total file count */
 307
 308    switch (ff_pkt->type) {
 309    case FT_LNKSAVED:                  /* Hard linked, file already saved */
 310       Dmsg2(130, "FT_LNKSAVED hard link: %s => %s\n", ff_pkt->fname, ff_pkt->link);
 311       break;
 312    case FT_REGE:
 313       Dmsg1(130, "FT_REGE saving: %s\n", ff_pkt->fname);
 314       has_file_data = true;
 315       break;
 316    case FT_REG:
 317       Dmsg1(130, "FT_REG saving: %s\n", ff_pkt->fname);
 318       has_file_data = true;
 319       break;
 320    case FT_LNK:
 321       Dmsg2(130, "FT_LNK saving: %s -> %s\n", ff_pkt->fname, ff_pkt->link);
 322       break;
 323    case FT_DIRBEGIN:
 324       jcr->num_files_examined--;      /* correct file count */
 325       return 1;                       /* not used */
 326    case FT_NORECURSE:
 327       Jmsg(jcr, M_INFO, 1, _("     Recursion turned off. Will not descend from %s into %s\n"),
 328            ff_pkt->top_fname, ff_pkt->fname);
 329       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 330       break;
 331    case FT_NOFSCHG:
 332       /* Suppress message for /dev filesystems */
 333       if (!is_in_fileset(ff_pkt)) {
 334          Jmsg(jcr, M_INFO, 1, _("     %s is a different filesystem. Will not descend from %s into %s\n"),
 335               ff_pkt->fname, ff_pkt->top_fname, ff_pkt->fname);
 336       }
 337       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 338       break;
 339    case FT_INVALIDFS:
 340       Jmsg(jcr, M_INFO, 1, _("     Disallowed filesystem. Will not descend from %s into %s\n"),
 341            ff_pkt->top_fname, ff_pkt->fname);
 342       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 343       break;
 344    case FT_INVALIDDT:
 345       Jmsg(jcr, M_INFO, 1, _("     Disallowed drive type. Will not descend into %s\n"),
 346            ff_pkt->fname);
 347       break;
 348    case FT_REPARSE:
 349    case FT_DIREND:
 350       Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
 351       break;
 352    case FT_SPEC:
 353       Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
 354       if (S_ISSOCK(ff_pkt->statp.st_mode)) {
 355         Jmsg(jcr, M_SKIPPED, 1, _("     Socket file skipped: %s\n"), ff_pkt->fname);
 356         return 1;
 357       }
 358       break;
 359    case FT_RAW:
 360       Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
 361       has_file_data = true;
 362       break;
 363    case FT_FIFO:
 364       Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
 365       break;
 366    case FT_NOACCESS: {
 367       berrno be;
 368       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not access \"%s\": ERR=%s\n"), ff_pkt->fname,
 369          be.bstrerror(ff_pkt->ff_errno));
 370       jcr->JobErrors++;
 371       return 1;
 372    }
 373    case FT_NOFOLLOW: {
 374       berrno be;
 375       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not follow link \"%s\": ERR=%s\n"),
 376            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 377       jcr->JobErrors++;
 378       return 1;
 379    }
 380    case FT_NOSTAT: {
 381       berrno be;
 382       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not stat \"%s\": ERR=%s\n"), ff_pkt->fname,
 383          be.bstrerror(ff_pkt->ff_errno));
 384       jcr->JobErrors++;
 385       return 1;
 386    }
 387    case FT_DIRNOCHG:
 388    case FT_NOCHG:
 389       Jmsg(jcr, M_SKIPPED, 1, _("     Unchanged file skipped: %s\n"), ff_pkt->fname);
 390       return 1;
 391    case FT_ISARCH:
 392       Jmsg(jcr, M_NOTSAVED, 0, _("     Archive file not saved: %s\n"), ff_pkt->fname);
 393       return 1;
 394    case FT_NOOPEN: {
 395       berrno be;
 396       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not open directory \"%s\": ERR=%s\n"),
 397            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 398       jcr->JobErrors++;
 399       return 1;
 400    }
 401    default:
 402       Jmsg(jcr, M_NOTSAVED, 0,  _("     Unknown file type %d; not saved: %s\n"),
 403            ff_pkt->type, ff_pkt->fname);
 404       jcr->JobErrors++;
 405       return 1;
 406    }
 407
 408    Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
 409
 410    /* Digests and encryption are only useful if there's file data */
 411    if (has_file_data) {
 412       /*
 413        * Setup for digest handling. If this fails, the digest will be set to NULL
 414        * and not used. Note, the digest (file hash) can be any one of the four
 415        * algorithms below.
 416        *
 417        * The signing digest is a single algorithm depending on
 418        * whether or not we have SHA2.
 419        *   ****FIXME****  the signing algoritm should really be
 420        *   determined a different way!!!!!!  What happens if
 421        *   sha2 was available during backup but not restore?
 422        */
 423       if (ff_pkt->flags & FO_MD5) {
 424          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_MD5);
 425          digest_stream = STREAM_MD5_DIGEST;
 426
 427       } else if (ff_pkt->flags & FO_SHA1) {
 428          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA1);
 429          digest_stream = STREAM_SHA1_DIGEST;
 430
 431       } else if (ff_pkt->flags & FO_SHA256) {
 432          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA256);
 433          digest_stream = STREAM_SHA256_DIGEST;
 434
 435       } else if (ff_pkt->flags & FO_SHA512) {
 436          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA512);
 437          digest_stream = STREAM_SHA512_DIGEST;
 438       }
 439
 440       /* Did digest initialization fail? */
 441       if (digest_stream != STREAM_NONE && digest == NULL) {
 442          Jmsg(jcr, M_WARNING, 0, _("%s digest initialization failed\n"),
 443             stream_to_ascii(digest_stream));
 444       }
 445
 446       /*
 447        * Set up signature digest handling. If this fails, the signature digest will be set to
 448        * NULL and not used.
 449        */
 450       // TODO landonf: We should really only calculate the digest once, for both verification and signing.
 451       if (jcr->crypto.pki_sign) {
 452          signing_digest = crypto_digest_new(jcr, signing_algorithm);
 453
 454          /* Full-stop if a failure occurred initializing the signature digest */
 455          if (signing_digest == NULL) {
 456             Jmsg(jcr, M_NOTSAVED, 0, _("%s signature digest initialization failed\n"),
 457                stream_to_ascii(signing_algorithm));
 458             jcr->JobErrors++;
 459             goto good_rtn;
 460          }
 461       }
 462
 463       /* Enable encryption */
 464       if (jcr->crypto.pki_encrypt) {
 465          ff_pkt->flags |= FO_ENCRYPT;
 466       }
 467    }
 468
 469    /* Initialize the file descriptor we use for data and other streams. */
 470    binit(&ff_pkt->bfd);
 471    if (ff_pkt->flags & FO_PORTABLE) {
 472       set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
 473    }
 474    if (ff_pkt->cmd_plugin) {
 475       if (!set_cmd_plugin(&ff_pkt->bfd, jcr)) {
 476          goto bail_out;
 477       }
 478       send_plugin_name(jcr, sd, true);      /* signal start of plugin data */
 479    }
 480
 481    /* Send attributes -- must be done after binit() */
 482    if (!encode_and_send_attributes(jcr, ff_pkt, data_stream)) {
 483       goto bail_out;
 484    }
 485
 486    /* Set up the encryption context and send the session data to the SD */
 487    if (has_file_data && jcr->crypto.pki_encrypt) {
 488       if (!crypto_session_send(jcr, sd)) {
 489          goto bail_out;
 490       }
 491    }
 492
 493    /*
 494     * Open any file with data that we intend to save, then save it.
 495     *
 496     * Note, if is_win32_backup, we must open the Directory so that
 497     * the BackupRead will save its permissions and ownership streams.
 498     */
 499    if (ff_pkt->type != FT_LNKSAVED && S_ISREG(ff_pkt->statp.st_mode)) {
 500 #ifdef HAVE_WIN32
 501       do_read = !is_portable_backup(&ff_pkt->bfd) || ff_pkt->statp.st_size > 0;
 502 #else
 503       do_read = ff_pkt->statp.st_size > 0;
 504 #endif
 505    } else if (ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
 506               ff_pkt->type == FT_REPARSE ||
 507          (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
 508       do_read = true;
 509    }
 510    if (ff_pkt->cmd_plugin) {
 511       do_read = true;
 512    }
 513
 514    Dmsg1(400, "do_read=%d\n", do_read);
 515    if (do_read) {
 516       btimer_t *tid;
 517
 518       if (ff_pkt->type == FT_FIFO) {
 519          tid = start_thread_timer(jcr, pthread_self(), 60);
 520       } else {
 521          tid = NULL;
 522       }
 523       int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
 524       ff_pkt->bfd.reparse_point = ff_pkt->type == FT_REPARSE;
 525       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
 526          ff_pkt->ff_errno = errno;
 527          berrno be;
 528          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open \"%s\": ERR=%s.\n"), ff_pkt->fname,
 529               be.bstrerror());
 530          jcr->JobErrors++;
 531          if (tid) {
 532             stop_thread_timer(tid);
 533             tid = NULL;
 534          }
 535          goto good_rtn;
 536       }
 537       if (tid) {
 538          stop_thread_timer(tid);
 539          tid = NULL;
 540       }
 541
 542       stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
 543
 544       if (ff_pkt->flags & FO_CHKCHANGES) {
 545          has_file_changed(jcr, ff_pkt);
 546       }
 547
 548       bclose(&ff_pkt->bfd);
 549
 550       if (!stat) {
 551          goto bail_out;
 552       }
 553    }
 554
 555 #ifdef HAVE_DARWIN_OS
 556    /* Regular files can have resource forks and Finder Info */
 557    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 558             ff_pkt->flags & FO_HFSPLUS)) {
 559       if (ff_pkt->hfsinfo.rsrclength > 0) {
 560          int flags;
 561          int rsrc_stream;
 562          if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 563             ff_pkt->ff_errno = errno;
 564             berrno be;
 565             Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for \"%s\": ERR=%s.\n"),
 566                  ff_pkt->fname, be.bstrerror());
 567             jcr->JobErrors++;
 568             if (is_bopen(&ff_pkt->bfd)) {
 569                bclose(&ff_pkt->bfd);
 570             }
 571             goto good_rtn;
 572          }
 573          flags = ff_pkt->flags;
 574          ff_pkt->flags &= ~(FO_GZIP|FO_SPARSE);
 575          if (flags & FO_ENCRYPT) {
 576             rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
 577          } else {
 578             rsrc_stream = STREAM_MACOS_FORK_DATA;
 579          }
 580          stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
 581          ff_pkt->flags = flags;
 582          bclose(&ff_pkt->bfd);
 583          if (!stat) {
 584             goto bail_out;
 585          }
 586       }
 587
 588       Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
 589       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 590       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 591       pm_memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 592       sd->msglen = 32;
 593       if (digest) {
 594          crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
 595       }
 596       if (signing_digest) {
 597          crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
 598       }
 599       sd->send();
 600       sd->signal(BNET_EOD);
 601    }
 602 #endif
 603
 604    /*
 605     * Save ACLs when requested and available for anything not being a symlink and not being a plugin.
 606     */
 607    if (have_acl) {
 608       if (ff_pkt->flags & FO_ACL && ff_pkt->type != FT_LNK && !ff_pkt->cmd_plugin) {
 609          switch (build_acl_streams(jcr, ff_pkt))
 610             case bsub_exit_fatal:
 611               goto bail_out;
 612             case bsub_exit_nok:
 613                /*
 614                 * Non-fatal errors, count them and when the number is under ACL_REPORT_ERR_MAX_PER_JOB
 615                 * print the error message set by the lower level routine in jcr->errmsg.
 616                 */
 617                if (jcr->total_acl_errors < ACL_REPORT_ERR_MAX_PER_JOB) {
 618                   Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg);
 619                }
 620                jcr->total_acl_errors++;
 621                break;
 622             case bsub_exit_ok:
 623                break;
 624          }
 625       }
 626    }
 627
 628    /*
 629     * Save Extended Attributes when requested and available for all files not being a plugin.
 630     */
 631    if (have_xattr) {
 632       if (ff_pkt->flags & FO_XATTR && !ff_pkt->cmd_plugin) {
 633          if (build_xattr_streams(jcr, ff_pkt) == bsub_exit_fatal)
 634             goto bail_out;
 635       }
 636    }
 637
 638    /* Terminate the signing digest and send it to the Storage daemon */
 639    if (signing_digest) {
 640       uint32_t size = 0;
 641
 642       if ((sig = crypto_sign_new(jcr)) == NULL) {
 643          Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for crypto signature.\n"));
 644          goto bail_out;
 645       }
 646
 647       if (!crypto_sign_add_signer(sig, signing_digest, jcr->crypto.pki_keypair)) {
 648          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 649          goto bail_out;
 650       }
 651
 652       /* Get signature size */
 653       if (!crypto_sign_encode(sig, NULL, &size)) {
 654          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 655          goto bail_out;
 656       }
 657
 658       /* Grow the bsock buffer to fit our message if necessary */
 659       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 660          sd->msg = realloc_pool_memory(sd->msg, size);
 661       }
 662
 663       /* Send our header */
 664       sd->fsend("%ld %ld 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
 665       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 666
 667       /* Encode signature data */
 668       if (!crypto_sign_encode(sig, (uint8_t *)sd->msg, &size)) {
 669          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 670          goto bail_out;
 671       }
 672
 673       sd->msglen = size;
 674       sd->send();
 675       sd->signal(BNET_EOD);              /* end of checksum */
 676    }
 677
 678    /* Terminate any digest and send it to Storage daemon */
 679    if (digest) {
 680       uint32_t size;
 681
 682       sd->fsend("%ld %d 0", jcr->JobFiles, digest_stream);
 683       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 684
 685       size = CRYPTO_DIGEST_MAX_SIZE;
 686
 687       /* Grow the bsock buffer to fit our message if necessary */
 688       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 689          sd->msg = realloc_pool_memory(sd->msg, size);
 690       }
 691
 692       if (!crypto_digest_finalize(digest, (uint8_t *)sd->msg, &size)) {
 693          Jmsg(jcr, M_FATAL, 0, _("An error occurred finalizing signing the stream.\n"));
 694          goto bail_out;
 695       }
 696
 697       sd->msglen = size;
 698       sd->send();
 699       sd->signal(BNET_EOD);              /* end of checksum */
 700    }
 701    if (ff_pkt->cmd_plugin) {
 702       send_plugin_name(jcr, sd, false); /* signal end of plugin data */
 703    }
 704
 705 good_rtn:
 706    rtnstat = 1;                       /* good return */
 707
 708 bail_out:
 709    if (digest) {
 710       crypto_digest_free(digest);
 711    }
 712    if (signing_digest) {
 713       crypto_digest_free(signing_digest);
 714    }
 715    if (sig) {
 716       crypto_sign_free(sig);
 717    }
 718    return rtnstat;
 719 }
 720
 721 /*
 722  * Send data read from an already open file descriptor.
 723  *
 724  * We return 1 on sucess and 0 on errors.
 725  *
 726  * ***FIXME***
 727  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 728  *  reading.
 729  * Currently this is not a problem as the only other stream, resource forks,
 730  * are not handled as sparse files.
 731  */
 732 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 733                      DIGEST *signing_digest)
 734 {
 735    BSOCK *sd = jcr->store_bsock;
 736    uint64_t fileAddr = 0;             /* file address */
 737    char *rbuf, *wbuf;
 738    int32_t rsize = jcr->buf_size;      /* read buffer size */
 739    POOLMEM *msgsave;
 740    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 741    const uint8_t *cipher_input;
 742    uint32_t cipher_input_len;
 743    uint32_t cipher_block_size;
 744    uint32_t encrypted_len;
 745 #ifdef FD_NO_SEND_TEST
 746    return 1;
 747 #endif
 748
 749    msgsave = sd->msg;
 750    rbuf = sd->msg;                    /* read buffer */
 751    wbuf = sd->msg;                    /* write buffer */
 752    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 753
 754    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 755
 756 #ifdef HAVE_LIBZ
 757    uLong compress_len = 0;
 758    uLong max_compress_len = 0;
 759    const Bytef *cbuf = NULL;
 760    int zstat;
 761
 762    if (ff_pkt->flags & FO_GZIP) {
 763       if (ff_pkt->flags & FO_SPARSE) {
 764          cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
 765          max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
 766       } else {
 767          cbuf = (Bytef *)jcr->compress_buf;
 768          max_compress_len = jcr->compress_buf_size; /* set max length */
 769       }
 770       wbuf = jcr->compress_buf;    /* compressed output here */
 771       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 772
 773       /*
 774        * Only change zlib parameters if there is no pending operation.
 775        * This should never happen as deflatereset is called after each
 776        * deflate.
 777        */
 778
 779       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 780          /* set gzip compression level - must be done per file */
 781          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 782               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 783             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 784             set_jcr_job_status(jcr, JS_ErrorTerminated);
 785             goto err;
 786          }
 787       }
 788    }
 789 #else
 790    const uint32_t max_compress_len = 0;
 791 #endif
 792
 793    if (ff_pkt->flags & FO_ENCRYPT) {
 794       if (ff_pkt->flags & FO_SPARSE) {
 795          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse data not supported.\n"));
 796          goto err;
 797       }
 798       /* Allocate the cipher context */
 799       if ((cipher_ctx = crypto_cipher_new(jcr->crypto.pki_session, true,
 800            &cipher_block_size)) == NULL) {
 801          /* Shouldn't happen! */
 802          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 803          goto err;
 804       }
 805
 806       /*
 807        * Grow the crypto buffer, if necessary.
 808        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 809        * We grow crypto_buf to the maximum number of blocks that
 810        * could be returned for the given read buffer size.
 811        * (Using the larger of either rsize or max_compress_len)
 812        */
 813       jcr->crypto.crypto_buf = check_pool_memory_size(jcr->crypto.crypto_buf,
 814            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 815             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 816
 817       wbuf = jcr->crypto.crypto_buf; /* Encrypted, possibly compressed output here. */
 818    }
 819
 820    /*
 821     * Send Data header to Storage daemon
 822     *    <file-index> <stream> <info>
 823     */
 824    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 825       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 826             sd->bstrerror());
 827       goto err;
 828    }
 829    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 830
 831    /*
 832     * Make space at beginning of buffer for fileAddr because this
 833     *   same buffer will be used for writing if compression is off.
 834     */
 835    if (ff_pkt->flags & FO_SPARSE) {
 836       rbuf += SPARSE_FADDR_SIZE;
 837       rsize -= SPARSE_FADDR_SIZE;
 838 #ifdef HAVE_FREEBSD_OS
 839       /*
 840        * To read FreeBSD partitions, the read size must be
 841        *  a multiple of 512.
 842        */
 843       rsize = (rsize/512) * 512;
 844 #endif
 845    }
 846
 847    /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
 848 #ifdef HAVE_WIN32
 849    if (S_ISBLK(ff_pkt->statp.st_mode))
 850       rsize = (rsize/512) * 512;
 851 #endif
 852
 853    /*
 854     * Read the file data
 855     */
 856    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 857
 858       /* Check for sparse blocks */
 859       if (ff_pkt->flags & FO_SPARSE) {
 860          ser_declare;
 861          bool allZeros = false;
 862          if ((sd->msglen == rsize &&
 863               fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size) ||
 864              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 865                (uint64_t)ff_pkt->statp.st_size == 0)) {
 866             allZeros = is_buf_zero(rbuf, rsize);
 867          }
 868          if (!allZeros) {
 869             /* Put file address as first data in buffer */
 870             ser_begin(wbuf, SPARSE_FADDR_SIZE);
 871             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 872          }
 873          fileAddr += sd->msglen;      /* update file address */
 874          /* Skip block of all zeros */
 875          if (allZeros) {
 876             continue;                 /* skip block of zeros */
 877          }
 878       }
 879
 880       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 881
 882       /* Uncompressed cipher input length */
 883       cipher_input_len = sd->msglen;
 884
 885       /* Update checksum if requested */
 886       if (digest) {
 887          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 888       }
 889
 890       /* Update signing digest if requested */
 891       if (signing_digest) {
 892          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 893       }
 894
 895 #ifdef HAVE_LIBZ
 896       /* Do compression if turned on */
 897       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 898          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 899
 900          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 901                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 902          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 903                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 904
 905          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 906             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 907             set_jcr_job_status(jcr, JS_ErrorTerminated);
 908             goto err;
 909          }
 910          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 911          /* reset zlib stream to be able to begin from scratch again */
 912          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 913             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 914             set_jcr_job_status(jcr, JS_ErrorTerminated);
 915             goto err;
 916          }
 917
 918          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 919                sd->msglen);
 920
 921          sd->msglen = compress_len;      /* set compressed length */
 922          cipher_input_len = compress_len;
 923       }
 924 #endif
 925       /*
 926        * Note, here we prepend the current record length to the beginning
 927        *  of the encrypted data. This is because both sparse and compression
 928        *  restore handling want records returned to them with exactly the
 929        *  same number of bytes that were processed in the backup handling.
 930        *  That is, both are block filters rather than a stream.  When doing
 931        *  compression, the compression routines may buffer data, so that for
 932        *  any one record compressed, when it is decompressed the same size
 933        *  will not be obtained. Of course, the buffered data eventually comes
 934        *  out in subsequent crypto_cipher_update() calls or at least
 935        *  when crypto_cipher_finalize() is called.  Unfortunately, this
 936        *  "feature" of encryption enormously complicates the restore code.
 937        */
 938       if (ff_pkt->flags & FO_ENCRYPT) {
 939          uint32_t initial_len = 0;
 940          ser_declare;
 941
 942          if (ff_pkt->flags & FO_SPARSE) {
 943             cipher_input_len += SPARSE_FADDR_SIZE;
 944          }
 945
 946          /* Encrypt the length of the input block */
 947          uint8_t packet_len[sizeof(uint32_t)];
 948
 949          ser_begin(packet_len, sizeof(uint32_t));
 950          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
 951          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
 952
 953          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
 954              (uint8_t *)jcr->crypto.crypto_buf, &initial_len)) {
 955             /* Encryption failed. Shouldn't happen. */
 956             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 957             goto err;
 958          }
 959
 960          /* Encrypt the input block */
 961          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
 962              (uint8_t *)&jcr->crypto.crypto_buf[initial_len], &encrypted_len)) {
 963             if ((initial_len + encrypted_len) == 0) {
 964                /* No full block of data available, read more data */
 965                continue;
 966             }
 967             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
 968                   sd->msglen);
 969             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
 970          } else {
 971             /* Encryption failed. Shouldn't happen. */
 972             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 973             goto err;
 974          }
 975       }
 976
 977       /* Send the buffer to the Storage daemon */
 978       if (ff_pkt->flags & FO_SPARSE) {
 979          sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 980       }
 981       sd->msg = wbuf;              /* set correct write buffer */
 982       if (!sd->send()) {
 983          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 984                sd->bstrerror());
 985          goto err;
 986       }
 987       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 988       /*          #endif */
 989       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 990       sd->msg = msgsave;                /* restore read buffer */
 991
 992    } /* end while read file data */
 993
 994    if (sd->msglen < 0) {                 /* error */
 995       berrno be;
 996       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 997          ff_pkt->fname, be.bstrerror(ff_pkt->bfd.berrno));
 998       if (jcr->JobErrors++ > 1000) {       /* insanity check */
 999          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
1000       }
1001    } else if (ff_pkt->flags & FO_ENCRYPT) {
1002       /*
1003        * For encryption, we must call finalize to push out any
1004        *  buffered data.
1005        */
1006       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto.crypto_buf,
1007            &encrypted_len)) {
1008          /* Padding failed. Shouldn't happen. */
1009          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
1010          goto err;
1011       }
1012
1013       /* Note, on SSL pre-0.9.7, there is always some output */
1014       if (encrypted_len > 0) {
1015          sd->msglen = encrypted_len;      /* set encrypted length */
1016          sd->msg = jcr->crypto.crypto_buf;       /* set correct write buffer */
1017          if (!sd->send()) {
1018             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1019                   sd->bstrerror());
1020             goto err;
1021          }
1022          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1023          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
1024          sd->msg = msgsave;               /* restore bnet buffer */
1025       }
1026    }
1027
1028    if (!sd->signal(BNET_EOD)) {        /* indicate end of file data */
1029       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1030             sd->bstrerror());
1031       goto err;
1032    }
1033
1034    /* Free the cipher context */
1035    if (cipher_ctx) {
1036       crypto_cipher_free(cipher_ctx);
1037    }
1038    return 1;
1039
1040 err:
1041    /* Free the cipher context */
1042    if (cipher_ctx) {
1043       crypto_cipher_free(cipher_ctx);
1044    }
1045
1046    sd->msg = msgsave; /* restore bnet buffer */
1047    sd->msglen = 0;
1048    return 0;
1049 }
1050
1051 bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1052 {
1053    BSOCK *sd = jcr->store_bsock;
1054    char attribs[MAXSTRING];
1055    char attribsEx[MAXSTRING];
1056    int attr_stream;
1057    int stat;
1058 #ifdef FD_NO_SEND_TEST
1059    return true;
1060 #endif
1061
1062    Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1063    /* Find what data stream we will use, then encode the attributes */
1064    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1065       /* This should not happen */
1066       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1067       return false;
1068    }
1069    encode_stat(attribs, &ff_pkt->statp, ff_pkt->LinkFI, data_stream);
1070
1071    /* Now possibly extend the attributes */
1072    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1073
1074    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1075
1076    jcr->lock();
1077    jcr->JobFiles++;                    /* increment number of files sent */
1078    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1079    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1080    jcr->unlock();
1081
1082    /*
1083     * Send Attributes header to Storage daemon
1084     *    <file-index> <stream> <info>
1085     */
1086    if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1087       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1088             sd->bstrerror());
1089       return false;
1090    }
1091    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1092
1093    /*
1094     * Send file attributes to Storage daemon
1095     *   File_index
1096     *   File type
1097     *   Filename (full path)
1098     *   Encoded attributes
1099     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1100     *   Encoded extended-attributes (for Win32)
1101     *
1102     * For a directory, link is the same as fname, but with trailing
1103     * slash. For a linked file, link is the link.
1104     */
1105    if (ff_pkt->type != FT_DELETED) { /* already stripped */
1106       strip_path(ff_pkt);
1107    }
1108    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
1109       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1110       stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
1111                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
1112                attribsEx, 0);
1113    } else if (ff_pkt->type == FT_DIREND || ff_pkt->type == FT_REPARSE) {
1114       /* Here link is the canonical filename (i.e. with trailing slash) */
1115       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1116                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
1117    } else {
1118       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1119                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
1120    }
1121    if (ff_pkt->type != FT_DELETED) {
1122       unstrip_path(ff_pkt);
1123    }
1124
1125    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1126    if (!stat) {
1127       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1128             sd->bstrerror());
1129       return false;
1130    }
1131    sd->signal(BNET_EOD);            /* indicate end of attributes data */
1132    return true;
1133 }
1134
1135 /*
1136  * Do in place strip of path
1137  */
1138 static bool do_strip(int count, char *in)
1139 {
1140    char *out = in;
1141    int stripped;
1142    int numsep = 0;
1143
1144    /* Copy to first path separator -- Win32 might have c: ... */
1145    while (*in && !IsPathSeparator(*in)) {
1146       out++; in++;
1147    }
1148    out++; in++;
1149    numsep++;                     /* one separator seen */
1150    for (stripped=0; stripped<count && *in; stripped++) {
1151       while (*in && !IsPathSeparator(*in)) {
1152          in++;                   /* skip chars */
1153       }
1154       if (*in) {
1155          numsep++;               /* count separators seen */
1156          in++;                   /* skip separator */
1157       }
1158    }
1159    /* Copy to end */
1160    while (*in) {                /* copy to end */
1161       if (IsPathSeparator(*in)) {
1162          numsep++;
1163       }
1164       *out++ = *in++;
1165    }
1166    *out = 0;
1167    Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1168          stripped, count, numsep, numsep>count);
1169    return stripped==count && numsep>count;
1170 }
1171
1172 /*
1173  * If requested strip leading components of the path so that we can
1174  *   save file as if it came from a subdirectory.  This is most useful
1175  *   for dealing with snapshots, by removing the snapshot directory, or
1176  *   in handling vendor migrations where files have been restored with
1177  *   a vendor product into a subdirectory.
1178  */
1179 void strip_path(FF_PKT *ff_pkt)
1180 {
1181    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1182       Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1183       return;
1184    }
1185    if (!ff_pkt->fname_save) {
1186      ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1187      ff_pkt->link_save = get_pool_memory(PM_FNAME);
1188    }
1189    pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1190    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1191       pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1192       Dmsg2(500, "strcpy link_save=%d link=%d\n", strlen(ff_pkt->link_save),
1193          strlen(ff_pkt->link));
1194       sm_check(__FILE__, __LINE__, true);
1195    }
1196
1197    /*
1198     * Strip path.  If it doesn't succeed put it back.  If
1199     *  it does, and there is a different link string,
1200     *  attempt to strip the link. If it fails, back them
1201     *  both back.
1202     * Do not strip symlinks.
1203     * I.e. if either stripping fails don't strip anything.
1204     */
1205    if (!do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1206       unstrip_path(ff_pkt);
1207       goto rtn;
1208    }
1209    /* Strip links but not symlinks */
1210    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1211       if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1212          unstrip_path(ff_pkt);
1213       }
1214    }
1215
1216 rtn:
1217    Dmsg3(100, "fname=%s stripped=%s link=%s\n", ff_pkt->fname_save, ff_pkt->fname,
1218        ff_pkt->link);
1219 }
1220
1221 void unstrip_path(FF_PKT *ff_pkt)
1222 {
1223    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1224       return;
1225    }
1226    strcpy(ff_pkt->fname, ff_pkt->fname_save);
1227    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1228       Dmsg2(500, "strcpy link=%s link_save=%s\n", ff_pkt->link,
1229           ff_pkt->link_save);
1230       strcpy(ff_pkt->link, ff_pkt->link_save);
1231       Dmsg2(500, "strcpy link=%d link_save=%d\n", strlen(ff_pkt->link),
1232           strlen(ff_pkt->link_save));
1233       sm_check(__FILE__, __LINE__, true);
1234    }
1235 }