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    jcr->acl_data = get_pool_memory(PM_MESSAGE);
 254    jcr->xattr_data = get_pool_memory(PM_MESSAGE);
 255
 256    while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
 257       /* Remember previous stream type */
 258       rctx.prev_stream = rctx.stream;
 259
 260       /* First we expect a Stream Record Header */
 261       if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
 262           &rctx.stream, &rctx.size) != 5) {
 263          Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
 264          goto bail_out;
 265       }
 266       Dmsg5(50, "Got hdr: Files=%d FilInx=%d size=%d Stream=%d, %s.\n",
 267             jcr->JobFiles, file_index, rctx.size, rctx.stream, stream_to_ascii(rctx.stream));
 268
 269       /* * Now we expect the Stream Data */
 270       if (bget_msg(sd) < 0) {
 271          Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), sd->bstrerror());
 272          goto bail_out;
 273       }
 274       if (rctx.size != (uint32_t)sd->msglen) {
 275          Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"),
 276                sd->msglen, rctx.size);
 277          Dmsg2(50, "Actual data size %d not same as header %d\n",
 278                sd->msglen, rctx.size);
 279          goto bail_out;
 280       }
 281       Dmsg3(130, "Got stream: %s len=%d extract=%d\n", stream_to_ascii(rctx.stream),
 282             sd->msglen, rctx.extract);
 283
 284       /* If we change streams, close and reset alternate data streams */
 285       if (rctx.prev_stream != rctx.stream) {
 286          if (is_bopen(&rctx.forkbfd)) {
 287             deallocate_fork_cipher(rctx);
 288             bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
 289          }
 290          rctx.fork_size = -1; /* Use an impossible value and set a proper one below */
 291          rctx.fork_addr = 0;
 292       }
 293
 294       /* File Attributes stream */
 295       switch (rctx.stream) {
 296       case STREAM_UNIX_ATTRIBUTES:
 297       case STREAM_UNIX_ATTRIBUTES_EX:
 298          close_previous_stream(rctx);     /* if any previous stream open, close it */
 299
 300
 301          /* TODO: manage deleted files */
 302          if (rctx.type == FT_DELETED) { /* deleted file */
 303             continue;
 304          }
 305
 306          /*
 307           * Unpack attributes and do sanity check them
 308           */
 309          if (!unpack_attributes_record(jcr, rctx.stream, sd->msg, attr)) {
 310             goto bail_out;
 311          }
 312 #ifdef xxx
 313          if (file_index != attr->file_index) {
 314             Jmsg(jcr, M_FATAL, 0, _("Record header file index %ld not equal record index %ld\n"),
 315                  file_index, attr->file_index);
 316             Dmsg0(200, "File index error\n");
 317             goto bail_out;
 318          }
 319 #endif
 320
 321          Dmsg3(200, "File %s\nattrib=%s\nattribsEx=%s\n", attr->fname,
 322                attr->attr, attr->attrEx);
 323
 324          attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
 325
 326          if (!is_restore_stream_supported(attr->data_stream)) {
 327             if (!non_support_data++) {
 328                Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
 329                   stream_to_ascii(attr->data_stream));
 330             }
 331             continue;
 332          }
 333
 334          build_attr_output_fnames(jcr, attr);
 335
 336          /*
 337           * Try to actually create the file, which returns a status telling
 338           *  us if we need to extract or not.
 339           */
 340          jcr->num_files_examined++;
 341          rctx.extract = false;
 342          if (jcr->plugin) {
 343             stat = plugin_create_file(jcr, attr, &rctx.bfd, jcr->replace);
 344          } else {
 345             stat = create_file(jcr, attr, &rctx.bfd, jcr->replace);
 346          }
 347          jcr->lock();
 348          pm_strcpy(jcr->last_fname, attr->ofname);
 349          jcr->last_type = attr->type;
 350          jcr->unlock();
 351          Dmsg2(130, "Outfile=%s create_file stat=%d\n", attr->ofname, stat);
 352          switch (stat) {
 353          case CF_ERROR:
 354          case CF_SKIP:
 355             pm_strcpy(jcr->last_fname, attr->ofname);
 356             jcr->last_type = attr->type;
 357             break;
 358          case CF_EXTRACT:        /* File created and we expect file data */
 359             rctx.extract = true;
 360             /* FALLTHROUGH */
 361          case CF_CREATED:        /* File created, but there is no content */
 362             jcr->JobFiles++;
 363             rctx.fileAddr = 0;
 364             print_ls_output(jcr, attr);
 365
 366             if (have_darwin_os) {
 367                /* Only restore the resource fork for regular files */
 368                from_base64(&rsrc_len, attr->attrEx);
 369                if (attr->type == FT_REG && rsrc_len > 0) {
 370                   rctx.extract = true;
 371                }
 372             }
 373             if (!rctx.extract) {
 374                /* set attributes now because file will not be extracted */
 375                if (jcr->plugin) {
 376                   plugin_set_attributes(jcr, attr, &rctx.bfd);
 377                } else {
 378                   set_attributes(jcr, attr, &rctx.bfd);
 379                }
 380             }
 381             break;
 382          }
 383          break;
 384
 385       /* Data stream */
 386       case STREAM_ENCRYPTED_SESSION_DATA:
 387          crypto_error_t cryptoerr;
 388
 389          /* Is this an unexpected session data entry? */
 390          if (rctx.cs) {
 391             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic session data stream.\n"));
 392             rctx.extract = false;
 393             bclose(&rctx.bfd);
 394             continue;
 395          }
 396
 397          /* Do we have any keys at all? */
 398          if (!jcr->crypto.pki_recipients) {
 399             Jmsg(jcr, M_ERROR, 0, _("No private decryption keys have been defined to decrypt encrypted backup data.\n"));
 400             rctx.extract = false;
 401             bclose(&rctx.bfd);
 402             break;
 403          }
 404
 405          if (jcr->crypto.digest) {
 406             crypto_digest_free(jcr->crypto.digest);
 407          }
 408          jcr->crypto.digest = crypto_digest_new(jcr, signing_algorithm);
 409          if (!jcr->crypto.digest) {
 410             Jmsg0(jcr, M_FATAL, 0, _("Could not create digest.\n"));
 411             rctx.extract = false;
 412             bclose(&rctx.bfd);
 413             break;
 414          }
 415
 416          /* Decode and save session keys. */
 417          cryptoerr = crypto_session_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen,
 418                         jcr->crypto.pki_recipients, &rctx.cs);
 419          switch(cryptoerr) {
 420          case CRYPTO_ERROR_NONE:
 421             /* Success */
 422             break;
 423          case CRYPTO_ERROR_NORECIPIENT:
 424             Jmsg(jcr, M_ERROR, 0, _("Missing private key required to decrypt encrypted backup data.\n"));
 425             break;
 426          case CRYPTO_ERROR_DECRYPTION:
 427             Jmsg(jcr, M_ERROR, 0, _("Decrypt of the session key failed.\n"));
 428             break;
 429          default:
 430             /* Shouldn't happen */
 431             Jmsg1(jcr, M_ERROR, 0, _("An error occurred while decoding encrypted session data stream: %s\n"), crypto_strerror(cryptoerr));
 432             break;
 433          }
 434
 435          if (cryptoerr != CRYPTO_ERROR_NONE) {
 436             rctx.extract = false;
 437             bclose(&rctx.bfd);
 438             continue;
 439          }
 440
 441          break;
 442
 443       case STREAM_FILE_DATA:
 444       case STREAM_SPARSE_DATA:
 445       case STREAM_WIN32_DATA:
 446       case STREAM_GZIP_DATA:
 447       case STREAM_SPARSE_GZIP_DATA:
 448       case STREAM_WIN32_GZIP_DATA:
 449       case STREAM_ENCRYPTED_FILE_DATA:
 450       case STREAM_ENCRYPTED_WIN32_DATA:
 451       case STREAM_ENCRYPTED_FILE_GZIP_DATA:
 452       case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
 453          /* Force an expected, consistent stream type here */
 454          if (rctx.extract && (rctx.prev_stream == rctx.stream
 455                          || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES
 456                          || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES_EX
 457                          || rctx.prev_stream == STREAM_ENCRYPTED_SESSION_DATA)) {
 458             rctx.flags = 0;
 459
 460             if (rctx.stream == STREAM_SPARSE_DATA ||
 461                 rctx.stream == STREAM_SPARSE_GZIP_DATA) {
 462                rctx.flags |= FO_SPARSE;
 463             }
 464
 465             if (rctx.stream == STREAM_GZIP_DATA
 466                   || rctx.stream == STREAM_SPARSE_GZIP_DATA
 467                   || rctx.stream == STREAM_WIN32_GZIP_DATA
 468                   || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 469                   || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 470                rctx.flags |= FO_GZIP;
 471             }
 472
 473             if (rctx.stream == STREAM_ENCRYPTED_FILE_DATA
 474                   || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 475                   || rctx.stream == STREAM_ENCRYPTED_WIN32_DATA
 476                   || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 477                /* Set up a decryption context */
 478                if (!rctx.cipher_ctx.cipher) {
 479                   if (!rctx.cs) {
 480                      Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 481                      rctx.extract = false;
 482                      bclose(&rctx.bfd);
 483                      continue;
 484                   }
 485
 486                   if ((rctx.cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false,
 487                            &rctx.cipher_ctx.block_size)) == NULL) {
 488                      Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 489                      free_session(rctx);
 490                      rctx.extract = false;
 491                      bclose(&rctx.bfd);
 492                      continue;
 493                   }
 494                }
 495                rctx.flags |= FO_ENCRYPT;
 496             }
 497
 498             if (is_win32_stream(rctx.stream) && !have_win32_api()) {
 499                set_portable_backup(&rctx.bfd);
 500                rctx.flags |= FO_WIN32DECOMP;    /* "decompose" BackupWrite data */
 501             }
 502
 503             if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fileAddr,
 504                              rctx.flags, &rctx.cipher_ctx) < 0) {
 505                bclose(&rctx.bfd);
 506                continue;
 507             }
 508          }
 509          break;
 510
 511       /* Resource fork stream - only recorded after a file to be restored */
 512       /* Silently ignore if we cannot write - we already reported that */
 513       case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 514       case STREAM_MACOS_FORK_DATA:
 515 #ifdef HAVE_DARWIN_OS
 516          rctx.fork_flags = 0;
 517          jcr->ff->flags |= FO_HFSPLUS;
 518
 519          if (rctx.stream == STREAM_ENCRYPTED_MACOS_FORK_DATA) {
 520             rctx.fork_flags |= FO_ENCRYPT;
 521
 522             /* Set up a decryption context */
 523             if (rctx.extract && !rctx.fork_cipher_ctx.cipher) {
 524                if (!rctx.cs) {
 525                   Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 526                   rctx.extract = false;
 527                   bclose(&rctx.bfd);
 528                   continue;
 529                }
 530
 531                if ((rctx.fork_cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false, &rctx.fork_cipher_ctx.block_size)) == NULL) {
 532                   Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 533                   free_session(rctx);
 534                   rctx.extract = false;
 535                   bclose(&rctx.bfd);
 536                   continue;
 537                }
 538             }
 539          }
 540
 541          if (rctx.extract) {
 542             if (rctx.prev_stream != rctx.stream) {
 543                if (bopen_rsrc(&rctx.forkbfd, jcr->last_fname, O_WRONLY | O_TRUNC | O_BINARY, 0) < 0) {
 544                   Jmsg(jcr, M_ERROR, 0, _("     Cannot open resource fork for %s.\n"), jcr->last_fname);
 545                   rctx.extract = false;
 546                   continue;
 547                }
 548
 549                rctx.fork_size = rsrc_len;
 550                Dmsg0(130, "Restoring resource fork\n");
 551             }
 552
 553             if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fork_addr, rctx.fork_flags,
 554                              &rctx.fork_cipher_ctx) < 0) {
 555                bclose(&rctx.forkbfd);
 556                continue;
 557             }
 558          }
 559 #else
 560          non_support_rsrc++;
 561 #endif
 562          break;
 563
 564       case STREAM_HFSPLUS_ATTRIBUTES:
 565 #ifdef HAVE_DARWIN_OS
 566          Dmsg0(130, "Restoring Finder Info\n");
 567          jcr->ff->flags |= FO_HFSPLUS;
 568          if (sd->msglen != 32) {
 569             Jmsg(jcr, M_ERROR, 0, _("     Invalid length of Finder Info (got %d, not 32)\n"), sd->msglen);
 570             continue;
 571          }
 572          if (setattrlist(jcr->last_fname, &attrList, sd->msg, sd->msglen, 0) != 0) {
 573             Jmsg(jcr, M_ERROR, 0, _("     Could not set Finder Info on %s\n"), jcr->last_fname);
 574             continue;
 575          }
 576 #else
 577          non_support_finfo++;
 578 #endif
 579          break;
 580
 581       case STREAM_UNIX_ACCESS_ACL:
 582       case STREAM_UNIX_DEFAULT_ACL:
 583       case STREAM_ACL_AIX_TEXT:
 584       case STREAM_ACL_DARWIN_ACCESS_ACL:
 585       case STREAM_ACL_FREEBSD_DEFAULT_ACL:
 586       case STREAM_ACL_FREEBSD_ACCESS_ACL:
 587       case STREAM_ACL_HPUX_ACL_ENTRY:
 588       case STREAM_ACL_IRIX_DEFAULT_ACL:
 589       case STREAM_ACL_IRIX_ACCESS_ACL:
 590       case STREAM_ACL_LINUX_DEFAULT_ACL:
 591       case STREAM_ACL_LINUX_ACCESS_ACL:
 592       case STREAM_ACL_TRU64_DEFAULT_ACL:
 593       case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
 594       case STREAM_ACL_TRU64_ACCESS_ACL:
 595       case STREAM_ACL_SOLARIS_ACLENT:
 596       case STREAM_ACL_SOLARIS_ACE:
 597          /*
 598           * Do not restore ACLs when
 599           * a) The current file is not extracted
 600           * b)     and it is not a directory (they are never "extracted")
 601           * c) or the file name is empty
 602           */
 603          if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
 604             break;
 605          }
 606          if (have_acl) {
 607             pm_memcpy(jcr->acl_data, sd->msg, sd->msglen);
 608             jcr->acl_data_len = sd->msglen;
 609             if (!parse_acl_stream(jcr, rctx.stream)) {
 610                Qmsg1(jcr, M_WARNING, 0, _("Can't restore ACLs of %s\n"), jcr->last_fname);
 611             }
 612          } else {
 613             non_support_acl++;
 614          }
 615          break;
 616
 617       case STREAM_XATTR_SOLARIS_SYS:
 618       case STREAM_XATTR_SOLARIS:
 619       case STREAM_XATTR_DARWIN:
 620       case STREAM_XATTR_FREEBSD:
 621       case STREAM_XATTR_LINUX:
 622          /*
 623           * Do not restore Extended Attributes when
 624           * a) The current file is not extracted
 625           * b)     and it is not a directory (they are never "extracted")
 626           * c) or the file name is empty
 627           */
 628          if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
 629             break;
 630          }
 631          if (have_xattr) {
 632             pm_memcpy(jcr->xattr_data, sd->msg, sd->msglen);
 633             jcr->xattr_data_len = sd->msglen;
 634             if (!parse_xattr_stream(jcr, rctx.stream)) {
 635                Qmsg1(jcr, M_WARNING, 0, _("Can't restore Extended Attributes of %s\n"), jcr->last_fname);
 636             }
 637          } else {
 638             non_support_xattr++;
 639          }
 640          break;
 641
 642       case STREAM_SIGNED_DIGEST:
 643          /* Is this an unexpected signature? */
 644          if (rctx.sig) {
 645             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic signature data stream.\n"));
 646             free_signature(rctx);
 647             continue;
 648          }
 649          /* Save signature. */
 650          if (rctx.extract && (rctx.sig = crypto_sign_decode(jcr, (uint8_t *)sd->msg, (uint32_t)sd->msglen)) == NULL) {
 651             Jmsg1(jcr, M_ERROR, 0, _("Failed to decode message signature for %s\n"), jcr->last_fname);
 652          }
 653          break;
 654
 655       case STREAM_MD5_DIGEST:
 656       case STREAM_SHA1_DIGEST:
 657       case STREAM_SHA256_DIGEST:
 658       case STREAM_SHA512_DIGEST:
 659          break;
 660
 661       case STREAM_PROGRAM_NAMES:
 662       case STREAM_PROGRAM_DATA:
 663          if (!non_support_progname) {
 664             Pmsg0(000, "Got Program Name or Data Stream. Ignored.\n");
 665             non_support_progname++;
 666          }
 667          break;
 668
 669       case STREAM_PLUGIN_NAME:
 670          close_previous_stream(rctx);
 671          Dmsg1(50, "restore stream_plugin_name=%s\n", sd->msg);
 672          plugin_name_stream(jcr, sd->msg);
 673          break;
 674
 675       default:
 676          close_previous_stream(rctx);
 677          Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"),
 678               rctx.stream);
 679          Dmsg2(0, "Unknown stream=%d data=%s\n", rctx.stream, sd->msg);
 680          break;
 681       } /* end switch(stream) */
 682
 683    } /* end while get_msg() */
 684
 685    /*
 686     * If output file is still open, it was the last one in the
 687     * archive since we just hit an end of file, so close the file.
 688     */
 689    if (is_bopen(&rctx.forkbfd)) {
 690       bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
 691    }
 692
 693    close_previous_stream(rctx);
 694    set_jcr_job_status(jcr, JS_Terminated);
 695    goto ok_out;
 696
 697 bail_out:
 698    set_jcr_job_status(jcr, JS_ErrorTerminated);
 699
 700 ok_out:
 701    /* Free Signature & Crypto Data */
 702    free_signature(rctx);
 703    free_session(rctx);
 704    if (jcr->crypto.digest) {
 705       crypto_digest_free(jcr->crypto.digest);
 706       jcr->crypto.digest = NULL;
 707    }
 708
 709    /* Free file cipher restore context */
 710    if (rctx.cipher_ctx.cipher) {
 711       crypto_cipher_free(rctx.cipher_ctx.cipher);
 712       rctx.cipher_ctx.cipher = NULL;
 713    }
 714    if (rctx.cipher_ctx.buf) {
 715       free_pool_memory(rctx.cipher_ctx.buf);
 716       rctx.cipher_ctx.buf = NULL;
 717    }
 718
 719    /* Free alternate stream cipher restore context */
 720    if (rctx.fork_cipher_ctx.cipher) {
 721       crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
 722       rctx.fork_cipher_ctx.cipher = NULL;
 723    }
 724    if (rctx.fork_cipher_ctx.buf) {
 725       free_pool_memory(rctx.fork_cipher_ctx.buf);
 726       rctx.fork_cipher_ctx.buf = NULL;
 727    }
 728
 729    if (jcr->compress_buf) {
 730       free(jcr->compress_buf);
 731       jcr->compress_buf = NULL;
 732       jcr->compress_buf_size = 0;
 733    }
 734
 735    if (jcr->xattr_data) {
 736       free_pool_memory(jcr->xattr_data);
 737       jcr->xattr_data = NULL;
 738    }
 739    if (jcr->acl_data) {
 740       free_pool_memory(jcr->acl_data);
 741       jcr->acl_data = NULL;
 742    }
 743
 744    bclose(&rctx.forkbfd);
 745    bclose(&rctx.bfd);
 746    free_attr(rctx.attr);
 747    Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles,
 748       edit_uint64(jcr->JobBytes, ec1));
 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
 771 #ifdef HAVE_LIBZ
 772 /*
 773  * Convert ZLIB error code into an ASCII message
 774  */
 775 static const char *zlib_strerror(int stat)
 776 {
 777    if (stat >= 0) {
 778       return _("None");
 779    }
 780    switch (stat) {
 781    case Z_ERRNO:
 782       return _("Zlib errno");
 783    case Z_STREAM_ERROR:
 784       return _("Zlib stream error");
 785    case Z_DATA_ERROR:
 786       return _("Zlib data error");
 787    case Z_MEM_ERROR:
 788       return _("Zlib memory error");
 789    case Z_BUF_ERROR:
 790       return _("Zlib buffer error");
 791    case Z_VERSION_ERROR:
 792       return _("Zlib version error");
 793    default:
 794       return _("*none*");
 795    }
 796 }
 797 #endif
 798
 799 static int do_file_digest(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
 800 {
 801    Dmsg1(50, "do_file_digest jcr=%p\n", jcr);
 802    return (digest_file(jcr, ff_pkt, jcr->crypto.digest));
 803 }
 804
 805 /*
 806  * Verify the signature for the last restored file
 807  * Return value is either true (signature correct)
 808  * or false (signature could not be verified).
 809  * TODO landonf: Implement without using find_one_file and
 810  * without re-reading the file.
 811  */
 812 static bool verify_signature(JCR *jcr, r_ctx &rctx)
 813 {
 814    X509_KEYPAIR *keypair;
 815    DIGEST *digest = NULL;
 816    crypto_error_t err;
 817    uint64_t saved_bytes;
 818    crypto_digest_t signing_algorithm = have_sha2 ?
 819                                        CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
 820    crypto_digest_t algorithm;
 821    SIGNATURE *sig = rctx.sig;
 822
 823
 824    if (!jcr->crypto.pki_sign) {
 825       return true;                    /* no signature OK */
 826    }
 827    if (!sig) {
 828       if (rctx.type == FT_REGE || rctx.type == FT_REG || rctx.type == FT_RAW) {
 829          Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"),
 830                jcr->last_fname);
 831          goto bail_out;
 832       }
 833       return true;
 834    }
 835
 836    /* Iterate through the trusted signers */
 837    foreach_alist(keypair, jcr->crypto.pki_signers) {
 838       err = crypto_sign_get_digest(sig, jcr->crypto.pki_keypair, algorithm, &digest);
 839       switch (err) {
 840       case CRYPTO_ERROR_NONE:
 841          Dmsg0(50, "== Got digest\n");
 842          /*
 843           * We computed jcr->crypto.digest using signing_algorithm while writing
 844           * the file. If it is not the same as the algorithm used for
 845           * this file, punt by releasing the computed algorithm and
 846           * computing by re-reading the file.
 847           */
 848          if (algorithm != signing_algorithm) {
 849             if (jcr->crypto.digest) {
 850                crypto_digest_free(jcr->crypto.digest);
 851                jcr->crypto.digest = NULL;
 852             }
 853          }
 854          if (jcr->crypto.digest) {
 855              /* Use digest computed while writing the file to verify the signature */
 856             if ((err = crypto_sign_verify(sig, keypair, jcr->crypto.digest)) != CRYPTO_ERROR_NONE) {
 857                Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
 858                Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
 859                      jcr->last_fname, crypto_strerror(err));
 860                goto bail_out;
 861             }
 862          } else {
 863             /* Signature found, digest allocated.  Old method,
 864              * re-read the file and compute the digest
 865              */
 866             jcr->crypto.digest = digest;
 867
 868             /* Checksum the entire file */
 869             /* Make sure we don't modify JobBytes by saving and restoring it */
 870             saved_bytes = jcr->JobBytes;
 871             if (find_one_file(jcr, jcr->ff, do_file_digest, jcr->last_fname, (dev_t)-1, 1) != 0) {
 872                Jmsg(jcr, M_ERROR, 0, _("Digest one file failed for file: %s\n"),
 873                     jcr->last_fname);
 874                jcr->JobBytes = saved_bytes;
 875                goto bail_out;
 876             }
 877             jcr->JobBytes = saved_bytes;
 878
 879             /* Verify the signature */
 880             if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
 881                Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
 882                Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
 883                      jcr->last_fname, crypto_strerror(err));
 884                goto bail_out;
 885             }
 886             jcr->crypto.digest = NULL;
 887          }
 888
 889          /* Valid signature */
 890          Dmsg1(50, "Signature good on %s\n", jcr->last_fname);
 891          crypto_digest_free(digest);
 892          return true;
 893
 894       case CRYPTO_ERROR_NOSIGNER:
 895          /* Signature not found, try again */
 896          if (digest) {
 897             crypto_digest_free(digest);
 898             digest = NULL;
 899          }
 900          continue;
 901       default:
 902          /* Something strange happened (that shouldn't happen!)... */
 903          Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 904          goto bail_out;
 905       }
 906    }
 907
 908    /* No signer */
 909    Dmsg1(50, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
 910
 911 bail_out:
 912    if (digest) {
 913       crypto_digest_free(digest);
 914    }
 915    return false;
 916 }
 917
 918 bool sparse_data(JCR *jcr, BFILE *bfd, uint64_t *addr, char **data, uint32_t *length)
 919 {
 920       unser_declare;
 921       uint64_t faddr;
 922       char ec1[50];
 923       unser_begin(*data, SPARSE_FADDR_SIZE);
 924       unser_uint64(faddr);
 925       if (*addr != faddr) {
 926          *addr = faddr;
 927          if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
 928             berrno be;
 929             Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
 930                   edit_uint64(*addr, ec1), jcr->last_fname,
 931                   be.bstrerror(bfd->berrno));
 932             return false;
 933          }
 934       }
 935       *data += SPARSE_FADDR_SIZE;
 936       *length -= SPARSE_FADDR_SIZE;
 937       return true;
 938 }
 939
 940 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
 941 {
 942 #ifdef HAVE_LIBZ
 943    uLong compress_len;
 944    int stat;
 945    char ec1[50];                      /* Buffer printing huge values */
 946
 947    /*
 948     * NOTE! We only use uLong and Byte because they are
 949     *  needed by the zlib routines, they should not otherwise
 950     *  be used in Bacula.
 951     */
 952    compress_len = jcr->compress_buf_size;
 953    Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, *length);
 954    if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
 955                (const Byte *)*data, (uLong)*length)) != Z_OK) {
 956       Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
 957             jcr->last_fname, zlib_strerror(stat));
 958       return false;
 959    }
 960    *data = jcr->compress_buf;
 961    *length = compress_len;
 962    Dmsg2(200, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
 963    return true;
 964 #else
 965    Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
 966    return false;
 967 #endif
 968 }
 969
 970 static void unser_crypto_packet_len(RESTORE_CIPHER_CTX *ctx)
 971 {
 972    unser_declare;
 973    if (ctx->packet_len == 0 && ctx->buf_len >= CRYPTO_LEN_SIZE) {
 974       unser_begin(&ctx->buf[0], CRYPTO_LEN_SIZE);
 975       unser_uint32(ctx->packet_len);
 976       ctx->packet_len += CRYPTO_LEN_SIZE;
 977    }
 978 }
 979
 980 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
 981 {
 982    if (jcr->crypto.digest) {
 983       crypto_digest_update(jcr->crypto.digest, (uint8_t *)data, length);
 984    }
 985    if (win32_decomp) {
 986       if (!processWin32BackupAPIBlock(bfd, data, length)) {
 987          berrno be;
 988          Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
 989                jcr->last_fname, be.bstrerror(bfd->berrno));
 990          return false;
 991       }
 992    } else if (bwrite(bfd, data, length) != (ssize_t)length) {
 993       berrno be;
 994       Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
 995             jcr->last_fname, be.bstrerror(bfd->berrno));
 996       return false;
 997    }
 998
 999    return true;
1000 }
1001
1002 /*
1003  * In the context of jcr, write data to bfd.
1004  * We write buflen bytes in buf at addr. addr is updated in place.
1005  * The flags specify whether to use sparse files or compression.
1006  * Return value is the number of bytes written, or -1 on errors.
1007  */
1008 int32_t extract_data(JCR *jcr, r_ctx &rctx, POOLMEM *buf, int32_t buflen,
1009       uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx)
1010 {
1011    BFILE *bfd = &rctx.bfd;
1012    char *wbuf;                        /* write buffer */
1013    uint32_t wsize;                    /* write size */
1014    uint32_t rsize;                    /* read size */
1015    uint32_t decrypted_len = 0;        /* Decryption output length */
1016    char ec1[50];                      /* Buffer printing huge values */
1017
1018    rsize = buflen;
1019    jcr->ReadBytes += rsize;
1020    wsize = rsize;
1021    wbuf = buf;
1022
1023    if (flags & FO_ENCRYPT) {
1024       ASSERT(cipher_ctx->cipher);
1025
1026       /* NOTE: We must implement block preserving semantics for the
1027        * non-streaming compression and sparse code. */
1028
1029       /*
1030        * Grow the crypto buffer, if necessary.
1031        * crypto_cipher_update() will process only whole blocks,
1032        * buffering the remaining input.
1033        */
1034       cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf,
1035                         cipher_ctx->buf_len + wsize + cipher_ctx->block_size);
1036
1037       /* Decrypt the input block */
1038       if (!crypto_cipher_update(cipher_ctx->cipher,
1039                                 (const u_int8_t *)wbuf,
1040                                 wsize,
1041                                 (u_int8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1042                                 &decrypted_len)) {
1043          /* Decryption failed. Shouldn't happen. */
1044          Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
1045          goto bail_out;
1046       }
1047
1048       if (decrypted_len == 0) {
1049          /* No full block of encrypted data available, write more data */
1050          return 0;
1051       }
1052
1053       Dmsg2(200, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
1054
1055       cipher_ctx->buf_len += decrypted_len;
1056       wbuf = cipher_ctx->buf;
1057
1058       /* If one full preserved block is available, write it to disk,
1059        * and then buffer any remaining data. This should be effecient
1060        * as long as Bacula's block size is not significantly smaller than the
1061        * encryption block size (extremely unlikely!) */
1062       unser_crypto_packet_len(cipher_ctx);
1063       Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1064
1065       if (cipher_ctx->packet_len == 0 || cipher_ctx->buf_len < cipher_ctx->packet_len) {
1066          /* No full preserved block is available. */
1067          return 0;
1068       }
1069
1070       /* We have one full block, set up the filter input buffers */
1071       wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1072       wbuf = &wbuf[CRYPTO_LEN_SIZE]; /* Skip the block length header */
1073       cipher_ctx->buf_len -= cipher_ctx->packet_len;
1074       Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1075    }
1076
1077    if (flags & FO_SPARSE) {
1078       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1079          goto bail_out;
1080       }
1081    }
1082
1083    if (flags & FO_GZIP) {
1084       if (!decompress_data(jcr, &wbuf, &wsize)) {
1085          goto bail_out;
1086       }
1087    }
1088
1089    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1090       goto bail_out;
1091    }
1092    jcr->JobBytes += wsize;
1093    *addr += wsize;
1094    Dmsg2(130, "Write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1095
1096    /* Clean up crypto buffers */
1097    if (flags & FO_ENCRYPT) {
1098       /* Move any remaining data to start of buffer */
1099       if (cipher_ctx->buf_len > 0) {
1100          Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1101          memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1102             cipher_ctx->buf_len);
1103       }
1104       /* The packet was successfully written, reset the length so that the next
1105        * packet length may be re-read by unser_crypto_packet_len() */
1106       cipher_ctx->packet_len = 0;
1107    }
1108    return wsize;
1109
1110 bail_out:
1111    rctx.extract = false;
1112    return -1;
1113
1114 }
1115
1116
1117 /*
1118  * If extracting, close any previous stream
1119  */
1120 static void close_previous_stream(r_ctx &rctx)
1121 {
1122    /*
1123     * If extracting, it was from previous stream, so
1124     * close the output file and validate the signature.
1125     */
1126    if (rctx.extract) {
1127       if (rctx.size > 0 && !is_bopen(&rctx.bfd)) {
1128          Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
1129          Dmsg2(000, "=== logic error size=%d bopen=%d\n", rctx.size,
1130             is_bopen(&rctx.bfd));
1131       }
1132
1133       if (rctx.prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
1134          deallocate_cipher(rctx);
1135          deallocate_fork_cipher(rctx);
1136       }
1137
1138       if (rctx.jcr->plugin) {
1139          plugin_set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1140       } else {
1141          set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1142       }
1143       rctx.extract = false;
1144
1145       /* Verify the cryptographic signature, if any */
1146       rctx.type = rctx.attr->type;
1147       verify_signature(rctx.jcr, rctx);
1148
1149       /* Free Signature */
1150       free_signature(rctx);
1151       free_session(rctx);
1152       rctx.jcr->ff->flags = 0;
1153       Dmsg0(130, "Stop extracting.\n");
1154    } else if (is_bopen(&rctx.bfd)) {
1155       Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
1156       Dmsg0(000, "=== logic error !open\n");
1157       bclose(&rctx.bfd);
1158    }
1159 }
1160
1161
1162 /*
1163  * In the context of jcr, flush any remaining data from the cipher context,
1164  * writing it to bfd.
1165  * Return value is true on success, false on failure.
1166  */
1167 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
1168                   RESTORE_CIPHER_CTX *cipher_ctx)
1169 {
1170    uint32_t decrypted_len = 0;
1171    char *wbuf;                        /* write buffer */
1172    uint32_t wsize;                    /* write size */
1173    char ec1[50];                      /* Buffer printing huge values */
1174    bool second_pass = false;
1175
1176 again:
1177    /* Write out the remaining block and free the cipher context */
1178    cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf, cipher_ctx->buf_len +
1179                      cipher_ctx->block_size);
1180
1181    if (!crypto_cipher_finalize(cipher_ctx->cipher, (uint8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1182         &decrypted_len)) {
1183       /* Writing out the final, buffered block failed. Shouldn't happen. */
1184       Jmsg3(jcr, M_ERROR, 0, _("Decryption error. buf_len=%d decrypt_len=%d on file %s\n"),
1185             cipher_ctx->buf_len, decrypted_len, jcr->last_fname);
1186    }
1187
1188    Dmsg2(130, "Flush decrypt len=%d buf_len=%d\n", decrypted_len, cipher_ctx->buf_len);
1189    /* If nothing new was decrypted, and our output buffer is empty, return */
1190    if (decrypted_len == 0 && cipher_ctx->buf_len == 0) {
1191       return true;
1192    }
1193
1194    cipher_ctx->buf_len += decrypted_len;
1195
1196    unser_crypto_packet_len(cipher_ctx);
1197    Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1198    wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1199    wbuf = &cipher_ctx->buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
1200    cipher_ctx->buf_len -= cipher_ctx->packet_len;
1201    Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1202
1203    if (flags & FO_SPARSE) {
1204       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1205          return false;
1206       }
1207    }
1208
1209    if (flags & FO_GZIP) {
1210       if (!decompress_data(jcr, &wbuf, &wsize)) {
1211          return false;
1212       }
1213    }
1214
1215    Dmsg0(130, "Call store_data\n");
1216    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1217       return false;
1218    }
1219    jcr->JobBytes += wsize;
1220    Dmsg2(130, "Flush write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1221
1222    /* Move any remaining data to start of buffer */
1223    if (cipher_ctx->buf_len > 0) {
1224       Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1225       memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1226          cipher_ctx->buf_len);
1227    }
1228    /* The packet was successfully written, reset the length so that the next
1229     * packet length may be re-read by unser_crypto_packet_len() */
1230    cipher_ctx->packet_len = 0;
1231
1232    if (cipher_ctx->buf_len >0 && !second_pass) {
1233       second_pass = true;
1234       goto again;
1235    }
1236
1237    /* Stop decryption */
1238    cipher_ctx->buf_len = 0;
1239    cipher_ctx->packet_len = 0;
1240
1241    return true;
1242 }
1243
1244 static void deallocate_cipher(r_ctx &rctx)
1245 {
1246    /* Flush and deallocate previous stream's cipher context */
1247    if (rctx.cipher_ctx.cipher) {
1248       flush_cipher(rctx.jcr, &rctx.bfd, &rctx.fileAddr, rctx.flags, &rctx.cipher_ctx);
1249       crypto_cipher_free(rctx.cipher_ctx.cipher);
1250       rctx.cipher_ctx.cipher = NULL;
1251    }
1252 }
1253
1254 static void deallocate_fork_cipher(r_ctx &rctx)
1255 {
1256
1257    /* Flush and deallocate previous stream's fork cipher context */
1258    if (rctx.fork_cipher_ctx.cipher) {
1259       flush_cipher(rctx.jcr, &rctx.forkbfd, &rctx.fork_addr, rctx.fork_flags, &rctx.fork_cipher_ctx);
1260       crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
1261       rctx.fork_cipher_ctx.cipher = NULL;
1262    }
1263 }
1264
1265 static void free_signature(r_ctx &rctx)
1266 {
1267    if (rctx.sig) {
1268       crypto_sign_free(rctx.sig);
1269       rctx.sig = NULL;
1270    }
1271 }
1272
1273 static void free_session(r_ctx &rctx)
1274 {
1275    if (rctx.cs) {
1276       crypto_session_free(rctx.cs);
1277       rctx.cs = NULL;
1278    }
1279 }
1280
1281
1282 /* This code if implemented goes above */
1283 #ifdef stbernard_implemented
1284 /  #if defined(HAVE_WIN32)
1285    bool        bResumeOfmOnExit = FALSE;
1286    if (isOpenFileManagerRunning()) {
1287        if ( pauseOpenFileManager() ) {
1288           Jmsg(jcr, M_INFO, 0, _("Open File Manager paused\n") );
1289           bResumeOfmOnExit = TRUE;
1290        }
1291        else {
1292           Jmsg(jcr, M_ERROR, 0, _("FAILED to pause Open File Manager\n") );
1293        }
1294    }
1295    {
1296        char username[UNLEN+1];
1297        DWORD usize = sizeof(username);
1298        int privs = enable_backup_privileges(NULL, 1);
1299        if (GetUserName(username, &usize)) {
1300           Jmsg2(jcr, M_INFO, 0, _("Running as '%s'. Privmask=%#08x\n"), username,
1301        } else {
1302           Jmsg(jcr, M_WARNING, 0, _("Failed to retrieve current UserName\n"));
1303        }
1304    }
1305 #endif