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