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

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