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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2007 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 plus additions
  11    that are listed 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 John Walker.
  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 #endif
  43
  44 #if defined(HAVE_CRYPTO)
  45 const bool have_crypto = true;
  46 #else
  47 const bool have_crypto = false;
  48 #endif
  49
  50 /* Data received from Storage Daemon */
  51 static char rec_header[] = "rechdr %ld %ld %ld %ld %ld";
  52
  53 /* Forward referenced functions */
  54 #if   defined(HAVE_LIBZ)
  55 static const char *zlib_strerror(int stat);
  56 const bool have_libz = true;
  57 #else
  58 const bool have_libz = false;
  59 #endif
  60
  61 typedef struct restore_cipher_ctx {
  62    CIPHER_CONTEXT *cipher;
  63    uint32_t block_size;
  64
  65    POOLMEM *buf;       /* Pointer to descryption buffer */
  66    int32_t buf_len;    /* Count of bytes currently in buf */
  67    int32_t packet_len; /* Total bytes in packet */
  68 } RESTORE_CIPHER_CTX;
  69
  70 int verify_signature(JCR *jcr, SIGNATURE *sig);
  71 int32_t extract_data(JCR *jcr, BFILE *bfd, POOLMEM *buf, int32_t buflen,
  72       uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx);
  73 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx);
  74
  75 #define RETRY 10                      /* retry wait time */
  76
  77 /*
  78  * Close a bfd check that we are at the expected file offset.
  79  * Makes some code in set_attributes().
  80  */
  81 int bclose_chksize(JCR *jcr, BFILE *bfd, boffset_t osize)
  82 {
  83    char ec1[50], ec2[50];
  84    boffset_t fsize;
  85
  86    fsize = blseek(bfd, 0, SEEK_CUR);
  87    bclose(bfd);                              /* first close file */
  88    if (fsize > 0 && fsize != osize) {
  89       Qmsg3(jcr, M_ERROR, 0, _("Size of data or stream of %s not correct. Original %s, restored %s.\n"),
  90             jcr->last_fname, edit_uint64(osize, ec1),
  91             edit_uint64(fsize, ec2));
  92       return -1;
  93    }
  94    return 0;
  95 }
  96
  97 /*
  98  * Restore the requested files.
  99  *
 100  */
 101 void do_restore(JCR *jcr)
 102 {
 103    BSOCK *sd;
 104    int32_t stream = 0;
 105    int32_t prev_stream;
 106    uint32_t VolSessionId, VolSessionTime;
 107    bool extract = false;
 108    int32_t file_index;
 109    char ec1[50];                       /* Buffer printing huge values */
 110    BFILE bfd;                          /* File content */
 111    uint64_t fileAddr = 0;              /* file write address */
 112    uint32_t size;                      /* Size of file */
 113    BFILE altbfd;                       /* Alternative data stream */
 114    uint64_t alt_addr = 0;              /* Write address for alternative stream */
 115    intmax_t alt_size = 0;              /* Size of alternate stream */
 116    SIGNATURE *sig = NULL;              /* Cryptographic signature (if any) for file */
 117    CRYPTO_SESSION *cs = NULL;          /* Cryptographic session data (if any) for file */
 118    RESTORE_CIPHER_CTX cipher_ctx;     /* Cryptographic restore context (if any) for file */
 119    RESTORE_CIPHER_CTX alt_cipher_ctx; /* Cryptographic restore context (if any) for alternative stream */
 120    int flags = 0;                      /* Options for extract_data() */
 121    int alt_flags = 0;                  /* Options for extract_data() */
 122    int stat;
 123    ATTR *attr;
 124
 125    /* The following variables keep track of "known unknowns" */
 126    int non_support_data = 0;
 127    int non_support_attr = 0;
 128    int non_support_rsrc = 0;
 129    int non_support_finfo = 0;
 130    int non_support_acl = 0;
 131    int non_support_progname = 0;
 132
 133    /* Finally, set up for special configurations */
 134 #ifdef HAVE_DARWIN_OS
 135    intmax_t rsrc_len = 0;             /* Original length of resource fork */
 136    struct attrlist attrList;
 137
 138    memset(&attrList, 0, sizeof(attrList));
 139    attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
 140    attrList.commonattr = ATTR_CMN_FNDRINFO;
 141 #endif
 142
 143    sd = jcr->store_bsock;
 144    set_jcr_job_status(jcr, JS_Running);
 145
 146    LockRes();
 147    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
 148    UnlockRes();
 149    uint32_t buf_size;
 150    if (client) {
 151       buf_size = client->max_network_buffer_size;
 152    } else {
 153       buf_size = 0;                   /* use default */
 154    }
 155    if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
 156       set_jcr_job_status(jcr, JS_ErrorTerminated);
 157       return;
 158    }
 159    jcr->buf_size = sd->msglen;
 160
 161 #ifdef stbernard_implemented
 162 /  #if defined(HAVE_WIN32)
 163    bool        bResumeOfmOnExit = FALSE;
 164    if (isOpenFileManagerRunning()) {
 165        if ( pauseOpenFileManager() ) {
 166           Jmsg(jcr, M_INFO, 0, _("Open File Manager paused\n") );
 167           bResumeOfmOnExit = TRUE;
 168        }
 169        else {
 170           Jmsg(jcr, M_ERROR, 0, _("FAILED to pause Open File Manager\n") );
 171        }
 172    }
 173    {
 174        char username[UNLEN+1];
 175        DWORD usize = sizeof(username);
 176        int privs = enable_backup_privileges(NULL, 1);
 177        if (GetUserName(username, &usize)) {
 178           Jmsg2(jcr, M_INFO, 0, _("Running as '%s'. Privmask=%#08x\n"), username,
 179        } else {
 180           Jmsg(jcr, M_WARNING, 0, _("Failed to retrieve current UserName\n"));
 181        }
 182    }
 183 #endif
 184
 185    if (have_libz) {
 186       uint32_t compress_buf_size = jcr->buf_size + 12 + ((jcr->buf_size+999) / 1000) + 100;
 187       jcr->compress_buf = (char *)bmalloc(compress_buf_size);
 188       jcr->compress_buf_size = compress_buf_size;
 189    }
 190
 191    cipher_ctx.cipher = NULL;
 192    alt_cipher_ctx.cipher = NULL;
 193    if (have_crypto) {
 194       cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 195       cipher_ctx.buf_len = 0;
 196       cipher_ctx.packet_len = 0;
 197
 198       alt_cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 199       alt_cipher_ctx.buf_len = 0;
 200       alt_cipher_ctx.packet_len = 0;
 201    } else {
 202       cipher_ctx.buf = NULL;
 203       alt_cipher_ctx.buf = NULL;
 204    }
 205
 206    /*
 207     * Get a record from the Storage daemon. We are guaranteed to
 208     *   receive records in the following order:
 209     *   1. Stream record header
 210     *   2. Stream data
 211     *        a. Attributes (Unix or Win32)
 212     *        b. Possibly stream encryption session data (e.g., symmetric session key)
 213     *    or  c. File data for the file
 214     *    or  d. Alternate data stream (e.g. Resource Fork)
 215     *    or  e. Finder info
 216     *    or  f. ACLs
 217     *    or  g. Possibly a cryptographic signature
 218     *    or  h. Possibly MD5 or SHA1 record
 219     *   3. Repeat step 1
 220     *
 221     * NOTE: We keep track of two bacula file descriptors:
 222     *   1. bfd for file data.
 223     *      This fd is opened for non empty files when an attribute stream is
 224     *      encountered and closed when we find the next attribute stream.
 225     *   2. alt_bfd for alternate data streams
 226     *      This fd is opened every time we encounter a new alternate data
 227     *      stream for the current file. When we find any other stream, we
 228     *      close it again.
 229     *      The expected size of the stream, alt_len, should be set when
 230     *      opening the fd.
 231     */
 232    binit(&bfd);
 233    binit(&altbfd);
 234    attr = new_attr();
 235    jcr->acl_text = get_pool_memory(PM_MESSAGE);
 236
 237    while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
 238       /* Remember previous stream type */
 239       prev_stream = stream;
 240
 241       /* First we expect a Stream Record Header */
 242       if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
 243           &stream, &size) != 5) {
 244          Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
 245          goto bail_out;
 246       }
 247       Dmsg4(30, "Got hdr: Files=%d FilInx=%d Stream=%d, %s.\n",
 248             jcr->JobFiles, file_index, stream, stream_to_ascii(stream));
 249
 250       /* * Now we expect the Stream Data */
 251       if (bget_msg(sd) < 0) {
 252          Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), bnet_strerror(sd));
 253          goto bail_out;
 254       }
 255       if (size != (uint32_t)sd->msglen) {
 256          Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"), sd->msglen, size);
 257          goto bail_out;
 258       }
 259       Dmsg3(30, "Got stream: %s len=%d extract=%d\n", stream_to_ascii(stream),
 260             sd->msglen, extract);
 261
 262       /* If we change streams, close and reset alternate data streams */
 263       if (prev_stream != stream) {
 264          if (is_bopen(&altbfd)) {
 265             if (alt_cipher_ctx.cipher) {
 266                flush_cipher(jcr, &altbfd, &alt_addr, alt_flags, &alt_cipher_ctx);
 267                crypto_cipher_free(alt_cipher_ctx.cipher);
 268                alt_cipher_ctx.cipher = NULL;
 269             }
 270             bclose_chksize(jcr, &altbfd, alt_size);
 271          }
 272          alt_size = -1; /* Use an impossible value and set a proper one below */
 273          alt_addr = 0;
 274       }
 275
 276       /* File Attributes stream */
 277       switch (stream) {
 278       case STREAM_UNIX_ATTRIBUTES:
 279       case STREAM_UNIX_ATTRIBUTES_EX:
 280          /*
 281           * If extracting, it was from previous stream, so
 282           * close the output file and validate the signature.
 283           */
 284          if (extract) {
 285             if (size > 0 && !is_bopen(&bfd)) {
 286                Jmsg0(jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
 287             }
 288             /* Flush and deallocate previous stream's cipher context */
 289             if (cipher_ctx.cipher && prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
 290                flush_cipher(jcr, &bfd, &fileAddr, flags, &cipher_ctx);
 291                crypto_cipher_free(cipher_ctx.cipher);
 292                cipher_ctx.cipher = NULL;
 293             }
 294
 295             /* Flush and deallocate previous stream's alt cipher context */
 296             if (alt_cipher_ctx.cipher && prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
 297                flush_cipher(jcr, &altbfd, &alt_addr, alt_flags, &alt_cipher_ctx);
 298                crypto_cipher_free(alt_cipher_ctx.cipher);
 299                alt_cipher_ctx.cipher = NULL;
 300             }
 301             set_attributes(jcr, attr, &bfd);
 302             extract = false;
 303
 304             /* Verify the cryptographic signature, if any */
 305             if (jcr->pki_sign) {
 306                if (sig) {
 307                   // Failure is reported in verify_signature() ...
 308                   verify_signature(jcr, sig);
 309                } else {
 310                   Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"), jcr->last_fname);
 311                }
 312             }
 313             /* Free Signature */
 314             if (sig) {
 315                crypto_sign_free(sig);
 316                sig = NULL;
 317             }
 318             if (cs) {
 319                crypto_session_free(cs);
 320                cs = NULL;
 321             }
 322             jcr->ff->flags = 0;
 323             Dmsg0(30, "Stop extracting.\n");
 324          } else if (is_bopen(&bfd)) {
 325             Jmsg0(jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
 326             bclose(&bfd);
 327          }
 328
 329          /*
 330           * Unpack and do sanity check fo attributes.
 331           */
 332          if (!unpack_attributes_record(jcr, stream, sd->msg, attr)) {
 333             goto bail_out;
 334          }
 335          if (file_index != attr->file_index) {
 336             Jmsg(jcr, M_FATAL, 0, _("Record header file index %ld not equal record index %ld\n"),
 337                  file_index, attr->file_index);
 338             Dmsg0(100, "File index error\n");
 339             goto bail_out;
 340          }
 341
 342          Dmsg3(200, "File %s\nattrib=%s\nattribsEx=%s\n", attr->fname,
 343                attr->attr, attr->attrEx);
 344
 345          attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
 346
 347          if (!is_restore_stream_supported(attr->data_stream)) {
 348             if (!non_support_data++) {
 349                Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
 350                   stream_to_ascii(attr->data_stream));
 351             }
 352             continue;
 353          }
 354
 355          build_attr_output_fnames(jcr, attr);
 356
 357          /*
 358           * Now determine if we are extracting or not.
 359           */
 360          jcr->num_files_examined++;
 361          extract = false;
 362          stat = create_file(jcr, attr, &bfd, jcr->replace);
 363          Dmsg2(30, "Outfile=%s create_file stat=%d\n", attr->ofname, stat);
 364          switch (stat) {
 365          case CF_ERROR:
 366          case CF_SKIP:
 367             break;
 368          case CF_EXTRACT:        /* File created and we expect file data */
 369             extract = true;
 370             /* FALLTHROUGH */
 371          case CF_CREATED:        /* File created, but there is no content */
 372             jcr->lock();
 373             pm_strcpy(jcr->last_fname, attr->ofname);
 374             jcr->last_type = attr->type;
 375             jcr->JobFiles++;
 376             jcr->unlock();
 377             fileAddr = 0;
 378             print_ls_output(jcr, attr);
 379
 380 #ifdef HAVE_DARWIN_OS
 381             /* Only restore the resource fork for regular files */
 382             from_base64(&rsrc_len, attr->attrEx);
 383             if (attr->type == FT_REG && rsrc_len > 0) {
 384                extract = true;
 385             }
 386 #endif
 387             if (!extract) {
 388                /* set attributes now because file will not be extracted */
 389                set_attributes(jcr, attr, &bfd);
 390             }
 391             break;
 392          }
 393          break;
 394
 395       /* Data stream */
 396       case STREAM_ENCRYPTED_SESSION_DATA:
 397          crypto_error_t cryptoerr;
 398
 399          /* Is this an unexpected session data entry? */
 400          if (cs) {
 401             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic session data stream.\n"));
 402             extract = false;
 403             bclose(&bfd);
 404             continue;
 405          }
 406
 407          /* Do we have any keys at all? */
 408          if (!jcr->pki_recipients) {
 409             Jmsg(jcr, M_ERROR, 0, _("No private decryption keys have been defined to decrypt encrypted backup data.\n"));
 410             extract = false;
 411             bclose(&bfd);
 412             break;
 413          }
 414
 415          /* Decode and save session keys. */
 416          cryptoerr = crypto_session_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen, jcr->pki_recipients, &cs);
 417          switch(cryptoerr) {
 418          case CRYPTO_ERROR_NONE:
 419             /* Success */
 420             break;
 421          case CRYPTO_ERROR_NORECIPIENT:
 422             Jmsg(jcr, M_ERROR, 0, _("Missing private key required to decrypt encrypted backup data.\n"));
 423             break;
 424          case CRYPTO_ERROR_DECRYPTION:
 425             Jmsg(jcr, M_ERROR, 0, _("Decrypt of the session key failed.\n"));
 426             break;
 427          default:
 428             /* Shouldn't happen */
 429             Jmsg1(jcr, M_ERROR, 0, _("An error occurred while decoding encrypted session data stream: %s\n"), crypto_strerror(cryptoerr));
 430             break;
 431          }
 432
 433          if (cryptoerr != CRYPTO_ERROR_NONE) {
 434             extract = false;
 435             bclose(&bfd);
 436             continue;
 437          }
 438
 439          /* Set up a decryption context */
 440          if ((cipher_ctx.cipher = crypto_cipher_new(cs, false, &cipher_ctx.block_size)) == NULL) {
 441             Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 442             crypto_session_free(cs);
 443             cs = NULL;
 444             extract = false;
 445             bclose(&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 (extract && (prev_stream == stream || prev_stream == STREAM_UNIX_ATTRIBUTES
 463                   || prev_stream == STREAM_UNIX_ATTRIBUTES_EX
 464                   || prev_stream == STREAM_ENCRYPTED_SESSION_DATA)) {
 465             flags = 0;
 466
 467             if (stream == STREAM_SPARSE_DATA || stream == STREAM_SPARSE_GZIP_DATA) {
 468                flags |= FO_SPARSE;
 469             }
 470
 471             if (stream == STREAM_GZIP_DATA || stream == STREAM_SPARSE_GZIP_DATA
 472                   || stream == STREAM_WIN32_GZIP_DATA || stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 473                   || stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 474                flags |= FO_GZIP;
 475             }
 476
 477             if (stream == STREAM_ENCRYPTED_FILE_DATA
 478                   || stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 479                   || stream == STREAM_ENCRYPTED_WIN32_DATA
 480                   || stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 481                if (!cipher_ctx.cipher) {
 482                   Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 483                   extract = false;
 484                   bclose(&bfd);
 485                   continue;
 486                }
 487                flags |= FO_ENCRYPT;
 488             }
 489
 490             if (is_win32_stream(stream) && !have_win32_api()) {
 491                set_portable_backup(&bfd);
 492                flags |= FO_WIN32DECOMP;    /* "decompose" BackupWrite data */
 493             }
 494
 495             if (extract_data(jcr, &bfd, sd->msg, sd->msglen, &fileAddr, flags,
 496                              &cipher_ctx) < 0) {
 497                extract = false;
 498                bclose(&bfd);
 499                continue;
 500             }
 501          }
 502          break;
 503
 504       /* Resource fork stream - only recorded after a file to be restored */
 505       /* Silently ignore if we cannot write - we already reported that */
 506       case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 507       case STREAM_MACOS_FORK_DATA:
 508 #ifdef HAVE_DARWIN_OS
 509          alt_flags = 0;
 510          jcr->ff->flags |= FO_HFSPLUS;
 511
 512          if (stream == STREAM_ENCRYPTED_MACOS_FORK_DATA) {
 513             alt_flags |= FO_ENCRYPT;
 514
 515             /* Set up a decryption context */
 516             if (extract && !alt_cipher_ctx.cipher) {
 517                if (!cs) {
 518                   Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 519                   extract = false;
 520                   bclose(&bfd);
 521                   continue;
 522                }
 523
 524                if ((alt_cipher_ctx.cipher = crypto_cipher_new(cs, false, &alt_cipher_ctx.block_size)) == NULL) {
 525                   Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 526                   crypto_session_free(cs);
 527                   cs = NULL;
 528                   extract = false;
 529                   bclose(&bfd);
 530                   continue;
 531                }
 532             }
 533          }
 534
 535          if (extract) {
 536             if (prev_stream != stream) {
 537                if (bopen_rsrc(&altbfd, jcr->last_fname, O_WRONLY | O_TRUNC | O_BINARY, 0) < 0) {
 538                   Jmsg(jcr, M_ERROR, 0, _("     Cannot open resource fork for %s.\n"), jcr->last_fname);
 539                   extract = false;
 540                   continue;
 541                }
 542
 543                alt_size = rsrc_len;
 544                Dmsg0(30, "Restoring resource fork\n");
 545             }
 546
 547             if (extract_data(jcr, &altbfd, sd->msg, sd->msglen, &alt_addr, alt_flags,
 548                              &alt_cipher_ctx) < 0) {
 549                extract = false;
 550                bclose(&altbfd);
 551                continue;
 552             }
 553          }
 554 #else
 555          non_support_rsrc++;
 556 #endif
 557          break;
 558
 559       case STREAM_HFSPLUS_ATTRIBUTES:
 560 #ifdef HAVE_DARWIN_OS
 561          Dmsg0(30, "Restoring Finder Info\n");
 562          jcr->ff->flags |= FO_HFSPLUS;
 563          if (sd->msglen != 32) {
 564             Jmsg(jcr, M_ERROR, 0, _("     Invalid length of Finder Info (got %d, not 32)\n"), sd->msglen);
 565             continue;
 566          }
 567          if (setattrlist(jcr->last_fname, &attrList, sd->msg, sd->msglen, 0) != 0) {
 568             Jmsg(jcr, M_ERROR, 0, _("     Could not set Finder Info on %s\n"), jcr->last_fname);
 569             continue;
 570          }
 571 #else
 572          non_support_finfo++;
 573 #endif
 574          break;
 575
 576       case STREAM_UNIX_ATTRIBUTES_ACCESS_ACL:
 577 #ifdef HAVE_ACL
 578          pm_strcpy(jcr->acl_text, sd->msg);
 579          Dmsg2(400, "Restoring ACL type 0x%2x <%s>\n", BACL_TYPE_ACCESS, jcr->acl_text);
 580          if (bacl_set(jcr, BACL_TYPE_ACCESS) != 0) {
 581                Qmsg1(jcr, M_WARNING, 0, _("Can't restore ACL of %s\n"), jcr->last_fname);
 582          }
 583 #else
 584          non_support_acl++;
 585 #endif
 586          break;
 587
 588       case STREAM_UNIX_ATTRIBUTES_DEFAULT_ACL:
 589 #ifdef HAVE_ACL
 590          pm_strcpy(jcr->acl_text, sd->msg);
 591          Dmsg2(400, "Restoring ACL type 0x%2x <%s>\n", BACL_TYPE_DEFAULT, jcr->acl_text);
 592          if (bacl_set(jcr, BACL_TYPE_DEFAULT) != 0) {
 593                Qmsg1(jcr, M_WARNING, 0, _("Can't restore default ACL of %s\n"), jcr->last_fname);
 594          }
 595 #else
 596          non_support_acl++;
 597 #endif
 598          break;
 599
 600       case STREAM_SIGNED_DIGEST:
 601
 602          /* Is this an unexpected signature? */
 603          if (sig) {
 604             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic signature data stream.\n"));
 605             continue;
 606          }
 607
 608          /* Save signature. */
 609          if (extract && (sig = crypto_sign_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen)) == NULL) {
 610             Jmsg1(jcr, M_ERROR, 0, _("Failed to decode message signature for %s\n"), jcr->last_fname);
 611          }
 612          break;
 613
 614       case STREAM_MD5_DIGEST:
 615       case STREAM_SHA1_DIGEST:
 616       case STREAM_SHA256_DIGEST:
 617       case STREAM_SHA512_DIGEST:
 618          break;
 619
 620       case STREAM_PROGRAM_NAMES:
 621       case STREAM_PROGRAM_DATA:
 622          if (!non_support_progname) {
 623             Pmsg0(000, "Got Program Name or Data Stream. Ignored.\n");
 624             non_support_progname++;
 625          }
 626          break;
 627
 628       default:
 629          /* If extracting, wierd stream (not 1 or 2), close output file anyway */
 630          if (extract) {
 631             Dmsg1(30, "Found wierd stream %d\n", stream);
 632             if (size > 0 && !is_bopen(&bfd)) {
 633                Jmsg0(jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
 634             }
 635             /* Flush and deallocate cipher context */
 636             if (cipher_ctx.cipher) {
 637                flush_cipher(jcr, &bfd, &fileAddr, flags, &cipher_ctx);
 638                crypto_cipher_free(cipher_ctx.cipher);
 639                cipher_ctx.cipher = NULL;
 640             }
 641
 642             /* Flush and deallocate alt cipher context */
 643             if (alt_cipher_ctx.cipher) {
 644                flush_cipher(jcr, &altbfd, &alt_addr, alt_flags, &alt_cipher_ctx);
 645                crypto_cipher_free(alt_cipher_ctx.cipher);
 646                alt_cipher_ctx.cipher = NULL;
 647             }
 648
 649             set_attributes(jcr, attr, &bfd);
 650
 651             /* Verify the cryptographic signature if any */
 652             if (jcr->pki_sign) {
 653                if (sig) {
 654                   // Failure is reported in verify_signature() ...
 655                   verify_signature(jcr, sig);
 656                } else {
 657                   Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"), jcr->last_fname);
 658                }
 659             }
 660
 661             extract = false;
 662          } else if (is_bopen(&bfd)) {
 663             Jmsg0(jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
 664             bclose(&bfd);
 665          }
 666          Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"), stream);
 667          Dmsg2(0, "None of above!!! stream=%d data=%s\n", stream,sd->msg);
 668          break;
 669       } /* end switch(stream) */
 670
 671    } /* end while get_msg() */
 672
 673    /* If output file is still open, it was the last one in the
 674     * archive since we just hit an end of file, so close the file.
 675     */
 676    if (is_bopen(&altbfd)) {
 677       bclose_chksize(jcr, &altbfd, alt_size);
 678    }
 679    if (extract) {
 680       /* Flush and deallocate cipher context */
 681       if (cipher_ctx.cipher) {
 682          flush_cipher(jcr, &bfd, &fileAddr, flags, &cipher_ctx);
 683          crypto_cipher_free(cipher_ctx.cipher);
 684          cipher_ctx.cipher = NULL;
 685       }
 686
 687       /* Flush and deallocate alt cipher context */
 688       if (alt_cipher_ctx.cipher) {
 689          flush_cipher(jcr, &altbfd, &alt_addr, alt_flags, &alt_cipher_ctx);
 690          crypto_cipher_free(alt_cipher_ctx.cipher);
 691          alt_cipher_ctx.cipher = NULL;
 692       }
 693
 694       set_attributes(jcr, attr, &bfd);
 695
 696       /* Verify the cryptographic signature on the last file, if any */
 697       if (jcr->pki_sign) {
 698          if (sig) {
 699             // Failure is reported in verify_signature() ...
 700             verify_signature(jcr, sig);
 701          } else {
 702             Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"), jcr->last_fname);
 703          }
 704       }
 705    }
 706
 707    if (is_bopen(&bfd)) {
 708       bclose(&bfd);
 709    }
 710
 711    set_jcr_job_status(jcr, JS_Terminated);
 712    goto ok_out;
 713
 714 bail_out:
 715    set_jcr_job_status(jcr, JS_ErrorTerminated);
 716
 717 ok_out:
 718    /* Free Signature & Crypto Data */
 719    if (sig) {
 720       crypto_sign_free(sig);
 721       sig = NULL;
 722    }
 723    if (cs) {
 724       crypto_session_free(cs);
 725       cs = NULL;
 726    }
 727
 728    /* Free file cipher restore context */
 729    if (cipher_ctx.cipher) {
 730       crypto_cipher_free(cipher_ctx.cipher);
 731       cipher_ctx.cipher = NULL;
 732    }
 733    if (cipher_ctx.buf) {
 734       free_pool_memory(cipher_ctx.buf);
 735       cipher_ctx.buf = NULL;
 736    }
 737
 738    /* Free alternate stream cipher restore context */
 739    if (alt_cipher_ctx.cipher) {
 740       crypto_cipher_free(alt_cipher_ctx.cipher);
 741       alt_cipher_ctx.cipher = NULL;
 742    }
 743    if (alt_cipher_ctx.buf) {
 744       free_pool_memory(alt_cipher_ctx.buf);
 745       alt_cipher_ctx.buf = NULL;
 746    }
 747
 748    if (jcr->compress_buf) {
 749       free(jcr->compress_buf);
 750       jcr->compress_buf = NULL;
 751       jcr->compress_buf_size = 0;
 752    }
 753    bclose(&altbfd);
 754    bclose(&bfd);
 755    free_attr(attr);
 756    free_pool_memory(jcr->acl_text);
 757    Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles,
 758       edit_uint64(jcr->JobBytes, ec1));
 759    if (non_support_data > 1 || non_support_attr > 1) {
 760       Jmsg(jcr, M_ERROR, 0, _("%d non-supported data streams and %d non-supported attrib streams ignored.\n"),
 761          non_support_data, non_support_attr);
 762    }
 763    if (non_support_rsrc) {
 764       Jmsg(jcr, M_INFO, 0, _("%d non-supported resource fork streams ignored.\n"), non_support_rsrc);
 765    }
 766    if (non_support_finfo) {
 767       Jmsg(jcr, M_INFO, 0, _("%d non-supported Finder Info streams ignored.\n"), non_support_rsrc);
 768    }
 769    if (non_support_acl) {
 770       Jmsg(jcr, M_INFO, 0, _("%d non-supported acl streams ignored.\n"), non_support_acl);
 771    }
 772
 773 }
 774
 775 #ifdef HAVE_LIBZ
 776 /*
 777  * Convert ZLIB error code into an ASCII message
 778  */
 779 static const char *zlib_strerror(int stat)
 780 {
 781    if (stat >= 0) {
 782       return _("None");
 783    }
 784    switch (stat) {
 785    case Z_ERRNO:
 786       return _("Zlib errno");
 787    case Z_STREAM_ERROR:
 788       return _("Zlib stream error");
 789    case Z_DATA_ERROR:
 790       return _("Zlib data error");
 791    case Z_MEM_ERROR:
 792       return _("Zlib memory error");
 793    case Z_BUF_ERROR:
 794       return _("Zlib buffer error");
 795    case Z_VERSION_ERROR:
 796       return _("Zlib version error");
 797    default:
 798       return _("*none*");
 799    }
 800 }
 801 #endif
 802
 803 static int do_file_digest(FF_PKT *ff_pkt, void *pkt, bool top_level)
 804 {
 805    JCR *jcr = (JCR *)pkt;
 806    return (digest_file(jcr, ff_pkt, jcr->digest));
 807 }
 808
 809 /*
 810  * Verify the signature for the last restored file
 811  * Return value is either true (signature correct)
 812  * or false (signature could not be verified).
 813  * TODO landonf: Implement without using find_one_file and
 814  * without re-reading the file.
 815  */
 816 int verify_signature(JCR *jcr, SIGNATURE *sig)
 817 {
 818    X509_KEYPAIR *keypair;
 819    DIGEST *digest = NULL;
 820    crypto_error_t err;
 821    uint64_t saved_bytes;
 822
 823    /* Iterate through the trusted signers */
 824    foreach_alist(keypair, jcr->pki_signers) {
 825       err = crypto_sign_get_digest(sig, jcr->pki_keypair, &digest);
 826
 827       switch (err) {
 828       case CRYPTO_ERROR_NONE:
 829          /* Signature found, digest allocated */
 830          jcr->digest = digest;
 831
 832          /* Checksum the entire file */
 833          /* Make sure we don't modify JobBytes by saving and restoring it */
 834          saved_bytes = jcr->JobBytes;
 835          if (find_one_file(jcr, jcr->ff, do_file_digest, jcr, jcr->last_fname, (dev_t)-1, 1) != 0) {
 836             Jmsg(jcr, M_ERROR, 0, _("Signature validation failed for %s: \n"), jcr->last_fname);
 837             jcr->JobBytes = saved_bytes;
 838             return false;
 839          }
 840          jcr->JobBytes = saved_bytes;
 841
 842          /* Verify the signature */
 843          if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
 844             Dmsg1(100, "Bad signature on %s\n", jcr->last_fname);
 845             Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 846             crypto_digest_free(digest);
 847             return false;
 848          }
 849
 850          /* Valid signature */
 851          Dmsg1(100, "Signature good on %s\n", jcr->last_fname);
 852          crypto_digest_free(digest);
 853          return true;
 854
 855       case CRYPTO_ERROR_NOSIGNER:
 856          /* Signature not found, try again */
 857          continue;
 858       default:
 859          /* Something strange happened (that shouldn't happen!)... */
 860          Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 861          if (digest) {
 862             crypto_digest_free(digest);
 863          }
 864          return false;
 865       }
 866    }
 867
 868    /* No signer */
 869    Dmsg1(100, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
 870    crypto_digest_free(digest);
 871    return false;
 872 }
 873
 874 bool sparse_data(JCR *jcr, BFILE *bfd, uint64_t *addr, char **data, uint32_t *length)
 875 {
 876       unser_declare;
 877       uint64_t faddr;
 878       char ec1[50];
 879       unser_begin(*data, SPARSE_FADDR_SIZE);
 880       unser_uint64(faddr);
 881       if (*addr != faddr) {
 882          *addr = faddr;
 883          if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
 884             berrno be;
 885             Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
 886                   edit_uint64(*addr, ec1), jcr->last_fname,
 887                   be.strerror(bfd->berrno));
 888             return false;
 889          }
 890       }
 891       *data += SPARSE_FADDR_SIZE;
 892       *length -= SPARSE_FADDR_SIZE;
 893       return true;
 894 }
 895
 896 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
 897 {
 898 #ifdef HAVE_LIBZ
 899    uLong compress_len;
 900    int stat;
 901    char ec1[50];                      /* Buffer printing huge values */
 902
 903    /*
 904     * NOTE! We only use uLong and Byte because they are
 905     *  needed by the zlib routines, they should not otherwise
 906     *  be used in Bacula.
 907     */
 908    compress_len = jcr->compress_buf_size;
 909    Dmsg2(100, "Comp_len=%d msglen=%d\n", compress_len, *length);
 910    if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
 911                (const Byte *)*data, (uLong)*length)) != Z_OK) {
 912       Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
 913             jcr->last_fname, zlib_strerror(stat));
 914       return false;
 915    }
 916    *data = jcr->compress_buf;
 917    *length = compress_len;
 918    Dmsg2(100, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
 919    return true;
 920 #else
 921    Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
 922    return false;
 923 #endif
 924 }
 925
 926 static void unser_crypto_packet_len(RESTORE_CIPHER_CTX *ctx)
 927 {
 928    unser_declare;
 929    if (ctx->packet_len == 0 && ctx->buf_len >= CRYPTO_LEN_SIZE) {
 930       unser_begin(&ctx->buf[0], CRYPTO_LEN_SIZE);
 931       unser_uint32(ctx->packet_len);
 932       ctx->packet_len += CRYPTO_LEN_SIZE;
 933    }
 934 }
 935
 936 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
 937 {
 938    if (win32_decomp) {
 939       if (!processWin32BackupAPIBlock(bfd, data, length)) {
 940          berrno be;
 941          Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
 942                jcr->last_fname, be.strerror(bfd->berrno));
 943          return false;
 944       }
 945    } else if (bwrite(bfd, data, length) != (ssize_t)length) {
 946       berrno be;
 947       Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
 948             jcr->last_fname, be.strerror(bfd->berrno));
 949       return false;
 950    }
 951
 952    return true;
 953 }
 954
 955 /*
 956  * In the context of jcr, write data to bfd.
 957  * We write buflen bytes in buf at addr. addr is updated in place.
 958  * The flags specify whether to use sparse files or compression.
 959  * Return value is the number of bytes written, or -1 on errors.
 960  */
 961 int32_t extract_data(JCR *jcr, BFILE *bfd, POOLMEM *buf, int32_t buflen,
 962       uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx)
 963 {
 964    char *wbuf;                        /* write buffer */
 965    uint32_t wsize;                    /* write size */
 966    uint32_t rsize;                    /* read size */
 967    uint32_t decrypted_len = 0;        /* Decryption output length */
 968    char ec1[50];                      /* Buffer printing huge values */
 969
 970    rsize = buflen;
 971    jcr->ReadBytes += rsize;
 972    wsize = rsize;
 973    wbuf = buf;
 974
 975    if (flags & FO_ENCRYPT) {
 976       ASSERT(cipher_ctx->cipher);
 977
 978       /* NOTE: We must implement block preserving semantics for the
 979        * non-streaming compression and sparse code. */
 980
 981       /*
 982        * Grow the crypto buffer, if necessary.
 983        * crypto_cipher_update() will process only whole blocks,
 984        * buffering the remaining input.
 985        */
 986       cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf,
 987                         cipher_ctx->buf_len + wsize + cipher_ctx->block_size);
 988
 989       /* Decrypt the input block */
 990       if (!crypto_cipher_update(cipher_ctx->cipher,
 991                                 (const u_int8_t *)wbuf,
 992                                 wsize,
 993                                 (u_int8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
 994                                 &decrypted_len)) {
 995          /* Decryption failed. Shouldn't happen. */
 996          Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
 997          return -1;
 998       }
 999
1000       if (decrypted_len == 0) {
1001          /* No full block of encrypted data available, write more data */
1002          return 0;
1003       }
1004
1005       Dmsg2(100, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
1006
1007       cipher_ctx->buf_len += decrypted_len;
1008       wbuf = cipher_ctx->buf;
1009
1010       /* If one full preserved block is available, write it to disk,
1011        * and then buffer any remaining data. This should be effecient
1012        * as long as Bacula's block size is not significantly smaller than the
1013        * encryption block size (extremely unlikely!) */
1014       unser_crypto_packet_len(cipher_ctx);
1015       Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1016
1017       if (cipher_ctx->packet_len == 0 || cipher_ctx->buf_len < cipher_ctx->packet_len) {
1018          /* No full preserved block is available. */
1019          return 0;
1020       }
1021
1022       /* We have one full block, set up the filter input buffers */
1023       wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1024       wbuf = &wbuf[CRYPTO_LEN_SIZE]; /* Skip the block length header */
1025       cipher_ctx->buf_len -= cipher_ctx->packet_len;
1026       Dmsg2(30, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1027    }
1028
1029    if (flags & FO_SPARSE) {
1030       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1031          return -1;
1032       }
1033    }
1034
1035    if (flags & FO_GZIP) {
1036       if (!decompress_data(jcr, &wbuf, &wsize)) {
1037          return -1;
1038       }
1039    }
1040
1041    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1042       return -1;
1043    }
1044    jcr->JobBytes += wsize;
1045    *addr += wsize;
1046    Dmsg2(30, "Write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1047
1048    /* Clean up crypto buffers */
1049    if (flags & FO_ENCRYPT) {
1050       /* Move any remaining data to start of buffer */
1051       if (cipher_ctx->buf_len > 0) {
1052          Dmsg1(30, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1053          memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1054             cipher_ctx->buf_len);
1055       }
1056       /* The packet was successfully written, reset the length so that the next
1057        * packet length may be re-read by unser_crypto_packet_len() */
1058       cipher_ctx->packet_len = 0;
1059    }
1060
1061    return wsize;
1062 }
1063
1064 /*
1065  * In the context of jcr, flush any remaining data from the cipher context,
1066  * writing it to bfd.
1067  * Return value is true on success, false on failure.
1068  */
1069 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
1070                   RESTORE_CIPHER_CTX *cipher_ctx)
1071 {
1072    uint32_t decrypted_len;
1073    char *wbuf;                        /* write buffer */
1074    uint32_t wsize;                    /* write size */
1075    char ec1[50];                      /* Buffer printing huge values */
1076    bool second_pass = false;
1077
1078 again:
1079    /* Write out the remaining block and free the cipher context */
1080    cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf, cipher_ctx->buf_len +
1081                      cipher_ctx->block_size);
1082
1083    if (!crypto_cipher_finalize(cipher_ctx->cipher, (uint8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1084         &decrypted_len)) {
1085       /* Writing out the final, buffered block failed. Shouldn't happen. */
1086       Jmsg1(jcr, M_FATAL, 0, _("Decryption error for %s\n"), jcr->last_fname);
1087    }
1088
1089    Dmsg2(30, "Flush decrypt len=%d buf_len=%d\n", decrypted_len, cipher_ctx->buf_len);
1090    /* If nothing new was decrypted, and our output buffer is empty, return */
1091    if (decrypted_len == 0 && cipher_ctx->buf_len == 0) {
1092       return true;
1093    }
1094
1095    cipher_ctx->buf_len += decrypted_len;
1096
1097    unser_crypto_packet_len(cipher_ctx);
1098    Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1099    wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1100    wbuf = &cipher_ctx->buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
1101    cipher_ctx->buf_len -= cipher_ctx->packet_len;
1102    Dmsg2(30, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1103
1104 #ifdef xxx
1105    Dmsg2(30, "check buf_len=%d pkt_len=%d\n", cipher_ctx->buf_len, cipher_ctx->packet_len);
1106    if (second_pass && cipher_ctx->buf_len != cipher_ctx->packet_len) {
1107       Jmsg2(jcr, M_FATAL, 0,
1108             _("Unexpected number of bytes remaining at end of file, received %u, expected %u\n"),
1109             cipher_ctx->packet_len, cipher_ctx->buf_len);
1110       return false;
1111    }
1112 #endif
1113
1114    if (flags & FO_SPARSE) {
1115       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1116          return false;
1117       }
1118    }
1119
1120    if (flags & FO_GZIP) {
1121       if (!decompress_data(jcr, &wbuf, &wsize)) {
1122          return false;
1123       }
1124    }
1125
1126    Dmsg0(30, "Call store_data\n");
1127    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1128       return false;
1129    }
1130    jcr->JobBytes += wsize;
1131    Dmsg2(30, "Flush write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1132
1133    /* Move any remaining data to start of buffer */
1134    if (cipher_ctx->buf_len > 0) {
1135       Dmsg1(30, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1136       memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1137          cipher_ctx->buf_len);
1138    }
1139    /* The packet was successfully written, reset the length so that the next
1140     * packet length may be re-read by unser_crypto_packet_len() */
1141    cipher_ctx->packet_len = 0;
1142
1143    if (cipher_ctx->buf_len >0 && !second_pass) {
1144       second_pass = true;
1145       goto again;
1146    }
1147
1148    /* Stop decryption */
1149    cipher_ctx->buf_len = 0;
1150    cipher_ctx->packet_len = 0;
1151
1152    return true;
1153 }