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