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-2005 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    BSOCK *sd;
 186    JCR *jcr = (JCR *)vjcr;
 187
 188    if (job_canceled(jcr)) {
 189       return 0;
 190    }
 191
 192    sd = jcr->store_bsock;
 193    jcr->num_files_examined++;         /* bump total file count */
 194
 195    switch (ff_pkt->type) {
 196    case FT_LNKSAVED:                  /* Hard linked, file already saved */
 197       Dmsg2(130, "FT_LNKSAVED hard link: %s => %s\n", ff_pkt->fname, ff_pkt->link);
 198       break;
 199    case FT_REGE:
 200       Dmsg1(130, "FT_REGE saving: %s\n", ff_pkt->fname);
 201       break;
 202    case FT_REG:
 203       Dmsg1(130, "FT_REG saving: %s\n", ff_pkt->fname);
 204       break;
 205    case FT_LNK:
 206       Dmsg2(130, "FT_LNK saving: %s -> %s\n", ff_pkt->fname, ff_pkt->link);
 207       break;
 208    case FT_DIRBEGIN:
 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 #endif
 591
 592    if (ff_pkt->flags & FO_ENCRYPT) {
 593       /* Allocate the cipher context */
 594       if ((cipher_ctx = crypto_cipher_new(jcr->pki_session, true, &cipher_block_size)) == NULL) {
 595          /* Shouldn't happen! */
 596          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context\n"));
 597          goto err;
 598       }
 599
 600       /*
 601        * Grow the crypto buffer, if necessary.
 602        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 603        * We grow crypto_buf to the maximum number of blocks that
 604        * could be returned for the given read buffer size.
 605        * (Using the larger of either rsize or max_compress_len)
 606        */
 607       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);
 608
 609       wbuf = jcr->crypto_buf; /* Encrypted, possibly compressed output here. */
 610    }
 611
 612    /*
 613     * Send Data header to Storage daemon
 614     *    <file-index> <stream> <info>
 615     */
 616    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 617       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 618             bnet_strerror(sd));
 619       goto err;
 620    }
 621    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 622
 623    /*
 624     * Make space at beginning of buffer for fileAddr because this
 625     *   same buffer will be used for writing if compression if off.
 626     */
 627    if (ff_pkt->flags & FO_SPARSE) {
 628       rbuf += SPARSE_FADDR_SIZE;
 629       rsize -= SPARSE_FADDR_SIZE;
 630 #ifdef HAVE_FREEBSD_OS
 631       /*
 632        * To read FreeBSD partitions, the read size must be
 633        *  a multiple of 512.
 634        */
 635       rsize = (rsize/512) * 512;
 636 #endif
 637    }
 638
 639    /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
 640 #ifdef HAVE_WIN32
 641    if (S_ISBLK(ff_pkt->statp.st_mode))
 642       rsize = (rsize/512) * 512;
 643 #endif
 644
 645    /*
 646     * Read the file data
 647     */
 648    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 649       int sparseBlock = 0;
 650
 651       /* Check for sparse blocks */
 652       if (ff_pkt->flags & FO_SPARSE) {
 653          ser_declare;
 654          if (sd->msglen == rsize &&
 655              fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
 656              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 657                (uint64_t)ff_pkt->statp.st_size == 0)) {
 658             sparseBlock = is_buf_zero(rbuf, rsize);
 659          }
 660
 661          ser_begin(wbuf, SPARSE_FADDR_SIZE);
 662          ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 663       }
 664
 665       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 666       fileAddr += sd->msglen;
 667
 668       /* Uncompressed cipher input length */
 669       cipher_input_len = sd->msglen;
 670
 671       /* Update checksum if requested */
 672       if (digest) {
 673          crypto_digest_update(digest, rbuf, sd->msglen);
 674       }
 675
 676       /* Update signing digest if requested */
 677       if (signing_digest) {
 678          crypto_digest_update(signing_digest, rbuf, sd->msglen);
 679       }
 680
 681 #ifdef HAVE_LIBZ
 682       /* Do compression if turned on */
 683       if (!sparseBlock && ff_pkt->flags & FO_GZIP) {
 684          int zstat;
 685          compress_len = max_compress_len;
 686          Dmsg4(400, "cbuf=0x%x len=%u rbuf=0x%x len=%u\n", cbuf, compress_len,
 687             rbuf, sd->msglen);
 688          /* NOTE! This call modifies compress_len !!! */
 689          if ((zstat=compress2((Bytef *)cbuf, &compress_len,
 690                (const Bytef *)rbuf, (uLong)sd->msglen,
 691                ff_pkt->GZIP_level)) != Z_OK) {
 692             Jmsg(jcr, M_FATAL, 0, _("Compression error: %d\n"), zstat);
 693             set_jcr_job_status(jcr, JS_ErrorTerminated);
 694             goto err;
 695          }
 696          Dmsg2(400, "compressed len=%d uncompressed len=%d\n",
 697             compress_len, sd->msglen);
 698
 699          sd->msglen = compress_len;      /* set compressed length */
 700          cipher_input_len = compress_len;
 701       }
 702 #endif
 703
 704       if (ff_pkt->flags & FO_ENCRYPT) {
 705          /* Encrypt the input block */
 706          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len, jcr->crypto_buf, &encrypted_len)) {
 707             if (encrypted_len == 0) {
 708                /* No full block of data available, read more data */
 709                continue;
 710             }
 711             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n",
 712                encrypted_len, sd->msglen);
 713             sd->msglen = encrypted_len; /* set encrypted length */
 714          } else {
 715             /* Encryption failed. Shouldn't happen. */
 716             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 717             goto err;
 718          }
 719       }
 720
 721       /* Send the buffer to the Storage daemon */
 722       if (!sparseBlock) {
 723          if (ff_pkt->flags & FO_SPARSE) {
 724             sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 725          }
 726          sd->msg = wbuf;              /* set correct write buffer */
 727          if (!bnet_send(sd)) {
 728             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 729                   bnet_strerror(sd));
 730             goto err;
 731          }
 732       }
 733       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 734       /*          #endif */
 735       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 736       sd->msg = msgsave;                /* restore read buffer */
 737
 738    } /* end while read file data */
 739
 740    /* Send any remaining encrypted data + padding */
 741    if (ff_pkt->flags & FO_ENCRYPT) {
 742       if (!crypto_cipher_finalize(cipher_ctx, jcr->crypto_buf, &encrypted_len)) {
 743          /* Padding failed. Shouldn't happen. */
 744          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
 745          goto err;
 746       }
 747
 748       if (encrypted_len > 0) {
 749          sd->msglen = encrypted_len; /* set encrypted length */
 750
 751          /* Send remaining encrypted data to the SD */
 752          if (ff_pkt->flags & FO_SPARSE) {
 753             sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 754          }
 755          sd->msg = wbuf;              /* set correct write buffer */
 756          if (!bnet_send(sd)) {
 757             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 758                   bnet_strerror(sd));
 759             goto err;
 760          }
 761          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 762          jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 763          sd->msg = msgsave;                /* restore bnet buffer */
 764       }
 765    }
 766
 767    if (sd->msglen < 0) {
 768       berrno be;
 769       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 770          ff_pkt->fname, be.strerror(ff_pkt->bfd.berrno));
 771       if (jcr->Errors++ > 1000) {       /* insanity check */
 772          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
 773       }
 774
 775    }
 776
 777    if (!bnet_sig(sd, BNET_EOD)) {        /* indicate end of file data */
 778       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 779             bnet_strerror(sd));
 780       goto err;
 781    }
 782
 783    /* Free the cipher context */
 784    if (cipher_ctx) {
 785       crypto_cipher_free(cipher_ctx);
 786    }
 787
 788    return 1;
 789
 790 err:
 791    if (cipher_ctx) {
 792       crypto_cipher_free(cipher_ctx);
 793    }
 794    sd->msg = msgsave; /* restore bnet buffer */
 795    sd->msglen = 0;
 796    return 0;
 797 }
 798
 799 /*
 800  * Read and send an ACL for the last encountered file.
 801  */
 802 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
 803 {
 804 #ifdef HAVE_ACL
 805    BSOCK *sd = jcr->store_bsock;
 806    POOLMEM *msgsave;
 807    int len;
 808 #ifdef FD_NO_SEND_TEST
 809    return true;
 810 #endif
 811
 812    len = bacl_get(jcr, acltype);
 813    if (len < 0) {
 814       Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
 815       return true;
 816    }
 817    if (len == 0) {
 818       return true;                    /* no ACL */
 819    }
 820
 821    /* Send header */
 822    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, stream)) {
 823       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 824             bnet_strerror(sd));
 825       return false;
 826    }
 827
 828    /* Send the buffer to the storage deamon */
 829    Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
 830    msgsave = sd->msg;
 831    sd->msg = jcr->acl_text;
 832    sd->msglen = len + 1;
 833    if (!bnet_send(sd)) {
 834       sd->msg = msgsave;
 835       sd->msglen = 0;
 836       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 837             bnet_strerror(sd));
 838       return false;
 839    }
 840
 841    jcr->JobBytes += sd->msglen;
 842    sd->msg = msgsave;
 843    if (!bnet_sig(sd, BNET_EOD)) {
 844       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 845             bnet_strerror(sd));
 846       return false;
 847    }
 848
 849    Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
 850 #endif
 851    return true;
 852 }
 853
 854 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
 855 {
 856    BSOCK *sd = jcr->store_bsock;
 857    char attribs[MAXSTRING];
 858    char attribsEx[MAXSTRING];
 859    int attr_stream;
 860    int stat;
 861 #ifdef FD_NO_SEND_TEST
 862    return true;
 863 #endif
 864
 865    /* Find what data stream we will use, then encode the attributes */
 866    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
 867       /* This should not happen */
 868       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
 869       return false;
 870    }
 871    encode_stat(attribs, ff_pkt, data_stream);
 872
 873    /* Now possibly extend the attributes */
 874    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
 875
 876    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
 877
 878    P(jcr->mutex);
 879    jcr->JobFiles++;                    /* increment number of files sent */
 880    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
 881    pm_strcpy(jcr->last_fname, ff_pkt->fname);
 882    V(jcr->mutex);
 883
 884    /*
 885     * Send Attributes header to Storage daemon
 886     *    <file-index> <stream> <info>
 887     */
 888    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, attr_stream)) {
 889       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 890             bnet_strerror(sd));
 891       return false;
 892    }
 893    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
 894
 895    /*
 896     * Send file attributes to Storage daemon
 897     *   File_index
 898     *   File type
 899     *   Filename (full path)
 900     *   Encoded attributes
 901     *   Link name (if type==FT_LNK or FT_LNKSAVED)
 902     *   Encoded extended-attributes (for Win32)
 903     *
 904     * For a directory, link is the same as fname, but with trailing
 905     * slash. For a linked file, link is the link.
 906     */
 907    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
 908       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
 909       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
 910                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
 911                attribsEx, 0);
 912    } else if (ff_pkt->type == FT_DIREND) {
 913       /* Here link is the canonical filename (i.e. with trailing slash) */
 914       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
 915                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
 916    } else {
 917       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
 918                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
 919    }
 920
 921    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
 922    if (!stat) {
 923       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 924             bnet_strerror(sd));
 925       return false;
 926    }
 927    bnet_sig(sd, BNET_EOD);            /* indicate end of attributes data */
 928    return true;
 929 }