NeoMutt  2025-01-09-81-g753ae0
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
handler.c File Reference

Decide how to display email content. More...

#include "config.h"
#include <ctype.h>
#include <iconv.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "handler.h"
#include "attach/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"
#include "pager/lib.h"
#include "copy.h"
#include "enriched.h"
#include "globals.h"
#include "mailcap.h"
#include "mutt_logging.h"
#include "muttlib.h"
#include "rfc3676.h"
#include <libintl.h>
+ Include dependency graph for handler.c:

Go to the source code of this file.

Macros

#define BUFI_SIZE   1000
 
#define BUFO_SIZE   2000
 
#define TXT_HTML   1
 
#define TXT_PLAIN   2
 
#define TXT_ENRICHED   3
 

Typedefs

typedef int(* handler_t) (struct Body *b_email, struct State *state)
 

Functions

static void print_part_line (struct State *state, struct Body *b_email, int n)
 Print a separator for the Mime part.
 
static void convert_to_state (iconv_t cd, char *bufi, size_t *l, struct State *state)
 Convert text and write it to a file.
 
static void decode_xbit (struct State *state, long len, bool istext, iconv_t cd)
 Decode xbit-encoded text.
 
static int qp_decode_triple (char *s, char *d)
 Decode a quoted-printable triplet.
 
static void qp_decode_line (char *dest, char *src, size_t *l, int last)
 Decode a line of quoted-printable text.
 
static void decode_quoted (struct State *state, long len, bool istext, iconv_t cd)
 Decode an attachment encoded with quoted-printable.
 
static unsigned char decode_byte (char ch)
 Decode a uuencoded byte.
 
static void decode_uuencoded (struct State *state, long len, bool istext, iconv_t cd)
 Decode uuencoded text.
 
static bool is_mmnoask (const char *buf)
 Metamail compatibility: should the attachment be autoviewed?
 
static bool is_autoview (struct Body *b)
 Should email body be filtered by mailcap.
 
static int autoview_handler (struct Body *b_email, struct State *state)
 Handler for autoviewable attachments - Implements handler_t -.
 
static int text_plain_handler (struct Body *b_email, struct State *state)
 Handler for plain text - Implements handler_t -.
 
static int message_handler (struct Body *b_email, struct State *state)
 Handler for message/rfc822 body parts - Implements handler_t -.
 
static int external_body_handler (struct Body *b_email, struct State *state)
 Handler for external-body emails - Implements handler_t -.
 
static int alternative_handler (struct Body *b_email, struct State *state)
 Handler for multipart alternative emails - Implements handler_t -.
 
static int multilingual_handler (struct Body *b_email, struct State *state)
 Handler for multi-lingual emails - Implements handler_t -.
 
static int multipart_handler (struct Body *b_email, struct State *state)
 Handler for multipart emails - Implements handler_t -.
 
static int run_decode_and_handler (struct Body *b, struct State *state, handler_t handler, bool plaintext)
 Run an appropriate decoder for an email.
 
static int valid_pgp_encrypted_handler (struct Body *b_email, struct State *state)
 Handler for valid pgp-encrypted emails - Implements handler_t -.
 
static int malformed_pgp_encrypted_handler (struct Body *b_email, struct State *state)
 Handler for invalid pgp-encrypted emails - Implements handler_t -.
 
void mutt_decode_base64 (struct State *state, size_t len, bool istext, iconv_t cd)
 Decode base64-encoded text.
 
int mutt_body_handler (struct Body *b, struct State *state)
 Handler for the Body of an email.
 
bool mutt_prefer_as_attachment (struct Body *b)
 Do we want this part as an attachment?
 
bool mutt_can_decode (struct Body *b)
 Will decoding the attachment produce any output.
 
void mutt_decode_attachment (const struct Body *b, struct State *state)
 Decode an email's attachment.
 

Detailed Description

Decide how to display email content.

Authors
  • Michael R. Elkins
  • Pietro Cerutti
  • Richard Russon
  • Federico Kircheis
  • Reis Radomil
  • Ian Zimmerman
  • David Purton
  • Dennis Schön

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file handler.c.

Macro Definition Documentation

◆ BUFI_SIZE

#define BUFI_SIZE   1000

Definition at line 68 of file handler.c.

◆ BUFO_SIZE

#define BUFO_SIZE   2000

Definition at line 69 of file handler.c.

◆ TXT_HTML

#define TXT_HTML   1

Definition at line 71 of file handler.c.

◆ TXT_PLAIN

#define TXT_PLAIN   2

Definition at line 72 of file handler.c.

◆ TXT_ENRICHED

#define TXT_ENRICHED   3

Definition at line 73 of file handler.c.

Typedef Documentation

◆ handler_t

typedef int(* handler_t) (struct Body *b_email, struct State *state)

Definition at line 85 of file handler.c.

Function Documentation

◆ print_part_line()

static void print_part_line ( struct State state,
struct Body b_email,
int  n 
)
static

Print a separator for the Mime part.

Parameters
stateState of text being processed
b_emailBody of the email
nPart number for multipart emails (0 otherwise)

Definition at line 93 of file handler.c.

94{
95 struct Buffer *length = buf_pool_get();
96 mutt_str_pretty_size(length, b_email->length);
97 state_mark_attach(state);
98 char *charset = mutt_param_get(&b_email->parameter, "charset");
99 if (n == 0)
100 {
101 state_printf(state, _("[-- Type: %s/%s%s%s, Encoding: %s, Size: %s --]\n"),
102 BODY_TYPE(b_email), b_email->subtype, charset ? "; charset=" : "",
103 charset ? charset : "", ENCODING(b_email->encoding), buf_string(length));
104 }
105 else
106 {
107 state_printf(state, _("[-- Alternative Type #%d: %s/%s%s%s, Encoding: %s, Size: %s --]\n"),
108 n, BODY_TYPE(b_email), b_email->subtype,
109 charset ? "; charset=" : "", charset ? charset : "",
110 ENCODING(b_email->encoding), buf_string(length));
111 }
112 buf_pool_release(&length);
113}
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
#define BODY_TYPE(body)
Definition: mime.h:89
#define ENCODING(x)
Definition: mime.h:92
#define _(a)
Definition: message.h:28
void state_mark_attach(struct State *state)
Write a unique marker around content.
Definition: state.c:73
int state_printf(struct State *state, const char *fmt,...)
Write a formatted string to the State.
Definition: state.c:187
int mutt_str_pretty_size(struct Buffer *buf, size_t num)
Display an abbreviated size, like 3.4K.
Definition: muttlib.c:1003
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:85
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:82
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:96
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:63
char * subtype
content-type subtype
Definition: body.h:61
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
String manipulation buffer.
Definition: buffer.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ convert_to_state()

static void convert_to_state ( iconv_t  cd,
char *  bufi,
size_t *  l,
struct State state 
)
static

Convert text and write it to a file.

Parameters
cdIconv conversion descriptor
bufiBuffer with text to convert
lLength of buffer
stateState to write to

Definition at line 122 of file handler.c.

123{
124 char bufo[BUFO_SIZE] = { 0 };
125 const char *ib = NULL;
126 char *ob = NULL;
127 size_t ibl, obl;
128
129 if (!bufi)
130 {
131 if (iconv_t_valid(cd))
132 {
133 ob = bufo;
134 obl = sizeof(bufo);
135 iconv(cd, NULL, NULL, &ob, &obl);
136 if (ob != bufo)
137 state_prefix_put(state, bufo, ob - bufo);
138 }
139 return;
140 }
141
142 if (!iconv_t_valid(cd))
143 {
144 state_prefix_put(state, bufi, *l);
145 *l = 0;
146 return;
147 }
148
149 ib = bufi;
150 ibl = *l;
151 while (true)
152 {
153 ob = bufo;
154 obl = sizeof(bufo);
155 mutt_ch_iconv(cd, &ib, &ibl, &ob, &obl, 0, "?", NULL);
156 if (ob == bufo)
157 break;
158 state_prefix_put(state, bufo, ob - bufo);
159 }
160 memmove(bufi, ib, ibl);
161 *l = ibl;
162}
#define BUFO_SIZE
Definition: handler.c:69
size_t mutt_ch_iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft, const char **inrepls, const char *outrepl, int *iconverrno)
Change the encoding of a string.
Definition: charset.c:697
static bool iconv_t_valid(const iconv_t cd)
Is the conversion descriptor valid?
Definition: charset.h:105
void state_prefix_put(struct State *state, const char *buf, size_t buflen)
Write a prefixed fixed-string to the State.
Definition: state.c:205
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ decode_xbit()

static void decode_xbit ( struct State state,
long  len,
bool  istext,
iconv_t  cd 
)
static

Decode xbit-encoded text.

Parameters
stateState to work with
lenLength of text to decode
istextMime part is plain text
cdIconv conversion descriptor

Definition at line 171 of file handler.c.

172{
173 if (!istext)
174 {
175 mutt_file_copy_bytes(state->fp_in, state->fp_out, len);
176 return;
177 }
178
179 state_set_prefix(state);
180
181 int c;
182 char bufi[BUFI_SIZE] = { 0 };
183 size_t l = 0;
184 while (((c = fgetc(state->fp_in)) != EOF) && len--)
185 {
186 if ((c == '\r') && len)
187 {
188 const int ch = fgetc(state->fp_in);
189 if (ch == '\n')
190 {
191 c = ch;
192 len--;
193 }
194 else
195 {
196 ungetc(ch, state->fp_in);
197 }
198 }
199
200 bufi[l++] = c;
201 if (l == sizeof(bufi))
202 convert_to_state(cd, bufi, &l, state);
203 }
204
205 convert_to_state(cd, bufi, &l, state);
206 convert_to_state(cd, 0, 0, state);
207
208 state_reset_prefix(state);
209}
int mutt_file_copy_bytes(FILE *fp_in, FILE *fp_out, size_t size)
Copy some content from one file to another.
Definition: file.c:195
#define BUFI_SIZE
Definition: handler.c:68
static void convert_to_state(iconv_t cd, char *bufi, size_t *l, struct State *state)
Convert text and write it to a file.
Definition: handler.c:122
#define state_set_prefix(state)
Definition: state.h:56
#define state_reset_prefix(state)
Definition: state.h:57
FILE * fp_out
File to write to.
Definition: state.h:50
FILE * fp_in
File to read from.
Definition: state.h:49
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ qp_decode_triple()

static int qp_decode_triple ( char *  s,
char *  d 
)
static

Decode a quoted-printable triplet.

Parameters
sState to work with
dDecoded character
Return values
0Success
-1Error

Definition at line 218 of file handler.c.

219{
220 /* soft line break */
221 if ((s[0] == '=') && (s[1] == '\0'))
222 return 1;
223
224 /* quoted-printable triple */
225 if ((s[0] == '=') && isxdigit((unsigned char) s[1]) && isxdigit((unsigned char) s[2]))
226 {
227 *d = (hexval(s[1]) << 4) | hexval(s[2]);
228 return 0;
229 }
230
231 /* something else */
232 return -1;
233}
#define hexval(ch)
Definition: mime.h:80
+ Here is the caller graph for this function:

◆ qp_decode_line()

static void qp_decode_line ( char *  dest,
char *  src,
size_t *  l,
int  last 
)
static

Decode a line of quoted-printable text.

Parameters
destBuffer for result
srcText to decode
lBytes written to buffer
lastLast character of the line

Definition at line 242 of file handler.c.

243{
244 char *d = NULL, *s = NULL;
245 char c = 0;
246
247 int kind = -1;
248 bool soft = false;
249
250 /* decode the line */
251
252 for (d = dest, s = src; *s;)
253 {
254 switch ((kind = qp_decode_triple(s, &c)))
255 {
256 case 0:
257 *d++ = c;
258 s += 3;
259 break; /* qp triple */
260 case -1:
261 *d++ = *s++;
262 break; /* single character */
263 case 1:
264 soft = true;
265 s++;
266 break; /* soft line break */
267 }
268 }
269
270 if (!soft && (last == '\n'))
271 {
272 /* neither \r nor \n as part of line-terminating CRLF
273 * may be qp-encoded, so remove \r and \n-terminate;
274 * see RFC2045, sect. 6.7, (1): General 8bit representation */
275 if ((kind == 0) && (c == '\r'))
276 *(d - 1) = '\n';
277 else
278 *d++ = '\n';
279 }
280
281 *d = '\0';
282 *l = d - dest;
283}
static int qp_decode_triple(char *s, char *d)
Decode a quoted-printable triplet.
Definition: handler.c:218
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ decode_quoted()

static void decode_quoted ( struct State state,
long  len,
bool  istext,
iconv_t  cd 
)
static

Decode an attachment encoded with quoted-printable.

Parameters
stateState to work with
lenLength of text to decode
istextMime part is plain text
cdIconv conversion descriptor

Why doesn't this overflow any buffers? First, it's guaranteed that the length of a line grows when you en-code it to quoted-printable. That means that we always can store the result in a buffer of at most the same size.

Now, we don't special-case if the line we read with fgets() isn't terminated. We don't care about this, since 256 > 78, so corrupted input will just be corrupted a bit more. That implies that 256+1 bytes are always sufficient to store the result of qp_decode_line.

Finally, at soft line breaks, some part of a multibyte character may have been left over by convert_to_state(). This shouldn't be more than 6 characters, so 256+7 should be sufficient memory to store the decoded data.

Just to make sure that I didn't make some off-by-one error above, we just use 512 for the target buffer's size.

Definition at line 310 of file handler.c.

311{
312 char line[256] = { 0 };
313 char decline[512] = { 0 };
314 size_t l = 0;
315 size_t l3;
316
317 if (istext)
318 state_set_prefix(state);
319
320 while (len > 0)
321 {
322 /* It's ok to use a fixed size buffer for input, even if the line turns
323 * out to be longer than this. Just process the line in chunks. This
324 * really shouldn't happen according the MIME spec, since Q-P encoded
325 * lines are at most 76 characters, but we should be liberal about what
326 * we accept. */
327 if (!fgets(line, MIN((ssize_t) sizeof(line), len + 1), state->fp_in))
328 break;
329
330 size_t linelen = strlen(line);
331 len -= linelen;
332
333 /* inspect the last character we read so we can tell if we got the
334 * entire line. */
335 const int last = (linelen != 0) ? line[linelen - 1] : 0;
336
337 /* chop trailing whitespace if we got the full line */
338 if (last == '\n')
339 {
340 while ((linelen > 0) && isspace(line[linelen - 1]))
341 linelen--;
342 line[linelen] = '\0';
343 }
344
345 /* decode and do character set conversion */
346 qp_decode_line(decline + l, line, &l3, last);
347 l += l3;
348 convert_to_state(cd, decline, &l, state);
349 }
350
351 convert_to_state(cd, 0, 0, state);
352 state_reset_prefix(state);
353}
static void qp_decode_line(char *dest, char *src, size_t *l, int last)
Decode a line of quoted-printable text.
Definition: handler.c:242
#define MIN(a, b)
Definition: memory.h:32
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ decode_byte()

static unsigned char decode_byte ( char  ch)
static

Decode a uuencoded byte.

Parameters
chCharacter to decode
Return values
numDecoded value

Definition at line 360 of file handler.c.

361{
362 if ((ch < 32) || (ch > 95))
363 return 0;
364 return ch - 32;
365}
+ Here is the caller graph for this function:

◆ decode_uuencoded()

static void decode_uuencoded ( struct State state,
long  len,
bool  istext,
iconv_t  cd 
)
static

Decode uuencoded text.

Parameters
stateState to work with
lenLength of text to decode
istextMime part is plain text
cdIconv conversion descriptor

Definition at line 374 of file handler.c.

375{
376 char tmps[128] = { 0 };
377 char *pt = NULL;
378 char bufi[BUFI_SIZE] = { 0 };
379 size_t k = 0;
380
381 if (istext)
382 state_set_prefix(state);
383
384 while (len > 0)
385 {
386 if (!fgets(tmps, sizeof(tmps), state->fp_in))
387 goto cleanup;
388 len -= mutt_str_len(tmps);
389 if (mutt_str_startswith(tmps, "begin "))
390 break;
391 }
392 while (len > 0)
393 {
394 if (!fgets(tmps, sizeof(tmps), state->fp_in))
395 goto cleanup;
396 len -= mutt_str_len(tmps);
397 if (mutt_str_startswith(tmps, "end"))
398 break;
399 pt = tmps;
400 const unsigned char linelen = decode_byte(*pt);
401 pt++;
402 for (unsigned char c = 0; (c < linelen) && *pt;)
403 {
404 for (char l = 2; (l <= 6) && pt[0] && pt[1]; l += 2)
405 {
406 char out = decode_byte(*pt) << l;
407 pt++;
408 out |= (decode_byte(*pt) >> (6 - l));
409 bufi[k++] = out;
410 c++;
411 if (c == linelen)
412 break;
413 }
414 convert_to_state(cd, bufi, &k, state);
415 pt++;
416 }
417 }
418
419cleanup:
420 convert_to_state(cd, bufi, &k, state);
421 convert_to_state(cd, 0, 0, state);
422
423 state_reset_prefix(state);
424}
static unsigned char decode_byte(char ch)
Decode a uuencoded byte.
Definition: handler.c:360
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:231
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:497
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ is_mmnoask()

static bool is_mmnoask ( const char *  buf)
static

Metamail compatibility: should the attachment be autoviewed?

Parameters
bufMime type, e.g. 'text/plain'
Return values
trueMetamail "no ask" is true

Test if the MM_NOASK environment variable should allow autoviewing of the attachment.

Note
If MM_NOASK=1 then the function will automatically return true.

Definition at line 436 of file handler.c.

437{
438 const char *val = mutt_str_getenv("MM_NOASK");
439 if (!val)
440 return false;
441
442 char *p = NULL;
443 char tmp[1024] = { 0 };
444 char *q = NULL;
445
446 if (mutt_str_equal(val, "1"))
447 return true;
448
449 mutt_str_copy(tmp, val, sizeof(tmp));
450 p = tmp;
451
452 while ((p = strtok(p, ",")))
453 {
454 q = strrchr(p, '/');
455 if (q)
456 {
457 if (q[1] == '*')
458 {
459 if (mutt_istrn_equal(buf, p, q - p))
460 return true;
461 }
462 else
463 {
464 if (mutt_istr_equal(buf, p))
465 return true;
466 }
467 }
468 else
469 {
470 const size_t plen = mutt_istr_startswith(buf, p);
471 if ((plen != 0) && (buf[plen] == '/'))
472 return true;
473 }
474
475 p = NULL;
476 }
477
478 return false;
479}
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:673
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:661
const char * mutt_str_getenv(const char *name)
Get an environment variable.
Definition: string.c:727
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:582
size_t mutt_istr_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix, ignoring case.
Definition: string.c:243
bool mutt_istrn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings ignoring case (to a maximum), safely.
Definition: string.c:454
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ is_autoview()

static bool is_autoview ( struct Body b)
static

Should email body be filtered by mailcap.

Parameters
bBody of the email
Return values
1body part should be filtered by a mailcap entry prior to viewing inline
0otherwise

Definition at line 487 of file handler.c.

488{
489 char type[256] = { 0 };
490 bool is_av = false;
491
492 snprintf(type, sizeof(type), "%s/%s", BODY_TYPE(b), b->subtype);
493
494 const bool c_implicit_auto_view = cs_subset_bool(NeoMutt->sub, "implicit_auto_view");
495 if (c_implicit_auto_view)
496 {
497 /* $implicit_auto_view is essentially the same as "auto_view *" */
498 is_av = true;
499 }
500 else
501 {
502 /* determine if this type is on the user's auto_view list */
503 mutt_check_lookup_list(b, type, sizeof(type));
504 struct ListNode *np = NULL;
505 STAILQ_FOREACH(np, &AutoViewList, entries)
506 {
507 int i = mutt_str_len(np->data);
508 i--;
509 if (((i > 0) && (np->data[i - 1] == '/') && (np->data[i] == '*') &&
510 mutt_istrn_equal(type, np->data, i)) ||
511 mutt_istr_equal(type, np->data))
512 {
513 is_av = true;
514 break;
515 }
516 }
517
518 if (is_mmnoask(type))
519 is_av = true;
520 }
521
522 /* determine if there is a mailcap entry suitable for auto_view
523 *
524 * @warning type is altered by this call as a result of 'mime_lookup' support */
525 if (is_av)
526 return mailcap_lookup(b, type, sizeof(type), NULL, MUTT_MC_AUTOVIEW);
527
528 return false;
529}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
struct ListHead AutoViewList
List of mime types to auto view.
Definition: globals.c:48
static bool is_mmnoask(const char *buf)
Metamail compatibility: should the attachment be autoviewed?
Definition: handler.c:436
bool mailcap_lookup(struct Body *b, char *type, size_t typelen, struct MailcapEntry *entry, enum MailcapLookup opt)
Find given type in the list of mailcap files.
Definition: mailcap.c:483
@ MUTT_MC_AUTOVIEW
Mailcap autoview field.
Definition: mailcap.h:61
void mutt_check_lookup_list(struct Body *b, char *type, size_t len)
Update the mime type.
Definition: mutt_attach.c:343
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:390
A List node for strings.
Definition: list.h:37
char * data
String.
Definition: list.h:38
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ run_decode_and_handler()

static int run_decode_and_handler ( struct Body b,
struct State state,
handler_t  handler,
bool  plaintext 
)
static

Run an appropriate decoder for an email.

Parameters
bBody of the email
stateState to work with
handlerCallback function to process the content - Implements handler_t
plaintextIs the content in plain text
Return values
0Success
-1Error

Definition at line 1328 of file handler.c.

1330{
1331 const char *save_prefix = NULL;
1332 FILE *fp = NULL;
1333 size_t tmplength = 0;
1334 LOFF_T tmpoffset = 0;
1335 int decode = 0;
1336 int rc = 0;
1337#ifndef USE_FMEMOPEN
1338 struct Buffer *tempfile = NULL;
1339#endif
1340
1341 if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
1342 {
1343 return -1;
1344 }
1345
1346#ifdef USE_FMEMOPEN
1347 char *temp = NULL;
1348 size_t tempsize = 0;
1349#endif
1350
1351 /* see if we need to decode this part before processing it */
1352 if ((b->encoding == ENC_BASE64) || (b->encoding == ENC_QUOTED_PRINTABLE) ||
1353 (b->encoding == ENC_UUENCODED) || (plaintext || mutt_is_text_part(b)))
1354 /* text subtypes may require character set conversion even with 8bit encoding */
1355 {
1356 const int orig_type = b->type;
1357 if (plaintext)
1358 {
1359 b->type = TYPE_TEXT;
1360 }
1361 else
1362 {
1363 /* decode to a tempfile, saving the original destination */
1364 fp = state->fp_out;
1365#ifdef USE_FMEMOPEN
1366 state->fp_out = open_memstream(&temp, &tempsize);
1367 if (!state->fp_out)
1368 {
1369 mutt_error(_("Unable to open 'memory stream'"));
1370 mutt_debug(LL_DEBUG1, "Can't open 'memory stream'\n");
1371 return -1;
1372 }
1373#else
1374 tempfile = buf_pool_get();
1375 buf_mktemp(tempfile);
1376 state->fp_out = mutt_file_fopen(buf_string(tempfile), "w");
1377 if (!state->fp_out)
1378 {
1379 mutt_error(_("Unable to open temporary file"));
1380 mutt_debug(LL_DEBUG1, "Can't open %s\n", buf_string(tempfile));
1381 buf_pool_release(&tempfile);
1382 return -1;
1383 }
1384#endif
1385 /* decoding the attachment changes the size and offset, so save a copy
1386 * of the "real" values now, and restore them after processing */
1387 tmplength = b->length;
1388 tmpoffset = b->offset;
1389
1390 /* if we are decoding binary bodies, we don't want to prefix each
1391 * line with the prefix or else the data will get corrupted. */
1392 save_prefix = state->prefix;
1393 state->prefix = NULL;
1394
1395 decode = 1;
1396 }
1397
1398 mutt_decode_attachment(b, state);
1399
1400 if (decode)
1401 {
1402 b->length = ftello(state->fp_out);
1403 b->offset = 0;
1404#ifdef USE_FMEMOPEN
1405 /* When running under torify, mutt_file_fclose(&state->fp_out) does not seem to
1406 * update tempsize. On the other hand, fflush does. See
1407 * https://github.com/neomutt/neomutt/issues/440 */
1408 fflush(state->fp_out);
1409#endif
1410 mutt_file_fclose(&state->fp_out);
1411
1412 /* restore final destination and substitute the tempfile for input */
1413 state->fp_out = fp;
1414 fp = state->fp_in;
1415#ifdef USE_FMEMOPEN
1416 if (tempsize)
1417 {
1418 state->fp_in = fmemopen(temp, tempsize, "r");
1419 }
1420 else
1421 { /* fmemopen can't handle zero-length buffers */
1422 state->fp_in = mutt_file_fopen("/dev/null", "r");
1423 }
1424 if (!state->fp_in)
1425 {
1426 mutt_perror(_("failed to re-open 'memory stream'"));
1427 FREE(&temp);
1428 return -1;
1429 }
1430#else
1431 state->fp_in = mutt_file_fopen(buf_string(tempfile), "r");
1432 unlink(buf_string(tempfile));
1433 buf_pool_release(&tempfile);
1434#endif
1435 /* restore the prefix */
1436 state->prefix = save_prefix;
1437 }
1438
1439 b->type = orig_type;
1440 }
1441
1442 /* process the (decoded) body part */
1443 if (handler)
1444 {
1445 rc = handler(b, state);
1446 if (rc != 0)
1447 {
1448 mutt_debug(LL_DEBUG1, "Failed on attachment of type %s/%s\n",
1449 BODY_TYPE(b), NONULL(b->subtype));
1450 }
1451
1452 if (decode)
1453 {
1454 b->length = tmplength;
1455 b->offset = tmpoffset;
1456
1457 /* restore the original source stream */
1458 mutt_file_fclose(&state->fp_in);
1459 state->fp_in = fp;
1460 }
1461 }
1462 state->flags |= STATE_FIRSTDONE;
1463#ifdef USE_FMEMOPEN
1464 FREE(&temp);
1465#endif
1466
1467 return rc;
1468}
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
Definition: file.c:655
#define mutt_file_fclose(FP)
Definition: file.h:139
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:138
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
#define mutt_perror(...)
Definition: logging2.h:93
void mutt_decode_attachment(const struct Body *b, struct State *state)
Decode an email's attachment.
Definition: handler.c:1907
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
#define FREE(x)
Definition: memory.h:55
@ ENC_UUENCODED
UUEncoded text.
Definition: mime.h:54
@ ENC_BASE64
Base-64 encoded text.
Definition: mime.h:52
@ ENC_QUOTED_PRINTABLE
Quoted-printable text.
Definition: mime.h:51
@ TYPE_TEXT
Type: 'text/*'.
Definition: mime.h:38
#define STATE_FIRSTDONE
The first attachment has been done.
Definition: state.h:40
bool mutt_is_text_part(const struct Body *b)
Is this part of an email in plain text?
Definition: muttlib.c:407
#define NONULL(x)
Definition: string2.h:37
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
StateFlags flags
Flags, e.g. STATE_DISPLAY.
Definition: state.h:52
const char * prefix
String to add to the beginning of each output line.
Definition: state.h:51
#define buf_mktemp(buf)
Definition: tmp.h:33
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_decode_base64()

void mutt_decode_base64 ( struct State state,
size_t  len,
bool  istext,
iconv_t  cd 
)

Decode base64-encoded text.

Parameters
stateState to work with
lenLength of text to decode
istextMime part is plain text
cdIconv conversion descriptor

Definition at line 1534 of file handler.c.

1535{
1536 char buf[5] = { 0 };
1537 int ch, i;
1538 bool cr = false;
1539 char bufi[BUFI_SIZE] = { 0 };
1540 size_t l = 0;
1541
1542 buf[4] = '\0';
1543
1544 if (istext)
1545 state_set_prefix(state);
1546
1547 while (len > 0)
1548 {
1549 for (i = 0; (i < 4) && (len > 0); len--)
1550 {
1551 ch = fgetc(state->fp_in);
1552 if (ch == EOF)
1553 break;
1554 if ((ch >= 0) && (ch < 128) && ((base64val(ch) != -1) || (ch == '=')))
1555 buf[i++] = ch;
1556 }
1557 if (i != 4)
1558 {
1559 /* "i" may be zero if there is trailing whitespace, which is not an error */
1560 if (i != 0)
1561 mutt_debug(LL_DEBUG2, "didn't get a multiple of 4 chars\n");
1562 break;
1563 }
1564
1565 const int c1 = base64val(buf[0]);
1566 const int c2 = base64val(buf[1]);
1567
1568 /* first char */
1569 ch = (c1 << 2) | (c2 >> 4);
1570
1571 if (cr && (ch != '\n'))
1572 bufi[l++] = '\r';
1573
1574 cr = false;
1575
1576 if (istext && (ch == '\r'))
1577 cr = true;
1578 else
1579 bufi[l++] = ch;
1580
1581 /* second char */
1582 if (buf[2] == '=')
1583 break;
1584 const int c3 = base64val(buf[2]);
1585 ch = ((c2 & 0xf) << 4) | (c3 >> 2);
1586
1587 if (cr && (ch != '\n'))
1588 bufi[l++] = '\r';
1589
1590 cr = false;
1591
1592 if (istext && (ch == '\r'))
1593 cr = true;
1594 else
1595 bufi[l++] = ch;
1596
1597 /* third char */
1598 if (buf[3] == '=')
1599 break;
1600 const int c4 = base64val(buf[3]);
1601 ch = ((c3 & 0x3) << 6) | c4;
1602
1603 if (cr && (ch != '\n'))
1604 bufi[l++] = '\r';
1605
1606 cr = false;
1607
1608 if (istext && (ch == '\r'))
1609 cr = true;
1610 else
1611 bufi[l++] = ch;
1612
1613 if ((l + 8) >= sizeof(bufi))
1614 convert_to_state(cd, bufi, &l, state);
1615 }
1616
1617 if (cr)
1618 bufi[l++] = '\r';
1619
1620 convert_to_state(cd, bufi, &l, state);
1621 convert_to_state(cd, 0, 0, state);
1622
1623 state_reset_prefix(state);
1624}
#define base64val(ch)
Definition: base64.h:32
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_body_handler()

int mutt_body_handler ( struct Body b,
struct State state 
)

Handler for the Body of an email.

Parameters
bBody of the email
stateState to work with
Return values
0Success
-1Error

Definition at line 1633 of file handler.c.

1634{
1635 if (!b || !state)
1636 return -1;
1637
1638 bool plaintext = false;
1639 handler_t handler = NULL;
1640 handler_t encrypted_handler = NULL;
1641 int rc = 0;
1642 static unsigned short recurse_level = 0;
1643
1644 const int oflags = state->flags;
1645 const bool is_attachment_display = (oflags & STATE_DISPLAY_ATTACH);
1646
1647 if (recurse_level >= MUTT_MIME_MAX_DEPTH)
1648 {
1649 mutt_debug(LL_DEBUG1, "recurse level too deep. giving up\n");
1650 return 1;
1651 }
1652 recurse_level++;
1653
1654 /* first determine which handler to use to process this part */
1655
1656 if (is_autoview(b))
1657 {
1658 handler = autoview_handler;
1659 state->flags &= ~STATE_CHARCONV;
1660 }
1661 else if (b->type == TYPE_TEXT)
1662 {
1663 if (mutt_istr_equal("plain", b->subtype))
1664 {
1665 const bool c_reflow_text = cs_subset_bool(NeoMutt->sub, "reflow_text");
1666 /* avoid copying this part twice since removing the transfer-encoding is
1667 * the only operation needed. */
1669 {
1670 encrypted_handler = crypt_pgp_application_handler;
1671 handler = encrypted_handler;
1672 }
1673 else if (c_reflow_text &&
1674 mutt_istr_equal("flowed", mutt_param_get(&b->parameter, "format")))
1675 {
1676 handler = rfc3676_handler;
1677 }
1678 else
1679 {
1680 handler = text_plain_handler;
1681 }
1682 }
1683 else if (mutt_istr_equal("enriched", b->subtype))
1684 {
1685 handler = text_enriched_handler;
1686 }
1687 else /* text body type without a handler */
1688 {
1689 plaintext = false;
1690 }
1691 }
1692 else if (b->type == TYPE_MESSAGE)
1693 {
1694 if (mutt_is_message_type(b->type, b->subtype))
1695 handler = message_handler;
1696 else if (mutt_istr_equal("delivery-status", b->subtype))
1697 plaintext = true;
1698 else if (mutt_istr_equal("external-body", b->subtype))
1699 handler = external_body_handler;
1700 }
1701 else if (b->type == TYPE_MULTIPART)
1702 {
1703 const char *const c_show_multipart_alternative = cs_subset_string(NeoMutt->sub, "show_multipart_alternative");
1704 if (!mutt_str_equal("inline", c_show_multipart_alternative) &&
1705 mutt_istr_equal("alternative", b->subtype))
1706 {
1707 handler = alternative_handler;
1708 }
1709 else if (!mutt_str_equal("inline", c_show_multipart_alternative) &&
1710 mutt_istr_equal("multilingual", b->subtype))
1711 {
1712 handler = multilingual_handler;
1713 }
1714 else if ((WithCrypto != 0) && mutt_istr_equal("signed", b->subtype))
1715 {
1716 if (!mutt_param_get(&b->parameter, "protocol"))
1717 mutt_error(_("Error: multipart/signed has no protocol"));
1718 else if (state->flags & STATE_VERIFY)
1719 handler = mutt_signed_handler;
1720 }
1722 {
1723 encrypted_handler = valid_pgp_encrypted_handler;
1724 handler = encrypted_handler;
1725 }
1727 {
1728 encrypted_handler = malformed_pgp_encrypted_handler;
1729 handler = encrypted_handler;
1730 }
1731
1732 if (!handler)
1733 handler = multipart_handler;
1734
1735 if ((b->encoding != ENC_7BIT) && (b->encoding != ENC_8BIT) && (b->encoding != ENC_BINARY))
1736 {
1737 mutt_debug(LL_DEBUG1, "Bad encoding type %d for multipart entity, assuming 7 bit\n",
1738 b->encoding);
1739 b->encoding = ENC_7BIT;
1740 }
1741 }
1742 else if ((WithCrypto != 0) && (b->type == TYPE_APPLICATION))
1743 {
1744 if (OptDontHandlePgpKeys && mutt_istr_equal("pgp-keys", b->subtype))
1745 {
1746 /* pass raw part through for key extraction */
1747 plaintext = true;
1748 }
1749 else if (((WithCrypto & APPLICATION_PGP) != 0) && mutt_is_application_pgp(b))
1750 {
1751 encrypted_handler = crypt_pgp_application_handler;
1752 handler = encrypted_handler;
1753 }
1754 else if (((WithCrypto & APPLICATION_SMIME) != 0) && mutt_is_application_smime(b))
1755 {
1756 encrypted_handler = crypt_smime_application_handler;
1757 handler = encrypted_handler;
1758 }
1759 }
1760
1761 if ((plaintext || handler) && (is_attachment_display || !mutt_prefer_as_attachment(b)))
1762 {
1763 /* only respect disposition == attachment if we're not
1764 * displaying from the attachment menu (i.e. pager) */
1765 /* Prevent encrypted attachments from being included in replies
1766 * unless $include_encrypted is set. */
1767 const bool c_include_encrypted = cs_subset_bool(NeoMutt->sub, "include_encrypted");
1768 if ((state->flags & STATE_REPLYING) && (state->flags & STATE_FIRSTDONE) &&
1769 encrypted_handler && !c_include_encrypted)
1770 {
1771 goto cleanup;
1772 }
1773
1774 rc = run_decode_and_handler(b, state, handler, plaintext);
1775 }
1776 else if (state->flags & STATE_DISPLAY)
1777 {
1778 /* print hint to use attachment menu for disposition == attachment
1779 * if we're not already being called from there */
1780 const bool c_honor_disposition = cs_subset_bool(NeoMutt->sub, "honor_disposition");
1781 struct Buffer *msg = buf_pool_get();
1782
1783 if (is_attachment_display)
1784 {
1785 if (c_honor_disposition && (b->disposition == DISP_ATTACH))
1786 {
1787 buf_strcpy(msg, _("[-- This is an attachment --]\n"));
1788 }
1789 else
1790 {
1791 /* L10N: %s/%s is a MIME type, e.g. "text/plain". */
1792 buf_printf(msg, _("[-- %s/%s is unsupported --]\n"), BODY_TYPE(b), b->subtype);
1793 }
1794 }
1795 else
1796 {
1797 struct Buffer *keystroke = buf_pool_get();
1798 if (km_expand_key(km_find_func(MENU_PAGER, OP_VIEW_ATTACHMENTS), keystroke))
1799 {
1800 if (c_honor_disposition && (b->disposition == DISP_ATTACH))
1801 {
1802 /* L10N: %s expands to a keystroke/key binding, e.g. 'v'. */
1803 buf_printf(msg, _("[-- This is an attachment (use '%s' to view this part) --]\n"),
1804 buf_string(keystroke));
1805 }
1806 else
1807 {
1808 /* L10N: %s/%s is a MIME type, e.g. "text/plain".
1809 The last %s expands to a keystroke/key binding, e.g. 'v'. */
1810 buf_printf(msg, _("[-- %s/%s is unsupported (use '%s' to view this part) --]\n"),
1811 BODY_TYPE(b), b->subtype, buf_string(keystroke));
1812 }
1813 }
1814 else
1815 {
1816 if (c_honor_disposition && (b->disposition == DISP_ATTACH))
1817 {
1818 buf_strcpy(msg, _("[-- This is an attachment (need 'view-attachments' bound to key) --]\n"));
1819 }
1820 else
1821 {
1822 /* L10N: %s/%s is a MIME type, e.g. "text/plain". */
1823 buf_printf(msg, _("[-- %s/%s is unsupported (need 'view-attachments' bound to key) --]\n"),
1824 BODY_TYPE(b), b->subtype);
1825 }
1826 }
1827 buf_pool_release(&keystroke);
1828 }
1829 state_mark_attach(state);
1830 state_printf(state, "%s", buf_string(msg));
1831 buf_pool_release(&msg);
1832 }
1833
1834cleanup:
1835 recurse_level--;
1836 state->flags = oflags | (state->flags & STATE_FIRSTDONE);
1837 if (rc != 0)
1838 {
1839 mutt_debug(LL_DEBUG1, "Bailing on attachment of type %s/%s\n", BODY_TYPE(b),
1840 NONULL(b->subtype));
1841 }
1842
1843 return rc;
1844}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
SecurityFlags mutt_is_application_smime(struct Body *b)
Does the message use S/MIME?
Definition: crypt.c:609
int mutt_is_valid_multipart_pgp_encrypted(struct Body *b)
Is this a valid multi-part encrypted message?
Definition: crypt.c:467
SecurityFlags mutt_is_malformed_multipart_pgp_encrypted(struct Body *b)
Check for malformed layout.
Definition: crypt.c:504
SecurityFlags mutt_is_application_pgp(const struct Body *b)
Does the message use PGP?
Definition: crypt.c:548
bool mutt_is_message_type(int type, const char *subtype)
Determine if a mime type matches a message or not.
Definition: parse.c:1498
bool OptDontHandlePgpKeys
(pseudo) used to extract PGP keys
Definition: globals.c:61
int crypt_pgp_application_handler(struct Body *b_email, struct State *state)
Wrapper for CryptModuleSpecs::application_handler() - Implements handler_t -.
Definition: cryptglue.c:236
static int alternative_handler(struct Body *b_email, struct State *state)
Handler for multipart alternative emails - Implements handler_t -.
Definition: handler.c:943
int text_enriched_handler(struct Body *b_email, struct State *state)
Handler for enriched text - Implements handler_t -.
Definition: enriched.c:469
static int text_plain_handler(struct Body *b_email, struct State *state)
Handler for plain text - Implements handler_t -.
Definition: handler.c:687
int crypt_smime_application_handler(struct Body *b_email, struct State *state)
Wrapper for CryptModuleSpecs::application_handler() - Implements handler_t -.
Definition: cryptglue.c:443
static int autoview_handler(struct Body *b_email, struct State *state)
Handler for autoviewable attachments - Implements handler_t -.
Definition: handler.c:534
static int external_body_handler(struct Body *b_email, struct State *state)
Handler for external-body emails - Implements handler_t -.
Definition: handler.c:772
int rfc3676_handler(struct Body *b_email, struct State *state)
Handler for format=flowed - Implements handler_t -.
Definition: rfc3676.c:323
static int malformed_pgp_encrypted_handler(struct Body *b_email, struct State *state)
Handler for invalid pgp-encrypted emails - Implements handler_t -.
Definition: handler.c:1502
static int valid_pgp_encrypted_handler(struct Body *b_email, struct State *state)
Handler for valid pgp-encrypted emails - Implements handler_t -.
Definition: handler.c:1473
static int message_handler(struct Body *b_email, struct State *state)
Handler for message/rfc822 body parts - Implements handler_t -.
Definition: handler.c:714
static int multipart_handler(struct Body *b_email, struct State *state)
Handler for multipart emails - Implements handler_t -.
Definition: handler.c:1239
static int multilingual_handler(struct Body *b_email, struct State *state)
Handler for multi-lingual emails - Implements handler_t -.
Definition: handler.c:1131
int mutt_signed_handler(struct Body *b_email, struct State *state)
Handler for "multipart/signed" - Implements handler_t -.
Definition: crypt.c:1243
static bool is_autoview(struct Body *b)
Should email body be filtered by mailcap.
Definition: handler.c:487
bool mutt_prefer_as_attachment(struct Body *b)
Do we want this part as an attachment?
Definition: handler.c:1851
int(* handler_t)(struct Body *b_email, struct State *state)
Definition: handler.c:85
static int run_decode_and_handler(struct Body *b, struct State *state, handler_t handler, bool plaintext)
Run an appropriate decoder for an email.
Definition: handler.c:1328
struct Keymap * km_find_func(enum MenuType mtype, int func)
Find a function's mapping in a Menu.
Definition: lib.c:483
bool km_expand_key(struct Keymap *map, struct Buffer *buf)
Get the key string bound to a Keymap.
Definition: lib.c:451
@ ENC_7BIT
7-bit text
Definition: mime.h:49
@ ENC_BINARY
Binary.
Definition: mime.h:53
@ ENC_8BIT
8-bit text
Definition: mime.h:50
#define MUTT_MIME_MAX_DEPTH
Definition: mime.h:69
@ TYPE_MESSAGE
Type: 'message/*'.
Definition: mime.h:35
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
@ TYPE_APPLICATION
Type: 'application/*'.
Definition: mime.h:33
@ DISP_ATTACH
Content is attached.
Definition: mime.h:63
#define STATE_DISPLAY
Output is displayed to the user.
Definition: state.h:33
#define STATE_DISPLAY_ATTACH
We are displaying an attachment.
Definition: state.h:41
#define STATE_REPLYING
Are we replying?
Definition: state.h:39
#define STATE_VERIFY
Perform signature verification.
Definition: state.h:34
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:96
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:97
#define WithCrypto
Definition: lib.h:122
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
@ MENU_PAGER
Pager pager (email viewer)
Definition: type.h:52
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_prefer_as_attachment()

bool mutt_prefer_as_attachment ( struct Body b)

Do we want this part as an attachment?

Parameters
bBody of email to test
Return values
trueWe want this part as an attachment

Definition at line 1851 of file handler.c.

1852{
1853 if (!mutt_can_decode(b))
1854 return true;
1855
1856 if (b->disposition != DISP_ATTACH)
1857 return false;
1858
1859 return cs_subset_bool(NeoMutt->sub, "honor_disposition");
1860}
bool mutt_can_decode(struct Body *b)
Will decoding the attachment produce any output.
Definition: handler.c:1867
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_can_decode()

bool mutt_can_decode ( struct Body b)

Will decoding the attachment produce any output.

Parameters
bBody of email to test
Return values
trueDecoding the attachment will produce output

Definition at line 1867 of file handler.c.

1868{
1869 if (is_autoview(b))
1870 return true;
1871 if (b->type == TYPE_TEXT)
1872 return true;
1873 if (b->type == TYPE_MESSAGE)
1874 return true;
1875 if (b->type == TYPE_MULTIPART)
1876 {
1877 if (WithCrypto)
1878 {
1879 if (mutt_istr_equal(b->subtype, "signed") || mutt_istr_equal(b->subtype, "encrypted"))
1880 {
1881 return true;
1882 }
1883 }
1884
1885 for (struct Body *part = b->parts; part; part = part->next)
1886 {
1887 if (mutt_can_decode(part))
1888 return true;
1889 }
1890 }
1891 else if ((WithCrypto != 0) && (b->type == TYPE_APPLICATION))
1892 {
1894 return true;
1896 return true;
1897 }
1898
1899 return false;
1900}
The body of an email.
Definition: body.h:36
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:73
struct Body * next
next attachment in the list
Definition: body.h:72
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_decode_attachment()

void mutt_decode_attachment ( const struct Body b,
struct State state 
)

Decode an email's attachment.

Parameters
bBody of the email
stateState of text being processed

Definition at line 1907 of file handler.c.

1908{
1909 int istext = mutt_is_text_part(b) && (b->disposition == DISP_INLINE);
1910 iconv_t cd = ICONV_T_INVALID;
1911
1912 if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
1913 {
1914 return;
1915 }
1916
1917 if (istext && (b->charset || (state->flags & STATE_CHARCONV)))
1918 {
1919 const char *charset = b->charset;
1920 if (!charset)
1921 {
1922 charset = mutt_param_get(&b->parameter, "charset");
1923 if (!charset && !slist_is_empty(cc_assumed_charset()))
1925 }
1926 if (charset && cc_charset())
1928 }
1929
1930 switch (b->encoding)
1931 {
1933 decode_quoted(state, b->length,
1934 istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
1936 cd);
1937 break;
1938 case ENC_BASE64:
1939 mutt_decode_base64(state, b->length,
1940 istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
1942 cd);
1943 break;
1944 case ENC_UUENCODED:
1945 decode_uuencoded(state, b->length,
1946 istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
1948 cd);
1949 break;
1950 default:
1951 decode_xbit(state, b->length,
1952 istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
1954 cd);
1955 break;
1956 }
1957}
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:116
const struct Slist * cc_assumed_charset(void)
Get the cached value of $assumed_charset.
Definition: config_cache.c:101
static void decode_uuencoded(struct State *state, long len, bool istext, iconv_t cd)
Decode uuencoded text.
Definition: handler.c:374
void mutt_decode_base64(struct State *state, size_t len, bool istext, iconv_t cd)
Decode base64-encoded text.
Definition: handler.c:1534
static void decode_quoted(struct State *state, long len, bool istext, iconv_t cd)
Decode an attachment encoded with quoted-printable.
Definition: handler.c:310
static void decode_xbit(struct State *state, long len, bool istext, iconv_t cd)
Decode xbit-encoded text.
Definition: handler.c:171
@ DISP_INLINE
Content is inline.
Definition: mime.h:62
iconv_t mutt_ch_iconv_open(const char *tocode, const char *fromcode, uint8_t flags)
Set up iconv for conversions.
Definition: charset.c:594
const char * mutt_ch_get_default_charset(const struct Slist *const assumed_charset)
Get the default character set.
Definition: charset.c:465
#define MUTT_ICONV_HOOK_FROM
apply charset-hooks to fromcode
Definition: charset.h:65
#define ICONV_T_INVALID
Error value for iconv functions.
Definition: charset.h:93
bool slist_is_empty(const struct Slist *list)
Is the slist empty?
Definition: slist.c:140
#define STATE_CHARCONV
Do character set conversions.
Definition: state.h:37
char * charset
Send mode: charset of attached file as stored on disk.
Definition: body.h:79
+ Here is the call graph for this function:
+ Here is the caller graph for this function: