NeoMutt  2023-11-03-107-g582dc1
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
pgp_traditional_encryptsign()

Create an inline PGP encrypted, signed email. More...

+ Collaboration diagram for pgp_traditional_encryptsign():

Functions

struct Bodypgp_class_traditional_encryptsign (struct Body *b, SecurityFlags flags, char *keylist)
 Create an inline PGP encrypted, signed email - Implements CryptModuleSpecs::pgp_traditional_encryptsign() -.
 

Detailed Description

Create an inline PGP encrypted, signed email.

Parameters
bBody of the email
flagsFlags, see SecurityFlags
keylistList of keys to encrypt to (space-separated)
Return values
ptrNew encrypted/signed Body
NULLError

Function Documentation

◆ pgp_class_traditional_encryptsign()

struct Body * pgp_class_traditional_encryptsign ( struct Body b,
SecurityFlags  flags,
char *  keylist 
)

Create an inline PGP encrypted, signed email - Implements CryptModuleSpecs::pgp_traditional_encryptsign() -.

Definition at line 1726 of file pgp.c.

1727{
1728 struct Body *b_enc = NULL;
1729 char body_charset[256] = { 0 };
1730 const char *from_charset = NULL;
1731 const char *send_charset = NULL;
1732 bool empty = false;
1733 bool err;
1734 char buf[256] = { 0 };
1735 pid_t pid;
1736 struct Buffer *pgpinfile = buf_pool_get();
1737 struct Buffer *pgpoutfile = buf_pool_get();
1738
1739 if (b->type != TYPE_TEXT)
1740 goto cleanup;
1741 if (!mutt_istr_equal(b->subtype, "plain"))
1742 goto cleanup;
1743
1744 FILE *fp_body = fopen(b->filename, "r");
1745 if (!fp_body)
1746 {
1747 mutt_perror("%s", b->filename);
1748 goto cleanup;
1749 }
1750
1751 buf_mktemp(pgpinfile);
1752 FILE *fp_pgp_in = mutt_file_fopen(buf_string(pgpinfile), "w");
1753 if (!fp_pgp_in)
1754 {
1755 mutt_perror("%s", buf_string(pgpinfile));
1756 mutt_file_fclose(&fp_body);
1757 goto cleanup;
1758 }
1759
1760 /* The following code is really correct: If noconv is set,
1761 * b's charset parameter contains the on-disk character set, and
1762 * we have to convert from that to utf-8. If noconv is not set,
1763 * we have to convert from $charset to utf-8. */
1764
1765 mutt_body_get_charset(b, body_charset, sizeof(body_charset));
1766 if (b->noconv)
1767 from_charset = body_charset;
1768 else
1769 from_charset = cc_charset();
1770
1771 if (mutt_ch_is_us_ascii(body_charset))
1772 {
1773 send_charset = "us-ascii";
1774 mutt_file_copy_stream(fp_body, fp_pgp_in);
1775 }
1776 else
1777 {
1778 int c;
1779 struct FgetConv *fc = NULL;
1780
1781 if (flags & SEC_ENCRYPT)
1782 send_charset = "us-ascii";
1783 else
1784 send_charset = "utf-8";
1785
1786 /* fromcode is assumed to be correct: we set flags to 0 */
1787 fc = mutt_ch_fgetconv_open(fp_body, from_charset, "utf-8", MUTT_ICONV_NO_FLAGS);
1788 while ((c = mutt_ch_fgetconv(fc)) != EOF)
1789 fputc(c, fp_pgp_in);
1790
1792 }
1793 mutt_file_fclose(&fp_body);
1794 mutt_file_fclose(&fp_pgp_in);
1795
1796 buf_mktemp(pgpoutfile);
1797 FILE *fp_pgp_out = mutt_file_fopen(buf_string(pgpoutfile), "w+");
1798 FILE *fp_pgp_err = mutt_file_mkstemp();
1799 if (!fp_pgp_out || !fp_pgp_err)
1800 {
1801 mutt_perror("%s", fp_pgp_out ? "Can't create temporary file" : buf_string(pgpoutfile));
1802 unlink(buf_string(pgpinfile));
1803 if (fp_pgp_out)
1804 {
1805 mutt_file_fclose(&fp_pgp_out);
1806 unlink(buf_string(pgpoutfile));
1807 }
1808 mutt_file_fclose(&fp_pgp_err);
1809 goto cleanup;
1810 }
1811
1812 pid = pgp_invoke_traditional(&fp_pgp_in, NULL, NULL, -1, fileno(fp_pgp_out),
1813 fileno(fp_pgp_err), buf_string(pgpinfile), keylist, flags);
1814 if (pid == -1)
1815 {
1816 mutt_perror(_("Can't invoke PGP"));
1817 mutt_file_fclose(&fp_pgp_out);
1818 mutt_file_fclose(&fp_pgp_err);
1819 mutt_file_unlink(buf_string(pgpinfile));
1820 unlink(buf_string(pgpoutfile));
1821 goto cleanup;
1822 }
1823
1824 if (pgp_use_gpg_agent())
1825 *PgpPass = '\0';
1826 if (flags & SEC_SIGN)
1827 fprintf(fp_pgp_in, "%s\n", PgpPass);
1828 mutt_file_fclose(&fp_pgp_in);
1829
1830 const bool c_pgp_check_exit = cs_subset_bool(NeoMutt->sub, "pgp_check_exit");
1831 if (filter_wait(pid) && c_pgp_check_exit)
1832 empty = true;
1833
1834 mutt_file_unlink(buf_string(pgpinfile));
1835
1836 fflush(fp_pgp_out);
1837 fflush(fp_pgp_err);
1838
1839 rewind(fp_pgp_out);
1840 rewind(fp_pgp_err);
1841
1842 if (!empty)
1843 empty = (fgetc(fp_pgp_out) == EOF);
1844 mutt_file_fclose(&fp_pgp_out);
1845
1846 err = false;
1847
1848 while (fgets(buf, sizeof(buf), fp_pgp_err))
1849 {
1850 err = true;
1851 fputs(buf, stdout);
1852 }
1853
1854 mutt_file_fclose(&fp_pgp_err);
1855
1856 if (err)
1858
1859 if (empty)
1860 {
1861 if (flags & SEC_SIGN)
1862 pgp_class_void_passphrase(); /* just in case */
1863 unlink(buf_string(pgpoutfile));
1864 goto cleanup;
1865 }
1866
1867 b_enc = mutt_body_new();
1868
1869 b_enc->encoding = ENC_7BIT;
1870
1871 b_enc->type = TYPE_TEXT;
1872 b_enc->subtype = mutt_str_dup("plain");
1873
1874 mutt_param_set(&b_enc->parameter, "x-action",
1875 (flags & SEC_ENCRYPT) ? "pgp-encrypted" : "pgp-signed");
1876 mutt_param_set(&b_enc->parameter, "charset", send_charset);
1877
1878 b_enc->filename = buf_strdup(pgpoutfile);
1879
1880 b_enc->disposition = DISP_NONE;
1881 b_enc->unlink = true;
1882
1883 b_enc->noconv = true;
1884 b_enc->use_disp = false;
1885
1886 if (!(flags & SEC_ENCRYPT))
1887 b_enc->encoding = b->encoding;
1888
1889cleanup:
1890 buf_pool_release(&pgpinfile);
1891 buf_pool_release(&pgpoutfile);
1892 return b_enc;
1893}
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:542
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:93
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:115
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
Definition: curs_lib.c:184
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:43
char * mutt_body_get_charset(struct Body *b, char *buf, size_t buflen)
Get a body's character set.
Definition: body.c:131
int mutt_file_copy_stream(FILE *fp_in, FILE *fp_out)
Copy the contents of one file into another.
Definition: file.c:262
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:636
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:196
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:218
void pgp_class_void_passphrase(void)
Forget the cached passphrase - Implements CryptModuleSpecs::void_passphrase() -.
Definition: pgp.c:77
#define mutt_perror(...)
Definition: logging2.h:93
@ ENC_7BIT
7-bit text
Definition: mime.h:49
@ TYPE_TEXT
Type: 'text/*'.
Definition: mime.h:38
@ DISP_NONE
No preferred disposition.
Definition: mime.h:65
int mutt_ch_fgetconv(struct FgetConv *fc)
Convert a file's character set.
Definition: charset.c:978
struct FgetConv * mutt_ch_fgetconv_open(FILE *fp, const char *from, const char *to, uint8_t flags)
Prepare a file for charset conversion.
Definition: charset.c:928
void mutt_ch_fgetconv_close(struct FgetConv **ptr)
Close an fgetconv handle.
Definition: charset.c:960
#define mutt_ch_is_us_ascii(str)
Definition: charset.h:97
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition: charset.h:71
#define _(a)
Definition: message.h:28
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:775
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:251
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:79
#define SEC_SIGN
Email is signed.
Definition: lib.h:80
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
Definition: parameter.c:110
static char PgpPass[1024]
Cached PGP Passphrase.
Definition: pgp.c:70
bool pgp_use_gpg_agent(void)
Does the user want to use the gpg agent?
Definition: pgp.c:128
pid_t pgp_invoke_traditional(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname, const char *uids, SecurityFlags flags)
Use PGP to create in inline-signed message.
Definition: pgpinvoke.c:382
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
The body of an email.
Definition: body.h:36
bool noconv
Don't do character set conversion.
Definition: body.h:46
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
Definition: body.h:67
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:62
bool use_disp
Content-Disposition uses filename= ?
Definition: body.h:47
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
char * subtype
content-type subtype
Definition: body.h:60
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:58
String manipulation buffer.
Definition: buffer.h:34
Cursor for converting a file's encoding.
Definition: charset.h:41
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
#define buf_mktemp(buf)
Definition: tmp.h:33
#define mutt_file_mkstemp()
Definition: tmp.h:36
+ Here is the call graph for this function: