mailcap.h File Reference

RFC1524 Mailcap routines. More...

#include <stdbool.h>
#include <stddef.h>

Include dependency graph for mailcap.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	MailcapEntry
	A mailcap entry. More...

Enumerations
enum	MailcapLookup {   MUTT_MC_NO_FLAGS = 0 , MUTT_MC_EDIT , MUTT_MC_COMPOSE , MUTT_MC_PRINT ,   MUTT_MC_AUTOVIEW }
	Mailcap actions. More...

Functions
void	mailcap_entry_free (struct MailcapEntry **ptr)
	Deallocate an struct MailcapEntry.
struct MailcapEntry *	mailcap_entry_new (void)
	Allocate memory for a new rfc1524 entry.
int	mailcap_expand_command (struct Body *b, const char *filename, const char *type, struct Buffer *command)
	Expand expandos in a command.
void	mailcap_expand_filename (const char *nametemplate, const char *oldfile, struct Buffer *newfile)
	Expand a new filename from a template or existing filename.
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.

Detailed Description

RFC1524 Mailcap routines.

Authors

• Richard Russon
• Pietro Cerutti

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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

Enumeration Type Documentation

MailcapLookup

enum MailcapLookup

Mailcap actions.

Enumerator
MUTT_MC_NO_FLAGS	No flags set.
MUTT_MC_EDIT	Mailcap edit field.
MUTT_MC_COMPOSE	Mailcap compose field.
MUTT_MC_PRINT	Mailcap print field.
MUTT_MC_AUTOVIEW	Mailcap autoview field.

Definition at line 55 of file mailcap.h.

{
  MUTT_MC_NO_FLAGS = 0, 
  MUTT_MC_EDIT,         
  MUTT_MC_COMPOSE,      
  MUTT_MC_PRINT,        
  MUTT_MC_AUTOVIEW,     
};

Function Documentation

mailcap_entry_free()

void mailcap_entry_free

(

struct MailcapEntry **

ptr

)

Deallocate an struct MailcapEntry.

Parameters

[out]

ptr

MailcapEntry to deallocate

Definition at line 455 of file mailcap.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct MailcapEntry *me = *ptr;
 
  FREE(&me->command);
  FREE(&me->testcommand);
  FREE(&me->composecommand);
  FREE(&me->composetypecommand);
  FREE(&me->editcommand);
  FREE(&me->printcommand);
  FREE(&me->nametemplate);
  FREE(ptr);
}

Here is the caller graph for this function:

mailcap_entry_new()

struct MailcapEntry * mailcap_entry_new

(

void

)

Allocate memory for a new rfc1524 entry.

Return values

ptr	An un-initialized struct MailcapEntry

Definition at line 446 of file mailcap.c.

{
  return MUTT_MEM_CALLOC(1, struct MailcapEntry);
}

Here is the caller graph for this function:

mailcap_expand_command()

int mailcap_expand_command	(	struct Body *	b,
		const char *	filename,
		const char *	type,
		struct Buffer *	command )

Expand expandos in a command.

Parameters

b	Email Body
filename	File containing the email text
type	Type, e.g. "text/plain"
command	Buffer containing command

Return values

0	Command works on a file
1	Command works on a pipe

The command semantics include the following: s is the filename that contains the mail body data t is the content type, like text/plain %{parameter} is replaced by the parameter value from the content-type field % is % Unsupported rfc1524 parameters: these would probably require some doing by neomutt, and can probably just be done by piping the message to metamail n is the integer number of sub-parts in the multipart F is "content-type filename" repeated for each sub-part

Definition at line 70 of file mailcap.c.

{
  int needspipe = true;
  struct Buffer *buf = buf_pool_get();
  struct Buffer *quoted = buf_pool_get();
  struct Buffer *param = NULL;
  struct Buffer *type2 = NULL;
 
  const bool c_mailcap_sanitize = cs_subset_bool(NeoMutt->sub, "mailcap_sanitize");
  const char *cptr = buf_string(command);
  while (*cptr)
  {
    if (*cptr == '\\')
    {
      cptr++;
      if (*cptr)
        buf_addch(buf, *cptr++);
    }
    else if (*cptr == '%')
    {
      cptr++;
      if (*cptr == '{')
      {
        const char *pvalue2 = NULL;
 
        if (param)
          buf_reset(param);
        else
          param = buf_pool_get();
 
        /* Copy parameter name into param buffer */
        cptr++;
        while (*cptr && (*cptr != '}'))
          buf_addch(param, *cptr++);
 
        /* In send mode, use the current charset, since the message hasn't
         * been converted yet.   If noconv is set, then we assume the
         * charset parameter has the correct value instead. */
        if (mutt_istr_equal(buf_string(param), "charset") && b->charset && !b->noconv)
          pvalue2 = b->charset;
        else
          pvalue2 = mutt_param_get(&b->parameter, buf_string(param));
 
        /* Now copy the parameter value into param buffer */
        if (c_mailcap_sanitize)
          buf_sanitize_filename(param, NONULL(pvalue2), false);
        else
          buf_strcpy(param, pvalue2);
 
        buf_quote_filename(quoted, buf_string(param), true);
        buf_addstr(buf, buf_string(quoted));
      }
      else if ((*cptr == 's') && filename)
      {
        buf_quote_filename(quoted, filename, true);
        buf_addstr(buf, buf_string(quoted));
        needspipe = false;
      }
      else if (*cptr == 't')
      {
        if (!type2)
        {
          type2 = buf_pool_get();
          if (c_mailcap_sanitize)
            buf_sanitize_filename(type2, type, false);
          else
            buf_strcpy(type2, type);
        }
        buf_quote_filename(quoted, buf_string(type2), true);
        buf_addstr(buf, buf_string(quoted));
      }
 
      if (*cptr)
        cptr++;
    }
    else
    {
      buf_addch(buf, *cptr++);
    }
  }
  buf_copy(command, buf);
 
  buf_pool_release(&buf);
  buf_pool_release(&quoted);
  buf_pool_release(&param);
  buf_pool_release(&type2);
 
  return needspipe;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mailcap_expand_filename()

void mailcap_expand_filename	(	const char *	nametemplate,
		const char *	oldfile,
		struct Buffer *	newfile )

Expand a new filename from a template or existing filename.

Parameters

nametemplate	Template
oldfile	Original filename
newfile	Buffer for new filename

If there is no nametemplate, the stripped oldfile name is used as the template for newfile.

If there is no oldfile, the stripped nametemplate name is used as the template for newfile.

If both a nametemplate and oldfile are specified, the template is checked for a "%s". If none is found, the nametemplate is used as the template for newfile. The first path component of the nametemplate and oldfile are ignored.

Definition at line 553 of file mailcap.c.

{
  int i, j, k;
  char *s = NULL;
  bool lmatch = false, rmatch = false;
 
  buf_reset(newfile);
 
  /* first, ignore leading path components */
 
  if (nametemplate && (s = strrchr(nametemplate, '/')))
    nametemplate = s + 1;
 
  if (oldfile && (s = strrchr(oldfile, '/')))
    oldfile = s + 1;
 
  if (!nametemplate)
  {
    if (oldfile)
      buf_strcpy(newfile, oldfile);
  }
  else if (!oldfile)
  {
    mutt_file_expand_fmt(newfile, nametemplate, "neomutt");
  }
  else /* oldfile && nametemplate */
  {
    /* first, compare everything left from the "%s"
     * (if there is one).  */
 
    lmatch = true;
    bool ps = false;
    for (i = 0; nametemplate[i]; i++)
    {
      if ((nametemplate[i] == '%') && (nametemplate[i + 1] == 's'))
      {
        ps = true;
        break;
      }
 
      /* note that the following will _not_ read beyond oldfile's end. */
 
      if (lmatch && (nametemplate[i] != oldfile[i]))
        lmatch = false;
    }
 
    if (ps)
    {
      /* If we had a "%s", check the rest. */
 
      /* now, for the right part: compare everything right from
       * the "%s" to the final part of oldfile.
       *
       * The logic here is as follows:
       *
       * - We start reading from the end.
       * - There must be a match _right_ from the "%s",
       *   thus the i + 2.
       * - If there was a left hand match, this stuff
       *   must not be counted again.  That's done by the
       *   condition (j >= (lmatch ? i : 0)).  */
 
      rmatch = true;
 
      for (j = mutt_str_len(oldfile) - 1, k = mutt_str_len(nametemplate) - 1;
           (j >= (lmatch ? i : 0)) && (k >= (i + 2)); j--, k--)
      {
        if (nametemplate[k] != oldfile[j])
        {
          rmatch = false;
          break;
        }
      }
 
      /* Now, check if we had a full match. */
 
      if (k >= i + 2)
        rmatch = false;
 
      struct Buffer *left = buf_pool_get();
      struct Buffer *right = buf_pool_get();
 
      if (!lmatch)
        buf_strcpy_n(left, nametemplate, i);
      if (!rmatch)
        buf_strcpy(right, nametemplate + i + 2);
      buf_printf(newfile, "%s%s%s", buf_string(left), oldfile, buf_string(right));
 
      buf_pool_release(&left);
      buf_pool_release(&right);
    }
    else
    {
      /* no "%s" in the name template. */
      buf_strcpy(newfile, nametemplate);
    }
  }
 
  mutt_adv_mktemp(newfile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mailcap_lookup()

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.

Parameters

b	Message body
type	Text type in "type/subtype" format
typelen	Length of the type
entry	struct MailcapEntry to populate with results
opt	Type of mailcap entry to lookup, see MailcapLookup

Return values

true	If *entry is not NULL it populates it with the mailcap entry
false	No matching entry is found

Find the given type in the list of mailcap files.

Definition at line 484 of file mailcap.c.

{
  /* rfc1524 specifies that a path of mailcap files should be searched.
   * joy.  They say
   * $HOME/.mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap, etc
   * and overridden by the MAILCAPS environment variable, and, just to be nice,
   * we'll make it specifiable in .neomuttrc */
  const struct Slist *c_mailcap_path = cs_subset_slist(NeoMutt->sub, "mailcap_path");
  if (!c_mailcap_path || (c_mailcap_path->count == 0))
  {
    /* L10N:
       Mutt is trying to look up a mailcap value, but $mailcap_path is empty.
       We added a reference to the MAILCAPS environment variable as a hint too.
 
       Because the variable is automatically populated by Mutt, this
       should only occur if the user deliberately runs in their shell:
         export MAILCAPS=
 
       or deliberately runs inside Mutt or their .muttrc:
         set mailcap_path=""
         -or-
         unset mailcap_path
    */
    mutt_error(_("Neither mailcap_path nor MAILCAPS specified"));
    return false;
  }
 
  mutt_check_lookup_list(b, type, typelen);
 
  struct Buffer *path = buf_pool_get();
  bool found = false;
 
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &c_mailcap_path->head, entries)
  {
    buf_strcpy(path, np->data);
    expand_path(path, false);
 
    mutt_debug(LL_DEBUG2, "Checking mailcap file: %s\n", buf_string(path));
    found = rfc1524_mailcap_parse(b, buf_string(path), type, entry, opt);
    if (found)
      break;
  }
 
  buf_pool_release(&path);
 
  if (entry && !found)
    mutt_error(_("mailcap entry for type %s not found"), type);
 
  return found;
}

Here is the call graph for this function:

Here is the caller graph for this function: