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