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

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