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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *  Bacula File Daemon  restore.c Restorefiles.
  30  *
  31  *    Kern Sibbald, November MM
  32  *
  33  *   Version $Id$
  34  *
  35  */
  36
  37 #include "bacula.h"
  38 #include "filed.h"
  39
  40 #ifdef HAVE_DARWIN_OS
  41 #include <sys/attr.h>
  42 const bool have_darwin_os = true;
  43 #else
  44 const bool have_darwin_os = false;
  45 #endif
  46
  47 #if defined(HAVE_CRYPTO)
  48 const bool have_crypto = true;
  49 #else
  50 const bool have_crypto = false;
  51 #endif
  52
  53 #if defined(HAVE_ACL)
  54 const bool have_acl = true;
  55 #else
  56 const bool have_acl = false;
  57 #endif
  58
  59 #ifdef HAVE_SHA2
  60 const bool have_sha2 = true;
  61 #else
  62 const bool have_sha2 = false;
  63 #endif
  64
  65 #if defined(HAVE_XATTR)
  66 const bool have_xattr = true;
  67 #else
  68 const bool have_xattr = false;
  69 #endif
  70
  71 /* Data received from Storage Daemon */
  72 static char rec_header[] = "rechdr %ld %ld %ld %ld %ld";
  73
  74 typedef struct restore_cipher_ctx {
  75    CIPHER_CONTEXT *cipher;
  76    uint32_t block_size;
  77
  78    POOLMEM *buf;       /* Pointer to descryption buffer */
  79    int32_t buf_len;    /* Count of bytes currently in buf */
  80    int32_t packet_len; /* Total bytes in packet */
  81 } RESTORE_CIPHER_CTX;
  82
  83 struct r_ctx {
  84    JCR *jcr;
  85    int32_t stream;
  86    int32_t prev_stream;
  87    BFILE bfd;                          /* File content */
  88    uint64_t fileAddr;                  /* file write address */
  89    uint32_t size;                      /* Size of file */
  90    int flags;                          /* Options for extract_data() */
  91    BFILE forkbfd;                      /* Alternative data stream */
  92    uint64_t fork_addr;                 /* Write address for alternative stream */
  93    intmax_t fork_size;                 /* Size of alternate stream */
  94    int fork_flags;                     /* Options for extract_data() */
  95    int32_t type;                       /* file type FT_ */
  96    ATTR *attr;                         /* Pointer to attributes */
  97    bool extract;                       /* set when extracting */
  98
  99    SIGNATURE *sig;                     /* Cryptographic signature (if any) for file */
 100    CRYPTO_SESSION *cs;                 /* Cryptographic session data (if any) for file */
 101    RESTORE_CIPHER_CTX cipher_ctx;      /* Cryptographic restore context (if any) for file */
 102    RESTORE_CIPHER_CTX fork_cipher_ctx; /* Cryptographic restore context (if any) for alternative stream */
 103 };
 104
 105
 106 /* Forward referenced functions */
 107 #if   defined(HAVE_LIBZ)
 108 static const char *zlib_strerror(int stat);
 109 const bool have_libz = true;
 110 #else
 111 const bool have_libz = false;
 112 #endif
 113
 114 static void deallocate_cipher(r_ctx &rctx);
 115 static void deallocate_fork_cipher(r_ctx &rctx);
 116 static void free_signature(r_ctx &rctx);
 117 static void free_session(r_ctx &rctx);
 118 static void close_previous_stream(r_ctx &rctx);
 119
 120
 121
 122 static bool verify_signature(JCR *jcr, r_ctx &rctx);
 123 int32_t extract_data(JCR *jcr, r_ctx &rctx, POOLMEM *buf, int32_t buflen,
 124                      uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx);
 125 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
 126                   RESTORE_CIPHER_CTX *cipher_ctx);
 127
 128
 129 /*
 130  * Close a bfd check that we are at the expected file offset.
 131  * Makes use of some code from set_attributes().
 132  */
 133 static int bclose_chksize(JCR *jcr, BFILE *bfd, boffset_t osize)
 134 {
 135    char ec1[50], ec2[50];
 136    boffset_t fsize;
 137
 138    fsize = blseek(bfd, 0, SEEK_CUR);
 139    bclose(bfd);                              /* first close file */
 140    if (fsize > 0 && fsize != osize) {
 141       Qmsg3(jcr, M_ERROR, 0, _("Size of data or stream of %s not correct. Original %s, restored %s.\n"),
 142             jcr->last_fname, edit_uint64(osize, ec1),
 143             edit_uint64(fsize, ec2));
 144       return -1;
 145    }
 146    return 0;
 147 }
 148
 149
 150 /*
 151  * Restore the requested files.
 152  *
 153  */
 154 void do_restore(JCR *jcr)
 155 {
 156    BSOCK *sd;
 157    uint32_t VolSessionId, VolSessionTime;
 158    int32_t file_index;
 159    char ec1[50];                       /* Buffer printing huge values */
 160    uint32_t buf_size;                  /* client buffer size */
 161    int stat;
 162    intmax_t rsrc_len = 0;             /* Original length of resource fork */
 163    r_ctx rctx;
 164    ATTR *attr;
 165    /* ***FIXME*** make configurable */
 166    crypto_digest_t signing_algorithm = have_sha2 ?
 167                                        CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
 168    memset(&rctx, 0, sizeof(rctx));
 169    rctx.jcr = jcr;
 170
 171    /* The following variables keep track of "known unknowns" */
 172    int non_support_data = 0;
 173    int non_support_attr = 0;
 174    int non_support_rsrc = 0;
 175    int non_support_finfo = 0;
 176    int non_support_acl = 0;
 177    int non_support_progname = 0;
 178    int non_support_crypto = 0;
 179    int non_support_xattr = 0;
 180
 181 #ifdef HAVE_DARWIN_OS
 182    struct attrlist attrList;
 183    memset(&attrList, 0, sizeof(attrList));
 184    attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
 185    attrList.commonattr = ATTR_CMN_FNDRINFO;
 186 #endif
 187
 188
 189    sd = jcr->store_bsock;
 190    set_jcr_job_status(jcr, JS_Running);
 191
 192    LockRes();
 193    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
 194    UnlockRes();
 195    if (client) {
 196       buf_size = client->max_network_buffer_size;
 197    } else {
 198       buf_size = 0;                   /* use default */
 199    }
 200    if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
 201       set_jcr_job_status(jcr, JS_ErrorTerminated);
 202       return;
 203    }
 204    jcr->buf_size = sd->msglen;
 205
 206    /* St Bernard code goes here if implemented -- see end of file */
 207
 208    if (have_libz) {
 209       uint32_t compress_buf_size = jcr->buf_size + 12 + ((jcr->buf_size+999) / 1000) + 100;
 210       jcr->compress_buf = (char *)bmalloc(compress_buf_size);
 211       jcr->compress_buf_size = compress_buf_size;
 212    }
 213
 214    if (have_crypto) {
 215       rctx.cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 216       if (have_darwin_os) {
 217          rctx.fork_cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 218       }
 219    }
 220
 221    /*
 222     * Get a record from the Storage daemon. We are guaranteed to
 223     *   receive records in the following order:
 224     *   1. Stream record header
 225     *   2. Stream data (one or more of the following in the order given)
 226     *        a. Attributes (Unix or Win32)
 227     *        b. Possibly stream encryption session data (e.g., symmetric session key)
 228     *        c. File data for the file
 229     *        d. Alternate data stream (e.g. Resource Fork)
 230     *        e. Finder info
 231     *        f. ACLs
 232     *        g. XATTRs
 233     *        h. Possibly a cryptographic signature
 234     *        i. Possibly MD5 or SHA1 record
 235     *   3. Repeat step 1
 236     *
 237     * NOTE: We keep track of two bacula file descriptors:
 238     *   1. bfd for file data.
 239     *      This fd is opened for non empty files when an attribute stream is
 240     *      encountered and closed when we find the next attribute stream.
 241     *   2. fork_bfd for alternate data streams
 242     *      This fd is opened every time we encounter a new alternate data
 243     *      stream for the current file. When we find any other stream, we
 244     *      close it again.
 245     *      The expected size of the stream, fork_len, should be set when
 246     *      opening the fd.
 247     *   3. Not all the stream data records are required -- e.g. if there
 248     *      is no fork, there is no alternate data stream, no ACL, ...
 249     */
 250    binit(&rctx.bfd);
 251    binit(&rctx.forkbfd);
 252    attr = rctx.attr = new_attr(jcr);
 253    if (have_acl) {
 254       jcr->acl_data = (acl_data_t *)malloc(sizeof(acl_data_t));
 255       memset((caddr_t)jcr->acl_data, 0, sizeof(acl_data_t));
 256       jcr->acl_data->content = get_pool_memory(PM_MESSAGE);
 257    }
 258    if (have_xattr) {
 259       jcr->xattr_data = (xattr_data_t *)malloc(sizeof(xattr_data_t));
 260       memset((caddr_t)jcr->xattr_data, 0, sizeof(xattr_data_t));
 261       jcr->xattr_data->content = get_pool_memory(PM_MESSAGE);
 262    }
 263
 264    while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
 265       /* Remember previous stream type */
 266       rctx.prev_stream = rctx.stream;
 267
 268       /* First we expect a Stream Record Header */
 269       if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
 270           &rctx.stream, &rctx.size) != 5) {
 271          Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
 272          goto bail_out;
 273       }
 274       Dmsg5(50, "Got hdr: Files=%d FilInx=%d size=%d Stream=%d, %s.\n",
 275             jcr->JobFiles, file_index, rctx.size, rctx.stream, stream_to_ascii(rctx.stream));
 276
 277       /* * Now we expect the Stream Data */
 278       if (bget_msg(sd) < 0) {
 279          Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), sd->bstrerror());
 280          goto bail_out;
 281       }
 282       if (rctx.size != (uint32_t)sd->msglen) {
 283          Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"),
 284                sd->msglen, rctx.size);
 285          Dmsg2(50, "Actual data size %d not same as header %d\n",
 286                sd->msglen, rctx.size);
 287          goto bail_out;
 288       }
 289       Dmsg3(130, "Got stream: %s len=%d extract=%d\n", stream_to_ascii(rctx.stream),
 290             sd->msglen, rctx.extract);
 291
 292       /* If we change streams, close and reset alternate data streams */
 293       if (rctx.prev_stream != rctx.stream) {
 294          if (is_bopen(&rctx.forkbfd)) {
 295             deallocate_fork_cipher(rctx);
 296             bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
 297          }
 298          rctx.fork_size = -1; /* Use an impossible value and set a proper one below */
 299          rctx.fork_addr = 0;
 300       }
 301
 302       /* File Attributes stream */
 303       switch (rctx.stream) {
 304       case STREAM_UNIX_ATTRIBUTES:
 305       case STREAM_UNIX_ATTRIBUTES_EX:
 306          close_previous_stream(rctx);     /* if any previous stream open, close it */
 307
 308
 309          /* TODO: manage deleted files */
 310          if (rctx.type == FT_DELETED) { /* deleted file */
 311             continue;
 312          }
 313
 314          /*
 315           * Unpack attributes and do sanity check them
 316           */
 317          if (!unpack_attributes_record(jcr, rctx.stream, sd->msg, attr)) {
 318             goto bail_out;
 319          }
 320 #ifdef xxx
 321          if (file_index != attr->file_index) {
 322             Jmsg(jcr, M_FATAL, 0, _("Record header file index %ld not equal record index %ld\n"),
 323                  file_index, attr->file_index);
 324             Dmsg0(200, "File index error\n");
 325             goto bail_out;
 326          }
 327 #endif
 328
 329          Dmsg3(200, "File %s\nattrib=%s\nattribsEx=%s\n", attr->fname,
 330                attr->attr, attr->attrEx);
 331
 332          attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
 333
 334          if (!is_restore_stream_supported(attr->data_stream)) {
 335             if (!non_support_data++) {
 336                Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
 337                   stream_to_ascii(attr->data_stream));
 338             }
 339             continue;
 340          }
 341
 342          build_attr_output_fnames(jcr, attr);
 343
 344          /*
 345           * Try to actually create the file, which returns a status telling
 346           *  us if we need to extract or not.
 347           */
 348          jcr->num_files_examined++;
 349          rctx.extract = false;
 350          if (jcr->plugin) {
 351             stat = plugin_create_file(jcr, attr, &rctx.bfd, jcr->replace);
 352          } else {
 353             stat = create_file(jcr, attr, &rctx.bfd, jcr->replace);
 354          }
 355          jcr->lock();
 356          pm_strcpy(jcr->last_fname, attr->ofname);
 357          jcr->last_type = attr->type;
 358          jcr->unlock();
 359          Dmsg2(130, "Outfile=%s create_file stat=%d\n", attr->ofname, stat);
 360          switch (stat) {
 361          case CF_ERROR:
 362          case CF_SKIP:
 363             pm_strcpy(jcr->last_fname, attr->ofname);
 364             jcr->last_type = attr->type;
 365             break;
 366          case CF_EXTRACT:        /* File created and we expect file data */
 367             rctx.extract = true;
 368             /* FALLTHROUGH */
 369          case CF_CREATED:        /* File created, but there is no content */
 370             jcr->JobFiles++;
 371             rctx.fileAddr = 0;
 372             print_ls_output(jcr, attr);
 373
 374             if (have_darwin_os) {
 375                /* Only restore the resource fork for regular files */
 376                from_base64(&rsrc_len, attr->attrEx);
 377                if (attr->type == FT_REG && rsrc_len > 0) {
 378                   rctx.extract = true;
 379                }
 380             }
 381             if (!rctx.extract) {
 382                /* set attributes now because file will not be extracted */
 383                if (jcr->plugin) {
 384                   plugin_set_attributes(jcr, attr, &rctx.bfd);
 385                } else {
 386                   set_attributes(jcr, attr, &rctx.bfd);
 387                }
 388             }
 389             break;
 390          }
 391          break;
 392
 393       /* Data stream */
 394       case STREAM_ENCRYPTED_SESSION_DATA:
 395          crypto_error_t cryptoerr;
 396
 397          /* Is this an unexpected session data entry? */
 398          if (rctx.cs) {
 399             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic session data stream.\n"));
 400             rctx.extract = false;
 401             bclose(&rctx.bfd);
 402             continue;
 403          }
 404
 405          /* Do we have any keys at all? */
 406          if (!jcr->crypto.pki_recipients) {
 407             Jmsg(jcr, M_ERROR, 0, _("No private decryption keys have been defined to decrypt encrypted backup data.\n"));
 408             rctx.extract = false;
 409             bclose(&rctx.bfd);
 410             break;
 411          }
 412
 413          if (jcr->crypto.digest) {
 414             crypto_digest_free(jcr->crypto.digest);
 415          }
 416          jcr->crypto.digest = crypto_digest_new(jcr, signing_algorithm);
 417          if (!jcr->crypto.digest) {
 418             Jmsg0(jcr, M_FATAL, 0, _("Could not create digest.\n"));
 419             rctx.extract = false;
 420             bclose(&rctx.bfd);
 421             break;
 422          }
 423
 424          /* Decode and save session keys. */
 425          cryptoerr = crypto_session_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen,
 426                         jcr->crypto.pki_recipients, &rctx.cs);
 427          switch(cryptoerr) {
 428          case CRYPTO_ERROR_NONE:
 429             /* Success */
 430             break;
 431          case CRYPTO_ERROR_NORECIPIENT:
 432             Jmsg(jcr, M_ERROR, 0, _("Missing private key required to decrypt encrypted backup data.\n"));
 433             break;
 434          case CRYPTO_ERROR_DECRYPTION:
 435             Jmsg(jcr, M_ERROR, 0, _("Decrypt of the session key failed.\n"));
 436             break;
 437          default:
 438             /* Shouldn't happen */
 439             Jmsg1(jcr, M_ERROR, 0, _("An error occurred while decoding encrypted session data stream: %s\n"), crypto_strerror(cryptoerr));
 440             break;
 441          }
 442
 443          if (cryptoerr != CRYPTO_ERROR_NONE) {
 444             rctx.extract = false;
 445             bclose(&rctx.bfd);
 446             continue;
 447          }
 448
 449          break;
 450
 451       case STREAM_FILE_DATA:
 452       case STREAM_SPARSE_DATA:
 453       case STREAM_WIN32_DATA:
 454       case STREAM_GZIP_DATA:
 455       case STREAM_SPARSE_GZIP_DATA:
 456       case STREAM_WIN32_GZIP_DATA:
 457       case STREAM_ENCRYPTED_FILE_DATA:
 458       case STREAM_ENCRYPTED_WIN32_DATA:
 459       case STREAM_ENCRYPTED_FILE_GZIP_DATA:
 460       case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
 461          /* Force an expected, consistent stream type here */
 462          if (rctx.extract && (rctx.prev_stream == rctx.stream
 463                          || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES
 464                          || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES_EX
 465                          || rctx.prev_stream == STREAM_ENCRYPTED_SESSION_DATA)) {
 466             rctx.flags = 0;
 467
 468             if (rctx.stream == STREAM_SPARSE_DATA ||
 469                 rctx.stream == STREAM_SPARSE_GZIP_DATA) {
 470                rctx.flags |= FO_SPARSE;
 471             }
 472
 473             if (rctx.stream == STREAM_GZIP_DATA
 474                   || rctx.stream == STREAM_SPARSE_GZIP_DATA
 475                   || rctx.stream == STREAM_WIN32_GZIP_DATA
 476                   || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 477                   || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 478                rctx.flags |= FO_GZIP;
 479             }
 480
 481             if (rctx.stream == STREAM_ENCRYPTED_FILE_DATA
 482                   || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 483                   || rctx.stream == STREAM_ENCRYPTED_WIN32_DATA
 484                   || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 485                /* Set up a decryption context */
 486                if (!rctx.cipher_ctx.cipher) {
 487                   if (!rctx.cs) {
 488                      Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 489                      rctx.extract = false;
 490                      bclose(&rctx.bfd);
 491                      continue;
 492                   }
 493
 494                   if ((rctx.cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false,
 495                            &rctx.cipher_ctx.block_size)) == NULL) {
 496                      Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 497                      free_session(rctx);
 498                      rctx.extract = false;
 499                      bclose(&rctx.bfd);
 500                      continue;
 501                   }
 502                }
 503                rctx.flags |= FO_ENCRYPT;
 504             }
 505
 506             if (is_win32_stream(rctx.stream) && !have_win32_api()) {
 507                set_portable_backup(&rctx.bfd);
 508                rctx.flags |= FO_WIN32DECOMP;    /* "decompose" BackupWrite data */
 509             }
 510
 511             if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fileAddr,
 512                              rctx.flags, &rctx.cipher_ctx) < 0) {
 513                bclose(&rctx.bfd);
 514                continue;
 515             }
 516          }
 517          break;
 518
 519       /* Resource fork stream - only recorded after a file to be restored */
 520       /* Silently ignore if we cannot write - we already reported that */
 521       case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 522       case STREAM_MACOS_FORK_DATA:
 523 #ifdef HAVE_DARWIN_OS
 524          rctx.fork_flags = 0;
 525          jcr->ff->flags |= FO_HFSPLUS;
 526
 527          if (rctx.stream == STREAM_ENCRYPTED_MACOS_FORK_DATA) {
 528             rctx.fork_flags |= FO_ENCRYPT;
 529
 530             /* Set up a decryption context */
 531             if (rctx.extract && !rctx.fork_cipher_ctx.cipher) {
 532                if (!rctx.cs) {
 533                   Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 534                   rctx.extract = false;
 535                   bclose(&rctx.bfd);
 536                   continue;
 537                }
 538
 539                if ((rctx.fork_cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false, &rctx.fork_cipher_ctx.block_size)) == NULL) {
 540                   Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 541                   free_session(rctx);
 542                   rctx.extract = false;
 543                   bclose(&rctx.bfd);
 544                   continue;
 545                }
 546             }
 547          }
 548
 549          if (rctx.extract) {
 550             if (rctx.prev_stream != rctx.stream) {
 551                if (bopen_rsrc(&rctx.forkbfd, jcr->last_fname, O_WRONLY | O_TRUNC | O_BINARY, 0) < 0) {
 552                   Jmsg(jcr, M_ERROR, 0, _("     Cannot open resource fork for %s.\n"), jcr->last_fname);
 553                   rctx.extract = false;
 554                   continue;
 555                }
 556
 557                rctx.fork_size = rsrc_len;
 558                Dmsg0(130, "Restoring resource fork\n");
 559             }
 560
 561             if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fork_addr, rctx.fork_flags,
 562                              &rctx.fork_cipher_ctx) < 0) {
 563                bclose(&rctx.forkbfd);
 564                continue;
 565             }
 566          }
 567 #else
 568          non_support_rsrc++;
 569 #endif
 570          break;
 571
 572       case STREAM_HFSPLUS_ATTRIBUTES:
 573 #ifdef HAVE_DARWIN_OS
 574          Dmsg0(130, "Restoring Finder Info\n");
 575          jcr->ff->flags |= FO_HFSPLUS;
 576          if (sd->msglen != 32) {
 577             Jmsg(jcr, M_ERROR, 0, _("     Invalid length of Finder Info (got %d, not 32)\n"), sd->msglen);
 578             continue;
 579          }
 580          if (setattrlist(jcr->last_fname, &attrList, sd->msg, sd->msglen, 0) != 0) {
 581             Jmsg(jcr, M_ERROR, 0, _("     Could not set Finder Info on %s\n"), jcr->last_fname);
 582             continue;
 583          }
 584 #else
 585          non_support_finfo++;
 586 #endif
 587          break;
 588
 589       case STREAM_UNIX_ACCESS_ACL:
 590       case STREAM_UNIX_DEFAULT_ACL:
 591       case STREAM_ACL_AIX_TEXT:
 592       case STREAM_ACL_DARWIN_ACCESS_ACL:
 593       case STREAM_ACL_FREEBSD_DEFAULT_ACL:
 594       case STREAM_ACL_FREEBSD_ACCESS_ACL:
 595       case STREAM_ACL_HPUX_ACL_ENTRY:
 596       case STREAM_ACL_IRIX_DEFAULT_ACL:
 597       case STREAM_ACL_IRIX_ACCESS_ACL:
 598       case STREAM_ACL_LINUX_DEFAULT_ACL:
 599       case STREAM_ACL_LINUX_ACCESS_ACL:
 600       case STREAM_ACL_TRU64_DEFAULT_ACL:
 601       case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
 602       case STREAM_ACL_TRU64_ACCESS_ACL:
 603       case STREAM_ACL_SOLARIS_ACLENT:
 604       case STREAM_ACL_SOLARIS_ACE:
 605          /*
 606           * Do not restore ACLs when
 607           * a) The current file is not extracted
 608           * b)     and it is not a directory (they are never "extracted")
 609           * c) or the file name is empty
 610           */
 611          if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
 612             break;
 613          }
 614          if (have_acl) {
 615             pm_memcpy(jcr->acl_data->content, sd->msg, sd->msglen);
 616             jcr->acl_data->content_length = sd->msglen;
 617             switch (parse_acl_streams(jcr, rctx.stream)) {
 618             case bacl_exit_fatal:
 619                goto bail_out;
 620             case bacl_exit_error:
 621                /*
 622                 * Non-fatal errors, count them and when the number is under ACL_REPORT_ERR_MAX_PER_JOB
 623                 * print the error message set by the lower level routine in jcr->errmsg.
 624                 */
 625                if (jcr->acl_data->nr_errors < ACL_REPORT_ERR_MAX_PER_JOB) {
 626                   Qmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
 627                }
 628                jcr->acl_data->nr_errors++;
 629                break;
 630             case bacl_exit_ok:
 631                break;
 632             }
 633          } else {
 634             non_support_acl++;
 635          }
 636          break;
 637
 638       case STREAM_XATTR_SOLARIS_SYS:
 639       case STREAM_XATTR_SOLARIS:
 640       case STREAM_XATTR_DARWIN:
 641       case STREAM_XATTR_FREEBSD:
 642       case STREAM_XATTR_LINUX:
 643       case STREAM_XATTR_NETBSD:
 644          /*
 645           * Do not restore Extended Attributes when
 646           * a) The current file is not extracted
 647           * b)     and it is not a directory (they are never "extracted")
 648           * c) or the file name is empty
 649           */
 650          if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
 651             break;
 652          }
 653          if (have_xattr) {
 654             pm_memcpy(jcr->xattr_data->content, sd->msg, sd->msglen);
 655             jcr->xattr_data->content_length = sd->msglen;
 656             switch (parse_xattr_streams(jcr, rctx.stream)) {
 657             case bxattr_exit_fatal:
 658                goto bail_out;
 659             case bxattr_exit_error:
 660                /*
 661                 * Non-fatal errors, count them and when the number is under XATTR_REPORT_ERR_MAX_PER_JOB
 662                 * print the error message set by the lower level routine in jcr->errmsg.
 663                 */
 664                if (jcr->xattr_data->nr_errors < XATTR_REPORT_ERR_MAX_PER_JOB) {
 665                   Qmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
 666                }
 667                jcr->xattr_data->nr_errors++;
 668                break;
 669             case bxattr_exit_ok:
 670                break;
 671             }
 672          } else {
 673             non_support_xattr++;
 674          }
 675          break;
 676
 677       case STREAM_SIGNED_DIGEST:
 678          /* Is this an unexpected signature? */
 679          if (rctx.sig) {
 680             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic signature data stream.\n"));
 681             free_signature(rctx);
 682             continue;
 683          }
 684          /* Save signature. */
 685          if (rctx.extract && (rctx.sig = crypto_sign_decode(jcr, (uint8_t *)sd->msg, (uint32_t)sd->msglen)) == NULL) {
 686             Jmsg1(jcr, M_ERROR, 0, _("Failed to decode message signature for %s\n"), jcr->last_fname);
 687          }
 688          break;
 689
 690       case STREAM_MD5_DIGEST:
 691       case STREAM_SHA1_DIGEST:
 692       case STREAM_SHA256_DIGEST:
 693       case STREAM_SHA512_DIGEST:
 694          break;
 695
 696       case STREAM_PROGRAM_NAMES:
 697       case STREAM_PROGRAM_DATA:
 698          if (!non_support_progname) {
 699             Pmsg0(000, "Got Program Name or Data Stream. Ignored.\n");
 700             non_support_progname++;
 701          }
 702          break;
 703
 704       case STREAM_PLUGIN_NAME:
 705          close_previous_stream(rctx);
 706          Dmsg1(50, "restore stream_plugin_name=%s\n", sd->msg);
 707          plugin_name_stream(jcr, sd->msg);
 708          break;
 709
 710       default:
 711          close_previous_stream(rctx);
 712          Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"),
 713               rctx.stream);
 714          Dmsg2(0, "Unknown stream=%d data=%s\n", rctx.stream, sd->msg);
 715          break;
 716       } /* end switch(stream) */
 717
 718    } /* end while get_msg() */
 719
 720    /*
 721     * If output file is still open, it was the last one in the
 722     * archive since we just hit an end of file, so close the file.
 723     */
 724    if (is_bopen(&rctx.forkbfd)) {
 725       bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
 726    }
 727
 728    close_previous_stream(rctx);
 729    set_jcr_job_status(jcr, JS_Terminated);
 730    goto ok_out;
 731
 732 bail_out:
 733    set_jcr_job_status(jcr, JS_ErrorTerminated);
 734
 735 ok_out:
 736    /*
 737     * First output the statistics.
 738     */
 739    Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles,
 740       edit_uint64(jcr->JobBytes, ec1));
 741    if (jcr->acl_data->nr_errors > 0) {
 742       Jmsg(jcr, M_ERROR, 0, _("Encountered %ld acl errors while doing restore\n"),
 743            jcr->acl_data->nr_errors);
 744    }
 745    if (jcr->xattr_data->nr_errors > 0) {
 746       Jmsg(jcr, M_ERROR, 0, _("Encountered %ld xattr errors while doing restore\n"),
 747            jcr->xattr_data->nr_errors);
 748    }
 749    if (non_support_data > 1 || non_support_attr > 1) {
 750       Jmsg(jcr, M_ERROR, 0, _("%d non-supported data streams and %d non-supported attrib streams ignored.\n"),
 751          non_support_data, non_support_attr);
 752    }
 753    if (non_support_rsrc) {
 754       Jmsg(jcr, M_INFO, 0, _("%d non-supported resource fork streams ignored.\n"), non_support_rsrc);
 755    }
 756    if (non_support_finfo) {
 757       Jmsg(jcr, M_INFO, 0, _("%d non-supported Finder Info streams ignored.\n"), non_support_rsrc);
 758    }
 759    if (non_support_acl) {
 760       Jmsg(jcr, M_INFO, 0, _("%d non-supported acl streams ignored.\n"), non_support_acl);
 761    }
 762    if (non_support_crypto) {
 763       Jmsg(jcr, M_INFO, 0, _("%d non-supported crypto streams ignored.\n"), non_support_acl);
 764    }
 765    if (non_support_xattr) {
 766       Jmsg(jcr, M_INFO, 0, _("%d non-supported xattr streams ignored.\n"), non_support_xattr);
 767    }
 768
 769    /*
 770     * Free Signature & Crypto Data
 771     */
 772    free_signature(rctx);
 773    free_session(rctx);
 774    if (jcr->crypto.digest) {
 775       crypto_digest_free(jcr->crypto.digest);
 776       jcr->crypto.digest = NULL;
 777    }
 778
 779    /*
 780     * Free file cipher restore context
 781     */
 782    if (rctx.cipher_ctx.cipher) {
 783       crypto_cipher_free(rctx.cipher_ctx.cipher);
 784       rctx.cipher_ctx.cipher = NULL;
 785    }
 786
 787    if (rctx.cipher_ctx.buf) {
 788       free_pool_memory(rctx.cipher_ctx.buf);
 789       rctx.cipher_ctx.buf = NULL;
 790    }
 791
 792    /*
 793     * Free alternate stream cipher restore context
 794     */
 795    if (rctx.fork_cipher_ctx.cipher) {
 796       crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
 797       rctx.fork_cipher_ctx.cipher = NULL;
 798    }
 799    if (rctx.fork_cipher_ctx.buf) {
 800       free_pool_memory(rctx.fork_cipher_ctx.buf);
 801       rctx.fork_cipher_ctx.buf = NULL;
 802    }
 803
 804    if (jcr->compress_buf) {
 805       free(jcr->compress_buf);
 806       jcr->compress_buf = NULL;
 807       jcr->compress_buf_size = 0;
 808    }
 809
 810    if (have_acl && jcr->acl_data) {
 811       free_pool_memory(jcr->acl_data->content);
 812       free(jcr->acl_data);
 813       jcr->acl_data = NULL;
 814    }
 815
 816    if (have_xattr && jcr->xattr_data) {
 817       free_pool_memory(jcr->xattr_data->content);
 818       free(jcr->xattr_data);
 819       jcr->xattr_data = NULL;
 820    }
 821
 822    bclose(&rctx.forkbfd);
 823    bclose(&rctx.bfd);
 824    free_attr(rctx.attr);
 825 }
 826
 827 #ifdef HAVE_LIBZ
 828 /*
 829  * Convert ZLIB error code into an ASCII message
 830  */
 831 static const char *zlib_strerror(int stat)
 832 {
 833    if (stat >= 0) {
 834       return _("None");
 835    }
 836    switch (stat) {
 837    case Z_ERRNO:
 838       return _("Zlib errno");
 839    case Z_STREAM_ERROR:
 840       return _("Zlib stream error");
 841    case Z_DATA_ERROR:
 842       return _("Zlib data error");
 843    case Z_MEM_ERROR:
 844       return _("Zlib memory error");
 845    case Z_BUF_ERROR:
 846       return _("Zlib buffer error");
 847    case Z_VERSION_ERROR:
 848       return _("Zlib version error");
 849    default:
 850       return _("*none*");
 851    }
 852 }
 853 #endif
 854
 855 static int do_file_digest(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
 856 {
 857    Dmsg1(50, "do_file_digest jcr=%p\n", jcr);
 858    return (digest_file(jcr, ff_pkt, jcr->crypto.digest));
 859 }
 860
 861 /*
 862  * Verify the signature for the last restored file
 863  * Return value is either true (signature correct)
 864  * or false (signature could not be verified).
 865  * TODO landonf: Implement without using find_one_file and
 866  * without re-reading the file.
 867  */
 868 static bool verify_signature(JCR *jcr, r_ctx &rctx)
 869 {
 870    X509_KEYPAIR *keypair;
 871    DIGEST *digest = NULL;
 872    crypto_error_t err;
 873    uint64_t saved_bytes;
 874    crypto_digest_t signing_algorithm = have_sha2 ?
 875                                        CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
 876    crypto_digest_t algorithm;
 877    SIGNATURE *sig = rctx.sig;
 878
 879
 880    if (!jcr->crypto.pki_sign) {
 881       return true;                    /* no signature OK */
 882    }
 883    if (!sig) {
 884       if (rctx.type == FT_REGE || rctx.type == FT_REG || rctx.type == FT_RAW) {
 885          Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"),
 886                jcr->last_fname);
 887          goto bail_out;
 888       }
 889       return true;
 890    }
 891
 892    /* Iterate through the trusted signers */
 893    foreach_alist(keypair, jcr->crypto.pki_signers) {
 894       err = crypto_sign_get_digest(sig, jcr->crypto.pki_keypair, algorithm, &digest);
 895       switch (err) {
 896       case CRYPTO_ERROR_NONE:
 897          Dmsg0(50, "== Got digest\n");
 898          /*
 899           * We computed jcr->crypto.digest using signing_algorithm while writing
 900           * the file. If it is not the same as the algorithm used for
 901           * this file, punt by releasing the computed algorithm and
 902           * computing by re-reading the file.
 903           */
 904          if (algorithm != signing_algorithm) {
 905             if (jcr->crypto.digest) {
 906                crypto_digest_free(jcr->crypto.digest);
 907                jcr->crypto.digest = NULL;
 908             }
 909          }
 910          if (jcr->crypto.digest) {
 911              /* Use digest computed while writing the file to verify the signature */
 912             if ((err = crypto_sign_verify(sig, keypair, jcr->crypto.digest)) != CRYPTO_ERROR_NONE) {
 913                Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
 914                Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
 915                      jcr->last_fname, crypto_strerror(err));
 916                goto bail_out;
 917             }
 918          } else {
 919             /* Signature found, digest allocated.  Old method,
 920              * re-read the file and compute the digest
 921              */
 922             jcr->crypto.digest = digest;
 923
 924             /* Checksum the entire file */
 925             /* Make sure we don't modify JobBytes by saving and restoring it */
 926             saved_bytes = jcr->JobBytes;
 927             if (find_one_file(jcr, jcr->ff, do_file_digest, jcr->last_fname, (dev_t)-1, 1) != 0) {
 928                Jmsg(jcr, M_ERROR, 0, _("Digest one file failed for file: %s\n"),
 929                     jcr->last_fname);
 930                jcr->JobBytes = saved_bytes;
 931                goto bail_out;
 932             }
 933             jcr->JobBytes = saved_bytes;
 934
 935             /* Verify the signature */
 936             if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
 937                Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
 938                Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
 939                      jcr->last_fname, crypto_strerror(err));
 940                goto bail_out;
 941             }
 942             jcr->crypto.digest = NULL;
 943          }
 944
 945          /* Valid signature */
 946          Dmsg1(50, "Signature good on %s\n", jcr->last_fname);
 947          crypto_digest_free(digest);
 948          return true;
 949
 950       case CRYPTO_ERROR_NOSIGNER:
 951          /* Signature not found, try again */
 952          if (digest) {
 953             crypto_digest_free(digest);
 954             digest = NULL;
 955          }
 956          continue;
 957       default:
 958          /* Something strange happened (that shouldn't happen!)... */
 959          Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 960          goto bail_out;
 961       }
 962    }
 963
 964    /* No signer */
 965    Dmsg1(50, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
 966
 967 bail_out:
 968    if (digest) {
 969       crypto_digest_free(digest);
 970    }
 971    return false;
 972 }
 973
 974 bool sparse_data(JCR *jcr, BFILE *bfd, uint64_t *addr, char **data, uint32_t *length)
 975 {
 976       unser_declare;
 977       uint64_t faddr;
 978       char ec1[50];
 979       unser_begin(*data, SPARSE_FADDR_SIZE);
 980       unser_uint64(faddr);
 981       if (*addr != faddr) {
 982          *addr = faddr;
 983          if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
 984             berrno be;
 985             Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
 986                   edit_uint64(*addr, ec1), jcr->last_fname,
 987                   be.bstrerror(bfd->berrno));
 988             return false;
 989          }
 990       }
 991       *data += SPARSE_FADDR_SIZE;
 992       *length -= SPARSE_FADDR_SIZE;
 993       return true;
 994 }
 995
 996 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
 997 {
 998 #ifdef HAVE_LIBZ
 999    uLong compress_len;
1000    int stat;
1001    char ec1[50];                      /* Buffer printing huge values */
1002
1003    /*
1004     * NOTE! We only use uLong and Byte because they are
1005     *  needed by the zlib routines, they should not otherwise
1006     *  be used in Bacula.
1007     */
1008    compress_len = jcr->compress_buf_size;
1009    Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, *length);
1010    if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
1011                (const Byte *)*data, (uLong)*length)) != Z_OK) {
1012       Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
1013             jcr->last_fname, zlib_strerror(stat));
1014       return false;
1015    }
1016    *data = jcr->compress_buf;
1017    *length = compress_len;
1018    Dmsg2(200, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
1019    return true;
1020 #else
1021    Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
1022    return false;
1023 #endif
1024 }
1025
1026 static void unser_crypto_packet_len(RESTORE_CIPHER_CTX *ctx)
1027 {
1028    unser_declare;
1029    if (ctx->packet_len == 0 && ctx->buf_len >= CRYPTO_LEN_SIZE) {
1030       unser_begin(&ctx->buf[0], CRYPTO_LEN_SIZE);
1031       unser_uint32(ctx->packet_len);
1032       ctx->packet_len += CRYPTO_LEN_SIZE;
1033    }
1034 }
1035
1036 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
1037 {
1038    if (jcr->crypto.digest) {
1039       crypto_digest_update(jcr->crypto.digest, (uint8_t *)data, length);
1040    }
1041    if (win32_decomp) {
1042       if (!processWin32BackupAPIBlock(bfd, data, length)) {
1043          berrno be;
1044          Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
1045                jcr->last_fname, be.bstrerror(bfd->berrno));
1046          return false;
1047       }
1048    } else if (bwrite(bfd, data, length) != (ssize_t)length) {
1049       berrno be;
1050       Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
1051             jcr->last_fname, be.bstrerror(bfd->berrno));
1052       return false;
1053    }
1054
1055    return true;
1056 }
1057
1058 /*
1059  * In the context of jcr, write data to bfd.
1060  * We write buflen bytes in buf at addr. addr is updated in place.
1061  * The flags specify whether to use sparse files or compression.
1062  * Return value is the number of bytes written, or -1 on errors.
1063  */
1064 int32_t extract_data(JCR *jcr, r_ctx &rctx, POOLMEM *buf, int32_t buflen,
1065       uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx)
1066 {
1067    BFILE *bfd = &rctx.bfd;
1068    char *wbuf;                        /* write buffer */
1069    uint32_t wsize;                    /* write size */
1070    uint32_t rsize;                    /* read size */
1071    uint32_t decrypted_len = 0;        /* Decryption output length */
1072    char ec1[50];                      /* Buffer printing huge values */
1073
1074    rsize = buflen;
1075    jcr->ReadBytes += rsize;
1076    wsize = rsize;
1077    wbuf = buf;
1078
1079    if (flags & FO_ENCRYPT) {
1080       ASSERT(cipher_ctx->cipher);
1081
1082       /* NOTE: We must implement block preserving semantics for the
1083        * non-streaming compression and sparse code. */
1084
1085       /*
1086        * Grow the crypto buffer, if necessary.
1087        * crypto_cipher_update() will process only whole blocks,
1088        * buffering the remaining input.
1089        */
1090       cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf,
1091                         cipher_ctx->buf_len + wsize + cipher_ctx->block_size);
1092
1093       /* Decrypt the input block */
1094       if (!crypto_cipher_update(cipher_ctx->cipher,
1095                                 (const u_int8_t *)wbuf,
1096                                 wsize,
1097                                 (u_int8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1098                                 &decrypted_len)) {
1099          /* Decryption failed. Shouldn't happen. */
1100          Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
1101          goto bail_out;
1102       }
1103
1104       if (decrypted_len == 0) {
1105          /* No full block of encrypted data available, write more data */
1106          return 0;
1107       }
1108
1109       Dmsg2(200, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
1110
1111       cipher_ctx->buf_len += decrypted_len;
1112       wbuf = cipher_ctx->buf;
1113
1114       /* If one full preserved block is available, write it to disk,
1115        * and then buffer any remaining data. This should be effecient
1116        * as long as Bacula's block size is not significantly smaller than the
1117        * encryption block size (extremely unlikely!) */
1118       unser_crypto_packet_len(cipher_ctx);
1119       Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1120
1121       if (cipher_ctx->packet_len == 0 || cipher_ctx->buf_len < cipher_ctx->packet_len) {
1122          /* No full preserved block is available. */
1123          return 0;
1124       }
1125
1126       /* We have one full block, set up the filter input buffers */
1127       wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1128       wbuf = &wbuf[CRYPTO_LEN_SIZE]; /* Skip the block length header */
1129       cipher_ctx->buf_len -= cipher_ctx->packet_len;
1130       Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1131    }
1132
1133    if (flags & FO_SPARSE) {
1134       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1135          goto bail_out;
1136       }
1137    }
1138
1139    if (flags & FO_GZIP) {
1140       if (!decompress_data(jcr, &wbuf, &wsize)) {
1141          goto bail_out;
1142       }
1143    }
1144
1145    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1146       goto bail_out;
1147    }
1148    jcr->JobBytes += wsize;
1149    *addr += wsize;
1150    Dmsg2(130, "Write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1151
1152    /* Clean up crypto buffers */
1153    if (flags & FO_ENCRYPT) {
1154       /* Move any remaining data to start of buffer */
1155       if (cipher_ctx->buf_len > 0) {
1156          Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1157          memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1158             cipher_ctx->buf_len);
1159       }
1160       /* The packet was successfully written, reset the length so that the next
1161        * packet length may be re-read by unser_crypto_packet_len() */
1162       cipher_ctx->packet_len = 0;
1163    }
1164    return wsize;
1165
1166 bail_out:
1167    rctx.extract = false;
1168    return -1;
1169
1170 }
1171
1172
1173 /*
1174  * If extracting, close any previous stream
1175  */
1176 static void close_previous_stream(r_ctx &rctx)
1177 {
1178    /*
1179     * If extracting, it was from previous stream, so
1180     * close the output file and validate the signature.
1181     */
1182    if (rctx.extract) {
1183       if (rctx.size > 0 && !is_bopen(&rctx.bfd)) {
1184          Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
1185          Dmsg2(000, "=== logic error size=%d bopen=%d\n", rctx.size,
1186             is_bopen(&rctx.bfd));
1187       }
1188
1189       if (rctx.prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
1190          deallocate_cipher(rctx);
1191          deallocate_fork_cipher(rctx);
1192       }
1193
1194       if (rctx.jcr->plugin) {
1195          plugin_set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1196       } else {
1197          set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1198       }
1199       rctx.extract = false;
1200
1201       /* Verify the cryptographic signature, if any */
1202       rctx.type = rctx.attr->type;
1203       verify_signature(rctx.jcr, rctx);
1204
1205       /* Free Signature */
1206       free_signature(rctx);
1207       free_session(rctx);
1208       rctx.jcr->ff->flags = 0;
1209       Dmsg0(130, "Stop extracting.\n");
1210    } else if (is_bopen(&rctx.bfd)) {
1211       Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
1212       Dmsg0(000, "=== logic error !open\n");
1213       bclose(&rctx.bfd);
1214    }
1215 }
1216
1217
1218 /*
1219  * In the context of jcr, flush any remaining data from the cipher context,
1220  * writing it to bfd.
1221  * Return value is true on success, false on failure.
1222  */
1223 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
1224                   RESTORE_CIPHER_CTX *cipher_ctx)
1225 {
1226    uint32_t decrypted_len = 0;
1227    char *wbuf;                        /* write buffer */
1228    uint32_t wsize;                    /* write size */
1229    char ec1[50];                      /* Buffer printing huge values */
1230    bool second_pass = false;
1231
1232 again:
1233    /* Write out the remaining block and free the cipher context */
1234    cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf, cipher_ctx->buf_len +
1235                      cipher_ctx->block_size);
1236
1237    if (!crypto_cipher_finalize(cipher_ctx->cipher, (uint8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1238         &decrypted_len)) {
1239       /* Writing out the final, buffered block failed. Shouldn't happen. */
1240       Jmsg3(jcr, M_ERROR, 0, _("Decryption error. buf_len=%d decrypt_len=%d on file %s\n"),
1241             cipher_ctx->buf_len, decrypted_len, jcr->last_fname);
1242    }
1243
1244    Dmsg2(130, "Flush decrypt len=%d buf_len=%d\n", decrypted_len, cipher_ctx->buf_len);
1245    /* If nothing new was decrypted, and our output buffer is empty, return */
1246    if (decrypted_len == 0 && cipher_ctx->buf_len == 0) {
1247       return true;
1248    }
1249
1250    cipher_ctx->buf_len += decrypted_len;
1251
1252    unser_crypto_packet_len(cipher_ctx);
1253    Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1254    wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1255    wbuf = &cipher_ctx->buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
1256    cipher_ctx->buf_len -= cipher_ctx->packet_len;
1257    Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1258
1259    if (flags & FO_SPARSE) {
1260       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1261          return false;
1262       }
1263    }
1264
1265    if (flags & FO_GZIP) {
1266       if (!decompress_data(jcr, &wbuf, &wsize)) {
1267          return false;
1268       }
1269    }
1270
1271    Dmsg0(130, "Call store_data\n");
1272    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1273       return false;
1274    }
1275    jcr->JobBytes += wsize;
1276    Dmsg2(130, "Flush write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1277
1278    /* Move any remaining data to start of buffer */
1279    if (cipher_ctx->buf_len > 0) {
1280       Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1281       memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1282          cipher_ctx->buf_len);
1283    }
1284    /* The packet was successfully written, reset the length so that the next
1285     * packet length may be re-read by unser_crypto_packet_len() */
1286    cipher_ctx->packet_len = 0;
1287
1288    if (cipher_ctx->buf_len >0 && !second_pass) {
1289       second_pass = true;
1290       goto again;
1291    }
1292
1293    /* Stop decryption */
1294    cipher_ctx->buf_len = 0;
1295    cipher_ctx->packet_len = 0;
1296
1297    return true;
1298 }
1299
1300 static void deallocate_cipher(r_ctx &rctx)
1301 {
1302    /* Flush and deallocate previous stream's cipher context */
1303    if (rctx.cipher_ctx.cipher) {
1304       flush_cipher(rctx.jcr, &rctx.bfd, &rctx.fileAddr, rctx.flags, &rctx.cipher_ctx);
1305       crypto_cipher_free(rctx.cipher_ctx.cipher);
1306       rctx.cipher_ctx.cipher = NULL;
1307    }
1308 }
1309
1310 static void deallocate_fork_cipher(r_ctx &rctx)
1311 {
1312
1313    /* Flush and deallocate previous stream's fork cipher context */
1314    if (rctx.fork_cipher_ctx.cipher) {
1315       flush_cipher(rctx.jcr, &rctx.forkbfd, &rctx.fork_addr, rctx.fork_flags, &rctx.fork_cipher_ctx);
1316       crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
1317       rctx.fork_cipher_ctx.cipher = NULL;
1318    }
1319 }
1320
1321 static void free_signature(r_ctx &rctx)
1322 {
1323    if (rctx.sig) {
1324       crypto_sign_free(rctx.sig);
1325       rctx.sig = NULL;
1326    }
1327 }
1328
1329 static void free_session(r_ctx &rctx)
1330 {
1331    if (rctx.cs) {
1332       crypto_session_free(rctx.cs);
1333       rctx.cs = NULL;
1334    }
1335 }
1336
1337
1338 /* This code if implemented goes above */
1339 #ifdef stbernard_implemented
1340 /  #if defined(HAVE_WIN32)
1341    bool        bResumeOfmOnExit = FALSE;
1342    if (isOpenFileManagerRunning()) {
1343        if ( pauseOpenFileManager() ) {
1344           Jmsg(jcr, M_INFO, 0, _("Open File Manager paused\n") );
1345           bResumeOfmOnExit = TRUE;
1346        }
1347        else {
1348           Jmsg(jcr, M_ERROR, 0, _("FAILED to pause Open File Manager\n") );
1349        }
1350    }
1351    {
1352        char username[UNLEN+1];
1353        DWORD usize = sizeof(username);
1354        int privs = enable_backup_privileges(NULL, 1);
1355        if (GetUserName(username, &usize)) {
1356           Jmsg2(jcr, M_INFO, 0, _("Running as '%s'. Privmask=%#08x\n"), username,
1357        } else {
1358           Jmsg(jcr, M_WARNING, 0, _("Failed to retrieve current UserName\n"));
1359        }
1360    }
1361 #endif