rfc3676.c File Reference

RFC3676 Format Flowed routines. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "rfc3676.h"
#include "body.h"
#include "email.h"
#include "mime.h"
#include "parameter.h"

Include dependency graph for rfc3676.c:

Go to the source code of this file.

Data Structures
struct	FlowedState
	State of a Format-Flowed line of text. More...

Macros
#define	FLOWED_MAX   72
	Maximum line length for format=flowed text (RFC 3676)

Functions
static int	get_quote_level (const char *line)
	Get the quote level of a line.
static int	space_quotes (struct State *state)
	Should we add spaces between quote levels.
static bool	add_quote_suffix (struct State *state, int ql)
	Should we add a trailing space to quotes.
static size_t	print_indent (int ql, struct State *state, int add_suffix)
	Print indented text.
static void	flush_par (struct State *state, struct FlowedState *fst)
	Write out the paragraph.
static int	quote_width (struct State *state, int ql)
	Calculate the paragraph width based upon the quote level.
static void	print_flowed_line (char *line, struct State *state, int ql, struct FlowedState *fst, bool term)
	Print a format-flowed line.
static void	print_fixed_line (const char *line, struct State *state, int ql, struct FlowedState *fst)
	Print a fixed format line.
int	rfc3676_handler (struct Body *b_email, struct State *state)
	Handler for format=flowed - Implements handler_t -.
bool	mutt_rfc3676_is_format_flowed (struct Body *b)
	Is the Email "format-flowed"?
static void	rfc3676_space_stuff (const char *filename, bool unstuff)
	Perform required RFC3676 space stuffing.
void	mutt_rfc3676_space_stuff (struct Email *e)
	Perform RFC3676 space stuffing on an Email.
void	mutt_rfc3676_space_unstuff (struct Email *e)
	Remove RFC3676 space stuffing.
void	mutt_rfc3676_space_unstuff_attachment (struct Body *b, const char *filename)
	Unstuff attachments.
void	mutt_rfc3676_space_stuff_attachment (struct Body *b, const char *filename)
	Stuff attachments.

Detailed Description

RFC3676 Format Flowed routines.

Authors

• Andreas Krennmair
• Peter J. Holzer
• Rocco Rutte
• Michael R. Elkins
• Richard Russon
• Federico Kircheis
• 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 rfc3676.c.

Macro Definition Documentation

FLOWED_MAX

#define FLOWED_MAX   72

Maximum line length for format=flowed text (RFC 3676)

Definition at line 50 of file rfc3676.c.

Function Documentation

get_quote_level()

static int get_quote_level ( const char * line )

static

Get the quote level of a line.

Parameters

line	Text to examine

Return values

num	Quote level

Definition at line 67 of file rfc3676.c.

{
  int quoted = 0;
  const char *p = line;
 
  while (p && (*p == '>'))
  {
    quoted++;
    p++;
  }
 
  return quoted;
}

Here is the caller graph for this function:

space_quotes()

static int space_quotes ( struct State * state )

static

Should we add spaces between quote levels.

Parameters

state

State to use

Return values

true	Spaces should be added

Determines whether to add spacing between/after each quote level: >>>foo becomes > > > foo

Definition at line 91 of file rfc3676.c.

{
  /* Allow quote spacing in the pager even for `$text_flowed`,
   * but obviously not when replying.  */
  const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
  if (c_text_flowed && (state->flags & STATE_REPLYING))
    return 0;
 
  const bool c_reflow_space_quotes = cs_subset_bool(NeoMutt->sub, "reflow_space_quotes");
  return c_reflow_space_quotes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_quote_suffix()

static bool add_quote_suffix ( struct State * state, int ql )

static

Should we add a trailing space to quotes.

Parameters

state	State to use
ql	Quote level

Return values

true	Spaces should be added

Determines whether to add a trailing space to quotes: >>> foo as opposed to >>>foo

Definition at line 114 of file rfc3676.c.

{
  if (state->flags & STATE_REPLYING)
    return false;
 
  if (space_quotes(state))
    return false;
 
  if (!ql && !state->prefix)
    return false;
 
  /* The prefix will add its own space */
  const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
  if (!c_text_flowed && !ql && state->prefix)
    return false;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_indent()

static size_t print_indent ( int ql, struct State * state, int add_suffix )

static

Print indented text.

Parameters

ql	Quote level
state	State to work with
add_suffix	If true, write a trailing space character

Return values

num	Number of characters written

Definition at line 140 of file rfc3676.c.

{
  size_t wid = 0;
 
  if (state->prefix)
  {
    /* use given prefix only for format=fixed replies to format=flowed,
     * for format=flowed replies to format=flowed, use '>' indentation */
    const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
    if (c_text_flowed)
    {
      ql++;
    }
    else
    {
      state_puts(state, state->prefix);
      wid = mutt_strwidth(state->prefix);
    }
  }
  for (int i = 0; i < ql; i++)
  {
    state_putc(state, '>');
    if (space_quotes(state))
      state_putc(state, ' ');
  }
  if (add_suffix)
    state_putc(state, ' ');
 
  if (space_quotes(state))
    ql *= 2;
 
  return ql + add_suffix + wid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

flush_par()

static void flush_par ( struct State * state, struct FlowedState * fst )

static

Write out the paragraph.

Parameters

state	State to work with
fst	State of the flowed text

Definition at line 179 of file rfc3676.c.

{
  if (fst->width > 0)
  {
    state_putc(state, '\n');
    fst->width = 0;
  }
  fst->spaces = 0;
}

Here is the caller graph for this function:

quote_width()

static int quote_width ( struct State * state, int ql )

static

Calculate the paragraph width based upon the quote level.

Parameters

state	State to use
ql	Quote level

Return values

num	Paragraph width

The start of a quoted line will be ">>> ", so we need to subtract the space required for the prefix from the terminal width.

Definition at line 198 of file rfc3676.c.

{
  const int screen_width = (state->flags & STATE_DISPLAY) ? state->wraplen : 80;
  const short c_reflow_wrap = cs_subset_number(NeoMutt->sub, "reflow_wrap");
  int width = mutt_window_wrap_cols(screen_width, c_reflow_wrap);
  const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
  if (c_text_flowed && (state->flags & STATE_REPLYING))
  {
    /* When replying, force a wrap at FLOWED_MAX to comply with RFC3676
     * guidelines */
    if (width > FLOWED_MAX)
      width = FLOWED_MAX;
    ql++; /* When replying, we will add an additional quote level */
  }
  /* adjust the paragraph width subtracting the number of prefix chars */
  width -= space_quotes(state) ? ql * 2 : ql;
  /* When displaying (not replying), there may be a space between the prefix
   * string and the paragraph */
  if (add_quote_suffix(state, ql))
    width--;
  /* failsafe for really long quotes */
  if (width <= 0)
    width = FLOWED_MAX; /* arbitrary, since the line will wrap */
  return width;
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_flowed_line()

static void print_flowed_line ( char * line, struct State * state, int ql, struct FlowedState * fst, bool term )

static

Print a format-flowed line.

Parameters

line	Text to print
state	State to work with
ql	Quote level
fst	State of the flowed text
term	If true, terminate with a new line

Definition at line 232 of file rfc3676.c.

{
  size_t width, w, words = 0;
  char *p = NULL;
  char last;
 
  if (!line || (*line == '\0'))
  {
    /* flush current paragraph (if any) first */
    flush_par(state, fst);
    print_indent(ql, state, 0);
    state_putc(state, '\n');
    return;
  }
 
  width = quote_width(state, ql);
  last = line[mutt_str_len(line) - 1];
 
  mutt_debug(LL_DEBUG5, "f=f: line [%s], width = %ld, spaces = %zu\n", line,
             (long) width, fst->spaces);
 
  for (words = 0; (p = mutt_str_sep(&line, " "));)
  {
    mutt_debug(LL_DEBUG5, "f=f: word [%s], width: %zu, remaining = [%s]\n", p,
               fst->width, line);
 
    /* remember number of spaces */
    if (*p == '\0')
    {
      mutt_debug(LL_DEBUG3, "f=f: additional space\n");
      fst->spaces++;
      continue;
    }
    /* there's exactly one space prior to every but the first word */
    if (words)
      fst->spaces++;
 
    w = mutt_strwidth(p);
    /* see if we need to break the line but make sure the first word is put on
     * the line regardless; if for DelSp=yes only one trailing space is used,
     * we probably have a long word that we should break within (we leave that
     * up to the pager or user) */
    if (!(!fst->spaces && fst->delsp && (last != ' ')) && (w < width) &&
        (w + fst->width + fst->spaces > width))
    {
      mutt_debug(LL_DEBUG3, "f=f: break line at %zu, %zu spaces left\n",
                 fst->width, fst->spaces);
      /* only honor trailing spaces for format=flowed replies */
      const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
      if (c_text_flowed)
        for (; fst->spaces; fst->spaces--)
          state_putc(state, ' ');
      state_putc(state, '\n');
      fst->width = 0;
      fst->spaces = 0;
      words = 0;
    }
 
    if (!words && !fst->width)
      fst->width = print_indent(ql, state, add_quote_suffix(state, ql));
    fst->width += w + fst->spaces;
    for (; fst->spaces; fst->spaces--)
      state_putc(state, ' ');
    state_puts(state, p);
    words++;
  }
 
  if (term)
    flush_par(state, fst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_fixed_line()

static void print_fixed_line ( const char * line, struct State * state, int ql, struct FlowedState * fst )

static

Print a fixed format line.

Parameters

line	Text to print
state	State to work with
ql	Quote level
fst	State of the flowed text

Definition at line 311 of file rfc3676.c.

{
  print_indent(ql, state, add_quote_suffix(state, ql));
  if (line && *line)
    state_puts(state, line);
  state_putc(state, '\n');
 
  fst->width = 0;
  fst->spaces = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc3676_is_format_flowed()

bool mutt_rfc3676_is_format_flowed

(

struct Body *

b

)

Is the Email "format-flowed"?

Parameters

b	Email Body to examine

Return values

true	Email is "format-flowed"

Definition at line 398 of file rfc3676.c.

{
  if (b && (b->type == TYPE_TEXT) && mutt_istr_equal("plain", b->subtype))
  {
    const char *format = mutt_param_get(&b->parameter, "format");
    if (mutt_istr_equal("flowed", format))
      return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rfc3676_space_stuff()

static void rfc3676_space_stuff ( const char * filename, bool unstuff )

static

Perform required RFC3676 space stuffing.

Parameters

filename	Attachment file
unstuff	If true, remove space stuffing

Space stuffing means that we have to add leading spaces to certain lines:

• lines starting with a space
• lines starting with 'From '

Care is taken to preserve the e->body->filename, as mutt -i -E can directly edit a passed in filename.

Definition at line 423 of file rfc3676.c.

{
  FILE *fp_out = NULL;
  char *buf = NULL;
  size_t blen = 0;
 
  struct Buffer *tempfile = buf_pool_get();
 
  FILE *fp_in = mutt_file_fopen(filename, "r");
  if (!fp_in)
    goto bail;
 
  buf_mktemp(tempfile);
  fp_out = mutt_file_fopen(buf_string(tempfile), "w+");
  if (!fp_out)
    goto bail;
 
  while ((buf = mutt_file_read_line(buf, &blen, fp_in, NULL, MUTT_RL_NO_FLAGS)) != NULL)
  {
    if (unstuff)
    {
      if (buf[0] == ' ')
        fputs(buf + 1, fp_out);
      else
        fputs(buf, fp_out);
    }
    else
    {
      if ((buf[0] == ' ') || mutt_str_startswith(buf, "From "))
        fputc(' ', fp_out);
      fputs(buf, fp_out);
    }
    fputc('\n', fp_out);
  }
  FREE(&buf);
  mutt_file_fclose(&fp_in);
  mutt_file_fclose(&fp_out);
  mutt_file_set_mtime(filename, buf_string(tempfile));
 
  fp_in = mutt_file_fopen(buf_string(tempfile), "r");
  if (!fp_in)
    goto bail;
 
  if ((truncate(filename, 0) == -1) || ((fp_out = mutt_file_fopen(filename, "a")) == NULL))
  {
    mutt_perror("%s", filename);
    goto bail;
  }
 
  mutt_file_copy_stream(fp_in, fp_out);
  mutt_file_set_mtime(buf_string(tempfile), filename);
  unlink(buf_string(tempfile));
 
bail:
  mutt_file_fclose(&fp_in);
  mutt_file_fclose(&fp_out);
  buf_pool_release(&tempfile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc3676_space_stuff()

void mutt_rfc3676_space_stuff

(

struct Email *

e

)

Perform RFC3676 space stuffing on an Email.

Parameters

e

Email

Note

We don't check the option $text_flowed because we want to stuff based the actual content type. The option only decides whether to set format=flowed on new messages.

Definition at line 490 of file rfc3676.c.

{
  if (!e || !e->body || !e->body->filename)
    return;
 
  if (mutt_rfc3676_is_format_flowed(e->body))
    rfc3676_space_stuff(e->body->filename, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc3676_space_unstuff()

void mutt_rfc3676_space_unstuff

(

struct Email *

e

)

Remove RFC3676 space stuffing.

Parameters

e

Email

Definition at line 503 of file rfc3676.c.

{
  if (!e || !e->body || !e->body->filename)
    return;
 
  if (mutt_rfc3676_is_format_flowed(e->body))
    rfc3676_space_stuff(e->body->filename, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc3676_space_unstuff_attachment()

void mutt_rfc3676_space_unstuff_attachment	(	struct Body *	b,
		const char *	filename )

Unstuff attachments.

Parameters

b	Email Body (OPTIONAL)
filename	Attachment file

This routine is used when saving/piping/viewing rfc3676 attachments.

If b is provided, the function will verify that the Email is format-flowed. The filename will be unstuffed, not b->filename or b->fp.

Definition at line 522 of file rfc3676.c.

{
  if (!filename)
    return;
 
  if (b && !mutt_rfc3676_is_format_flowed(b))
    return;
 
  rfc3676_space_stuff(filename, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc3676_space_stuff_attachment()

void mutt_rfc3676_space_stuff_attachment	(	struct Body *	b,
		const char *	filename )

Stuff attachments.

Parameters

b	Email Body (OPTIONAL)
filename	Attachment file

This routine is used when filtering rfc3676 attachments.

If b is provided, the function will verify that the Email is format-flowed. The filename will be unstuffed, not b->filename or b->fp.

Definition at line 543 of file rfc3676.c.

{
  if (!filename)
    return;
 
  if (b && !mutt_rfc3676_is_format_flowed(b))
    return;
 
  rfc3676_space_stuff(filename, false);
}

Here is the call graph for this function:

Here is the caller graph for this function: