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    int stat, data_stream;
 215    int rtnstat = 0;
 216    DIGEST *digest = NULL;
 217    DIGEST *signing_digest = NULL;
 218    int digest_stream = STREAM_NONE;
 219    SIGNATURE *sig = NULL;
 220    uint8_t *buf = NULL;
 221    bool has_file_data = false;
 222    // TODO landonf: Allow the user to specify the digest algorithm
 223 #ifdef HAVE_SHA2
 224    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA256;
 225 #else
 226    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA1;
 227 #endif
 228    JCR *jcr = (JCR *)vjcr;
 229    BSOCK *sd = jcr->store_bsock;
 230
 231    if (job_canceled(jcr)) {
 232       return 0;
 233    }
 234
 235    jcr->num_files_examined++;         /* bump total file count */
 236
 237    switch (ff_pkt->type) {
 238    case FT_LNKSAVED:                  /* Hard linked, file already saved */
 239       Dmsg2(130, "FT_LNKSAVED hard link: %s => %s\n", ff_pkt->fname, ff_pkt->link);
 240       break;
 241    case FT_REGE:
 242       Dmsg1(130, "FT_REGE saving: %s\n", ff_pkt->fname);
 243       has_file_data = true;
 244       break;
 245    case FT_REG:
 246       Dmsg1(130, "FT_REG saving: %s\n", ff_pkt->fname);
 247       has_file_data = true;
 248       break;
 249    case FT_LNK:
 250       Dmsg2(130, "FT_LNK saving: %s -> %s\n", ff_pkt->fname, ff_pkt->link);
 251       break;
 252    case FT_DIRBEGIN:
 253       jcr->num_files_examined--;      /* correct file count */
 254       return 1;                       /* not used */
 255    case FT_NORECURSE:
 256       Jmsg(jcr, M_INFO, 1, _("     Recursion turned off. Will not descend from %s into %s\n"),
 257            ff_pkt->top_fname, ff_pkt->fname);
 258       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 259       break;
 260    case FT_NOFSCHG:
 261       /* Suppress message for /dev filesystems */
 262       if (strncmp(ff_pkt->fname, "/dev/", 5) != 0) {
 263          Jmsg(jcr, M_INFO, 1, _("     %s is a different filesystem. Will not descend from %s into %s\n"),
 264               ff_pkt->fname, ff_pkt->top_fname, ff_pkt->fname);
 265       }
 266       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 267       break;
 268    case FT_INVALIDFS:
 269       Jmsg(jcr, M_INFO, 1, _("     Disallowed filesystem. Will not descend from %s into %s\n"),
 270            ff_pkt->top_fname, ff_pkt->fname);
 271       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 272       break;
 273    case FT_INVALIDDT:
 274       Jmsg(jcr, M_INFO, 1, _("     Disallowed drive type. Will not descend into %s\n"),
 275            ff_pkt->fname);
 276       break;
 277    case FT_DIREND:
 278       Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
 279       break;
 280    case FT_SPEC:
 281       Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
 282       break;
 283    case FT_RAW:
 284       Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
 285       has_file_data = true;
 286       break;
 287    case FT_FIFO:
 288       Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
 289       break;
 290    case FT_NOACCESS: {
 291       berrno be;
 292       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not access %s: ERR=%s\n"), ff_pkt->fname,
 293          be.strerror(ff_pkt->ff_errno));
 294       jcr->Errors++;
 295       return 1;
 296    }
 297    case FT_NOFOLLOW: {
 298       berrno be;
 299       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not follow link %s: ERR=%s\n"), ff_pkt->fname,
 300          be.strerror(ff_pkt->ff_errno));
 301       jcr->Errors++;
 302       return 1;
 303    }
 304    case FT_NOSTAT: {
 305       berrno be;
 306       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not stat %s: ERR=%s\n"), ff_pkt->fname,
 307          be.strerror(ff_pkt->ff_errno));
 308       jcr->Errors++;
 309       return 1;
 310    }
 311    case FT_DIRNOCHG:
 312    case FT_NOCHG:
 313       Jmsg(jcr, M_SKIPPED, 1, _("     Unchanged file skipped: %s\n"), ff_pkt->fname);
 314       return 1;
 315    case FT_ISARCH:
 316       Jmsg(jcr, M_NOTSAVED, 0, _("     Archive file not saved: %s\n"), ff_pkt->fname);
 317       return 1;
 318    case FT_NOOPEN: {
 319       berrno be;
 320       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not open directory %s: ERR=%s\n"), ff_pkt->fname,
 321          be.strerror(ff_pkt->ff_errno));
 322       jcr->Errors++;
 323       return 1;
 324    }
 325    default:
 326       Jmsg(jcr, M_NOTSAVED, 0,  _("     Unknown file type %d; not saved: %s\n"), ff_pkt->type, ff_pkt->fname);
 327       jcr->Errors++;
 328       return 1;
 329    }
 330
 331    Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
 332
 333    /* Digests and encryption are only useful if there's file data */
 334    if (has_file_data) {
 335       /*
 336        * Setup for digest handling. If this fails, the digest will be set to NULL
 337        * and not used.
 338        */
 339       if (ff_pkt->flags & FO_MD5) {
 340          digest = crypto_digest_new(CRYPTO_DIGEST_MD5);
 341          digest_stream = STREAM_MD5_DIGEST;
 342
 343       } else if (ff_pkt->flags & FO_SHA1) {
 344          digest = crypto_digest_new(CRYPTO_DIGEST_SHA1);
 345          digest_stream = STREAM_SHA1_DIGEST;
 346
 347       } else if (ff_pkt->flags & FO_SHA256) {
 348          digest = crypto_digest_new(CRYPTO_DIGEST_SHA256);
 349          digest_stream = STREAM_SHA256_DIGEST;
 350
 351       } else if (ff_pkt->flags & FO_SHA512) {
 352          digest = crypto_digest_new(CRYPTO_DIGEST_SHA512);
 353          digest_stream = STREAM_SHA512_DIGEST;
 354       }
 355
 356       /* Did digest initialization fail? */
 357       if (digest_stream != STREAM_NONE && digest == NULL) {
 358          Jmsg(jcr, M_WARNING, 0, _("%s digest initialization failed\n"),
 359             stream_to_ascii(digest_stream));
 360       }
 361
 362       /*
 363        * Set up signature digest handling. If this fails, the signature digest will be set to
 364        * NULL and not used.
 365        */
 366       // TODO landonf: We should really only calculate the digest once, for both verification and signing.
 367       if (jcr->pki_sign) {
 368          signing_digest = crypto_digest_new(signing_algorithm);
 369
 370          /* Full-stop if a failure occurred initializing the signature digest */
 371          if (signing_digest == NULL) {
 372             Jmsg(jcr, M_NOTSAVED, 0, _("%s signature digest initialization failed\n"),
 373                stream_to_ascii(signing_algorithm));
 374             jcr->Errors++;
 375             goto good_rtn;
 376          }
 377       }
 378
 379       /* Enable encryption */
 380       if (jcr->pki_encrypt) {
 381          ff_pkt->flags |= FO_ENCRYPT;
 382       }
 383    }
 384
 385    /* Initialise the file descriptor we use for data and other streams. */
 386    binit(&ff_pkt->bfd);
 387    if (ff_pkt->flags & FO_PORTABLE) {
 388       set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
 389    }
 390    if (ff_pkt->reader) {
 391       if (!set_prog(&ff_pkt->bfd, ff_pkt->reader, jcr)) {
 392          Jmsg(jcr, M_FATAL, 0, _("Python reader program \"%s\" not found.\n"),
 393             ff_pkt->reader);
 394          goto bail_out;
 395       }
 396    }
 397
 398    /* Send attributes -- must be done after binit() */
 399    if (!encode_and_send_attributes(jcr, ff_pkt, data_stream)) {
 400       goto bail_out;
 401    }
 402
 403    /*
 404     * Open any file with data that we intend to save, then save it.
 405     *
 406     * Note, if is_win32_backup, we must open the Directory so that
 407     * the BackupRead will save its permissions and ownership streams.
 408     */
 409    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 410          ff_pkt->statp.st_size > 0) ||
 411          ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
 412          (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
 413       btimer_t *tid;
 414       if (ff_pkt->type == FT_FIFO) {
 415          tid = start_thread_timer(pthread_self(), 60);
 416       } else {
 417          tid = NULL;
 418       }
 419       int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
 420       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
 421          ff_pkt->ff_errno = errno;
 422          berrno be;
 423          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open %s: ERR=%s.\n"), ff_pkt->fname,
 424               be.strerror());
 425          jcr->Errors++;
 426          if (tid) {
 427             stop_thread_timer(tid);
 428             tid = NULL;
 429          }
 430          goto good_rtn;
 431       }
 432       if (tid) {
 433          stop_thread_timer(tid);
 434          tid = NULL;
 435       }
 436
 437       /* Set up the encryption context, send the session data to the SD */
 438       if (jcr->pki_encrypt) {
 439          /* Send our header */
 440          Dmsg2(100, "Send hdr fi=%ld stream=%d\n", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 441          bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 442
 443          /* Grow the bsock buffer to fit our message if necessary */
 444          if (sizeof_pool_memory(sd->msg) < jcr->pki_session_encoded_size) {
 445             sd->msg = realloc_pool_memory(sd->msg, jcr->pki_session_encoded_size);
 446          }
 447
 448          /* Copy our message over and send it */
 449          memcpy(sd->msg, jcr->pki_session_encoded, jcr->pki_session_encoded_size);
 450          sd->msglen = jcr->pki_session_encoded_size;
 451          jcr->JobBytes += sd->msglen;
 452
 453          Dmsg1(100, "Send data len=%d\n", sd->msglen);
 454          bnet_send(sd);
 455          bnet_sig(sd, BNET_EOD);
 456       }
 457
 458       stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
 459       bclose(&ff_pkt->bfd);
 460       if (!stat) {
 461          goto bail_out;
 462       }
 463    }
 464
 465 #ifdef HAVE_DARWIN_OS
 466    /* Regular files can have resource forks and Finder Info */
 467    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 468             ff_pkt->flags & FO_HFSPLUS)) {
 469       if (ff_pkt->hfsinfo.rsrclength > 0) {
 470          int flags;
 471          int rsrc_stream;
 472          if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 473             ff_pkt->ff_errno = errno;
 474             berrno be;
 475             Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for %s: ERR=%s.\n"), ff_pkt->fname,
 476                   be.strerror());
 477             jcr->Errors++;
 478             if (is_bopen(&ff_pkt->bfd)) {
 479                bclose(&ff_pkt->bfd);
 480             }
 481             goto good_rtn;
 482          }
 483          flags = ff_pkt->flags;
 484          ff_pkt->flags &= ~(FO_GZIP|FO_SPARSE);
 485          if (flags & FO_ENCRYPT) {
 486             rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
 487          } else {
 488             rsrc_stream = STREAM_MACOS_FORK_DATA;
 489          }
 490          stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
 491          ff_pkt->flags = flags;
 492          bclose(&ff_pkt->bfd);
 493          if (!stat) {
 494             goto bail_out;
 495          }
 496       }
 497
 498       Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
 499       bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 500       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 501       memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 502       sd->msglen = 32;
 503       if (digest) {
 504          crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
 505       }
 506       if (signing_digest) {
 507          crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
 508       }
 509       bnet_send(sd);
 510       bnet_sig(sd, BNET_EOD);
 511    }
 512 #endif
 513
 514    if (ff_pkt->flags & FO_ACL) {
 515       /* Read access ACLs for files, dirs and links */
 516       if (!read_and_send_acl(jcr, BACL_TYPE_ACCESS, STREAM_UNIX_ATTRIBUTES_ACCESS_ACL)) {
 517          goto bail_out;
 518       }
 519       /* Directories can have default ACLs too */
 520       if (ff_pkt->type == FT_DIREND && (BACL_CAP & BACL_CAP_DEFAULTS_DIR)) {
 521          if (!read_and_send_acl(jcr, BACL_TYPE_DEFAULT, STREAM_UNIX_ATTRIBUTES_DEFAULT_ACL)) {
 522             goto bail_out;
 523          }
 524       }
 525    }
 526
 527    /* Terminate the signing digest and send it to the Storage daemon */
 528    if (signing_digest) {
 529       uint32_t size = 0;
 530
 531       if ((sig = crypto_sign_new()) == NULL) {
 532          Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for stream signature.\n"));
 533          goto bail_out;
 534       }
 535
 536       if (crypto_sign_add_signer(sig, signing_digest, jcr->pki_keypair) == false) {
 537          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 538          goto bail_out;
 539       }
 540
 541       /* Get signature size */
 542       if (crypto_sign_encode(sig, NULL, &size) == false) {
 543          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 544          goto bail_out;
 545       }
 546
 547       /* Allocate signature data buffer */
 548       buf = (uint8_t *)malloc(size);
 549       if (!buf) {
 550          goto bail_out;
 551       }
 552
 553       /* Encode signature data */
 554       if (crypto_sign_encode(sig, buf, &size) == false) {
 555          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 556          goto bail_out;
 557       }
 558
 559       /* Send our header */
 560       bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
 561       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 562
 563       /* Grow the bsock buffer to fit our message if necessary */
 564       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 565          sd->msg = realloc_pool_memory(sd->msg, size);
 566       }
 567
 568       /* Copy our message over and send it */
 569       memcpy(sd->msg, buf, size);
 570       sd->msglen = size;
 571       bnet_send(sd);
 572       bnet_sig(sd, BNET_EOD);              /* end of checksum */
 573       goto good_rtn;
 574    }
 575
 576    /* Terminate any digest and send it to Storage daemon and the Director */
 577    if (digest) {
 578       uint8_t md[CRYPTO_DIGEST_MAX_SIZE];
 579       uint32_t size;
 580
 581       size = sizeof(md);
 582
 583       if (crypto_digest_finalize(digest, md, &size)) {
 584          bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, digest_stream);
 585          Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 586          memcpy(sd->msg, md, size);
 587          sd->msglen = size;
 588          bnet_send(sd);
 589          bnet_sig(sd, BNET_EOD);              /* end of checksum */
 590       }
 591    }
 592
 593 good_rtn:
 594    rtnstat = 1;                       /* good return */
 595
 596 bail_out:
 597    if (digest) {
 598       crypto_digest_free(digest);
 599    }
 600    if (signing_digest) {
 601       crypto_digest_free(signing_digest);
 602    }
 603    if (sig) {
 604       crypto_sign_free(sig);
 605    }
 606    if (buf) {
 607       free(buf);
 608    }
 609    return rtnstat;
 610 }
 611
 612 /*
 613  * Send data read from an already open file descriptor.
 614  *
 615  * We return 1 on sucess and 0 on errors.
 616  *
 617  * ***FIXME***
 618  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 619  *  reading.
 620  * Currently this is not a problem as the only other stream, resource forks,
 621  * are not handled as sparse files.
 622  */
 623 int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 624               DIGEST *signing_digest)
 625 {
 626    BSOCK *sd = jcr->store_bsock;
 627    uint64_t fileAddr = 0;             /* file address */
 628    char *rbuf, *wbuf;
 629    int32_t rsize = jcr->buf_size;      /* read buffer size */
 630    POOLMEM *msgsave;
 631    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 632    const uint8_t *cipher_input;
 633    uint32_t cipher_input_len;
 634    uint32_t cipher_block_size;
 635    uint32_t encrypted_len;
 636 #ifdef FD_NO_SEND_TEST
 637    return 1;
 638 #endif
 639
 640    msgsave = sd->msg;
 641    rbuf = sd->msg;                    /* read buffer */
 642    wbuf = sd->msg;                    /* write buffer */
 643    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 644
 645    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 646
 647 #ifdef HAVE_LIBZ
 648    uLong compress_len = 0;
 649    uLong max_compress_len = 0;
 650    const Bytef *cbuf = NULL;
 651    int zstat;
 652
 653    if (ff_pkt->flags & FO_GZIP) {
 654       if (ff_pkt->flags & FO_SPARSE) {
 655          cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
 656          max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
 657       } else {
 658          cbuf = (Bytef *)jcr->compress_buf;
 659          max_compress_len = jcr->compress_buf_size; /* set max length */
 660       }
 661       wbuf = jcr->compress_buf;    /* compressed output here */
 662       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 663
 664       /*
 665        * Only change zlib parameters if there is no pending operation.
 666        * This should never happen as deflatereset is called after each
 667        * deflate.
 668        */
 669
 670       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 671          /* set gzip compression level - must be done per file */
 672          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 673               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 674             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 675             set_jcr_job_status(jcr, JS_ErrorTerminated);
 676             goto err;
 677          }
 678       }
 679    }
 680 #else
 681    const uint32_t max_compress_len = 0;
 682 #endif
 683
 684    if (ff_pkt->flags & FO_ENCRYPT) {
 685       if (ff_pkt->flags & FO_SPARSE) {
 686          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse data not supported.\n"));
 687          goto err;
 688       }
 689       /* Allocate the cipher context */
 690       if ((cipher_ctx = crypto_cipher_new(jcr->pki_session, true,
 691            &cipher_block_size)) == NULL) {
 692          /* Shouldn't happen! */
 693          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 694          goto err;
 695       }
 696
 697       /*
 698        * Grow the crypto buffer, if necessary.
 699        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 700        * We grow crypto_buf to the maximum number of blocks that
 701        * could be returned for the given read buffer size.
 702        * (Using the larger of either rsize or max_compress_len)
 703        */
 704       jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf,
 705            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 706             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 707
 708       wbuf = jcr->crypto_buf; /* Encrypted, possibly compressed output here. */
 709    }
 710
 711    /*
 712     * Send Data header to Storage daemon
 713     *    <file-index> <stream> <info>
 714     */
 715    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 716       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 717             bnet_strerror(sd));
 718       goto err;
 719    }
 720    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 721
 722    /*
 723     * Make space at beginning of buffer for fileAddr because this
 724     *   same buffer will be used for writing if compression is off.
 725     */
 726    if (ff_pkt->flags & FO_SPARSE) {
 727       rbuf += SPARSE_FADDR_SIZE;
 728       rsize -= SPARSE_FADDR_SIZE;
 729 #ifdef HAVE_FREEBSD_OS
 730       /*
 731        * To read FreeBSD partitions, the read size must be
 732        *  a multiple of 512.
 733        */
 734       rsize = (rsize/512) * 512;
 735 #endif
 736    }
 737
 738    /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
 739 #ifdef HAVE_WIN32
 740    if (S_ISBLK(ff_pkt->statp.st_mode))
 741       rsize = (rsize/512) * 512;
 742 #endif
 743
 744    /*
 745     * Read the file data
 746     */
 747    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 748
 749       /* Check for sparse blocks */
 750       if (ff_pkt->flags & FO_SPARSE) {
 751          ser_declare;
 752          bool haveBlock = true;
 753          if (sd->msglen == rsize &&
 754              fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
 755              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 756                (uint64_t)ff_pkt->statp.st_size == 0)) {
 757             haveBlock = !is_buf_zero(rbuf, rsize);
 758          }
 759          if (haveBlock) {
 760             ser_begin(wbuf, SPARSE_FADDR_SIZE);
 761             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 762          }
 763          fileAddr += sd->msglen;      /* update file address */
 764          if (!haveBlock) {
 765             continue;                 /* skip block of zeros */
 766          }
 767       }
 768
 769       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 770
 771       /* Uncompressed cipher input length */
 772       cipher_input_len = sd->msglen;
 773
 774       /* Update checksum if requested */
 775       if (digest) {
 776          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 777       }
 778
 779       /* Update signing digest if requested */
 780       if (signing_digest) {
 781          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 782       }
 783
 784 #ifdef HAVE_LIBZ
 785       /* Do compression if turned on */
 786       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 787          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 788
 789          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 790                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 791          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 792                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 793
 794          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 795             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 796             set_jcr_job_status(jcr, JS_ErrorTerminated);
 797             goto err;
 798          }
 799          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 800          /* reset zlib stream to be able to begin from scratch again */
 801          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 802             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 803             set_jcr_job_status(jcr, JS_ErrorTerminated);
 804             goto err;
 805          }
 806
 807          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 808                sd->msglen);
 809
 810          sd->msglen = compress_len;      /* set compressed length */
 811          cipher_input_len = compress_len;
 812       }
 813 #endif
 814       /*
 815        * Note, here we prepend the current record length to the beginning
 816        *  of the encrypted data. This is because both sparse and compression
 817        *  restore handling want records returned to them with exactly the
 818        *  same number of bytes that were processed in the backup handling.
 819        *  That is, both are block filters rather than a stream.  When doing
 820        *  compression, the compression routines may buffer data, so that for
 821        *  any one record compressed, when it is decompressed the same size
 822        *  will not be obtained. Of course, the buffered data eventually comes
 823        *  out in subsequent crypto_cipher_update() calls or at least
 824        *  when crypto_cipher_finalize() is called.  Unfortunately, this
 825        *  "feature" of encryption enormously complicates the restore code.
 826        */
 827       if (ff_pkt->flags & FO_ENCRYPT) {
 828          uint32_t initial_len = 0;
 829          ser_declare;
 830
 831          if (ff_pkt->flags & FO_SPARSE) {
 832             cipher_input_len += SPARSE_FADDR_SIZE;
 833          }
 834
 835          /* Encrypt the length of the input block */
 836          uint8_t packet_len[sizeof(uint32_t)];
 837
 838          ser_begin(packet_len, sizeof(uint32_t));
 839          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
 840          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
 841
 842          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
 843              (u_int8_t *)jcr->crypto_buf, &initial_len)) {
 844             /* Encryption failed. Shouldn't happen. */
 845             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 846             goto err;
 847          }
 848
 849          /* Encrypt the input block */
 850          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
 851              (u_int8_t *)&jcr->crypto_buf[initial_len], &encrypted_len)) {
 852             if ((initial_len + encrypted_len) == 0) {
 853                /* No full block of data available, read more data */
 854                continue;
 855             }
 856             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
 857                   sd->msglen);
 858             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
 859          } else {
 860             /* Encryption failed. Shouldn't happen. */
 861             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 862             goto err;
 863          }
 864       }
 865
 866       /* Send the buffer to the Storage daemon */
 867       if (ff_pkt->flags & FO_SPARSE) {
 868          sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 869       }
 870       sd->msg = wbuf;              /* set correct write buffer */
 871       if (!bnet_send(sd)) {
 872          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 873                bnet_strerror(sd));
 874          goto err;
 875       }
 876       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 877       /*          #endif */
 878       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 879       sd->msg = msgsave;                /* restore read buffer */
 880
 881    } /* end while read file data */
 882
 883    if (sd->msglen < 0) {                 /* error */
 884       berrno be;
 885       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 886          ff_pkt->fname, be.strerror(ff_pkt->bfd.berrno));
 887       if (jcr->Errors++ > 1000) {       /* insanity check */
 888          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
 889       }
 890    } else if (ff_pkt->flags & FO_ENCRYPT) {
 891       /*
 892        * For encryption, we must call finalize to push out any
 893        *  buffered data.
 894        */
 895       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto_buf,
 896            &encrypted_len)) {
 897          /* Padding failed. Shouldn't happen. */
 898          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
 899          goto err;
 900       }
 901
 902       /* Note, on SSL pre-0.9.7, there is always some output */
 903       if (encrypted_len > 0) {
 904          sd->msglen = encrypted_len;      /* set encrypted length */
 905          sd->msg = jcr->crypto_buf;       /* set correct write buffer */
 906          if (!bnet_send(sd)) {
 907             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 908                   bnet_strerror(sd));
 909             goto err;
 910          }
 911          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 912          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
 913          sd->msg = msgsave;               /* restore bnet buffer */
 914       }
 915    }
 916
 917    if (!bnet_sig(sd, BNET_EOD)) {        /* indicate end of file data */
 918       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 919             bnet_strerror(sd));
 920       goto err;
 921    }
 922
 923    /* Free the cipher context */
 924    if (cipher_ctx) {
 925       crypto_cipher_free(cipher_ctx);
 926    }
 927    return 1;
 928
 929 err:
 930    /* Free the cipher context */
 931    if (cipher_ctx) {
 932       crypto_cipher_free(cipher_ctx);
 933    }
 934
 935    sd->msg = msgsave; /* restore bnet buffer */
 936    sd->msglen = 0;
 937    return 0;
 938 }
 939
 940 /*
 941  * Read and send an ACL for the last encountered file.
 942  */
 943 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
 944 {
 945 #ifdef HAVE_ACL
 946    BSOCK *sd = jcr->store_bsock;
 947    POOLMEM *msgsave;
 948    int len;
 949 #ifdef FD_NO_SEND_TEST
 950    return true;
 951 #endif
 952
 953    len = bacl_get(jcr, acltype);
 954    if (len < 0) {
 955       Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
 956       return true;
 957    }
 958    if (len == 0) {
 959       return true;                    /* no ACL */
 960    }
 961
 962    /* Send header */
 963    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 964       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 965             bnet_strerror(sd));
 966       return false;
 967    }
 968
 969    /* Send the buffer to the storage deamon */
 970    Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
 971    msgsave = sd->msg;
 972    sd->msg = jcr->acl_text;
 973    sd->msglen = len + 1;
 974    if (!bnet_send(sd)) {
 975       sd->msg = msgsave;
 976       sd->msglen = 0;
 977       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 978             bnet_strerror(sd));
 979       return false;
 980    }
 981
 982    jcr->JobBytes += sd->msglen;
 983    sd->msg = msgsave;
 984    if (!bnet_sig(sd, BNET_EOD)) {
 985       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 986             bnet_strerror(sd));
 987       return false;
 988    }
 989
 990    Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
 991 #endif
 992    return true;
 993 }
 994
 995 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
 996 {
 997    BSOCK *sd = jcr->store_bsock;
 998    char attribs[MAXSTRING];
 999    char attribsEx[MAXSTRING];
1000    int attr_stream;
1001    int stat;
1002 #ifdef FD_NO_SEND_TEST
1003    return true;
1004 #endif
1005
1006    /* Find what data stream we will use, then encode the attributes */
1007    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1008       /* This should not happen */
1009       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1010       return false;
1011    }
1012    encode_stat(attribs, ff_pkt, data_stream);
1013
1014    /* Now possibly extend the attributes */
1015    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1016
1017    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1018
1019    jcr->lock();
1020    jcr->JobFiles++;                    /* increment number of files sent */
1021    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1022    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1023    jcr->unlock();
1024
1025    /*
1026     * Send Attributes header to Storage daemon
1027     *    <file-index> <stream> <info>
1028     */
1029    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, attr_stream)) {
1030       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1031             bnet_strerror(sd));
1032       return false;
1033    }
1034    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1035
1036    /*
1037     * Send file attributes to Storage daemon
1038     *   File_index
1039     *   File type
1040     *   Filename (full path)
1041     *   Encoded attributes
1042     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1043     *   Encoded extended-attributes (for Win32)
1044     *
1045     * For a directory, link is the same as fname, but with trailing
1046     * slash. For a linked file, link is the link.
1047     */
1048    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
1049       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1050       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
1051                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
1052                attribsEx, 0);
1053    } else if (ff_pkt->type == FT_DIREND) {
1054       /* Here link is the canonical filename (i.e. with trailing slash) */
1055       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1056                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
1057    } else {
1058       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1059                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
1060    }
1061
1062    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1063    if (!stat) {
1064       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1065             bnet_strerror(sd));
1066       return false;
1067    }
1068    bnet_sig(sd, BNET_EOD);            /* indicate end of attributes data */
1069    return true;
1070 }