picnoir
/
Systemd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Systemd/src/basic/extract-word.c

304 lines
11 KiB
C
Raw Normal View History

Add SPDX license identifiers to source files under the LGPL This follows what the kernel is doing, c.f. https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5fd54ace4721fc5ce2bb5aef6318fcf17f421460.
2017-11-18 17:09:20 +01:00
/* SPDX-License-Identifier: LGPL-2.1+ */
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
/***
This file is part of systemd.
Copyright 2010 Lennart Poettering
systemd is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
systemd 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
basic: include only what we use This is a cleaned up result of running iwyu but without forward declarations on src/basic.
2015-11-30 21:43:37 +01:00
#include <errno.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
util-lib: split out allocation calls into alloc-util.[ch]
2015-10-27 03:01:06 +01:00
#include "alloc-util.h"
util: split out escaping code into escape.[ch] This really deserves its own file, given how much code this is now.
2015-10-23 18:52:53 +02:00
#include "escape.h"
util-lib: move character class definitions to string-util.h
2015-11-03 12:25:29 +01:00
#include "extract-word.h"
basic: include only what we use This is a cleaned up result of running iwyu but without forward declarations on src/basic.
2015-11-30 21:43:37 +01:00
#include "log.h"
#include "macro.h"
util-lib: move character class definitions to string-util.h
2015-11-03 12:25:29 +01:00
#include "string-util.h"
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
#include "utf8.h"
int extract_first_word(const char **p, char **ret, const char *separators, ExtractFlags flags) {
_cleanup_free_ char *s = NULL;
size_t allocated = 0, sz = 0;
extract-word: move start block outside the for loop This block runs once before all the other handling, so move it outside the main loop and put it in its own loop until it's finished doing its job. Tested by confirming `make check` (and particularly test-extract-word) still passes and by booting a system with binaries including this commit.
2015-11-04 05:13:11 +01:00
char c;
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
int r;
char quote = 0; /* 0 or ' or " */
bool backslash = false; /* whether we've just seen a backslash */
assert(p);
assert(ret);
/* Bail early if called after last value or with no input */
if (!*p)
tree-wide: make invocations of extract_first_word more uniform (#4627) extract_first_words deals fine with the string being NULL, so drop the upfront check for that.
2016-11-11 18:58:41 +01:00
goto finish;
extract-word: increment pointer p and keep c in sync in for loop This will make it easier to use inner loops to keep looping in the same state, by just updating p and c in the same way in the inner loops. Tested that no regressions were created in test-extract-word.
2015-11-06 06:41:04 +01:00
c = **p;
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
extract-word: Check for early bail out before inspecting separators It's a pretty small optimization but doesn't hurt... Tested with test-extract-word.
2015-11-06 06:31:29 +01:00
if (!separators)
separators = WHITESPACE;
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
/* Parses the first word of a string, and returns it in
* *ret. Removes all quotes in the process. When parsing fails
* (because of an uneven number of quotes or similar), leaves
* the pointer *p at the first invalid character. */
extract-word: move start block outside the for loop This block runs once before all the other handling, so move it outside the main loop and put it in its own loop until it's finished doing its job. Tested by confirming `make check` (and particularly test-extract-word) still passes and by booting a system with binaries including this commit.
2015-11-04 05:13:11 +01:00
if (flags & EXTRACT_DONT_COALESCE_SEPARATORS)
if (!GREEDY_REALLOC(s, allocated, sz+1))
return -ENOMEM;
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
tree-wide: make ++/-- usage consistent WRT spacing Throughout the tree there's spurious use of spaces separating ++ and -- operators from their respective operands. Make ++ and -- operator consistent with the majority of existing uses; discard the spaces.
2016-02-23 05:32:04 +01:00
for (;; (*p)++, c = **p) {
extract-word: move start block outside the for loop This block runs once before all the other handling, so move it outside the main loop and put it in its own loop until it's finished doing its job. Tested by confirming `make check` (and particularly test-extract-word) still passes and by booting a system with binaries including this commit.
2015-11-04 05:13:11 +01:00
if (c == 0)
goto finish_force_terminate;
else if (strchr(separators, c)) {
extract-word: increment pointer p and keep c in sync in for loop This will make it easier to use inner loops to keep looping in the same state, by just updating p and c in the same way in the inner loops. Tested that no regressions were created in test-extract-word.
2015-11-06 06:41:04 +01:00
if (flags & EXTRACT_DONT_COALESCE_SEPARATORS) {
tree-wide: make ++/-- usage consistent WRT spacing Throughout the tree there's spurious use of spaces separating ++ and -- operators from their respective operands. Make ++ and -- operator consistent with the majority of existing uses; discard the spaces.
2016-02-23 05:32:04 +01:00
(*p)++;
extract-word: move start block outside the for loop This block runs once before all the other handling, so move it outside the main loop and put it in its own loop until it's finished doing its job. Tested by confirming `make check` (and particularly test-extract-word) still passes and by booting a system with binaries including this commit.
2015-11-04 05:13:11 +01:00
goto finish_force_next;
extract-word: increment pointer p and keep c in sync in for loop This will make it easier to use inner loops to keep looping in the same state, by just updating p and c in the same way in the inner loops. Tested that no regressions were created in test-extract-word.
2015-11-06 06:41:04 +01:00
}
extract-word: move start block outside the for loop This block runs once before all the other handling, so move it outside the main loop and put it in its own loop until it's finished doing its job. Tested by confirming `make check` (and particularly test-extract-word) still passes and by booting a system with binaries including this commit.
2015-11-04 05:13:11 +01:00
} else {
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
/* We found a non-blank character, so we will always
* want to return a string (even if it is empty),
* allocate it here. */
if (!GREEDY_REALLOC(s, allocated, sz+1))
return -ENOMEM;
extract-word: move start block outside the for loop This block runs once before all the other handling, so move it outside the main loop and put it in its own loop until it's finished doing its job. Tested by confirming `make check` (and particularly test-extract-word) still passes and by booting a system with binaries including this commit.
2015-11-04 05:13:11 +01:00
break;
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
}
extract-word: move start block outside the for loop This block runs once before all the other handling, so move it outside the main loop and put it in its own loop until it's finished doing its job. Tested by confirming `make check` (and particularly test-extract-word) still passes and by booting a system with binaries including this commit.
2015-11-04 05:13:11 +01:00
}
tree-wide: make ++/-- usage consistent WRT spacing Throughout the tree there's spurious use of spaces separating ++ and -- operators from their respective operands. Make ++ and -- operator consistent with the majority of existing uses; discard the spaces.
2016-02-23 05:32:04 +01:00
for (;; (*p)++, c = **p) {
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
if (backslash) {
if (!GREEDY_REALLOC(s, allocated, sz+7))
return -ENOMEM;
if (c == 0) {
if ((flags & EXTRACT_CUNESCAPE_RELAX) &&
(!quote || flags & EXTRACT_RELAX)) {
/* If we find an unquoted trailing backslash and we're in
* EXTRACT_CUNESCAPE_RELAX mode, keep it verbatim in the
* output.
*
* Unbalanced quotes will only be allowed in EXTRACT_RELAX
* mode, EXTRACT_CUNESCAPE_RELAX mode does not allow them.
*/
s[sz++] = '\\';
goto finish_force_terminate;
}
if (flags & EXTRACT_RELAX)
goto finish_force_terminate;
return -EINVAL;
}
if (flags & EXTRACT_CUNESCAPE) {
basic/escape: merge utf8 and non-utf8 paths in cunescape_one Not every byte sequence is valid utf8. We allow escaping of non-utf8 sequences in strings by using octal and hexadecimal escape sequences (\123 and \0xAB) for bytes at or above 128. Users of cunescape_one could infer whether such use occured when they received an answer between 128 and 256 in *ret (a non-ascii one byte character). But this is subtle and misleading: the comments were wrong, because ascii is a subset of unicode, so c != 0 did not mean non-unicode, but rather ascii-subset-of-unicode-or-raw-byte. This was all rather confusing, so make the "single byte" condition explicit. I'm not convinced that allowing non-utf8 sequences to be produced is useful in all cases where we allow it (e.g. in config files), but that behaviour is unchanged, just made more explicit. This also fixes an (invalid) gcc warning about unitialized variable (*ret_unicode) in callers of cunescape_one.
2016-01-12 21:36:57 +01:00
bool eight_bit = false;
utf8.[ch] et al: use char32_t and char16_t instead of int, int32_t, int16_t rework C11 utf8.[ch] to use char32_t instead of uint32_t when referring to unicode chars, to make things more expressive. [ @zonque: * rebased to current master * use AC_CHECK_DECLS to detect availibility of char{16,32}_t * make utf8_encoded_to_unichar() return int ]
2015-12-13 23:26:43 +01:00
char32_t u;
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
basic/escape: merge utf8 and non-utf8 paths in cunescape_one Not every byte sequence is valid utf8. We allow escaping of non-utf8 sequences in strings by using octal and hexadecimal escape sequences (\123 and \0xAB) for bytes at or above 128. Users of cunescape_one could infer whether such use occured when they received an answer between 128 and 256 in *ret (a non-ascii one byte character). But this is subtle and misleading: the comments were wrong, because ascii is a subset of unicode, so c != 0 did not mean non-unicode, but rather ascii-subset-of-unicode-or-raw-byte. This was all rather confusing, so make the "single byte" condition explicit. I'm not convinced that allowing non-utf8 sequences to be produced is useful in all cases where we allow it (e.g. in config files), but that behaviour is unchanged, just made more explicit. This also fixes an (invalid) gcc warning about unitialized variable (*ret_unicode) in callers of cunescape_one.
2016-01-12 21:36:57 +01:00
r = cunescape_one(*p, (size_t) -1, &u, &eight_bit);
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
if (r < 0) {
if (flags & EXTRACT_CUNESCAPE_RELAX) {
s[sz++] = '\\';
s[sz++] = c;
extract-word: replace an use of `goto` with structured code Using `goto` might be appropriate for the "finish" cases but it was really not necessary at this point of the code... Just use if/else blocks to accomplish the same. Confirmed that the test cases in test-extract-word keep working as expected.
2015-11-06 06:17:11 +01:00
} else
return -EINVAL;
} else {
(*p) += r - 1;
basic/escape: merge utf8 and non-utf8 paths in cunescape_one Not every byte sequence is valid utf8. We allow escaping of non-utf8 sequences in strings by using octal and hexadecimal escape sequences (\123 and \0xAB) for bytes at or above 128. Users of cunescape_one could infer whether such use occured when they received an answer between 128 and 256 in *ret (a non-ascii one byte character). But this is subtle and misleading: the comments were wrong, because ascii is a subset of unicode, so c != 0 did not mean non-unicode, but rather ascii-subset-of-unicode-or-raw-byte. This was all rather confusing, so make the "single byte" condition explicit. I'm not convinced that allowing non-utf8 sequences to be produced is useful in all cases where we allow it (e.g. in config files), but that behaviour is unchanged, just made more explicit. This also fixes an (invalid) gcc warning about unitialized variable (*ret_unicode) in callers of cunescape_one.
2016-01-12 21:36:57 +01:00
if (eight_bit)
s[sz++] = u;
extract-word: replace an use of `goto` with structured code Using `goto` might be appropriate for the "finish" cases but it was really not necessary at this point of the code... Just use if/else blocks to accomplish the same. Confirmed that the test cases in test-extract-word keep working as expected.
2015-11-06 06:17:11 +01:00
else
basic/escape: merge utf8 and non-utf8 paths in cunescape_one Not every byte sequence is valid utf8. We allow escaping of non-utf8 sequences in strings by using octal and hexadecimal escape sequences (\123 and \0xAB) for bytes at or above 128. Users of cunescape_one could infer whether such use occured when they received an answer between 128 and 256 in *ret (a non-ascii one byte character). But this is subtle and misleading: the comments were wrong, because ascii is a subset of unicode, so c != 0 did not mean non-unicode, but rather ascii-subset-of-unicode-or-raw-byte. This was all rather confusing, so make the "single byte" condition explicit. I'm not convinced that allowing non-utf8 sequences to be produced is useful in all cases where we allow it (e.g. in config files), but that behaviour is unchanged, just made more explicit. This also fixes an (invalid) gcc warning about unitialized variable (*ret_unicode) in callers of cunescape_one.
2016-01-12 21:36:57 +01:00
sz += utf8_encode_unichar(s + sz, u);
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
}
} else
s[sz++] = c;
backslash = false;
} else if (quote) { /* inside either single or double quotes */
tree-wide: make ++/-- usage consistent WRT spacing Throughout the tree there's spurious use of spaces separating ++ and -- operators from their respective operands. Make ++ and -- operator consistent with the majority of existing uses; discard the spaces.
2016-02-23 05:32:04 +01:00
for (;; (*p)++, c = **p) {
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
if (c == 0) {
if (flags & EXTRACT_RELAX)
goto finish_force_terminate;
return -EINVAL;
} else if (c == quote) { /* found the end quote */
quote = 0;
break;
core: fix dependency parsing 3d793d29059a7ddf5282efa6b32b953c183d7a4d broke parsing of unit file names that include backslashes, as extract_first_word() strips those. Fix this, by introducing a new EXTRACT_RETAIN_ESCAPE flag which disables looking at any flags, thus being compatible with the classic FOREACH_WORD() behaviour.
2015-11-11 22:53:05 +01:00
} else if (c == '\\' && !(flags & EXTRACT_RETAIN_ESCAPE)) {
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
backslash = true;
break;
} else {
if (!GREEDY_REALLOC(s, allocated, sz+2))
return -ENOMEM;
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
s[sz++] = c;
}
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
}
} else {
tree-wide: make ++/-- usage consistent WRT spacing Throughout the tree there's spurious use of spaces separating ++ and -- operators from their respective operands. Make ++ and -- operator consistent with the majority of existing uses; discard the spaces.
2016-02-23 05:32:04 +01:00
for (;; (*p)++, c = **p) {
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
if (c == 0)
goto finish_force_terminate;
tree-wide: use IN_SET macro (#6977)
2017-10-04 16:01:32 +02:00
else if (IN_SET(c, '\'', '"') && (flags & EXTRACT_QUOTES)) {
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
quote = c;
break;
core: fix dependency parsing 3d793d29059a7ddf5282efa6b32b953c183d7a4d broke parsing of unit file names that include backslashes, as extract_first_word() strips those. Fix this, by introducing a new EXTRACT_RETAIN_ESCAPE flag which disables looking at any flags, thus being compatible with the classic FOREACH_WORD() behaviour.
2015-11-11 22:53:05 +01:00
} else if (c == '\\' && !(flags & EXTRACT_RETAIN_ESCAPE)) {
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
backslash = true;
break;
} else if (strchr(separators, c)) {
if (flags & EXTRACT_DONT_COALESCE_SEPARATORS) {
tree-wide: make ++/-- usage consistent WRT spacing Throughout the tree there's spurious use of spaces separating ++ and -- operators from their respective operands. Make ++ and -- operator consistent with the majority of existing uses; discard the spaces.
2016-02-23 05:32:04 +01:00
(*p)++;
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
goto finish_force_next;
}
extract-word: Skip coalesced separators in place Just skip them in place, instead of setting separator=true. We only do that in a single place (while finding a separator outside of quote or backslash states) so we don't really need a separate state for it. Tested that no regressions were introduced in test-extract-word. Ran a full `make check` and also installed the binaries on a test system and did not see any issues related to parsing unit files or starting units after a reboot.
2015-11-06 06:57:26 +01:00
/* Skip additional coalesced separators. */
tree-wide: make ++/-- usage consistent WRT spacing Throughout the tree there's spurious use of spaces separating ++ and -- operators from their respective operands. Make ++ and -- operator consistent with the majority of existing uses; discard the spaces.
2016-02-23 05:32:04 +01:00
for (;; (*p)++, c = **p) {
extract-word: Skip coalesced separators in place Just skip them in place, instead of setting separator=true. We only do that in a single place (while finding a separator outside of quote or backslash states) so we don't really need a separate state for it. Tested that no regressions were introduced in test-extract-word. Ran a full `make check` and also installed the binaries on a test system and did not see any issues related to parsing unit files or starting units after a reboot.
2015-11-06 06:57:26 +01:00
if (c == 0)
goto finish_force_terminate;
if (!strchr(separators, c))
break;
}
goto finish;
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
} else {
if (!GREEDY_REALLOC(s, allocated, sz+2))
return -ENOMEM;
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
extract-word: Do not re-evaluate the state on each parsed character Use inner loops to keep processing the same state, except when there is a state change, then break back to the outer loop so that the correct branch can be selected again. Tested that no regressions were introduced in test-extract-word.
2015-11-06 06:51:24 +01:00
s[sz++] = c;
}
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
}
}
}
finish_force_terminate:
*p = NULL;
finish:
if (!s) {
*p = NULL;
*ret = NULL;
return 0;
}
finish_force_next:
s[sz] = 0;
macro: introduce TAKE_PTR() macro This macro will read a pointer of any type, return it, and set the pointer to NULL. This is useful as an explicit concept of passing ownership of a memory area between pointers. This takes inspiration from Rust: https://doc.rust-lang.org/std/option/enum.Option.html#method.take and was suggested by Alan Jenkins (@sourcejedi). It drops ~160 lines of code from our codebase, which makes me like it. Also, I think it clarifies passing of ownership, and thus helps readability a bit (at least for the initiated who know the new macro)
2018-03-22 16:53:26 +01:00
*ret = TAKE_PTR(s);
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
return 1;
}
int extract_first_word_and_warn(
const char **p,
char **ret,
const char *separators,
ExtractFlags flags,
const char *unit,
const char *filename,
unsigned line,
const char *rvalue) {
util-lib: rework extract_first_word_and_warn() a bit - Really warn in all error cases, not just some. We need to make sure that all errors are logged to not confuse the user. - Explicitly check for EINVAL error code before claiming anything about invalid escapes, could be ENOMEM after all.
2015-10-23 18:20:54 +02:00
/* Try to unquote it, if it fails, warn about it and try again
* but this time using EXTRACT_CUNESCAPE_RELAX to keep the
* backslashes verbatim in invalid escape sequences. */
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
const char *save;
int r;
save = *p;
r = extract_first_word(p, ret, separators, flags);
util-lib: rework extract_first_word_and_warn() a bit - Really warn in all error cases, not just some. We need to make sure that all errors are logged to not confuse the user. - Explicitly check for EINVAL error code before claiming anything about invalid escapes, could be ENOMEM after all.
2015-10-23 18:20:54 +02:00
if (r >= 0)
return r;
if (r == -EINVAL && !(flags & EXTRACT_CUNESCAPE_RELAX)) {
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
/* Retry it with EXTRACT_CUNESCAPE_RELAX. */
*p = save;
r = extract_first_word(p, ret, separators, flags|EXTRACT_CUNESCAPE_RELAX);
util-lib: rework extract_first_word_and_warn() a bit - Really warn in all error cases, not just some. We need to make sure that all errors are logged to not confuse the user. - Explicitly check for EINVAL error code before claiming anything about invalid escapes, could be ENOMEM after all.
2015-10-23 18:20:54 +02:00
if (r >= 0) {
basic/extract-word,man: clarify "correction" of invalid escapes Our warning message was misleading, because we wouldn't "correct" anything, we'd just ignore unkown escapes. Update the message. Also, print just the extracted word (which contains the offending sequences) in the message, instead of the whole line. Fixes #4697.
2016-12-11 05:20:42 +01:00
/* It worked this time, hence it must have been an invalid escape sequence. */
log_syntax(unit, LOG_WARNING, filename, line, EINVAL, "Ignoring unknown escape sequences: \"%s\"", *ret);
util-lib: rework extract_first_word_and_warn() a bit - Really warn in all error cases, not just some. We need to make sure that all errors are logged to not confuse the user. - Explicitly check for EINVAL error code before claiming anything about invalid escapes, could be ENOMEM after all.
2015-10-23 18:20:54 +02:00
return r;
}
/* If it's still EINVAL; then it must be unbalanced quoting, report this. */
if (r == -EINVAL)
return log_syntax(unit, LOG_ERR, filename, line, r, "Unbalanced quoting, ignoring: \"%s\"", rvalue);
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
}
util-lib: rework extract_first_word_and_warn() a bit - Really warn in all error cases, not just some. We need to make sure that all errors are logged to not confuse the user. - Explicitly check for EINVAL error code before claiming anything about invalid escapes, could be ENOMEM after all.
2015-10-23 18:20:54 +02:00
/* Can be any error, report it */
return log_syntax(unit, LOG_ERR, filename, line, r, "Unable to decode word \"%s\", ignoring: %m", rvalue);
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
}
shared/extract-word: replace enum with unsigned int to avoid undefined behaviour ../src/basic/extract-word.c:255:22: warning: passing an object that undergoes default argument promotion to 'va_start' has undefined behavior [-Wvarargs] va_start(ap, flags); ^ ../src/basic/extract-word.c:244:77: note: parameter of type 'ExtractFlags' (aka 'enum ExtractFlags') is declared here int extract_many_words(const char **p, const char *separators, ExtractFlags flags, ...) { ^ ../src/basic/extract-word.c:286:22: warning: passing an object that undergoes default argument promotion to 'va_start' has undefined behavior [-Wvarargs] va_start(ap, flags); ^ ../src/basic/extract-word.c:244:77: note: parameter of type 'ExtractFlags' (aka 'enum ExtractFlags') is declared here int extract_many_words(const char **p, const char *separators, ExtractFlags flags, ...) { ^ 2 warnings generated. I think the relevant part of C99 is 6.7.2.2 Enumeration specifiers: Each enumerated type shall be compatible with char, a signed integer type, or an unsigned integer type. The choice of type is implementation-defined, but shall be capable of representing the values of all the members of the enumeration. and 7.16.1.4: The parameter parmN is the identifier of the rightmost parameter in the variable parameter list in the function definition (the one just before the ...). If the parameter parmN is declared with the register storage class, with a function or array type, or with a type that is not compatible with the type that results after application of the default argument promotions, the behavior is undefined. This might cause a real issue if the compiler chooses something that is not an integer for ExtractFlags. Rework the code to avoid the warning, but add an assert_cc in a large-valued ExtractFlags element is ever defined and the type is bumped to something wider than an int.
2017-04-23 01:04:02 +02:00
/* We pass ExtractFlags as unsigned int (to avoid undefined behaviour when passing
* an object that undergoes default argument promotion as an argument to va_start).
* Let's make sure that ExtractFlags fits into an unsigned int. */
assert_cc(sizeof(enum ExtractFlags) <= sizeof(unsigned));
int extract_many_words(const char **p, const char *separators, unsigned flags, ...) {
util: split out extract_first_word() and related calls into extract-word.[ch] This is quite a lot of code these days, hence move it to its own source file.
2015-10-22 20:12:31 +02:00
va_list ap;
char **l;
int n = 0, i, c, r;
/* Parses a number of words from a string, stripping any
* quotes if necessary. */
assert(p);
/* Count how many words are expected */
va_start(ap, flags);
for (;;) {
if (!va_arg(ap, char **))
break;
n++;
}
va_end(ap);
if (n <= 0)
return 0;
/* Read all words into a temporary array */
l = newa0(char*, n);
for (c = 0; c < n; c++) {
r = extract_first_word(p, &l[c], separators, flags);
if (r < 0) {
int j;
for (j = 0; j < c; j++)
free(l[j]);
return r;
}
if (r == 0)
break;
}
/* If we managed to parse all words, return them in the passed
* in parameters */
va_start(ap, flags);
for (i = 0; i < n; i++) {
char **v;
v = va_arg(ap, char **);
assert(v);
*v = l[i];
}
va_end(ap);
return c;
}