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

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