NeoMutt  2024-11-14-138-ge5ca67
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
handler.h File Reference

Decide how to display email content. More...

#include <iconv.h>
#include <stdbool.h>
#include <stddef.h>
+ Include dependency graph for handler.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

int mutt_body_handler (struct Body *b, struct State *state)
 Handler for the Body of an email.
 
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.
 
void mutt_decode_base64 (struct State *state, size_t len, bool istext, iconv_t cd)
 Decode base64-encoded text.
 
bool mutt_prefer_as_attachment (struct Body *b)
 Do we want this part as an attachment?
 

Detailed Description

Decide how to display email content.

Authors
  • Richard Russon
  • Pietro Cerutti

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.h.

Function Documentation

◆ 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 1632 of file handler.c.

1633{
1634 if (!b || !state)
1635 return -1;
1636
1637 bool plaintext = false;
1638 handler_t handler = NULL;
1639 handler_t encrypted_handler = NULL;
1640 int rc = 0;
1641 static unsigned short recurse_level = 0;
1642
1643 const int oflags = state->flags;
1644 const bool is_attachment_display = (oflags & STATE_DISPLAY_ATTACH);
1645
1646 if (recurse_level >= MUTT_MIME_MAX_DEPTH)
1647 {
1648 mutt_debug(LL_DEBUG1, "recurse level too deep. giving up\n");
1649 return 1;
1650 }
1651 recurse_level++;
1652
1653 /* first determine which handler to use to process this part */
1654
1655 if (is_autoview(b))
1656 {
1657 handler = autoview_handler;
1658 state->flags &= ~STATE_CHARCONV;
1659 }
1660 else if (b->type == TYPE_TEXT)
1661 {
1662 if (mutt_istr_equal("plain", b->subtype))
1663 {
1664 const bool c_reflow_text = cs_subset_bool(NeoMutt->sub, "reflow_text");
1665 /* avoid copying this part twice since removing the transfer-encoding is
1666 * the only operation needed. */
1668 {
1669 encrypted_handler = crypt_pgp_application_handler;
1670 handler = encrypted_handler;
1671 }
1672 else if (c_reflow_text &&
1673 mutt_istr_equal("flowed", mutt_param_get(&b->parameter, "format")))
1674 {
1675 handler = rfc3676_handler;
1676 }
1677 else
1678 {
1679 handler = text_plain_handler;
1680 }
1681 }
1682 else if (mutt_istr_equal("enriched", b->subtype))
1683 {
1684 handler = text_enriched_handler;
1685 }
1686 else /* text body type without a handler */
1687 {
1688 plaintext = false;
1689 }
1690 }
1691 else if (b->type == TYPE_MESSAGE)
1692 {
1693 if (mutt_is_message_type(b->type, b->subtype))
1694 handler = message_handler;
1695 else if (mutt_istr_equal("delivery-status", b->subtype))
1696 plaintext = true;
1697 else if (mutt_istr_equal("external-body", b->subtype))
1698 handler = external_body_handler;
1699 }
1700 else if (b->type == TYPE_MULTIPART)
1701 {
1702 const char *const c_show_multipart_alternative = cs_subset_string(NeoMutt->sub, "show_multipart_alternative");
1703 if (!mutt_str_equal("inline", c_show_multipart_alternative) &&
1704 mutt_istr_equal("alternative", b->subtype))
1705 {
1706 handler = alternative_handler;
1707 }
1708 else if (!mutt_str_equal("inline", c_show_multipart_alternative) &&
1709 mutt_istr_equal("multilingual", b->subtype))
1710 {
1711 handler = multilingual_handler;
1712 }
1713 else if ((WithCrypto != 0) && mutt_istr_equal("signed", b->subtype))
1714 {
1715 if (!mutt_param_get(&b->parameter, "protocol"))
1716 mutt_error(_("Error: multipart/signed has no protocol"));
1717 else if (state->flags & STATE_VERIFY)
1718 handler = mutt_signed_handler;
1719 }
1721 {
1722 encrypted_handler = valid_pgp_encrypted_handler;
1723 handler = encrypted_handler;
1724 }
1726 {
1727 encrypted_handler = malformed_pgp_encrypted_handler;
1728 handler = encrypted_handler;
1729 }
1730
1731 if (!handler)
1732 handler = multipart_handler;
1733
1734 if ((b->encoding != ENC_7BIT) && (b->encoding != ENC_8BIT) && (b->encoding != ENC_BINARY))
1735 {
1736 mutt_debug(LL_DEBUG1, "Bad encoding type %d for multipart entity, assuming 7 bit\n",
1737 b->encoding);
1738 b->encoding = ENC_7BIT;
1739 }
1740 }
1741 else if ((WithCrypto != 0) && (b->type == TYPE_APPLICATION))
1742 {
1743 if (OptDontHandlePgpKeys && mutt_istr_equal("pgp-keys", b->subtype))
1744 {
1745 /* pass raw part through for key extraction */
1746 plaintext = true;
1747 }
1748 else if (((WithCrypto & APPLICATION_PGP) != 0) && mutt_is_application_pgp(b))
1749 {
1750 encrypted_handler = crypt_pgp_application_handler;
1751 handler = encrypted_handler;
1752 }
1753 else if (((WithCrypto & APPLICATION_SMIME) != 0) && mutt_is_application_smime(b))
1754 {
1755 encrypted_handler = crypt_smime_application_handler;
1756 handler = encrypted_handler;
1757 }
1758 }
1759
1760 if ((plaintext || handler) && (is_attachment_display || !mutt_prefer_as_attachment(b)))
1761 {
1762 /* only respect disposition == attachment if we're not
1763 * displaying from the attachment menu (i.e. pager) */
1764 /* Prevent encrypted attachments from being included in replies
1765 * unless $include_encrypted is set. */
1766 const bool c_include_encrypted = cs_subset_bool(NeoMutt->sub, "include_encrypted");
1767 if ((state->flags & STATE_REPLYING) && (state->flags & STATE_FIRSTDONE) &&
1768 encrypted_handler && !c_include_encrypted)
1769 {
1770 goto cleanup;
1771 }
1772
1773 rc = run_decode_and_handler(b, state, handler, plaintext);
1774 }
1775 else if (state->flags & STATE_DISPLAY)
1776 {
1777 /* print hint to use attachment menu for disposition == attachment
1778 * if we're not already being called from there */
1779 const bool c_honor_disposition = cs_subset_bool(NeoMutt->sub, "honor_disposition");
1780 struct Buffer *msg = buf_pool_get();
1781
1782 if (is_attachment_display)
1783 {
1784 if (c_honor_disposition && (b->disposition == DISP_ATTACH))
1785 {
1786 buf_strcpy(msg, _("[-- This is an attachment --]\n"));
1787 }
1788 else
1789 {
1790 /* L10N: %s/%s is a MIME type, e.g. "text/plain". */
1791 buf_printf(msg, _("[-- %s/%s is unsupported --]\n"), TYPE(b), b->subtype);
1792 }
1793 }
1794 else
1795 {
1796 char keystroke[128] = { 0 };
1797 if (km_expand_key(keystroke, sizeof(keystroke),
1798 km_find_func(MENU_PAGER, OP_VIEW_ATTACHMENTS)))
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 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 TYPE(b), b->subtype, 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 TYPE(b), b->subtype);
1825 }
1826 }
1827 }
1828 state_mark_attach(state);
1829 state_printf(state, "%s", buf_string(msg));
1830 buf_pool_release(&msg);
1831 }
1832
1833cleanup:
1834 recurse_level--;
1835 state->flags = oflags | (state->flags & STATE_FIRSTDONE);
1836 if (rc != 0)
1837 {
1838 mutt_debug(LL_DEBUG1, "Bailing on attachment of type %s/%s\n", TYPE(b),
1839 NONULL(b->subtype));
1840 }
1841
1842 return rc;
1843}
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
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
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:942
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:685
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:532
static int external_body_handler(struct Body *b_email, struct State *state)
Handler for external-body emails - Implements handler_t -.
Definition: handler.c:770
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:1501
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:1472
static int message_handler(struct Body *b_email, struct State *state)
Handler for message/rfc822 body parts - Implements handler_t -.
Definition: handler.c:712
static int multipart_handler(struct Body *b_email, struct State *state)
Handler for multipart emails - Implements handler_t -.
Definition: handler.c:1238
static int multilingual_handler(struct Body *b_email, struct State *state)
Handler for multi-lingual emails - Implements handler_t -.
Definition: handler.c:1130
int mutt_signed_handler(struct Body *b_email, struct State *state)
Handler for "multipart/signed" - Implements handler_t -.
Definition: crypt.c:1243
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
static bool is_autoview(struct Body *b)
Should email body be filtered by mailcap.
Definition: handler.c:485
bool mutt_prefer_as_attachment(struct Body *b)
Do we want this part as an attachment?
Definition: handler.c:1850
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:1327
struct Keymap * km_find_func(enum MenuType mtype, int func)
Find a function's mapping in a Menu.
Definition: lib.c:509
int km_expand_key(char *s, size_t len, struct Keymap *map)
Get the key string bound to a Keymap.
Definition: lib.c:457
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
@ 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
@ TYPE_TEXT
Type: 'text/*'.
Definition: mime.h:38
@ DISP_ATTACH
Content is attached.
Definition: mime.h:63
#define TYPE(body)
Definition: mime.h:89
#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
#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_FIRSTDONE
The first attachment has been done.
Definition: state.h:40
#define STATE_REPLYING
Are we replying?
Definition: state.h:39
#define STATE_VERIFY
Perform signature verification.
Definition: state.h:34
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
#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
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
#define NONULL(x)
Definition: string2.h:37
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:63
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
char * subtype
content-type subtype
Definition: body.h:61
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
String manipulation buffer.
Definition: buffer.h:36
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
StateFlags flags
Flags, e.g. STATE_DISPLAY.
Definition: state.h:52
@ 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_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 1866 of file handler.c.

1867{
1868 if (is_autoview(b))
1869 return true;
1870 if (b->type == TYPE_TEXT)
1871 return true;
1872 if (b->type == TYPE_MESSAGE)
1873 return true;
1874 if (b->type == TYPE_MULTIPART)
1875 {
1876 if (WithCrypto)
1877 {
1878 if (mutt_istr_equal(b->subtype, "signed") || mutt_istr_equal(b->subtype, "encrypted"))
1879 {
1880 return true;
1881 }
1882 }
1883
1884 for (struct Body *part = b->parts; part; part = part->next)
1885 {
1886 if (mutt_can_decode(part))
1887 return true;
1888 }
1889 }
1890 else if ((WithCrypto != 0) && (b->type == TYPE_APPLICATION))
1891 {
1893 return true;
1895 return true;
1896 }
1897
1898 return false;
1899}
bool mutt_can_decode(struct Body *b)
Will decoding the attachment produce any output.
Definition: handler.c:1866
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 1906 of file handler.c.

1907{
1908 int istext = mutt_is_text_part(b) && (b->disposition == DISP_INLINE);
1909 iconv_t cd = ICONV_T_INVALID;
1910
1911 if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
1912 {
1913 return;
1914 }
1915
1916 if (istext && (b->charset || (state->flags & STATE_CHARCONV)))
1917 {
1918 const char *charset = b->charset;
1919 if (!charset)
1920 {
1921 charset = mutt_param_get(&b->parameter, "charset");
1922 if (!charset && !slist_is_empty(cc_assumed_charset()))
1924 }
1925 if (charset && cc_charset())
1927 }
1928
1929 switch (b->encoding)
1930 {
1932 decode_quoted(state, b->length,
1933 istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
1935 cd);
1936 break;
1937 case ENC_BASE64:
1938 mutt_decode_base64(state, b->length,
1939 istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
1941 cd);
1942 break;
1943 case ENC_UUENCODED:
1944 decode_uuencoded(state, b->length,
1945 istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
1947 cd);
1948 break;
1949 default:
1950 decode_xbit(state, b->length,
1951 istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
1953 cd);
1954 break;
1955 }
1956}
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
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
Definition: file.c:778
static void decode_uuencoded(struct State *state, long len, bool istext, iconv_t cd)
Decode uuencoded text.
Definition: handler.c:372
void mutt_decode_base64(struct State *state, size_t len, bool istext, iconv_t cd)
Decode base64-encoded text.
Definition: handler.c:1533
static void decode_quoted(struct State *state, long len, bool istext, iconv_t cd)
Decode an attachment encoded with quoted-printable.
Definition: handler.c:308
static void decode_xbit(struct State *state, long len, bool istext, iconv_t cd)
Decode xbit-encoded text.
Definition: handler.c:169
@ 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
@ 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:138
#define STATE_CHARCONV
Do character set conversions.
Definition: state.h:37
bool mutt_is_text_part(const struct Body *b)
Is this part of an email in plain text?
Definition: muttlib.c:407
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
char * charset
Send mode: charset of attached file as stored on disk.
Definition: body.h:79
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:

◆ 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 1533 of file handler.c.

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

1851{
1852 if (!mutt_can_decode(b))
1853 return true;
1854
1855 if (b->disposition != DISP_ATTACH)
1856 return false;
1857
1858 return cs_subset_bool(NeoMutt->sub, "honor_disposition");
1859}
+ Here is the call graph for this function:
+ Here is the caller graph for this function: