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       /* Keep the checksum if this file is a hardlink */
 745       if (ff_pkt->linked) {
 746          ff_pkt_set_link_digest(ff_pkt, digest_stream, sd->msg, size);
 747       }
 748
 749       sd->msglen = size;
 750       sd->send();
 751       sd->signal(BNET_EOD);              /* end of checksum */
 752    }
 753
 754    /* Check if original file has a digest, and send it */
 755    if (ff_pkt->type == FT_LNKSAVED && ff_pkt->digest) {
 756       Dmsg2(300, "Link %s digest %d\n", ff_pkt->fname, ff_pkt->digest_len);
 757       sd->fsend("%ld %d 0", jcr->JobFiles, ff_pkt->digest_stream);
 758
 759       sd->msg = check_pool_memory_size(sd->msg, ff_pkt->digest_len);
 760       memcpy(sd->msg, ff_pkt->digest, ff_pkt->digest_len);
 761       sd->msglen = ff_pkt->digest_len;
 762       sd->send();
 763
 764       sd->signal(BNET_EOD);              /* end of hardlink record */
 765    }
 766
 767 good_rtn:
 768    rtnstat = jcr->is_canceled() ? 0 : 1; /* good return if not canceled */
 769
 770 bail_out:
 771    if (jcr->is_incomplete()) {
 772       rtnstat = 0;
 773    }
 774    if (ff_pkt->cmd_plugin && plugin_started) {
 775       send_plugin_name(jcr, sd, false); /* signal end of plugin data */
 776    }
 777    if (digest) {
 778       crypto_digest_free(digest);
 779    }
 780    if (signing_digest) {
 781       crypto_digest_free(signing_digest);
 782    }
 783    if (sig) {
 784       crypto_sign_free(sig);
 785    }
 786    return rtnstat;
 787 }
 788
 789 /**
 790  * Send data read from an already open file descriptor.
 791  *
 792  * We return 1 on sucess and 0 on errors.
 793  *
 794  * ***FIXME***
 795  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 796  *  reading.
 797  * Currently this is not a problem as the only other stream, resource forks,
 798  * are not handled as sparse files.
 799  */
 800 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 801                      DIGEST *signing_digest)
 802 {
 803    BSOCK *sd = jcr->store_bsock;
 804    uint64_t fileAddr = 0;             /* file address */
 805    char *rbuf, *wbuf;
 806    int32_t rsize = jcr->buf_size;      /* read buffer size */
 807    POOLMEM *msgsave;
 808    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 809    const uint8_t *cipher_input;
 810    uint32_t cipher_input_len;
 811    uint32_t cipher_block_size;
 812    uint32_t encrypted_len;
 813 #ifdef FD_NO_SEND_TEST
 814    return 1;
 815 #endif
 816
 817    msgsave = sd->msg;
 818    rbuf = sd->msg;                    /* read buffer */
 819    wbuf = sd->msg;                    /* write buffer */
 820    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 821
 822    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 823
 824 #ifdef HAVE_LIBZ
 825    uLong compress_len = 0;
 826    uLong max_compress_len = 0;
 827    const Bytef *cbuf = NULL;
 828    int zstat;
 829
 830    if (ff_pkt->flags & FO_GZIP) {
 831       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 832          cbuf = (Bytef *)jcr->compress_buf + OFFSET_FADDR_SIZE;
 833          max_compress_len = jcr->compress_buf_size - OFFSET_FADDR_SIZE;
 834       } else {
 835          cbuf = (Bytef *)jcr->compress_buf;
 836          max_compress_len = jcr->compress_buf_size; /* set max length */
 837       }
 838       wbuf = jcr->compress_buf;    /* compressed output here */
 839       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 840
 841       /**
 842        * Only change zlib parameters if there is no pending operation.
 843        * This should never happen as deflatereset is called after each
 844        * deflate.
 845        */
 846
 847       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 848          /** set gzip compression level - must be done per file */
 849          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 850               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 851             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 852             jcr->setJobStatus(JS_ErrorTerminated);
 853             goto err;
 854          }
 855       }
 856    }
 857 #else
 858    const uint32_t max_compress_len = 0;
 859 #endif
 860
 861    if (ff_pkt->flags & FO_ENCRYPT) {
 862       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 863          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse or offset data not supported.\n"));
 864          goto err;
 865       }
 866       /** Allocate the cipher context */
 867       if ((cipher_ctx = crypto_cipher_new(jcr->crypto.pki_session, true,
 868            &cipher_block_size)) == NULL) {
 869          /* Shouldn't happen! */
 870          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 871          goto err;
 872       }
 873
 874       /**
 875        * Grow the crypto buffer, if necessary.
 876        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 877        * We grow crypto_buf to the maximum number of blocks that
 878        * could be returned for the given read buffer size.
 879        * (Using the larger of either rsize or max_compress_len)
 880        */
 881       jcr->crypto.crypto_buf = check_pool_memory_size(jcr->crypto.crypto_buf,
 882            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 883             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 884
 885       wbuf = jcr->crypto.crypto_buf; /* Encrypted, possibly compressed output here. */
 886    }
 887
 888    /**
 889     * Send Data header to Storage daemon
 890     *    <file-index> <stream> <info>
 891     */
 892    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 893       if (!jcr->is_job_canceled()) {
 894          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 895                sd->bstrerror());
 896       }
 897       goto err;
 898    }
 899    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 900
 901    /**
 902     * Make space at beginning of buffer for fileAddr because this
 903     *   same buffer will be used for writing if compression is off.
 904     */
 905    if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
 906       rbuf += OFFSET_FADDR_SIZE;
 907       rsize -= OFFSET_FADDR_SIZE;
 908 #ifdef HAVE_FREEBSD_OS
 909       /**
 910        * To read FreeBSD partitions, the read size must be
 911        *  a multiple of 512.
 912        */
 913       rsize = (rsize/512) * 512;
 914 #endif
 915    }
 916
 917    /** a RAW device read on win32 only works if the buffer is a multiple of 512 */
 918 #ifdef HAVE_WIN32
 919    if (S_ISBLK(ff_pkt->statp.st_mode))
 920       rsize = (rsize/512) * 512;
 921 #endif
 922
 923    /**
 924     * Read the file data
 925     */
 926    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 927
 928       /** Check for sparse blocks */
 929       if (ff_pkt->flags & FO_SPARSE) {
 930          ser_declare;
 931          bool allZeros = false;
 932          if ((sd->msglen == rsize &&
 933               fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size) ||
 934              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 935                (uint64_t)ff_pkt->statp.st_size == 0)) {
 936             allZeros = is_buf_zero(rbuf, rsize);
 937          }
 938          if (!allZeros) {
 939             /** Put file address as first data in buffer */
 940             ser_begin(wbuf, OFFSET_FADDR_SIZE);
 941             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 942          }
 943          fileAddr += sd->msglen;      /* update file address */
 944          /** Skip block of all zeros */
 945          if (allZeros) {
 946             continue;                 /* skip block of zeros */
 947          }
 948       } else if (ff_pkt->flags & FO_OFFSETS) {
 949          ser_declare;
 950          ser_begin(wbuf, OFFSET_FADDR_SIZE);
 951          ser_uint64(ff_pkt->bfd.offset);     /* store offset in begin of buffer */
 952       }
 953
 954       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 955
 956       /** Uncompressed cipher input length */
 957       cipher_input_len = sd->msglen;
 958
 959       /** Update checksum if requested */
 960       if (digest) {
 961          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 962       }
 963
 964       /** Update signing digest if requested */
 965       if (signing_digest) {
 966          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 967       }
 968
 969 #ifdef HAVE_LIBZ
 970       /** Do compression if turned on */
 971       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 972          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 973
 974          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 975                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 976          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 977                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 978
 979          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 980             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 981             jcr->setJobStatus(JS_ErrorTerminated);
 982             goto err;
 983          }
 984          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 985          /** reset zlib stream to be able to begin from scratch again */
 986          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 987             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 988             jcr->setJobStatus(JS_ErrorTerminated);
 989             goto err;
 990          }
 991
 992          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 993                sd->msglen);
 994
 995          sd->msglen = compress_len;      /* set compressed length */
 996          cipher_input_len = compress_len;
 997       }
 998 #endif
 999       /**
1000        * Note, here we prepend the current record length to the beginning
1001        *  of the encrypted data. This is because both sparse and compression
1002        *  restore handling want records returned to them with exactly the
1003        *  same number of bytes that were processed in the backup handling.
1004        *  That is, both are block filters rather than a stream.  When doing
1005        *  compression, the compression routines may buffer data, so that for
1006        *  any one record compressed, when it is decompressed the same size
1007        *  will not be obtained. Of course, the buffered data eventually comes
1008        *  out in subsequent crypto_cipher_update() calls or at least
1009        *  when crypto_cipher_finalize() is called.  Unfortunately, this
1010        *  "feature" of encryption enormously complicates the restore code.
1011        */
1012       if (ff_pkt->flags & FO_ENCRYPT) {
1013          uint32_t initial_len = 0;
1014          ser_declare;
1015
1016          if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
1017             cipher_input_len += OFFSET_FADDR_SIZE;
1018          }
1019
1020          /** Encrypt the length of the input block */
1021          uint8_t packet_len[sizeof(uint32_t)];
1022
1023          ser_begin(packet_len, sizeof(uint32_t));
1024          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
1025          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
1026
1027          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
1028              (uint8_t *)jcr->crypto.crypto_buf, &initial_len)) {
1029             /** Encryption failed. Shouldn't happen. */
1030             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
1031             goto err;
1032          }
1033
1034          /** Encrypt the input block */
1035          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
1036              (uint8_t *)&jcr->crypto.crypto_buf[initial_len], &encrypted_len)) {
1037             if ((initial_len + encrypted_len) == 0) {
1038                /** No full block of data available, read more data */
1039                continue;
1040             }
1041             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
1042                   sd->msglen);
1043             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
1044          } else {
1045             /** Encryption failed. Shouldn't happen. */
1046             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
1047             goto err;
1048          }
1049       }
1050
1051       /* Send the buffer to the Storage daemon */
1052       if ((ff_pkt->flags & FO_SPARSE) || (ff_pkt->flags & FO_OFFSETS)) {
1053          sd->msglen += OFFSET_FADDR_SIZE; /* include fileAddr in size */
1054       }
1055       sd->msg = wbuf;              /* set correct write buffer */
1056       if (!sd->send()) {
1057          if (!jcr->is_job_canceled()) {
1058             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1059                   sd->bstrerror());
1060          }
1061          goto err;
1062       }
1063       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1064       /*          #endif */
1065       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
1066       sd->msg = msgsave;                /* restore read buffer */
1067
1068    } /* end while read file data */
1069
1070    if (sd->msglen < 0) {                 /* error */
1071       berrno be;
1072       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
1073          ff_pkt->fname, be.bstrerror(ff_pkt->bfd.berrno));
1074       if (jcr->JobErrors++ > 1000) {       /* insanity check */
1075          Jmsg(jcr, M_FATAL, 0, _("Too many errors. JobErrors=%d.\n"), jcr->JobErrors);
1076       }
1077    } else if (ff_pkt->flags & FO_ENCRYPT) {
1078       /**
1079        * For encryption, we must call finalize to push out any
1080        *  buffered data.
1081        */
1082       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto.crypto_buf,
1083            &encrypted_len)) {
1084          /* Padding failed. Shouldn't happen. */
1085          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
1086          goto err;
1087       }
1088
1089       /** Note, on SSL pre-0.9.7, there is always some output */
1090       if (encrypted_len > 0) {
1091          sd->msglen = encrypted_len;      /* set encrypted length */
1092          sd->msg = jcr->crypto.crypto_buf;       /* set correct write buffer */
1093          if (!sd->send()) {
1094             if (!jcr->is_job_canceled()) {
1095                Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1096                      sd->bstrerror());
1097             }
1098             goto err;
1099          }
1100          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
1101          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
1102          sd->msg = msgsave;               /* restore bnet buffer */
1103       }
1104    }
1105
1106    if (!sd->signal(BNET_EOD)) {        /* indicate end of file data */
1107       if (!jcr->is_job_canceled()) {
1108          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1109                sd->bstrerror());
1110       }
1111       goto err;
1112    }
1113
1114    /** Free the cipher context */
1115    if (cipher_ctx) {
1116       crypto_cipher_free(cipher_ctx);
1117    }
1118    return 1;
1119
1120 err:
1121    /** Free the cipher context */
1122    if (cipher_ctx) {
1123       crypto_cipher_free(cipher_ctx);
1124    }
1125
1126    sd->msg = msgsave; /* restore bnet buffer */
1127    sd->msglen = 0;
1128    return 0;
1129 }
1130
1131 bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1132 {
1133    BSOCK *sd = jcr->store_bsock;
1134    char attribs[MAXSTRING];
1135    char attribsExBuf[MAXSTRING];
1136    char *attribsEx = NULL;
1137    int attr_stream;
1138    int comp_len;
1139    bool stat;
1140    int hangup = get_hangup();
1141 #ifdef FD_NO_SEND_TEST
1142    return true;
1143 #endif
1144
1145    Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1146    /** Find what data stream we will use, then encode the attributes */
1147    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1148       /* This should not happen */
1149       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1150       return false;
1151    }
1152    encode_stat(attribs, &ff_pkt->statp, ff_pkt->LinkFI, data_stream);
1153
1154    /** Now possibly extend the attributes */
1155    if (ff_pkt->type == FT_RESTORE_FIRST) {
1156       attr_stream = STREAM_RESTORE_OBJECT;
1157    } else {
1158       attribsEx = attribsExBuf;
1159       attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1160    }
1161
1162    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1163
1164    jcr->lock();
1165    jcr->JobFiles++;                    /* increment number of files sent */
1166    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1167    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1168    jcr->unlock();
1169
1170    /* Debug code: check if we must hangup */
1171    if (hangup && (jcr->JobFiles > (uint32_t)hangup)) {
1172       jcr->setJobStatus(JS_Incomplete);
1173       Jmsg1(jcr, M_FATAL, 0, "Debug hangup requested after %d files.\n", hangup);
1174       set_hangup(0);
1175       return false;
1176    }
1177
1178    /**
1179     * Send Attributes header to Storage daemon
1180     *    <file-index> <stream> <info>
1181     */
1182    if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1183       if (!jcr->is_canceled() && !jcr->is_incomplete()) {
1184          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1185                sd->bstrerror());
1186       }
1187       return false;
1188    }
1189    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1190
1191    /**
1192     * Send file attributes to Storage daemon
1193     *   File_index
1194     *   File type
1195     *   Filename (full path)
1196     *   Encoded attributes
1197     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1198     *   Encoded extended-attributes (for Win32)
1199     *
1200     * or send Restore Object to Storage daemon
1201     *   File_index
1202     *   File_type
1203     *   Object_index
1204     *   Object_len  (possibly compressed)
1205     *   Object_full_len (not compressed)
1206     *   Object_compression
1207     *   Plugin_name
1208     *   Object_name
1209     *   Binary Object data
1210     *
1211     * For a directory, link is the same as fname, but with trailing
1212     * slash. For a linked file, link is the link.
1213     */
1214    if (ff_pkt->type != FT_DELETED) { /* already stripped */
1215       strip_path(ff_pkt);
1216    }
1217    switch (ff_pkt->type) {
1218    case FT_LNK:
1219    case FT_LNKSAVED:
1220       Dmsg3(300, "Link %d %s to %s\n", jcr->JobFiles, ff_pkt->fname, ff_pkt->link);
1221       stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c%u%c", jcr->JobFiles,
1222                        ff_pkt->type, ff_pkt->fname, 0, attribs, 0,
1223                        ff_pkt->link, 0, attribsEx, 0, ff_pkt->delta_seq, 0);
1224       break;
1225    case FT_DIREND:
1226    case FT_REPARSE:
1227    case FT_JUNCTION:
1228       /* Here link is the canonical filename (i.e. with trailing slash) */
1229       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
1230                        ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0,
1231                        attribsEx, 0, ff_pkt->delta_seq, 0);
1232       break;
1233    case FT_RESTORE_FIRST:
1234       comp_len = ff_pkt->object_len;
1235       ff_pkt->object_compression = 0;
1236       if (ff_pkt->object_len > 1000) {
1237          /* Big object, compress it */
1238          int stat;
1239          comp_len = ff_pkt->object_len + 1000;
1240          POOLMEM *comp_obj = get_memory(comp_len);
1241          stat = Zdeflate(ff_pkt->object, ff_pkt->object_len, comp_obj, comp_len);
1242          if (comp_len < ff_pkt->object_len) {
1243             ff_pkt->object = comp_obj;
1244             ff_pkt->object_compression = 1;    /* zlib level 9 compression */
1245          } else {
1246             /* Uncompressed object smaller, use it */
1247             comp_len = ff_pkt->object_len;
1248          }
1249          Dmsg2(100, "Object compressed from %d to %d bytes\n", ff_pkt->object_len, comp_len);
1250       }
1251       sd->msglen = Mmsg(sd->msg, "%d %d %d %d %d %d %s%c%s%c",
1252                         jcr->JobFiles, ff_pkt->type, ff_pkt->object_index,
1253                         comp_len, ff_pkt->object_len, ff_pkt->object_compression,
1254                         ff_pkt->fname, 0, ff_pkt->object_name, 0);
1255       sd->msg = check_pool_memory_size(sd->msg, sd->msglen + comp_len + 2);
1256       memcpy(sd->msg + sd->msglen, ff_pkt->object, comp_len);
1257       /* Note we send one extra byte so Dir can store zero after object */
1258       sd->msglen += comp_len + 1;
1259       stat = sd->send();
1260       if (ff_pkt->object_compression) {
1261          free_and_null_pool_memory(ff_pkt->object);
1262       }
1263       break;
1264    case FT_REG:
1265       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%d%c", jcr->JobFiles,
1266                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0,
1267                ff_pkt->delta_seq, 0);
1268       break;
1269    default:
1270       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
1271                        ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0,
1272                        attribsEx, 0, ff_pkt->delta_seq, 0);
1273       break;
1274    }
1275    if (ff_pkt->type != FT_DELETED) {
1276       unstrip_path(ff_pkt);
1277    }
1278
1279    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1280    if (!stat && !jcr->is_job_canceled()) {
1281       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1282             sd->bstrerror());
1283    }
1284    sd->signal(BNET_EOD);            /* indicate end of attributes data */
1285    return stat;
1286 }
1287
1288 /**
1289  * Do in place strip of path
1290  */
1291 static bool do_strip(int count, char *in)
1292 {
1293    char *out = in;
1294    int stripped;
1295    int numsep = 0;
1296
1297    /** Copy to first path separator -- Win32 might have c: ... */
1298    while (*in && !IsPathSeparator(*in)) {
1299       out++; in++;
1300    }
1301    out++; in++;
1302    numsep++;                     /* one separator seen */
1303    for (stripped=0; stripped<count && *in; stripped++) {
1304       while (*in && !IsPathSeparator(*in)) {
1305          in++;                   /* skip chars */
1306       }
1307       if (*in) {
1308          numsep++;               /* count separators seen */
1309          in++;                   /* skip separator */
1310       }
1311    }
1312    /* Copy to end */
1313    while (*in) {                /* copy to end */
1314       if (IsPathSeparator(*in)) {
1315          numsep++;
1316       }
1317       *out++ = *in++;
1318    }
1319    *out = 0;
1320    Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1321          stripped, count, numsep, numsep>count);
1322    return stripped==count && numsep>count;
1323 }
1324
1325 /**
1326  * If requested strip leading components of the path so that we can
1327  *   save file as if it came from a subdirectory.  This is most useful
1328  *   for dealing with snapshots, by removing the snapshot directory, or
1329  *   in handling vendor migrations where files have been restored with
1330  *   a vendor product into a subdirectory.
1331  */
1332 void strip_path(FF_PKT *ff_pkt)
1333 {
1334    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1335       Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1336       return;
1337    }
1338    if (!ff_pkt->fname_save) {
1339      ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1340      ff_pkt->link_save = get_pool_memory(PM_FNAME);
1341    }
1342    pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1343    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1344       pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1345       Dmsg2(500, "strcpy link_save=%d link=%d\n", strlen(ff_pkt->link_save),
1346          strlen(ff_pkt->link));
1347       sm_check(__FILE__, __LINE__, true);
1348    }
1349
1350    /**
1351     * Strip path.  If it doesn't succeed put it back.  If
1352     *  it does, and there is a different link string,
1353     *  attempt to strip the link. If it fails, back them
1354     *  both back.
1355     * Do not strip symlinks.
1356     * I.e. if either stripping fails don't strip anything.
1357     */
1358    if (!do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1359       unstrip_path(ff_pkt);
1360       goto rtn;
1361    }
1362    /** Strip links but not symlinks */
1363    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1364       if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1365          unstrip_path(ff_pkt);
1366       }
1367    }
1368
1369 rtn:
1370    Dmsg3(100, "fname=%s stripped=%s link=%s\n", ff_pkt->fname_save, ff_pkt->fname,
1371        ff_pkt->link);
1372 }
1373
1374 void unstrip_path(FF_PKT *ff_pkt)
1375 {
1376    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1377       return;
1378    }
1379    strcpy(ff_pkt->fname, ff_pkt->fname_save);
1380    if (ff_pkt->type != FT_LNK && ff_pkt->fname != ff_pkt->link) {
1381       Dmsg2(500, "strcpy link=%s link_save=%s\n", ff_pkt->link,
1382           ff_pkt->link_save);
1383       strcpy(ff_pkt->link, ff_pkt->link_save);
1384       Dmsg2(500, "strcpy link=%d link_save=%d\n", strlen(ff_pkt->link),
1385           strlen(ff_pkt->link_save));
1386       sm_check(__FILE__, __LINE__, true);
1387    }
1388 }
1389
1390 static void close_vss_backup_session(JCR *jcr)
1391 {
1392 #if defined(WIN32_VSS)
1393    /* STOP VSS ON WIN32 */
1394    /* tell vss to close the backup session */
1395    if (jcr->VSS) {
1396       if (g_pVSSClient->CloseBackup()) {
1397          /* inform user about writer states */
1398          for (int i=0; i<(int)g_pVSSClient->GetWriterCount(); i++) {
1399             int msg_type = M_INFO;
1400             if (g_pVSSClient->GetWriterState(i) < 1) {
1401                msg_type = M_WARNING;
1402                jcr->JobErrors++;
1403             }
1404             Jmsg(jcr, msg_type, 0, _("VSS Writer (BackupComplete): %s\n"), g_pVSSClient->GetWriterInfo(i));
1405          }
1406       }
1407       WCHAR *metadata = g_pVSSClient->GetMetadata();
1408       if (metadata) {
1409          FF_PKT *ff_pkt = jcr->ff;
1410          ff_pkt->fname = (char *)"job";
1411          ff_pkt->type = FT_RESTORE_FIRST;
1412          ff_pkt->LinkFI = 0;
1413          ff_pkt->object_name = (char *)"job_metadata.xml";
1414          ff_pkt->object = (char *)metadata;
1415          ff_pkt->object_len = (wcslen(metadata) + 1) * sizeof(WCHAR);
1416          ff_pkt->object_index = (int)time(NULL);
1417          save_file(jcr, ff_pkt, true);
1418      }
1419    }
1420 #endif
1421 }