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

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