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