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