NeoMutt  2023-11-03-85-g512e01
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
commands.c File Reference

Functions to parse commands in a config file. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "commands.h"
#include "attach/lib.h"
#include "color/lib.h"
#include "imap/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "pager/lib.h"
#include "parse/lib.h"
#include "store/lib.h"
#include "alternates.h"
#include "globals.h"
#include "muttlib.h"
#include "mx.h"
#include "score.h"
#include "version.h"
#include "monitor.h"
#include <libintl.h>
+ Include dependency graph for commands.c:

Go to the source code of this file.

Macros

#define MAX_ERRS   128
 

Enumerations

enum  TriBool { TB_UNSET = -1 , TB_FALSE , TB_TRUE }
 Tri-state boolean. More...
 
enum  GroupState { GS_NONE , GS_RX , GS_ADDR }
 Type of email address group. More...
 

Functions

static bool is_function (const char *name)
 Is the argument a neomutt function?
 
int parse_grouplist (struct GroupList *gl, struct Buffer *buf, struct Buffer *s, struct Buffer *err)
 Parse a group context.
 
enum CommandResult parse_rc_line_cwd (const char *line, char *cwd, struct Buffer *err)
 Parse and run a muttrc line in a relative directory.
 
char * mutt_get_sourced_cwd (void)
 Get the current file path that is being parsed.
 
int source_rc (const char *rcfile_path, struct Buffer *err)
 Read an initialization file.
 
