dump.c File Reference

Dump all the config. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "dump.h"
#include "set.h"
#include "subset.h"
#include "types.h"

Include dependency graph for dump.c:

Go to the source code of this file.

Functions
void	mutt_pretty_mailbox (char *buf, size_t buflen)
	Shorten a mailbox path using '~' or '='.
size_t	escape_string (struct Buffer *buf, const char *src)
	Write a string to a buffer, escaping special characters.
size_t	pretty_var (const char *str, struct Buffer *buf)
	Escape and stringify a config item value.
void	dump_config_neo (struct ConfigSet *cs, struct HashElem *he, struct Buffer *value, struct Buffer *initial, ConfigDumpFlags flags, FILE *fp)
	Dump the config in the style of NeoMutt.
bool	dump_config (struct ConfigSet *cs, ConfigDumpFlags flags, FILE *fp)
	Write all the config to a file.

Detailed Description

Dump all the config.

Authors

• Richard Russon
• Pietro Cerutti
• Dennis Schön

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

Function Documentation

mutt_pretty_mailbox()

void mutt_pretty_mailbox	(	char *	buf,
		size_t	buflen
	)

Shorten a mailbox path using '~' or '='.

Parameters

buf	Buffer containing string to shorten
buflen	Length of buffer

Collapse the pathname using ~ or = when possible

Definition at line 475 of file muttlib.c.

