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