NeoMutt  2024-04-25-89-g194907
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 1721 of file pgp.c.

1722{
1723 struct Body *b_enc = NULL;
1724 char body_charset[256] = { 0 };
1725 const char *from_charset = NULL;
1726 const char *send_charset = NULL;
1727 bool empty = false;
1728 bool err;
1729 char buf[256] = { 0 };
1730 pid_t pid;
1731 struct Buffer *pgpinfile = buf_pool_get();
1732 struct Buffer *pgpoutfile = buf_pool_get();
1733
1734 if (b->type != TYPE_TEXT)
1735 goto cleanup;
1736 if (!mutt_istr_equal(b->subtype, "plain"))
1737 goto cleanup;
1738
1739 FILE *fp_body = mutt_file_fopen(b->filename, "r");
1740 if (!fp_body)
1741 {
1742 mutt_perror("%s", b->filename);
1743 goto cleanup;
1744 }
1745
1746 buf_mktemp(pgpinfile);
1747 FILE *fp_pgp_in = mutt_file_fopen(buf_string(pgpinfile), "w");
1748 if (!fp_pgp_in)
1749 {
1750 mutt_perror("%s", buf_string(pgpinfile));
1751 mutt_file_fclose(&fp_body);
1752 goto cleanup;
1753 }
1754
1755 /* The following code is really correct: If noconv is set,
1756 * b's charset parameter contains the on-disk character set, and
1757 * we have to convert from that to utf-8. If noconv is not set,
1758 * we have to convert from $charset to utf-8. */
1759
1760 mutt_body_get_charset(b, body_charset, sizeof(body_charset));
1761 if (b->noconv)
1762 from_charset = body_charset;
1763 else
1764 from_charset = cc_charset();
1765
1766 if (mutt_ch_is_us_ascii(body_charset))
1767 {
1768 send_charset = "us-ascii";
1769 mutt_file_copy_stream(fp_body, fp_pgp_in);
1770 }
1771 else
1772 {
1773 int c;
1774 struct FgetConv *fc = NULL;
1775
1776 if (flags & SEC_ENCRYPT)
1777 send_charset = "us-ascii";
1778 else
1779 send_charset = "utf-8";
1780
1781 /* fromcode is assumed to be correct: we set flags to 0 */
1782 fc = mutt_ch_fgetconv_open(fp_body, from_charset, "utf-8", MUTT_ICONV_NO_FLAGS);
1783 while ((c = mutt_ch_fgetconv(fc)) != EOF)
1784 fputc(c, fp_pgp_in);
1785
1787 }
1788 mutt_file_fclose(&fp_body);
1789 mutt_file_fclose(&fp_pgp_in);
1790
1791 buf_mktemp(pgpoutfile);
1792 FILE *fp_pgp_out = mutt_file_fopen(buf_string(pgpoutfile), "w+");
1793 FILE *fp_pgp_err = mutt_file_mkstemp();
1794 if (!fp_pgp_out || !fp_pgp_err)
1795 {
1796 mutt_perror("%s", fp_pgp_out ? "Can't create temporary file" : buf_string(pgpoutfile));
1797 unlink(buf_string(pgpinfile));
1798 if (fp_pgp_out)
1799 {
1800 mutt_file_fclose(&fp_pgp_out);
1801 unlink(buf_string(pgpoutfile));
1802 }
1803 mutt_file_fclose(&fp_pgp_err);
1804 goto cleanup;
1805 }
1806
1807 pid = pgp_invoke_traditional(&fp_pgp_in, NULL, NULL, -1, fileno(fp_pgp_out),
1808 fileno(fp_pgp_err), buf_string(pgpinfile), keylist, flags);
1809 if (pid == -1)
1810 {
1811 mutt_perror(_("Can't invoke PGP"));
1812 mutt_file_fclose(&fp_pgp_out);
1813 mutt_file_fclose(&fp_pgp_err);
1814 mutt_file_unlink(buf_string(pgpinfile));
1815 unlink(buf_string(pgpoutfile));
1816 goto cleanup;
1817 }
1818
1819 if (pgp_use_gpg_agent())
1820 *PgpPass = '\0';
1821 if (flags & SEC_SIGN)
1822 fprintf(fp_pgp_in, "%s\n", PgpPass);
1823 mutt_file_fclose(&fp_pgp_in);
1824
1825 const bool c_pgp_check_exit = cs_subset_bool(NeoMutt->sub, "pgp_check_exit");
1826 if (filter_wait(pid) && c_pgp_check_exit)
1827 empty = true;
1828
1829 mutt_file_unlink(buf_string(pgpinfile));
1830
1831 fflush(fp_pgp_out);
1832 fflush(fp_pgp_err);
1833
1834 rewind(fp_pgp_out);
1835 rewind(fp_pgp_err);
1836
1837 if (!empty)
1838 empty = (fgetc(fp_pgp_out) == EOF);
1839 mutt_file_fclose(&fp_pgp_out);
1840
1841 err = false;
1842
1843 while (fgets(buf, sizeof(buf), fp_pgp_err))
1844 {
1845 err = true;
1846 fputs(buf, stdout);
1847 }
1848
1849 mutt_file_fclose(&fp_pgp_err);
1850
1851 if (err)
1853
1854 if (empty)
1855 {
1856 if (flags & SEC_SIGN)
1857 pgp_class_void_passphrase(); /* just in case */
1858 unlink(buf_string(pgpoutfile));
1859 goto cleanup;
1860 }
1861
1862 b_enc = mutt_body_new();
1863
1864 b_enc->encoding = ENC_7BIT;
1865
1866 b_enc->type = TYPE_TEXT;
1867 b_enc->subtype = mutt_str_dup("plain");
1868
1869 mutt_param_set(&b_enc->parameter, "x-action",
1870 (flags & SEC_ENCRYPT) ? "pgp-encrypted" : "pgp-signed");
1871 mutt_param_set(&b_enc->parameter, "charset", send_charset);
1872
1873 b_enc->filename = buf_strdup(pgpoutfile);
1874
1875 b_enc->disposition = DISP_NONE;
1876 b_enc->unlink = true;
1877
1878 b_enc->noconv = true;
1879 b_enc->use_disp = false;
1880
1881 if (!(flags & SEC_ENCRYPT))
1882 b_enc->encoding = b->encoding;
1883
1884cleanup:
1885 buf_pool_release(&pgpinfile);
1886 buf_pool_release(&pgpoutfile);
1887 return b_enc;
1888}
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:571
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:116
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
Definition: curs_lib.c:173
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:44
char * mutt_body_get_charset(struct Body *b, char *buf, size_t buflen)
Get a body's character set.
Definition: body.c:132
int mutt_file_copy_stream(FILE *fp_in, FILE *fp_out)
Copy the contents of one file into another.
Definition: file.c:287
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:221
#define mutt_file_fclose(FP)
Definition: file.h:149
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:148
void pgp_class_void_passphrase(void)
Forget the cached passphrase - Implements CryptModuleSpecs::void_passphrase() -.
Definition: pgp.c:76
#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:983
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:933
void mutt_ch_fgetconv_close(struct FgetConv **ptr)
Close an fgetconv handle.
Definition: charset.c:965
#define mutt_ch_is_us_ascii(str)
Definition: charset.h:99
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition: charset.h:73
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:220
#define _(a)
Definition: message.h:28
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:78
#define SEC_SIGN
Email is signed.
Definition: lib.h:79
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
Definition: parameter.c:111
static char PgpPass[1024]
Cached PGP Passphrase.
Definition: pgp.c:69
bool pgp_use_gpg_agent(void)
Does the user want to use the gpg agent?
Definition: pgp.c:127
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:332
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:36
Cursor for converting a file's encoding.
Definition: charset.h:43
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
#define buf_mktemp(buf)
Definition: tmp.h:33
#define mutt_file_mkstemp()
Definition: tmp.h:36
+ Here is the call graph for this function: