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