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