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    /*
 648     * Read the file data
 649     */
 650    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 651       int sparseBlock = 0;
 652
 653       /* Check for sparse blocks */
 654       if (ff_pkt->flags & FO_SPARSE) {
 655          ser_declare;
 656          if (sd->msglen == rsize &&
 657              fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
 658              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 659                (uint64_t)ff_pkt->statp.st_size == 0)) {
 660             sparseBlock = is_buf_zero(rbuf, rsize);
 661          }
 662
 663          ser_begin(wbuf, SPARSE_FADDR_SIZE);
 664          ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 665       }
 666
 667       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 668       fileAddr += sd->msglen;
 669
 670       /* Uncompressed cipher input length */
 671       cipher_input_len = sd->msglen;
 672
 673       /* Update checksum if requested */
 674       if (digest) {
 675          crypto_digest_update(digest, rbuf, sd->msglen);
 676       }
 677
 678       /* Update signing digest if requested */
 679       if (signing_digest) {
 680          crypto_digest_update(signing_digest, rbuf, sd->msglen);
 681       }
 682
 683 #ifdef HAVE_LIBZ
 684       /* Do compression if turned on */
 685       if (!sparseBlock && ff_pkt->flags & FO_GZIP) {
 686          int zstat;
 687          compress_len = max_compress_len;
 688          Dmsg4(400, "cbuf=0x%x len=%u rbuf=0x%x len=%u\n", cbuf, compress_len,
 689             rbuf, sd->msglen);
 690          /* NOTE! This call modifies compress_len !!! */
 691          if ((zstat=compress2((Bytef *)cbuf, &compress_len,
 692                (const Bytef *)rbuf, (uLong)sd->msglen,
 693                ff_pkt->GZIP_level)) != Z_OK) {
 694             Jmsg(jcr, M_FATAL, 0, _("Compression error: %d\n"), zstat);
 695             set_jcr_job_status(jcr, JS_ErrorTerminated);
 696             goto err;
 697          }
 698          Dmsg2(400, "compressed len=%d uncompressed len=%d\n",
 699             compress_len, sd->msglen);
 700
 701          sd->msglen = compress_len;      /* set compressed length */
 702          cipher_input_len = compress_len;
 703       }
 704 #endif
 705
 706       if (ff_pkt->flags & FO_ENCRYPT) {
 707          /* Encrypt the input block */
 708          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len, jcr->crypto_buf, &encrypted_len)) {
 709             if (encrypted_len == 0) {
 710                /* No full block of data available, read more data */
 711                continue;
 712             }
 713             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n",
 714                encrypted_len, sd->msglen);
 715             sd->msglen = encrypted_len; /* set encrypted length */
 716          } else {
 717             /* Encryption failed. Shouldn't happen. */
 718             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 719             goto err;
 720          }
 721       }
 722
 723       /* Send the buffer to the Storage daemon */
 724       if (!sparseBlock) {
 725          if (ff_pkt->flags & FO_SPARSE) {
 726             sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 727          }
 728          sd->msg = wbuf;              /* set correct write buffer */
 729          if (!bnet_send(sd)) {
 730             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 731                   bnet_strerror(sd));
 732             goto err;
 733          }
 734       }
 735       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 736       /*          #endif */
 737       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 738       sd->msg = msgsave;                /* restore read buffer */
 739
 740    } /* end while read file data */
 741
 742    /* Send any remaining encrypted data + padding */
 743    if (ff_pkt->flags & FO_ENCRYPT) {
 744       if (!crypto_cipher_finalize(cipher_ctx, jcr->crypto_buf, &encrypted_len)) {
 745          /* Padding failed. Shouldn't happen. */
 746          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
 747          goto err;
 748       }
 749
 750       if (encrypted_len > 0) {
 751          sd->msglen = encrypted_len; /* set encrypted length */
 752
 753          /* Send remaining encrypted data to the SD */
 754          if (ff_pkt->flags & FO_SPARSE) {
 755             sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 756          }
 757          sd->msg = wbuf;              /* set correct write buffer */
 758          if (!bnet_send(sd)) {
 759             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 760                   bnet_strerror(sd));
 761             goto err;
 762          }
 763          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 764          jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 765          sd->msg = msgsave;                /* restore bnet buffer */
 766       }
 767    }
 768
 769    if (sd->msglen < 0) {
 770       berrno be;
 771       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 772          ff_pkt->fname, be.strerror(ff_pkt->bfd.berrno));
 773       if (jcr->Errors++ > 1000) {       /* insanity check */
 774          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
 775       }
 776
 777    }
 778
 779    if (!bnet_sig(sd, BNET_EOD)) {        /* indicate end of file data */
 780       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 781             bnet_strerror(sd));
 782       goto err;
 783    }
 784
 785    /* Free the cipher context */
 786    if (cipher_ctx) {
 787       crypto_cipher_free(cipher_ctx);
 788    }
 789
 790    return 1;
 791
 792 err:
 793    if (cipher_ctx) {
 794       crypto_cipher_free(cipher_ctx);
 795    }
 796    sd->msg = msgsave; /* restore bnet buffer */
 797    sd->msglen = 0;
 798    return 0;
 799 }
 800
 801 /*
 802  * Read and send an ACL for the last encountered file.
 803  */
 804 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
 805 {
 806 #ifdef HAVE_ACL
 807    BSOCK *sd = jcr->store_bsock;
 808    POOLMEM *msgsave;
 809    int len;
 810 #ifdef FD_NO_SEND_TEST
 811    return true;
 812 #endif
 813
 814    len = bacl_get(jcr, acltype);
 815    if (len < 0) {
 816       Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
 817       return true;
 818    }
 819    if (len == 0) {
 820       return true;                    /* no ACL */
 821    }
 822
 823    /* Send header */
 824    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 825       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 826             bnet_strerror(sd));
 827       return false;
 828    }
 829
 830    /* Send the buffer to the storage deamon */
 831    Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
 832    msgsave = sd->msg;
 833    sd->msg = jcr->acl_text;
 834    sd->msglen = len + 1;
 835    if (!bnet_send(sd)) {
 836       sd->msg = msgsave;
 837       sd->msglen = 0;
 838       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 839             bnet_strerror(sd));
 840       return false;
 841    }
 842
 843    jcr->JobBytes += sd->msglen;
 844    sd->msg = msgsave;
 845    if (!bnet_sig(sd, BNET_EOD)) {
 846       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 847             bnet_strerror(sd));
 848       return false;
 849    }
 850
 851    Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
 852 #endif
 853    return true;
 854 }
 855
 856 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
 857 {
 858    BSOCK *sd = jcr->store_bsock;
 859    char attribs[MAXSTRING];
 860    char attribsEx[MAXSTRING];
 861    int attr_stream;
 862    int stat;
 863 #ifdef FD_NO_SEND_TEST
 864    return true;
 865 #endif
 866
 867    /* Find what data stream we will use, then encode the attributes */
 868    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
 869       /* This should not happen */
 870       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
 871       return false;
 872    }
 873    encode_stat(attribs, ff_pkt, data_stream);
 874
 875    /* Now possibly extend the attributes */
 876    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
 877
 878    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
 879
 880    jcr->lock();
 881    jcr->JobFiles++;                    /* increment number of files sent */
 882    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
 883    pm_strcpy(jcr->last_fname, ff_pkt->fname);
 884    jcr->unlock();
 885
 886    /*
 887     * Send Attributes header to Storage daemon
 888     *    <file-index> <stream> <info>
 889     */
 890    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, attr_stream)) {
 891       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 892             bnet_strerror(sd));
 893       return false;
 894    }
 895    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
 896
 897    /*
 898     * Send file attributes to Storage daemon
 899     *   File_index
 900     *   File type
 901     *   Filename (full path)
 902     *   Encoded attributes
 903     *   Link name (if type==FT_LNK or FT_LNKSAVED)
 904     *   Encoded extended-attributes (for Win32)
 905     *
 906     * For a directory, link is the same as fname, but with trailing
 907     * slash. For a linked file, link is the link.
 908     */
 909    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
 910       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
 911       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
 912                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
 913                attribsEx, 0);
 914    } else if (ff_pkt->type == FT_DIREND) {
 915       /* Here link is the canonical filename (i.e. with trailing slash) */
 916       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
 917                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
 918    } else {
 919       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
 920                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
 921    }
 922
 923    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
 924    if (!stat) {
 925       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 926             bnet_strerror(sd));
 927       return false;
 928    }
 929    bnet_sig(sd, BNET_EOD);            /* indicate end of attributes data */
 930    return true;
 931 }