code/cid_8c_source.html

#include "config.h"

#include <stddef.h>

#include <stdbool.h>

#include <stdio.h>

#include <string.h>

#include "email/lib.h"

#include "core/lib.h"

#include "cid.h"

#include "attach.h"

#include "mailcap.h"

#include "mutt_attach.h"


void cid_map_free(struct CidMap **ptr)

{

  if (!ptr || !*ptr)

    return;


  struct CidMap *cid_map = *ptr;


  FREE(&cid_map->cid);

  FREE(&cid_map->fname);


  FREE(ptr);

}


struct CidMap *cid_map_new(const char *cid, const char *filename)

{

  if (!cid || !filename)

    return NULL;


  struct CidMap *cid_map = mutt_mem_calloc(1, sizeof(struct CidMap));


  cid_map->cid = mutt_str_dup(cid);

  cid_map->fname = mutt_str_dup(filename);


  return cid_map;

}


void cid_map_list_clear(struct CidMapList *cid_map_list)

{

  if (!cid_map_list)

    return;


  while (!STAILQ_EMPTY(cid_map_list))

  {

    struct CidMap *cid_map = STAILQ_FIRST(cid_map_list);

    STAILQ_REMOVE_HEAD(cid_map_list, entries);

    cid_map_free(&cid_map);

  }

}


static void cid_save_attachment(struct Body *b, struct CidMapList *cid_map_list)

{

  if (!b || !cid_map_list)

    return;


  char *id = mutt_param_get(&b->parameter, "content-id");

  if (!id)

    return;


  struct Buffer *tmpfile = buf_pool_get();

  struct Buffer *cid = buf_pool_get();

  bool has_tempfile = false;

  FILE *fp = NULL;


  mutt_debug(LL_DEBUG2, "attachment found with \"Content-ID: %s\"\n", id);

  /* get filename */

  char *fname = mutt_str_dup(b->filename);

  if (b->aptr)

    fp = b->aptr->fp;

  mutt_file_sanitize_filename(fname, fp ? true : false);

  mailcap_expand_filename("%s", fname, tmpfile);

  FREE(&fname);


  /* save attachment */

  if (mutt_save_attachment(fp, b, buf_string(tmpfile), 0, NULL) == -1)

    goto bail;

  has_tempfile = true;

  mutt_debug(LL_DEBUG2, "attachment with \"Content-ID: %s\" saved to file \"%s\"\n",

             id, buf_string(tmpfile));


  /* add Content-ID to filename mapping to list */

  buf_printf(cid, "cid:%s", id);

  struct CidMap *cid_map = cid_map_new(buf_string(cid), buf_string(tmpfile));

  STAILQ_INSERT_TAIL(cid_map_list, cid_map, entries);


bail:


  if ((fp && !buf_is_empty(tmpfile)) || has_tempfile)

    mutt_add_temp_attachment(buf_string(tmpfile));

  buf_pool_release(&tmpfile);

  buf_pool_release(&cid);

}


void cid_save_attachments(struct Body *body, struct CidMapList *cid_map_list)

{

  if (!body || !cid_map_list)

    return;


  for (struct Body *b = body; b; b = b->next)

  {

    if (b->parts)

      cid_save_attachments(b->parts, cid_map_list);

    else

      cid_save_attachment(b, cid_map_list);

  }

}


void cid_to_filename(struct Buffer *filename, const struct CidMapList *cid_map_list)

{

  if (!filename || !cid_map_list)

    return;


  FILE *fp_out = NULL;

  char *pbuf = NULL;

  char *searchbuf = NULL;

  char *buf = NULL;

  char *cid = NULL;

  size_t blen = 0;

  struct CidMap *cid_map = NULL;


  struct Buffer *tmpfile = buf_pool_get();

  struct Buffer *tmpbuf = buf_pool_get();


  FILE *fp_in = mutt_file_fopen(buf_string(filename), "r");

  if (!fp_in)

    goto bail;


  /* ensure tmpfile has the same file extension as filename otherwise an

   * HTML file may be opened as plain text by the viewer */

  const char *suffix = mutt_strn_rfind(buf_string(filename), buf_len(filename), ".");

  if (suffix && *(suffix++))

    buf_mktemp_pfx_sfx(tmpfile, "neomutt", suffix);

  else

    buf_mktemp(tmpfile);

  fp_out = mutt_file_fopen(buf_string(tmpfile), "w+");

  if (!fp_out)

    goto bail;


  /* Read in lines from filename into buf */

  while ((buf = mutt_file_read_line(buf, &blen, fp_in, NULL, MUTT_RL_NO_FLAGS)) != NULL)

  {

    if (mutt_str_len(buf) == 0)

    {

      fputs(buf, fp_out);

      continue;

    }


    /* copy buf to searchbuf because we need to edit multiple times */

    searchbuf = mutt_str_dup(buf);

    buf_reset(tmpbuf);


    /* loop through Content-ID to filename mappings and do search and replace */

    STAILQ_FOREACH(cid_map, cid_map_list, entries)

    {

      pbuf = searchbuf;

      while ((cid = strstr(pbuf, cid_map->cid)) != NULL)

      {

        buf_addstr_n(tmpbuf, pbuf, cid - pbuf);

        buf_addstr(tmpbuf, cid_map->fname);

        pbuf = cid + mutt_str_len(cid_map->cid);

        mutt_debug(LL_DEBUG2, "replaced \"%s\" with \"%s\" in file \"%s\"\n",

                   cid_map->cid, cid_map->fname, buf_string(filename));

      }

      buf_addstr(tmpbuf, pbuf);

      FREE(&searchbuf);

      searchbuf = buf_strdup(tmpbuf);

      buf_reset(tmpbuf);

    }


    /* write edited line to output file */

    fputs(searchbuf, fp_out);

    fputs("\n", fp_out);

    FREE(&searchbuf);

  }


  mutt_file_set_mtime(buf_string(filename), buf_string(tmpfile));


  /* add filename to TempAtachmentsList so it doesn't get left lying around */

  mutt_add_temp_attachment(buf_string(filename));

  /* update filename to point to new file */

  buf_copy(filename, tmpfile);


bail:

  FREE(&buf);

  mutt_file_fclose(&fp_in);

  mutt_file_fclose(&fp_out);

  buf_pool_release(&tmpfile);

  buf_pool_release(&tmpbuf);

}

attach.h
Handling of email attachments.

buf_printf
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:173

buf_addstr_n
size_t buf_addstr_n(struct Buffer *buf, const char *s, size_t len)
Add a string to a Buffer, expanding it if necessary.
Definition: buffer.c:108

buf_len
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:466

buf_reset
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:88

buf_is_empty
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:303

buf_addstr
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:238

buf_copy
size_t buf_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer's contents to another Buffer.
Definition: buffer.c:572

buf_strdup
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:542

buf_string
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:93

cid_map_new
struct CidMap * cid_map_new(const char *cid, const char *filename)
Initialise a new CidMap.
Definition: cid.c:64

cid_map_free
void cid_map_free(struct CidMap **ptr)
Free a CidMap.
Definition: cid.c:45

cid_save_attachment
static void cid_save_attachment(struct Body *b, struct CidMapList *cid_map_list)
Save attachment if it has a Content-ID.
Definition: cid.c:102

cid_save_attachments
void cid_save_attachments(struct Body *body, struct CidMapList *cid_map_list)
Save all attachments in a "multipart/related" group with a Content-ID.
Definition: cid.c:150

cid_to_filename
void cid_to_filename(struct Buffer *filename, const struct CidMapList *cid_map_list)
Replace Content-IDs with filenames.
Definition: cid.c:169

cid_map_list_clear
void cid_map_list_clear(struct CidMapList *cid_map_list)
Empty a CidMapList.
Definition: cid.c:81

cid.h
Attachment Content-ID header functions.

lib.h
Convenience wrapper for the core headers.

lib.h
Structs that make up an email.

mutt_file_read_line
char * mutt_file_read_line(char *line, size_t *size, FILE *fp, int *line_num, ReadLineFlags flags)
Read a line from a file.
Definition: file.c:763

mutt_file_fopen
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:636

mutt_file_fclose
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152

mutt_file_sanitize_filename
void mutt_file_sanitize_filename(char *path, bool slash)
Replace unsafe characters in a filename.
Definition: file.c:667

mutt_file_set_mtime
void mutt_file_set_mtime(const char *from, const char *to)
Set the modification time of one file from another.
Definition: file.c:1071

MUTT_RL_NO_FLAGS
#define MUTT_RL_NO_FLAGS
No flags are set.
Definition: file.h:39

mutt_debug
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89

LL_DEBUG2
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44

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.
Definition: mailcap.c:549

mailcap.h
RFC1524 Mailcap routines.

mutt_mem_calloc
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50

FREE
#define FREE(x)
Definition: memory.h:45

mutt_str_dup
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:251

mutt_str_len
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:568

mutt_strn_rfind
const char * mutt_strn_rfind(const char *haystack, size_t haystack_length, const char *needle)
Find last instance of a substring.
Definition: string.c:847

mutt_save_attachment
int mutt_save_attachment(FILE *fp, struct Body *b, const char *path, enum SaveAttach opt, struct Email *e)
Save an attachment.
Definition: mutt_attach.c:906

mutt_add_temp_attachment
void mutt_add_temp_attachment(const char *filename)
Add file to list of temporary attachments.
Definition: mutt_attach.c:1300

mutt_attach.h
Handling of email attachments.

mutt_param_get
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84

buf_pool_get
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81

buf_pool_release
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94

STAILQ_REMOVE_HEAD
#define STAILQ_REMOVE_HEAD(head, field)
Definition: queue.h:422

STAILQ_FIRST
#define STAILQ_FIRST(head)
Definition: queue.h:350

STAILQ_FOREACH
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352

STAILQ_INSERT_TAIL
#define STAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:389

STAILQ_EMPTY
#define STAILQ_EMPTY(head)
Definition: queue.h:348

AttachPtr::fp
FILE * fp
Used in the recvattach menu.
Definition: attach.h:37

Body
The body of an email.
Definition: body.h:36

Body::parameter
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:62

Body::aptr
struct AttachPtr * aptr
Menu information, used in recvattach.c.
Definition: body.h:74

Body::next
struct Body * next
next attachment in the list
Definition: body.h:71

Body::filename
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:58

Buffer
String manipulation buffer.
Definition: buffer.h:34

CidMap
List of Content-ID to filename mappings.
Definition: cid.h:35

CidMap::fname
char * fname
Filename.
Definition: cid.h:37

CidMap::cid
char * cid
Content-ID.
Definition: cid.h:36

buf_mktemp
#define buf_mktemp(buf)
Definition: tmp.h:33

buf_mktemp_pfx_sfx
#define buf_mktemp_pfx_sfx(buf, prefix, suffix)
Definition: tmp.h:34