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