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