NeoMutt  2023-11-03-107-g582dc1
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
extract.c
Go to the documentation of this file.
1
29#include "config.h"
30#include <ctype.h>
31#include <stdio.h>
32#include <string.h>
33#include <sys/types.h>
34#include "mutt/lib.h"
35#include "config/lib.h"
36#include "core/lib.h"
37#include "extract.h"
38#include "globals.h"
39
48int parse_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
49{
50 if (!dest || !tok)
51 return -1;
52
53 char ch;
54 char qc = '\0'; /* quote char */
55 char *pc = NULL;
56
57 /* Some callers used to rely on the (bad) assumption that dest->data would be
58 * non-NULL after calling this function. Perhaps I've missed a few cases, or
59 * a future caller might make the same mistake. */
60 if (!dest->data)
61 buf_alloc(dest, 256);
62
63 buf_reset(dest);
64
65 SKIPWS(tok->dptr);
66 while ((ch = *tok->dptr))
67 {
68 if (qc == '\0')
69 {
70 if (isspace(ch) && !(flags & TOKEN_SPACE))
71 break;
72 if ((ch == '#') && !(flags & TOKEN_COMMENT))
73 break;
74 if ((ch == '+') && (flags & TOKEN_PLUS))
75 break;
76 if ((ch == '-') && (flags & TOKEN_MINUS))
77 break;
78 if ((ch == '=') && (flags & TOKEN_EQUAL))
79 break;
80 if ((ch == '?') && (flags & TOKEN_QUESTION))
81 break;
82 if ((ch == ';') && !(flags & TOKEN_SEMICOLON))
83 break;
84 if ((flags & TOKEN_PATTERN) && strchr("~%=!|", ch))
85 break;
86 }
87
88 tok->dptr++;
89
90 if (ch == qc)
91 {
92 qc = 0; /* end of quote */
93 }
94 else if (!qc && ((ch == '\'') || (ch == '"')) && !(flags & TOKEN_QUOTE))
95 {
96 qc = ch;
97 }
98 else if ((ch == '\\') && (qc != '\''))
99 {
100 if (tok->dptr[0] == '\0')
101 return -1; /* premature end of token */
102 switch (ch = *tok->dptr++)
103 {
104 case 'c':
105 case 'C':
106 if (tok->dptr[0] == '\0')
107 return -1; /* premature end of token */
108 buf_addch(dest, (toupper((unsigned char) tok->dptr[0]) - '@') & 0x7f);
109 tok->dptr++;
110 break;
111 case 'e':
112 buf_addch(dest, '\033'); // Escape
113 break;
114 case 'f':
115 buf_addch(dest, '\f');
116 break;
117 case 'n':
118 buf_addch(dest, '\n');
119 break;
120 case 'r':
121 buf_addch(dest, '\r');
122 break;
123 case 't':
124 buf_addch(dest, '\t');
125 break;
126 default:
127 if (isdigit((unsigned char) ch) && isdigit((unsigned char) tok->dptr[0]) &&
128 isdigit((unsigned char) tok->dptr[1]))
129 {
130 buf_addch(dest, (ch << 6) + (tok->dptr[0] << 3) + tok->dptr[1] - 3504);
131 tok->dptr += 2;
132 }
133 else
134 {
135 buf_addch(dest, ch);
136 }
137 }
138 }
139 else if ((ch == '^') && (flags & TOKEN_CONDENSE))
140 {
141 if (tok->dptr[0] == '\0')
142 return -1; /* premature end of token */
143 ch = *tok->dptr++;
144 if (ch == '^')
145 {
146 buf_addch(dest, ch);
147 }
148 else if (ch == '[')
149 {
150 buf_addch(dest, '\033'); // Escape
151 }
152 else if (isalpha((unsigned char) ch))
153 {
154 buf_addch(dest, toupper((unsigned char) ch) - '@');
155 }
156 else
157 {
158 buf_addch(dest, '^');
159 buf_addch(dest, ch);
160 }
161 }
162 else if ((ch == '`') && (!qc || (qc == '"')))
163 {
164 FILE *fp = NULL;
165 pid_t pid;
166
167 pc = tok->dptr;
168 do
169 {
170 pc = strpbrk(pc, "\\`");
171 if (pc)
172 {
173 /* skip any quoted chars */
174 if (*pc == '\\')
175 pc += 2;
176 }
177 } while (pc && (pc[0] != '`'));
178 if (!pc)
179 {
180 mutt_debug(LL_DEBUG1, "mismatched backticks\n");
181 return -1;
182 }
183 struct Buffer *cmd = buf_pool_get();
184 *pc = '\0';
185 if (flags & TOKEN_BACKTICK_VARS)
186 {
187 /* recursively extract tokens to interpolate variables */
188 parse_extract_token(cmd, tok,
191 }
192 else
193 {
194 buf_strcpy(cmd, tok->dptr);
195 }
196 *pc = '`';
197 pid = filter_create(buf_string(cmd), NULL, &fp, NULL, EnvList);
198 if (pid < 0)
199 {
200 mutt_debug(LL_DEBUG1, "unable to fork command: %s\n", buf_string(cmd));
201 buf_pool_release(&cmd);
202 return -1;
203 }
204
205 tok->dptr = pc + 1;
206
207 /* read line */
208 struct Buffer expn = buf_make(0);
209 expn.data = mutt_file_read_line(NULL, &expn.dsize, fp, NULL, MUTT_RL_NO_FLAGS);
210 mutt_file_fclose(&fp);
211 int rc = filter_wait(pid);
212 if (rc != 0)
213 {
214 mutt_debug(LL_DEBUG1, "backticks exited code %d for command: %s\n", rc,
215 buf_string(cmd));
216 }
217 buf_pool_release(&cmd);
218
219 /* if we got output, make a new string consisting of the shell output
220 * plus whatever else was left on the original line */
221 /* BUT: If this is inside a quoted string, directly add output to
222 * the token */
223 if (expn.data)
224 {
225 if (qc)
226 {
227 buf_addstr(dest, expn.data);
228 }
229 else
230 {
231 struct Buffer *copy = buf_pool_get();
232 buf_fix_dptr(&expn);
233 buf_copy(copy, &expn);
234 buf_addstr(copy, tok->dptr);
235 buf_copy(tok, copy);
236 buf_seek(tok, 0);
237 buf_pool_release(&copy);
238 }
239 FREE(&expn.data);
240 }
241 }
242 else if ((ch == '$') && (!qc || (qc == '"')) &&
243 ((tok->dptr[0] == '{') || isalpha((unsigned char) tok->dptr[0])))
244 {
245 const char *env = NULL;
246 char *var = NULL;
247
248 if (tok->dptr[0] == '{')
249 {
250 pc = strchr(tok->dptr, '}');
251 if (pc)
252 {
253 var = mutt_strn_dup(tok->dptr + 1, pc - (tok->dptr + 1));
254 tok->dptr = pc + 1;
255
256 if ((flags & TOKEN_NOSHELL))
257 {
258 buf_addch(dest, ch);
259 buf_addch(dest, '{');
260 buf_addstr(dest, var);
261 buf_addch(dest, '}');
262 FREE(&var);
263 }
264 }
265 }
266 else
267 {
268 for (pc = tok->dptr; isalnum((unsigned char) *pc) || (pc[0] == '_'); pc++)
269 ; // do nothing
270
271 var = mutt_strn_dup(tok->dptr, pc - tok->dptr);
272 tok->dptr = pc;
273 }
274 if (var)
275 {
276 struct Buffer *result = buf_pool_get();
277 int rc = cs_subset_str_string_get(NeoMutt->sub, var, result);
278
279 if (CSR_RESULT(rc) == CSR_SUCCESS)
280 {
281 buf_addstr(dest, buf_string(result));
282 }
283 else if (!(flags & TOKEN_NOSHELL) && (env = mutt_str_getenv(var)))
284 {
285 buf_addstr(dest, env);
286 }
287 else
288 {
289 buf_addch(dest, ch);
290 buf_addstr(dest, var);
291 }
292 FREE(&var);
293 buf_pool_release(&result);
294 }
295 }
296 else
297 {
298 buf_addch(dest, ch);
299 }
300 }
301 buf_addch(dest, 0); /* terminate the string */
302 SKIPWS(tok->dptr);
303 return 0;
304}
void buf_seek(struct Buffer *buf, size_t offset)
Set current read/write position to offset from beginning.
Definition: buffer.c:593
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:88
struct Buffer buf_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:70
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:194
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:253
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:238
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:407
size_t buf_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer's contents to another Buffer.
Definition: buffer.c:572
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:349
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:93
Convenience wrapper for the config headers.
#define CSR_RESULT(x)
Definition: set.h:52
#define CSR_SUCCESS
Action completed successfully.
Definition: set.h:35
Convenience wrapper for the core headers.
int parse_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: extract.c:48
Text parser.
#define TOKEN_BACKTICK_VARS
Expand variables within backticks.
Definition: extract.h:53
#define TOKEN_SPACE
Don't treat whitespace as a term.
Definition: extract.h:48
#define TOKEN_QUOTE
Don't interpret quotes.
Definition: extract.h:49
#define TOKEN_NOSHELL
Don't expand environment variables.
Definition: extract.h:54
#define TOKEN_EQUAL
Treat '=' as a special.
Definition: extract.h:46
uint16_t TokenFlags
Flags for parse_extract_token(), e.g. TOKEN_EQUAL.
Definition: extract.h:44
#define TOKEN_CONDENSE
^(char) to control chars (macros)
Definition: extract.h:47
#define TOKEN_PLUS
Treat '+' as a special.
Definition: extract.h:56
#define TOKEN_COMMENT
Don't reap comments.
Definition: extract.h:51
#define TOKEN_MINUS
Treat '-' as a special.
Definition: extract.h:57
#define TOKEN_PATTERN
~%=!| are terms (for patterns)
Definition: extract.h:50
#define TOKEN_SEMICOLON
Don't treat ; as special.
Definition: extract.h:52
#define TOKEN_QUESTION
Treat '?' as a special.
Definition: extract.h:55
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_NO_FLAGS
No flags are set.
Definition: file.h:39
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:218
pid_t filter_create(const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, char **envlist)
Set up filter program.
Definition: filter.c:207
char ** EnvList
Private copy of the environment variables.
Definition: globals.c:83
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
#define FREE(x)
Definition: memory.h:45
Convenience wrapper for the library headers.
char * mutt_strn_dup(const char *begin, size_t len)
Duplicate a sub-string.
Definition: string.c:452
const char * mutt_str_getenv(const char *name)
Get an environment variable.
Definition: string.c:862
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
#define SKIPWS(ch)
Definition: string2.h:45
String manipulation buffer.
Definition: buffer.h:34
char * dptr
Current read/write position.
Definition: buffer.h:36
size_t dsize
Length of data.
Definition: buffer.h:37
char * data
Pointer to data.
Definition: buffer.h:35
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
int cs_subset_str_string_get(const struct ConfigSubset *sub, const char *name, struct Buffer *result)
Get a config item as a string.
Definition: subset.c:369