NeoMutt  2024-04-25-102-g19653a
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 <sys/types.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.
 
bool mailbox_add_simple (const char *mailbox, 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
  • Richard Russon
  • Aditya De Saha
  • Matthew Hughes
  • R Primus
  • Pietro Cerutti
  • Marco Sirabella
  • Dennis Schön

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 79 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 84 of file commands.c.

85{
86 TB_UNSET = -1,
87 TB_FALSE,
88 TB_TRUE,
89};
@ TB_FALSE
Value is false.
Definition: commands.c:87
@ TB_TRUE
Value is true.
Definition: commands.c:88
@ TB_UNSET
Value hasn't been set.
Definition: commands.c:86

◆ 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 94 of file commands.c.

95{
96 GS_NONE,
97 GS_RX,
98 GS_ADDR,
99};
@ GS_RX
Entry is a regular expression.
Definition: commands.c:97
@ GS_NONE
Group is missing an argument.
Definition: commands.c:96
@ GS_ADDR
Entry is an address.
Definition: commands.c:98

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 107 of file commands.c.

108{
109 for (size_t i = 0; MenuNames[i].name; i++)
110 {
111 const struct MenuFuncOp *fns = km_get_table(MenuNames[i].value);
112 if (!fns)
113 continue;
114
115 for (int j = 0; fns[j].name; j++)
116 if (mutt_str_equal(name, fns[j].name))
117 return true;
118 }
119 return false;
120}
const struct MenuFuncOp * km_get_table(enum MenuType mtype)
Lookup a Menu's functions.
Definition: lib.c:525
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
const char * name
String value.
Definition: mapping.h:34
Mapping between a function and an operation.
Definition: lib.h:101
const char * name
Name of the function.
Definition: lib.h:102
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 131 of file commands.c.

133{
134 while (mutt_istr_equal(buf->data, "-group"))
135 {
136 if (!MoreArgs(s))
137 {
138 buf_strcpy(err, _("-group: no group name"));
139 return -1;
140 }
141
143
145
146 if (!MoreArgs(s))
147 {
148 buf_strcpy(err, _("out of arguments"));
149 return -1;
150 }
151
153 }
154
155 return 0;
156}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
int parse_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: extract.c:50
#define MoreArgs(buf)
Definition: extract.h:32
#define TOKEN_NO_FLAGS
No flags are set.
Definition: extract.h:46
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:672
char * data
Pointer to data.
Definition: buffer.h:37
+ 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 165 of file commands.c.

166{
168
169 enum CommandResult ret = parse_rc_line(line, err);
170
171 struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
173 FREE(&np->data);
174 FREE(&np);
175
176 return ret;
177}
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:77
struct ListNode * mutt_list_insert_head(struct ListHead *h, char *s)
Insert a string at the beginning of a List.
Definition: list.c:46
#define FREE(x)
Definition: memory.h:45
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
#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:37
char * data
String.
Definition: list.h:38
+ 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 185 of file commands.c.

186{
187 struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
188 if (np && np->data)
189 return mutt_str_dup(np->data);
190
191 // stack is empty, return our own dummy file relative to cwd
192 struct Buffer *cwd = buf_pool_get();
193 mutt_path_getcwd(cwd);
194 buf_addstr(cwd, "/dummy.rc");
195 char *ret = buf_strdup(cwd);
196 buf_pool_release(&cwd);
197 return ret;
198}
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:571
const char * mutt_path_getcwd(struct Buffer *cwd)
Get the current working directory.
Definition: path.c:469
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:36
+ 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 206 of file commands.c.

207{
208 int lineno = 0, rc = 0, warnings = 0;
209 enum CommandResult line_rc;
210 struct Buffer *token = NULL, *linebuf = NULL;
211 char *line = NULL;
212 char *currentline = NULL;
213 char rcfile[PATH_MAX] = { 0 };
214 size_t linelen = 0;
215 pid_t pid;
216
217 mutt_str_copy(rcfile, rcfile_path, sizeof(rcfile));
218
219 size_t rcfilelen = mutt_str_len(rcfile);
220 if (rcfilelen == 0)
221 return -1;
222
223 bool ispipe = rcfile[rcfilelen - 1] == '|';
224
225 if (!ispipe)
226 {
227 struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
228 if (!mutt_path_to_absolute(rcfile, np ? NONULL(np->data) : ""))
229 {
230 mutt_error(_("Error: Can't build path of '%s'"), rcfile_path);
231 return -1;
232 }
233
234 STAILQ_FOREACH(np, &MuttrcStack, entries)
235 {
236 if (mutt_str_equal(np->data, rcfile))
237 {
238 break;
239 }
240 }
241 if (np)
242 {
243 mutt_error(_("Error: Cyclic sourcing of configuration file '%s'"), rcfile);
244 return -1;
245 }
246
248 }
249
250 mutt_debug(LL_DEBUG2, "Reading configuration file '%s'\n", rcfile);
251
252 FILE *fp = mutt_open_read(rcfile, &pid);
253 if (!fp)
254 {
255 buf_printf(err, "%s: %s", rcfile, strerror(errno));
256 return -1;
257 }
258
259 token = buf_pool_get();
260 linebuf = buf_pool_get();
261
262 const char *const c_config_charset = cs_subset_string(NeoMutt->sub, "config_charset");
263 const char *const c_charset = cc_charset();
264 while ((line = mutt_file_read_line(line, &linelen, fp, &lineno, MUTT_RL_CONT)) != NULL)
265 {
266 const bool conv = c_config_charset && c_charset;
267 if (conv)
268 {
269 currentline = mutt_str_dup(line);
270 if (!currentline)
271 continue;
272 mutt_ch_convert_string(&currentline, c_config_charset, c_charset, MUTT_ICONV_NO_FLAGS);
273 }
274 else
275 {
276 currentline = line;
277 }
278
279 buf_strcpy(linebuf, currentline);
280
281 buf_reset(err);
282 line_rc = parse_rc_buffer(linebuf, token, err);
283 if (line_rc == MUTT_CMD_ERROR)
284 {
285 mutt_error("%s:%d: %s", rcfile, lineno, buf_string(err));
286 if (--rc < -MAX_ERRS)
287 {
288 if (conv)
289 FREE(&currentline);
290 break;
291 }
292 }
293 else if (line_rc == MUTT_CMD_WARNING)
294 {
295 /* Warning */
296 mutt_warning("%s:%d: %s", rcfile, lineno, buf_string(err));
297 warnings++;
298 }
299 else if (line_rc == MUTT_CMD_FINISH)
300 {
301 if (conv)
302 FREE(&currentline);
303 break; /* Found "finish" command */
304 }
305 else
306 {
307 if (rc < 0)
308 rc = -1;
309 }
310 if (conv)
311 FREE(&currentline);
312 }
313
314 FREE(&line);
315 mutt_file_fclose(&fp);
316 if (pid != -1)
317 filter_wait(pid);
318
319 if (rc)
320 {
321 /* the neomuttrc source keyword */
322 buf_reset(err);
323 buf_printf(err, (rc >= -MAX_ERRS) ? _("source: errors in %s") : _("source: reading aborted due to too many errors in %s"),
324 rcfile);
325 rc = -1;
326 }
327 else
328 {
329 /* Don't alias errors with warnings */
330 if (warnings > 0)
331 {
332 buf_printf(err, ngettext("source: %d warning in %s", "source: %d warnings in %s", warnings),
333 warnings, rcfile);
334 rc = -2;
335 }
336 }
337
338 if (!ispipe && !STAILQ_EMPTY(&MuttrcStack))
339 {
340 struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
342 FREE(&np->data);
343 FREE(&np);
344 }
345
346 buf_pool_release(&token);
347 buf_pool_release(&linebuf);
348 return rc;
349}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
@ 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:79
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:116
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:808
#define MUTT_RL_CONT
-continuation
Definition: file.h:41
#define mutt_file_fclose(FP)
Definition: file.h:149
#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:831
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition: charset.h:73
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:220
bool mutt_path_to_absolute(char *path, const char *reference)
Convert relative filepath to an absolute path.
Definition: path.c:333
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
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:581
#define PATH_MAX
Definition: mutt.h:42
FILE * mutt_open_read(const char *path, pid_t *thepid)
Run a command to read from.
Definition: muttlib.c:701
#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:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ 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.

Parameters
folderPath to use for '+' abbreviations
mailboxMailbox to add
labelDescriptive label
pollEnable mailbox polling?
notifyEnable mailbox notification?
errBuffer for error messages
Return values
CommandResultResult e.g. MUTT_CMD_SUCCESS

Definition at line 623 of file commands.c.

626{
627 mutt_debug(LL_DEBUG1, "Adding mailbox: '%s' label '%s', poll %s, notify %s\n",
628 mailbox, label ? label : "[NONE]",
629 (poll == TB_UNSET) ? "[UNSPECIFIED]" :
630 (poll == TB_TRUE) ? "true" :
631 "false",
632 (notify == TB_UNSET) ? "[UNSPECIFIED]" :
633 (notify == TB_TRUE) ? "true" :
634 "false");
635 struct Mailbox *m = mailbox_new();
636
637 buf_strcpy(&m->pathbuf, mailbox);
638 /* int rc = */ mx_path_canon2(m, folder);
639
640 if (m->type <= MUTT_UNKNOWN)
641 {
642 buf_printf(err, "Unknown Mailbox: %s", m->realpath);
643 mailbox_free(&m);
644 return MUTT_CMD_ERROR;
645 }
646
647 bool new_account = false;
648 struct Account *a = mx_ac_find(m);
649 if (!a)
650 {
651 a = account_new(NULL, NeoMutt->sub);
652 a->type = m->type;
653 new_account = true;
654 }
655
656 if (!new_account)
657 {
658 struct Mailbox *m_old = mx_mbox_find(a, m->realpath);
659 if (m_old)
660 {
661 if (!m_old->visible)
662 {
663 m_old->visible = true;
664 m_old->gen = mailbox_gen();
665 }
666
667 if (label)
668 mutt_str_replace(&m_old->name, label);
669
670 if (notify != TB_UNSET)
671 m_old->notify_user = notify;
672
673 if (poll != TB_UNSET)
674 m_old->poll_new_mail = poll;
675
676 struct EventMailbox ev_m = { m_old };
678
679 mailbox_free(&m);
680 return MUTT_CMD_SUCCESS;
681 }
682 }
683
684 if (label)
685 m->name = mutt_str_dup(label);
686
687 if (notify != TB_UNSET)
688 m->notify_user = notify;
689
690 if (poll != TB_UNSET)
691 m->poll_new_mail = poll;
692
693 if (!mx_ac_add(a, m))
694 {
695 mailbox_free(&m);
696 if (new_account)
697 {
698 cs_subset_free(&a->sub);
699 FREE(&a->name);
700 notify_free(&a->notify);
701 FREE(&a);
702 }
703 return MUTT_CMD_SUCCESS;
704 }
705
706 if (new_account)
707 {
709 }
710
711 // this is finally a visible mailbox in the sidebar and mailboxes list
712 m->visible = true;
713
714#ifdef USE_INOTIFY
716#endif
717
718 return MUTT_CMD_SUCCESS;
719}
@ MUTT_CMD_SUCCESS
Success: Command worked.
Definition: command.h:39
struct Account * account_new(const char *name, struct ConfigSubset *sub)
Create a new Account.
Definition: account.c:44
int mailbox_gen(void)
Get the next generation number.
Definition: mailbox.c:58
struct Mailbox * mailbox_new(void)
Create a new Mailbox.
Definition: mailbox.c:68
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:89
@ NT_MAILBOX_CHANGE
Mailbox has been changed.
Definition: mailbox.h:185
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
int mutt_monitor_add(struct Mailbox *m)
Add a watch for a mailbox.
Definition: monitor.c:484
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:280
struct Mailbox * mx_mbox_find(struct Account *a, const char *path)
Find a Mailbox on an Account.
Definition: mx.c:1543
bool mx_ac_add(struct Account *a, struct Mailbox *m)
Add a Mailbox to an Account - Wrapper for MxOps::ac_add()
Definition: mx.c:1723
struct Account * mx_ac_find(struct Mailbox *m)
Find the Account owning a Mailbox.
Definition: mx.c:1519
int mx_path_canon2(struct Mailbox *m, const char *folder)
Canonicalise the path to realpath.
Definition: mx.c:1471
bool neomutt_account_add(struct NeoMutt *n, struct Account *a)
Add an Account to the global list.
Definition: neomutt.c:110
@ NT_MAILBOX
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:49
A group of associated Mailboxes.
Definition: account.h:36
enum MailboxType type
Type of Mailboxes this Account contains.
Definition: account.h:37
char * name
Name of Account.
Definition: account.h:38
struct Notify * notify
Notifications: NotifyAccount, EventAccount.
Definition: account.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: account.h:39
An Event that happened to a Mailbox.
Definition: mailbox.h:199
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:115
char * name
A short name for the Mailbox.
Definition: mailbox.h:82
struct Notify * notify
Notifications: NotifyMailbox, EventMailbox.
Definition: mailbox.h:145
bool notify_user
Notify the user of new mail.
Definition: mailbox.h:113
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:80
bool visible
True if a result of "mailboxes".
Definition: mailbox.h:130
int gen
Generation number, for sorting.
Definition: mailbox.h:147
void cs_subset_free(struct ConfigSubset **ptr)
Free a Config Subset.
Definition: subset.c:108
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mailbox_add_simple()

bool mailbox_add_simple ( const char *  mailbox,
struct Buffer err 
)

Add a new Mailbox.

Parameters
mailboxMailbox to add
errBuffer for error messages
Return values
trueSuccess

Definition at line 727 of file commands.c.

728{
729 enum CommandResult rc = mailbox_add("", mailbox, NULL, TB_UNSET, TB_UNSET, err);
730
731 return (rc == MUTT_CMD_SUCCESS);
732}
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.
Definition: commands.c:623
+ 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 874 of file commands.c.

875{
876 struct Buffer *tempfile = buf_pool_get();
877 buf_mktemp(tempfile);
878
879 FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w");
880 if (!fp_out)
881 {
882 // L10N: '%s' is the file name of the temporary file
883 buf_printf(err, _("Could not create temporary file %s"), buf_string(tempfile));
884 buf_pool_release(&tempfile);
885 return MUTT_CMD_ERROR;
886 }
887
888 dump_config(NeoMutt->sub->cs, flags, fp_out);
889
890 mutt_file_fclose(&fp_out);
891
892 struct PagerData pdata = { 0 };
893 struct PagerView pview = { &pdata };
894
895 pdata.fname = buf_string(tempfile);
896
897 pview.banner = "set";
899 pview.mode = PAGER_MODE_OTHER;
900
901 mutt_do_pager(&pview, NULL);
902 buf_pool_release(&tempfile);
903
904 return MUTT_CMD_SUCCESS;
905}
bool dump_config(struct ConfigSet *cs, ConfigDumpFlags flags, FILE *fp)
Write all the config to a file.
Definition: dump.c:167
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:122
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:148
#define MUTT_PAGER_NO_FLAGS
No flags are set.
Definition: lib.h:60
@ PAGER_MODE_OTHER
Pager is invoked via 3rd path. Non-email content is likely to be shown.
Definition: lib.h:142
struct ConfigSet * cs
Parent ConfigSet.
Definition: subset.h:51
Data to be displayed by PagerView.
Definition: lib.h:161
const char * fname
Name of the file to read.
Definition: lib.h:165
Paged view into some data.
Definition: lib.h:172
struct PagerData * pdata
Data that pager displays. NOTNULL.
Definition: lib.h:173
enum PagerMode mode
Pager mode.
Definition: lib.h:174
PagerFlags flags
Additional settings to tweak pager's function.
Definition: lib.h:175
const char * banner
Title to display in status bar.
Definition: lib.h:176
#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 1406 of file commands.c.

1407{
1408#ifdef USE_INOTIFY
1409 if (m->poll_new_mail)
1411#endif
1412 m->visible = false;
1413 m->gen = -1;
1414 if (m->opened)
1415 {
1416 struct EventMailbox ev_m = { NULL };
1417 mutt_debug(LL_NOTIFY, "NT_MAILBOX_CHANGE: NULL\n");
1419 }
1420 else
1421 {
1423 mailbox_free(&m);
1424 }
1425}
bool account_mailbox_remove(struct Account *a, struct Mailbox *m)
Remove a Mailbox from an Account.
Definition: account.c:98
@ 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:528
struct Account * account
Account that owns this Mailbox.
Definition: mailbox.h:127
int opened
Number of times mailbox is opened.
Definition: mailbox.h:128
struct Notify * notify
Notifications handler.
Definition: neomutt.h:43
+ 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 1430 of file commands.c.

1431{
1432 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
1434 struct MailboxNode *np = NULL;
1435 struct MailboxNode *nptmp = NULL;
1436 STAILQ_FOREACH_SAFE(np, &ml, entries, nptmp)
1437 {
1439 }
1441}
static void do_unmailboxes(struct Mailbox *m)
Remove a Mailbox from the Sidebar/notifications.
Definition: commands.c:1406
@ 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:168
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:191
#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:166
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:167
+ 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 1654 of file commands.c.

1655{
1657}
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:123
+ 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 1730 of file commands.c.

1731{
1733}
static const struct Command MuttCommands[]
General NeoMutt Commands.
Definition: commands.c:1662
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 77 of file commands.c.

◆ MuttCommands

const struct Command MuttCommands[]
static

General NeoMutt Commands.

Definition at line 1662 of file commands.c.