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