NeoMutt  2024-04-25-102-g19653a
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
commands.h File Reference

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

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include "config/lib.h"
#include "core/lib.h"
+ Include dependency graph for commands.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define MUTT_NAMED   (1 << 0)
 

Functions

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 parse_subjectrx_list (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'subjectrx' 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() -.
 
enum CommandResult parse_unalternates (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unalternates' command - Implements Command::parse() -.
 
enum CommandResult parse_unmailboxes (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unmailboxes' command - Implements Command::parse() -.
 
enum CommandResult parse_unsubjectrx_list (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unsubjectrx' 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() -.
 
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.
 
bool mailbox_add_simple (const char *mailbox, struct Buffer *err)
 Add a new Mailbox.
 
int parse_grouplist (struct GroupList *gl, struct Buffer *buf, struct Buffer *s, struct Buffer *err)
 Parse a group context.
 
void source_stack_cleanup (void)
 Free memory from the stack used for the source command.
 
int source_rc (const char *rcfile_path, struct Buffer *err)
 Read an initialization file.
 
enum CommandResult set_dump (ConfigDumpFlags flags, struct Buffer *err)
 Dump list of config variables into a file/pager.
 

Detailed Description

Functions to parse commands in a config file.

Authors
  • Richard Russon

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

Macro Definition Documentation

◆ MUTT_NAMED

#define MUTT_NAMED   (1 << 0)

Definition at line 36 of file commands.h.

Function Documentation

◆ 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:

◆ 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}
@ MUTT_CMD_SUCCESS
Success: Command worked.
Definition: command.h:39
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
@ TB_UNSET
Value hasn't been set.
Definition: commands.c:86
+ 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:

◆ 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:

◆ 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
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
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:

◆ 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: