2428{
2429 int needpass = -1;
2430 bool pgp_keyblock = false;
2431 bool clearsign = false;
2432 long bytes;
2433 LOFF_T last_pos;
2434 LOFF_T block_begin;
2435 LOFF_T block_end;
2436 char buf[8192] = { 0 };
2437 FILE *fp_out = NULL;
2438
2439 gpgme_error_t err = 0;
2440 gpgme_data_t armored_data = NULL;
2441
2442 bool maybe_goodsig = true;
2443 bool have_any_sigs = false;
2444
2445 char body_charset[256] = { 0 };
2446 char *gpgcharset = NULL;
2447
2449
2450
2451
2453 mutt_str_copy(body_charset,
"iso-8859-1",
sizeof(body_charset));
2454
2456 {
2457 return -1;
2458 }
2460
2461 for (bytes = b->
length; bytes > 0;)
2462 {
2463
2464 block_begin = last_pos;
2465
2466 if (!fgets(buf,
sizeof(buf), state->
fp_in))
2467 break;
2468
2469 LOFF_T offset = ftello(state->
fp_in);
2470 if (offset < 0)
2471 {
2473 offset = 0;
2474 }
2475 bytes -= (offset - last_pos);
2476 last_pos = offset;
2477
2479 if (plen != 0)
2480 {
2481 needpass = 0;
2482 clearsign = false;
2483 pgp_keyblock = false;
2484
2486 {
2487 needpass = 1;
2488 }
2490 {
2491 clearsign = true;
2492 }
2494 {
2495 pgp_keyblock = true;
2496 }
2497 else
2498 {
2499
2503 continue;
2504 }
2505
2506
2507 while ((bytes > 0) && (fgets(buf,
sizeof(buf) - 1, state->
fp_in) != NULL))
2508 {
2509 offset = ftello(state->
fp_in);
2510 if (offset < 0)
2511 {
2513 offset = 0;
2514 }
2515 bytes -= (offset - last_pos);
2516 last_pos = offset;
2517
2518 if (needpass &&
mutt_str_equal(
"-----END PGP MESSAGE-----\n", buf))
2519 {
2520 break;
2521 }
2522
2523 if (!needpass && (
mutt_str_equal(
"-----END PGP SIGNATURE-----\n", buf) ||
2525 {
2526 break;
2527 }
2528
2529
2531 {
2532 size_t l = 0;
2535 if ((l =
mutt_str_len(gpgcharset)) > 0 && gpgcharset[l - 1] ==
'\n')
2536 gpgcharset[l - 1] = 0;
2539 }
2540 }
2541 block_end = ftello(state->
fp_in);
2542 if (block_end < 0)
2543 {
2545 block_end = 0;
2546 }
2547
2548 have_any_sigs = (have_any_sigs || (clearsign && (state->
flags &
STATE_VERIFY)));
2549
2550
2552 fseeko(state->
fp_in, block_end, 0);
2553
2554
2555 if (pgp_keyblock)
2556 {
2558 }
2560 {
2563
2564 if (clearsign)
2565 {
2566 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2567 }
2568 else
2569 {
2570 err = gpgme_op_decrypt_verify(ctx, armored_data, plaintext);
2571 if (gpg_err_code(err) == GPG_ERR_NO_DATA)
2572 {
2573
2574 gpgme_data_seek(armored_data, 0, SEEK_SET);
2575
2576 gpgme_data_release(plaintext);
2578 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2579 }
2580 }
2582
2583 if (err != 0)
2584 {
2585 char errbuf[200] = { 0 };
2586
2587 snprintf(errbuf, sizeof(errbuf) - 1,
2588 _(
"Error: decryption/verification failed: %s\n"), gpgme_strerror(err));
2590 }
2591 else
2592 {
2593
2594
2596
2597 bool sig_stat = false;
2598 char *tmpfname = NULL;
2599
2600
2601 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
2602 if (verify_result->signatures)
2603 sig_stat = true;
2604
2605 have_any_sigs = false;
2606 maybe_goodsig = false;
2608 {
2609 int res, idx;
2610 bool anybad = false;
2611
2613 have_any_sigs = true;
2615 {
2616 if (res == 1)
2617 anybad = true;
2618 }
2619 if (!anybad && idx)
2620 maybe_goodsig = true;
2621
2623 }
2624
2626 if (tmpfname)
2627 {
2628 unlink(tmpfname);
2630 }
2631 else
2632 {
2634 state_puts(state,
_(
"Error: copy data failed\n"));
2635 }
2636 }
2637 gpgme_data_release(plaintext);
2638 gpgme_release(ctx);
2639 }
2640
2641
2642
2643
2645 {
2646 if (needpass)
2648 else if (pgp_keyblock)
2650 else
2652 }
2653
2654 if (clearsign)
2655 {
2657 }
2658 else if (fp_out)
2659 {
2660 int c;
2661 char *expected_charset = gpgcharset && *gpgcharset ? gpgcharset : "utf-8";
2662 rewind(fp_out);
2666 {
2668 if ((c ==
'\n') && state->
prefix)
2670 }
2672 }
2673
2675 {
2677 if (needpass)
2679 else if (pgp_keyblock)
2681 else
2683 }
2684
2685
2686 gpgme_data_release(armored_data);
2688 }
2689 else
2690 {
2691
2692
2696 }
2697 }
2699
2700 b->
goodsig = (maybe_goodsig && have_any_sigs);
2701
2702 if (needpass == -1)
2703 {
2704 state_attach_puts(state,
_(
"[-- Error: could not find beginning of PGP message --]\n\n"));
2705 return 1;
2706 }
2708
2709 return err;
2710}
const char * cc_charset(void)
Get the cached value of $charset.
static gpgme_data_t create_gpgme_data(void)
Create a new GPGME data object.
gpgme_ctx_t create_gpgme_context(bool for_smime)
Create a new GPGME context.
#define SIGNED_MESSAGE(_y)
static gpgme_data_t file_to_data_object(FILE *fp, long offset, size_t length)
Create GPGME data object from file.
#define PUBLIC_KEY_BLOCK(_y)
static char * data_object_to_tempfile(gpgme_data_t data, FILE **fp_ret)
Copy a data object to a temporary file.
static void redraw_if_needed(gpgme_ctx_t ctx)
Accommodate for a redraw if needed.
static int pgp_gpgme_extract_keys(gpgme_data_t keydata, FILE **fp)
Write PGP keys to a file.
static void copy_clearsigned(gpgme_data_t data, struct State *state, char *charset)
Copy a clearsigned message.
static int show_one_sig_status(gpgme_ctx_t ctx, int idx, struct State *state)
Show information about one signature.
char * mutt_body_get_charset(struct Body *b, char *buf, size_t buflen)
Get a body's character set.
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
#define mutt_file_fclose(FP)
#define mutt_message(...)
#define mutt_debug(LEVEL,...)
@ LL_DEBUG2
Log at debug level 2.
@ LL_DEBUG1
Log at debug level 1.
bool mutt_ch_check_charset(const char *cs, bool strict)
Does iconv understand a character set?
int mutt_ch_fgetconv(struct FgetConv *fc)
Convert a file's character set.
struct FgetConv * mutt_ch_fgetconv_open(FILE *fp, const char *from, const char *to, uint8_t flags)
Prepare a file for charset conversion.
void mutt_ch_fgetconv_close(struct FgetConv **ptr)
Close an fgetconv handle.
#define MUTT_ICONV_HOOK_FROM
apply charset-hooks to fromcode
void state_attach_puts(struct State *state, const char *t)
Write a string to the state.
#define state_puts(STATE, STR)
#define STATE_DISPLAY
Output is displayed to the user.
#define state_putc(STATE, STR)
#define STATE_VERIFY
Perform signature verification.
char * mutt_str_dup(const char *str)
Copy a string, safely.
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
LOFF_T offset
offset where the actual data begins
LOFF_T length
length (in bytes) of attachment
bool goodsig
Good cryptographic signature.
Cursor for converting a file's encoding.
StateFlags flags
Flags, e.g. STATE_DISPLAY.
FILE * fp_in
File to read from.
const char * prefix
String to add to the beginning of each output line.