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