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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2011 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 three of the GNU Affero 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 Affero General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /**
  29  *  Bacula File Daemon  backup.c  send file attributes and data
  30  *   to the Storage daemon.
  31  *
  32  *    Kern Sibbald, March MM
  33  *
  34  */
  35
  36 #include "bacula.h"
  37 #include "filed.h"
  38 #include "ch.h"
  39
  40 #ifdef HAVE_DARWIN_OS
  41 const bool have_darwin_os = true;
  42 #else
  43 const bool have_darwin_os = false;
  44 #endif
  45
  46 #if defined(HAVE_ACL)
  47 const bool have_acl = true;
  48 #else
  49 const bool have_acl = false;
  50 #endif
  51
  52 #if defined(HAVE_XATTR)
  53 const bool have_xattr = true;
  54 #else
  55 const bool have_xattr = false;
  56 #endif
  57
  58 /* Forward referenced functions */
  59 int save_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level);
  60 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest, DIGEST *signature_digest);
  61 bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream);
  62 static bool crypto_session_start(JCR *jcr);
  63 static void crypto_session_end(JCR *jcr);
  64 static bool crypto_session_send(JCR *jcr, BSOCK *sd);
  65 static void close_vss_backup_session(JCR *jcr);
  66
  67 /**
  68  * Find all the requested files and send them
  69  * to the Storage daemon.
  70  *
  71  * Note, we normally carry on a one-way
  72  * conversation from this point on with the SD, simply blasting
  73  * data to him.  To properly know what is going on, we
  74  * also run a "heartbeat" monitor which reads the socket and
  75  * reacts accordingly (at the moment it has nothing to do
  76  * except echo the heartbeat to the Director).
  77  *
  78  */
  79 bool blast_data_to_storage_daemon(JCR *jcr, char *addr)
  80 {
  81    BSOCK *sd;
  82    bool ok = true;
  83    // TODO landonf: Allow user to specify encryption algorithm
  84
  85    sd = jcr->store_bsock;
  86
  87    jcr->setJobStatus(JS_Running);
  88
  89    Dmsg1(300, "bfiled: opened data connection %d to stored\n", sd->m_fd);
  90
  91    LockRes();
  92    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
  93    UnlockRes();
  94    uint32_t buf_size;
  95    if (client) {
  96       buf_size = client->max_network_buffer_size;
  97    } else {
  98       buf_size = 0;                   /* use default */
  99    }
 100    if (!sd->set_buffer_size(buf_size, BNET_SETBUF_WRITE)) {
 101       jcr->setJobStatus(JS_ErrorTerminated);
 102       Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size FD->SD.\n"));
 103       return false;
 104    }
 105
 106    jcr->buf_size = sd->msglen;
 107    /**
 108     * Adjust for compression so that output buffer is
 109     *  12 bytes + 0.1% larger than input buffer plus 18 bytes.
 110     *  This gives a bit extra plus room for the sparse addr if any.
 111     *  Note, we adjust the read size to be smaller so that the
 112     *  same output buffer can be used without growing it.
 113     *
 114     *  For LZO1X compression the recommended value is :
 115     *                  output_block_size = input_block_size + (input_block_size / 16) + 64 + 3 + sizeof(comp_stream_header)
 116     *
 117     * The zlib compression workset is initialized here to minimize
 118     *  the "per file" load. The jcr member is only set, if the init
 119     *  was successful.
 120     *
 121     *  For the same reason, lzo compression is initialized here.
 122     */
 123 #ifdef HAVE_LZO
 124    jcr->compress_buf_size = MAX(jcr->buf_size + (jcr->buf_size / 16) + 67 + (int)sizeof(comp_stream_header), jcr->buf_size + ((jcr->buf_size+999) / 1000) + 30);
 125    jcr->compress_buf = get_memory(jcr->compress_buf_size);
 126 #else
 127    jcr->compress_buf_size = jcr->buf_size + ((jcr->buf_size+999) / 1000) + 30;
 128    jcr->compress_buf = get_memory(jcr->compress_buf_size);
 129 #endif
 130
 131 #ifdef HAVE_LIBZ
 132    z_stream *pZlibStream = (z_stream*)malloc(sizeof(z_stream));
 133    if (pZlibStream) {
 134       pZlibStream->zalloc = Z_NULL;
 135       pZlibStream->zfree = Z_NULL;
 136       pZlibStream->opaque = Z_NULL;
 137       pZlibStream->state = Z_NULL;
 138
 139       if (deflateInit(pZlibStream, Z_DEFAULT_COMPRESSION) == Z_OK) {
 140          jcr->pZLIB_compress_workset = pZlibStream;
 141       } else {
 142          free (pZlibStream);
 143       }
 144    }
 145 #endif
 146
 147 #ifdef HAVE_LZO
 148    lzo_voidp pLzoMem = (lzo_voidp) malloc(LZO1X_1_MEM_COMPRESS);
 149    if (pLzoMem) {
 150       if (lzo_init() == LZO_E_OK) {
 151          jcr->LZO_compress_workset = pLzoMem;
 152       } else {
 153          free (pLzoMem);
 154       }
 155    }
 156 #endif
 157
 158    if (!crypto_session_start(jcr)) {
 159       return false;
 160    }
 161
 162    set_find_options((FF_PKT *)jcr->ff, jcr->incremental, jcr->mtime);
 163
 164    /** in accurate mode, we overload the find_one check function */
 165    if (jcr->accurate) {
 166       set_find_changed_function((FF_PKT *)jcr->ff, accurate_check_file);
 167    }
 168
 169    start_heartbeat_monitor(jcr);
 170
 171    if (have_acl) {
 172       jcr->acl_data = (acl_data_t *)malloc(sizeof(acl_data_t));
 173       memset(jcr->acl_data, 0, sizeof(acl_data_t));
 174       jcr->acl_data->u.build = (acl_build_data_t *)malloc(sizeof(acl_build_data_t));
 175       memset(jcr->acl_data->u.build, 0, sizeof(acl_build_data_t));
 176       jcr->acl_data->u.build->content = get_pool_memory(PM_MESSAGE);
 177    }
 178
 179    if (have_xattr) {
 180       jcr->xattr_data = (xattr_data_t *)malloc(sizeof(xattr_data_t));
 181       memset(jcr->xattr_data, 0, sizeof(xattr_data_t));
 182       jcr->xattr_data->u.build = (xattr_build_data_t *)malloc(sizeof(xattr_build_data_t));
 183       memset(jcr->xattr_data->u.build, 0, sizeof(xattr_build_data_t));
 184       jcr->xattr_data->u.build->content = get_pool_memory(PM_MESSAGE);
 185    }
 186
 187    /** Subroutine save_file() is called for each file */
 188    if (!find_files(jcr, (FF_PKT *)jcr->ff, save_file, plugin_save)) {
 189       ok = false;                     /* error */
 190       jcr->setJobStatus(JS_ErrorTerminated);
 191    }
 192
 193    if (have_acl && jcr->acl_data->u.build->nr_errors > 0) {
 194       Jmsg(jcr, M_WARNING, 0, _("Encountered %ld acl errors while doing backup\n"),
 195            jcr->acl_data->u.build->nr_errors);
 196    }
 197    if (have_xattr && jcr->xattr_data->u.build->nr_errors > 0) {
 198       Jmsg(jcr, M_WARNING, 0, _("Encountered %ld xattr errors while doing backup\n"),
 199            jcr->xattr_data->u.build->nr_errors);
 200    }
 201
 202    close_vss_backup_session(jcr);
 203
 204    accurate_finish(jcr);              /* send deleted or base file list to SD */
 205
 206    stop_heartbeat_monitor(jcr);
 207
 208    sd->signal(BNET_EOD);            /* end of sending data */
 209
 210    if (have_acl && jcr->acl_data) {
 211       free_pool_memory(jcr->acl_data->u.build->content);
 212       free(jcr->acl_data->u.build);
 213       free(jcr->acl_data);
 214       jcr->acl_data = NULL;
 215    }
 216    if (have_xattr && jcr->xattr_data) {
 217       free_pool_memory(jcr->xattr_data->u.build->content);
 218       free(jcr->xattr_data->u.build);
 219       free(jcr->xattr_data);
 220       jcr->xattr_data = NULL;
 221    }
 222    if (jcr->big_buf) {
 223       free(jcr->big_buf);
 224       jcr->big_buf = NULL;
 225    }
 226    if (jcr->compress_buf) {
 227       free_pool_memory(jcr->compress_buf);
 228       jcr->compress_buf = NULL;
 229    }
 230    if (jcr->pZLIB_compress_workset) {
 231       /* Free the zlib stream */
 232 #ifdef HAVE_LIBZ
 233       deflateEnd((z_stream *)jcr->pZLIB_compress_workset);
 234 #endif
 235       free (jcr->pZLIB_compress_workset);
 236       jcr->pZLIB_compress_workset = NULL;
 237    }
 238    if (jcr->LZO_compress_workset) {
 239       free (jcr->LZO_compress_workset);
 240       jcr->LZO_compress_workset = NULL;
 241    }
 242
 243    crypto_session_end(jcr);
 244
 245
 246    Dmsg1(100, "end blast_data ok=%d\n", ok);
 247    return ok;
 248 }
 249
 250 static bool crypto_session_start(JCR *jcr)
 251 {
 252    crypto_cipher_t cipher = CRYPTO_CIPHER_AES_128_CBC;
 253
 254    /**
 255     * Create encryption session data and a cached, DER-encoded session data
 256     * structure. We use a single session key for each backup, so we'll encode
 257     * the session data only once.
 258     */
 259    if (jcr->crypto.pki_encrypt) {
 260       uint32_t size = 0;
 261
 262       /** Create per-job session encryption context */
 263       jcr->crypto.pki_session = crypto_session_new(cipher, jcr->crypto.pki_recipients);
 264
 265       /** Get the session data size */
 266       if (!crypto_session_encode(jcr->crypto.pki_session, (uint8_t *)0, &size)) {
 267          Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
 268          return false;
 269       }
 270
 271       /** Allocate buffer */
 272       jcr->crypto.pki_session_encoded = get_memory(size);
 273
 274       /** Encode session data */
 275       if (!crypto_session_encode(jcr->crypto.pki_session, (uint8_t *)jcr->crypto.pki_session_encoded, &size)) {
 276          Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
 277          return false;
 278       }
 279
 280       /** ... and store the encoded size */
 281       jcr->crypto.pki_session_encoded_size = size;
 282
 283       /** Allocate the encryption/decryption buffer */
 284       jcr->crypto.crypto_buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 285    }
 286    return true;
 287 }
 288
 289 static void crypto_session_end(JCR *jcr)
 290 {
 291    if (jcr->crypto.crypto_buf) {
 292       free_pool_memory(jcr->crypto.crypto_buf);
 293       jcr->crypto.crypto_buf = NULL;
 294    }
 295    if (jcr->crypto.pki_session) {
 296       crypto_session_free(jcr->crypto.pki_session);
 297    }
 298    if (jcr->crypto.pki_session_encoded) {
 299       free_pool_memory(jcr->crypto.pki_session_encoded);
 300       jcr->crypto.pki_session_encoded = NULL;
 301    }
 302 }
 303
 304 static bool crypto_session_send(JCR *jcr, BSOCK *sd)
 305 {
 306    POOLMEM *msgsave;
 307
 308    /** Send our header */
 309    Dmsg2(100, "Send hdr fi=%ld stream=%d\n", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 310    sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 311
 312    msgsave = sd->msg;
 313    sd->msg = jcr->crypto.pki_session_encoded;
 314    sd->msglen = jcr->crypto.pki_session_encoded_size;
 315    jcr->JobBytes += sd->msglen;
 316
 317    Dmsg1(100, "Send data len=%d\n", sd->msglen);
 318    sd->send();
 319    sd->msg = msgsave;
 320    sd->signal(BNET_EOD);
 321    return true;
 322 }
 323
 324
 325 /**
 326  * Called here by find() for each file included.
 327  *   This is a callback. The original is find_files() above.
 328  *
 329  *  Send the file and its data to the Storage daemon.
 330  *
 331  *  Returns: 1 if OK
 332  *           0 if error
 333  *          -1 to ignore file/directory (not used here)
 334  */
 335 int save_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
 336 {
 337    bool do_read = false;
 338    bool plugin_started = false;
 339    bool do_plugin_set = false;
 340    int stat, data_stream;
 341    int rtnstat = 0;
 342    DIGEST *digest = NULL;
 343    DIGEST *signing_digest = NULL;
 344    int digest_stream = STREAM_NONE;
 345    SIGNATURE *sig = NULL;
 346    bool has_file_data = false;
 347    struct save_pkt sp;          /* use by option plugin */
 348    // TODO landonf: Allow the user to specify the digest algorithm
 349 #ifdef HAVE_SHA2
 350    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA256;
 351 #else
 352    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA1;
 353 #endif
 354    BSOCK *sd = jcr->store_bsock;
 355
 356    if (jcr->is_canceled() || jcr->is_incomplete()) {
 357       return 0;
 358    }
 359
 360    jcr->num_files_examined++;         /* bump total file count */
 361
 362    switch (ff_pkt->type) {
 363    case FT_LNKSAVED:                  /* Hard linked, file already saved */
 364       Dmsg2(130, "FT_LNKSAVED hard link: %s => %s\n", ff_pkt->fname, ff_pkt->link);
 365       break;
 366    case FT_REGE:
 367       Dmsg1(130, "FT_REGE saving: %s\n", ff_pkt->fname);
 368       has_file_data = true;
 369       break;
 370    case FT_REG:
 371       Dmsg1(130, "FT_REG saving: %s\n", ff_pkt->fname);
 372       has_file_data = true;
 373       break;
 374    case FT_LNK:
 375       Dmsg2(130, "FT_LNK saving: %s -> %s\n", ff_pkt->fname, ff_pkt->link);
 376       break;
 377    case FT_RESTORE_FIRST:
 378       Dmsg1(100, "FT_RESTORE_FIRST saving: %s\n", ff_pkt->fname);
 379       break;
 380    case FT_PLUGIN_CONFIG:
 381       Dmsg1(100, "FT_PLUGIN_CONFIG saving: %s\n", ff_pkt->fname);
 382       break;
 383    case FT_DIRBEGIN:
 384       jcr->num_files_examined--;      /* correct file count */
 385       return 1;                       /* not used */
 386    case FT_NORECURSE:
 387       Jmsg(jcr, M_INFO, 1, _("     Recursion turned off. Will not descend from %s into %s\n"),
 388            ff_pkt->top_fname, ff_pkt->fname);
 389       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 390       break;
 391    case FT_NOFSCHG:
 392       /* Suppress message for /dev filesystems */
 393       if (!is_in_fileset(ff_pkt)) {
 394          Jmsg(jcr, M_INFO, 1, _("     %s is a different filesystem. Will not descend from %s into it.\n"),
 395               ff_pkt->fname, ff_pkt->top_fname);
 396       }
 397       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 398       break;
 399    case FT_INVALIDFS:
 400       Jmsg(jcr, M_INFO, 1, _("     Disallowed filesystem. Will not descend from %s into %s\n"),
 401            ff_pkt->top_fname, ff_pkt->fname);
 402       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 403       break;
 404    case FT_INVALIDDT:
 405       Jmsg(jcr, M_INFO, 1, _("     Disallowed drive type. Will not descend into %s\n"),
 406            ff_pkt->fname);
 407       break;
 408    case FT_REPARSE:
 409    case FT_JUNCTION:
 410    case FT_DIREND:
 411       Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
 412       break;
 413    case FT_SPEC:
 414       Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
 415       if (S_ISSOCK(ff_pkt->statp.st_mode)) {
 416         Jmsg(jcr, M_SKIPPED, 1, _("     Socket file skipped: %s\n"), ff_pkt->fname);
 417         return 1;
 418       }
 419       break;
 420    case FT_RAW:
 421       Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
 422       has_file_data = true;
 423       break;
 424    case FT_FIFO:
 425       Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
 426       break;
 427    case FT_NOACCESS: {
 428       berrno be;
 429       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not access \"%s\": ERR=%s\n"), ff_pkt->fname,
 430          be.bstrerror(ff_pkt->ff_errno));
 431       jcr->JobErrors++;
 432       return 1;
 433    }
 434    case FT_NOFOLLOW: {
 435       berrno be;
 436       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not follow link \"%s\": ERR=%s\n"),
 437            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 438       jcr->JobErrors++;
 439       return 1;
 440    }
 441    case FT_NOSTAT: {
 442       berrno be;
 443       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not stat \"%s\": ERR=%s\n"), ff_pkt->fname,
 444          be.bstrerror(ff_pkt->ff_errno));
 445       jcr->JobErrors++;
 446       return 1;
 447    }
 448    case FT_DIRNOCHG:
 449    case FT_NOCHG:
 450       Jmsg(jcr, M_SKIPPED, 1, _("     Unchanged file skipped: %s\n"), ff_pkt->fname);
 451       return 1;
 452    case FT_ISARCH:
 453       Jmsg(jcr, M_NOTSAVED, 0, _("     Archive file not saved: %s\n"), ff_pkt->fname);
 454       return 1;
 455    case FT_NOOPEN: {
 456       berrno be;
 457       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not open directory \"%s\": ERR=%s\n"),
 458            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 459       jcr->JobErrors++;
 460       return 1;
 461    }
 462    default:
 463       Jmsg(jcr, M_NOTSAVED, 0,  _("     Unknown file type %d; not saved: %s\n"),
 464            ff_pkt->type, ff_pkt->fname);
 465       jcr->JobErrors++;
 466       return 1;
 467    }
 468
 469    Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
 470
 471    /** Digests and encryption are only useful if there's file data */
 472    if (has_file_data) {
 473       /**
 474        * Setup for digest handling. If this fails, the digest will be set to NULL
 475        * and not used. Note, the digest (file hash) can be any one of the four
 476        * algorithms below.
 477        *
 478        * The signing digest is a single algorithm depending on
 479        * whether or not we have SHA2.
 480        *   ****FIXME****  the signing algoritm should really be
 481        *   determined a different way!!!!!!  What happens if
 482        *   sha2 was available during backup but not restore?
 483        */
 484       if (ff_pkt->flags & FO_MD5) {
 485          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_MD5);
 486          digest_stream = STREAM_MD5_DIGEST;
 487
 488       } else if (ff_pkt->flags & FO_SHA1) {
 489          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA1);
 490          digest_stream = STREAM_SHA1_DIGEST;
 491
 492       } else if (ff_pkt->flags & FO_SHA256) {
 493          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA256);
 494          digest_stream = STREAM_SHA256_DIGEST;
 495
 496       } else if (ff_pkt->flags & FO_SHA512) {
 497          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA512);
 498          digest_stream = STREAM_SHA512_DIGEST;
 499       }
 500
 501       /** Did digest initialization fail? */
 502       if (digest_stream != STREAM_NONE && digest == NULL) {
 503          Jmsg(jcr, M_WARNING, 0, _("%s digest initialization failed\n"),
 504             stream_to_ascii(digest_stream));
 505       }
 506
 507       /**
 508        * Set up signature digest handling. If this fails, the signature digest
 509        * will be set to NULL and not used.
 510        */
 511       /* TODO landonf: We should really only calculate the digest once, for
 512        * both verification and signing.
 513        */
 514       if (jcr->crypto.pki_sign) {
 515          signing_digest = crypto_digest_new(jcr, signing_algorithm);
 516
 517          /** Full-stop if a failure occurred initializing the signature digest */
 518          if (signing_digest == NULL) {
 519             Jmsg(jcr, M_NOTSAVED, 0, _("%s signature digest initialization failed\n"),
 520                stream_to_ascii(signing_algorithm));
 521             jcr->JobErrors++;
 522             goto good_rtn;
 523          }
 524       }
 525
 526       /** Enable encryption */
 527       if (jcr->crypto.pki_encrypt) {
 528          ff_pkt->flags |= FO_ENCRYPT;
 529       }
 530    }
 531
 532    /** Initialize the file descriptor we use for data and other streams. */
 533    binit(&ff_pkt->bfd);
 534    if (ff_pkt->flags & FO_PORTABLE) {
 535       set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
 536    }
 537
 538    if (ff_pkt->cmd_plugin) {
 539       do_plugin_set = true;
 540
 541    /* option and cmd plugin are not compatible together */
 542    } else if (ff_pkt->opt_plugin) {
 543
 544       /* ask the option plugin what to do with this file */
 545       switch (plugin_option_handle_file(jcr, ff_pkt, &sp)) {
 546       case bRC_OK:
 547          Dmsg2(10, "Option plugin %s will be used to backup %s\n",
 548                ff_pkt->plugin, ff_pkt->fname);
 549          do_plugin_set = true;
 550          break;
 551       case bRC_Skip:
 552          Dmsg2(10, "Option plugin %s decided to skip %s\n",
 553                ff_pkt->plugin, ff_pkt->fname);
 554          goto good_rtn;
 555       default:
 556          Dmsg2(10, "Option plugin %s decided to let bacula handle %s\n",
 557                ff_pkt->plugin, ff_pkt->fname);
 558          break;
 559       }
 560    }
 561
 562    if (do_plugin_set) {
 563       /* Tell bfile that it needs to call plugin */
 564       if (!set_cmd_plugin(&ff_pkt->bfd, jcr)) {
 565          goto bail_out;
 566       }
 567       send_plugin_name(jcr, sd, true);      /* signal start of plugin data */
 568       plugin_started = true;
 569    }
 570
 571    /** Send attributes -- must be done after binit() */
 572    if (!encode_and_send_attributes(jcr, ff_pkt, data_stream)) {
 573       goto bail_out;
 574    }
 575    /** Meta data only for restore object */
 576    if (IS_FT_OBJECT(ff_pkt->type)) {
 577       goto good_rtn;
 578    }
 579
 580    /** Set up the encryption context and send the session data to the SD */
 581    if (has_file_data && jcr->crypto.pki_encrypt) {
 582       if (!crypto_session_send(jcr, sd)) {
 583          goto bail_out;
 584       }
 585    }
 586
 587    /**
 588     * Open any file with data that we intend to save, then save it.
 589     *
 590     * Note, if is_win32_backup, we must open the Directory so that
 591     * the BackupRead will save its permissions and ownership streams.
 592     */
 593    if (ff_pkt->type != FT_LNKSAVED && S_ISREG(ff_pkt->statp.st_mode)) {
 594 #ifdef HAVE_WIN32
 595       do_read = !is_portable_backup(&ff_pkt->bfd) || ff_pkt->statp.st_size > 0;
 596 #else
 597       do_read = ff_pkt->statp.st_size > 0;
 598 #endif
 599    } else if (ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
 600               ff_pkt->type == FT_REPARSE || ff_pkt->type == FT_JUNCTION ||
 601          (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
 602       do_read = true;
 603    }
 604
 605    if (ff_pkt->cmd_plugin) {
 606       do_read = true;
 607    }
 608
 609    Dmsg2(150, "type=%d do_read=%d\n", ff_pkt->type, do_read);
 610    if (do_read) {
 611       btimer_t *tid;
 612
 613       if (ff_pkt->type == FT_FIFO) {
 614          tid = start_thread_timer(jcr, pthread_self(), 60);
 615       } else {
 616          tid = NULL;
 617       }
 618       int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
 619       ff_pkt->bfd.reparse_point = (ff_pkt->type == FT_REPARSE ||
 620                                    ff_pkt->type == FT_JUNCTION);
 621       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
 622          ff_pkt->ff_errno = errno;
 623          berrno be;
 624          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open \"%s\": ERR=%s.\n"), ff_pkt->fname,
 625               be.bstrerror());
 626          jcr->JobErrors++;
 627          if (tid) {
 628             stop_thread_timer(tid);
 629             tid = NULL;
 630          }
 631          goto good_rtn;
 632       }
 633       if (tid) {
 634          stop_thread_timer(tid);
 635          tid = NULL;
 636       }
 637
 638       stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
 639
 640       if (ff_pkt->flags & FO_CHKCHANGES) {
 641          has_file_changed(jcr, ff_pkt);
 642       }
 643
 644       bclose(&ff_pkt->bfd);
 645
 646       if (!stat) {
 647          goto bail_out;
 648       }
 649    }
 650
 651    if (have_darwin_os) {
 652       /** Regular files can have resource forks and Finder Info */
 653       if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 654           ff_pkt->flags & FO_HFSPLUS)) {
 655          if (ff_pkt->hfsinfo.rsrclength > 0) {
 656             int flags;
 657             int rsrc_stream;
 658             if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 659                ff_pkt->ff_errno = errno;
 660                berrno be;
 661                Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for \"%s\": ERR=%s.\n"),
 662                     ff_pkt->fname, be.bstrerror());
 663                jcr->JobErrors++;
 664                if (is_bopen(&ff_pkt->bfd)) {
 665                   bclose(&ff_pkt->bfd);
 666                }
 667                goto good_rtn;
 668             }
 669             flags = ff_pkt->flags;
 670             ff_pkt->flags &= ~(FO_COMPRESS|FO_SPARSE|FO_OFFSETS);
 671             if (flags & FO_ENCRYPT) {
 672                rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
 673             } else {
 674                rsrc_stream = STREAM_MACOS_FORK_DATA;
 675             }
 676             stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
 677             ff_pkt->flags = flags;
 678             bclose(&ff_pkt->bfd);
 679             if (!stat) {
 680                goto bail_out;
 681             }
 682          }
 683
 684          Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
 685          sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 686          Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 687          pm_memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 688          sd->msglen = 32;
 689          if (digest) {
 690             crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
 691          }
 692          if (signing_digest) {
 693             crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
 694          }
 695          sd->send();
 696          sd->signal(BNET_EOD);
 697       }
 698    }
 699
 700    /**
 701     * Save ACLs when requested and available for anything not being a symlink
 702     * and not being a plugin.
 703     */
 704    if (have_acl) {
 705       if (ff_pkt->flags & FO_ACL && ff_pkt->type != FT_LNK && !ff_pkt->cmd_plugin) {
 706          switch (build_acl_streams(jcr, ff_pkt)) {
 707          case bacl_exit_fatal:
 708             goto bail_out;
 709          case bacl_exit_error:
 710             /**
 711              * Non-fatal errors, count them and when the number is under
 712              * ACL_REPORT_ERR_MAX_PER_JOB print the error message set by the
 713              * lower level routine in jcr->errmsg.
 714              */
 715             if (jcr->acl_data->u.build->nr_errors < ACL_REPORT_ERR_MAX_PER_JOB) {
 716                Jmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
 717             }
 718             jcr->acl_data->u.build->nr_errors++;
 719             break;
 720          case bacl_exit_ok:
 721             break;
 722          }
 723       }
 724    }
 725
 726    /**
 727     * Save Extended Attributes when requested and available for all files not
 728     * being a plugin.
 729     */
 730    if (have_xattr) {
 731       if (ff_pkt->flags & FO_XATTR && !ff_pkt->cmd_plugin) {
 732          switch (build_xattr_streams(jcr, ff_pkt)) {
 733          case bxattr_exit_fatal:
 734             goto bail_out;
 735          case bxattr_exit_error:
 736             /**
 737              * Non-fatal errors, count them and when the number is under
 738              * XATTR_REPORT_ERR_MAX_PER_JOB print the error message set by the
 739              * lower level routine in jcr->errmsg.
 740              */
 741             if (jcr->xattr_data->u.build->nr_errors < XATTR_REPORT_ERR_MAX_PER_JOB) {
 742                Jmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
 743             }
 744             jcr->xattr_data->u.build->nr_errors++;
 745             break;
 746          case bxattr_exit_ok:
 747             break;
 748          }
 749       }
 750    }
 751
 752    /** Terminate the signing digest and send it to the Storage daemon */
 753    if (signing_digest) {
 754       uint32_t size = 0;
 755
 756       if ((sig = crypto_sign_new(jcr)) == NULL) {
 757          Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for crypto signature.\n"));
 758          goto bail_out;
 759       }
 760
 761       if (!crypto_sign_add_signer(sig, signing_digest, jcr->crypto.pki_keypair)) {
 762          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 763          goto bail_out;
 764       }
 765
 766       /** Get signature size */
 767       if (!crypto_sign_encode(sig, NULL, &size)) {
 768          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 769          goto bail_out;
 770       }
 771
 772       /** Grow the bsock buffer to fit our message if necessary */
 773       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 774          sd->msg = realloc_pool_memory(sd->msg, size);
 775       }
 776
 777       /** Send our header */
 778       sd->fsend("%ld %ld 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
 779       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 780
 781       /** Encode signature data */
 782       if (!crypto_sign_encode(sig, (uint8_t *)sd->msg, &size)) {
 783          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 784          goto bail_out;
 785       }
 786
 787       sd->msglen = size;
 788       sd->send();
 789       sd->signal(BNET_EOD);              /* end of checksum */
 790    }
 791
 792    /** Terminate any digest and send it to Storage daemon */
 793    if (digest) {
 794       uint32_t size;
 795
 796       sd->fsend("%ld %d 0", jcr->JobFiles, digest_stream);
 797       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 798
 799       size = CRYPTO_DIGEST_MAX_SIZE;
 800
 801       /** Grow the bsock buffer to fit our message if necessary */
 802       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 803          sd->msg = realloc_pool_memory(sd->msg, size);
 804       }
 805
 806       if (!crypto_digest_finalize(digest, (uint8_t *)sd->msg, &size)) {
 807          Jmsg(jcr, M_FATAL, 0, _("An error occurred finalizing signing the stream.\n"));
 808          goto bail_out;
 809       }
 810
 811       /* Keep the checksum if this file is a hardlink */
 812       if (ff_pkt->linked) {
 813          ff_pkt_set_link_digest(ff_pkt, digest_stream, sd->msg, size);
 814       }
 815
 816       sd->msglen = size;
 817       sd->send();
 818       sd->signal(BNET_EOD);              /* end of checksum */
 819    }
 820
 821    /* Check if original file has a digest, and send it */
 822    if (ff_pkt->type == FT_LNKSAVED && ff_pkt->digest) {
 823       Dmsg2(300, "Link %s digest %d\n", ff_pkt->fname, ff_pkt->digest_len);
 824       sd->fsend("%ld %d 0", jcr->JobFiles, ff_pkt->digest_stream);
 825
 826       sd->msg = check_pool_memory_size(sd->msg, ff_pkt->digest_len);
 827       memcpy(sd->msg, ff_pkt->digest, ff_pkt->digest_len);
 828       sd->msglen = ff_pkt->digest_len;
 829       sd->send();
 830
 831       sd->signal(BNET_EOD);              /* end of hardlink record */
 832    }
 833
 834 good_rtn:
 835    rtnstat = jcr->is_canceled() ? 0 : 1; /* good return if not canceled */
 836
 837 bail_out:
 838    if (jcr->is_incomplete() || jcr->is_canceled()) {
 839       rtnstat = 0;
 840    }
 841    if (plugin_started) {
 842       send_plugin_name(jcr, sd, false); /* signal end of plugin data */
 843    }
 844    if (ff_pkt->opt_plugin) {
 845       jcr->plugin_sp = NULL;    /* sp is local to this function */
 846       jcr->plugin_ctx = NULL;
 847       jcr->plugin = NULL;
 848       jcr->opt_plugin = false;
 849    }
 850    if (digest) {
 851       crypto_digest_free(digest);
 852    }
 853    if (signing_digest) {
 854       crypto_digest_free(signing_digest);
 855    }
 856    if (sig) {
 857       crypto_sign_free(sig);
 858    }
 859    return rtnstat;
 860 }
 861
 862 /**
 863  * Send data read from an already open file descriptor.
 864  *
 865  * We return 1 on sucess and 0 on errors.
 866  *
 867  * ***FIXME***
 868  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 869  *  reading.
 870  * Currently this is not a problem as the only other stream, resource forks,
 871  * are not handled as sparse files.
 872  */
 873 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 874                      DIGEST *signing_digest)
 875 {
 876    BSOCK *sd = jcr->store_bsock;
 877    uint64_t fileAddr = 0;             /* file address */
 878    char *rbuf, *wbuf;
 879    int32_t rsize = jcr->buf_size;      /* read buffer size */
 880    POOLMEM *msgsave;
 881    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 882    const uint8_t *cipher_input;
 883    uint32_t cipher_input_len;
 884    uint32_t cipher_block_size;
 885    uint32_t encrypted_len;
 886 #ifdef FD_NO_SEND_TEST
 887    return 1;
 888 #endif
 889
 890    msgsave = sd->msg;
 891    rbuf = sd->msg;                    /* read buffer */
 892    wbuf = sd->msg;                    /* write buffer */
 893    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 894
 895    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 896
 897 #if defined(HAVE_LIBZ) || defined(HAVE_LZO)
 898    uLong compress_len = 0;
 899    uLong max_compress_len = 0;
 900    const Bytef *cbuf = NULL;
 901  #ifdef HAVE_LIBZ
 902    int zstat;
 903
 904    if ((ff_pkt->flags & FO_COMPRESS) && ff_pkt->Compress_algo == COMPRESS_GZIP) {
 905       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 906          cbuf = (Bytef *)jcr->compress_buf + OFFSET_FADDR_SIZE;
 907          max_compress_len = jcr->compress_buf_size - OFFSET_FADDR_SIZE;
 908       } else {
 909          cbuf = (Bytef *)jcr->compress_buf;
 910          max_compress_len = jcr->compress_buf_size; /* set max length */
 911       }
 912       wbuf = jcr->compress_buf;    /* compressed output here */
 913       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 914
 915       /**
 916        * Only change zlib parameters if there is no pending operation.
 917        * This should never happen as deflatereset is called after each
 918        * deflate.
 919        */
 920
 921       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 922          /** set gzip compression level - must be done per file */
 923          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 924               ff_pkt->Compress_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 925             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 926             jcr->setJobStatus(JS_ErrorTerminated);
 927             goto err;
 928          }
 929       }
 930    }
 931  #endif
 932  #ifdef HAVE_LZO
 933    Bytef *cbuf2;
 934    int lzores;
 935    comp_stream_header ch;
 936
 937    memset(&ch, 0, sizeof(comp_stream_header));
 938    cbuf2 = NULL;
 939
 940    if ((ff_pkt->flags & FO_COMPRESS) && ff_pkt->Compress_algo == COMPRESS_LZO1X) {
 941       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 942          cbuf = (Bytef *)jcr->compress_buf + OFFSET_FADDR_SIZE;
 943          cbuf2 = (Bytef *)jcr->compress_buf + OFFSET_FADDR_SIZE + sizeof(comp_stream_header);
 944          max_compress_len = jcr->compress_buf_size - OFFSET_FADDR_SIZE;
 945       } else {
 946          cbuf = (Bytef *)jcr->compress_buf;
 947          cbuf2 = (Bytef *)jcr->compress_buf + sizeof(comp_stream_header);
 948          max_compress_len = jcr->compress_buf_size; /* set max length */
 949       }
 950       ch.magic = COMPRESS_LZO1X;
 951       ch.version = COMP_HEAD_VERSION;
 952       wbuf = jcr->compress_buf;    /* compressed output here */
 953       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 954    }
 955  #endif
 956 #else
 957    const uint32_t max_compress_len = 0;
 958 #endif
 959
 960    if (ff_pkt->flags & FO_ENCRYPT) {
 961       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 962          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse or offset data not supported.\n"));
 963          goto err;
 964       }
 965       /** Allocate the cipher context */
 966       if ((cipher_ctx = crypto_cipher_new(jcr->crypto.pki_session, true,
 967            &cipher_block_size)) == NULL) {
 968          /* Shouldn't happen! */
 969          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 970          goto err;
 971       }
 972
 973       /**
 974        * Grow the crypto buffer, if necessary.
 975        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 976        * We grow crypto_buf to the maximum number of blocks that
 977        * could be returned for the given read buffer size.
 978        * (Using the larger of either rsize or max_compress_len)
 979        */
 980       jcr->crypto.crypto_buf = check_pool_memory_size(jcr->crypto.crypto_buf,
 981            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 982             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 983
 984       wbuf = jcr->crypto.crypto_buf; /* Encrypted, possibly compressed output here. */
 985    }
 986
 987    /**
 988     * Send Data header to Storage daemon
 989     *    <file-index> <stream> <info>
 990     */
 991    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 992       if (!jcr->is_job_canceled()) {
 993          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 994                sd->bstrerror());
 995       }
 996       goto err;
 997    }
 998    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 999
1000    /**
1001     * Make space at beginning of buffer for fileAddr because this
1002     *   same buffer will be used for writing if compression is off.
1003     */
1004    if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
1005       rbuf += OFFSET_FADDR_SIZE;
1006       rsize -= OFFSET_FADDR_SIZE;
1007 #ifdef HAVE_FREEBSD_OS
1008       /**
1009        * To read FreeBSD partitions, the read size must be
1010        *  a multiple of 512.
1011        */
1012       rsize = (rsize/512) * 512;
1013 #endif
1014    }
1015
1016    /** a RAW device read on win32 only works if the buffer is a multiple of 512 */
1017 #ifdef HAVE_WIN32
1018    if (S_ISBLK(ff_pkt->statp.st_mode))
1019       rsize = (rsize/512) * 512;
1020 #endif
1021
1022    /**
1023     * Read the file data
1024     */
1025    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
1026
1027       /** Check for sparse blocks */
1028       if (ff_pkt->flags & FO_SPARSE) {
1029          ser_declare;
1030          bool allZeros = false;
1031          if ((sd->msglen == rsize &&
1032               fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size) ||
1033              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
1034                (uint64_t)ff_pkt->statp.st_size == 0)) {
1035             allZeros = is_buf_zero(rbuf, rsize);
1036          }
1037          if (!allZeros) {
1038             /** Put file address as first data in buffer */
1039             ser_begin(wbuf, OFFSET_FADDR_SIZE);
1040             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
1041          }
1042          fileAddr += sd->msglen;      /* update file address */
1043          /** Skip block of all zeros */
1044          if (allZeros) {
1045             continue;                 /* skip block of zeros */
1046          }
1047       } else if (ff_pkt->flags & FO_OFFSETS) {
1048          ser_declare;
1049          ser_begin(wbuf, OFFSET_FADDR_SIZE);
1050          ser_uint64(ff_pkt->bfd.offset);     /* store offset in begin of buffer */
1051       }
1052
1053       jcr->ReadBytes += sd->msglen;         /* count bytes read */
1054
1055       /** Uncompressed cipher input length */
1056       cipher_input_len = sd->msglen;
1057
1058       /** Update checksum if requested */
1059       if (digest) {
1060          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
1061       }
1062
1063       /** Update signing digest if requested */
1064       if (signing_digest) {
1065          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
1066       }
1067
1068 #ifdef HAVE_LIBZ
1069       /** Do compression if turned on */
1070       if (ff_pkt->flags & FO_COMPRESS && ff_pkt->Compress_algo == COMPRESS_GZIP && jcr->pZLIB_compress_workset) {
1071          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
1072
1073          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
1074                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
1075          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
1076                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
1077
1078          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
1079             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
1080             jcr->setJobStatus(JS_ErrorTerminated);
1081             goto err;
1082          }
1083          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
1084          /** reset zlib stream to be able to begin from scratch again */
1085          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
1086             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
1087             jcr->setJobStatus(JS_ErrorTerminated);
1088             goto err;
1089          }
1090
1091          Dmsg2(400, "GZIP compressed len=%d uncompressed len=%d\n", compress_len,
1092                sd->msglen);
1093
1094          sd->msglen = compress_len;      /* set compressed length */
1095          cipher_input_len = compress_len;
1096       }
1097 #endif
1098 #ifdef HAVE_LZO
1099       /** Do compression if turned on */
1100       if (ff_pkt->flags & FO_COMPRESS && ff_pkt->Compress_algo == COMPRESS_LZO1X && jcr->LZO_compress_workset) {
1101          ser_declare;
1102          ser_begin(cbuf, sizeof(comp_stream_header));
1103
1104          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
1105
1106          lzores = lzo1x_1_compress((const unsigned char*)rbuf, sd->msglen, cbuf2, &compress_len, jcr->LZO_compress_workset);
1107          if (lzores == LZO_E_OK && compress_len <= max_compress_len)
1108          {
1109             /* complete header */
1110             ser_uint32(COMPRESS_LZO1X);
1111             ser_uint32(compress_len);
1112             ser_uint16(ch.level);
1113             ser_uint16(ch.version);
1114          } else {
1115             /** this should NEVER happen */
1116             Jmsg(jcr, M_FATAL, 0, _("Compression LZO error: %d\n"), lzores);
1117             jcr->setJobStatus(JS_ErrorTerminated);
1118             goto err;
1119          }
1120
1121          Dmsg2(400, "LZO compressed len=%d uncompressed len=%d\n", compress_len,
1122                sd->msglen);
1123
1124          compress_len += sizeof(comp_stream_header); /* add size of header */
1125          sd->msglen = compress_len;      /* set compressed length */
1126          cipher_input_len = compress_len;
1127       }
1128 #endif
1129
1130       /**
1131        * Note, here we prepend the current record length to the beginning
1132        *  of the encrypted data. This is because both sparse and compression
1133        *  restore handling want records returned to them with exactly the
1134        *  same number of bytes that were processed in the backup handling.
1135        *  That is, both are block filters rather than a stream.  When doing
1136        *  compression, the compression routines may buffer data, so that for
1137        *  any one record compressed, when it is decompressed the same size
1138        *  will not be obtained. Of course, the buffered data eventually comes
1139        *  out in subsequent crypto_cipher_update() calls or at least
1140        *  when crypto_cipher_finalize() is called.  Unfortunately, this
1141        *  "feature" of encryption enormously complicates the restore code.
1142        */
1143       if (ff_pkt->flags & FO_ENCRYPT) {
1144          uint32_t initial_len = 0;
1145          ser_declare;
1146
1147          if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
1148             cipher_input_len += OFFSET_FADDR_SIZE;
1149          }
1150
1151          /** Encrypt the length of the input block */
1152          uint8_t packet_len[sizeof(uint32_t)];
1153
1154          ser_begin(packet_len, sizeof(uint32_t));
1155          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
1156          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
1157
1158          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
1159              (uint8_t *)jcr->crypto.crypto_buf, &initial_len)) {
1160             /** Encryption failed. Shouldn't happen. */
1161             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
1162             goto err;
1163          }
1164
1165          /** Encrypt the input block */
1166          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
1167              (uint8_t *)&jcr->crypto.crypto_buf[initial_len], &encrypted_len)) {
1168             if ((initial_len + encrypted_len) == 0) {
1169                /** No full block of data available, read more data */
1170                continue;
1171             }
1172             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
1173                   sd->msglen);
1174             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
1175          } else {
1176             /** Encryption failed. Shouldn't happen. */
1177             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
1178             goto err;
1179          }
1180       }
1181
1182       /* Send the buffer to the Storage daemon */
1183       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
1184          sd->msglen += OFFSET_FADDR_SIZE; /* include fileAddr in size */
1185       }
1186       sd->msg = wbuf;              /* set correct write buffer */
1187       if (!sd->send()) {
1188          if (!jcr->is_job_canceled()) {
1189             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1190                   sd->bstrerror());
1191          }
1192          goto err;
1193       }
1194       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1195       /*          #endif */
1196       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
1197       sd->msg = msgsave;                /* restore read buffer */
1198
1199    } /* end while read file data */
1200
1201    if (sd->msglen < 0) {                 /* error */
1202       berrno be;
1203       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
1204          ff_pkt->fname, be.bstrerror(ff_pkt->bfd.berrno));
1205       if (jcr->JobErrors++ > 1000) {       /* insanity check */
1206          Jmsg(jcr, M_FATAL, 0, _("Too many errors. JobErrors=%d.\n"), jcr->JobErrors);
1207       }
1208    } else if (ff_pkt->flags & FO_ENCRYPT) {
1209       /**
1210        * For encryption, we must call finalize to push out any
1211        *  buffered data.
1212        */
1213       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto.crypto_buf,
1214            &encrypted_len)) {
1215          /* Padding failed. Shouldn't happen. */
1216          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
1217          goto err;
1218       }
1219
1220       /** Note, on SSL pre-0.9.7, there is always some output */
1221       if (encrypted_len > 0) {
1222          sd->msglen = encrypted_len;      /* set encrypted length */
1223          sd->msg = jcr->crypto.crypto_buf;       /* set correct write buffer */
1224          if (!sd->send()) {
1225             if (!jcr->is_job_canceled()) {
1226                Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1227                      sd->bstrerror());
1228             }
1229             goto err;
1230          }
1231          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1232          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
1233          sd->msg = msgsave;               /* restore bnet buffer */
1234       }
1235    }
1236
1237    if (!sd->signal(BNET_EOD)) {        /* indicate end of file data */
1238       if (!jcr->is_job_canceled()) {
1239          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1240                sd->bstrerror());
1241       }
1242       goto err;
1243    }
1244
1245    /** Free the cipher context */
1246    if (cipher_ctx) {
1247       crypto_cipher_free(cipher_ctx);
1248    }
1249    return 1;
1250
1251 err:
1252    /** Free the cipher context */
1253    if (cipher_ctx) {
1254       crypto_cipher_free(cipher_ctx);
1255    }
1256
1257    sd->msg = msgsave; /* restore bnet buffer */
1258    sd->msglen = 0;
1259    return 0;
1260 }
1261
1262 bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1263 {
1264    BSOCK *sd = jcr->store_bsock;
1265    char attribs[MAXSTRING];
1266    char attribsExBuf[MAXSTRING];
1267    char *attribsEx = NULL;
1268    int attr_stream;
1269    int comp_len;
1270    bool stat;
1271    int hangup = get_hangup();
1272 #ifdef FD_NO_SEND_TEST
1273    return true;
1274 #endif
1275
1276    Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1277    /** Find what data stream we will use, then encode the attributes */
1278    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1279       /* This should not happen */
1280       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1281       return false;
1282    }
1283    encode_stat(attribs, &ff_pkt->statp, sizeof(ff_pkt->statp), ff_pkt->LinkFI, data_stream);
1284
1285    /** Now possibly extend the attributes */
1286    if (IS_FT_OBJECT(ff_pkt->type)) {
1287       attr_stream = STREAM_RESTORE_OBJECT;
1288    } else {
1289       attribsEx = attribsExBuf;
1290       attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1291    }
1292
1293    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1294
1295    jcr->lock();
1296    jcr->JobFiles++;                    /* increment number of files sent */
1297    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1298    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1299    jcr->unlock();
1300
1301    /* Debug code: check if we must hangup */
1302    if (hangup && (jcr->JobFiles > (uint32_t)hangup)) {
1303       jcr->setJobStatus(JS_Incomplete);
1304       Jmsg1(jcr, M_FATAL, 0, "Debug hangup requested after %d files.\n", hangup);
1305       set_hangup(0);
1306       return false;
1307    }
1308
1309    /**
1310     * Send Attributes header to Storage daemon
1311     *    <file-index> <stream> <info>
1312     */
1313    if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1314       if (!jcr->is_canceled() && !jcr->is_incomplete()) {
1315          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1316                sd->bstrerror());
1317       }
1318       return false;
1319    }
1320    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1321
1322    /**
1323     * Send file attributes to Storage daemon
1324     *   File_index
1325     *   File type
1326     *   Filename (full path)
1327     *   Encoded attributes
1328     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1329     *   Encoded extended-attributes (for Win32)
1330     *
1331     * or send Restore Object to Storage daemon
1332     *   File_index
1333     *   File_type
1334     *   Object_index
1335     *   Object_len  (possibly compressed)
1336     *   Object_full_len (not compressed)
1337     *   Object_compression
1338     *   Plugin_name
1339     *   Object_name
1340     *   Binary Object data
1341     *
1342     * For a directory, link is the same as fname, but with trailing
1343     * slash. For a linked file, link is the link.
1344     */
1345    if (ff_pkt->type != FT_DELETED) { /* already stripped */
1346       strip_path(ff_pkt);
1347    }
1348    switch (ff_pkt->type) {
1349    case FT_LNK:
1350    case FT_LNKSAVED:
1351       Dmsg3(300, "Link %d %s to %s\n", jcr->JobFiles, ff_pkt->fname, ff_pkt->link);
1352       stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c%u%c", jcr->JobFiles,
1353                        ff_pkt->type, ff_pkt->fname, 0, attribs, 0,
1354                        ff_pkt->link, 0, attribsEx, 0, ff_pkt->delta_seq, 0);
1355       break;
1356    case FT_DIREND:
1357    case FT_REPARSE:
1358    case FT_JUNCTION:
1359       /* Here link is the canonical filename (i.e. with trailing slash) */
1360       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
1361                        ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0,
1362                        attribsEx, 0, ff_pkt->delta_seq, 0);
1363       break;
1364    case FT_PLUGIN_CONFIG:
1365    case FT_RESTORE_FIRST:
1366       comp_len = ff_pkt->object_len;
1367       ff_pkt->object_compression = 0;
1368       if (ff_pkt->object_len > 1000) {
1369          /* Big object, compress it */
1370          comp_len = ff_pkt->object_len + 1000;
1371          POOLMEM *comp_obj = get_memory(comp_len);
1372          /* *** FIXME *** check Zdeflate error */
1373          Zdeflate(ff_pkt->object, ff_pkt->object_len, comp_obj, comp_len);
1374          if (comp_len < ff_pkt->object_len) {
1375             ff_pkt->object = comp_obj;
1376             ff_pkt->object_compression = 1;    /* zlib level 9 compression */
1377          } else {
1378             /* Uncompressed object smaller, use it */
1379             comp_len = ff_pkt->object_len;
1380          }
1381          Dmsg2(100, "Object compressed from %d to %d bytes\n", ff_pkt->object_len, comp_len);
1382       }
1383       sd->msglen = Mmsg(sd->msg, "%d %d %d %d %d %d %s%c%s%c",
1384                         jcr->JobFiles, ff_pkt->type, ff_pkt->object_index,
1385                         comp_len, ff_pkt->object_len, ff_pkt->object_compression,
1386                         ff_pkt->fname, 0, ff_pkt->object_name, 0);
1387       sd->msg = check_pool_memory_size(sd->msg, sd->msglen + comp_len + 2);
1388       memcpy(sd->msg + sd->msglen, ff_pkt->object, comp_len);
1389       /* Note we send one extra byte so Dir can store zero after object */
1390       sd->msglen += comp_len + 1;
1391       stat = sd->send();
1392       if (ff_pkt->object_compression) {
1393          free_and_null_pool_memory(ff_pkt->object);
1394       }
1395       break;
1396    case FT_REG:
1397       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%d%c", jcr->JobFiles,
1398                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0,
1399                ff_pkt->delta_seq, 0);
1400       break;
1401    default:
1402       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
1403                        ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0,
1404                        attribsEx, 0, ff_pkt->delta_seq, 0);
1405       break;
1406    }
1407    if (ff_pkt->type != FT_DELETED) {
1408       unstrip_path(ff_pkt);
1409    }
1410
1411    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1412    if (!stat && !jcr->is_job_canceled()) {
1413       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1414             sd->bstrerror());
1415    }
1416    sd->signal(BNET_EOD);            /* indicate end of attributes data */
1417    return stat;
1418 }
1419
1420 /**
1421  * Do in place strip of path
1422  */
1423 static bool do_strip(int count, char *in)
1424 {
1425    char *out = in;
1426    int stripped;
1427    int numsep = 0;
1428
1429    /** Copy to first path separator -- Win32 might have c: ... */
1430    while (*in && !IsPathSeparator(*in)) {
1431       out++; in++;
1432    }
1433    out++; in++;
1434    numsep++;                     /* one separator seen */
1435    for (stripped=0; stripped<count && *in; stripped++) {
1436       while (*in && !IsPathSeparator(*in)) {
1437          in++;                   /* skip chars */
1438       }
1439       if (*in) {
1440          numsep++;               /* count separators seen */
1441          in++;                   /* skip separator */
1442       }
1443    }
1444    /* Copy to end */
1445    while (*in) {                /* copy to end */
1446       if (IsPathSeparator(*in)) {
1447          numsep++;
1448       }
1449       *out++ = *in++;
1450    }
1451    *out = 0;
1452    Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1453          stripped, count, numsep, numsep>count);
1454    return stripped==count && numsep>count;
1455 }
1456
1457 /**
1458  * If requested strip leading components of the path so that we can
1459  *   save file as if it came from a subdirectory.  This is most useful
1460  *   for dealing with snapshots, by removing the snapshot directory, or
1461  *   in handling vendor migrations where files have been restored with
1462  *   a vendor product into a subdirectory.
1463  */
1464 void strip_path(FF_PKT *ff_pkt)
1465 {
1466    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1467       Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1468       return;
1469    }
1470    if (!ff_pkt->fname_save) {
1471      ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1472      ff_pkt->link_save = get_pool_memory(PM_FNAME);
1473    }
1474    pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1475    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1476       pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1477       Dmsg2(500, "strcpy link_save=%d link=%d\n", strlen(ff_pkt->link_save),
1478          strlen(ff_pkt->link));
1479       Dsm_check(200);
1480    }
1481
1482    /**
1483     * Strip path.  If it doesn't succeed put it back.  If
1484     *  it does, and there is a different link string,
1485     *  attempt to strip the link. If it fails, back them
1486     *  both back.
1487     * Do not strip symlinks.
1488     * I.e. if either stripping fails don't strip anything.
1489     */
1490    if (!do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1491       unstrip_path(ff_pkt);
1492       goto rtn;
1493    }
1494    /** Strip links but not symlinks */
1495    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1496       if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1497          unstrip_path(ff_pkt);
1498       }
1499    }
1500
1501 rtn:
1502    Dmsg3(100, "fname=%s stripped=%s link=%s\n", ff_pkt->fname_save, ff_pkt->fname,
1503        ff_pkt->link);
1504 }
1505
1506 void unstrip_path(FF_PKT *ff_pkt)
1507 {
1508    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1509       return;
1510    }
1511    strcpy(ff_pkt->fname, ff_pkt->fname_save);
1512    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1513       Dmsg2(500, "strcpy link=%s link_save=%s\n", ff_pkt->link,
1514           ff_pkt->link_save);
1515       strcpy(ff_pkt->link, ff_pkt->link_save);
1516       Dmsg2(500, "strcpy link=%d link_save=%d\n", strlen(ff_pkt->link),
1517           strlen(ff_pkt->link_save));
1518       Dsm_check(200);
1519    }
1520 }
1521
1522 static void close_vss_backup_session(JCR *jcr)
1523 {
1524 #if defined(WIN32_VSS)
1525    /* STOP VSS ON WIN32 */
1526    /* tell vss to close the backup session */
1527    if (jcr->VSS) {
1528       if (g_pVSSClient->CloseBackup()) {
1529          /* inform user about writer states */
1530          for (int i=0; i<(int)g_pVSSClient->GetWriterCount(); i++) {
1531             int msg_type = M_INFO;
1532             if (g_pVSSClient->GetWriterState(i) < 1) {
1533                msg_type = M_WARNING;
1534                jcr->JobErrors++;
1535             }
1536             Jmsg(jcr, msg_type, 0, _("VSS Writer (BackupComplete): %s\n"), g_pVSSClient->GetWriterInfo(i));
1537          }
1538       }
1539       WCHAR *metadata = g_pVSSClient->GetMetadata();
1540       if (metadata) {
1541          FF_PKT *ff_pkt = jcr->ff;
1542          ff_pkt->fname = (char *)"job";
1543          ff_pkt->type = FT_RESTORE_FIRST;
1544          ff_pkt->LinkFI = 0;
1545          ff_pkt->object_name = (char *)"job_metadata.xml";
1546          ff_pkt->object = (char *)metadata;
1547          ff_pkt->object_len = (wcslen(metadata) + 1) * sizeof(WCHAR);
1548          ff_pkt->object_index = (int)time(NULL);
1549          save_file(jcr, ff_pkt, true);
1550      }
1551    }
1552 #endif
1553 }