NeoMutt  2021-10-29-225-gb9986f
Teaching an old dog new tricks
DOXYGEN
attachments.c File Reference

Handle the attachments command. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.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 "attachments.h"
#include "ncrypt/lib.h"
#include "init.h"
#include "mutt_commands.h"
+ Include dependency graph for attachments.c:

Go to the source code of this file.

Data Structures

struct  AttachMatch
 An attachment matching a regex for attachment counter. More...
 

Functions

static void attachmatch_free (struct AttachMatch **ptr)
 Free an AttachMatch - Implements list_free_t -. More...
 
static struct AttachMatchattachmatch_new (void)
 Create a new AttachMatch. More...
 
void attach_free (void)
 Free the attachments lists. More...
 
void attach_init (void)
 Set up the attachments lists. More...
 
static bool count_body_parts_check (struct ListHead *checklist, struct Body *b, bool dflt)
 Compares mime types to the ok and except lists. More...
 
static int count_body_parts (struct Body *body)
 Count the MIME Body parts. More...
 
int mutt_count_body_parts (struct Mailbox *m, struct Email *e, FILE *fp)
 Count the MIME Body parts. More...
 
void mutt_attachments_reset (struct Mailbox *m)
 Reset the attachment count for all Emails. More...
 
static enum CommandResult parse_attach_list (struct Buffer *buf, struct Buffer *s, struct ListHead *head, struct Buffer *err)
 Parse the "attachments" command. More...
 
static enum CommandResult parse_unattach_list (struct Buffer *buf, struct Buffer *s, struct ListHead *head, struct Buffer *err)
 Parse the "unattachments" command. More...
 
static int print_attach_list (struct ListHead *h, const char op, const char *name)
 Print a list of attachments. More...
 
enum CommandResult parse_attachments (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'attachments' command - Implements Command::parse() -. More...
 
enum CommandResult parse_unattachments (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unattachments' command - Implements Command::parse() -. More...
 
void mutt_parse_mime_message (struct Email *e, FILE *fp)
 Parse a MIME email. More...
 

Variables

struct ListHead AttachAllow = STAILQ_HEAD_INITIALIZER(AttachAllow)
 List of attachment types to be counted. More...
 
struct ListHead AttachExclude = STAILQ_HEAD_INITIALIZER(AttachExclude)
 List of attachment types to be ignored. More...
 
struct ListHead InlineAllow = STAILQ_HEAD_INITIALIZER(InlineAllow)
 List of inline types to counted. More...
 
struct ListHead InlineExclude = STAILQ_HEAD_INITIALIZER(InlineExclude)
 List of inline types to ignore. More...
 
static struct NotifyAttachmentsNotify = NULL
 

Detailed Description

Handle the attachments command.

Authors
  • Michael R. Elkins

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 attachments.c.

Function Documentation

◆ attachmatch_new()

static struct AttachMatch* attachmatch_new ( void  )
static

Create a new AttachMatch.

Return values
ptrNew AttachMatch

Definition at line 84 of file attachments.c.

85 {
86  return mutt_mem_calloc(1, sizeof(struct AttachMatch));
87 }
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
An attachment matching a regex for attachment counter.
Definition: attachments.c:49
+ Here is the call graph for this function:

◆ attach_free()

void attach_free ( void  )

Free the attachments lists.

Definition at line 92 of file attachments.c.

93 {
95 
96  /* Lists of AttachMatch */
101 }
struct ListHead AttachAllow
List of attachment types to be counted.
Definition: attachments.c:56
struct ListHead InlineExclude
List of inline types to ignore.
Definition: attachments.c:59
struct ListHead AttachExclude
List of attachment types to be ignored.
Definition: attachments.c:57
static struct Notify * AttachmentsNotify
Definition: attachments.c:60
struct ListHead InlineAllow
List of inline types to counted.
Definition: attachments.c:58
static void attachmatch_free(struct AttachMatch **ptr)
Free an AttachMatch - Implements list_free_t -.
Definition: attachments.c:69
void mutt_list_free_type(struct ListHead *h, list_free_t fn)
Free a List of type.
Definition: list.c:144
void(* list_free_t)(void **ptr)
Definition: list.h:48
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:73
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ attach_init()

void attach_init ( void  )

Set up the attachments lists.

Definition at line 106 of file attachments.c.

107 {
108  if (AttachmentsNotify)
109  return;
110 
113 }
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:60
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:93
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct Notify * notify
Notifications handler.
Definition: neomutt.h:38
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ count_body_parts_check()

static bool count_body_parts_check ( struct ListHead *  checklist,
struct Body b,
bool  dflt 
)
static

Compares mime types to the ok and except lists.

Parameters
checklistList of AttachMatch
bEmail Body
dfltLog whether the matches are OK, or Excluded
Return values
trueAttachment should be counted

Definition at line 122 of file attachments.c.

123 {
124  /* If list is null, use default behavior. */
125  if (!checklist || STAILQ_EMPTY(checklist))
126  {
127  return false;
128  }
129 
130  struct AttachMatch *a = NULL;
131  struct ListNode *np = NULL;
132  STAILQ_FOREACH(np, checklist, entries)
133  {
134  a = (struct AttachMatch *) np->data;
135  mutt_debug(LL_DEBUG3, "%s %d/%s ?? %s/%s [%d]... ", dflt ? "[OK] " : "[EXCL] ",
136  b->type, b->subtype ? b->subtype : "*", a->major, a->minor, a->major_int);
137  if (((a->major_int == TYPE_ANY) || (a->major_int == b->type)) &&
138  (!b->subtype || (regexec(&a->minor_regex, b->subtype, 0, NULL, 0) == 0)))
139  {
140  mutt_debug(LL_DEBUG3, "yes\n");
141  return true;
142  }
143  else
144  {
145  mutt_debug(LL_DEBUG3, "no\n");
146  }
147  }
148 
149  return false;
150 }
#define mutt_debug(LEVEL,...)
Definition: logging.h:84
@ LL_DEBUG3
Log at debug level 3.
Definition: logging.h:42
@ TYPE_ANY
Type: '*' or '.*'.
Definition: mime.h:40
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define STAILQ_EMPTY(head)
Definition: queue.h:348
const char * minor
Minor mime type, e.g. "html".
Definition: attachments.c:52
regex_t minor_regex
Minor mime type regex.
Definition: attachments.c:53
const char * major
Major mime type, e.g. "text".
Definition: attachments.c:50
enum ContentType major_int
Major mime type, e.g. TYPE_TEXT.
Definition: attachments.c:51
char * subtype
content-type subtype
Definition: body.h:59
unsigned int type
content-type primary type, ContentType
Definition: body.h:39
A List node for strings.
Definition: list.h:35
char * data
String.
Definition: list.h:36
+ Here is the caller graph for this function:

◆ count_body_parts()

static int count_body_parts ( struct Body body)
static

Count the MIME Body parts.

Parameters
bodyBody of email
Return values
numNumber of MIME Body parts

Definition at line 157 of file attachments.c.

158 {
159  if (!body)
160  return 0;
161 
162  int count = 0;
163 
164  for (struct Body *bp = body; bp; bp = bp->next)
165  {
166  /* Initial disposition is to count and not to recurse this part. */
167  bool shallcount = true; /* default */
168  bool shallrecurse = false;
169 
170  mutt_debug(LL_DEBUG5, "desc=\"%s\"; fn=\"%s\", type=\"%d/%s\"\n",
171  bp->description ? bp->description : ("none"),
172  bp->filename ? bp->filename :
173  bp->d_filename ? bp->d_filename :
174  "(none)",
175  bp->type, bp->subtype ? bp->subtype : "*");
176 
177  if (bp->type == TYPE_MESSAGE)
178  {
179  shallrecurse = true;
180 
181  /* If it's an external body pointer, don't recurse it. */
182  if (mutt_istr_equal(bp->subtype, "external-body"))
183  shallrecurse = false;
184  }
185  else if (bp->type == TYPE_MULTIPART)
186  {
187  /* Always recurse multiparts, except multipart/alternative. */
188  shallrecurse = true;
189  if (mutt_istr_equal(bp->subtype, "alternative"))
190  {
191  const bool c_count_alternatives =
192  cs_subset_bool(NeoMutt->sub, "count_alternatives");
193  shallrecurse = c_count_alternatives;
194  }
195  }
196 
197  if ((bp->disposition == DISP_INLINE) && (bp->type != TYPE_MULTIPART) &&
198  (bp->type != TYPE_MESSAGE) && (bp == body))
199  {
200  shallcount = false; /* ignore fundamental inlines */
201  }
202 
203  /* If this body isn't scheduled for enumeration already, don't bother
204  * profiling it further. */
205  if (shallcount)
206  {
207  /* Turn off shallcount if message type is not in ok list,
208  * or if it is in except list. Check is done separately for
209  * inlines vs. attachments. */
210 
211  if (bp->disposition == DISP_ATTACH)
212  {
213  if (!count_body_parts_check(&AttachAllow, bp, true))
214  shallcount = false; /* attach not allowed */
215  if (count_body_parts_check(&AttachExclude, bp, false))
216  shallcount = false; /* attach excluded */
217  }
218  else
219  {
220  if (!count_body_parts_check(&InlineAllow, bp, true))
221  shallcount = false; /* inline not allowed */
222  if (count_body_parts_check(&InlineExclude, bp, false))
223  shallcount = false; /* excluded */
224  }
225  }
226 
227  if (shallcount)
228  count++;
229  bp->attach_qualifies = shallcount;
230 
231  mutt_debug(LL_DEBUG3, "%p shallcount = %d\n", (void *) bp, shallcount);
232 
233  if (shallrecurse)
234  {
235  mutt_debug(LL_DEBUG3, "%p pre count = %d\n", (void *) bp, count);
236  bp->attach_count = count_body_parts(bp->parts);
237  count += bp->attach_count;
238  mutt_debug(LL_DEBUG3, "%p post count = %d\n", (void *) bp, count);
239  }
240  }
241 
242  mutt_debug(LL_DEBUG3, "return %d\n", (count < 0) ? 0 : count);
243  return (count < 0) ? 0 : count;
244 }
static int count_body_parts(struct Body *body)
Count the MIME Body parts.
Definition: attachments.c:157
static bool count_body_parts_check(struct ListHead *checklist, struct Body *b, bool dflt)
Compares mime types to the ok and except lists.
Definition: attachments.c:122
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
@ LL_DEBUG5
Log at debug level 5.
Definition: logging.h:44
@ TYPE_MESSAGE
Type: 'message/*'.
Definition: mime.h:35
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
@ DISP_ATTACH
Content is attached.
Definition: mime.h:63
@ DISP_INLINE
Content is inline.
Definition: mime.h:62
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:727
The body of an email.
Definition: body.h:35
struct Body * next
next attachment in the list
Definition: body.h:70
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_count_body_parts()

int mutt_count_body_parts ( struct Mailbox m,
struct Email e,
FILE *  fp 
)

Count the MIME Body parts.

Parameters
mMailbox
eEmail
fpFile to parse
Return values
numNumber of MIME Body parts

Definition at line 253 of file attachments.c.

254 {
255  if (!m || !e)
256  return 0;
257 
258  bool keep_parts = false;
259 
260  if (e->attach_valid)
261  return e->attach_total;
262 
263  if (e->body->parts)
264  keep_parts = true;
265  else
267 
270  {
272  }
273  else
274  e->attach_total = 0;
275 
276  e->attach_valid = true;
277 
278  if (!keep_parts)
279  mutt_body_free(&e->body->parts);
280 
281  return e->attach_total;
282 }
void mutt_parse_mime_message(struct Email *e, FILE *fp)
Parse a MIME email.
Definition: attachments.c:593
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:71
bool attach_valid
true when the attachment count is valid
Definition: email.h:100
struct Body * body
List of MIME parts.
Definition: email.h:67
short attach_total
Number of qualifying attachments in message, if attach_valid.
Definition: email.h:115
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_attachments_reset()

void mutt_attachments_reset ( struct Mailbox m)

Reset the attachment count for all Emails.

Definition at line 287 of file attachments.c.

288 {
289  if (!m)
290  return;
291 
292  for (int i = 0; i < m->msg_count; i++)
293  {
294  struct Email *e = m->emails[i];
295  if (!e)
296  break;
297  e->attach_valid = false;
298  e->attach_total = 0;
299  }
300 }
The envelope/body of an email.
Definition: email.h:37
int msg_count
Total number of messages.
Definition: mailbox.h:91
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
+ Here is the caller graph for this function:

◆ parse_attach_list()

static enum CommandResult parse_attach_list ( struct Buffer buf,
struct Buffer s,
struct ListHead *  head,
struct Buffer err 
)
static

Parse the "attachments" command.

Parameters
bufBuffer for temporary storage
sBuffer containing the attachments command
headList of AttachMatch to add to
errBuffer for error messages
Return values
CommandResultResult e.g. MUTT_CMD_SUCCESS

Definition at line 287 of file attachments.c.

312 {
313  struct AttachMatch *a = NULL;
314  char *p = NULL;
315  char *tmpminor = NULL;
316  size_t len;
317  int ret;
318 
319  do
320  {
322 
323  if (!buf->data || (*buf->data == '\0'))
324  continue;
325 
326  a = attachmatch_new();
327 
328  /* some cheap hacks that I expect to remove */
329  if (mutt_istr_equal(buf->data, "any"))
330  a->major = mutt_str_dup("*/.*");
331  else if (mutt_istr_equal(buf->data, "none"))
332  a->major = mutt_str_dup("cheap_hack/this_should_never_match");
333  else
334  a->major = mutt_str_dup(buf->data);
335 
336  p = strchr(a->major, '/');
337  if (p)
338  {
339  *p = '\0';
340  p++;
341  a->minor = p;
342  }
343  else
344  {
345  a->minor = "unknown";
346  }
347 
348  len = strlen(a->minor);
349  tmpminor = mutt_mem_malloc(len + 3);
350  strcpy(&tmpminor[1], a->minor);
351  tmpminor[0] = '^';
352  tmpminor[len + 1] = '$';
353  tmpminor[len + 2] = '\0';
354 
356  ret = REG_COMP(&a->minor_regex, tmpminor, REG_ICASE);
357 
358  FREE(&tmpminor);
359 
360  if (ret != 0)
361  {
362  regerror(ret, &a->minor_regex, err->data, err->dsize);
363  FREE(&a->major);
364  FREE(&a);
365  return MUTT_CMD_ERROR;
366  }
367 
368  mutt_debug(LL_DEBUG3, "added %s/%s [%d]\n", a->major, a->minor, a->major_int);
369 
370  mutt_list_insert_tail(head, (char *) a);
371  } while (MoreArgs(s));
372 
373  if (!a)
374  return MUTT_CMD_ERROR;
375 
376  mutt_debug(LL_NOTIFY, "NT_ATTACH_ADD: %s/%s\n", a->major, a->minor);
378 
379  return MUTT_CMD_SUCCESS;
380 }
static struct AttachMatch * attachmatch_new(void)
Create a new AttachMatch.
Definition: attachments.c:84
@ NT_ATTACH_ADD
Attachment regex has been added.
Definition: attachments.h:38
#define MoreArgs(buf)
Definition: buffer.h:40
@ MUTT_CMD_SUCCESS
Success: Command worked.
Definition: command.h:37
@ MUTT_CMD_ERROR
Error: Can't help the user.
Definition: command.h:35
int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: init.c:399
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:64
@ LL_NOTIFY
Log of notifications.
Definition: logging.h:45
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
#define FREE(x)
Definition: memory.h:40
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:171
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:181
#define MUTT_TOKEN_NO_FLAGS
No flags are set.
Definition: mutt.h:66
@ NT_ATTACH
Attachment command changed, NotifyAttach.
Definition: notify_type.h:37
enum ContentType mutt_check_mime_type(const char *s)
Check a MIME type string.
Definition: parse.c:324
#define REG_COMP(preg, regex, cflags)
Compile a regular expression.
Definition: regex3.h:54
size_t dsize
Length of data.
Definition: buffer.h:37
char * data
Pointer to data.
Definition: buffer.h:35

◆ parse_unattach_list()

static enum CommandResult parse_unattach_list ( struct Buffer buf,
struct Buffer s,
struct ListHead *  head,
struct Buffer err 
)
static

Parse the "unattachments" command.

Parameters
bufBuffer for temporary storage
sBuffer containing the unattachments command
headList of AttachMatch to remove from
errBuffer for error messages
Return values
MUTT_CMD_SUCCESSAlways

Definition at line 287 of file attachments.c.

392 {
393  struct AttachMatch *a = NULL;
394  char *tmp = NULL;
395  char *minor = NULL;
396 
397  do
398  {
400  FREE(&tmp);
401 
402  if (mutt_istr_equal(buf->data, "any"))
403  tmp = mutt_str_dup("*/.*");
404  else if (mutt_istr_equal(buf->data, "none"))
405  tmp = mutt_str_dup("cheap_hack/this_should_never_match");
406  else
407  tmp = mutt_str_dup(buf->data);
408 
409  minor = strchr(tmp, '/');
410  if (minor)
411  {
412  *minor = '\0';
413  minor++;
414  }
415  else
416  {
417  minor = "unknown";
418  }
419  const enum ContentType major = mutt_check_mime_type(tmp);
420 
421  struct ListNode *np = NULL, *tmp2 = NULL;
422  STAILQ_FOREACH_SAFE(np, head, entries, tmp2)
423  {
424  a = (struct AttachMatch *) np->data;
425  mutt_debug(LL_DEBUG3, "check %s/%s [%d] : %s/%s [%d]\n", a->major,
426  a->minor, a->major_int, tmp, minor, major);
427  if ((a->major_int == major) && mutt_istr_equal(minor, a->minor))
428  {
429  mutt_debug(LL_DEBUG3, "removed %s/%s [%d]\n", a->major, a->minor, a->major_int);
430  mutt_debug(LL_NOTIFY, "NT_ATTACH_DELETE: %s/%s\n", a->major, a->minor);
431 
432  regfree(&a->minor_regex);
433  FREE(&a->major);
434  STAILQ_REMOVE(head, np, ListNode, entries);
435  FREE(&np->data);
436  FREE(&np);
437  }
438  }
439 
440  } while (MoreArgs(s));
441 
442  FREE(&tmp);
443 
445 
446  return MUTT_CMD_SUCCESS;
447 }
@ NT_ATTACH_DELETE
Attachment regex has been deleted.
Definition: attachments.h:39
ContentType
Content-Type.
Definition: mime.h:30
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:402
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:362

◆ print_attach_list()

static int print_attach_list ( struct ListHead *  h,
const char  op,
const char *  name 
)
static

Print a list of attachments.

Parameters
hList of attachments
opOperation, e.g. '+', '-'
nameAttached/Inline, 'A', 'I'
Return values
0Always

Definition at line 456 of file attachments.c.

457 {
458  struct ListNode *np = NULL;
459  STAILQ_FOREACH(np, h, entries)
460  {
461  printf("attachments %c%s %s/%s\n", op, name,
462  ((struct AttachMatch *) np->data)->major,
463  ((struct AttachMatch *) np->data)->minor);
464  }
465 
466  return 0;
467 }

◆ mutt_parse_mime_message()

void mutt_parse_mime_message ( struct Email e,
FILE *  fp 
)

Parse a MIME email.

Parameters
eEmail
fpFile to parse

Definition at line 593 of file attachments.c.

594 {
595  const bool right_type =
596  (e->body->type == TYPE_MESSAGE) || (e->body->type == TYPE_MULTIPART);
597  const bool not_parsed = (e->body->parts == NULL);
598 
599  if (right_type && fp && not_parsed)
600  {
601  mutt_parse_part(fp, e->body);
602  if (WithCrypto)
603  {
604  e->security = crypt_query(e->body);
605  }
606  }
607 
608  e->attach_valid = false;
609 }
SecurityFlags crypt_query(struct Body *b)
Check out the type of encryption used.
Definition: crypt.c:692
#define WithCrypto
Definition: lib.h:113
void mutt_parse_part(FILE *fp, struct Body *b)
Parse a MIME part.
Definition: parse.c:1730
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:41
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ AttachAllow

struct ListHead AttachAllow = STAILQ_HEAD_INITIALIZER(AttachAllow)

List of attachment types to be counted.

Definition at line 1 of file attachments.c.

◆ AttachExclude

struct ListHead AttachExclude = STAILQ_HEAD_INITIALIZER(AttachExclude)

List of attachment types to be ignored.

Definition at line 1 of file attachments.c.

◆ InlineAllow

struct ListHead InlineAllow = STAILQ_HEAD_INITIALIZER(InlineAllow)

List of inline types to counted.

Definition at line 1 of file attachments.c.

◆ InlineExclude

struct ListHead InlineExclude = STAILQ_HEAD_INITIALIZER(InlineExclude)

List of inline types to ignore.

Definition at line 1 of file attachments.c.

◆ AttachmentsNotify

struct Notify* AttachmentsNotify = NULL
static

Definition at line 60 of file attachments.c.