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

   1 /*
   2  *  Bacula File Daemon  backup.c  send file attributes and data
   3  *   to the Storage daemon.
   4  *
   5  *    Kern Sibbald, March MM
   6  *
   7  *   Version $Id$
   8  *
   9  */
  10 /*
  11    Bacula® - The Network Backup Solution
  12
  13    Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
  14
  15    The main author of Bacula is Kern Sibbald, with contributions from
  16    many others, a complete list can be found in the file AUTHORS.
  17    This program is Free Software; you can redistribute it and/or
  18    modify it under the terms of version two of the GNU General Public
  19    License as published by the Free Software Foundation plus additions
  20    that are listed in the file LICENSE.
  21
  22    This program is distributed in the hope that it will be useful, but
  23    WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  25    General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public License
  28    along with this program; if not, write to the Free Software
  29    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  30    02110-1301, USA.
  31
  32    Bacula® is a registered trademark of John Walker.
  33    The licensor of Bacula is the Free Software Foundation Europe
  34    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  35    Switzerland, email:ftf@fsfeurope.org.
  36 */
  37
  38 #include "bacula.h"
  39 #include "filed.h"
  40
  41 /* Forward referenced functions */
  42 static int save_file(FF_PKT *ff_pkt, void *pkt, bool top_level);
  43 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest, DIGEST *signature_digest);
  44 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream);
  45 static bool read_and_send_acl(JCR *jcr, int acltype, int stream);
  46
  47 /*
  48  * Find all the requested files and send them
  49  * to the Storage daemon.
  50  *
  51  * Note, we normally carry on a one-way
  52  * conversation from this point on with the SD, simply blasting
  53  * data to him.  To properly know what is going on, we
  54  * also run a "heartbeat" monitor which reads the socket and
  55  * reacts accordingly (at the moment it has nothing to do
  56  * except echo the heartbeat to the Director).
  57  *
  58  */
  59 bool blast_data_to_storage_daemon(JCR *jcr, char *addr)
  60 {
  61    BSOCK *sd;
  62    bool ok = true;
  63    // TODO landonf: Allow user to specify encryption algorithm
  64    crypto_cipher_t cipher = CRYPTO_CIPHER_AES_128_CBC;
  65
  66
  67    sd = jcr->store_bsock;
  68
  69    set_jcr_job_status(jcr, JS_Running);
  70
  71    Dmsg1(300, "bfiled: opened data connection %d to stored\n", sd->fd);
  72
  73    LockRes();
  74    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
  75    UnlockRes();
  76    uint32_t buf_size;
  77    if (client) {
  78       buf_size = client->max_network_buffer_size;
  79    } else {
  80       buf_size = 0;                   /* use default */
  81    }
  82    if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
  83       set_jcr_job_status(jcr, JS_ErrorTerminated);
  84       Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size FD->SD.\n"));
  85       return false;
  86    }
  87
  88    jcr->buf_size = sd->msglen;
  89    /* Adjust for compression so that output buffer is
  90     * 12 bytes + 0.1% larger than input buffer plus 18 bytes.
  91     * This gives a bit extra plus room for the sparse addr if any.
  92     * Note, we adjust the read size to be smaller so that the
  93     * same output buffer can be used without growing it.
  94     *
  95     * The zlib compression workset is initialized here to minimise
  96     * the "per file" load. The jcr member is only set, if the init was successful.
  97     */
  98    jcr->compress_buf_size = jcr->buf_size + ((jcr->buf_size+999) / 1000) + 30;
  99    jcr->compress_buf = get_memory(jcr->compress_buf_size);
 100
 101 #ifdef HAVE_LIBZ
 102    z_stream *pZlibStream = (z_stream*)malloc(sizeof(z_stream));
 103    if (pZlibStream) {
 104       pZlibStream->zalloc = Z_NULL;
 105       pZlibStream->zfree = Z_NULL;
 106       pZlibStream->opaque = Z_NULL;
 107       pZlibStream->state = Z_NULL;
 108
 109       if (deflateInit(pZlibStream, Z_DEFAULT_COMPRESSION) == Z_OK)
 110          jcr->pZLIB_compress_workset = pZlibStream;
 111       else
 112          free (pZlibStream);
 113    }
 114 #endif
 115
 116    /* Create encryption session data and a cached, DER-encoded session data
 117     * structure. We use a single session key for each backup, so we'll encode
 118     * the session data only once. */
 119    if (jcr->pki_encrypt) {
 120       uint32_t size = 0;
 121
 122       /* Create per-job session encryption context */
 123       jcr->pki_session = crypto_session_new(cipher, jcr->pki_recipients);
 124
 125       /* Get the session data size */
 126       if (crypto_session_encode(jcr->pki_session, (uint8_t *)0, &size) == false) {
 127          Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
 128          return 0;
 129       }
 130
 131       /* Allocate buffer */
 132       jcr->pki_session_encoded = (uint8_t *)malloc(size);
 133       if (!jcr->pki_session_encoded) {
 134          return 0;
 135       }
 136
 137       /* Encode session data */
 138       if (crypto_session_encode(jcr->pki_session, jcr->pki_session_encoded, &size) == false) {
 139          Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
 140          return 0;
 141       }
 142
 143       /* ... and store the encoded size */
 144       jcr->pki_session_encoded_size = size;
 145
 146       /* Allocate the encryption/decryption buffer */
 147       jcr->crypto_buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 148    }
 149
 150    Dmsg1(300, "set_find_options ff=%p\n", jcr->ff);
 151    set_find_options((FF_PKT *)jcr->ff, jcr->incremental, jcr->mtime);
 152    Dmsg0(300, "start find files\n");
 153
 154    start_heartbeat_monitor(jcr);
 155
 156    jcr->acl_text = get_pool_memory(PM_MESSAGE);
 157
 158    /* Subroutine save_file() is called for each file */
 159    if (!find_files(jcr, (FF_PKT *)jcr->ff, save_file, (void *)jcr)) {
 160       ok = false;                     /* error */
 161       set_jcr_job_status(jcr, JS_ErrorTerminated);
 162 //    Jmsg(jcr, M_FATAL, 0, _("Find files error.\n"));
 163    }
 164
 165    free_pool_memory(jcr->acl_text);
 166
 167    stop_heartbeat_monitor(jcr);
 168
 169    bnet_sig(sd, BNET_EOD);            /* end of sending data */
 170
 171    if (jcr->big_buf) {
 172       free(jcr->big_buf);
 173       jcr->big_buf = NULL;
 174    }
 175    if (jcr->compress_buf) {
 176       free_pool_memory(jcr->compress_buf);
 177       jcr->compress_buf = NULL;
 178    }
 179    if (jcr->pZLIB_compress_workset) {
 180       /* Free the zlib stream */
 181 #ifdef HAVE_LIBZ
 182       deflateEnd((z_stream *)jcr->pZLIB_compress_workset);
 183 #endif
 184       free (jcr->pZLIB_compress_workset);
 185       jcr->pZLIB_compress_workset = NULL;
 186    }
 187    if (jcr->crypto_buf) {
 188       free_pool_memory(jcr->crypto_buf);
 189       jcr->crypto_buf = NULL;
 190    }
 191    if (jcr->pki_session) {
 192       crypto_session_free(jcr->pki_session);
 193    }
 194    if (jcr->pki_session_encoded) {
 195       free(jcr->pki_session_encoded);
 196    }
 197
 198    Dmsg1(100, "end blast_data ok=%d\n", ok);
 199    return ok;
 200 }
 201
 202 /*
 203  * Called here by find() for each file included.
 204  *   This is a callback. The original is find_files() above.
 205  *
 206  *  Send the file and its data to the Storage daemon.
 207  *
 208  *  Returns: 1 if OK
 209  *           0 if error
 210  *          -1 to ignore file/directory (not used here)
 211  */
 212 static int save_file(FF_PKT *ff_pkt, void *vjcr, bool top_level)
 213 {
 214    bool do_read = false;
 215    int stat, data_stream;
 216    int rtnstat = 0;
 217    DIGEST *digest = NULL;
 218    DIGEST *signing_digest = NULL;
 219    int digest_stream = STREAM_NONE;
 220    SIGNATURE *sig = NULL;
 221    uint8_t *buf = NULL;
 222    bool has_file_data = false;
 223    // TODO landonf: Allow the user to specify the digest algorithm
 224 #ifdef HAVE_SHA2
 225    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA256;
 226 #else
 227    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA1;
 228 #endif
 229    JCR *jcr = (JCR *)vjcr;
 230    BSOCK *sd = jcr->store_bsock;
 231
 232    if (job_canceled(jcr)) {
 233       return 0;
 234    }
 235
 236    jcr->num_files_examined++;         /* bump total file count */
 237
 238    switch (ff_pkt->type) {
 239    case FT_LNKSAVED:                  /* Hard linked, file already saved */
 240       Dmsg2(130, "FT_LNKSAVED hard link: %s => %s\n", ff_pkt->fname, ff_pkt->link);
 241       break;
 242    case FT_REGE:
 243       Dmsg1(130, "FT_REGE saving: %s\n", ff_pkt->fname);
 244       has_file_data = true;
 245       break;
 246    case FT_REG:
 247       Dmsg1(130, "FT_REG saving: %s\n", ff_pkt->fname);
 248       has_file_data = true;
 249       break;
 250    case FT_LNK:
 251       Dmsg2(130, "FT_LNK saving: %s -> %s\n", ff_pkt->fname, ff_pkt->link);
 252       break;
 253    case FT_DIRBEGIN:
 254       jcr->num_files_examined--;      /* correct file count */
 255       return 1;                       /* not used */
 256    case FT_NORECURSE:
 257       Jmsg(jcr, M_INFO, 1, _("     Recursion turned off. Will not descend from %s into %s\n"),
 258            ff_pkt->top_fname, ff_pkt->fname);
 259       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 260       break;
 261    case FT_NOFSCHG:
 262       /* Suppress message for /dev filesystems */
 263       if (strncmp(ff_pkt->fname, "/dev/", 5) != 0) {
 264          Jmsg(jcr, M_INFO, 1, _("     %s is a different filesystem. Will not descend from %s into %s\n"),
 265               ff_pkt->fname, ff_pkt->top_fname, ff_pkt->fname);
 266       }
 267       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 268       break;
 269    case FT_INVALIDFS:
 270       Jmsg(jcr, M_INFO, 1, _("     Disallowed filesystem. Will not descend from %s into %s\n"),
 271            ff_pkt->top_fname, ff_pkt->fname);
 272       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 273       break;
 274    case FT_INVALIDDT:
 275       Jmsg(jcr, M_INFO, 1, _("     Disallowed drive type. Will not descend into %s\n"),
 276            ff_pkt->fname);
 277       break;
 278    case FT_DIREND:
 279       Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
 280       break;
 281    case FT_SPEC:
 282       Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
 283       break;
 284    case FT_RAW:
 285       Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
 286       has_file_data = true;
 287       break;
 288    case FT_FIFO:
 289       Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
 290       break;
 291    case FT_NOACCESS: {
 292       berrno be;
 293       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not access %s: ERR=%s\n"), ff_pkt->fname,
 294          be.strerror(ff_pkt->ff_errno));
 295       jcr->Errors++;
 296       return 1;
 297    }
 298    case FT_NOFOLLOW: {
 299       berrno be;
 300       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not follow link %s: ERR=%s\n"), ff_pkt->fname,
 301          be.strerror(ff_pkt->ff_errno));
 302       jcr->Errors++;
 303       return 1;
 304    }
 305    case FT_NOSTAT: {
 306       berrno be;
 307       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not stat %s: ERR=%s\n"), ff_pkt->fname,
 308          be.strerror(ff_pkt->ff_errno));
 309       jcr->Errors++;
 310       return 1;
 311    }
 312    case FT_DIRNOCHG:
 313    case FT_NOCHG:
 314       Jmsg(jcr, M_SKIPPED, 1, _("     Unchanged file skipped: %s\n"), ff_pkt->fname);
 315       return 1;
 316    case FT_ISARCH:
 317       Jmsg(jcr, M_NOTSAVED, 0, _("     Archive file not saved: %s\n"), ff_pkt->fname);
 318       return 1;
 319    case FT_NOOPEN: {
 320       berrno be;
 321       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not open directory %s: ERR=%s\n"), ff_pkt->fname,
 322          be.strerror(ff_pkt->ff_errno));
 323       jcr->Errors++;
 324       return 1;
 325    }
 326    default:
 327       Jmsg(jcr, M_NOTSAVED, 0,  _("     Unknown file type %d; not saved: %s\n"), ff_pkt->type, ff_pkt->fname);
 328       jcr->Errors++;
 329       return 1;
 330    }
 331
 332    Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
 333
 334    /* Digests and encryption are only useful if there's file data */
 335    if (has_file_data) {
 336       /*
 337        * Setup for digest handling. If this fails, the digest will be set to NULL
 338        * and not used.
 339        */
 340       if (ff_pkt->flags & FO_MD5) {
 341          digest = crypto_digest_new(CRYPTO_DIGEST_MD5);
 342          digest_stream = STREAM_MD5_DIGEST;
 343
 344       } else if (ff_pkt->flags & FO_SHA1) {
 345          digest = crypto_digest_new(CRYPTO_DIGEST_SHA1);
 346          digest_stream = STREAM_SHA1_DIGEST;
 347
 348       } else if (ff_pkt->flags & FO_SHA256) {
 349          digest = crypto_digest_new(CRYPTO_DIGEST_SHA256);
 350          digest_stream = STREAM_SHA256_DIGEST;
 351
 352       } else if (ff_pkt->flags & FO_SHA512) {
 353          digest = crypto_digest_new(CRYPTO_DIGEST_SHA512);
 354          digest_stream = STREAM_SHA512_DIGEST;
 355       }
 356
 357       /* Did digest initialization fail? */
 358       if (digest_stream != STREAM_NONE && digest == NULL) {
 359          Jmsg(jcr, M_WARNING, 0, _("%s digest initialization failed\n"),
 360             stream_to_ascii(digest_stream));
 361       }
 362
 363       /*
 364        * Set up signature digest handling. If this fails, the signature digest will be set to
 365        * NULL and not used.
 366        */
 367       // TODO landonf: We should really only calculate the digest once, for both verification and signing.
 368       if (jcr->pki_sign) {
 369          signing_digest = crypto_digest_new(signing_algorithm);
 370
 371          /* Full-stop if a failure occurred initializing the signature digest */
 372          if (signing_digest == NULL) {
 373             Jmsg(jcr, M_NOTSAVED, 0, _("%s signature digest initialization failed\n"),
 374                stream_to_ascii(signing_algorithm));
 375             jcr->Errors++;
 376             goto good_rtn;
 377          }
 378       }
 379
 380       /* Enable encryption */
 381       if (jcr->pki_encrypt) {
 382          ff_pkt->flags |= FO_ENCRYPT;
 383       }
 384    }
 385
 386    /* Initialise the file descriptor we use for data and other streams. */
 387    binit(&ff_pkt->bfd);
 388    if (ff_pkt->flags & FO_PORTABLE) {
 389       set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
 390    }
 391    if (ff_pkt->reader) {
 392       if (!set_prog(&ff_pkt->bfd, ff_pkt->reader, jcr)) {
 393          Jmsg(jcr, M_FATAL, 0, _("Python reader program \"%s\" not found.\n"),
 394             ff_pkt->reader);
 395          goto bail_out;
 396       }
 397    }
 398
 399    /* Send attributes -- must be done after binit() */
 400    if (!encode_and_send_attributes(jcr, ff_pkt, data_stream)) {
 401       goto bail_out;
 402    }
 403
 404    /* Set up the encryption context and send the session data to the SD */
 405    if (has_file_data && jcr->pki_encrypt) {
 406       /* Send our header */
 407       Dmsg2(100, "Send hdr fi=%ld stream=%d\n", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 408       bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 409
 410       /* Grow the bsock buffer to fit our message if necessary */
 411       if (sizeof_pool_memory(sd->msg) < jcr->pki_session_encoded_size) {
 412          sd->msg = realloc_pool_memory(sd->msg, jcr->pki_session_encoded_size);
 413       }
 414
 415       /* Copy our message over and send it */
 416       memcpy(sd->msg, jcr->pki_session_encoded, jcr->pki_session_encoded_size);
 417       sd->msglen = jcr->pki_session_encoded_size;
 418       jcr->JobBytes += sd->msglen;
 419
 420       Dmsg1(100, "Send data len=%d\n", sd->msglen);
 421       bnet_send(sd);
 422       bnet_sig(sd, BNET_EOD);
 423    }
 424
 425    /*
 426     * Open any file with data that we intend to save, then save it.
 427     *
 428     * Note, if is_win32_backup, we must open the Directory so that
 429     * the BackupRead will save its permissions and ownership streams.
 430     */
 431
 432    if (ff_pkt->type != FT_LNKSAVED && S_ISREG(ff_pkt->statp.st_mode)) {
 433 #ifdef HAVE_WIN32
 434       do_read = !is_portable_backup(&ff_pkt->bfd) || ff_pkt->statp.st_size > 0;
 435 #else
 436       do_read = ff_pkt->statp.st_size > 0;
 437 #endif
 438    } else if (ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
 439          (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
 440       do_read = true;
 441    }
 442
 443    if (do_read) {
 444       btimer_t *tid;
 445       if (ff_pkt->type == FT_FIFO) {
 446          tid = start_thread_timer(pthread_self(), 60);
 447       } else {
 448          tid = NULL;
 449       }
 450       int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
 451       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
 452          ff_pkt->ff_errno = errno;
 453          berrno be;
 454          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open %s: ERR=%s.\n"), ff_pkt->fname,
 455               be.strerror());
 456          jcr->Errors++;
 457          if (tid) {
 458             stop_thread_timer(tid);
 459             tid = NULL;
 460          }
 461          goto good_rtn;
 462       }
 463       if (tid) {
 464          stop_thread_timer(tid);
 465          tid = NULL;
 466       }
 467
 468       stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
 469
 470       if (ff_pkt->flags & FO_CHKCHANGES) {
 471          has_file_changed(jcr, ff_pkt);
 472       }
 473
 474       bclose(&ff_pkt->bfd);
 475
 476       if (!stat) {
 477          goto bail_out;
 478       }
 479    }
 480
 481 #ifdef HAVE_DARWIN_OS
 482    /* Regular files can have resource forks and Finder Info */
 483    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 484             ff_pkt->flags & FO_HFSPLUS)) {
 485       if (ff_pkt->hfsinfo.rsrclength > 0) {
 486          int flags;
 487          int rsrc_stream;
 488          if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 489             ff_pkt->ff_errno = errno;
 490             berrno be;
 491             Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for %s: ERR=%s.\n"), ff_pkt->fname,
 492                   be.strerror());
 493             jcr->Errors++;
 494             if (is_bopen(&ff_pkt->bfd)) {
 495                bclose(&ff_pkt->bfd);
 496             }
 497             goto good_rtn;
 498          }
 499          flags = ff_pkt->flags;
 500          ff_pkt->flags &= ~(FO_GZIP|FO_SPARSE);
 501          if (flags & FO_ENCRYPT) {
 502             rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
 503          } else {
 504             rsrc_stream = STREAM_MACOS_FORK_DATA;
 505          }
 506          stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
 507          ff_pkt->flags = flags;
 508          bclose(&ff_pkt->bfd);
 509          if (!stat) {
 510             goto bail_out;
 511          }
 512       }
 513
 514       Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
 515       bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 516       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 517       memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 518       sd->msglen = 32;
 519       if (digest) {
 520          crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
 521       }
 522       if (signing_digest) {
 523          crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
 524       }
 525       bnet_send(sd);
 526       bnet_sig(sd, BNET_EOD);
 527    }
 528 #endif
 529
 530    if (ff_pkt->flags & FO_ACL) {
 531       /* Read access ACLs for files, dirs and links */
 532       if (!read_and_send_acl(jcr, BACL_TYPE_ACCESS, STREAM_UNIX_ATTRIBUTES_ACCESS_ACL)) {
 533          goto bail_out;
 534       }
 535       /* Directories can have default ACLs too */
 536       if (ff_pkt->type == FT_DIREND && (BACL_CAP & BACL_CAP_DEFAULTS_DIR)) {
 537          if (!read_and_send_acl(jcr, BACL_TYPE_DEFAULT, STREAM_UNIX_ATTRIBUTES_DEFAULT_ACL)) {
 538             goto bail_out;
 539          }
 540       }
 541    }
 542
 543    /* Terminate the signing digest and send it to the Storage daemon */
 544    if (signing_digest) {
 545       uint32_t size = 0;
 546
 547       if ((sig = crypto_sign_new()) == NULL) {
 548          Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for stream signature.\n"));
 549          goto bail_out;
 550       }
 551
 552       if (crypto_sign_add_signer(sig, signing_digest, jcr->pki_keypair) == false) {
 553          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 554          goto bail_out;
 555       }
 556
 557       /* Get signature size */
 558       if (crypto_sign_encode(sig, NULL, &size) == false) {
 559          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 560          goto bail_out;
 561       }
 562
 563       /* Allocate signature data buffer */
 564       buf = (uint8_t *)malloc(size);
 565       if (!buf) {
 566          goto bail_out;
 567       }
 568
 569       /* Encode signature data */
 570       if (crypto_sign_encode(sig, buf, &size) == false) {
 571          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 572          goto bail_out;
 573       }
 574
 575       /* Send our header */
 576       bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
 577       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 578
 579       /* Grow the bsock buffer to fit our message if necessary */
 580       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 581          sd->msg = realloc_pool_memory(sd->msg, size);
 582       }
 583
 584       /* Copy our message over and send it */
 585       memcpy(sd->msg, buf, size);
 586       sd->msglen = size;
 587       bnet_send(sd);
 588       bnet_sig(sd, BNET_EOD);              /* end of checksum */
 589       goto good_rtn;
 590    }
 591
 592    /* Terminate any digest and send it to Storage daemon and the Director */
 593    if (digest) {
 594       uint8_t md[CRYPTO_DIGEST_MAX_SIZE];
 595       uint32_t size;
 596
 597       size = sizeof(md);
 598
 599       if (crypto_digest_finalize(digest, md, &size)) {
 600          bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, digest_stream);
 601          Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 602          memcpy(sd->msg, md, size);
 603          sd->msglen = size;
 604          bnet_send(sd);
 605          bnet_sig(sd, BNET_EOD);              /* end of checksum */
 606       }
 607    }
 608
 609 good_rtn:
 610    rtnstat = 1;                       /* good return */
 611
 612 bail_out:
 613    if (digest) {
 614       crypto_digest_free(digest);
 615    }
 616    if (signing_digest) {
 617       crypto_digest_free(signing_digest);
 618    }
 619    if (sig) {
 620       crypto_sign_free(sig);
 621    }
 622    if (buf) {
 623       free(buf);
 624    }
 625    return rtnstat;
 626 }
 627
 628 /*
 629  * Send data read from an already open file descriptor.
 630  *
 631  * We return 1 on sucess and 0 on errors.
 632  *
 633  * ***FIXME***
 634  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 635  *  reading.
 636  * Currently this is not a problem as the only other stream, resource forks,
 637  * are not handled as sparse files.
 638  */
 639 int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 640               DIGEST *signing_digest)
 641 {
 642    BSOCK *sd = jcr->store_bsock;
 643    uint64_t fileAddr = 0;             /* file address */
 644    char *rbuf, *wbuf;
 645    int32_t rsize = jcr->buf_size;      /* read buffer size */
 646    POOLMEM *msgsave;
 647    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 648    const uint8_t *cipher_input;
 649    uint32_t cipher_input_len;
 650    uint32_t cipher_block_size;
 651    uint32_t encrypted_len;
 652 #ifdef FD_NO_SEND_TEST
 653    return 1;
 654 #endif
 655
 656    msgsave = sd->msg;
 657    rbuf = sd->msg;                    /* read buffer */
 658    wbuf = sd->msg;                    /* write buffer */
 659    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 660
 661    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 662
 663 #ifdef HAVE_LIBZ
 664    uLong compress_len = 0;
 665    uLong max_compress_len = 0;
 666    const Bytef *cbuf = NULL;
 667    int zstat;
 668
 669    if (ff_pkt->flags & FO_GZIP) {
 670       if (ff_pkt->flags & FO_SPARSE) {
 671          cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
 672          max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
 673       } else {
 674          cbuf = (Bytef *)jcr->compress_buf;
 675          max_compress_len = jcr->compress_buf_size; /* set max length */
 676       }
 677       wbuf = jcr->compress_buf;    /* compressed output here */
 678       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 679
 680       /*
 681        * Only change zlib parameters if there is no pending operation.
 682        * This should never happen as deflatereset is called after each
 683        * deflate.
 684        */
 685
 686       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 687          /* set gzip compression level - must be done per file */
 688          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 689               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 690             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 691             set_jcr_job_status(jcr, JS_ErrorTerminated);
 692             goto err;
 693          }
 694       }
 695    }
 696 #else
 697    const uint32_t max_compress_len = 0;
 698 #endif
 699
 700    if (ff_pkt->flags & FO_ENCRYPT) {
 701       if (ff_pkt->flags & FO_SPARSE) {
 702          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse data not supported.\n"));
 703          goto err;
 704       }
 705       /* Allocate the cipher context */
 706       if ((cipher_ctx = crypto_cipher_new(jcr->pki_session, true,
 707            &cipher_block_size)) == NULL) {
 708          /* Shouldn't happen! */
 709          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 710          goto err;
 711       }
 712
 713       /*
 714        * Grow the crypto buffer, if necessary.
 715        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 716        * We grow crypto_buf to the maximum number of blocks that
 717        * could be returned for the given read buffer size.
 718        * (Using the larger of either rsize or max_compress_len)
 719        */
 720       jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf,
 721            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 722             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 723
 724       wbuf = jcr->crypto_buf; /* Encrypted, possibly compressed output here. */
 725    }
 726
 727    /*
 728     * Send Data header to Storage daemon
 729     *    <file-index> <stream> <info>
 730     */
 731    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 732       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 733             bnet_strerror(sd));
 734       goto err;
 735    }
 736    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 737
 738    /*
 739     * Make space at beginning of buffer for fileAddr because this
 740     *   same buffer will be used for writing if compression is off.
 741     */
 742    if (ff_pkt->flags & FO_SPARSE) {
 743       rbuf += SPARSE_FADDR_SIZE;
 744       rsize -= SPARSE_FADDR_SIZE;
 745 #ifdef HAVE_FREEBSD_OS
 746       /*
 747        * To read FreeBSD partitions, the read size must be
 748        *  a multiple of 512.
 749        */
 750       rsize = (rsize/512) * 512;
 751 #endif
 752    }
 753
 754    /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
 755 #ifdef HAVE_WIN32
 756    if (S_ISBLK(ff_pkt->statp.st_mode))
 757       rsize = (rsize/512) * 512;
 758 #endif
 759
 760    /*
 761     * Read the file data
 762     */
 763    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 764
 765       /* Check for sparse blocks */
 766       if (ff_pkt->flags & FO_SPARSE) {
 767          ser_declare;
 768          bool haveBlock = true;
 769          if (sd->msglen == rsize &&
 770              fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
 771              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 772                (uint64_t)ff_pkt->statp.st_size == 0)) {
 773             haveBlock = !is_buf_zero(rbuf, rsize);
 774          }
 775          if (haveBlock) {
 776             ser_begin(wbuf, SPARSE_FADDR_SIZE);
 777             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 778          }
 779          fileAddr += sd->msglen;      /* update file address */
 780          if (!haveBlock) {
 781             continue;                 /* skip block of zeros */
 782          }
 783       }
 784
 785       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 786
 787       /* Uncompressed cipher input length */
 788       cipher_input_len = sd->msglen;
 789
 790       /* Update checksum if requested */
 791       if (digest) {
 792          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 793       }
 794
 795       /* Update signing digest if requested */
 796       if (signing_digest) {
 797          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 798       }
 799
 800 #ifdef HAVE_LIBZ
 801       /* Do compression if turned on */
 802       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 803          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 804
 805          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 806                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 807          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 808                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 809
 810          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 811             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 812             set_jcr_job_status(jcr, JS_ErrorTerminated);
 813             goto err;
 814          }
 815          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 816          /* reset zlib stream to be able to begin from scratch again */
 817          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 818             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 819             set_jcr_job_status(jcr, JS_ErrorTerminated);
 820             goto err;
 821          }
 822
 823          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 824                sd->msglen);
 825
 826          sd->msglen = compress_len;      /* set compressed length */
 827          cipher_input_len = compress_len;
 828       }
 829 #endif
 830       /*
 831        * Note, here we prepend the current record length to the beginning
 832        *  of the encrypted data. This is because both sparse and compression
 833        *  restore handling want records returned to them with exactly the
 834        *  same number of bytes that were processed in the backup handling.
 835        *  That is, both are block filters rather than a stream.  When doing
 836        *  compression, the compression routines may buffer data, so that for
 837        *  any one record compressed, when it is decompressed the same size
 838        *  will not be obtained. Of course, the buffered data eventually comes
 839        *  out in subsequent crypto_cipher_update() calls or at least
 840        *  when crypto_cipher_finalize() is called.  Unfortunately, this
 841        *  "feature" of encryption enormously complicates the restore code.
 842        */
 843       if (ff_pkt->flags & FO_ENCRYPT) {
 844          uint32_t initial_len = 0;
 845          ser_declare;
 846
 847          if (ff_pkt->flags & FO_SPARSE) {
 848             cipher_input_len += SPARSE_FADDR_SIZE;
 849          }
 850
 851          /* Encrypt the length of the input block */
 852          uint8_t packet_len[sizeof(uint32_t)];
 853
 854          ser_begin(packet_len, sizeof(uint32_t));
 855          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
 856          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
 857
 858          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
 859              (u_int8_t *)jcr->crypto_buf, &initial_len)) {
 860             /* Encryption failed. Shouldn't happen. */
 861             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 862             goto err;
 863          }
 864
 865          /* Encrypt the input block */
 866          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
 867              (u_int8_t *)&jcr->crypto_buf[initial_len], &encrypted_len)) {
 868             if ((initial_len + encrypted_len) == 0) {
 869                /* No full block of data available, read more data */
 870                continue;
 871             }
 872             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
 873                   sd->msglen);
 874             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
 875          } else {
 876             /* Encryption failed. Shouldn't happen. */
 877             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 878             goto err;
 879          }
 880       }
 881
 882       /* Send the buffer to the Storage daemon */
 883       if (ff_pkt->flags & FO_SPARSE) {
 884          sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 885       }
 886       sd->msg = wbuf;              /* set correct write buffer */
 887       if (!bnet_send(sd)) {
 888          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 889                bnet_strerror(sd));
 890          goto err;
 891       }
 892       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 893       /*          #endif */
 894       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 895       sd->msg = msgsave;                /* restore read buffer */
 896
 897    } /* end while read file data */
 898
 899    if (sd->msglen < 0) {                 /* error */
 900       berrno be;
 901       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 902          ff_pkt->fname, be.strerror(ff_pkt->bfd.berrno));
 903       if (jcr->Errors++ > 1000) {       /* insanity check */
 904          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
 905       }
 906    } else if (ff_pkt->flags & FO_ENCRYPT) {
 907       /*
 908        * For encryption, we must call finalize to push out any
 909        *  buffered data.
 910        */
 911       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto_buf,
 912            &encrypted_len)) {
 913          /* Padding failed. Shouldn't happen. */
 914          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
 915          goto err;
 916       }
 917
 918       /* Note, on SSL pre-0.9.7, there is always some output */
 919       if (encrypted_len > 0) {
 920          sd->msglen = encrypted_len;      /* set encrypted length */
 921          sd->msg = jcr->crypto_buf;       /* set correct write buffer */
 922          if (!bnet_send(sd)) {
 923             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 924                   bnet_strerror(sd));
 925             goto err;
 926          }
 927          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 928          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
 929          sd->msg = msgsave;               /* restore bnet buffer */
 930       }
 931    }
 932
 933    if (!bnet_sig(sd, BNET_EOD)) {        /* indicate end of file data */
 934       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 935             bnet_strerror(sd));
 936       goto err;
 937    }
 938
 939    /* Free the cipher context */
 940    if (cipher_ctx) {
 941       crypto_cipher_free(cipher_ctx);
 942    }
 943    return 1;
 944
 945 err:
 946    /* Free the cipher context */
 947    if (cipher_ctx) {
 948       crypto_cipher_free(cipher_ctx);
 949    }
 950
 951    sd->msg = msgsave; /* restore bnet buffer */
 952    sd->msglen = 0;
 953    return 0;
 954 }
 955
 956 /*
 957  * Read and send an ACL for the last encountered file.
 958  */
 959 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
 960 {
 961 #ifdef HAVE_ACL
 962    BSOCK *sd = jcr->store_bsock;
 963    POOLMEM *msgsave;
 964    int len;
 965 #ifdef FD_NO_SEND_TEST
 966    return true;
 967 #endif
 968
 969    len = bacl_get(jcr, acltype);
 970    if (len < 0) {
 971       Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
 972       return true;
 973    }
 974    if (len == 0) {
 975       return true;                    /* no ACL */
 976    }
 977
 978    /* Send header */
 979    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 980       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 981             bnet_strerror(sd));
 982       return false;
 983    }
 984
 985    /* Send the buffer to the storage deamon */
 986    Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
 987    msgsave = sd->msg;
 988    sd->msg = jcr->acl_text;
 989    sd->msglen = len + 1;
 990    if (!bnet_send(sd)) {
 991       sd->msg = msgsave;
 992       sd->msglen = 0;
 993       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 994             bnet_strerror(sd));
 995       return false;
 996    }
 997
 998    jcr->JobBytes += sd->msglen;
 999    sd->msg = msgsave;
1000    if (!bnet_sig(sd, BNET_EOD)) {
1001       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1002             bnet_strerror(sd));
1003       return false;
1004    }
1005
1006    Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
1007 #endif
1008    return true;
1009 }
1010
1011 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1012 {
1013    BSOCK *sd = jcr->store_bsock;
1014    char attribs[MAXSTRING];
1015    char attribsEx[MAXSTRING];
1016    int attr_stream;
1017    int stat;
1018 #ifdef FD_NO_SEND_TEST
1019    return true;
1020 #endif
1021
1022    /* Find what data stream we will use, then encode the attributes */
1023    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1024       /* This should not happen */
1025       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1026       return false;
1027    }
1028    encode_stat(attribs, ff_pkt, data_stream);
1029
1030    /* Now possibly extend the attributes */
1031    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1032
1033    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1034
1035    jcr->lock();
1036    jcr->JobFiles++;                    /* increment number of files sent */
1037    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1038    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1039    jcr->unlock();
1040
1041    /*
1042     * Send Attributes header to Storage daemon
1043     *    <file-index> <stream> <info>
1044     */
1045    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, attr_stream)) {
1046       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1047             bnet_strerror(sd));
1048       return false;
1049    }
1050    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1051
1052    /*
1053     * Send file attributes to Storage daemon
1054     *   File_index
1055     *   File type
1056     *   Filename (full path)
1057     *   Encoded attributes
1058     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1059     *   Encoded extended-attributes (for Win32)
1060     *
1061     * For a directory, link is the same as fname, but with trailing
1062     * slash. For a linked file, link is the link.
1063     */
1064    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
1065       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1066       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
1067                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
1068                attribsEx, 0);
1069    } else if (ff_pkt->type == FT_DIREND) {
1070       /* Here link is the canonical filename (i.e. with trailing slash) */
1071       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1072                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
1073    } else {
1074       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1075                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
1076    }
1077
1078    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1079    if (!stat) {
1080       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1081             bnet_strerror(sd));
1082       return false;
1083    }
1084    bnet_sig(sd, BNET_EOD);            /* indicate end of attributes data */
1085    return true;
1086 }