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