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