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          Jmsg(jcr, M_INFO, 1, _("     %s is a different filesystem. Will not descend from %s into it.\n"),
 357               ff_pkt->fname, ff_pkt->top_fname);
 358       }
 359       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 360       break;
 361    case FT_INVALIDFS:
 362       Jmsg(jcr, M_INFO, 1, _("     Disallowed filesystem. Will not descend from %s into %s\n"),
 363            ff_pkt->top_fname, ff_pkt->fname);
 364       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 365       break;
 366    case FT_INVALIDDT:
 367       Jmsg(jcr, M_INFO, 1, _("     Disallowed drive type. Will not descend into %s\n"),
 368            ff_pkt->fname);
 369       break;
 370    case FT_REPARSE:
 371    case FT_JUNCTION:
 372    case FT_DIREND:
 373       Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
 374       break;
 375    case FT_SPEC:
 376       Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
 377       if (S_ISSOCK(ff_pkt->statp.st_mode)) {
 378         Jmsg(jcr, M_SKIPPED, 1, _("     Socket file skipped: %s\n"), ff_pkt->fname);
 379         return 1;
 380       }
 381       break;
 382    case FT_RAW:
 383       Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
 384       has_file_data = true;
 385       break;
 386    case FT_FIFO:
 387       Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
 388       break;
 389    case FT_NOACCESS: {
 390       berrno be;
 391       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not access \"%s\": ERR=%s\n"), ff_pkt->fname,
 392          be.bstrerror(ff_pkt->ff_errno));
 393       jcr->JobErrors++;
 394       return 1;
 395    }
 396    case FT_NOFOLLOW: {
 397       berrno be;
 398       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not follow link \"%s\": ERR=%s\n"),
 399            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 400       jcr->JobErrors++;
 401       return 1;
 402    }
 403    case FT_NOSTAT: {
 404       berrno be;
 405       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not stat \"%s\": ERR=%s\n"), ff_pkt->fname,
 406          be.bstrerror(ff_pkt->ff_errno));
 407       jcr->JobErrors++;
 408       return 1;
 409    }
 410    case FT_DIRNOCHG:
 411    case FT_NOCHG:
 412       Jmsg(jcr, M_SKIPPED, 1, _("     Unchanged file skipped: %s\n"), ff_pkt->fname);
 413       return 1;
 414    case FT_ISARCH:
 415       Jmsg(jcr, M_NOTSAVED, 0, _("     Archive file not saved: %s\n"), ff_pkt->fname);
 416       return 1;
 417    case FT_NOOPEN: {
 418       berrno be;
 419       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not open directory \"%s\": ERR=%s\n"),
 420            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 421       jcr->JobErrors++;
 422       return 1;
 423    }
 424    default:
 425       Jmsg(jcr, M_NOTSAVED, 0,  _("     Unknown file type %d; not saved: %s\n"),
 426            ff_pkt->type, ff_pkt->fname);
 427       jcr->JobErrors++;
 428       return 1;
 429    }
 430
 431    Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
 432
 433    /** Digests and encryption are only useful if there's file data */
 434    if (has_file_data) {
 435       /**
 436        * Setup for digest handling. If this fails, the digest will be set to NULL
 437        * and not used. Note, the digest (file hash) can be any one of the four
 438        * algorithms below.
 439        *
 440        * The signing digest is a single algorithm depending on
 441        * whether or not we have SHA2.
 442        *   ****FIXME****  the signing algoritm should really be
 443        *   determined a different way!!!!!!  What happens if
 444        *   sha2 was available during backup but not restore?
 445        */
 446       if (ff_pkt->flags & FO_MD5) {
 447          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_MD5);
 448          digest_stream = STREAM_MD5_DIGEST;
 449
 450       } else if (ff_pkt->flags & FO_SHA1) {
 451          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA1);
 452          digest_stream = STREAM_SHA1_DIGEST;
 453
 454       } else if (ff_pkt->flags & FO_SHA256) {
 455          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA256);
 456          digest_stream = STREAM_SHA256_DIGEST;
 457
 458       } else if (ff_pkt->flags & FO_SHA512) {
 459          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA512);
 460          digest_stream = STREAM_SHA512_DIGEST;
 461       }
 462
 463       /** Did digest initialization fail? */
 464       if (digest_stream != STREAM_NONE && digest == NULL) {
 465          Jmsg(jcr, M_WARNING, 0, _("%s digest initialization failed\n"),
 466             stream_to_ascii(digest_stream));
 467       }
 468
 469       /**
 470        * Set up signature digest handling. If this fails, the signature digest
 471        * will be set to NULL and not used.
 472        */
 473       /* TODO landonf: We should really only calculate the digest once, for
 474        * both verification and signing.
 475        */
 476       if (jcr->crypto.pki_sign) {
 477          signing_digest = crypto_digest_new(jcr, signing_algorithm);
 478
 479          /** Full-stop if a failure occurred initializing the signature digest */
 480          if (signing_digest == NULL) {
 481             Jmsg(jcr, M_NOTSAVED, 0, _("%s signature digest initialization failed\n"),
 482                stream_to_ascii(signing_algorithm));
 483             jcr->JobErrors++;
 484             goto good_rtn;
 485          }
 486       }
 487
 488       /** Enable encryption */
 489       if (jcr->crypto.pki_encrypt) {
 490          ff_pkt->flags |= FO_ENCRYPT;
 491       }
 492    }
 493
 494    /** Initialize the file descriptor we use for data and other streams. */
 495    binit(&ff_pkt->bfd);
 496    if (ff_pkt->flags & FO_PORTABLE) {
 497       set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
 498    }
 499    if (ff_pkt->cmd_plugin) {
 500       /* Tell bfile that it needs to call plugin */
 501       if (!set_cmd_plugin(&ff_pkt->bfd, jcr)) {
 502          goto bail_out;
 503       }
 504       send_plugin_name(jcr, sd, true);      /* signal start of plugin data */
 505       plugin_started = true;
 506    }
 507
 508    /** Send attributes -- must be done after binit() */
 509    if (!encode_and_send_attributes(jcr, ff_pkt, data_stream)) {
 510       goto bail_out;
 511    }
 512    /** Meta data only for restore object */
 513    if (ff_pkt->type == FT_RESTORE_FIRST) {
 514       goto good_rtn;
 515    }
 516
 517    /** Set up the encryption context and send the session data to the SD */
 518    if (has_file_data && jcr->crypto.pki_encrypt) {
 519       if (!crypto_session_send(jcr, sd)) {
 520          goto bail_out;
 521       }
 522    }
 523
 524    /**
 525     * Open any file with data that we intend to save, then save it.
 526     *
 527     * Note, if is_win32_backup, we must open the Directory so that
 528     * the BackupRead will save its permissions and ownership streams.
 529     */
 530    if (ff_pkt->type != FT_LNKSAVED && S_ISREG(ff_pkt->statp.st_mode)) {
 531 #ifdef HAVE_WIN32
 532       do_read = !is_portable_backup(&ff_pkt->bfd) || ff_pkt->statp.st_size > 0;
 533 #else
 534       do_read = ff_pkt->statp.st_size > 0;
 535 #endif
 536    } else if (ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
 537               ff_pkt->type == FT_REPARSE || ff_pkt->type == FT_JUNCTION ||
 538          (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
 539       do_read = true;
 540    }
 541
 542    if (ff_pkt->cmd_plugin) {
 543       do_read = true;
 544    }
 545
 546    Dmsg2(150, "type=%d do_read=%d\n", ff_pkt->type, do_read);
 547    if (do_read) {
 548       btimer_t *tid;
 549
 550       if (ff_pkt->type == FT_FIFO) {
 551          tid = start_thread_timer(jcr, pthread_self(), 60);
 552       } else {
 553          tid = NULL;
 554       }
 555       int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
 556       ff_pkt->bfd.reparse_point = (ff_pkt->type == FT_REPARSE ||
 557                                    ff_pkt->type == FT_JUNCTION);
 558       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
 559          ff_pkt->ff_errno = errno;
 560          berrno be;
 561          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open \"%s\": ERR=%s.\n"), ff_pkt->fname,
 562               be.bstrerror());
 563          jcr->JobErrors++;
 564          if (tid) {
 565             stop_thread_timer(tid);
 566             tid = NULL;
 567          }
 568          goto good_rtn;
 569       }
 570       if (tid) {
 571          stop_thread_timer(tid);
 572          tid = NULL;
 573       }
 574
 575       stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
 576
 577       if (ff_pkt->flags & FO_CHKCHANGES) {
 578          has_file_changed(jcr, ff_pkt);
 579       }
 580
 581       bclose(&ff_pkt->bfd);
 582
 583       if (!stat) {
 584          goto bail_out;
 585       }
 586    }
 587
 588    if (have_darwin_os) {
 589       /** Regular files can have resource forks and Finder Info */
 590       if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 591           ff_pkt->flags & FO_HFSPLUS)) {
 592          if (ff_pkt->hfsinfo.rsrclength > 0) {
 593             int flags;
 594             int rsrc_stream;
 595             if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 596                ff_pkt->ff_errno = errno;
 597                berrno be;
 598                Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for \"%s\": ERR=%s.\n"),
 599                     ff_pkt->fname, be.bstrerror());
 600                jcr->JobErrors++;
 601                if (is_bopen(&ff_pkt->bfd)) {
 602                   bclose(&ff_pkt->bfd);
 603                }
 604                goto good_rtn;
 605             }
 606             flags = ff_pkt->flags;
 607             ff_pkt->flags &= ~(FO_GZIP|FO_SPARSE|FO_OFFSETS);
 608             if (flags & FO_ENCRYPT) {
 609                rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
 610             } else {
 611                rsrc_stream = STREAM_MACOS_FORK_DATA;
 612             }
 613             stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
 614             ff_pkt->flags = flags;
 615             bclose(&ff_pkt->bfd);
 616             if (!stat) {
 617                goto bail_out;
 618             }
 619          }
 620
 621          Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
 622          sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 623          Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 624          pm_memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 625          sd->msglen = 32;
 626          if (digest) {
 627             crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
 628          }
 629          if (signing_digest) {
 630             crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
 631          }
 632          sd->send();
 633          sd->signal(BNET_EOD);
 634       }
 635    }
 636
 637    /**
 638     * Save ACLs when requested and available for anything not being a symlink and not being a plugin.
 639     */
 640    if (have_acl) {
 641       if (ff_pkt->flags & FO_ACL && ff_pkt->type != FT_LNK && !ff_pkt->cmd_plugin) {
 642          switch (build_acl_streams(jcr, ff_pkt)) {
 643          case bacl_exit_fatal:
 644             goto bail_out;
 645          case bacl_exit_error:
 646             /**
 647              * Non-fatal errors, count them and when the number is under ACL_REPORT_ERR_MAX_PER_JOB
 648              * print the error message set by the lower level routine in jcr->errmsg.
 649              */
 650             if (jcr->acl_data->nr_errors < ACL_REPORT_ERR_MAX_PER_JOB) {
 651                Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg);
 652             }
 653             jcr->acl_data->nr_errors++;
 654             break;
 655          case bacl_exit_ok:
 656             break;
 657          }
 658       }
 659    }
 660
 661    /**
 662     * Save Extended Attributes when requested and available for all files not being a plugin.
 663     */
 664    if (have_xattr) {
 665       if (ff_pkt->flags & FO_XATTR && !ff_pkt->cmd_plugin) {
 666          switch (build_xattr_streams(jcr, ff_pkt)) {
 667          case bxattr_exit_fatal:
 668             goto bail_out;
 669          case bxattr_exit_error:
 670             /**
 671              * Non-fatal errors, count them and when the number is under XATTR_REPORT_ERR_MAX_PER_JOB
 672              * print the error message set by the lower level routine in jcr->errmsg.
 673              */
 674             if (jcr->xattr_data->nr_errors < XATTR_REPORT_ERR_MAX_PER_JOB) {
 675                Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg);
 676             }
 677             jcr->xattr_data->nr_errors++;
 678             break;
 679          case bxattr_exit_ok:
 680             break;
 681          }
 682       }
 683    }
 684
 685    /** Terminate the signing digest and send it to the Storage daemon */
 686    if (signing_digest) {
 687       uint32_t size = 0;
 688
 689       if ((sig = crypto_sign_new(jcr)) == NULL) {
 690          Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for crypto signature.\n"));
 691          goto bail_out;
 692       }
 693
 694       if (!crypto_sign_add_signer(sig, signing_digest, jcr->crypto.pki_keypair)) {
 695          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 696          goto bail_out;
 697       }
 698
 699       /** Get signature size */
 700       if (!crypto_sign_encode(sig, NULL, &size)) {
 701          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 702          goto bail_out;
 703       }
 704
 705       /** Grow the bsock buffer to fit our message if necessary */
 706       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 707          sd->msg = realloc_pool_memory(sd->msg, size);
 708       }
 709
 710       /** Send our header */
 711       sd->fsend("%ld %ld 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
 712       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 713
 714       /** Encode signature data */
 715       if (!crypto_sign_encode(sig, (uint8_t *)sd->msg, &size)) {
 716          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 717          goto bail_out;
 718       }
 719
 720       sd->msglen = size;
 721       sd->send();
 722       sd->signal(BNET_EOD);              /* end of checksum */
 723    }
 724
 725    /** Terminate any digest and send it to Storage daemon */
 726    if (digest) {
 727       uint32_t size;
 728
 729       sd->fsend("%ld %d 0", jcr->JobFiles, digest_stream);
 730       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 731
 732       size = CRYPTO_DIGEST_MAX_SIZE;
 733
 734       /** Grow the bsock buffer to fit our message if necessary */
 735       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 736          sd->msg = realloc_pool_memory(sd->msg, size);
 737       }
 738
 739       if (!crypto_digest_finalize(digest, (uint8_t *)sd->msg, &size)) {
 740          Jmsg(jcr, M_FATAL, 0, _("An error occurred finalizing signing the stream.\n"));
 741          goto bail_out;
 742       }
 743
 744       sd->msglen = size;
 745       sd->send();
 746       sd->signal(BNET_EOD);              /* end of checksum */
 747    }
 748
 749 good_rtn:
 750    rtnstat = jcr->is_job_canceled() ? 0 : 1; /* good return if not canceled */
 751
 752 bail_out:
 753    if (ff_pkt->cmd_plugin && plugin_started) {
 754       send_plugin_name(jcr, sd, false); /* signal end of plugin data */
 755    }
 756    if (digest) {
 757       crypto_digest_free(digest);
 758    }
 759    if (signing_digest) {
 760       crypto_digest_free(signing_digest);
 761    }
 762    if (sig) {
 763       crypto_sign_free(sig);
 764    }
 765    return rtnstat;
 766 }
 767
 768 /**
 769  * Send data read from an already open file descriptor.
 770  *
 771  * We return 1 on sucess and 0 on errors.
 772  *
 773  * ***FIXME***
 774  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 775  *  reading.
 776  * Currently this is not a problem as the only other stream, resource forks,
 777  * are not handled as sparse files.
 778  */
 779 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 780                      DIGEST *signing_digest)
 781 {
 782    BSOCK *sd = jcr->store_bsock;
 783    uint64_t fileAddr = 0;             /* file address */
 784    char *rbuf, *wbuf;
 785    int32_t rsize = jcr->buf_size;      /* read buffer size */
 786    POOLMEM *msgsave;
 787    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 788    const uint8_t *cipher_input;
 789    uint32_t cipher_input_len;
 790    uint32_t cipher_block_size;
 791    uint32_t encrypted_len;
 792 #ifdef FD_NO_SEND_TEST
 793    return 1;
 794 #endif
 795
 796    msgsave = sd->msg;
 797    rbuf = sd->msg;                    /* read buffer */
 798    wbuf = sd->msg;                    /* write buffer */
 799    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 800
 801    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 802
 803 #ifdef HAVE_LIBZ
 804    uLong compress_len = 0;
 805    uLong max_compress_len = 0;
 806    const Bytef *cbuf = NULL;
 807    int zstat;
 808
 809    if (ff_pkt->flags & FO_GZIP) {
 810       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 811          cbuf = (Bytef *)jcr->compress_buf + OFFSET_FADDR_SIZE;
 812          max_compress_len = jcr->compress_buf_size - OFFSET_FADDR_SIZE;
 813       } else {
 814          cbuf = (Bytef *)jcr->compress_buf;
 815          max_compress_len = jcr->compress_buf_size; /* set max length */
 816       }
 817       wbuf = jcr->compress_buf;    /* compressed output here */
 818       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 819
 820       /**
 821        * Only change zlib parameters if there is no pending operation.
 822        * This should never happen as deflatereset is called after each
 823        * deflate.
 824        */
 825
 826       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 827          /** set gzip compression level - must be done per file */
 828          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 829               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 830             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 831             set_jcr_job_status(jcr, JS_ErrorTerminated);
 832             goto err;
 833          }
 834       }
 835    }
 836 #else
 837    const uint32_t max_compress_len = 0;
 838 #endif
 839
 840    if (ff_pkt->flags & FO_ENCRYPT) {
 841       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 842          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse or offset data not supported.\n"));
 843          goto err;
 844       }
 845       /** Allocate the cipher context */
 846       if ((cipher_ctx = crypto_cipher_new(jcr->crypto.pki_session, true,
 847            &cipher_block_size)) == NULL) {
 848          /* Shouldn't happen! */
 849          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 850          goto err;
 851       }
 852
 853       /**
 854        * Grow the crypto buffer, if necessary.
 855        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 856        * We grow crypto_buf to the maximum number of blocks that
 857        * could be returned for the given read buffer size.
 858        * (Using the larger of either rsize or max_compress_len)
 859        */
 860       jcr->crypto.crypto_buf = check_pool_memory_size(jcr->crypto.crypto_buf,
 861            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 862             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 863
 864       wbuf = jcr->crypto.crypto_buf; /* Encrypted, possibly compressed output here. */
 865    }
 866
 867    /**
 868     * Send Data header to Storage daemon
 869     *    <file-index> <stream> <info>
 870     */
 871    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 872       if (!jcr->is_job_canceled()) {
 873          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 874                sd->bstrerror());
 875       }
 876       goto err;
 877    }
 878    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 879
 880    /**
 881     * Make space at beginning of buffer for fileAddr because this
 882     *   same buffer will be used for writing if compression is off.
 883     */
 884    if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 885       rbuf += OFFSET_FADDR_SIZE;
 886       rsize -= OFFSET_FADDR_SIZE;
 887 #ifdef HAVE_FREEBSD_OS
 888       /**
 889        * To read FreeBSD partitions, the read size must be
 890        *  a multiple of 512.
 891        */
 892       rsize = (rsize/512) * 512;
 893 #endif
 894    }
 895
 896    /** a RAW device read on win32 only works if the buffer is a multiple of 512 */
 897 #ifdef HAVE_WIN32
 898    if (S_ISBLK(ff_pkt->statp.st_mode))
 899       rsize = (rsize/512) * 512;
 900 #endif
 901
 902    /**
 903     * Read the file data
 904     */
 905    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 906
 907       /** Check for sparse blocks */
 908       if (ff_pkt->flags & FO_SPARSE) {
 909          ser_declare;
 910          bool allZeros = false;
 911          if ((sd->msglen == rsize &&
 912               fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size) ||
 913              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 914                (uint64_t)ff_pkt->statp.st_size == 0)) {
 915             allZeros = is_buf_zero(rbuf, rsize);
 916          }
 917          if (!allZeros) {
 918             /** Put file address as first data in buffer */
 919             ser_begin(wbuf, OFFSET_FADDR_SIZE);
 920             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 921          }
 922          fileAddr += sd->msglen;      /* update file address */
 923          /** Skip block of all zeros */
 924          if (allZeros) {
 925             continue;                 /* skip block of zeros */
 926          }
 927       } else if (ff_pkt->flags & FO_OFFSETS) {
 928          ser_declare;
 929          ser_begin(wbuf, OFFSET_FADDR_SIZE);
 930          ser_uint64(ff_pkt->bfd.offset);     /* store offset in begin of buffer */
 931       }
 932
 933       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 934
 935       /** Uncompressed cipher input length */
 936       cipher_input_len = sd->msglen;
 937
 938       /** Update checksum if requested */
 939       if (digest) {
 940          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 941       }
 942
 943       /** Update signing digest if requested */
 944       if (signing_digest) {
 945          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 946       }
 947
 948 #ifdef HAVE_LIBZ
 949       /** Do compression if turned on */
 950       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 951          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 952
 953          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 954                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 955          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 956                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 957
 958          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 959             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 960             set_jcr_job_status(jcr, JS_ErrorTerminated);
 961             goto err;
 962          }
 963          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 964          /** reset zlib stream to be able to begin from scratch again */
 965          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 966             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 967             set_jcr_job_status(jcr, JS_ErrorTerminated);
 968             goto err;
 969          }
 970
 971          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 972                sd->msglen);
 973
 974          sd->msglen = compress_len;      /* set compressed length */
 975          cipher_input_len = compress_len;
 976       }
 977 #endif
 978       /**
 979        * Note, here we prepend the current record length to the beginning
 980        *  of the encrypted data. This is because both sparse and compression
 981        *  restore handling want records returned to them with exactly the
 982        *  same number of bytes that were processed in the backup handling.
 983        *  That is, both are block filters rather than a stream.  When doing
 984        *  compression, the compression routines may buffer data, so that for
 985        *  any one record compressed, when it is decompressed the same size
 986        *  will not be obtained. Of course, the buffered data eventually comes
 987        *  out in subsequent crypto_cipher_update() calls or at least
 988        *  when crypto_cipher_finalize() is called.  Unfortunately, this
 989        *  "feature" of encryption enormously complicates the restore code.
 990        */
 991       if (ff_pkt->flags & FO_ENCRYPT) {
 992          uint32_t initial_len = 0;
 993          ser_declare;
 994
 995          if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 996             cipher_input_len += OFFSET_FADDR_SIZE;
 997          }
 998
 999          /** Encrypt the length of the input block */
1000          uint8_t packet_len[sizeof(uint32_t)];
1001
1002          ser_begin(packet_len, sizeof(uint32_t));
1003          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
1004          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
1005
1006          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
1007              (uint8_t *)jcr->crypto.crypto_buf, &initial_len)) {
1008             /** Encryption failed. Shouldn't happen. */
1009             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
1010             goto err;
1011          }
1012
1013          /** Encrypt the input block */
1014          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
1015              (uint8_t *)&jcr->crypto.crypto_buf[initial_len], &encrypted_len)) {
1016             if ((initial_len + encrypted_len) == 0) {
1017                /** No full block of data available, read more data */
1018                continue;
1019             }
1020             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
1021                   sd->msglen);
1022             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
1023          } else {
1024             /** Encryption failed. Shouldn't happen. */
1025             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
1026             goto err;
1027          }
1028       }
1029
1030       /* Send the buffer to the Storage daemon */
1031       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
1032          sd->msglen += OFFSET_FADDR_SIZE; /* include fileAddr in size */
1033       }
1034       sd->msg = wbuf;              /* set correct write buffer */
1035       if (!sd->send()) {
1036          if (!jcr->is_job_canceled()) {
1037             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1038                   sd->bstrerror());
1039          }
1040          goto err;
1041       }
1042       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1043       /*          #endif */
1044       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
1045       sd->msg = msgsave;                /* restore read buffer */
1046
1047    } /* end while read file data */
1048
1049    if (sd->msglen < 0) {                 /* error */
1050       berrno be;
1051       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
1052          ff_pkt->fname, be.bstrerror(ff_pkt->bfd.berrno));
1053       if (jcr->JobErrors++ > 1000) {       /* insanity check */
1054          Jmsg(jcr, M_FATAL, 0, _("Too many errors. JobErrors=%d.\n"), jcr->JobErrors);
1055       }
1056    } else if (ff_pkt->flags & FO_ENCRYPT) {
1057       /**
1058        * For encryption, we must call finalize to push out any
1059        *  buffered data.
1060        */
1061       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto.crypto_buf,
1062            &encrypted_len)) {
1063          /* Padding failed. Shouldn't happen. */
1064          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
1065          goto err;
1066       }
1067
1068       /** Note, on SSL pre-0.9.7, there is always some output */
1069       if (encrypted_len > 0) {
1070          sd->msglen = encrypted_len;      /* set encrypted length */
1071          sd->msg = jcr->crypto.crypto_buf;       /* set correct write buffer */
1072          if (!sd->send()) {
1073             if (!jcr->is_job_canceled()) {
1074                Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1075                      sd->bstrerror());
1076             }
1077             goto err;
1078          }
1079          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1080          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
1081          sd->msg = msgsave;               /* restore bnet buffer */
1082       }
1083    }
1084
1085    if (!sd->signal(BNET_EOD)) {        /* indicate end of file data */
1086       if (!jcr->is_job_canceled()) {
1087          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1088                sd->bstrerror());
1089       }
1090       goto err;
1091    }
1092
1093    /** Free the cipher context */
1094    if (cipher_ctx) {
1095       crypto_cipher_free(cipher_ctx);
1096    }
1097    return 1;
1098
1099 err:
1100    /** Free the cipher context */
1101    if (cipher_ctx) {
1102       crypto_cipher_free(cipher_ctx);
1103    }
1104
1105    sd->msg = msgsave; /* restore bnet buffer */
1106    sd->msglen = 0;
1107    return 0;
1108 }
1109
1110 bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1111 {
1112    BSOCK *sd = jcr->store_bsock;
1113    char attribs[MAXSTRING];
1114    char attribsExBuf[MAXSTRING];
1115    char *attribsEx = NULL;
1116    int attr_stream;
1117    int comp_len;
1118    bool stat;
1119 #ifdef FD_NO_SEND_TEST
1120    return true;
1121 #endif
1122
1123    Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1124    /** Find what data stream we will use, then encode the attributes */
1125    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1126       /* This should not happen */
1127       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1128       return false;
1129    }
1130    encode_stat(attribs, &ff_pkt->statp, ff_pkt->LinkFI, data_stream);
1131
1132    /** Now possibly extend the attributes */
1133    if (ff_pkt->type == FT_RESTORE_FIRST) {
1134       attr_stream = STREAM_RESTORE_OBJECT;
1135    } else {
1136       attribsEx = attribsExBuf;
1137       attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1138    }
1139
1140    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1141
1142    jcr->lock();
1143    jcr->JobFiles++;                    /* increment number of files sent */
1144    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1145    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1146    jcr->unlock();
1147
1148    /**
1149     * Send Attributes header to Storage daemon
1150     *    <file-index> <stream> <info>
1151     */
1152    if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1153       if (!jcr->is_job_canceled()) {
1154          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1155                sd->bstrerror());
1156       }
1157       return false;
1158    }
1159    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1160
1161    /**
1162     * Send file attributes to Storage daemon
1163     *   File_index
1164     *   File type
1165     *   Filename (full path)
1166     *   Encoded attributes
1167     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1168     *   Encoded extended-attributes (for Win32)
1169     *
1170     * or send Restore Object to Storage daemon
1171     *   File_index
1172     *   File_type
1173     *   Object_index
1174     *   Object_len  (possibly compressed)
1175     *   Object_full_len (not compressed)
1176     *   Object_compression
1177     *   Plugin_name
1178     *   Object_name
1179     *   Binary Object data
1180     *
1181     * For a directory, link is the same as fname, but with trailing
1182     * slash. For a linked file, link is the link.
1183     */
1184    if (ff_pkt->type != FT_DELETED) { /* already stripped */
1185       strip_path(ff_pkt);
1186    }
1187    switch (ff_pkt->type) {
1188    case FT_LNK:
1189    case FT_LNKSAVED:
1190       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1191       stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c%u%c", jcr->JobFiles,
1192                        ff_pkt->type, ff_pkt->fname, 0, attribs, 0,
1193                        ff_pkt->link, 0, attribsEx, 0, ff_pkt->delta_seq, 0);
1194       break;
1195    case FT_DIREND:
1196    case FT_REPARSE:
1197    case FT_JUNCTION:
1198       /* Here link is the canonical filename (i.e. with trailing slash) */
1199       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
1200                        ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0,
1201                        attribsEx, 0, ff_pkt->delta_seq, 0);
1202       break;
1203    case FT_RESTORE_FIRST:
1204       comp_len = ff_pkt->object_len;
1205       ff_pkt->object_compression = 0;
1206       if (ff_pkt->object_len > 1000) {
1207          /* Big object, compress it */
1208          int stat;
1209          comp_len = ff_pkt->object_len + 1000;
1210          POOLMEM *comp_obj = get_memory(comp_len);
1211          stat = Zdeflate(ff_pkt->object, ff_pkt->object_len, comp_obj, comp_len);
1212          if (comp_len < ff_pkt->object_len) {
1213             ff_pkt->object = comp_obj;
1214             ff_pkt->object_compression = 1;    /* zlib level 9 compression */
1215          } else {
1216             /* Uncompressed object smaller, use it */
1217             comp_len = ff_pkt->object_len;
1218          }
1219          Dmsg2(100, "Object compressed from %d to %d bytes\n", ff_pkt->object_len, comp_len);
1220       }
1221       sd->msglen = Mmsg(sd->msg, "%d %d %d %d %d %d %s%c%s%c",
1222                         jcr->JobFiles, ff_pkt->type, ff_pkt->object_index,
1223                         comp_len, ff_pkt->object_len, ff_pkt->object_compression,
1224                         ff_pkt->fname, 0, ff_pkt->object_name, 0);
1225       sd->msg = check_pool_memory_size(sd->msg, sd->msglen + comp_len + 2);
1226       memcpy(sd->msg + sd->msglen, ff_pkt->object, comp_len);
1227       /* Note we send one extra byte so Dir can store zero after object */
1228       sd->msglen += comp_len + 1;
1229       stat = sd->send();
1230       if (ff_pkt->object_compression) {
1231          free_and_null_pool_memory(ff_pkt->object);
1232       }
1233       break;
1234    case FT_REG:
1235       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%d%c", jcr->JobFiles,
1236                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0,
1237                ff_pkt->delta_seq, 0);
1238       break;
1239    default:
1240       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
1241                        ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0,
1242                        attribsEx, 0, ff_pkt->delta_seq, 0);
1243       break;
1244    }
1245    if (ff_pkt->type != FT_DELETED) {
1246       unstrip_path(ff_pkt);
1247    }
1248
1249    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1250    if (!stat && !jcr->is_job_canceled()) {
1251       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1252             sd->bstrerror());
1253    }
1254    sd->signal(BNET_EOD);            /* indicate end of attributes data */
1255    return stat;
1256 }
1257
1258 /**
1259  * Do in place strip of path
1260  */
1261 static bool do_strip(int count, char *in)
1262 {
1263    char *out = in;
1264    int stripped;
1265    int numsep = 0;
1266
1267    /** Copy to first path separator -- Win32 might have c: ... */
1268    while (*in && !IsPathSeparator(*in)) {
1269       out++; in++;
1270    }
1271    out++; in++;
1272    numsep++;                     /* one separator seen */
1273    for (stripped=0; stripped<count && *in; stripped++) {
1274       while (*in && !IsPathSeparator(*in)) {
1275          in++;                   /* skip chars */
1276       }
1277       if (*in) {
1278          numsep++;               /* count separators seen */
1279          in++;                   /* skip separator */
1280       }
1281    }
1282    /* Copy to end */
1283    while (*in) {                /* copy to end */
1284       if (IsPathSeparator(*in)) {
1285          numsep++;
1286       }
1287       *out++ = *in++;
1288    }
1289    *out = 0;
1290    Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1291          stripped, count, numsep, numsep>count);
1292    return stripped==count && numsep>count;
1293 }
1294
1295 /**
1296  * If requested strip leading components of the path so that we can
1297  *   save file as if it came from a subdirectory.  This is most useful
1298  *   for dealing with snapshots, by removing the snapshot directory, or
1299  *   in handling vendor migrations where files have been restored with
1300  *   a vendor product into a subdirectory.
1301  */
1302 void strip_path(FF_PKT *ff_pkt)
1303 {
1304    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1305       Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1306       return;
1307    }
1308    if (!ff_pkt->fname_save) {
1309      ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1310      ff_pkt->link_save = get_pool_memory(PM_FNAME);
1311    }
1312    pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1313    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1314       pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1315       Dmsg2(500, "strcpy link_save=%d link=%d\n", strlen(ff_pkt->link_save),
1316          strlen(ff_pkt->link));
1317       sm_check(__FILE__, __LINE__, true);
1318    }
1319
1320    /**
1321     * Strip path.  If it doesn't succeed put it back.  If
1322     *  it does, and there is a different link string,
1323     *  attempt to strip the link. If it fails, back them
1324     *  both back.
1325     * Do not strip symlinks.
1326     * I.e. if either stripping fails don't strip anything.
1327     */
1328    if (!do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1329       unstrip_path(ff_pkt);
1330       goto rtn;
1331    }
1332    /** Strip links but not symlinks */
1333    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1334       if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1335          unstrip_path(ff_pkt);
1336       }
1337    }
1338
1339 rtn:
1340    Dmsg3(100, "fname=%s stripped=%s link=%s\n", ff_pkt->fname_save, ff_pkt->fname,
1341        ff_pkt->link);
1342 }
1343
1344 void unstrip_path(FF_PKT *ff_pkt)
1345 {
1346    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1347       return;
1348    }
1349    strcpy(ff_pkt->fname, ff_pkt->fname_save);
1350    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1351       Dmsg2(500, "strcpy link=%s link_save=%s\n", ff_pkt->link,
1352           ff_pkt->link_save);
1353       strcpy(ff_pkt->link, ff_pkt->link_save);
1354       Dmsg2(500, "strcpy link=%d link_save=%d\n", strlen(ff_pkt->link),
1355           strlen(ff_pkt->link_save));
1356       sm_check(__FILE__, __LINE__, true);
1357    }
1358 }
1359
1360 static void close_vss_backup_session(JCR *jcr)
1361 {
1362 #if defined(WIN32_VSS)
1363    /* STOP VSS ON WIN32 */
1364    /* tell vss to close the backup session */
1365    if (jcr->VSS) {
1366       if (g_pVSSClient->CloseBackup()) {
1367          /* inform user about writer states */
1368          for (int i=0; i<(int)g_pVSSClient->GetWriterCount(); i++) {
1369             int msg_type = M_INFO;
1370             if (g_pVSSClient->GetWriterState(i) < 1) {
1371                msg_type = M_WARNING;
1372                jcr->JobErrors++;
1373             }
1374             Jmsg(jcr, msg_type, 0, _("VSS Writer (BackupComplete): %s\n"), g_pVSSClient->GetWriterInfo(i));
1375          }
1376       }
1377       WCHAR *metadata = g_pVSSClient->GetMetadata();
1378       if (metadata) {
1379          FF_PKT *ff_pkt = jcr->ff;
1380          ff_pkt->fname = (char *)"job";
1381          ff_pkt->type = FT_RESTORE_FIRST;
1382          ff_pkt->LinkFI = 0;
1383          ff_pkt->object_name = (char *)"job_metadata.xml";
1384          ff_pkt->object = (char *)metadata;
1385          ff_pkt->object_len = (wcslen(metadata) + 1) * sizeof(WCHAR);
1386          ff_pkt->object_index = (int)time(NULL);
1387          save_file(jcr, ff_pkt, true);
1388      }
1389    }
1390 #endif
1391 }