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