{
  if (!buf)
    return;
 
  char *p = buf, *q = buf;
  size_t len;
  enum UrlScheme scheme;
  char tmp[PATH_MAX] = { 0 };
 
  scheme = url_check_scheme(buf);
 
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  if ((scheme == U_IMAP) || (scheme == U_IMAPS))
  {
    imap_pretty_mailbox(buf, buflen, c_folder);
    return;
  }
 
  if (scheme == U_NOTMUCH)
    return;
 
  /* if buf is an url, only collapse path component */
  if (scheme != U_UNKNOWN)
  {
    p = strchr(buf, ':') + 1;
    if (mutt_strn_equal(p, "//", 2))
      q = strchr(p + 2, '/');
    if (!q)
      q = strchr(p, '\0');
    p = q;
  }
 
  /* cleanup path */
  if (strstr(p, "//") || strstr(p, "/./"))
  {
    /* first attempt to collapse the pathname, this is more
     * lightweight than realpath() and doesn't resolve links */
    while (*p)
    {
      if ((p[0] == '/') && (p[1] == '/'))
      {
        *q++ = '/';
        p += 2;
      }
      else if ((p[0] == '/') && (p[1] == '.') && (p[2] == '/'))
      {
        *q++ = '/';
        p += 3;
      }
      else
      {
        *q++ = *p++;
      }
    }
    *q = '\0';
  }
  else if (strstr(p, "..") && ((scheme == U_UNKNOWN) || (scheme == U_FILE)) &&
           realpath(p, tmp))
  {
    mutt_str_copy(p, tmp, buflen - (p - buf));
  }
 
  if ((len = mutt_str_startswith(buf, c_folder)) && (buf[len] == '/'))
  {
    *buf++ = '=';
    memmove(buf, buf + len, mutt_str_len(buf + len) + 1);
  }
  else if ((len = mutt_str_startswith(buf, HomeDir)) && (buf[len] == '/'))
  {
    *buf++ = '~';
    memmove(buf, buf + len - 1, mutt_str_len(buf + len - 1) + 1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

escape_string()

size_t escape_string	(	struct Buffer *	buf,
		const char *	src
	)

Write a string to a buffer, escaping special characters.

Parameters

buf	Buffer to write to
src	String to write

Return values

num	Bytes written to buffer

Definition at line 48 of file dump.c.

{
  if (!buf || !src)
    return 0;
 
  size_t len = 0;
  for (; *src; src++)
  {
    switch (*src)
    {
      case '\007':
        len += buf_addstr(buf, "\\g");
        break;
      case '\n':
        len += buf_addstr(buf, "\\n");
        break;
      case '\r':
        len += buf_addstr(buf, "\\r");
        break;
      case '\t':
        len += buf_addstr(buf, "\\t");
        break;
      default:
        if ((*src == '\\') || (*src == '"'))
          len += buf_addch(buf, '\\');
        len += buf_addch(buf, src[0]);
    }
  }
  return len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pretty_var()

size_t pretty_var	(	const char *	str,
		struct Buffer *	buf
	)

Escape and stringify a config item value.

Parameters

str	String to escape
buf	Buffer to write to

Return values

num	Number of bytes written to buffer

Definition at line 85 of file dump.c.

{
  if (!buf || !str)
    return 0;
 
  int len = 0;
 
  len += buf_addch(buf, '"');
  len += escape_string(buf, str);
  len += buf_addch(buf, '"');
 
  return len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_config_neo()

void dump_config_neo	(	struct ConfigSet *	cs,
		struct HashElem *	he,
		struct Buffer *	value,
		struct Buffer *	initial,
		ConfigDumpFlags	flags,
		FILE *	fp
	)

Dump the config in the style of NeoMutt.

Parameters

cs	Config items
he	HashElem representing config item
value	Current value of the config item
initial	Initial value of the config item
flags	Flags, see ConfigDumpFlags
fp	File pointer to write to

Definition at line 108 of file dump.c.

{
  if (!he || !value || !fp)
    return;
 
  const char *name = he->key.strkey;
 
  if ((flags & CS_DUMP_ONLY_CHANGED) &&
      (!initial || mutt_str_equal(value->data, initial->data)))
  {
    return;
  }
 
  if (he->type == DT_SYNONYM)
  {
    const struct ConfigDef *cdef = he->data;
    const char *syn = (const char *) cdef->initial;
    fprintf(fp, "# synonym: %s -> %s\n", name, syn);
    return;
  }
 
  if (flags & CS_DUMP_SHOW_DOCS)
  {
    const struct ConfigDef *cdef = he->data;
    fprintf(fp, "# %s\n", cdef->docs);
  }
 
  bool show_name = !(flags & CS_DUMP_HIDE_NAME);
  bool show_value = !(flags & CS_DUMP_HIDE_VALUE);
 
  if (show_name && show_value)
    fprintf(fp, "set ");
  if (show_name)
    fprintf(fp, "%s", name);
  if (show_name && show_value)
    fprintf(fp, " = ");
  if (show_value)
    fprintf(fp, "%s", value->data);
  if (show_name || show_value)
    fprintf(fp, "\n");
 
  if (flags & CS_DUMP_SHOW_DEFAULTS)
  {
    const struct ConfigSetType *cst = cs_get_type_def(cs, he->type);
    if (cst)
      fprintf(fp, "# %s %s %s\n", cst->name, name, value->data);
  }
 
  if (flags & CS_DUMP_SHOW_DOCS)
    fprintf(fp, "\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_config()

bool dump_config	(	struct ConfigSet *	cs,
		ConfigDumpFlags	flags,
		FILE *	fp
	)

Write all the config to a file.

Parameters

cs	ConfigSet to dump
flags	Flags, see ConfigDumpFlags
fp	File to write config to

Definition at line 167 of file dump.c.

{
  if (!cs)
    return false;
 
  struct HashElem *he = NULL;
 
  struct HashElem **he_list = get_elem_list(cs);
  if (!he_list)
    return false; /* LCOV_EXCL_LINE */
 
  bool result = true;
 
  struct Buffer *value = buf_pool_get();
  struct Buffer *initial = buf_pool_get();
  struct Buffer *tmp = buf_pool_get();
 
  for (size_t i = 0; he_list[i]; i++)
  {
    buf_reset(value);
    buf_reset(initial);
    he = he_list[i];
    const int type = DTYPE(he->type);
 
    if ((type == DT_SYNONYM) && !(flags & CS_DUMP_SHOW_SYNONYMS))
      continue;
 
    if ((he->type & D_INTERNAL_DEPRECATED) && !(flags & CS_DUMP_SHOW_DEPRECATED))
      continue;
 
    if (type != DT_SYNONYM)
    {
      /* If necessary, get the current value */
      if ((flags & CS_DUMP_ONLY_CHANGED) || !(flags & CS_DUMP_HIDE_VALUE) ||
          (flags & CS_DUMP_SHOW_DEFAULTS))
      {
        int rc = cs_he_string_get(cs, he, value);
        if (CSR_RESULT(rc) != CSR_SUCCESS)
        {
          result = false; /* LCOV_EXCL_LINE */
          break;          /* LCOV_EXCL_LINE */
        }
 
        const struct ConfigDef *cdef = he->data;
        if ((type == DT_STRING) && (cdef->type & D_SENSITIVE) &&
            (flags & CS_DUMP_HIDE_SENSITIVE) && !buf_is_empty(value))
        {
          buf_reset(value);
          buf_addstr(value, "***");
        }
 
        if (((type == DT_PATH) || IS_MAILBOX(he->type)) && (value->data[0] == '/'))
          mutt_pretty_mailbox(value->data, value->dsize);
 
        if ((type != DT_BOOL) && (type != DT_NUMBER) && (type != DT_LONG) &&
            (type != DT_QUAD) && !(flags & CS_DUMP_NO_ESCAPING))
        {
          buf_reset(tmp);
          pretty_var(value->data, tmp);
          buf_strcpy(value, tmp->data);
        }
      }
 
      /* If necessary, get the default value */
      if (flags & (CS_DUMP_ONLY_CHANGED | CS_DUMP_SHOW_DEFAULTS))
      {
        int rc = cs_he_initial_get(cs, he, initial);
        if (CSR_RESULT(rc) != CSR_SUCCESS)
        {
          result = false; /* LCOV_EXCL_LINE */
          break;          /* LCOV_EXCL_LINE */
        }
 
        if (((type == DT_PATH) || IS_MAILBOX(he->type)) && !(he->type & D_STRING_MAILBOX))
          mutt_pretty_mailbox(initial->data, initial->dsize);
 
        if ((type != DT_BOOL) && (type != DT_NUMBER) && (type != DT_LONG) &&
            (type != DT_QUAD) && !(flags & CS_DUMP_NO_ESCAPING))
        {
          buf_reset(tmp);
          pretty_var(initial->data, tmp);
          buf_strcpy(initial, tmp->data);
        }
      }
    }
 
    dump_config_neo(cs, he, value, initial, flags, fp);
  }
 
  FREE(&he_list);
  buf_pool_release(&value);
  buf_pool_release(&initial);
  buf_pool_release(&tmp);
 
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function: