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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2011 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version three of the GNU Affero General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU Affero General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /**
  29  *  Bacula File Daemon  backup.c  send file attributes and data
  30  *   to the Storage daemon.
  31  *
  32  *    Kern Sibbald, March MM
  33  *
  34  */
  35
  36 #include "bacula.h"
  37 #include "filed.h"
  38
  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    jcr->setJobStatus(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       jcr->setJobStatus(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 overload 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       jcr->setJobStatus(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_canceled() || jcr->is_incomplete()) {
 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_canceled() ? 0 : 1; /* good return if not canceled */
 751
 752 bail_out:
 753    if (jcr->is_incomplete()) {
 754       rtnstat = 0;
 755    }
 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_OFFSETS)) {
 814          cbuf = (Bytef *)jcr->compress_buf + OFFSET_FADDR_SIZE;
 815          max_compress_len = jcr->compress_buf_size - OFFSET_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             jcr->setJobStatus(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) || (ff_pkt->flags & FO_OFFSETS)) {
 845          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse or offset 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_OFFSETS)) {
 888       rbuf += OFFSET_FADDR_SIZE;
 889       rsize -= OFFSET_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, OFFSET_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_OFFSETS) {
 931          ser_declare;
 932          ser_begin(wbuf, OFFSET_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             jcr->setJobStatus(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             jcr->setJobStatus(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_OFFSETS)) {
 999             cipher_input_len += OFFSET_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_OFFSETS)) {
1035          sd->msglen += OFFSET_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    int hangup = get_hangup();
1123 #ifdef FD_NO_SEND_TEST
1124    return true;
1125 #endif
1126
1127    Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1128    /** Find what data stream we will use, then encode the attributes */
1129    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1130       /* This should not happen */
1131       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1132       return false;
1133    }
1134    encode_stat(attribs, &ff_pkt->statp, ff_pkt->LinkFI, data_stream);
1135
1136    /** Now possibly extend the attributes */
1137    if (ff_pkt->type == FT_RESTORE_FIRST) {
1138       attr_stream = STREAM_RESTORE_OBJECT;
1139    } else {
1140       attribsEx = attribsExBuf;
1141       attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1142    }
1143
1144    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1145
1146    jcr->lock();
1147    jcr->JobFiles++;                    /* increment number of files sent */
1148    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1149    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1150    jcr->unlock();
1151
1152    /* Debug code: check if we must hangup */
1153    if (hangup && (jcr->JobFiles > (uint32_t)hangup)) {
1154       jcr->setJobStatus(JS_Incomplete);
1155       Jmsg1(jcr, M_FATAL, 0, "Debug hangup requested after %d files.\n", hangup);
1156       set_hangup(0);
1157       return false;
1158    }
1159
1160    /**
1161     * Send Attributes header to Storage daemon
1162     *    <file-index> <stream> <info>
1163     */
1164    if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1165       if (!jcr->is_canceled() && !jcr->is_incomplete()) {
1166          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1167                sd->bstrerror());
1168       }
1169       return false;
1170    }
1171    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1172
1173    /**
1174     * Send file attributes to Storage daemon
1175     *   File_index
1176     *   File type
1177     *   Filename (full path)
1178     *   Encoded attributes
1179     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1180     *   Encoded extended-attributes (for Win32)
1181     *
1182     * or send Restore Object to Storage daemon
1183     *   File_index
1184     *   File_type
1185     *   Object_index
1186     *   Object_len  (possibly compressed)
1187     *   Object_full_len (not compressed)
1188     *   Object_compression
1189     *   Plugin_name
1190     *   Object_name
1191     *   Binary Object data
1192     *
1193     * For a directory, link is the same as fname, but with trailing
1194     * slash. For a linked file, link is the link.
1195     */
1196    if (ff_pkt->type != FT_DELETED) { /* already stripped */
1197       strip_path(ff_pkt);
1198    }
1199    switch (ff_pkt->type) {
1200    case FT_LNK:
1201    case FT_LNKSAVED:
1202       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1203       stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c%u%c", jcr->JobFiles,
1204                        ff_pkt->type, ff_pkt->fname, 0, attribs, 0,
1205                        ff_pkt->link, 0, attribsEx, 0, ff_pkt->delta_seq, 0);
1206       break;
1207    case FT_DIREND:
1208    case FT_REPARSE:
1209    case FT_JUNCTION:
1210       /* Here link is the canonical filename (i.e. with trailing slash) */
1211       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
1212                        ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0,
1213                        attribsEx, 0, ff_pkt->delta_seq, 0);
1214       break;
1215    case FT_RESTORE_FIRST:
1216       comp_len = ff_pkt->object_len;
1217       ff_pkt->object_compression = 0;
1218       if (ff_pkt->object_len > 1000) {
1219          /* Big object, compress it */
1220          int stat;
1221          comp_len = ff_pkt->object_len + 1000;
1222          POOLMEM *comp_obj = get_memory(comp_len);
1223          stat = Zdeflate(ff_pkt->object, ff_pkt->object_len, comp_obj, comp_len);
1224          if (comp_len < ff_pkt->object_len) {
1225             ff_pkt->object = comp_obj;
1226             ff_pkt->object_compression = 1;    /* zlib level 9 compression */
1227          } else {
1228             /* Uncompressed object smaller, use it */
1229             comp_len = ff_pkt->object_len;
1230          }
1231          Dmsg2(100, "Object compressed from %d to %d bytes\n", ff_pkt->object_len, comp_len);
1232       }
1233       sd->msglen = Mmsg(sd->msg, "%d %d %d %d %d %d %s%c%s%c",
1234                         jcr->JobFiles, ff_pkt->type, ff_pkt->object_index,
1235                         comp_len, ff_pkt->object_len, ff_pkt->object_compression,
1236                         ff_pkt->fname, 0, ff_pkt->object_name, 0);
1237       sd->msg = check_pool_memory_size(sd->msg, sd->msglen + comp_len + 2);
1238       memcpy(sd->msg + sd->msglen, ff_pkt->object, comp_len);
1239       /* Note we send one extra byte so Dir can store zero after object */
1240       sd->msglen += comp_len + 1;
1241       stat = sd->send();
1242       if (ff_pkt->object_compression) {
1243          free_and_null_pool_memory(ff_pkt->object);
1244       }
1245       break;
1246    case FT_REG:
1247       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%d%c", jcr->JobFiles,
1248                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0,
1249                ff_pkt->delta_seq, 0);
1250       break;
1251    default:
1252       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
1253                        ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0,
1254                        attribsEx, 0, ff_pkt->delta_seq, 0);
1255       break;
1256    }
1257    if (ff_pkt->type != FT_DELETED) {
1258       unstrip_path(ff_pkt);
1259    }
1260
1261    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1262    if (!stat && !jcr->is_job_canceled()) {
1263       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1264             sd->bstrerror());
1265    }
1266    sd->signal(BNET_EOD);            /* indicate end of attributes data */
1267    return stat;
1268 }
1269
1270 /**
1271  * Do in place strip of path
1272  */
1273 static bool do_strip(int count, char *in)
1274 {
1275    char *out = in;
1276    int stripped;
1277    int numsep = 0;
1278
1279    /** Copy to first path separator -- Win32 might have c: ... */
1280    while (*in && !IsPathSeparator(*in)) {
1281       out++; in++;
1282    }
1283    out++; in++;
1284    numsep++;                     /* one separator seen */
1285    for (stripped=0; stripped<count && *in; stripped++) {
1286       while (*in && !IsPathSeparator(*in)) {
1287          in++;                   /* skip chars */
1288       }
1289       if (*in) {
1290          numsep++;               /* count separators seen */
1291          in++;                   /* skip separator */
1292       }
1293    }
1294    /* Copy to end */
1295    while (*in) {                /* copy to end */
1296       if (IsPathSeparator(*in)) {
1297          numsep++;
1298       }
1299       *out++ = *in++;
1300    }
1301    *out = 0;
1302    Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1303          stripped, count, numsep, numsep>count);
1304    return stripped==count && numsep>count;
1305 }
1306
1307 /**
1308  * If requested strip leading components of the path so that we can
1309  *   save file as if it came from a subdirectory.  This is most useful
1310  *   for dealing with snapshots, by removing the snapshot directory, or
1311  *   in handling vendor migrations where files have been restored with
1312  *   a vendor product into a subdirectory.
1313  */
1314 void strip_path(FF_PKT *ff_pkt)
1315 {
1316    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1317       Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1318       return;
1319    }
1320    if (!ff_pkt->fname_save) {
1321      ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1322      ff_pkt->link_save = get_pool_memory(PM_FNAME);
1323    }
1324    pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1325    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1326       pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1327       Dmsg2(500, "strcpy link_save=%d link=%d\n", strlen(ff_pkt->link_save),
1328          strlen(ff_pkt->link));
1329       sm_check(__FILE__, __LINE__, true);
1330    }
1331
1332    /**
1333     * Strip path.  If it doesn't succeed put it back.  If
1334     *  it does, and there is a different link string,
1335     *  attempt to strip the link. If it fails, back them
1336     *  both back.
1337     * Do not strip symlinks.
1338     * I.e. if either stripping fails don't strip anything.
1339     */
1340    if (!do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1341       unstrip_path(ff_pkt);
1342       goto rtn;
1343    }
1344    /** Strip links but not symlinks */
1345    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1346       if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1347          unstrip_path(ff_pkt);
1348       }
1349    }
1350
1351 rtn:
1352    Dmsg3(100, "fname=%s stripped=%s link=%s\n", ff_pkt->fname_save, ff_pkt->fname,
1353        ff_pkt->link);
1354 }
1355
1356 void unstrip_path(FF_PKT *ff_pkt)
1357 {
1358    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1359       return;
1360    }
1361    strcpy(ff_pkt->fname, ff_pkt->fname_save);
1362    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1363       Dmsg2(500, "strcpy link=%s link_save=%s\n", ff_pkt->link,
1364           ff_pkt->link_save);
1365       strcpy(ff_pkt->link, ff_pkt->link_save);
1366       Dmsg2(500, "strcpy link=%d link_save=%d\n", strlen(ff_pkt->link),
1367           strlen(ff_pkt->link_save));
1368       sm_check(__FILE__, __LINE__, true);
1369    }
1370 }
1371
1372 static void close_vss_backup_session(JCR *jcr)
1373 {
1374 #if defined(WIN32_VSS)
1375    /* STOP VSS ON WIN32 */
1376    /* tell vss to close the backup session */
1377    if (jcr->VSS) {
1378       if (g_pVSSClient->CloseBackup()) {
1379          /* inform user about writer states */
1380          for (int i=0; i<(int)g_pVSSClient->GetWriterCount(); i++) {
1381             int msg_type = M_INFO;
1382             if (g_pVSSClient->GetWriterState(i) < 1) {
1383                msg_type = M_WARNING;
1384                jcr->JobErrors++;
1385             }
1386             Jmsg(jcr, msg_type, 0, _("VSS Writer (BackupComplete): %s\n"), g_pVSSClient->GetWriterInfo(i));
1387          }
1388       }
1389       WCHAR *metadata = g_pVSSClient->GetMetadata();
1390       if (metadata) {
1391          FF_PKT *ff_pkt = jcr->ff;
1392          ff_pkt->fname = (char *)"job";
1393          ff_pkt->type = FT_RESTORE_FIRST;
1394          ff_pkt->LinkFI = 0;
1395          ff_pkt->object_name = (char *)"job_metadata.xml";
1396          ff_pkt->object = (char *)metadata;
1397          ff_pkt->object_len = (wcslen(metadata) + 1) * sizeof(WCHAR);
1398          ff_pkt->object_index = (int)time(NULL);
1399          save_file(jcr, ff_pkt, true);
1400      }
1401    }
1402 #endif
1403 }