dump.h File Reference

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

Include dependency graph for dump.h:

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

Go to the source code of this file.

Macros
#define	CS_DUMP_NO_FLAGS   0
	No flags are set. More...
#define	CS_DUMP_ONLY_CHANGED   (1 << 0)
	Only show config that the user has changed. More...
#define	CS_DUMP_HIDE_SENSITIVE   (1 << 1)
	Obscure sensitive information like passwords. More...
#define	CS_DUMP_NO_ESCAPING   (1 << 2)
	Do not escape special chars, or quote the string. More...
#define	CS_DUMP_HIDE_NAME   (1 << 3)
	Do not print the name of the config item. More...
#define	CS_DUMP_HIDE_VALUE   (1 << 4)
	Do not print the value of the config item. More...
#define	CS_DUMP_SHOW_DEFAULTS   (1 << 5)
	Show the default value for the config item. More...
#define	CS_DUMP_SHOW_DISABLED   (1 << 6)
	Show disabled config items, too. More...
#define	CS_DUMP_SHOW_SYNONYMS   (1 << 7)
	Show synonyms and the config items they're linked to. More...
#define	CS_DUMP_SHOW_DEPRECATED   (1 << 8)
	Show config items that aren't used any more. More...
#define	CS_DUMP_SHOW_DOCS   (1 << 9)
	Show one-liner documentation for the config item. More...

Typedefs
typedef uint16_t	ConfigDumpFlags
	Flags for dump_config(), e.g. CS_DUMP_ONLY_CHANGED. More...

Functions
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. More...
bool	dump_config (struct ConfigSet *cs, ConfigDumpFlags flags, FILE *fp)
	Write all the config to a file. More...
size_t	escape_string (struct Buffer *buf, const char *src)
	Write a string to a buffer, escaping special characters. More...
size_t	pretty_var (const char *str, struct Buffer *buf)
	Escape and stringify a config item value. More...

Detailed Description

Dump all the config

Authors

• Richard Russon

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

Macro Definition Documentation

CS_DUMP_NO_FLAGS

#define CS_DUMP_NO_FLAGS   0

No flags are set.

Definition at line 35 of file dump.h.

CS_DUMP_ONLY_CHANGED

#define CS_DUMP_ONLY_CHANGED   (1 << 0)

Only show config that the user has changed.

Definition at line 36 of file dump.h.

CS_DUMP_HIDE_SENSITIVE

#define CS_DUMP_HIDE_SENSITIVE   (1 << 1)

Obscure sensitive information like passwords.

Definition at line 37 of file dump.h.

CS_DUMP_NO_ESCAPING

#define CS_DUMP_NO_ESCAPING   (1 << 2)

Do not escape special chars, or quote the string.

Definition at line 38 of file dump.h.

CS_DUMP_HIDE_NAME

#define CS_DUMP_HIDE_NAME   (1 << 3)

Do not print the name of the config item.

Definition at line 39 of file dump.h.

CS_DUMP_HIDE_VALUE

#define CS_DUMP_HIDE_VALUE   (1 << 4)

Do not print the value of the config item.

Definition at line 40 of file dump.h.

CS_DUMP_SHOW_DEFAULTS

#define CS_DUMP_SHOW_DEFAULTS   (1 << 5)

Show the default value for the config item.

Definition at line 41 of file dump.h.

CS_DUMP_SHOW_DISABLED

#define CS_DUMP_SHOW_DISABLED   (1 << 6)

Show disabled config items, too.

Definition at line 42 of file dump.h.

CS_DUMP_SHOW_SYNONYMS

#define CS_DUMP_SHOW_SYNONYMS   (1 << 7)

Show synonyms and the config items they're linked to.

Definition at line 43 of file dump.h.

CS_DUMP_SHOW_DEPRECATED

#define CS_DUMP_SHOW_DEPRECATED   (1 << 8)

Show config items that aren't used any more.

Definition at line 44 of file dump.h.

CS_DUMP_SHOW_DOCS

#define CS_DUMP_SHOW_DOCS   (1 << 9)

Show one-liner documentation for the config item.

Definition at line 45 of file dump.h.

Typedef Documentation

ConfigDumpFlags

typedef uint16_t ConfigDumpFlags

Flags for dump_config(), e.g. CS_DUMP_ONLY_CHANGED.

Definition at line 32 of file dump.h.

Function Documentation

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 106 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 165 of file dump.c.

{
  if (!cs)
    return false;
 
  struct HashElem *he = NULL;
 
  struct HashElem **list = get_elem_list(cs);
  if (!list)
    return false; /* LCOV_EXCL_LINE */
 
  bool result = true;
 
  struct Buffer value = mutt_buffer_make(256);
  struct Buffer initial = mutt_buffer_make(256);
  struct Buffer tmp = mutt_buffer_make(256);
 
  for (size_t i = 0; list[i]; i++)
  {
    mutt_buffer_reset(&value);
    mutt_buffer_reset(&initial);
    he = list[i];
    const int type = DTYPE(he->type);
 
    if ((type == DT_SYNONYM) && !(flags & CS_DUMP_SHOW_SYNONYMS))
      continue;
 
    if ((he->type & DT_DEPRECATED) && !(flags & CS_DUMP_SHOW_DEPRECATED))
      continue;
 
    // if ((type == DT_DISABLED) && !(flags & CS_DUMP_SHOW_DISABLED))
    //   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) && IS_SENSITIVE(*cdef) &&
            (flags & CS_DUMP_HIDE_SENSITIVE) && !mutt_buffer_is_empty(&value))
        {
          mutt_buffer_reset(&value);
          mutt_buffer_addstr(&value, "***");
        }
 
        if (((type == DT_PATH) || IS_MAILBOX(he)) && (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))
        {
          mutt_buffer_reset(&tmp);
          pretty_var(value.data, &tmp);
          mutt_buffer_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)) && !(he->type & DT_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))
        {
          mutt_buffer_reset(&tmp);
          pretty_var(initial.data, &tmp);
          mutt_buffer_strcpy(&initial, tmp.data);
        }
      }
    }
 
    dump_config_neo(cs, he, &value, &initial, flags, fp);
  }
 
  FREE(&list);
  mutt_buffer_dealloc(&value);
  mutt_buffer_dealloc(&initial);
  mutt_buffer_dealloc(&tmp);
 
  return result;
}

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 46 of file dump.c.

{
  if (!buf || !src)
    return 0;
 
  size_t len = 0;
  for (; *src; src++)
  {
    switch (*src)
    {
      case '\007':
        len += mutt_buffer_addstr(buf, "\\g");
        break;
      case '\n':
        len += mutt_buffer_addstr(buf, "\\n");
        break;
      case '\r':
        len += mutt_buffer_addstr(buf, "\\r");
        break;
      case '\t':
        len += mutt_buffer_addstr(buf, "\\t");
        break;
      default:
        if ((*src == '\\') || (*src == '"'))
          len += mutt_buffer_addch(buf, '\\');
        len += mutt_buffer_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 83 of file dump.c.

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

Here is the call graph for this function:

Here is the caller graph for this function: