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 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 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    } else if (ff_pkt->cmd_plugin) {
 477       do_read = true;
 478    }
 479
 480    if (do_read) {
 481       btimer_t *tid;
 482       if (ff_pkt->type == FT_FIFO) {
 483          tid = start_thread_timer(jcr, pthread_self(), 60);
 484       } else {
 485          tid = NULL;
 486       }
 487       int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
 488       ff_pkt->bfd.reparse_point = ff_pkt->type == FT_REPARSE;
 489       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
 490          ff_pkt->ff_errno = errno;
 491          berrno be;
 492          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open %s: ERR=%s.\n"), ff_pkt->fname,
 493               be.bstrerror());
 494          jcr->Errors++;
 495          if (tid) {
 496             stop_thread_timer(tid);
 497             tid = NULL;
 498          }
 499          goto good_rtn;
 500       }
 501       if (tid) {
 502          stop_thread_timer(tid);
 503          tid = NULL;
 504       }
 505
 506       stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
 507
 508       if (ff_pkt->flags & FO_CHKCHANGES) {
 509          has_file_changed(jcr, ff_pkt);
 510       }
 511
 512       bclose(&ff_pkt->bfd);
 513
 514       if (!stat) {
 515          goto bail_out;
 516       }
 517    }
 518
 519 #ifdef HAVE_DARWIN_OS
 520    /* Regular files can have resource forks and Finder Info */
 521    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 522             ff_pkt->flags & FO_HFSPLUS)) {
 523       if (ff_pkt->hfsinfo.rsrclength > 0) {
 524          int flags;
 525          int rsrc_stream;
 526          if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 527             ff_pkt->ff_errno = errno;
 528             berrno be;
 529             Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for %s: ERR=%s.\n"),
 530                  ff_pkt->fname, be.bstrerror());
 531             jcr->Errors++;
 532             if (is_bopen(&ff_pkt->bfd)) {
 533                bclose(&ff_pkt->bfd);
 534             }
 535             goto good_rtn;
 536          }
 537          flags = ff_pkt->flags;
 538          ff_pkt->flags &= ~(FO_GZIP|FO_SPARSE);
 539          if (flags & FO_ENCRYPT) {
 540             rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
 541          } else {
 542             rsrc_stream = STREAM_MACOS_FORK_DATA;
 543          }
 544          stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
 545          ff_pkt->flags = flags;
 546          bclose(&ff_pkt->bfd);
 547          if (!stat) {
 548             goto bail_out;
 549          }
 550       }
 551
 552       Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
 553       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 554       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 555       memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 556       sd->msglen = 32;
 557       if (digest) {
 558          crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
 559       }
 560       if (signing_digest) {
 561          crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
 562       }
 563       sd->send();
 564       sd->signal(BNET_EOD);
 565    }
 566 #endif
 567
 568    if (ff_pkt->flags & FO_ACL) {
 569       /* Read access ACLs for files, dirs and links */
 570       if (!read_and_send_acl(jcr, BACL_TYPE_ACCESS, STREAM_UNIX_ATTRIBUTES_ACCESS_ACL)) {
 571          goto bail_out;
 572       }
 573       /* Directories can have default ACLs too */
 574       if (ff_pkt->type == FT_DIREND && (BACL_CAP & BACL_CAP_DEFAULTS_DIR)) {
 575          if (!read_and_send_acl(jcr, BACL_TYPE_DEFAULT, STREAM_UNIX_ATTRIBUTES_DEFAULT_ACL)) {
 576             goto bail_out;
 577          }
 578       }
 579    }
 580
 581    /* Terminate the signing digest and send it to the Storage daemon */
 582    if (signing_digest) {
 583       uint32_t size = 0;
 584
 585       if ((sig = crypto_sign_new(jcr)) == NULL) {
 586          Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for crypto signature.\n"));
 587          goto bail_out;
 588       }
 589
 590       if (!crypto_sign_add_signer(sig, signing_digest, jcr->crypto.pki_keypair)) {
 591          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 592          goto bail_out;
 593       }
 594
 595       /* Get signature size */
 596       if (!crypto_sign_encode(sig, NULL, &size)) {
 597          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 598          goto bail_out;
 599       }
 600
 601       /* Grow the bsock buffer to fit our message if necessary */
 602       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 603          sd->msg = realloc_pool_memory(sd->msg, size);
 604       }
 605
 606       /* Send our header */
 607       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
 608       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 609
 610       /* Encode signature data */
 611       if (!crypto_sign_encode(sig, (uint8_t *)sd->msg, &size)) {
 612          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 613          goto bail_out;
 614       }
 615
 616       sd->msglen = size;
 617       sd->send();
 618       sd->signal(BNET_EOD);              /* end of checksum */
 619    }
 620
 621    /* Terminate any digest and send it to Storage daemon */
 622    if (digest) {
 623       uint32_t size;
 624
 625       sd->fsend("%ld %d 0", jcr->JobFiles, digest_stream);
 626       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 627
 628       size = CRYPTO_DIGEST_MAX_SIZE;
 629
 630       /* Grow the bsock buffer to fit our message if necessary */
 631       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 632          sd->msg = realloc_pool_memory(sd->msg, size);
 633       }
 634
 635       if (!crypto_digest_finalize(digest, (uint8_t *)sd->msg, &size)) {
 636          Jmsg(jcr, M_FATAL, 0, _("An error occurred finalizing signing the stream.\n"));
 637          goto bail_out;
 638       }
 639
 640       sd->msglen = size;
 641       sd->send();
 642       sd->signal(BNET_EOD);              /* end of checksum */
 643    }
 644
 645 good_rtn:
 646    rtnstat = 1;                       /* good return */
 647
 648 bail_out:
 649    if (digest) {
 650       crypto_digest_free(digest);
 651    }
 652    if (signing_digest) {
 653       crypto_digest_free(signing_digest);
 654    }
 655    if (sig) {
 656       crypto_sign_free(sig);
 657    }
 658    return rtnstat;
 659 }
 660
 661 /*
 662  * Send data read from an already open file descriptor.
 663  *
 664  * We return 1 on sucess and 0 on errors.
 665  *
 666  * ***FIXME***
 667  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 668  *  reading.
 669  * Currently this is not a problem as the only other stream, resource forks,
 670  * are not handled as sparse files.
 671  */
 672 int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 673               DIGEST *signing_digest)
 674 {
 675    BSOCK *sd = jcr->store_bsock;
 676    uint64_t fileAddr = 0;             /* file address */
 677    char *rbuf, *wbuf;
 678    int32_t rsize = jcr->buf_size;      /* read buffer size */
 679    POOLMEM *msgsave;
 680    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 681    const uint8_t *cipher_input;
 682    uint32_t cipher_input_len;
 683    uint32_t cipher_block_size;
 684    uint32_t encrypted_len;
 685 #ifdef FD_NO_SEND_TEST
 686    return 1;
 687 #endif
 688
 689    msgsave = sd->msg;
 690    rbuf = sd->msg;                    /* read buffer */
 691    wbuf = sd->msg;                    /* write buffer */
 692    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 693
 694    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 695
 696 #ifdef HAVE_LIBZ
 697    uLong compress_len = 0;
 698    uLong max_compress_len = 0;
 699    const Bytef *cbuf = NULL;
 700    int zstat;
 701
 702    if (ff_pkt->flags & FO_GZIP) {
 703       if (ff_pkt->flags & FO_SPARSE) {
 704          cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
 705          max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
 706       } else {
 707          cbuf = (Bytef *)jcr->compress_buf;
 708          max_compress_len = jcr->compress_buf_size; /* set max length */
 709       }
 710       wbuf = jcr->compress_buf;    /* compressed output here */
 711       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 712
 713       /*
 714        * Only change zlib parameters if there is no pending operation.
 715        * This should never happen as deflatereset is called after each
 716        * deflate.
 717        */
 718
 719       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 720          /* set gzip compression level - must be done per file */
 721          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 722               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 723             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 724             set_jcr_job_status(jcr, JS_ErrorTerminated);
 725             goto err;
 726          }
 727       }
 728    }
 729 #else
 730    const uint32_t max_compress_len = 0;
 731 #endif
 732
 733    if (ff_pkt->flags & FO_ENCRYPT) {
 734       if (ff_pkt->flags & FO_SPARSE) {
 735          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse data not supported.\n"));
 736          goto err;
 737       }
 738       /* Allocate the cipher context */
 739       if ((cipher_ctx = crypto_cipher_new(jcr->crypto.pki_session, true,
 740            &cipher_block_size)) == NULL) {
 741          /* Shouldn't happen! */
 742          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 743          goto err;
 744       }
 745
 746       /*
 747        * Grow the crypto buffer, if necessary.
 748        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 749        * We grow crypto_buf to the maximum number of blocks that
 750        * could be returned for the given read buffer size.
 751        * (Using the larger of either rsize or max_compress_len)
 752        */
 753       jcr->crypto.crypto_buf = check_pool_memory_size(jcr->crypto.crypto_buf,
 754            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 755             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 756
 757       wbuf = jcr->crypto.crypto_buf; /* Encrypted, possibly compressed output here. */
 758    }
 759
 760    /*
 761     * Send Data header to Storage daemon
 762     *    <file-index> <stream> <info>
 763     */
 764    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 765       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 766             sd->bstrerror());
 767       goto err;
 768    }
 769    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 770
 771    /*
 772     * Make space at beginning of buffer for fileAddr because this
 773     *   same buffer will be used for writing if compression is off.
 774     */
 775    if (ff_pkt->flags & FO_SPARSE) {
 776       rbuf += SPARSE_FADDR_SIZE;
 777       rsize -= SPARSE_FADDR_SIZE;
 778 #ifdef HAVE_FREEBSD_OS
 779       /*
 780        * To read FreeBSD partitions, the read size must be
 781        *  a multiple of 512.
 782        */
 783       rsize = (rsize/512) * 512;
 784 #endif
 785    }
 786
 787    /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
 788 #ifdef HAVE_WIN32
 789    if (S_ISBLK(ff_pkt->statp.st_mode))
 790       rsize = (rsize/512) * 512;
 791 #endif
 792
 793    /*
 794     * Read the file data
 795     */
 796    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 797
 798       /* Check for sparse blocks */
 799       if (ff_pkt->flags & FO_SPARSE) {
 800          ser_declare;
 801          bool haveBlock = true;
 802          if (sd->msglen == rsize &&
 803              fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
 804              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 805                (uint64_t)ff_pkt->statp.st_size == 0)) {
 806             haveBlock = !is_buf_zero(rbuf, rsize);
 807          }
 808          if (haveBlock) {
 809             ser_begin(wbuf, SPARSE_FADDR_SIZE);
 810             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 811          }
 812          fileAddr += sd->msglen;      /* update file address */
 813          if (!haveBlock) {
 814             continue;                 /* skip block of zeros */
 815          }
 816       }
 817
 818       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 819
 820       /* Uncompressed cipher input length */
 821       cipher_input_len = sd->msglen;
 822
 823       /* Update checksum if requested */
 824       if (digest) {
 825          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 826       }
 827
 828       /* Update signing digest if requested */
 829       if (signing_digest) {
 830          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 831       }
 832
 833 #ifdef HAVE_LIBZ
 834       /* Do compression if turned on */
 835       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 836          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 837
 838          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 839                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 840          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 841                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 842
 843          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 844             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 845             set_jcr_job_status(jcr, JS_ErrorTerminated);
 846             goto err;
 847          }
 848          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 849          /* reset zlib stream to be able to begin from scratch again */
 850          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 851             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 852             set_jcr_job_status(jcr, JS_ErrorTerminated);
 853             goto err;
 854          }
 855
 856          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 857                sd->msglen);
 858
 859          sd->msglen = compress_len;      /* set compressed length */
 860          cipher_input_len = compress_len;
 861       }
 862 #endif
 863       /*
 864        * Note, here we prepend the current record length to the beginning
 865        *  of the encrypted data. This is because both sparse and compression
 866        *  restore handling want records returned to them with exactly the
 867        *  same number of bytes that were processed in the backup handling.
 868        *  That is, both are block filters rather than a stream.  When doing
 869        *  compression, the compression routines may buffer data, so that for
 870        *  any one record compressed, when it is decompressed the same size
 871        *  will not be obtained. Of course, the buffered data eventually comes
 872        *  out in subsequent crypto_cipher_update() calls or at least
 873        *  when crypto_cipher_finalize() is called.  Unfortunately, this
 874        *  "feature" of encryption enormously complicates the restore code.
 875        */
 876       if (ff_pkt->flags & FO_ENCRYPT) {
 877          uint32_t initial_len = 0;
 878          ser_declare;
 879
 880          if (ff_pkt->flags & FO_SPARSE) {
 881             cipher_input_len += SPARSE_FADDR_SIZE;
 882          }
 883
 884          /* Encrypt the length of the input block */
 885          uint8_t packet_len[sizeof(uint32_t)];
 886
 887          ser_begin(packet_len, sizeof(uint32_t));
 888          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
 889          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
 890
 891          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
 892              (uint8_t *)jcr->crypto.crypto_buf, &initial_len)) {
 893             /* Encryption failed. Shouldn't happen. */
 894             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 895             goto err;
 896          }
 897
 898          /* Encrypt the input block */
 899          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
 900              (uint8_t *)&jcr->crypto.crypto_buf[initial_len], &encrypted_len)) {
 901             if ((initial_len + encrypted_len) == 0) {
 902                /* No full block of data available, read more data */
 903                continue;
 904             }
 905             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
 906                   sd->msglen);
 907             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
 908          } else {
 909             /* Encryption failed. Shouldn't happen. */
 910             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 911             goto err;
 912          }
 913       }
 914
 915       /* Send the buffer to the Storage daemon */
 916       if (ff_pkt->flags & FO_SPARSE) {
 917          sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 918       }
 919       sd->msg = wbuf;              /* set correct write buffer */
 920       if (!sd->send()) {
 921          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 922                sd->bstrerror());
 923          goto err;
 924       }
 925       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 926       /*          #endif */
 927       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 928       sd->msg = msgsave;                /* restore read buffer */
 929
 930    } /* end while read file data */
 931
 932    if (sd->msglen < 0) {                 /* error */
 933       berrno be;
 934       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 935          ff_pkt->fname, be.bstrerror(ff_pkt->bfd.berrno));
 936       if (jcr->Errors++ > 1000) {       /* insanity check */
 937          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
 938       }
 939    } else if (ff_pkt->flags & FO_ENCRYPT) {
 940       /*
 941        * For encryption, we must call finalize to push out any
 942        *  buffered data.
 943        */
 944       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto.crypto_buf,
 945            &encrypted_len)) {
 946          /* Padding failed. Shouldn't happen. */
 947          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
 948          goto err;
 949       }
 950
 951       /* Note, on SSL pre-0.9.7, there is always some output */
 952       if (encrypted_len > 0) {
 953          sd->msglen = encrypted_len;      /* set encrypted length */
 954          sd->msg = jcr->crypto.crypto_buf;       /* set correct write buffer */
 955          if (!sd->send()) {
 956             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 957                   sd->bstrerror());
 958             goto err;
 959          }
 960          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 961          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
 962          sd->msg = msgsave;               /* restore bnet buffer */
 963       }
 964    }
 965
 966    if (!sd->signal(BNET_EOD)) {        /* indicate end of file data */
 967       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 968             sd->bstrerror());
 969       goto err;
 970    }
 971
 972    /* Free the cipher context */
 973    if (cipher_ctx) {
 974       crypto_cipher_free(cipher_ctx);
 975    }
 976    return 1;
 977
 978 err:
 979    /* Free the cipher context */
 980    if (cipher_ctx) {
 981       crypto_cipher_free(cipher_ctx);
 982    }
 983
 984    sd->msg = msgsave; /* restore bnet buffer */
 985    sd->msglen = 0;
 986    return 0;
 987 }
 988
 989 /*
 990  * Read and send an ACL for the last encountered file.
 991  */
 992 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
 993 {
 994 #ifdef HAVE_ACL
 995    BSOCK *sd = jcr->store_bsock;
 996    POOLMEM *msgsave;
 997    int len;
 998 #ifdef FD_NO_SEND_TEST
 999    return true;
1000 #endif
1001
1002    len = bacl_get(jcr, acltype);
1003    if (len < 0) {
1004       Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
1005       return true;
1006    }
1007    if (len == 0) {
1008       return true;                    /* no ACL */
1009    }
1010
1011    /* Send header */
1012    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
1013       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1014             sd->bstrerror());
1015       return false;
1016    }
1017
1018    /* Send the buffer to the storage deamon */
1019    Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
1020    msgsave = sd->msg;
1021    sd->msg = jcr->acl_text;
1022    sd->msglen = len + 1;
1023    if (!sd->send()) {
1024       sd->msg = msgsave;
1025       sd->msglen = 0;
1026       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1027             sd->bstrerror());
1028       return false;
1029    }
1030
1031    jcr->JobBytes += sd->msglen;
1032    sd->msg = msgsave;
1033    if (!sd->signal(BNET_EOD)) {
1034       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1035             sd->bstrerror());
1036       return false;
1037    }
1038
1039    Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
1040 #endif
1041    return true;
1042 }
1043
1044 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1045 {
1046    BSOCK *sd = jcr->store_bsock;
1047    char attribs[MAXSTRING];
1048    char attribsEx[MAXSTRING];
1049    int attr_stream;
1050    int stat;
1051 #ifdef FD_NO_SEND_TEST
1052    return true;
1053 #endif
1054
1055    Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1056    /* Find what data stream we will use, then encode the attributes */
1057    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1058       /* This should not happen */
1059       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1060       return false;
1061    }
1062    encode_stat(attribs, ff_pkt, data_stream);
1063
1064    /* Now possibly extend the attributes */
1065    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1066
1067    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1068
1069    jcr->lock();
1070    jcr->JobFiles++;                    /* increment number of files sent */
1071    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1072    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1073    jcr->unlock();
1074
1075    /*
1076     * Send Attributes header to Storage daemon
1077     *    <file-index> <stream> <info>
1078     */
1079    if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1080       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1081             sd->bstrerror());
1082       return false;
1083    }
1084    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1085
1086    /*
1087     * Send file attributes to Storage daemon
1088     *   File_index
1089     *   File type
1090     *   Filename (full path)
1091     *   Encoded attributes
1092     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1093     *   Encoded extended-attributes (for Win32)
1094     *
1095     * For a directory, link is the same as fname, but with trailing
1096     * slash. For a linked file, link is the link.
1097     */
1098    strip_path(ff_pkt);
1099    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
1100       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1101       stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
1102                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
1103                attribsEx, 0);
1104    } else if (ff_pkt->type == FT_DIREND || ff_pkt->type == FT_REPARSE) {
1105       /* Here link is the canonical filename (i.e. with trailing slash) */
1106       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1107                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
1108    } else {
1109       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1110                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
1111    }
1112    unstrip_path(ff_pkt);
1113
1114    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1115    if (!stat) {
1116       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1117             sd->bstrerror());
1118       return false;
1119    }
1120    sd->signal(BNET_EOD);            /* indicate end of attributes data */
1121    return true;
1122 }
1123
1124 /*
1125  * Do in place strip of path
1126  */
1127 static bool do_strip(int count, char *in)
1128 {
1129    char *out = in;
1130    int stripped;
1131    int numsep = 0;
1132
1133    /* Copy to first path separator -- Win32 might have c: ... */
1134    while (*in && !IsPathSeparator(*in)) {
1135       *out++ = *in++;
1136    }
1137    *out++ = *in++;
1138    numsep++;                     /* one separator seen */
1139    for (stripped=0; stripped<count && *in; stripped++) {
1140       while (*in && !IsPathSeparator(*in)) {
1141          in++;                   /* skip chars */
1142       }
1143       if (*in) {
1144          numsep++;               /* count separators seen */
1145          in++;                   /* skip separator */
1146       }
1147    }
1148    /* Copy to end */
1149    while (*in) {                /* copy to end */
1150       if (IsPathSeparator(*in)) {
1151          numsep++;
1152       }
1153       *out++ = *in++;
1154    }
1155    *out = 0;
1156    Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1157          stripped, count, numsep, numsep>count);
1158    return stripped==count && numsep>count;
1159 }
1160
1161 /*
1162  * If requested strip leading components of the path
1163  */
1164 static void strip_path(FF_PKT *ff_pkt)
1165 {
1166    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1167       Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1168       return;
1169    }
1170    if (!ff_pkt->fname_save) {
1171      ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1172      ff_pkt->link_save = get_pool_memory(PM_FNAME);
1173    }
1174    pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1175
1176    /*
1177     * Strip path.  If it doesn't succeed put it back.  If
1178     *  it does, and there is a different link string,
1179     *  attempt to strip the link. If it fails, back them
1180     *  both back.
1181     * Do not strip symlinks.
1182     * I.e. if either stripping fails don't strip anything.
1183     */
1184    if (do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1185       /* Strip links but not symlinks */
1186       if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1187          pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1188          if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1189             pm_strcpy(ff_pkt->link, ff_pkt->link_save);
1190             pm_strcpy(ff_pkt->fname, ff_pkt->fname_save);
1191          }
1192       }
1193    } else {
1194       pm_strcpy(ff_pkt->fname, ff_pkt->fname_save);
1195    }
1196    Dmsg2(200, "fname=%s stripped=%s\n", ff_pkt->fname_save, ff_pkt->fname);
1197 }
1198
1199 static void unstrip_path(FF_PKT *ff_pkt)
1200 {
1201    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1202       return;
1203    }
1204    pm_strcpy(ff_pkt->fname, ff_pkt->fname_save);
1205    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1206       pm_strcpy(ff_pkt->link, ff_pkt->link_save);
1207    }
1208 }