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