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 to know when to stop
 599  *  reading.
 600  * Currently this is not a problem as the only other stream, resource forks,
 601  * are not handled as sparse files.
 602  */
 603 int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 604               DIGEST *signing_digest)
 605 {
 606    BSOCK *sd = jcr->store_bsock;
 607    uint64_t fileAddr = 0;             /* file address */
 608    char *rbuf, *wbuf;
 609    int32_t rsize = jcr->buf_size;      /* read buffer size */
 610    POOLMEM *msgsave;
 611    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 612    const uint8_t *cipher_input;
 613    uint32_t cipher_input_len;
 614    uint32_t cipher_block_size;
 615    uint32_t encrypted_len;
 616 #ifdef FD_NO_SEND_TEST
 617    return 1;
 618 #endif
 619
 620    msgsave = sd->msg;
 621    rbuf = sd->msg;                    /* read buffer */
 622    wbuf = sd->msg;                    /* write buffer */
 623    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 624
 625    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 626
 627 #ifdef HAVE_LIBZ
 628    uLong compress_len = 0;
 629    uLong max_compress_len = 0;
 630    const Bytef *cbuf = NULL;
 631    int zstat;
 632
 633    if (ff_pkt->flags & FO_GZIP) {
 634       if (ff_pkt->flags & FO_SPARSE) {
 635          cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
 636          max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
 637       } else {
 638          cbuf = (Bytef *)jcr->compress_buf;
 639          max_compress_len = jcr->compress_buf_size; /* set max length */
 640       }
 641       wbuf = jcr->compress_buf;    /* compressed output here */
 642       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 643
 644       /*
 645        * Only change zlib parameters if there is no pending operation.
 646        * This should never happen as deflatereset is called after each
 647        * deflate.
 648        */
 649
 650       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 651          /* set gzip compression level - must be done per file */
 652          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 653               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 654             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 655             set_jcr_job_status(jcr, JS_ErrorTerminated);
 656             goto err;
 657          }
 658       }
 659    }
 660 #else
 661    const uint32_t max_compress_len = 0;
 662 #endif
 663
 664    if (ff_pkt->flags & FO_ENCRYPT) {
 665       /* Allocate the cipher context */
 666       if ((cipher_ctx = crypto_cipher_new(jcr->pki_session, true,
 667            &cipher_block_size)) == NULL) {
 668          /* Shouldn't happen! */
 669          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context\n"));
 670          goto err;
 671       }
 672
 673       /*
 674        * Grow the crypto buffer, if necessary.
 675        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 676        * We grow crypto_buf to the maximum number of blocks that
 677        * could be returned for the given read buffer size.
 678        * (Using the larger of either rsize or max_compress_len)
 679        */
 680       jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf,
 681            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 682             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 683
 684       wbuf = jcr->crypto_buf; /* Encrypted, possibly compressed output here. */
 685    }
 686
 687    /*
 688     * Send Data header to Storage daemon
 689     *    <file-index> <stream> <info>
 690     */
 691    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 692       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 693             bnet_strerror(sd));
 694       goto err;
 695    }
 696    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 697
 698    /*
 699     * Make space at beginning of buffer for fileAddr because this
 700     *   same buffer will be used for writing if compression is off.
 701     */
 702    if (ff_pkt->flags & FO_SPARSE) {
 703       rbuf += SPARSE_FADDR_SIZE;
 704       rsize -= SPARSE_FADDR_SIZE;
 705 #ifdef HAVE_FREEBSD_OS
 706       /*
 707        * To read FreeBSD partitions, the read size must be
 708        *  a multiple of 512.
 709        */
 710       rsize = (rsize/512) * 512;
 711 #endif
 712    }
 713
 714    /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
 715 #ifdef HAVE_WIN32
 716    if (S_ISBLK(ff_pkt->statp.st_mode))
 717       rsize = (rsize/512) * 512;
 718 #endif
 719
 720    /*
 721     * Read the file data
 722     */
 723    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 724
 725       /* Check for sparse blocks */
 726       if (ff_pkt->flags & FO_SPARSE) {
 727          ser_declare;
 728          bool haveBlock = true;
 729          if (sd->msglen == rsize &&
 730              fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
 731              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 732                (uint64_t)ff_pkt->statp.st_size == 0)) {
 733             haveBlock = !is_buf_zero(rbuf, rsize);
 734          }
 735          if (haveBlock) {
 736             ser_begin(wbuf, SPARSE_FADDR_SIZE);
 737             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 738          }
 739          fileAddr += sd->msglen;      /* update file address */
 740          if (!haveBlock) {
 741             continue;                 /* skip block of zeros */
 742          }
 743       }
 744
 745       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 746
 747       /* Uncompressed cipher input length */
 748       cipher_input_len = sd->msglen;
 749
 750       /* Update checksum if requested */
 751       if (digest) {
 752          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 753       }
 754
 755       /* Update signing digest if requested */
 756       if (signing_digest) {
 757          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 758       }
 759
 760 #ifdef HAVE_LIBZ
 761       /* Do compression if turned on */
 762       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 763          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 764
 765          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 766                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 767          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 768                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 769
 770          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 771             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 772             set_jcr_job_status(jcr, JS_ErrorTerminated);
 773             goto err;
 774          }
 775          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 776          /* reset zlib stream to be able to begin from scratch again */
 777          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 778             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 779             set_jcr_job_status(jcr, JS_ErrorTerminated);
 780             goto err;
 781          }
 782
 783          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 784                sd->msglen);
 785
 786          sd->msglen = compress_len;      /* set compressed length */
 787          cipher_input_len = compress_len;
 788       }
 789 #endif
 790       /*
 791        * Note, here we prepend the current record length to the beginning
 792        *  of the encrypted data. This is because both sparse and compression
 793        *  restore handling want records returned to them with exactly the
 794        *  same number of bytes that were processed in the backup handling.
 795        *  That is, both are block filters rather than a stream.  When doing
 796        *  compression, the compression routines may buffer data, so that for
 797        *  any one record compressed, when it is decompressed the same size
 798        *  will not be obtained. Of course, the buffered data eventually comes
 799        *  out in subsequent crypto_cipher_update() calls or at least
 800        *  when crypto_cipher_finalize() is called.  Unfortunately, this
 801        *  "feature" of encryption enormously complicates the restore code.
 802        */
 803       if (ff_pkt->flags & FO_ENCRYPT) {
 804          uint32_t initial_len = 0;
 805          ser_declare;
 806
 807          if (ff_pkt->flags & FO_SPARSE) {
 808             cipher_input_len += SPARSE_FADDR_SIZE;
 809          }
 810
 811          /* Encrypt the length of the input block */
 812          uint8_t packet_len[sizeof(uint32_t)];
 813
 814          ser_begin(packet_len, sizeof(uint32_t));
 815          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
 816          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
 817
 818          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
 819                   (u_int8_t *)jcr->crypto_buf, &initial_len)) {
 820             /* Encryption failed. Shouldn't happen. */
 821             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 822             goto err;
 823          }
 824
 825          /* Encrypt the input block */
 826          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
 827              (u_int8_t *)&jcr->crypto_buf[initial_len], &encrypted_len)) {
 828             if ((initial_len + encrypted_len) == 0) {
 829                /* No full block of data available, read more data */
 830                continue;
 831             }
 832             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
 833                   sd->msglen);
 834             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
 835          } else {
 836             /* Encryption failed. Shouldn't happen. */
 837             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 838             goto err;
 839          }
 840       }
 841
 842       /* Send the buffer to the Storage daemon */
 843       if (ff_pkt->flags & FO_SPARSE) {
 844          sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 845       }
 846       sd->msg = wbuf;              /* set correct write buffer */
 847       if (!bnet_send(sd)) {
 848          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 849                bnet_strerror(sd));
 850          goto err;
 851       }
 852       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 853       /*          #endif */
 854       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 855       sd->msg = msgsave;                /* restore read buffer */
 856
 857    } /* end while read file data */
 858
 859    if (sd->msglen < 0) {                 /* error */
 860       berrno be;
 861       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 862          ff_pkt->fname, be.strerror(ff_pkt->bfd.berrno));
 863       if (jcr->Errors++ > 1000) {       /* insanity check */
 864          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
 865       }
 866    } else if (ff_pkt->flags & FO_ENCRYPT) {
 867       /*
 868        * For encryption, we must call finalize to push out any
 869        *  buffered data.
 870        */
 871       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto_buf,
 872            &encrypted_len)) {
 873          /* Padding failed. Shouldn't happen. */
 874          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
 875          goto err;
 876       }
 877
 878       /* Note, on SSL pre-0.9.7, there is always some output */
 879       if (encrypted_len > 0) {
 880          sd->msglen = encrypted_len;      /* set encrypted length */
 881          sd->msg = jcr->crypto_buf;       /* set correct write buffer */
 882          if (!bnet_send(sd)) {
 883             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 884                   bnet_strerror(sd));
 885             goto err;
 886          }
 887          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 888          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
 889          sd->msg = msgsave;               /* restore bnet buffer */
 890       }
 891    }
 892
 893    if (!bnet_sig(sd, BNET_EOD)) {        /* indicate end of file data */
 894       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 895             bnet_strerror(sd));
 896       goto err;
 897    }
 898
 899    /* Free the cipher context */
 900    if (cipher_ctx) {
 901       crypto_cipher_free(cipher_ctx);
 902    }
 903    return 1;
 904
 905 err:
 906    /* Free the cipher context */
 907    if (cipher_ctx) {
 908       crypto_cipher_free(cipher_ctx);
 909    }
 910
 911    sd->msg = msgsave; /* restore bnet buffer */
 912    sd->msglen = 0;
 913    return 0;
 914 }
 915
 916 /*
 917  * Read and send an ACL for the last encountered file.
 918  */
 919 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
 920 {
 921 #ifdef HAVE_ACL
 922    BSOCK *sd = jcr->store_bsock;
 923    POOLMEM *msgsave;
 924    int len;
 925 #ifdef FD_NO_SEND_TEST
 926    return true;
 927 #endif
 928
 929    len = bacl_get(jcr, acltype);
 930    if (len < 0) {
 931       Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
 932       return true;
 933    }
 934    if (len == 0) {
 935       return true;                    /* no ACL */
 936    }
 937
 938    /* Send header */
 939    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 940       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 941             bnet_strerror(sd));
 942       return false;
 943    }
 944
 945    /* Send the buffer to the storage deamon */
 946    Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
 947    msgsave = sd->msg;
 948    sd->msg = jcr->acl_text;
 949    sd->msglen = len + 1;
 950    if (!bnet_send(sd)) {
 951       sd->msg = msgsave;
 952       sd->msglen = 0;
 953       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 954             bnet_strerror(sd));
 955       return false;
 956    }
 957
 958    jcr->JobBytes += sd->msglen;
 959    sd->msg = msgsave;
 960    if (!bnet_sig(sd, BNET_EOD)) {
 961       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 962             bnet_strerror(sd));
 963       return false;
 964    }
 965
 966    Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
 967 #endif
 968    return true;
 969 }
 970
 971 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
 972 {
 973    BSOCK *sd = jcr->store_bsock;
 974    char attribs[MAXSTRING];
 975    char attribsEx[MAXSTRING];
 976    int attr_stream;
 977    int stat;
 978 #ifdef FD_NO_SEND_TEST
 979    return true;
 980 #endif
 981
 982    /* Find what data stream we will use, then encode the attributes */
 983    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
 984       /* This should not happen */
 985       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
 986       return false;
 987    }
 988    encode_stat(attribs, ff_pkt, data_stream);
 989
 990    /* Now possibly extend the attributes */
 991    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
 992
 993    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
 994
 995    jcr->lock();
 996    jcr->JobFiles++;                    /* increment number of files sent */
 997    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
 998    pm_strcpy(jcr->last_fname, ff_pkt->fname);
 999    jcr->unlock();
1000
1001    /*
1002     * Send Attributes header to Storage daemon
1003     *    <file-index> <stream> <info>
1004     */
1005    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, attr_stream)) {
1006       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1007             bnet_strerror(sd));
1008       return false;
1009    }
1010    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1011
1012    /*
1013     * Send file attributes to Storage daemon
1014     *   File_index
1015     *   File type
1016     *   Filename (full path)
1017     *   Encoded attributes
1018     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1019     *   Encoded extended-attributes (for Win32)
1020     *
1021     * For a directory, link is the same as fname, but with trailing
1022     * slash. For a linked file, link is the link.
1023     */
1024    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
1025       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1026       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
1027                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
1028                attribsEx, 0);
1029    } else if (ff_pkt->type == FT_DIREND) {
1030       /* Here link is the canonical filename (i.e. with trailing slash) */
1031       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1032                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
1033    } else {
1034       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1035                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
1036    }
1037
1038    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1039    if (!stat) {
1040       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1041             bnet_strerror(sd));
1042       return false;
1043    }
1044    bnet_sig(sd, BNET_EOD);            /* indicate end of attributes data */
1045    return true;
1046 }