static enum CommandResult parse_cd (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'cd' command - Implements Command::parse() -.
 
static enum CommandResult parse_echo (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'echo' command - Implements Command::parse() -.
 
static enum CommandResult parse_finish (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'finish' command - Implements Command::parse() -.
 
static enum CommandResult parse_group (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'group' and 'ungroup' commands - Implements Command::parse() -.
 
static enum CommandResult parse_ifdef (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'ifdef' and 'ifndef' commands - Implements Command::parse() -.
 
static enum CommandResult parse_ignore (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'ignore' command - Implements Command::parse() -.
 
static enum CommandResult parse_lists (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'lists' command - Implements Command::parse() -.
 
static enum CommandResult mailbox_add (const char *folder, const char *mailbox, const char *label, enum TriBool poll, enum TriBool notify, struct Buffer *err)
 Add a new Mailbox.
 
enum CommandResult parse_mailboxes (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'mailboxes' command - Implements Command::parse() -.
 
enum CommandResult parse_my_hdr (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'my_hdr' command - Implements Command::parse() -.
 
enum CommandResult set_dump (ConfigDumpFlags flags, struct Buffer *err)
 Dump list of config variables into a file/pager.
 
static int envlist_sort (const void *a, const void *b, void *sdata)
 Compare two environment strings - Implements sort_t -.
 
static enum CommandResult parse_setenv (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'setenv' and 'unsetenv' commands - Implements Command::parse() -.
 
static enum CommandResult parse_source (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'source' command - Implements Command::parse() -.
 
static enum CommandResult parse_nospam (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'nospam' command - Implements Command::parse() -.
 
static enum CommandResult parse_spam (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'spam' command - Implements Command::parse() -.
 
static enum CommandResult parse_stailq (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse a list command - Implements Command::parse() -.
 
static enum CommandResult parse_subscribe (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'subscribe' command - Implements Command::parse() -.
 
enum CommandResult parse_subscribe_to (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'subscribe-to' command - Implements Command::parse() -.
 
static enum CommandResult parse_tag_formats (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'tag-formats' command - Implements Command::parse() -.
 
static enum CommandResult parse_tag_transforms (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'tag-transforms' command - Implements Command::parse() -.
 
static enum CommandResult parse_unignore (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unignore' command - Implements Command::parse() -.
 
static enum CommandResult parse_unlists (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unlists' command - Implements Command::parse() -.
 
static void do_unmailboxes (struct Mailbox *m)
 Remove a Mailbox from the Sidebar/notifications.
 
static void do_unmailboxes_star (void)
 Remove all Mailboxes from the Sidebar/notifications.
 
enum CommandResult parse_unmailboxes (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unmailboxes' command - Implements Command::parse() -.
 
static enum CommandResult parse_unmy_hdr (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unmy_hdr' command - Implements Command::parse() -.
 
static enum CommandResult parse_unstailq (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse an unlist command - Implements Command::parse() -.
 
static enum CommandResult parse_unsubscribe (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unsubscribe' command - Implements Command::parse() -.
 
enum CommandResult parse_unsubscribe_from (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unsubscribe-from' command - Implements Command::parse() -.
 
static enum CommandResult parse_version (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'version' command - Implements Command::parse() -.
 
void source_stack_cleanup (void)
 Free memory from the stack used for the source command.
 
void commands_init (void)
 Initialize commands array and register default commands.
 

Variables

static struct ListHead MuttrcStack = STAILQ_HEAD_INITIALIZER(MuttrcStack)
 LIFO designed to contain the list of config files that have been sourced and avoid cyclic sourcing.
 
static const struct Command MuttCommands []
 General NeoMutt Commands.
 

Detailed Description

Functions to parse commands in a config file.

Authors
  • Michael R. Elkins
  • g10 Code GmbH
  • R Primus

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

Macro Definition Documentation

◆ MAX_ERRS

#define MAX_ERRS   128

Definition at line 72 of file commands.c.

Enumeration Type Documentation

◆ TriBool

enum TriBool

Tri-state boolean.

Enumerator
TB_UNSET 

Value hasn't been set.

TB_FALSE 

Value is false.

TB_TRUE 

Value is true.

Definition at line 77 of file commands.c.

78{
79 TB_UNSET = -1,
80 TB_FALSE,
81 TB_TRUE,
82};
@ TB_FALSE
Value is false.
Definition: commands.c:80
@ TB_TRUE
Value is true.
Definition: commands.c:81
@ TB_UNSET
Value hasn't been set.
Definition: commands.c:79

◆ GroupState

enum GroupState

Type of email address group.

Enumerator
GS_NONE 

Group is missing an argument.

GS_RX 

Entry is a regular expression.

GS_ADDR 

Entry is an address.

Definition at line 87 of file commands.c.

88{
89 GS_NONE,
90 GS_RX,
91 GS_ADDR,
92};
@ GS_RX
Entry is a regular expression.
Definition: commands.c:90
@ GS_NONE
Group is missing an argument.
Definition: commands.c:89
@ GS_ADDR
Entry is an address.
Definition: commands.c:91

Function Documentation

◆ is_function()

static bool is_function ( const char *  name)
static

Is the argument a neomutt function?

Parameters
nameCommand name to be searched for
Return values
trueFunction found
falseFunction not found

Definition at line 100 of file commands.c.

101{
102 for (size_t i = 0; MenuNames[i].name; i++)
103 {
104 const struct MenuFuncOp *fns = km_get_table(MenuNames[i].value);
105 if (!fns)
106 continue;
107
108 for (int j = 0; fns[j].name; j++)
109 if (mutt_str_equal(name, fns[j].name))
110 return true;
111 }
112 return false;
113}
const struct MenuFuncOp * km_get_table(enum MenuType mtype)
Lookup a Menu's functions.
Definition: lib.c:529
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:798
const char * name
String value.
Definition: mapping.h:33
Mapping between a function and an operation.
Definition: lib.h:102
const char * name
Name of the function.
Definition: lib.h:103
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ parse_grouplist()

int parse_grouplist ( struct GroupList *  gl,
struct Buffer buf,
struct Buffer s,
struct Buffer err 
)

Parse a group context.

Parameters
glGroupList to add to
bufTemporary Buffer space
sBuffer containing string to be parsed
errBuffer for error messages
Return values
0Success
-1Error

Definition at line 124 of file commands.c.

126{
127 while (mutt_istr_equal(buf->data, "-group"))
128 {
129 if (!MoreArgs(s))
130 {
131 buf_strcpy(err, _("-group: no group name"));
132 return -1;
133 }
134
136
138
139 if (!MoreArgs(s))
140 {
141 buf_strcpy(err, _("out of arguments"));
142 return -1;
143 }
144
146 }
147
148 return 0;
149}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:407
int parse_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: extract.c:48
#define MoreArgs(buf)
Definition: extract.h:31
#define TOKEN_NO_FLAGS
No flags are set.
Definition: extract.h:45
void mutt_grouplist_add(struct GroupList *gl, struct Group *group)
Add a Group to a GroupList.
Definition: group.c:182
struct Group * mutt_pattern_group(const char *pat)
Match a pattern to a Group.
Definition: group.c:117
#define _(a)
Definition: message.h:28
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:810
char * data
Pointer to data.
Definition: buffer.h:35
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ parse_rc_line_cwd()

enum CommandResult parse_rc_line_cwd ( const char *  line,
char *  cwd,
struct Buffer err 
)

Parse and run a muttrc line in a relative directory.

Parameters
lineLine to be parsed
cwdFile relative where to run the line
errWhere to write error messages
Return values
CommandResultResult e.g. MUTT_CMD_SUCCESS

Definition at line 158 of file commands.c.

159{
161
162 enum CommandResult ret = parse_rc_line(line, err);
163
164 struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
166 FREE(&np->data);
167 FREE(&np);
168
169 return ret;
170}
CommandResult
Error codes for command_t parse functions.
Definition: command.h:36
static struct ListHead MuttrcStack
LIFO designed to contain the list of config files that have been sourced and avoid cyclic sourcing.
Definition: commands.c:70
struct ListNode * mutt_list_insert_head(struct ListHead *h, char *s)
Insert a string at the beginning of a List.
Definition: list.c:45
#define FREE(x)
Definition: memory.h:45
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:251
#define STAILQ_REMOVE_HEAD(head, field)
Definition: queue.h:422
#define STAILQ_FIRST(head)
Definition: queue.h:350
enum CommandResult parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: rc.c:104
#define NONULL(x)
Definition: string2.h:37
A List node for strings.
Definition: list.h:35
char * data
String.
Definition: list.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_get_sourced_cwd()

char * mutt_get_sourced_cwd ( void  )

Get the current file path that is being parsed.

Return values
ptrFile path that is being parsed or cwd at runtime
Note
Caller is responsible for freeing returned string

Definition at line 178 of file commands.c.

179{
180 struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
181 if (np && np->data)
182 return mutt_str_dup(np->data);
183
184 // stack is empty, return our own dummy file relative to cwd
185 struct Buffer *cwd = buf_pool_get();
186 mutt_path_getcwd(cwd);
187 buf_addstr(cwd, "/dummy.rc");
188 char *ret = buf_strdup(cwd);
189 buf_pool_release(&cwd);
190 return ret;
191}
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:238
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:542
const char * mutt_path_getcwd(struct Buffer *cwd)
Get the current working directory.
Definition: path.c:498
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
String manipulation buffer.
Definition: buffer.h:34
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ source_rc()

int source_rc ( const char *  rcfile_path,
struct Buffer err 
)

Read an initialization file.

Parameters
rcfile_pathPath to initialization file
errBuffer for error messages
Return values
<0NeoMutt should pause to let the user know

Definition at line 199 of file commands.c.

200{
201 int lineno = 0, rc = 0, warnings = 0;
202 enum CommandResult line_rc;
203 struct Buffer *token = NULL, *linebuf = NULL;
204 char *line = NULL;
205 char *currentline = NULL;
206 char rcfile[PATH_MAX] = { 0 };
207 size_t linelen = 0;
208 pid_t pid;
209
210 mutt_str_copy(rcfile, rcfile_path, sizeof(rcfile));
211
212 size_t rcfilelen = mutt_str_len(rcfile);
213 if (rcfilelen == 0)
214 return -1;
215
216 bool ispipe = rcfile[rcfilelen - 1] == '|';
217
218 if (!ispipe)
219 {
220 struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
221 if (!mutt_path_to_absolute(rcfile, np ? NONULL(np->data) : ""))
222 {
223 mutt_error(_("Error: Can't build path of '%s'"), rcfile_path);
224 return -1;
225 }
226
227 STAILQ_FOREACH(np, &MuttrcStack, entries)
228 {
229 if (mutt_str_equal(np->data, rcfile))
230 {
231 break;
232 }
233 }
234 if (np)
235 {
236 mutt_error(_("Error: Cyclic sourcing of configuration file '%s'"), rcfile);
237 return -1;
238 }
239
241 }
242
243 mutt_debug(LL_DEBUG2, "Reading configuration file '%s'\n", rcfile);
244
245 FILE *fp = mutt_open_read(rcfile, &pid);
246 if (!fp)
247 {
248 buf_printf(err, "%s: %s", rcfile, strerror(errno));
249 return -1;
250 }
251
252 token = buf_pool_get();
253 linebuf = buf_pool_get();
254
255 const char *const c_config_charset = cs_subset_string(NeoMutt->sub, "config_charset");
256 const char *const c_charset = cc_charset();
257 while ((line = mutt_file_read_line(line, &linelen, fp, &lineno, MUTT_RL_CONT)) != NULL)
258 {
259 const bool conv = c_config_charset && c_charset;
260 if (conv)
261 {
262 currentline = mutt_str_dup(line);
263 if (!currentline)
264 continue;
265 mutt_ch_convert_string(&currentline, c_config_charset, c_charset, MUTT_ICONV_NO_FLAGS);
266 }
267 else
268 {
269 currentline = line;
270 }
271
272 buf_strcpy(linebuf, currentline);
273
274 buf_reset(err);
275 line_rc = parse_rc_buffer(linebuf, token, err);
276 if (line_rc == MUTT_CMD_ERROR)
277 {
278 mutt_error("%s:%d: %s", rcfile, lineno, buf_string(err));
279 if (--rc < -MAX_ERRS)
280 {
281 if (conv)
282 FREE(&currentline);
283 break;
284 }
285 }
286 else if (line_rc == MUTT_CMD_WARNING)
287 {
288 /* Warning */
289 mutt_warning("%s:%d: %s", rcfile, lineno, buf_string(err));
290 warnings++;
291 }
292 else if (line_rc == MUTT_CMD_FINISH)
293 {
294 if (conv)
295 FREE(&currentline);
296 break; /* Found "finish" command */
297 }
298 else
299 {
300 if (rc < 0)
301 rc = -1;
302 }
303 if (conv)
304 FREE(&currentline);
305 }
306
307 FREE(&line);
308 mutt_file_fclose(&fp);
309 if (pid != -1)
310 filter_wait(pid);
311
312 if (rc)
313 {
314 /* the neomuttrc source keyword */
315 buf_reset(err);
316 buf_printf(err, (rc >= -MAX_ERRS) ? _("source: errors in %s") : _("source: reading aborted due to too many errors in %s"),
317 rcfile);
318 rc = -1;
319 }
320 else
321 {
322 /* Don't alias errors with warnings */
323 if (warnings > 0)
324 {
325 buf_printf(err, ngettext("source: %d warning in %s", "source: %d warnings in %s", warnings),
326 warnings, rcfile);
327 rc = -2;
328 }
329 }
330
331 if (!ispipe && !STAILQ_EMPTY(&MuttrcStack))
332 {
333 struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
335 FREE(&np->data);
336 FREE(&np);
337 }
338
339 buf_pool_release(&token);
340 buf_pool_release(&linebuf);
341 return rc;
342}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:173
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:88
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:93
@ MUTT_CMD_ERROR
Error: Can't help the user.
Definition: command.h:37
@ MUTT_CMD_WARNING
Warning: Help given to the user.
Definition: command.h:38
@ MUTT_CMD_FINISH
Finish: Stop processing this file.
Definition: command.h:40
#define MAX_ERRS
Definition: commands.c:72
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:115
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
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
#define MUTT_RL_CONT
-continuation
Definition: file.h:40
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:218
#define mutt_warning(...)
Definition: logging2.h:90
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
int mutt_ch_convert_string(char **ps, const char *from, const char *to, uint8_t flags)
Convert a string between encodings.
Definition: charset.c:826
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition: charset.h:71
bool mutt_path_to_absolute(char *path, const char *reference)
Convert relative filepath to an absolute path.
Definition: path.c:329
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:568
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:653
#define PATH_MAX
Definition: mutt.h:41
FILE * mutt_open_read(const char *path, pid_t *thepid)
Run a command to read from.
Definition: muttlib.c:1276
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define STAILQ_EMPTY(head)
Definition: queue.h:348
enum CommandResult parse_rc_buffer(struct Buffer *line, struct Buffer *token, struct Buffer *err)
Parse a line of user config.
Definition: rc.c:46
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mailbox_add()

static enum CommandResult mailbox_add ( const char *  folder,
const char *  mailbox,
const char *  label,
enum TriBool  poll,
enum TriBool  notify,
struct Buffer err 
)
static

Add a new Mailbox.

Definition at line 609 of file commands.c.

612{
613 mutt_debug(LL_DEBUG1, "Adding mailbox: '%s' label '%s', poll %s, notify %s\n",
614 mailbox, label ? label : "[NONE]",
615 (poll == TB_UNSET) ? "[UNSPECIFIED]" :
616 (poll == TB_TRUE) ? "true" :
617 "false",
618 (notify == TB_UNSET) ? "[UNSPECIFIED]" :
619 (notify == TB_TRUE) ? "true" :
620 "false");
621 struct Mailbox *m = mailbox_new();
622
623 buf_strcpy(&m->pathbuf, mailbox);
624 /* int rc = */ mx_path_canon2(m, folder);
625
626 if (m->type <= MUTT_UNKNOWN)
627 {
628 buf_printf(err, "Unknown Mailbox: %s", m->realpath);
629 mailbox_free(&m);
630 return MUTT_CMD_ERROR;
631 }
632
633 bool new_account = false;
634 struct Account *a = mx_ac_find(m);
635 if (!a)
636 {
637 a = account_new(NULL, NeoMutt->sub);
638 a->type = m->type;
639 new_account = true;
640 }
641
642 if (!new_account)
643 {
644 struct Mailbox *m_old = mx_mbox_find(a, m->realpath);
645 if (m_old)
646 {
647 if (!m_old->visible)
648 {
649 m_old->visible = true;
650 m_old->gen = mailbox_gen();
651 }
652
653 if (label)
654 mutt_str_replace(&m_old->name, label);
655
656 if (notify != TB_UNSET)
657 m_old->notify_user = notify;
658
659 if (poll != TB_UNSET)
660 m_old->poll_new_mail = poll;
661
662 struct EventMailbox ev_m = { m_old };
664
665 mailbox_free(&m);
666 return MUTT_CMD_SUCCESS;
667 }
668 }
669
670 if (label)
671 m->name = mutt_str_dup(label);
672
673 if (notify != TB_UNSET)
674 m->notify_user = notify;
675
676 if (poll != TB_UNSET)
677 m->poll_new_mail = poll;
678
679 if (!mx_ac_add(a, m))
680 {
681 mailbox_free(&m);
682 if (new_account)
683 {
684 cs_subset_free(&a->sub);
685 FREE(&a->name);
686 notify_free(&a->notify);
687 FREE(&a);
688 }
689 return MUTT_CMD_SUCCESS;
690 }
691
692 if (new_account)
693 {
695 }
696
697 // this is finally a visible mailbox in the sidebar and mailboxes list
698 m->visible = true;
699
700#ifdef USE_INOTIFY
702#endif
703
704 return MUTT_CMD_SUCCESS;
705}
struct Account * account_new(const char *name, struct ConfigSubset *sub)
Create a new Account.
Definition: account.c:43
@ MUTT_CMD_SUCCESS
Success: Command worked.
Definition: command.h:39
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
int mailbox_gen(void)
Get the next generation number.
Definition: mailbox.c:59
struct Mailbox * mailbox_new(void)
Create a new Mailbox.
Definition: mailbox.c:69
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:90
@ NT_MAILBOX_CHANGE
Mailbox has been changed.
Definition: mailbox.h:172
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
int mutt_monitor_add(struct Mailbox *m)
Add a watch for a mailbox.
Definition: monitor.c:480
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:173
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:75
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:327
struct Mailbox * mx_mbox_find(struct Account *a, const char *path)
Find a Mailbox on an Account.
Definition: mx.c:1559
bool mx_ac_add(struct Account *a, struct Mailbox *m)
Add a Mailbox to an Account - Wrapper for MxOps::ac_add()
Definition: mx.c:1739
struct Account * mx_ac_find(struct Mailbox *m)
Find the Account owning a Mailbox.
Definition: mx.c:1535
int mx_path_canon2(struct Mailbox *m, const char *folder)
Canonicalise the path to realpath.
Definition: mx.c:1476
bool neomutt_account_add(struct NeoMutt *n, struct Account *a)
Add an Account to the global list.
Definition: neomutt.c:104
@ NT_MAILBOX
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:49
A group of associated Mailboxes.
Definition: account.h:37
enum MailboxType type
Type of Mailboxes this Account contains.
Definition: account.h:38
char * name
Name of Account.
Definition: account.h:39
struct Notify * notify
Notifications: NotifyAccount, EventAccount.
Definition: account.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: account.h:40
An Event that happened to a Mailbox.
Definition: mailbox.h:186
A mailbox.
Definition: mailbox.h:79
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:81
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
bool poll_new_mail
Check for new mail.
Definition: mailbox.h:114
char * name
A short name for the Mailbox.
Definition: mailbox.h:82
struct Notify * notify
Notifications: NotifyMailbox, EventMailbox.
Definition: mailbox.h:144
bool notify_user
Notify the user of new mail.
Definition: mailbox.h:112
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:80
bool visible
True if a result of "mailboxes".
Definition: mailbox.h:129
int gen
Generation number, for sorting.
Definition: mailbox.h:146
void cs_subset_free(struct ConfigSubset **ptr)
Free a Config Subset.
Definition: subset.c:99
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ set_dump()

enum CommandResult set_dump ( ConfigDumpFlags  flags,
struct Buffer err 
)

Dump list of config variables into a file/pager.

Parameters
flagswhat configs to dump: see ConfigDumpFlags
errbuffer for error message
Returns
num See CommandResult

FIXME: Move me into parse/set.c. Note: this function currently depends on pager, which is the reason it is not included in the parse library.

Definition at line 847 of file commands.c.

848{
849 struct Buffer *tempfile = buf_pool_get();
850 buf_mktemp(tempfile);
851
852 FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w");
853 if (!fp_out)
854 {
855 // L10N: '%s' is the file name of the temporary file
856 buf_printf(err, _("Could not create temporary file %s"), buf_string(tempfile));
857 buf_pool_release(&tempfile);
858 return MUTT_CMD_ERROR;
859 }
860
861 dump_config(NeoMutt->sub->cs, flags, fp_out);
862
863 mutt_file_fclose(&fp_out);
864
865 struct PagerData pdata = { 0 };
866 struct PagerView pview = { &pdata };
867
868 pdata.fname = buf_string(tempfile);
869
870 pview.banner = "set";
872 pview.mode = PAGER_MODE_OTHER;
873
874 mutt_do_pager(&pview, NULL);
875 buf_pool_release(&tempfile);
876
877 return MUTT_CMD_SUCCESS;
878}
bool dump_config(struct ConfigSet *cs, ConfigDumpFlags flags, FILE *fp)
Write all the config to a file.
Definition: dump.c:165
int mutt_do_pager(struct PagerView *pview, struct Email *e)
Display some page-able text to the user (help or attachment)
Definition: do_pager.c:123
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:636
#define MUTT_PAGER_NO_FLAGS
No flags are set.
Definition: lib.h:59
@ PAGER_MODE_OTHER
Pager is invoked via 3rd path. Non-email content is likely to be shown.
Definition: lib.h:141
struct ConfigSet * cs
Parent ConfigSet.
Definition: subset.h:51
Data to be displayed by PagerView.
Definition: lib.h:160
const char * fname
Name of the file to read.
Definition: lib.h:164
Paged view into some data.
Definition: lib.h:171
struct PagerData * pdata
Data that pager displays. NOTNULL.
Definition: lib.h:172
enum PagerMode mode
Pager mode.
Definition: lib.h:173
PagerFlags flags
Additional settings to tweak pager's function.
Definition: lib.h:174
const char * banner
Title to display in status bar.
Definition: lib.h:175
#define buf_mktemp(buf)
Definition: tmp.h:33
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ do_unmailboxes()

static void do_unmailboxes ( struct Mailbox m)
static

Remove a Mailbox from the Sidebar/notifications.

Parameters
mMailbox to unmailboxes

Definition at line 1374 of file commands.c.

1375{
1376#ifdef USE_INOTIFY
1377 if (m->poll_new_mail)
1379#endif
1380 m->visible = false;
1381 m->gen = -1;
1382 if (m->opened)
1383 {
1384 struct EventMailbox ev_m = { NULL };
1385 mutt_debug(LL_NOTIFY, "NT_MAILBOX_CHANGE: NULL\n");
1387 }
1388 else
1389 {
1391 mailbox_free(&m);
1392 }
1393}
bool account_mailbox_remove(struct Account *a, struct Mailbox *m)
Remove a Mailbox from an Account.
Definition: account.c:97
@ LL_NOTIFY
Log of notifications.
Definition: logging2.h:48
int mutt_monitor_remove(struct Mailbox *m)
Remove a watch for a mailbox.
Definition: monitor.c:524
struct Account * account
Account that owns this Mailbox.
Definition: mailbox.h:126
int opened
Number of times mailbox is opened.
Definition: mailbox.h:127
struct Notify * notify
Notifications handler.
Definition: neomutt.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ do_unmailboxes_star()

static void do_unmailboxes_star ( void  )
static

Remove all Mailboxes from the Sidebar/notifications.

Definition at line 1398 of file commands.c.

1399{
1400 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
1402 struct MailboxNode *np = NULL;
1403 struct MailboxNode *nptmp = NULL;
1404 STAILQ_FOREACH_SAFE(np, &ml, entries, nptmp)
1405 {
1407 }
1409}
static void do_unmailboxes(struct Mailbox *m)
Remove a Mailbox from the Sidebar/notifications.
Definition: commands.c:1374
@ MUTT_MAILBOX_ANY
Match any Mailbox type.
Definition: mailbox.h:42
void neomutt_mailboxlist_clear(struct MailboxList *ml)
Free a Mailbox List.
Definition: neomutt.c:162
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:185
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:362
List of Mailboxes.
Definition: mailbox.h:153
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:154
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ source_stack_cleanup()

void source_stack_cleanup ( void  )

Free memory from the stack used for the source command.

Definition at line 1621 of file commands.c.

1622{
1624}
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:122
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ commands_init()

void commands_init ( void  )

Initialize commands array and register default commands.

Definition at line 1697 of file commands.c.

1698{
1700}
static const struct Command MuttCommands[]
General NeoMutt Commands.
Definition: commands.c:1629
void commands_register(const struct Command *cmds, const size_t num_cmds)
Add commands to Commands array.
Definition: command.c:53
#define mutt_array_size(x)
Definition: memory.h:38
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ MuttrcStack

struct ListHead MuttrcStack = STAILQ_HEAD_INITIALIZER(MuttrcStack)
static

LIFO designed to contain the list of config files that have been sourced and avoid cyclic sourcing.

Definition at line 70 of file commands.c.

◆ MuttCommands

const struct Command MuttCommands[]
static

General NeoMutt Commands.

Definition at line 1629 of file commands.c.