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

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