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

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