git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/backup.c

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